def main(): os.environ["QT_IM_MODULE"] = "qtvirtualkeyboard" app = QtWidgets.QApplication(sys.argv) # class instance chartManager1 = ChartManager1() chartManager2 = ChartManager2() chartManager3 = ChartManager3() alarmManager = AlarmManager() # patient = Patient() userInput = UserInput() modeSelect = ms.ModeSelect() # connect signal app.aboutToQuit.connect(chartManager1.stop) app.aboutToQuit.connect(chartManager2.stop) app.aboutToQuit.connect(chartManager3.stop) app.aboutToQuit.connect(modeSelect.stop) app.aboutToQuit.connect(alarmManager.stop) dp = 0 # start thread chartManager1.start() modeSelect.start() alarmManager.start() engine = QtQml.QQmlApplicationEngine() ctx = engine.rootContext() ctx.setContextProperty("ChartManager1", chartManager1) ctx.setContextProperty("ChartManager2", chartManager2) ctx.setContextProperty("ChartManager3", chartManager3) ctx.setContextProperty("ModeSelect", modeSelect) # ctx.setContextProperty("Patient", patient) ctx.setContextProperty("UserInput", userInput) ctx.setContextProperty("AlarmManager", alarmManager) ctx.setContextProperty("dp", dp) ctx.setContextProperty("fs", False) # if redis exists take the userinput if config.useredis: params = config.r.get("PARAMS") params = json.loads(params) ctx.setContextProperty("Params", params) if config.args.fullscreen: logging.debug("Runnin in full screen") ctx.setContextProperty("fs", True) # engine.load('main.qml') engine.load('./qml/MainQt.qml') if not engine.rootObjects(): sys.exit(-1) sys.exit(app.exec_())
def create(self) -> bool: # search the main QML file path = utils.get_resource('themes', self._theme_name, 'main.qml') if not path: ERR('Cannot find theme: "{}"'.format(self._theme_name)) return False LOG('Loading theme: "{}"'.format(path)) # create the QML engine self._qml_engine = QtQml.QQmlApplicationEngine() # inject MainMenu and Browser model ctxt = self._qml_engine.rootContext() self._mainmenu_qtmodel = MainMenuModel() ctxt.setContextProperty('MainMenuModel', self._mainmenu_qtmodel) self._browser_qtmodel = BrowserModel(self) ctxt.setContextProperty('BrowserModel', self._browser_qtmodel) # ctxt.setContextProperty('NavigatorModel', self._navigator_proxymodel) self._notify_model = NotifyModel() ctxt.setContextProperty('EmcNotifyModel', self._notify_model) # inject the Communicator class self._backend_instance = GuiCommunicator(self) ctxt.setContextProperty('EmcBackend', self._backend_instance) # inject the network cache manager self._nam_factory = QMLNetworkAccessManagerFactory() self._qml_engine.setNetworkAccessManagerFactory(self._nam_factory) # load and show the QML theme self._qml_engine.load(path) roots = self._qml_engine.rootObjects() if not roots: ERR('Cannot create the QML view') return False # keep a reference of the main QML object for fast access self._qml_root = roots[0] # keep a reference of the main QGuiApplication for faster access self._qapp = QtGui.QGuiApplication.instance() # all the keyboard input must be forwarded to EMC and ignored self._events_manager = EventManager(self) self._qapp.installEventFilter(self._events_manager) # startup with correct volume value self.volume_set(mediaplayer.volume_get()) # startup with correct fullscreen state self.fullscreen_set(self._boot_in_fullscreen) return True
def __init__(self, parent = None): QObject.__init__(self, parent) engine = QtQml.QQmlApplicationEngine() engine.rootContext().setContextProperty("ui_control", self) url = QtCore.QUrl.fromLocalFile('./qml/main.qml') engine.load(url) self._engine = engine fc = fixt.FixtureController() self._calib_workflow = cwc.CalibrationWorkflowController(fc, self) self._sensor_mappings = []
def main(): app = QtGui.QGuiApplication(sys.argv) QtQml.qmlRegisterType(CalendarProvider, "MyCalendar", 1, 0, "CalendarProvider") engine = QtQml.QQmlApplicationEngine() filename = os.path.join(CURRENT_DIR, "main.qml") engine.load(QtCore.QUrl.fromLocalFile(filename)) if not engine.rootObjects(): sys.exit(-1) sys.exit(app.exec_())
def main(): app = qtg.QGuiApplication(sys.argv) engine = qml.QQmlApplicationEngine() # Bind the backend object in qml backend = Backend() engine.rootContext().setContextProperty('backend', backend) engine.load(qtc.QUrl.fromLocalFile(os.path.join(CURRENT_DIR, 'main.qml'))) if not engine.rootObjects(): return -1 return app.exec_()
def main(): # sys.argv += ['--style', 'material'] app = qtg.QGuiApplication(sys.argv) engine = qml.QQmlApplicationEngine() backend = Backend() engine.rootContext().setContextProperty('backend', backend) engine.load(qtc.QUrl(os.path.join(CURRENT_DIR, 'main.qml'))) if not engine.rootObjects: sys.exit(-1) sys.exit(app.exec_())
def main(): import os import sys CURRENT_DIR = os.path.dirname(os.path.realpath(__file__)) app = QtGui.QGuiApplication(sys.argv) engine = QtQml.QQmlApplicationEngine() filename = os.path.join(CURRENT_DIR, "Clockwindow.qml") engine.load(QUrl.fromLocalFile(filename)) if not engine.rootObjects(): sys.exit(-1) sys.exit(app.exec_())
def run(argv=None): if argv is None: argv = sys.argv[1:] p = argparse.ArgumentParser() p.add_argument('-l', '--local-qml', dest='local_qml', action='store_true', help='Use local qml files (development mode)', ) p.add_argument('--palette', dest='palette', choices=['system', 'dark'], default='dark') args, remaining = p.parse_known_args(argv) if not resource_manager.ready: resource_manager.build_missing() assert resource_manager.ready is True QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) app = QApplication(remaining) QtGui.QIcon.setThemeName('fa-icons') loop = QEventLoop(app) asyncio.set_event_loop(loop) app.setOrganizationName('jvconnected') app.setApplicationName('jvconnected') engine = QtQml.QQmlApplicationEngine() if args.local_qml: logger.debug('Using local qml files') qml_import = str(QML_PATH) qml_main = str(QML_PATH / 'main.qml') else: check_qrc_hash() qml_import = 'qrc:/qml' qml_main = 'qrc:/qml/main.qml' register_qml_types() engine.addImportPath(qml_import) palette_manager = palette.PaletteManager( qmlEngine=engine, defaultPaletteName=args.palette, ) context = engine.rootContext() context.setContextProperty('paletteManager', palette_manager) engine.load(qml_main) win = engine.rootObjects()[0] win.show() with loop: sys.exit(loop.run_forever())
def run(argv=None): if argv is None: argv = sys.argv logger.info('starting application') app = QApplication(argv) app.setOrganizationName('rtlsdr-wwb-scanner') app.setApplicationName('wwb_scanner') app.aboutToQuit.connect(on_app_quit) QtCore.qInstallMessageHandler(qt_message_handler) engine = QtQml.QQmlApplicationEngine() engine.setBaseUrl(str(QML_PATH)) engine.addImportPath(str(QML_PATH)) register_qml_types() qml_main = QML_PATH / 'main.qml' engine.load(str(qml_main)) win = engine.rootObjects()[0] win.show() sys.exit(app.exec_())
def main(): import os import sys CURRENT_DIR = os.path.dirname(os.path.realpath(__file__)) app = QtGui.QGuiApplication(sys.argv) time = WeatherDate() engine = QtQml.QQmlApplicationEngine() engine.rootContext().setContextProperty("time", time) filename = os.path.join(CURRENT_DIR, "Weather.qml") engine.load(QUrl.fromLocalFile(filename)) if not engine.rootObjects(): sys.exit(-1) sys.exit(app.exec_())
def main(): global _bi _bi = Bi() op_init() app = QtGui.QGuiApplication(sys.argv) screens = QtGui.QGuiApplication.screens() for screen in screens: screen.setOrientationUpdateMask(Qt.LandscapeOrientation | Qt.PortraitOrientation | Qt.InvertedLandscapeOrientation | Qt.InvertedPortraitOrientation) QQuickWindow.setDefaultAlphaBuffer(True) engine = QtQml.QQmlApplicationEngine() engine.rootContext().setContextProperty('bi', _bi) engine.load(QtCore.QUrl.fromLocalFile(f'{CURRENT_DIR}/window.qml')) if not engine.rootObjects(): return -1 # https://wiki.qt.io/Qt_for_Python_Signals_and_Slots app.aboutToQuit.connect(op_exit) return app.exec_()
def main(): sys.argv += ['--style', 'material'] CURRENT_DIR = os.path.dirname(sys.argv[0]) QtGui.QGuiApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling) QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps) QtQml.qmlRegisterType(Backend, 'MyLibrary', 1, 0, 'Backend') app = QtGui.QGuiApplication(sys.argv) app.setWindowIcon(QtGui.QIcon(resource_path('icon.ico'))) engine = QtQml.QQmlApplicationEngine() utils = Utils() engine.rootContext().setContextProperty('Utils', utils) engine.load(os.path.join(CURRENT_DIR, resource_path('qml/main.qml'))) if not engine.rootObjects(): sys.exit(-1) sys.exit(app.exec_())
def main(): QtCore.QCoreApplication #subprocess.run(['xset', '-dpms']) subprocess.run(['xset', 's', 'off', '-dpms']) app = QtWidgets.QApplication(sys.argv) QtWebEngine.QtWebEngine.initialize() engine = QtQml.QQmlApplicationEngine() settings = settingsController() try: settings.check() settings.load() except: subprocess.run([ 'x-terminal-emulator', '-T', settings.system_id, '-geometry', '146x80', '-e', 'sudo nmtui' ]) exit(403) t = threading.Thread(target=settings.while_touch) t.daemon = True t.start() printer = printController(settings.settings, settings) ctx = engine.rootContext() ctx.setContextProperty('KioskPrinter', printer) ctx.setContextProperty('KioskSettings', settings) engine.load(QtCore.QUrl("qrc:/Kiosk.qml")) c = app.exec_() content.resource.qCleanupResources() return c
# coding: utf-8 from PySide2 import QtWidgets, QtCore, QtGui, QtQuick, QtQml import sys import os from resources import qml if __name__ == '__main__': app = QtWidgets.QApplication(sys.argv[1:]) engine = QtQml.QQmlApplicationEngine() engine.addImportPath(os.path.join(os.path.dirname(__file__), 'imports')) # import path 是qml中用来improt 的路径,类似python sys.path # plugin path 是能读到qmdir的路径 engine.load("qrc:/main.qml") sys.exit(app.exec_())
return self.y = newY self.handYChanged.emit() @qtc.Property(float, notify=handZChanged) def handZ(self): return self.z @handZ.setter def setZ(self, newZ): # Do not emit a changed signal if the icon is the same if self.z == newZ: return self.z = newZ self.handZChanged.emit() if __name__ == '__main__': # Initializes the app, engine, and classes app = qtg.QGuiApplication(sys.argv) engine = qtm.QQmlApplicationEngine() root_context = engine.rootContext() handgest = HandGest() root_context.setContextProperty('handgest', handgest) engine.load(qtc.QUrl.fromLocalFile('../test.qml')) sys.exit(app.exec_())
import sys from PySide2 import QtCore as qtc, QtWidgets as qtw, QtGui as qtgui, QtQml as qtqml from main import Main if __name__ == "__main__": # Set attributes qtw.QApplication.setAttribute(qtc.Qt.AA_EnableHighDpiScaling) qtc.QCoreApplication.setAttribute(qtc.Qt.AA_UseHighDpiPixmaps) # Define application app = qtw.QApplication(sys.argv) app.setOrganizationName("Yeahlowflicker Production") # Define engine engine = qtqml.QQmlApplicationEngine() manager = Main(engine) engine.load(qtc.QUrl("/mnt/YFP/Projects/PRJ000-Simple-Text-Editor/proj/main.qml")) # Exit handler sys.exit(app.exec_())
def run(): # Sets path of QML files qml_path = "" if os.path.isdir(sys.path[0] + "/qml"): qml_path = sys.path[0] + "/qml" else: qml_path = sys.path[0] + "/../qml" # Create a Qt Application object from the system arguments app = QtWidgets.QApplication(sys.argv) # Set the application icon app.setWindowIcon(QtGui.QIcon("assets/img/icon.png")) # Enable material design in the app os.environ["QT_QUICK_CONTROLS_STYLE"] = "Material" # When the SIGINT signal is received, exit signal.signal(signal.SIGINT, signal.SIG_DFL) # Creates an engine for the application to run under engine = QtQml.QQmlApplicationEngine() # A function to start the main part of the program. # It is conditionally executed based on if the program # has been started before. def start_main(): # Access the global proc and app vars # Load in the config config.load() # Prep the engine (see views.main) views.main.prep_engine(engine, qml_path) # Get the list of root objects: n = engine.rootObjects() # If there are more than one objects in the list, use the second one. # This occurs when the wizard is shown first. if len(n) > 1: root = engine.rootObjects()[1] else: # Else, show the first one root = engine.rootObjects()[0] # Establish all the properties from the config nameProp = QtQml.QQmlProperty(root, "name") schoolProp = QtQml.QQmlProperty(root, "school") hostProp = QtQml.QQmlProperty(root, "hostname") nameProp.write(config.user["firstName"] + " " + config.user["lastName"]) schoolProp.write(config.user["school"]) hostProp.write(config.hostname) # Show the root window root.show() # And execute the application proc = app.exec_() # Register this client to the main server network.register_client() # A function to start the wizard # Again, it is conditionally executed. def start_wizard(): global proc # A function to start the main application from the wizard: def start_main_from_wizard(root): # Close the main window root.close() # and execute start_main start_main() # Load in the interface so it is accessible from QML context = engine.rootContext() engine.load(qml_path + "/wizard/wizard.qml") interface = WizardInterface(lambda: start_main_from_wizard(root)) root = engine.rootObjects()[0] context.setContextProperty("wizardInterface", interface) # Bind user_created to onUserCreated interface.user_created.connect(root.onUserCreated) # And execute the application proc = app.exec_() # If the config file exists, show the main window, if not, show the wizard. if config.exists(): start_main() else: start_wizard() # Exit python when the app starts sys.exit()
# App constants MODULE_NAME = 'QtTodos' MAJOR_VERSION = 0 MINOR_VERSION = 1 # Enable Ctrl-C to kill signal.signal(signal.SIGINT, signal.SIG_DFL) if __name__ == '__main__': # Create QML components from a Python classes # major_version and minor_version represent major and minor version numbers for when we import it in QML QtQml.qmlRegisterType(TodosViewModel, MODULE_NAME, MAJOR_VERSION, MINOR_VERSION, 'TodosViewModel') QtQml.qmlRegisterType(SettingsViewModel, MODULE_NAME, MAJOR_VERSION, MINOR_VERSION, 'SettingsViewModel') QtQml.qmlRegisterType(TodosListModel, MODULE_NAME, MAJOR_VERSION, MINOR_VERSION, 'TodosListModel') # Use render loop that supports persistent 6major_versionfps os.environ['QSG_RENDER_LOOP'] = 'windows' # Create system app app = QtGui.QGuiApplication(sys.argv) # Initialize QML rendering engine engine = QtQml.QQmlApplicationEngine(parent=app) engine.load('main.qml') # Use the app's status as an exit code sys.exit( app.exec_()) # exec_ to avoid collision with built in exec function