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)
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