def testIt(self):
app = QGuiApplication([])
qmlRegisterType(MyClass,'Example',1,0,'MyClass')
view = QQuickView()
view.setSource(QUrl.fromLocalFile(adjust_filename('bug_926.qml', __file__)))
self.assertEqual(len(view.errors()), 0)
view.show()
QTimer.singleShot(0, app.quit)
app.exec_()
def testIt(self):
app = QGuiApplication([])
qmlRegisterType(PieChart, 'Charts', 1, 0, 'PieChart');
qmlRegisterType(PieSlice, "Charts", 1, 0, "PieSlice");
view = QQuickView()
view.setSource(QUrl.fromLocalFile(helper.adjust_filename('registertype.qml', __file__)))
view.show()
QTimer.singleShot(250, view.close)
app.exec_()
self.assertTrue(appendCalled)
self.assertTrue(paintCalled)
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle('Qt DataVisualization 3D Bars')
self.bars = QtDataVisualization.Q3DBars()
self.columnAxis = QtDataVisualization.QCategory3DAxis()
self.columnAxis.setTitle('Columns')
self.columnAxis.setTitleVisible(True)
self.columnAxis.setLabels(['Column1', 'Column2'])
self.columnAxis.setLabelAutoRotation(30)
self.rowAxis = QtDataVisualization.QCategory3DAxis()
self.rowAxis.setTitle('Rows')
self.rowAxis.setTitleVisible(True)
self.rowAxis.setLabels(['Row1', 'Row2'])
self.rowAxis.setLabelAutoRotation(30)
self.valueAxis = QtDataVisualization.QValue3DAxis()
self.valueAxis.setTitle('Values')
self.valueAxis.setTitleVisible(True)
self.valueAxis.setRange(0, 5)
self.bars.setRowAxis(self.rowAxis)
self.bars.setColumnAxis(self.columnAxis)
self.bars.setValueAxis(self.valueAxis)
self.series = QtDataVisualization.QBar3DSeries()
self.arrayData = [[1, 2], [3, 4]]
self.series.dataProxy().addRows(dataToBarDataArray(self.arrayData))
self.bars.setPrimarySeries(self.series)
self.container = QWidget.createWindowContainer(self.bars)
if not self.bars.hasContext():
print("Couldn't initialize the OpenGL context.")
sys.exit(-1)
camera = self.bars.scene().activeCamera()
camera.setYRotation(22.5)
geometry = QGuiApplication.primaryScreen().geometry()
size = geometry.height() * 3 / 4
self.container.setMinimumSize(size, size)
self.container.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.container.setFocusPolicy(Qt.StrongFocus)
self.setCentralWidget(self.container)
def _restore_preview_ui(self):
"""Restore UI state from previous session."""
if not self._preview_window_state:
self._settings.beginGroup(self._SETTINGS_GROUP_NAME)
window_size = self._settings.value("windowSize")
window_pos = self._settings.value("windowPosition")
n_screens = self._settings.value("n_screens", defaultValue=1)
window_maximized = self._settings.value("windowMaximized",
defaultValue='false')
splitter_state = {}
for splitter in self._import_preview.findChildren(QSplitter):
splitter_state[splitter] = self._settings.value(
splitter.objectName() + "_splitterState")
self._settings.endGroup()
original_size = self.size()
if window_size:
self.resize(window_size)
else:
self.setGeometry(
QStyle.alignedRect(
Qt.LeftToRight, Qt.AlignCenter, QSize(1000, 700),
QApplication.desktop().availableGeometry(self)))
if window_pos:
self.move(window_pos)
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(
0, 0) # Move this widget to primary screen position (0,0)
ensure_window_is_on_screen(self, original_size)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
for splitter, state in splitter_state.items():
if state:
splitter.restoreState(state)
else:
self.resize(self._preview_window_state["size"])
self.move(self._preview_window_state["position"])
self.setWindowState(self._preview_window_state["maximized"])
for splitter in self._import_preview.findChildren(QSplitter):
name = splitter.objectName()
splitter.restoreState(
self._preview_window_state["splitters"][name])
def __init__(self, db_mngr):
"""Initializes form.
Args:
db_mngr (SpineDBManager): The manager to use
"""
super().__init__(flags=Qt.Window)
from ..ui.spine_db_editor_window import Ui_MainWindow # pylint: disable=import-outside-toplevel
self.db_mngr = db_mngr
self.db_maps = []
self.db_urls = []
self._change_notifiers = []
self._changelog = []
self.db_url = None
self._fetcher = None
# Setup UI from Qt Designer file
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.takeCentralWidget()
self.url_toolbar = UrlToolBar(self)
self.addToolBar(Qt.TopToolBarArea, self.url_toolbar)
self.setStyleSheet(MAINWINDOW_SS)
self.setAttribute(Qt.WA_DeleteOnClose)
self.qsettings = self.db_mngr.qsettings
self.err_msg = QErrorMessage(self)
self.err_msg.setWindowTitle("Error")
self.err_msg.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
self.notification_stack = NotificationStack(self)
self.silenced = False
fm = QFontMetrics(QFont("", 0))
self.default_row_height = 1.2 * fm.lineSpacing()
max_screen_height = max(
[s.availableSize().height() for s in QGuiApplication.screens()])
self.visible_rows = int(max_screen_height / self.default_row_height)
self.settings_group = "spineDBEditor"
self.undo_action = None
self.redo_action = None
self.ui.actionUndo.setShortcuts(QKeySequence.Undo)
self.ui.actionRedo.setShortcuts(QKeySequence.Redo)
self.update_commit_enabled()
self.setContextMenuPolicy(Qt.NoContextMenu)
def shoot_screen(self, windo=0):
screen = QGuiApplication.primaryScreen()
window = QWindow()
window = self.windowHandle()
if window:
screen = window.screen()
if not screen:
return
if type(windo) in (list, tuple):
self.original_pixmap = screen.grabWindow(
QApplication.desktop().winId(), *windo)
else:
self.original_pixmap = screen.grabWindow(
QApplication.desktop().winId(), windo)
self.update_screenshot_label()
# self.new_screenshot_button.setDisabled(False)
# if self.hide_this_window_check_box.isChecked():
self.show()
def closeEvent(self, event=None):
"""Handle close window.
Args:
event (QEvent): Closing event if 'X' is clicked.
"""
qsettings = self._qsettings
qsettings.beginGroup(self.settings_group)
for splitter in self.findChildren(QSplitter):
qsettings.setValue(splitter.objectName() + "_splitterState",
splitter.saveState())
qsettings.setValue("windowSize", self.size())
qsettings.setValue("windowPosition", self.pos())
qsettings.setValue("windowState", self.saveState(version=1))
qsettings.setValue("windowMaximized",
self.windowState() == Qt.WindowMaximized)
qsettings.setValue("n_screens", len(QGuiApplication.screens()))
qsettings.endGroup()
if event:
event.accept()
def get_screen_image(bounding_box=None):
""" Get screen image.
:param bounding_box: [tuple] The image rectangle in screen, formatted in (left, upper, width, height).
:returns: [QPixmap or None] Screen image.
"""
screen = QGuiApplication.primaryScreen()
if not screen:
logging.error("Failed to get 'QScreen' object.")
return None
if bounding_box:
return screen.grabWindow(0,
x=bounding_box[0],
y=bounding_box[1],
width=bounding_box[2],
height=bounding_box[3])
else:
return screen.grabWindow(0)
def __init__(self, popup_type, text, focus):
super(PopupWindow, self).__init__()
msgbox = self
# Set window center of screen
msgbox.setGeometry(
QStyle.alignedRect(
Qt.LeftToRight,
Qt.AlignCenter,
self.size(),
QGuiApplication.primaryScreen().availableGeometry(),
), )
msgbox.setWindowIcon(QIcon("static/images/main_icon.png"))
title = "Network Assistant"
if popup_type == "warning":
msgbox.warning(self, title, text)
focus.setFocus()
def __init__(self, entity_item):
"""Initializes item.
Args:
entity_item (spinetoolbox.widgets.graph_view_graphics_items.EntityItem): The parent item.
"""
super().__init__(entity_item)
self.entity_item = entity_item
self._font = QApplication.font()
self._font.setPointSize(11)
self.setFont(self._font)
self.bg = QGraphicsRectItem(self)
self.bg_color = QGuiApplication.palette().color(
QPalette.Normal, QPalette.ToolTipBase)
self.bg_color.setAlphaF(0.8)
self.bg.setBrush(QBrush(self.bg_color))
self.bg.setPen(Qt.NoPen)
self.bg.setFlag(QGraphicsItem.ItemStacksBehindParent)
self.setFlag(QGraphicsItem.ItemIsSelectable, enabled=False)
self.setAcceptHoverEvents(False)
def init_font_config(self):
self.ui_default_font = QGuiApplication.font()
self.disasm_font = QFont("DejaVu Sans Mono", 10)
self.disasm_font_metrics = QFontMetricsF(self.disasm_font)
self.disasm_font_height = self.disasm_font_metrics.height()
self.disasm_font_width = self.disasm_font_metrics.width('A')
self.disasm_font_ascent = self.disasm_font_metrics.ascent()
self.symexec_font = QFont("DejaVu Sans Mono", 10)
self.symexec_font_metrics = QFontMetricsF(self.symexec_font)
self.symexec_font_height = self.symexec_font_metrics.height()
self.symexec_font_width = self.symexec_font_metrics.width('A')
self.symexec_font_ascent = self.symexec_font_metrics.ascent()
self.code_font = QFont("Source Code Pro", 10)
self.code_font_metrics = QFontMetricsF(self.code_font)
self.code_font_height = self.code_font_metrics.height()
self.code_font_width = self.code_font_metrics.width('A')
self.code_font_ascent = self.code_font_metrics.ascent()
def init_ui(self):
self.setWindowTitle('Preferences')
self.setGeometry(100, 100, 400, 200)
grid = QVBoxLayout()
grid.setSpacing(15)
self.darkmode = QCheckBox('Dark Mode', self)
self.app.setStyle("Fusion")
if QGuiApplication.palette() != self.default:
self.darkmode.setChecked(True)
palette = QPalette()
palette.setColor(QPalette.Window, QColor(25, 25, 25)) # 53 53 53
palette.setColor(QPalette.WindowText, Qt.white)
palette.setColor(QPalette.Base, QColor(53, 53, 53)) # 25 25 25
palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))
palette.setColor(QPalette.ToolTipBase, Qt.white)
palette.setColor(QPalette.ToolTipText, Qt.white)
palette.setColor(QPalette.Text, Qt.white)
palette.setColor(QPalette.Button, QColor(53, 53, 53))
palette.setColor(QPalette.ButtonText, Qt.white)
palette.setColor(QPalette.BrightText, Qt.red)
palette.setColor(QPalette.Link, QColor(42, 130, 218))
palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
palette.setColor(QPalette.HighlightedText, Qt.black)
self.darkmode.toggled.connect(lambda: self.app.setPalette(palette)
if self.darkmode.isChecked() else self.
app.setPalette(self.default))
grid.addWidget(self.darkmode, 1)
center = QWidget()
center.setLayout(grid)
self.setCentralWidget(center)
self.show()
def data(self, index, role=Qt.DisplayRole):
"""Gets the id and database for the row, and reads data from the db manager
using the item_type property.
Paint the object_class icon next to the name.
Also paint background of fixed indexes gray and apply custom format to JSON fields."""
field = self.header[index.column()]
# Background role
if role == Qt.BackgroundRole and field in self.fixed_fields:
return QGuiApplication.palette().button()
# Display, edit, tool tip, alignment role of 'json fields'
if field in self.json_fields and role in (
Qt.DisplayRole,
Qt.EditRole,
Qt.ToolTipRole,
Qt.TextAlignmentRole,
PARSED_ROLE,
):
id_ = self._main_data[index.row()]
return self.db_mngr.get_value(self.db_map, self.item_type, id_,
role)
if role in (Qt.DisplayRole, Qt.EditRole, Qt.ToolTipRole):
if field == "database":
return self.db_map.codename
id_ = self._main_data[index.row()]
item = self.db_mngr.get_item(self.db_map, self.item_type, id_)
if role == Qt.ToolTipRole:
description = self.get_field_item(field, item).get(
"description", None)
if description not in (None, ""):
return description
data = item.get(field)
if role == Qt.DisplayRole and data and field in self.group_fields:
data = data.replace(",", self.db_mngr._GROUP_SEP)
return data
# Decoration role
if role == Qt.DecorationRole and field == self.entity_class_name_field:
return self.db_mngr.entity_class_icon(self.db_map,
self.entity_class_type,
self.entity_class_id)
return super().data(index, role)
def screenshot(self):
self.hasResult = False
# 对鼠标移动事件进行监听
self.setMouseTracking(True)
# 标识开始截图
self.startFlag = True
self.endFlag = False
# 休眠0.3秒
time.sleep(0.3)
# 调整窗口大小 用于展示当前页面图
self.setGeometry(0, 0, self.screen.width(), self.screen.height())
# 截全屏
self.desktop_pix = QPixmap(
QGuiApplication.primaryScreen().grabWindow(0))
self.blurry_pix = pix_add_blurry(self.desktop_pix, 0.3)
# 设置画笔
self.palette.setBrush(self.backgroundRole(), QBrush(self.blurry_pix))
self.setPalette(self.palette)
# 显示
self.show()
def _onCopy( self, action:QAction, point:QPoint ):
values:str = ""
indexes = self._tv.selectedIndexes()
row = -1
for idx in indexes:
if row == -1: row = idx.row()
if row != idx.row():
values += "\n"
row = idx.row()
elif len( values ) > 0:
values += "\t"
val = self._tv.model().data( idx, Qt.DisplayRole )
val = "" if not val else val
if isinstance( val, Number ):
values += str( val )
else:
values += val
#print( idx.row(), "/", idx.column(), ": ", val )
#print( "valuestring: ", values )
clipboard = QGuiApplication.clipboard()
clipboard.setText( values )
def restore_ui(self):
"""Restore UI state from previous session."""
window_size = self.qsettings.value("dataPackageWidget/windowSize")
window_pos = self.qsettings.value("dataPackageWidget/windowPosition")
window_maximized = self.qsettings.value("dataPackageWidget/windowMaximized", defaultValue='false')
window_state = self.qsettings.value("dataPackageWidget/windowState")
n_screens = self.qsettings.value("mainWindow/n_screens", defaultValue=1)
original_size = self.size()
if window_size:
self.resize(window_size)
if window_pos:
self.move(window_pos)
# noinspection PyArgumentList
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(0, 0) # Move this widget to primary screen position (0,0)
ensure_window_is_on_screen(self, original_size)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
if window_state:
self.restoreState(window_state, version=1) # Toolbar and dockWidget positions
def __init__(self):
super().__init__(flags=Qt.Widget
| Qt.FramelessWindowHint
| Qt.BypassWindowManagerHint
| Qt.WindowTransparentForInput
| Qt.WindowStaysOnTopHint)
self.logger = logging.getLogger(__name__ + "." +
self.__class__.__name__)
self.setAttribute(Qt.WA_NoSystemBackground, True)
self.setAttribute(Qt.WA_TranslucentBackground, True)
self.setAttribute(Qt.WA_DeleteOnClose, True)
self.setStyleSheet("background: transparent")
self._instances = {}
virtual_screen = QRect(0, 0, 0, 0)
for screen in QGuiApplication.screens():
# TODO: Handle screen change
geom = screen.virtualGeometry()
virtual_screen = virtual_screen.united(geom)
self.scene = QGraphicsScene(0,
0,
virtual_screen.width(),
virtual_screen.height(),
parent=self)
self.view = QGraphicsView(self.scene, self)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setStyleSheet("background: transparent")
self.view.setGeometry(0, 0, virtual_screen.width(),
virtual_screen.height())
self.view.setInteractive(False)
self.transparent_pen = QPen()
self.transparent_pen.setBrush(Qt.NoBrush)
self.setGeometry(virtual_screen)
def copy_button_clicked(self,button):
clipboard = QGuiApplication.clipboard()
self.button=button
if self.button==self.copy_button_1:
clipboard.setText(self.label_1.text())
elif self.button==self.copy_button_2:
clipboard.setText(self.label_2.text())
elif self.button==self.copy_button_3:
clipboard.setText(self.label_3.text())
elif self.button==self.copy_button_4:
clipboard.setText(self.label_4.text())
elif self.button==self.copy_button_5:
clipboard.setText(self.label_5.text())
def __init__(self, app):
self.app = app
# self.qmp = QMP('localhost', 55555)
self.qmp = QMP()
self.qmp.stateChanged.connect(self.handle_pause_button)
self.qmp.connectionChange.connect(self.handle_connect_button)
self.paused = False
super().__init__()
self.init_ui()
self.qmp.timeUpdate.connect(self.update_time)
self.t = TimeThread(self.qmp)
self.time_mult = TimeMultiplier(self.qmp, self.kill_thread)
self.window = []
self.default_theme = QGuiApplication.palette()
def restore_ui(self):
"""Restore UI state from previous session."""
window_size = self.qsettings.value("{0}/windowSize".format(
self.settings_key))
window_pos = self.qsettings.value("{0}/windowPosition".format(
self.settings_key))
window_maximized = self.qsettings.value("{0}/windowMaximized".format(
self.settings_key),
defaultValue='false')
n_screens = self.qsettings.value("{0}/n_screens".format(
self.settings_key),
defaultValue=1)
if window_size:
self.resize(window_size)
if window_pos:
self.move(window_pos)
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
# noinspection PyArgumentList
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(0,
0) # Move this widget to primary screen position (0,0)
#restore splitters
splitters = [self.ui.splitter_3, self.ui.splitter_2, self.ui.splitter]
splitter_keys = [
"/splitterSelectTable", "/splitterTableFilter",
"/splitterPivotFrozen"
]
splitter_states = [
self.qsettings.value(s)
for s in (self.settings_key + p for p in splitter_keys)
]
for state, splitter in zip(splitter_states, splitters):
if state:
splitter.restoreState(state)
def __init__(self, nf_settings_path):
super(batch_file_viewer,self).__init__(parent = None)
self.nf_settings_parser = custom_config_parser()
self.nf_settings_parser.load(nf_settings_path)
self.setRowCount(20)
self.setColumnCount(2)
# Fill all places so there are no "None" types in the table
for row in range(self.rowCount()):
for column in range(self.columnCount()):
item = QTableWidgetItem()
item.setText('')
self.setItem(row, column, item)
self.original_background = item.background()
self.clipboard = QGuiApplication.clipboard()
self.cellChanged.connect(self.check_cell) # Needs to be after "filling for loop" above
self.header = self.horizontalHeader()
self.header.setSectionResizeMode(0, QHeaderView.Stretch)
self.setHorizontalHeaderLabels(["MS files", "Label"])
self.header.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.header.customContextMenuRequested.connect( self.right_click_menu )
self.saved_text = ''
self.store_re_text = ''
def restore_ui(self):
"""Restore UI state from previous session."""
self.qsettings.beginGroup(self.settings_group)
window_size = self.qsettings.value("windowSize")
window_pos = self.qsettings.value("windowPosition")
window_state = self.qsettings.value("windowState")
window_maximized = self.qsettings.value("windowMaximized",
defaultValue='false')
n_screens = self.qsettings.value("n_screens", defaultValue=1)
self.qsettings.endGroup()
if window_size:
self.resize(window_size)
if window_pos:
self.move(window_pos)
if window_state:
self.restoreState(window_state,
version=1) # Toolbar and dockWidget positions
if window_maximized == 'true':
self.setWindowState(Qt.WindowMaximized)
# noinspection PyArgumentList
if len(QGuiApplication.screens()) < int(n_screens):
# There are less screens available now than on previous application startup
self.move(0,
0) # Move this widget to primary screen position (0,0)
def paste(self):
data = {}
try:
data = json.loads(QGuiApplication.clipboard().text())
except Exception as e:
return
self.clear_selection()
# calculate offset
positions = []
for d in data['drawings']:
positions.append({'x': d['pos x'],
'y': d['pos y']})
for n in data['nodes']:
positions.append({'x': n['position x'],
'y': n['position y']})
offset_for_middle_pos = QPointF(0, 0)
if len(positions) > 0:
rect = QRectF(positions[0]['x'], positions[0]['y'], 0, 0)
for p in positions:
x = p['x']
y = p['y']
if x < rect.left():
rect.setLeft(x)
if x > rect.right():
rect.setRight(x)
if y < rect.top():
rect.setTop(y)
if y > rect.bottom():
rect.setBottom(y)
offset_for_middle_pos = self.last_mouse_move_pos - rect.center()
self.undo_stack.push(Paste_Command(self, data, offset_for_middle_pos))
def paste_button_clicked(self, button):
clipboard = QGuiApplication.clipboard()
self.button = button
if self.button == self.paste_button_1:
self.label_1.setText(clipboard.text())
elif self.button == self.paste_button_2:
self.label_2.setText(clipboard.text())
elif self.button == self.paste_button_3:
self.label_3.setText(clipboard.text())
elif self.button == self.paste_button_4:
self.label_4.setText(clipboard.text())
elif self.button == self.paste_button_5:
self.label_5.setText(clipboard.text())
# This Python file uses the following encoding: utf-8
import sys
import os
from PySide2.QtGui import QGuiApplication, QIcon
from PySide2.QtQml import QQmlApplicationEngine
from mainWindow import MainWindow
if __name__ == "__main__":
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
# Get Context
main = MainWindow()
engine.rootContext().setContextProperty("backend", main)
# Set App Extra Info
app.setOrganizationName("Wanderson M. Pimenta")
app.setOrganizationDomain("N/A")
# Set Icon
app.setWindowIcon(QIcon("app.ico"))
# Load Initial Window
engine.load(os.path.join(os.path.dirname(__file__),
"qml/splashScreen.qml"))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
self.gltfImporter.setSceneEntity(self.rootEntity)
self.gltfImporter.setSource(assetsUrl() + "/models/Box.glb")
# Since Kuesa is based on a PBR pipeline, we need an environment map.
self.rootEntity.addComponent(DefaultEnvMap(self.rootEntity))
# Camera.
self.camera().setPosition(QVector3D(10, 1.5, 10))
self.camera().setViewCenter(QVector3D(0, .5, 0))
self.camera().setUpVector(QVector3D(0, 1, 0))
self.camera().setAspectRatio(16. / 9.)
# Camera controls.
self.camController = Qt3DExtras.QOrbitCameraController(self.rootEntity)
self.camController.setCamera(self.camera())
# Frame graph.
self.fg = Kuesa.ForwardRenderer()
self.fg.setCamera(self.camera())
self.fg.setClearColor("white")
self.setActiveFrameGraph(self.fg)
self.setRootEntity(self.rootEntity)
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
view = Window()
view.show()
sys.exit(app.exec_())
def get_scaling(self) -> float:
screen = QGuiApplication.screenAt(self.get_position().topLeft())
return screen.devicePixelRatio()
def copy(self):
QGuiApplication.clipboard().setText(self.fileNameLabel.text())
##
## $QT_END_LICENSE$
##
#############################################################################
from __future__ import print_function
import os
import sys
from PySide2.QtCore import QTimer, QUrl
from PySide2.QtGui import QGuiApplication
import PySide2.QtQml
from PySide2.QtQuick import QQuickView
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
timer = QTimer()
timer.start(2000)
view = QQuickView()
qmlFile = os.path.join(os.path.dirname(__file__), 'view.qml')
view.setSource(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
if view.status() == QQuickView.Error:
sys.exit(-1)
root = view.rootObject()
timer.timeout.connect(root.updateRotater)
view.show()
res = app.exec_()
def cut_window(self, x0, y0, wide, high):
pqscreen = QGuiApplication.primaryScreen()
pixmap2 = pqscreen.grabWindow(self.winId(), x0, y0, wide, high)
pixmap2.save('pridict.png')
def __init__(self, argv=None):
super().__init__(argv)
self._app = QGuiApplication(argv or [])
def _paint_as_selected(self):
self._bg.setBrush(QGuiApplication.palette().highlight())
else:
self.labe1.setProperty('text', 'Digite algo no campo de texto :)')
@Slot(str)
def _on_button_clicked(self, text):
print('Botão clicado (Python)')
if text:
self.labe1.setProperty('text', text)
else:
self.labe1.setProperty('text', 'Digite algo no campo de texto :)')
if __name__ == "__main__":
import sys
app = QGuiApplication(sys.argv)
app.setWindowIcon(QIcon('../../icons/icon.png'))
engine = QQmlApplicationEngine()
engine.load('./ui/MainWindow.qml-qquickview')
if not engine.rootObjects():
sys.exit(-1)
window = engine.rootObjects()[0]
mainwindow = MainWindow(window=window)
# Expondo o Python para o QML.
# Caso os métodos sejam criados no QML (@SLOT()).
context = engine.rootContext()
context.setContextProperty('MainWindow', mainwindow)
def copy(self):
QGuiApplication.clipboard().setText(self.fileNameLabel.text())
import sys
import os
from PySide2.QtGui import QGuiApplication
from PySide2.QtQml import QQmlApplicationEngine
from view_model import ViewModel
if __name__ == '__main__':
myApp = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
context = engine.rootContext()
# import the path for the Qt Application Manager
engine.addImportPath("/home/bob/Qt/5.11.2/Automotive/sources/qtapplicationmanager/dummyimports/")
# create a view model
view_model = ViewModel()
# bind the view model to the context
context.setContextProperty('view_model', view_model)
# load the main QML window
engine.load('mainwindow.qml')
if not engine.rootObjects():
sys.exit(-1)
sys.exit(myApp.exec_())
def setName(self, value):
self._name = value
colorChanged = Signal()
color = Property(QColor, getColor, setColor, notify=colorChanged)
name = Property(text_type, getName, setName)
chartCleared = Signal()
@Slot() # This should be something like @Invokable
def clearChart(self):
self.setColor(Qt.transparent)
self.update()
self.chartCleared.emit()
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
qmlRegisterType(PieChart, 'Charts', 1, 0, 'PieChart');
view = QQuickView()
view.setResizeMode(QQuickView.SizeRootObjectToView)
qmlFile = os.path.join(os.path.dirname(__file__), 'app.qml')
view.setSource(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
if view.status() == QQuickView.Error:
sys.exit(-1)
view.show()
res = app.exec_()
# Deleting the view before it goes out of scope is required to make sure all child QML instances
# are destroyed in the correct order.
del view
sys.exit(res)
numberChanged = Signal(int)
def __set_number(self, val):
if self.__number != val:
self.__number = val;
self.numberChanged.emit(self.__number)
def get_number(self):
return self.__number
number = Property(int, get_number, notify=numberChanged)
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
number_generator = NumberGenerator()
engine.rootContext().setContextProperty("numberGenerator", number_generator)
engine.load(QUrl("main.qml"))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
# ...
d = self._data[index.row()]
if role == Qt.DisplayRole:
return d['name']
elif role == Qt.DecorationRole:
return Qt.black
elif role == PersonModel.MyRole:
return d['myrole']
return None
def populate(self):
self._data.append({'name':'Qt', 'myrole':'role1'})
self._data.append({'name':'PySide', 'myrole':'role2'})
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
view = QQuickView()
view.setResizeMode(QQuickView.SizeRootObjectToView)
myModel = PersonModel()
myModel.populate()
view.rootContext().setContextProperty("myModel", myModel)
qmlFile = os.path.join(os.path.dirname(__file__), 'view.qml')
view.setSource(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
if view.status() == QQuickView.Error:
sys.exit(-1)
view.show()
app.exec_()
# Deleting the view before it goes out of scope is required to make sure all child QML instances
