def main(): import sys QGuiApplication.setApplicationName("Gallery") QGuiApplication.setOrganizationName("QtProject") QGuiApplication.setAttribute(Qt.AA_EnableHighDpiScaling) app = QGuiApplication(sys.argv) QIcon.setThemeName("gallery") settings = QSettings() style = Fakequickcontrols2.name() if style: settings.setValue("style", style) else: Fakequickcontrols2.setStyle(settings.value("style")) engine = QQmlApplicationEngine() engine.rootContext().setContextProperty( "availableStyles", Fakequickcontrols2.availableStyles()) engine.load(QUrl("qrc:/gallery.qml")) if not engine.rootObjects(): sys.exit(-1) sys.exit(app.exec_())
def main(): app = QGuiApplication(sys.argv) engine = QQmlApplicationEngine() controller = MyPersonalViewController() schema = [ QByteArray(str.encode("index")), QByteArray(str.encode("dog")), QByteArray(str.encode("thirdValue")), ] michael = Dog("Michael", 23) philipp = Dog("Philipp", 18) listOfDogs = DogList(schema) items = [ { QByteArray(str.encode("index")): "test1", QByteArray(str.encode("dog")): michael.name, QByteArray(str.encode("thirdValue")): michael.age }, { QByteArray(str.encode("index")): "test2", QByteArray(str.encode("dog")): philipp.name, QByteArray(str.encode("thirdValue")): philipp.age, } ] for item in items: listOfDogs.append(item) engine.rootContext().setContextProperty("pyModel", listOfDogs) engine.rootContext().setContextProperty("controller", controller) engine.load(QUrl('view.qml')) engine.quit.connect(app.quit) sys.exit(app.exec_())
def start(self): """Display the GUI""" myApp = QApplication(sys.argv) sys.excepthook = lambda typ, val, tb: error_handler(typ, val, tb) myApp.setOrganizationDomain('mlox') myApp.setOrganizationName('mlox') icon_data: bytes = resource_manager.resource_string( "mlox.static", "mlox.ico") icon = QIcon() pixmap = QPixmap() pixmap.loadFromData(icon_data) icon.addPixmap(pixmap) myApp.setWindowIcon(icon) myEngine = QQmlApplicationEngine() # Need to set these before loading myEngine.rootContext().setContextProperty("python", self) myEngine.addImageProvider('static', PkgResourcesImageProvider()) qml: bytes = resource_manager.resource_string("mlox.static", "window.qml") myEngine.loadData(qml) # These two are hacks, because getting them in the __init__ and RAII working isn't self.debug_window = ScrollableDialog() self.clipboard = myApp.clipboard() self.analyze_loadorder() sys.exit(myApp.exec())
def __init__(self, opts, args): QGuiApplication.__init__(self, args) translator = QTranslator() translator.load(QLocale.system().name(), "po") self.installTranslator(translator) qmlRegisterUncreatableType( ReleaseDownload, 'LiveUSB', 1, 0, 'Download', 'Not creatable directly, use the liveUSBData instance instead') qmlRegisterUncreatableType( ReleaseWriter, 'LiveUSB', 1, 0, 'Writer', 'Not creatable directly, use the liveUSBData instance instead') qmlRegisterUncreatableType( ReleaseListModel, 'LiveUSB', 1, 0, 'ReleaseModel', 'Not creatable directly, use the liveUSBData instance instead') qmlRegisterUncreatableType( Release, 'LiveUSB', 1, 0, 'Release', 'Not creatable directly, use the liveUSBData instance instead') qmlRegisterUncreatableType( USBDrive, 'LiveUSB', 1, 0, 'Drive', 'Not creatable directly, use the liveUSBData instance instead') qmlRegisterUncreatableType(LiveUSBData, 'LiveUSB', 1, 0, 'Data', 'Use the liveUSBData root instance') engine = QQmlApplicationEngine() self.data = LiveUSBData(opts) engine.rootContext().setContextProperty('liveUSBData', self.data) if (opts.directqml): engine.load(QUrl('liveusb/liveusb.qml')) else: engine.load(QUrl('qrc:/liveusb.qml')) engine.rootObjects()[0].show() self.exec_()
def main(): """Shows the GUI for event configuration """ from .Controllers.LoginController import LoginController try: print('Starting GUI') app = QApplication(sys.argv) engine = QQmlApplicationEngine() controller = Controller(engine) loginController = LoginController(controller) controller.active_controller_exit_point = loginController._unload engine.rootContext().setContextProperty("controller", controller) engine.rootContext().setContextProperty("loginController", loginController) engine.load(os.path.join(base_path, 'Views', "main.qml")) #component.loadUrl(QUrl(os.path.join(base_path, "main.qml"))) def hide_all(): print('hiding all root objects') for r in engine.rootObjects(): r.hide() engine.quit.connect(hide_all) #engine.quit.connect(app.quit) app.exec_() print('application ended') app = None except Exception as ex: print(ex) pass
class MainWindow(QObject): def __init__(self, parent=None): super().__init__(parent) self.model = MainWindowViewModel(self) self.loginModel = LoginViewModel(self) self.engine = QQmlApplicationEngine(self) self.engine.rootContext().setContextProperty('model', self.model) self.engine.rootContext().setContextProperty('loginModel', self.loginModel) self.engine.quit.connect(parent.quit) self.engine.load(QUrl.fromLocalFile('ui/Chrome.qml')) self.window = self.engine.rootObjects()[0] # wire up logging console self.log = self.window.findChild(QQuickItem, 'log') parent.log_changed.connect(self._log) def show(self): self.window.show() def _log(self, msg): # replace with collections.deque binding(ish)? if self.log.property('lineCount') == LOG_BUFFER_SIZE: line_end = self.log.property('text').find('\n') + 1 self.log.remove(0, line_end) self.log.append(msg)
def showError(message): writeSettings("", "") app = QGuiApplication(sys.argv) engine = QQmlApplicationEngine() engine.rootContext().setContextProperty("message", message) engine.load(QUrl("qrc:/message.qml")) sys.exit(app.exec())
def run(): # First set some application settings for QSettings QtCore.QCoreApplication.setOrganizationName("QTodoTxt") QtCore.QCoreApplication.setApplicationName("QTodoTxt2") # Now set up our application and start app = QtWidgets.QApplication(sys.argv) # it is said, that this is lighter: # (without qwidgets, as we probably don't need them anymore, when transition to qml is done) # app = QtGui.QGuiApplication(sys.argv) name = QtCore.QLocale.system().name() translator = QtCore.QTranslator() if translator.load(str(name) + ".qm", "..//i18n"): app.installTranslator(translator) args = _parseArgs() setupSingleton(args) _setupLogging(args.loglevel) engine = QQmlApplicationEngine(parent=app) controller = MainController(args) engine.rootContext().setContextProperty("mainController", controller) path = os.path.join(os.path.dirname(__file__), 'qml') engine.addImportPath(path) mainqml = os.path.join(path, 'QTodoTxt.qml') engine.load(mainqml) setupAnotherInstanceEvent(controller) controller.start() app.setWindowIcon(QtGui.QIcon(":/qtodotxt")) app.exec_() sys.exit()
def main(): if os.getuid() != 0: print('root permissions needed to launch keylogger') return no_func_keys = '--no-func-keys' in sys.argv if no_func_keys: ignored_keys = [] else: ignored_keys = ['<Enter>', '<LShft>', '<#+8>', '<#+18>'] app = QGuiApplication(sys.argv[:1]) keypressprovider = KeyPressProvider(ignore_keys=ignored_keys, no_func_keys=no_func_keys) engine = QQmlApplicationEngine() engine.rootContext().setContextProperty("text_provider", keypressprovider) engine.load(os.path.join(os.path.dirname(__file__), "main.qml")) window = engine.rootObjects()[0] if not window: sys.exit(-1) k = keypressprovider.keysPressedChanged k.connect(window.setText) sys.exit(app.exec_())
class App(): def __init__(self): self.app = QGuiApplication(sys.argv + ['--style', 'material']) fontdatabase = QFontDatabase() fontdatabase.addApplicationFont("fonts/Exo2-Regular.ttf") exo = QFont("Exo 2", 15) self.app.setFont(exo) self.engine = QQmlApplicationEngine() self.bridge = Bridge(self.app, self.engine) #responder a KeyboardInterrupt signal.signal(signal.SIGINT, signal.SIG_DFL) self.engine.rootContext().setContextProperty("bridge", self.bridge) self.engine.load("assets/main.qml") listDicts = csvInterpreter.readCSV("components.csv") for d in listDicts: self.bridge.createComponent(d) # self.bridge.updateComponents(bytearray.fromhex('5553501408010401080110011F')) self.engine.quit.connect(self.app.quit) self.app.exec()
def main(): try: base_path = sys._MEIPASS except AttributeError: base_path = Path(__file__).parent # https://github.com/kivy/kivy/issues/4182#issuecomment-471488773 if 'twisted.internet.reactor' in sys.modules: del sys.modules['twisted.internet.reactor'] qapp = QApplication(sys.argv) qapp.setApplicationName("HPOS Seed") qapp.setOrganizationDomain("holo.host") qapp.setOrganizationName("Holo") # qt5reactor needs to be imported and installed after QApplication(), # but before importing twisted.internet.reactor. See qt5reactor docs. import qt5reactor qt5reactor.install() from twisted.internet import reactor app = App(qapp, reactor) engine = QQmlApplicationEngine() engine.rootContext().setContextProperty("app", app) engine.load(Path(base_path, 'send_qt.qml').as_uri()) reactor.run()
def __init__(self): app = QGuiApplication(sys.argv) engine = QQmlApplicationEngine() handler = Haldler() engine.rootContext().setContextProperty("handler", handler) engine.load("main.qml") engine.quit.connect(app.quit) sys.exit(app.exec_())
def run(self): engine = QQmlApplicationEngine() w = Wrapper() engine.rootContext().setContextProperty("manager", w) engine.load(QUrl("qrc:/qml/main.qml")) self.exec()
def main(): app = QGuiApplication(sys.argv) qmlRegisterType(MainController, 'MainController', 1, 0, 'MainController') qmlRegisterType(ProfileViewModel, 'ProfileViewModel', 1, 0, 'ProfileViewModel') engine = QQmlApplicationEngine() main_controller = MainController() main_controller.profile_selection_changed(0) engine.rootContext().setContextProperty('mainController', main_controller) engine.load(QUrl.fromLocalFile(pkg_resources.resource_filename('yarg.resource', 'main.qml'))) sys.exit(app.exec_())
def main(): app = QGuiApplication(argv) qmlRegisterType(syncer.Channel.Channel, 'Example', 1, 0, 'Channel') qmlRegisterType(syncer.Store.Store, 'Example', 1, 0, 'Store') qmlRegisterType(syncer.Watcher.Watcher, 'Example', 1, 0, 'Watcher') engine = QQmlApplicationEngine() engine.rootContext().setContextProperty('store', _STORE) engine.load('qml/main.qml') exit(app.exec_())
def main(): app = QGuiApplication(sys.argv) qmlRegisterType(MainController, 'MainController', 1, 0, 'MainController') qmlRegisterType(ProfileViewModel, 'ProfileViewModel', 1, 0, 'ProfileViewModel') engine = QQmlApplicationEngine() main_controller = MainController() main_controller.profile_selection_changed(0) engine.rootContext().setContextProperty('mainController', main_controller) engine.load(QUrl.fromLocalFile('yarg/resource/main.qml')) window = engine.rootObjects()[0] sys.exit(app.exec_())
class PixelWall(QApplication): def __init__(self, *args, **kwargs): super(PixelWall, self).__init__(*args, **kwargs) self.engine = QQmlApplicationEngine(self) self.servers = ServerModel(self.engine) self.settings = QSettings('OpenServices', 'PixelWall') url = self.settings.value('server/url') self.engine.setNetworkAccessManagerFactory(NetworkAccessManagerFactory('hetzner.fladi.at', 3128)) ctxt = self.engine.rootContext() ctxt.setContextProperty('app', self) ctxt.setContextProperty('url', 'about:blank') self.engine.load(QUrl('states.qml')) discoverer = Avahi(self.engine, '_pixelwall._tcp') discoverer.initialized.connect(self.serverState) discoverer.added.connect(self.servers.addService) ctxt.setContextProperty('serverModel', self.servers) discoverer.run() if url: self.setUrl(url) self.setState('Web') def setState(self, state): for root in self.engine.rootObjects(): node = root.findChild(QObject, 'main') if node: logger.info('Setting state: {}'.format(state)) node.setProperty('state', state) def setUrl(self, url): logger.info('Connecting WebView to {}'.format(url)) ctxt = self.engine.rootContext() ctxt.setContextProperty('url', 'https://www.heise.de/') @pyqtSlot() def reset(self): self.settings.remove('server/url') self.setState('Servers') @pyqtSlot(int) def serverSelected(self, index): server = self.servers.getIndex(index) logger.info('Server selected {}'.format(server)) url = 'https://{server.host}:{server.port}/'.format(server=server) self.settings.setValue('server/url', url) self.setUrl(url) self.setState('Web') @pyqtSlot() def serverState(self): self.setState('Servers')
def main() -> None: """Application entry point""" # configure logging logging.basicConfig(level=logging.INFO) # create the App ant the event loop app = QGuiApplication(sys.argv + ["--style", QUICK_CONTROLS2_STYLE]) loop = QEventLoop(app) asyncio.set_event_loop(loop) # register custom types register_types() # create the QML engine engine = QQmlApplicationEngine() # set context properties engine.rootContext().setContextProperty("version", VERSION) engine.rootContext().setContextProperty("author", AUTHOR) engine.rootContext().setContextProperty("authorEmail", AUTHOR_EMAIL) engine.rootContext().setContextProperty("projectUrl", URL) # load the main QML file engine.load(MAIN_QML_PATH) # start the event loop with loop: loop.run_forever()
def main(): app = QGuiApplication(argv) qmlRegisterType(Manager.Manager, 'BTManager', 1, 0, 'BTManager') qmlRegisterType(Notifier.Notifier, 'BTNotifier', 1, 0, 'BTNotifier') qmlRegisterType(Device.Device, 'Device', 1, 0, 'Device') print('Create my device') notifier = Notifier.Notifier() manager = Manager.Manager() manager.set_notifier(notifier) print('Bluetooth manager create') path = os.path.dirname(__file__) print('Detect run path') print('Run GUI') engine = QQmlApplicationEngine() engine.rootContext().setContextProperty('AppPath', path) engine.rootContext().setContextProperty('MyDevice', manager.my_device) engine.rootContext().setContextProperty('BTManager', manager) engine.rootContext().setContextProperty('BTNotifier', notifier) engine.load('ui/Main.qml') print('Start search for near by devices') manager.search(True) print('Execute app') exit(app.exec_())
def main(): app = QApplication(sys.argv) engine = QQmlApplicationEngine() width = 15 height = 15 gameManager = GameManager(width, height, 50) engine.rootContext().setContextProperty("gameManager", gameManager) engine.load('Views/Window.qml') window = engine.rootObjects()[0] window.setProperty("title", "Sapper") window.setProperty("width", width * 50 + 90) window.setProperty("height", height * 50 + 140) window.show() sys.exit(app.exec_())
def _start(self): qApp = QGuiApplication(sys.argv) qApp.setWindowIcon(QIcon(self.root_folder + \ "/assets/image/logo_GGuides.ico")) engine = QQmlApplicationEngine() engine.rootContext().setContextProperty('manager', self.manager) engine.load('UI/main.qml') engine.quit.connect(qApp.quit) qApp.aboutToQuit.connect(self._postprocess) qApp.exec_() sys.exit()
def start(self): """Display the GUI""" myApp = QApplication(sys.argv) myEngine = QQmlApplicationEngine() sys.excepthook = lambda typ, val, tb: error_handler(typ, val, tb) myEngine.rootContext().setContextProperty( "python", self) # Need to set this before loading myEngine.load(QUrl(qml_file)) # These two are hacks, because getting them in the __init__ and RAII working isn't self.debug_window = ScrollableDialog() self.clipboard = myApp.clipboard() self.analyze_loadorder() sys.exit(myApp.exec_())
def main(): argv = sys.argv # Trick to set the style / not found how to do it in pythonic way argv.extend(["-style", "universal"]) app = QGuiApplication(argv) qmlRegisterType(FigureCanvasQTAggToolbar, "Backend", 1, 0, "FigureToolbar") imgProvider = MatplotlibIconProvider() # !! You must specified the QApplication as parent of QQmlApplicationEngine # otherwise a segmentation fault is raised when exiting the app engine = QQmlApplicationEngine(parent=app) engine.addImageProvider("mplIcons", imgProvider) context = engine.rootContext() data_model = DataSeriesModel() context.setContextProperty("dataModel", data_model) mainApp = Form(data=data_model) context.setContextProperty("draw_mpl", mainApp) engine.load(QUrl('main.qml')) win = engine.rootObjects()[0] mainApp.figure = win.findChild(QObject, "figure").getFigure() rc = app.exec_() # There is some trouble arising when deleting all the objects here # but I have not figure out how to solve the error message. # It looks like 'app' is destroyed before some QObject sys.exit(rc)
def main(): print('main()') app = QApplication(sys.argv) engine = QQmlApplicationEngine() main_controller = MainController(app) context = engine.rootContext() context.setContextProperty("main", main_controller) script_directory = os.path.dirname(os.path.abspath(__file__)) engine.load(os.path.join(script_directory, 'qml/main.qml')) # hook into SIGINT signal to shutdown the application when commanded def sig_int_handler(signal, frame): logger.info('SIGINT received') main_controller.shutdown() signal.signal(signal.SIGINT, sig_int_handler) # Python cannot handle signals while the Qt event loop is running # So we'll let the python interpreter run periodically so any # SIGINT signals can be processed timer = QTimer() timer.start(500) # You may change this if you wish. timer.timeout.connect(lambda: None) main_controller.start() sys.exit(app.exec_())
def start(): app = QApplication(sys.argv) engine = QQmlApplicationEngine() app.setOrganizationName('Aldian A') app.setOrganizationDomain('Perpustakaan') engine.rootContext().setContextProperty('AdminProps', AdminProps) engine.rootContext().setContextProperty('LoginProps', LoginProps) engine.rootContext().setContextProperty('GuestProps', GuestProps) engine.load('view/main.qml') engine.quit.connect(app.quit) signal.signal(signal.SIGINT, signal.SIG_DFL) sys.exit(app.exec_())
def _startUp(self): """ """ # start app app = QGuiApplication(sys.argv) app.setWindowIcon( QIcon(self.HOME_PATH + 'ui/images/ic_album_black_24dp.png')) engine = QQmlApplicationEngine() self.control = Control() engine.rootContext().setContextProperty('Functions', self.control) engine.rootContext().setContextProperty('FileSys', self.fileSys) engine.load(self.main_qml) engine.quit.connect(app.quit) app.aboutToQuit.connect(self._postprocesses) sys.exit(app.exec_())
def main(): global app # The following command line argument sets the style of the QML app. There is no alternative. # Available styles: https://doc.qt.io/qt-5/qtquickcontrols2-styles.html sys.argv += ['--style', 'fusion'] app = QApplication(sys.argv) # Make the Data Preprocessor Manager accessible through QML. engine = QQmlApplicationEngine() context = engine.rootContext() dpmanager = DataPreprocessorManager() context.setContextProperty('dpManager', dpmanager) idsmanager = TwoStageIDSManager() context.setContextProperty('idsManager', idsmanager) reportmanager = ReportManager() context.setContextProperty('reportManager', reportmanager) simulationmanager = SimulationManager(idsmanager) context.setContextProperty('simManager', simulationmanager) baselogmodel = BaseOutputLogModel() outputlogmodel = OutputLogModel() outputlogmodel.setDynamicSortFilter(True) outputlogmodel.setSourceModel(baselogmodel) context.setContextProperty('outputLogModel', outputlogmodel) context.setContextProperty('excHandler', excHandler) # Load the QML file. engine.load(os.path.dirname(os.path.abspath(__file__)) + '/gui/main.qml') # Run the QML file. sys.exit(app.exec_())
def runQML(): #view = QQuickView() #ui.setupUi(this) #container = QWidget.createWindowContainer(view, this) #container.setMinimumSize(200, 200) #container.setMaximumSize(200, 200) app =QApplication(sys.argv) engine = QQmlApplicationEngine() # app.setWindowIcon(QIcon("icon.png")) root = engine.rootContext() engine.load('dice/main.qml') #ui.verticalLayout.addWidget(container) child = engine.rootObjects()[0].findChild(QtCore.QObject, "foo_object") #print(str(child)) child.setProperty("text", "Blödsinn") #root.setContextProperty("guisettings", guisettings) print(str(len(engine.rootObjects()))) for w in engine.rootObjects(): #print(str(type(w.contentItem().childItems()).__name__)) for v in w.contentItem().childItems(): print(str(v.setOpacity(0.9))) for i,x in enumerate(v.childItems()): print(str(x.setOpacity(0.9))) x.stackAfter(v.childItems()[-i]) if not engine.rootObjects(): return -1 return app.exec_()
def main(blocks=None, angle=None): app = QApplication(sys.argv) app_engine = QQmlApplicationEngine() context = app_engine.rootContext() # WARNING: ALL THE ADDIMAGEPROVIDER LINES BELOW ARE REQUIRED TO MAKE # WARNING: QML BELIEVE THE PROVIDER IS VALID BEFORE ITS CREATION analysis_image_provider = PyplotImageProvider(fig=None) app_engine.addImageProvider("analysisprovider", analysis_image_provider) win = get_main_window(app_engine) detector = DetectionInterface(app, context, win, display_name="detectionGraph", image_provider=analysis_image_provider, image_provider_name="analysisprovider") context.setContextProperty('py_detector', detector) if blocks is not None: detector.set_blocks(blocks, angle) win.show() # detector.detect() # to display cell 0 detector.init_ui() app.exec_()
def run(torrent_client): """ Start the UI """ app = QApplication(sys.argv) app.setOrganizationName("example") app.setOrganizationDomain("example.com") engine = QQmlApplicationEngine() context = engine.rootContext() ctx_manager = ContextManager(torrent_client) ctx_props = ctx_manager.context_props for prop_name in ctx_props: context.setContextProperty(prop_name, ctx_props[prop_name]) qml_file = os.path.join(os.path.dirname(__file__), "views/window.qml") engine.load(QUrl.fromLocalFile(os.path.abspath(qml_file))) if not engine.rootObjects(): sys.exit(-1) window = engine.rootObjects()[0] ctx_manager.set_window(window) ret = app.exec_() ctx_manager.clean_up() sys.exit(ret)
def start_GUI(self): app = QApplication(sys.argv) try: engine = QQmlApplicationEngine() ctx = engine.rootContext() ctx.setContextProperty("roscam_main", self) engine.load( os.path.join(os.path.dirname(__file__), "../../Resources/main.qml")) timer = QtCore.QTimer() timer.timeout.connect(lambda: None) timer.start(100) sys.exit(self.Close_fct(app=app, sub=self.application_node)) except KeyboardInterrupt: print("keyboard interupt") sys.exit(self.Close_fct(app=app, sub=self.application_node)) except Exception: print("exception") sys.exit(self.Close_fct(app=app, sub=self.application_node))
def __init__(self, argv): app = QGuiApplication(argv) engine = QQmlApplicationEngine() context = engine.rootContext() context.setContextProperty('mainWindow', engine) # the string can be anything engine.load('/Users/hebingchang/QtCreator/sniffer/sniffer.qml') self.root = engine.rootObjects()[0] self.root.setDevModel(pcap.findalldevs()) self.dev = pcap.findalldevs()[0] self.sniffer_status = False # self.root.appendPacketModel({'source': '10.162.31.142', 'destination': '151.101.74.49', 'length': 52, 'id': 1}) self.packetModel = self.root.findChild(QObject, "packetModel") btnStart = self.root.findChild(QObject, "btnStart") btnStart.clicked.connect(self.myFunction) # works too self.comboDev = self.root.findChild(QObject, "comboDevice") self.comboDev.activated.connect(self.getDev) engine.quit.connect(app.quit) sys.exit(app.exec_())
def main(args=sys.argv, qml_code=None): app = QApplication(args) app.setApplicationName('Batch resizer') app.setOrganizationName('BSC') qmlEngine = QQmlApplicationEngine() imd = ImageMagickDispatcher() qmlEngine.rootContext().setContextProperty("imageMagickDispatcher", imd) if qml_code: qmlEngine.loadData(qml_code.encode()) else: qmlEngine.load('resizer.qml') qmlEngine.quit.connect(app.quit) app.exec_()
class Application: organization = 'pisak' name = 'pisak' def __init__(self, gui): self._app = QApplication(sys.argv) self._app.setOrganizationName(self.organization) self._app.setApplicationName(self.name) self._context = _ApplicationContext() self._engine = QQmlApplicationEngine() self._engine.rootContext().setContextProperty('pisak', self._context) self._engine.load(gui) def run(self): sys.exit(self._app.exec_())
class Application(QApplication): def __init__(self, argv): super(Application, self).__init__(argv) stderrHandler = logging.StreamHandler(stream=sys.stderr) stderrHandler.setLevel(logging.WARN) stdoutHandler = logging.StreamHandler(stream=sys.stdout) stdoutHandler.setLevel(logging.INFO) stdoutHandler.filter = lambda rec: rec.levelno <= stdoutHandler.level logging.basicConfig( format='%(name)-15s %(message)s', level=logging.INFO, handlers=[stderrHandler, stdoutHandler] ) logger.info("__init__") self._qml_engine = QQmlApplicationEngine() self._root_context = self._qml_engine.rootContext() self.char = Character(self) def setContext(self, name, value): self._root_context.setContextProperty(name, value) def start(self): logger.info("start") self.setContext('character', self.char) self.readModels() self._qml_engine.load(QUrl("qrc:/ui/main.qml")) def readModels(self): logger.info("readModels") modelTypes = [ MODEL.Perk, MODEL.Quirk, MODEL.Species ] allDelayedInits = {} for modelType in modelTypes: delayedInits = [] logger.info("parsing model %s", modelType.__name__) g = modelParsers.parse(modelType, delayedInits=delayedInits) allDelayedInits[modelType] = delayedInits model = list(g) # TODO name = "%sModel" % modelType.__name__ assert model is not None, "failed to parse {0}".format(modelType.__name__) self.setContext(name, model) for modelType, delayedInits in allDelayedInits.items(): logger.info("delayed init model %s (%s)", modelType.__name__, len(delayedInits)) for delayedInit in delayedInits: delayedInit() def exec(self): logger.info("exec") super().exec()
class MainWindow(QObject): def __init__(self, parent=None): super().__init__(parent) self.log = logging.getLogger(__name__) self._read_settings() self.client = Client(self) if self.remember: self._autologin() self.model = MainWindowViewModel(self) self.loginModel = LoginViewModel(self.client, self.user, self.password, self.remember, self) self.loginModel.panel_visible = not self.remember self.gamesModel = GamesViewModel(self) self.engine = QQmlApplicationEngine(self) self.engine.rootContext().setContextProperty('windowModel', self.model) self.engine.rootContext().setContextProperty('loginModel', self.loginModel) self.engine.rootContext().setContextProperty('contentModel', self.gamesModel) self.engine.quit.connect(parent.quit) self.engine.load(QUrl.fromLocalFile('ui/Chrome.qml')) self.window = self.engine.rootObjects()[0] # wire up logging console self.console = self.window.findChild(QQuickItem, 'console') parent.log_changed.connect(self._log) def show(self): self.window.show() def _read_settings(self): stored = settings.get() stored.beginGroup('login') self.user = stored.value('user') self.password = stored.value('password') self.remember = stored.value('remember') == 'true' stored.endGroup() @async_slot def _autologin(self): try: self.log.info('logging in (auto)...') self.loginModel.logged_in = yield from self.client.login(self.user, self.password) self.log.debug('autologin result: {}'.format(self.loginModel.logged_in)) except Exception as e: self.log.error('autologin failed. {}'.format(e)) @pyqtSlot(str) def _log(self, msg): # replace with collections.deque binding(ish)? if self.console.property('lineCount') == LOG_BUFFER_SIZE: line_end = self.console.property('text').find('\n') + 1 self.console.remove(0, line_end) self.console.append(msg)
class MyApp(QObject): def __init__(self, qml, set_context=None): super().__init__() self.app = QApplication(sys.argv) self.engine = QQmlApplicationEngine(self) self.root_context = self.engine.rootContext() if set_context: set_context(self.root_context) self.engine.load(QUrl(qml)) self.root_view = self.engine.rootObjects()[0] @staticmethod def run(my_app): my_app.root_view.show() return my_app.app.exec_()
def main(argv): signal.signal(signal.SIGINT, signal.SIG_DFL) qapp = QGuiApplication([]) engine = QQmlApplicationEngine() data_list = [] for entry in os.scandir(argv[1]): url = "file://" + urllib.parse.quote(os.path.abspath(entry.path)) digest = hashlib.md5(os.fsencode(url)).hexdigest() result = os.path.join(xdg.BaseDirectory.xdg_cache_home, "thumbnails", "normal", digest + ".png") data_list.append(Foo(entry.name, result, "2018-01-11T19:20")) engine.load(QUrl('main.qml')) ctxt = engine.rootContext() ctxt.setContextProperty("menu2", QVariant(data_list)) win = engine.rootObjects()[0] win.show() sys.exit(qapp.exec())
The method to make it compatible with sys.stdout The text gets printed in the corresponding qml component :param string text: The text to append at the end of the current qml component text """ if text: previousText = self.log.property('text') outputText = '{}\n>>>{}'.format(previousText, text) self.log.setProperty('text', outputText) if __name__ == '__main__': app = QApplication(sys.argv) appEngine = QQmlApplicationEngine() context = appEngine.rootContext() appEngine.addImageProvider('viewerprovider', CvImageProvider()) # Hack to make qml believe provider is valid before its creation appEngine.addImageProvider('trackerprovider', CvImageProvider()) # Hack to make qml believe provider is valid before its creation appEngine.addImageProvider('recorderprovider', CvImageProvider()) # Hack to make qml believe provider is valid before its creation appEngine.addImageProvider('calibrationprovider', CvImageProvider()) # Hack to make qml believe provider is valid before its creation analysisImageProvider = PyplotImageProvider(fig=None) appEngine.addImageProvider("analysisprovider", analysisImageProvider) analysisImageProvider2 = PyplotImageProvider(fig=None) appEngine.addImageProvider("analysisprovider2", analysisImageProvider2) appEngine.load(QUrl('./qml/MouseTracker.qml')) win = appEngine.rootObjects()[0] if not DEBUG: logger = Logger(context, win, "log")
class QtApplication(QApplication, Application): pluginsLoaded = Signal() applicationRunning = Signal() def __init__(self, tray_icon_name: str = None, **kwargs) -> None: plugin_path = "" if sys.platform == "win32": if hasattr(sys, "frozen"): plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins") Logger.log("i", "Adding QT5 plugin path: %s", plugin_path) QCoreApplication.addLibraryPath(plugin_path) else: import site for sitepackage_dir in site.getsitepackages(): QCoreApplication.addLibraryPath(os.path.join(sitepackage_dir, "PyQt5", "plugins")) elif sys.platform == "darwin": plugin_path = os.path.join(self.getInstallPrefix(), "Resources", "plugins") if plugin_path: Logger.log("i", "Adding QT5 plugin path: %s", plugin_path) QCoreApplication.addLibraryPath(plugin_path) # use Qt Quick Scene Graph "basic" render loop os.environ["QSG_RENDER_LOOP"] = "basic" super().__init__(sys.argv, **kwargs) # type: ignore self._qml_import_paths = [] #type: List[str] self._main_qml = "main.qml" #type: str self._qml_engine = None #type: Optional[QQmlApplicationEngine] self._main_window = None #type: Optional[MainWindow] self._tray_icon_name = tray_icon_name #type: Optional[str] self._tray_icon = None #type: Optional[str] self._tray_icon_widget = None #type: Optional[QSystemTrayIcon] self._theme = None #type: Optional[Theme] self._renderer = None #type: Optional[QtRenderer] self._job_queue = None #type: Optional[JobQueue] self._version_upgrade_manager = None #type: Optional[VersionUpgradeManager] self._is_shutting_down = False #type: bool self._recent_files = [] #type: List[QUrl] self._configuration_error_message = None #type: Optional[ConfigurationErrorMessage] def addCommandLineOptions(self) -> None: super().addCommandLineOptions() # This flag is used by QApplication. We don't process it. self._cli_parser.add_argument("-qmljsdebugger", help = "For Qt's QML debugger compatibility") def initialize(self) -> None: super().initialize() # Initialize the package manager to remove and install scheduled packages. self._package_manager = self._package_manager_class(self, parent = self) self._mesh_file_handler = MeshFileHandler(self) #type: MeshFileHandler self._workspace_file_handler = WorkspaceFileHandler(self) #type: WorkspaceFileHandler # Remove this and you will get Windows 95 style for all widgets if you are using Qt 5.10+ self.setStyle("fusion") self.setAttribute(Qt.AA_UseDesktopOpenGL) major_version, minor_version, profile = OpenGLContext.detectBestOpenGLVersion() if major_version is None and minor_version is None and profile is None and not self.getIsHeadLess(): Logger.log("e", "Startup failed because OpenGL version probing has failed: tried to create a 2.0 and 4.1 context. Exiting") QMessageBox.critical(None, "Failed to probe OpenGL", "Could not probe OpenGL. This program requires OpenGL 2.0 or higher. Please check your video card drivers.") sys.exit(1) else: opengl_version_str = OpenGLContext.versionAsText(major_version, minor_version, profile) Logger.log("d", "Detected most suitable OpenGL context version: %s", opengl_version_str) if not self.getIsHeadLess(): OpenGLContext.setDefaultFormat(major_version, minor_version, profile = profile) self._qml_import_paths.append(os.path.join(os.path.dirname(sys.executable), "qml")) self._qml_import_paths.append(os.path.join(self.getInstallPrefix(), "Resources", "qml")) Logger.log("i", "Initializing job queue ...") self._job_queue = JobQueue() self._job_queue.jobFinished.connect(self._onJobFinished) Logger.log("i", "Initializing version upgrade manager ...") self._version_upgrade_manager = VersionUpgradeManager(self) def startSplashWindowPhase(self) -> None: super().startSplashWindowPhase() self._package_manager.initialize() # Read preferences here (upgrade won't work) to get the language in use, so the splash window can be shown in # the correct language. try: preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg") self._preferences.readFromFile(preferences_filename) except FileNotFoundError: Logger.log("i", "Preferences file not found, ignore and use default language '%s'", self._default_language) signal.signal(signal.SIGINT, signal.SIG_DFL) # This is done here as a lot of plugins require a correct gl context. If you want to change the framework, # these checks need to be done in your <framework>Application.py class __init__(). i18n_catalog = i18nCatalog("uranium") self._configuration_error_message = ConfigurationErrorMessage(self, i18n_catalog.i18nc("@info:status", "Your configuration seems to be corrupt."), lifetime = 0, title = i18n_catalog.i18nc("@info:title", "Configuration errors") ) # Remove, install, and then loading plugins self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins...")) # Remove and install the plugins that have been scheduled self._plugin_registry.initializeBeforePluginsAreLoaded() self._loadPlugins() self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins()) self.pluginsLoaded.emit() self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Updating configuration...")) with self._container_registry.lockFile(): VersionUpgradeManager.getInstance().upgrade() # Load preferences again because before we have loaded the plugins, we don't have the upgrade routine for # the preferences file. Now that we have, load the preferences file again so it can be upgraded and loaded. try: preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg") with open(preferences_filename, "r", encoding = "utf-8") as f: serialized = f.read() # This performs the upgrade for Preferences self._preferences.deserialize(serialized) self._preferences.setValue("general/plugins_to_remove", "") self._preferences.writeToFile(preferences_filename) except FileNotFoundError: Logger.log("i", "The preferences file cannot be found, will use default values") # Force the configuration file to be written again since the list of plugins to remove maybe changed self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences...")) try: self._preferences_filename = Resources.getPath(Resources.Preferences, self._app_name + ".cfg") self._preferences.readFromFile(self._preferences_filename) except FileNotFoundError: Logger.log("i", "The preferences file '%s' cannot be found, will use default values", self._preferences_filename) self._preferences_filename = Resources.getStoragePath(Resources.Preferences, self._app_name + ".cfg") # FIXME: This is done here because we now use "plugins.json" to manage plugins instead of the Preferences file, # but the PluginRegistry will still import data from the Preferences files if present, such as disabled plugins, # so we need to reset those values AFTER the Preferences file is loaded. self._plugin_registry.initializeAfterPluginsAreLoaded() # Check if we have just updated from an older version self._preferences.addPreference("general/last_run_version", "") last_run_version_str = self._preferences.getValue("general/last_run_version") if not last_run_version_str: last_run_version_str = self._version last_run_version = Version(last_run_version_str) current_version = Version(self._version) if last_run_version < current_version: self._just_updated_from_old_version = True self._preferences.setValue("general/last_run_version", str(current_version)) self._preferences.writeToFile(self._preferences_filename) # Preferences: recent files self._preferences.addPreference("%s/recent_files" % self._app_name, "") file_names = self._preferences.getValue("%s/recent_files" % self._app_name).split(";") for file_name in file_names: if not os.path.isfile(file_name): continue self._recent_files.append(QUrl.fromLocalFile(file_name)) if not self.getIsHeadLess(): # Initialize System tray icon and make it invisible because it is used only to show pop up messages self._tray_icon = None if self._tray_icon_name: self._tray_icon = QIcon(Resources.getPath(Resources.Images, self._tray_icon_name)) self._tray_icon_widget = QSystemTrayIcon(self._tray_icon) self._tray_icon_widget.setVisible(False) def initializeEngine(self) -> None: # TODO: Document native/qml import trickery self._qml_engine = QQmlApplicationEngine(self) self._qml_engine.setOutputWarningsToStandardError(False) self._qml_engine.warnings.connect(self.__onQmlWarning) for path in self._qml_import_paths: self._qml_engine.addImportPath(path) if not hasattr(sys, "frozen"): self._qml_engine.addImportPath(os.path.join(os.path.dirname(__file__), "qml")) self._qml_engine.rootContext().setContextProperty("QT_VERSION_STR", QT_VERSION_STR) self._qml_engine.rootContext().setContextProperty("screenScaleFactor", self._screenScaleFactor()) self.registerObjects(self._qml_engine) Bindings.register() self._qml_engine.load(self._main_qml) self.engineCreatedSignal.emit() recentFilesChanged = pyqtSignal() @pyqtProperty("QVariantList", notify=recentFilesChanged) def recentFiles(self) -> List[QUrl]: return self._recent_files def _onJobFinished(self, job: Job) -> None: if isinstance(job, WriteFileJob): if not job.getResult() or not job.getAddToRecentFiles(): # For a write file job, if it failed or it doesn't need to be added to the recent files list, we do not # add it. return elif (not isinstance(job, ReadMeshJob) and not isinstance(job, ReadFileJob)) or not job.getResult(): return if isinstance(job, (ReadMeshJob, ReadFileJob, WriteFileJob)): self.addFileToRecentFiles(job.getFileName()) def addFileToRecentFiles(self, file_name: str) -> None: file_path = QUrl.fromLocalFile(file_name) if file_path in self._recent_files: self._recent_files.remove(file_path) self._recent_files.insert(0, file_path) if len(self._recent_files) > 10: del self._recent_files[10] pref = "" for path in self._recent_files: pref += path.toLocalFile() + ";" self.getPreferences().setValue("%s/recent_files" % self.getApplicationName(), pref) self.recentFilesChanged.emit() def run(self) -> None: super().run() def hideMessage(self, message: Message) -> None: with self._message_lock: if message in self._visible_messages: message.hide(send_signal = False) # we're in handling hideMessageSignal so we don't want to resend it self._visible_messages.remove(message) self.visibleMessageRemoved.emit(message) def showMessage(self, message: Message) -> None: with self._message_lock: if message not in self._visible_messages: self._visible_messages.append(message) message.setLifetimeTimer(QTimer()) message.setInactivityTimer(QTimer()) self.visibleMessageAdded.emit(message) # also show toast message when the main window is minimized self.showToastMessage(self._app_name, message.getText()) def _onMainWindowStateChanged(self, window_state: int) -> None: if self._tray_icon and self._tray_icon_widget: visible = window_state == Qt.WindowMinimized self._tray_icon_widget.setVisible(visible) # Show toast message using System tray widget. def showToastMessage(self, title: str, message: str) -> None: if self.checkWindowMinimizedState() and self._tray_icon_widget: # NOTE: Qt 5.8 don't support custom icon for the system tray messages, but Qt 5.9 does. # We should use the custom icon when we switch to Qt 5.9 self._tray_icon_widget.showMessage(title, message) def setMainQml(self, path: str) -> None: self._main_qml = path def exec_(self, *args: Any, **kwargs: Any) -> None: self.applicationRunning.emit() super().exec_(*args, **kwargs) @pyqtSlot() def reloadQML(self) -> None: # only reload when it is a release build if not self.getIsDebugMode(): return if self._qml_engine and self._theme: self._qml_engine.clearComponentCache() self._theme.reload() self._qml_engine.load(self._main_qml) # Hide the window. For some reason we can't close it yet. This needs to be done in the onComponentCompleted. for obj in self._qml_engine.rootObjects(): if obj != self._qml_engine.rootObjects()[-1]: obj.hide() @pyqtSlot() def purgeWindows(self) -> None: # Close all root objects except the last one. # Should only be called by onComponentCompleted of the mainWindow. if self._qml_engine: for obj in self._qml_engine.rootObjects(): if obj != self._qml_engine.rootObjects()[-1]: obj.close() @pyqtSlot("QList<QQmlError>") def __onQmlWarning(self, warnings: List[QQmlError]) -> None: for warning in warnings: Logger.log("w", warning.toString()) engineCreatedSignal = Signal() def isShuttingDown(self) -> bool: return self._is_shutting_down def registerObjects(self, engine) -> None: #type: ignore #Don't type engine, because the type depends on the platform you're running on so it always gives an error somewhere. engine.rootContext().setContextProperty("PluginRegistry", PluginRegistry.getInstance()) def getRenderer(self) -> QtRenderer: if not self._renderer: self._renderer = QtRenderer() return cast(QtRenderer, self._renderer) mainWindowChanged = Signal() def getMainWindow(self) -> Optional[MainWindow]: return self._main_window def setMainWindow(self, window: MainWindow) -> None: if window != self._main_window: if self._main_window is not None: self._main_window.windowStateChanged.disconnect(self._onMainWindowStateChanged) self._main_window = window if self._main_window is not None: self._main_window.windowStateChanged.connect(self._onMainWindowStateChanged) self.mainWindowChanged.emit() def setVisible(self, visible: bool) -> None: if self._main_window is not None: self._main_window.visible = visible @property def isVisible(self) -> bool: if self._main_window is not None: return self._main_window.visible #type: ignore #MyPy doesn't realise that self._main_window cannot be None here. return False def getTheme(self) -> Optional[Theme]: if self._theme is None: if self._qml_engine is None: Logger.log("e", "The theme cannot be accessed before the engine is initialised") return None self._theme = UM.Qt.Bindings.Theme.Theme.getInstance(self._qml_engine) return self._theme # Handle a function that should be called later. def functionEvent(self, event: QEvent) -> None: e = _QtFunctionEvent(event) QCoreApplication.postEvent(self, e) # Handle Qt events def event(self, event: QEvent) -> bool: if event.type() == _QtFunctionEvent.QtFunctionEvent: event._function_event.call() return True return super().event(event) def windowClosed(self, save_data: bool = True) -> None: Logger.log("d", "Shutting down %s", self.getApplicationName()) self._is_shutting_down = True # garbage collect tray icon so it gets properly closed before the application is closed self._tray_icon_widget = None if save_data: try: self.savePreferences() except Exception as e: Logger.log("e", "Exception while saving preferences: %s", repr(e)) try: self.applicationShuttingDown.emit() except Exception as e: Logger.log("e", "Exception while emitting shutdown signal: %s", repr(e)) try: self.getBackend().close() except Exception as e: Logger.log("e", "Exception while closing backend: %s", repr(e)) if self._tray_icon_widget: self._tray_icon_widget.deleteLater() self.quit() def checkWindowMinimizedState(self) -> bool: if self._main_window is not None and self._main_window.windowState() == Qt.WindowMinimized: return True else: return False ## Get the backend of the application (the program that does the heavy lifting). # The backend is also a QObject, which can be used from qml. @pyqtSlot(result = "QObject*") def getBackend(self) -> Backend: return self._backend ## Property used to expose the backend # It is made static as the backend is not supposed to change during runtime. # This makes the connection between backend and QML more reliable than the pyqtSlot above. # \returns Backend \type{Backend} @pyqtProperty("QVariant", constant = True) def backend(self) -> Backend: return self.getBackend() ## Create a class variable so we can manage the splash in the CrashHandler dialog when the Application instance # is not yet created, e.g. when an error occurs during the initialization splash = None # type: Optional[QSplashScreen] def createSplash(self) -> None: if not self.getIsHeadLess(): try: QtApplication.splash = self._createSplashScreen() except FileNotFoundError: QtApplication.splash = None else: if QtApplication.splash: QtApplication.splash.show() self.processEvents() ## Display text on the splash screen. def showSplashMessage(self, message: str) -> None: if not QtApplication.splash: self.createSplash() if QtApplication.splash: QtApplication.splash.showMessage(message, Qt.AlignHCenter | Qt.AlignVCenter) self.processEvents() elif self.getIsHeadLess(): Logger.log("d", message) ## Close the splash screen after the application has started. def closeSplash(self) -> None: if QtApplication.splash: QtApplication.splash.close() QtApplication.splash = None ## Create a QML component from a qml file. # \param qml_file_path: The absolute file path to the root qml file. # \param context_properties: Optional dictionary containing the properties that will be set on the context of the # qml instance before creation. # \return None in case the creation failed (qml error), else it returns the qml instance. # \note If the creation fails, this function will ensure any errors are logged to the logging service. def createQmlComponent(self, qml_file_path: str, context_properties: Dict[str, "QObject"] = None) -> Optional["QObject"]: if self._qml_engine is None: # Protect in case the engine was not initialized yet return None path = QUrl.fromLocalFile(qml_file_path) component = QQmlComponent(self._qml_engine, path) result_context = QQmlContext(self._qml_engine.rootContext()) #type: ignore #MyPy doens't realise that self._qml_engine can't be None here. if context_properties is not None: for name, value in context_properties.items(): result_context.setContextProperty(name, value) result = component.create(result_context) for err in component.errors(): Logger.log("e", str(err.toString())) if result is None: return None # We need to store the context with the qml object, else the context gets garbage collected and the qml objects # no longer function correctly/application crashes. result.attached_context = result_context return result ## Delete all nodes containing mesh data in the scene. # \param only_selectable. Set this to False to delete objects from all build plates @pyqtSlot() def deleteAll(self, only_selectable = True) -> None: Logger.log("i", "Clearing scene") if not self.getController().getToolsEnabled(): return nodes = [] for node in DepthFirstIterator(self.getController().getScene().getRoot()): #type: ignore #Ignore type error because iter() should get called automatically by Python syntax. if not isinstance(node, SceneNode): continue if (not node.getMeshData() and not node.callDecoration("getLayerData")) and not node.callDecoration("isGroup"): continue # Node that doesnt have a mesh and is not a group. if only_selectable and not node.isSelectable(): continue if not node.callDecoration("isSliceable") and not node.callDecoration("getLayerData") and not node.callDecoration("isGroup"): continue # Only remove nodes that are selectable. if node.getParent() and cast(SceneNode, node.getParent()).callDecoration("isGroup"): continue # Grouped nodes don't need resetting as their parent (the group) is resetted) nodes.append(node) if nodes: op = GroupedOperation() for node in nodes: op.addOperation(RemoveSceneNodeOperation(node)) # Reset the print information self.getController().getScene().sceneChanged.emit(node) op.push() Selection.clear() ## Get the MeshFileHandler of this application. def getMeshFileHandler(self) -> MeshFileHandler: return self._mesh_file_handler def getWorkspaceFileHandler(self) -> WorkspaceFileHandler: return self._workspace_file_handler @pyqtSlot(result = QObject) def getPackageManager(self) -> PackageManager: return self._package_manager ## Gets the instance of this application. # # This is just to further specify the type of Application.getInstance(). # \return The instance of this application. @classmethod def getInstance(cls, *args, **kwargs) -> "QtApplication": return cast(QtApplication, super().getInstance(**kwargs)) def _createSplashScreen(self) -> QSplashScreen: return QSplashScreen(QPixmap(Resources.getPath(Resources.Images, self.getApplicationName() + ".png"))) def _screenScaleFactor(self) -> float: # OSX handles sizes of dialogs behind our backs, but other platforms need # to know about the device pixel ratio if sys.platform == "darwin": return 1.0 else: # determine a device pixel ratio from font metrics, using the same logic as UM.Theme fontPixelRatio = QFontMetrics(QCoreApplication.instance().font()).ascent() / 11 # round the font pixel ratio to quarters fontPixelRatio = int(fontPixelRatio * 4) / 4 return fontPixelRatio
fig.canvas.draw() img = QImage(fig.canvas.buffer_rgba(), width, height, QImage.Format_ARGB32) plot_area = (left*width, top*height, (1-left-right)*width, (1-top-bottom)*height) return img, plot_area if __name__ == '__main__': from PyQt5.QtQml import QQmlApplicationEngine from PyQt5.QtWidgets import QApplication import sys app = QApplication(sys.argv) qmlRegisterType(MeasurementData, "org.dynalyzer", 1, 0, "MeasurementData"); qmlRegisterType(DifferenceAnalyzer, "org.dynalyzer", 1, 0, "DifferenceAnalyzer"); qmlRegisterType(SnapshotView, "org.dynalyzer", 1, 0, "SnapshotView"); qmlRegisterType(DifferenceOverlayImage, "org.dynalyzer", 1, 0, "DifferenceOverlayImage"); qmlRegisterType(AnalogSignalPlot, "org.dynalyzer", 1, 0, "AnalogSignalPlot"); qmlRegisterType(Exporter, "org.dynalyzer", 1, 0, "Exporter"); engine = QQmlApplicationEngine() if len(sys.argv) > 1: path = QUrl(sys.argv[1]) engine.rootContext().setContextProperty("loadpath", path) dir_path = os.path.dirname(__file__) engine.load(os.path.join(dir_path, 'dynalyzer.qml')) app.exec_()
loaded = pyqtSignal() error = pyqtSignal(str, arguments=["errorText"]) metaDataChanged = pyqtSignal() @pyqtProperty("QVariantMap", notify=metaDataChanged) def metaData(self): return self._metadata @pyqtProperty(str, notify=loaded) def definitionId(self): return self._definition_id signal.signal(signal.SIGINT, signal.SIG_DFL) file_name = None if len(sys.argv) > 1: file_name = sys.argv[1] del sys.argv[1] app = QApplication(sys.argv) engine = QQmlApplicationEngine() qmlRegisterType(DefinitionLoader, "Example", 1, 0, "DefinitionLoader") qmlRegisterType(DefinitionTreeModel.DefinitionTreeModel, "Example", 1, 0, "DefinitionTreeModel") if file_name: engine.rootContext().setContextProperty("open_file", QUrl.fromLocalFile(file_name)) engine.load(os.path.join(os.path.dirname(os.path.abspath(__file__)), "main.qml")) app.exec_()
class QtApplication(QApplication, Application): def __init__(self, **kwargs): plugin_path = "" if sys.platform == "win32": if hasattr(sys, "frozen"): plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins") Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path)) QCoreApplication.addLibraryPath(plugin_path) else: import site for dir in site.getsitepackages(): QCoreApplication.addLibraryPath(os.path.join(dir, "PyQt5", "plugins")) elif sys.platform == "darwin": plugin_path = os.path.join(Application.getInstallPrefix(), "Resources", "plugins") if plugin_path: Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path)) QCoreApplication.addLibraryPath(plugin_path) os.environ["QSG_RENDER_LOOP"] = "basic" super().__init__(sys.argv, **kwargs) self.setAttribute(Qt.AA_UseDesktopOpenGL) major_version, minor_version, profile = OpenGLContext.detectBestOpenGLVersion() if major_version is None and minor_version is None and profile is None: Logger.log("e", "Startup failed because OpenGL version probing has failed: tried to create a 2.0 and 4.1 context. Exiting") QMessageBox.critical(None, "Failed to probe OpenGL", "Could not probe OpenGL. This program requires OpenGL 2.0 or higher. Please check your video card drivers.") sys.exit(1) else: Logger.log("d", "Detected most suitable OpenGL context version: %s" % ( OpenGLContext.versionAsText(major_version, minor_version, profile))) OpenGLContext.setDefaultFormat(major_version, minor_version, profile = profile) self._plugins_loaded = False # Used to determine when it's safe to use the plug-ins. self._main_qml = "main.qml" self._engine = None self._renderer = None self._main_window = None self._theme = None self._shutting_down = False self._qml_import_paths = [] self._qml_import_paths.append(os.path.join(os.path.dirname(sys.executable), "qml")) self._qml_import_paths.append(os.path.join(Application.getInstallPrefix(), "Resources", "qml")) try: self._splash = self._createSplashScreen() except FileNotFoundError: self._splash = None else: self._splash.show() self.processEvents() signal.signal(signal.SIGINT, signal.SIG_DFL) # This is done here as a lot of plugins require a correct gl context. If you want to change the framework, # these checks need to be done in your <framework>Application.py class __init__(). i18n_catalog = i18nCatalog("uranium") self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins...")) self._loadPlugins() self.parseCommandLine() Logger.log("i", "Command line arguments: %s", self._parsed_command_line) self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins()) self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Updating configuration...")) upgraded = UM.VersionUpgradeManager.VersionUpgradeManager.getInstance().upgrade() if upgraded: # Preferences might have changed. Load them again. # Note that the language can't be updated, so that will always revert to English. preferences = Preferences.getInstance() try: preferences.readFromFile(Resources.getPath(Resources.Preferences, self._application_name + ".cfg")) except FileNotFoundError: pass self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences...")) try: file = Resources.getPath(Resources.Preferences, self.getApplicationName() + ".cfg") Preferences.getInstance().readFromFile(file) except FileNotFoundError: pass self.getApplicationName() Preferences.getInstance().addPreference("%s/recent_files" % self.getApplicationName(), "") self._recent_files = [] files = Preferences.getInstance().getValue("%s/recent_files" % self.getApplicationName()).split(";") for f in files: if not os.path.isfile(f): continue self._recent_files.append(QUrl.fromLocalFile(f)) JobQueue.getInstance().jobFinished.connect(self._onJobFinished) recentFilesChanged = pyqtSignal() @pyqtProperty("QVariantList", notify=recentFilesChanged) def recentFiles(self): return self._recent_files def _onJobFinished(self, job): if (not isinstance(job, ReadMeshJob) and not isinstance(job, ReadFileJob)) or not job.getResult(): return f = QUrl.fromLocalFile(job.getFileName()) if f in self._recent_files: self._recent_files.remove(f) self._recent_files.insert(0, f) if len(self._recent_files) > 10: del self._recent_files[10] pref = "" for path in self._recent_files: pref += path.toLocalFile() + ";" Preferences.getInstance().setValue("%s/recent_files" % self.getApplicationName(), pref) self.recentFilesChanged.emit() def run(self): pass def hideMessage(self, message): with self._message_lock: if message in self._visible_messages: self._visible_messages.remove(message) self.visibleMessageRemoved.emit(message) def showMessage(self, message): with self._message_lock: if message not in self._visible_messages: self._visible_messages.append(message) message.setTimer(QTimer()) self.visibleMessageAdded.emit(message) def setMainQml(self, path): self._main_qml = path def initializeEngine(self): # TODO: Document native/qml import trickery Bindings.register() self._engine = QQmlApplicationEngine() for path in self._qml_import_paths: self._engine.addImportPath(path) if not hasattr(sys, "frozen"): self._engine.addImportPath(os.path.join(os.path.dirname(__file__), "qml")) self._engine.rootContext().setContextProperty("QT_VERSION_STR", QT_VERSION_STR) self._engine.rootContext().setContextProperty("screenScaleFactor", self._screenScaleFactor()) self.registerObjects(self._engine) self._engine.load(self._main_qml) self.engineCreatedSignal.emit() engineCreatedSignal = Signal() def isShuttingDown(self): return self._shutting_down def registerObjects(self, engine): engine.rootContext().setContextProperty("PluginRegistry", PluginRegistry.getInstance()) def getRenderer(self): if not self._renderer: self._renderer = QtRenderer() return self._renderer @classmethod def addCommandLineOptions(self, parser): super().addCommandLineOptions(parser) parser.add_argument("--disable-textures", dest="disable-textures", action="store_true", default=False, help="Disable Qt texture loading as a workaround for certain crashes.") parser.add_argument("-qmljsdebugger", help="For Qt's QML debugger compatibility") mainWindowChanged = Signal() def getMainWindow(self): return self._main_window def setMainWindow(self, window): if window != self._main_window: self._main_window = window self.mainWindowChanged.emit() def getTheme(self, *args): if self._theme is None: if self._engine is None: Logger.log("e", "The theme cannot be accessed before the engine is initialised") return None self._theme = UM.Qt.Bindings.Theme.Theme.getInstance(self._engine) return self._theme # Handle a function that should be called later. def functionEvent(self, event): e = _QtFunctionEvent(event) QCoreApplication.postEvent(self, e) # Handle Qt events def event(self, event): if event.type() == _QtFunctionEvent.QtFunctionEvent: event._function_event.call() return True return super().event(event) def windowClosed(self): Logger.log("d", "Shutting down %s", self.getApplicationName()) self._shutting_down = True try: Preferences.getInstance().writeToFile(Resources.getStoragePath(Resources.Preferences, self.getApplicationName() + ".cfg")) except Exception as e: Logger.log("e", "Exception while saving preferences: %s", repr(e)) try: self.applicationShuttingDown.emit() except Exception as e: Logger.log("e", "Exception while emitting shutdown signal: %s", repr(e)) try: self.getBackend().close() except Exception as e: Logger.log("e", "Exception while closing backend: %s", repr(e)) self.quit() ## Get the backend of the application (the program that does the heavy lifting). # The backend is also a QObject, which can be used from qml. # \returns Backend \type{Backend} @pyqtSlot(result="QObject*") def getBackend(self): return self._backend ## Load a Qt translation catalog. # # This method will locate, load and install a Qt message catalog that can be used # by Qt's translation system, like qsTr() in QML files. # # \param file The file name to load, without extension. It will be searched for in # the i18nLocation Resources directory. If it can not be found a warning # will be logged but no error will be thrown. # \param language The language to load translations for. This can be any valid language code # or 'default' in which case the language is looked up based on system locale. # If the specified language can not be found, this method will fall back to # loading the english translations file. # # \note When `language` is `default`, the language to load can be changed with the # environment variable "LANGUAGE". def loadQtTranslation(self, file, language = "default"): # TODO Add support for specifying a language from preferences path = None if language == "default": path = self._getDefaultLanguage(file) else: path = Resources.getPath(Resources.i18n, language, "LC_MESSAGES", file + ".qm") # If all else fails, fall back to english. if not path: Logger.log("w", "Could not find any translations matching {0} for file {1}, falling back to english".format(language, file)) try: path = Resources.getPath(Resources.i18n, "en", "LC_MESSAGES", file + ".qm") except FileNotFoundError: Logger.log("w", "Could not find English translations for file {0}. Switching to developer english.".format(file)) return translator = QTranslator() if not translator.load(path): Logger.log("e", "Unable to load translations %s", file) return # Store a reference to the translator. # This prevents the translator from being destroyed before Qt has a chance to use it. self._translators[file] = translator # Finally, install the translator so Qt can use it. self.installTranslator(translator) ## Display text on the splash screen. def showSplashMessage(self, message): if self._splash: self._splash.showMessage(message , Qt.AlignHCenter | Qt.AlignVCenter) self.processEvents() ## Close the splash screen after the application has started. def closeSplash(self): if self._splash: self._splash.close() self._splash = None def _createSplashScreen(self): return QSplashScreen(QPixmap(Resources.getPath(Resources.Images, self.getApplicationName() + ".png"))) def _screenScaleFactor(self): physical_dpi = QGuiApplication.primaryScreen().physicalDotsPerInch() # Typically 'normal' screens have a DPI around 96. Modern high DPI screens are up around 220. # We scale the low DPI screens with a traditional 1, and double the high DPI ones. return 1.0 if physical_dpi < 150 else 2.0 def _getDefaultLanguage(self, file): # If we have a language override set in the environment, try and use that. lang = os.getenv("URANIUM_LANGUAGE") if lang: try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # Else, try and get the current language from preferences lang = Preferences.getInstance().getValue("general/language") if lang: try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # If none of those are set, try to use the environment's LANGUAGE variable. lang = os.getenv("LANGUAGE") if lang: try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # If looking up the language from the enviroment or preferences fails, try and use Qt's system locale instead. locale = QLocale.system() # First, try and find a directory for any of the provided languages for lang in locale.uiLanguages(): try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # If that fails, see if we can extract a language "class" from the # preferred language. This will turn "en-GB" into "en" for example. lang = locale.uiLanguages()[0] lang = lang[0:lang.find("-")] try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass return None
import sys import os from PyQt5.QtWidgets import QApplication from PyQt5.QtCore import QUrl from PyQt5.QtQml import QQmlComponent, QQmlApplicationEngine from PyQt5.QtQuick import QQuickWindow from view_model import ViewModel if __name__ == '__main__': myApp = QApplication(sys.argv) engine = QQmlApplicationEngine() context = engine.rootContext() 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) component = QQmlComponent(engine) component.loadUrl(QUrl('mainwindow.qml')) # some boilerplate to make sure the component is ready before showing if component.status() != QQmlComponent.Ready: if component.status() == QQmlComponent.Error: sys.exit(component.errorString())
from PyQt5.QtQml import QQmlApplicationEngine from PyQt5.QtCore import QUrl from PyQt5.QtQml import qmlRegisterType from PyQt5.QtWidgets import QApplication from mvc_control.controller import Controller import sys, signal from mvc_view.FFDScene import FFDScene from util.util import filter_for_speed __author__ = 'ac' # logging.basicConfig(level=logging.DEBUG) app = QApplication(sys.argv) signal.signal(signal.SIGINT, signal.SIG_DFL) qmlRegisterType(FFDScene, 'FFD', 1, 0, "FFDScene") # controller = Controller() engine = QQmlApplicationEngine() engine.load(QUrl(filter_for_speed(file_name='res/ui/main.qml'))) scene = engine.rootObjects()[0].findChild(FFDScene, 'scene') controller = scene.controller # type: Controller engine.rootContext().setContextProperty('controller', controller) # print('main thread:', threading.current_thread().ident) # app.exec() sys.exit(app.exec())
window = engine.rootObjects()[0] myObject = window.findChild(QObject, "myObject") #loop.call_soon(myObject.funcRetClicked()) #myObject.funcRetClicked() loop.run_in_executor(exec, myObject.funcRetClicked) ''' with loop: try: test = Test() service = Service(loop) #loop.run_forever() print('1') # rootObjects 실행전 context를 선언/추가해줍니다. ctx = engine.rootContext() ctx.setContextProperty('Service', service) #engine.load("main.qml") engine.load("qml/tytrader.qml") window = engine.rootObjects()[0] #window.setContextProperty('Service', service) loop.run_until_complete(test.printInterval()) loop.run_forever() except: pass
class Application(QApplication): """Main Nuxeo Drive application controlled by a system tray icon + menu""" icon = QIcon(str(find_icon("app_icon.svg"))) icons: Dict[str, QIcon] = {} icon_state = None use_light_icons = None filters_dlg: Optional[FiltersDialog] = None _delegator: Optional["NotificationDelegator"] = None tray_icon: DriveSystrayIcon def __init__(self, manager: "Manager", *args: Any) -> None: super().__init__(list(*args)) self.manager = manager self.osi = self.manager.osi self.setWindowIcon(self.icon) self.setApplicationName(APP_NAME) self._init_translator() self.setQuitOnLastWindowClosed(False) self.ask_for_metrics_approval() self._conflicts_modals: Dict[str, bool] = dict() self.current_notification: Optional[Notification] = None self.default_tooltip = APP_NAME font = QFont("Helvetica, Arial, sans-serif", 12) self.setFont(font) self.ratio = sqrt(QFontMetricsF(font).height() / 12) self.init_gui() self.manager.dropEngine.connect(self.dropped_engine) self.setup_systray() self.manager.reloadIconsSet.connect(self.load_icons_set) # Direct Edit self.manager.direct_edit.directEditConflict.connect(self._direct_edit_conflict) self.manager.direct_edit.directEditError.connect(self._direct_edit_error) # Check if actions is required, separate method so it can be overridden self.init_checks() # Setup notification center for macOS if MAC: self._setup_notification_center() # Application update self.manager.updater.appUpdated.connect(self.quit) self.manager.updater.serverIncompatible.connect(self._server_incompatible) self.manager.updater.wrongChannel.connect(self._wrong_channel) # Display release notes on new version if self.manager.old_version != self.manager.version: self.show_release_notes(self.manager.version) # Listen for nxdrive:// sent by a new instance self.init_nxdrive_listener() # Connect this slot last so the other slots connected # to self.aboutToQuit can run beforehand. self.aboutToQuit.connect(self.manager.stop) @if_frozen def add_qml_import_path(self, view: QQuickView) -> None: """ Manually set the path to the QML folder to fix errors with unicode paths. This is needed only on Windows when packaged with Nuitka. """ if Options.freezer != "nuitka": return qml_dir = Options.res_dir.parent / "PyQt5" / "Qt" / "qml" log.debug(f"Setting QML import path for {view} to {qml_dir!r}") view.engine().addImportPath(str(qml_dir)) def init_gui(self) -> None: self.api = QMLDriveApi(self) self.conflicts_model = FileModel() self.errors_model = FileModel() self.engine_model = EngineModel(self) self.action_model = ActionModel() self.file_model = FileModel() self.ignoreds_model = FileModel() self.language_model = LanguageModel() self.add_engines(list(self.manager._engines.values())) self.engine_model.statusChanged.connect(self.update_status) self.language_model.addLanguages(Translator.languages()) flags = Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint if WINDOWS: self.conflicts_window = QQuickView() self.add_qml_import_path(self.conflicts_window) self.conflicts_window.setMinimumWidth(550) self.conflicts_window.setMinimumHeight(600) self.settings_window = QQuickView() self.add_qml_import_path(self.settings_window) self.settings_window.setMinimumWidth(640) self.settings_window.setMinimumHeight(520) self.systray_window = SystrayWindow() self.add_qml_import_path(self.systray_window) self._fill_qml_context(self.conflicts_window.rootContext()) self._fill_qml_context(self.settings_window.rootContext()) self._fill_qml_context(self.systray_window.rootContext()) self.systray_window.rootContext().setContextProperty( "systrayWindow", self.systray_window ) self.conflicts_window.setSource( QUrl.fromLocalFile(str(find_resource("qml", "Conflicts.qml"))) ) self.settings_window.setSource( QUrl.fromLocalFile(str(find_resource("qml", "Settings.qml"))) ) self.systray_window.setSource( QUrl.fromLocalFile(str(find_resource("qml", "Systray.qml"))) ) flags |= Qt.Popup else: self.app_engine = QQmlApplicationEngine() self._fill_qml_context(self.app_engine.rootContext()) self.app_engine.load( QUrl.fromLocalFile(str(find_resource("qml", "Main.qml"))) ) root = self.app_engine.rootObjects()[0] self.conflicts_window = root.findChild(QQuickWindow, "conflictsWindow") self.settings_window = root.findChild(QQuickWindow, "settingsWindow") self.systray_window = root.findChild(SystrayWindow, "systrayWindow") if LINUX: flags |= Qt.Drawer self.systray_window.setFlags(flags) self.manager.newEngine.connect(self.add_engines) self.manager.initEngine.connect(self.add_engines) self.manager.dropEngine.connect(self.remove_engine) self._window_root(self.conflicts_window).changed.connect(self.refresh_conflicts) self._window_root(self.systray_window).appUpdate.connect(self.api.app_update) self._window_root(self.systray_window).getLastFiles.connect(self.get_last_files) self.api.setMessage.connect(self._window_root(self.settings_window).setMessage) if self.manager.get_engines(): current_uid = self.engine_model.engines_uid[0] self.get_last_files(current_uid) self.update_status(self.manager._engines[current_uid]) self.manager.updater.updateAvailable.connect( self._window_root(self.systray_window).updateAvailable ) self.manager.updater.updateProgress.connect( self._window_root(self.systray_window).updateProgress ) @pyqtSlot(Action) def action_started(self, action: Action) -> None: self.refresh_actions() @pyqtSlot(Action) def action_progressing(self, action: Action) -> None: self.action_model.set_progress(action.export()) @pyqtSlot(Action) def action_done(self, action: Action) -> None: self.refresh_actions() def add_engines(self, engines: Union[Engine, List[Engine]]) -> None: if not engines: return engines = engines if isinstance(engines, list) else [engines] for engine in engines: self.engine_model.addEngine(engine.uid) def remove_engine(self, uid: str) -> None: self.engine_model.removeEngine(uid) def _fill_qml_context(self, context: QQmlContext) -> None: """ Fill the context of a QML element with the necessary resources. """ context.setContextProperty("ConflictsModel", self.conflicts_model) context.setContextProperty("ErrorsModel", self.errors_model) context.setContextProperty("EngineModel", self.engine_model) context.setContextProperty("ActionModel", self.action_model) context.setContextProperty("FileModel", self.file_model) context.setContextProperty("IgnoredsModel", self.ignoreds_model) context.setContextProperty("languageModel", self.language_model) context.setContextProperty("api", self.api) context.setContextProperty("application", self) context.setContextProperty("currentLanguage", self.current_language()) context.setContextProperty("manager", self.manager) context.setContextProperty("osi", self.osi) context.setContextProperty("updater", self.manager.updater) context.setContextProperty("ratio", self.ratio) context.setContextProperty("update_check_delay", Options.update_check_delay) context.setContextProperty("isFrozen", Options.is_frozen) context.setContextProperty("WINDOWS", WINDOWS) context.setContextProperty("tl", Translator._singleton) context.setContextProperty( "nuxeoVersionText", f"{APP_NAME} {self.manager.version}" ) metrics = self.manager.get_metrics() versions = ( f'Python {metrics["python_version"]}, ' f'Qt {metrics["qt_version"]}, ' f'SIP {metrics["sip_version"]}' ) if Options.system_wide: versions += " [admin]" context.setContextProperty("modulesVersionText", versions) colors = { "darkBlue": "#1F28BF", "nuxeoBlue": "#0066FF", "lightBlue": "#00ADED", "teal": "#73D2CF", "purple": "#8400FF", "red": "#C02828", "orange": "#FF9E00", "darkGray": "#495055", "mediumGray": "#7F8284", "lightGray": "#BCBFBF", "lighterGray": "#F5F5F5", } for name, value in colors.items(): context.setContextProperty(name, value) def _window_root(self, window): if WINDOWS: return window.rootObject() return window def translate(self, message: str, values: List[Any] = None) -> str: return Translator.get(message, values) def _show_window(self, window: QWindow) -> None: window.show() window.raise_() window.requestActivate() def _init_translator(self) -> None: locale = Options.force_locale or Options.locale Translator(find_resource("i18n"), self.manager.get_config("locale", locale)) # Make sure that a language change changes external values like # the text in the contextual menu Translator.on_change(self._handle_language_change) # Trigger it now self.osi.register_contextual_menu() self.installTranslator(Translator._singleton) @pyqtSlot(str, Path, str) def _direct_edit_conflict(self, filename: str, ref: Path, digest: str) -> None: log.debug(f"Entering _direct_edit_conflict for {filename!r} / {ref!r}") try: if filename in self._conflicts_modals: log.debug(f"Filename already in _conflicts_modals: {filename!r}") return log.debug(f"Putting filename in _conflicts_modals: {filename!r}") self._conflicts_modals[filename] = True msg = QMessageBox() msg.setInformativeText( Translator.get("DIRECT_EDIT_CONFLICT_MESSAGE", [short_name(filename)]) ) overwrite = msg.addButton( Translator.get("DIRECT_EDIT_CONFLICT_OVERWRITE"), QMessageBox.AcceptRole ) msg.addButton(Translator.get("CANCEL"), QMessageBox.RejectRole) msg.setIcon(QMessageBox.Warning) msg.exec_() if msg.clickedButton() == overwrite: self.manager.direct_edit.force_update(ref, digest) del self._conflicts_modals[filename] except: log.exception( f"Error while displaying Direct Edit conflict modal dialog for {filename!r}" ) @pyqtSlot(str, list) def _direct_edit_error(self, message: str, values: List[str]) -> None: """ Display a simple Direct Edit error message. """ msg_text = self.translate(message, values) log.warning(f"DirectEdit error message: '{msg_text}', values={values}") msg = QMessageBox() msg.setWindowTitle(f"Direct Edit - {APP_NAME}") msg.setWindowIcon(self.icon) msg.setIcon(QMessageBox.Warning) msg.setTextFormat(Qt.RichText) msg.setText(msg_text) msg.exec_() @pyqtSlot() def _root_deleted(self) -> None: engine = self.sender() log.info(f"Root has been deleted for engine: {engine.uid}") msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setWindowIcon(self.icon) msg.setText(Translator.get("DRIVE_ROOT_DELETED", [engine.local_folder])) recreate = msg.addButton( Translator.get("DRIVE_ROOT_RECREATE"), QMessageBox.AcceptRole ) disconnect = msg.addButton( Translator.get("DRIVE_ROOT_DISCONNECT"), QMessageBox.RejectRole ) msg.exec_() res = msg.clickedButton() if res == disconnect: self.manager.unbind_engine(engine.uid) elif res == recreate: engine.reinit() engine.start() @pyqtSlot() def _no_space_left(self) -> None: msg = QMessageBox() msg.setIcon(QMessageBox.Warning) msg.setWindowIcon(self.icon) msg.setText(Translator.get("NO_SPACE_LEFT_ON_DEVICE")) msg.addButton(Translator.get("OK"), QMessageBox.AcceptRole) msg.exec_() @pyqtSlot(Path) def _root_moved(self, new_path: Path) -> None: engine = self.sender() log.info(f"Root has been moved for engine: {engine.uid} to {new_path!r}") info = [engine.local_folder, str(new_path)] msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setWindowIcon(self.icon) msg.setText(Translator.get("DRIVE_ROOT_MOVED", info)) move = msg.addButton( Translator.get("DRIVE_ROOT_UPDATE"), QMessageBox.AcceptRole ) recreate = msg.addButton( Translator.get("DRIVE_ROOT_RECREATE"), QMessageBox.AcceptRole ) disconnect = msg.addButton( Translator.get("DRIVE_ROOT_DISCONNECT"), QMessageBox.RejectRole ) msg.exec_() res = msg.clickedButton() if res == disconnect: self.manager.unbind_engine(engine.uid) elif res == recreate: engine.reinit() engine.start() elif res == move: engine.set_local_folder(new_path) engine.start() def confirm_deletion(self, path: Path) -> DelAction: msg = QMessageBox() msg.setIcon(QMessageBox.Question) msg.setWindowIcon(self.icon) cb = QCheckBox(Translator.get("DONT_ASK_AGAIN")) msg.setCheckBox(cb) mode = self.manager.get_deletion_behavior() unsync = None if mode is DelAction.DEL_SERVER: descr = "DELETION_BEHAVIOR_CONFIRM_DELETE" confirm_text = "DELETE_FOR_EVERYONE" unsync = msg.addButton( Translator.get("JUST_UNSYNC"), QMessageBox.RejectRole ) elif mode is DelAction.UNSYNC: descr = "DELETION_BEHAVIOR_CONFIRM_UNSYNC" confirm_text = "UNSYNC" msg.setText( Translator.get(descr, [str(path), Translator.get("SELECT_SYNC_FOLDERS")]) ) msg.addButton(Translator.get("CANCEL"), QMessageBox.RejectRole) confirm = msg.addButton(Translator.get(confirm_text), QMessageBox.AcceptRole) msg.exec_() res = msg.clickedButton() if cb.isChecked(): self.manager._dao.store_bool("show_deletion_prompt", False) if res == confirm: return mode if res == unsync: msg = QMessageBox() msg.setIcon(QMessageBox.Question) msg.setWindowIcon(self.icon) msg.setText(Translator.get("DELETION_BEHAVIOR_SWITCH")) msg.addButton(Translator.get("NO"), QMessageBox.RejectRole) confirm = msg.addButton(Translator.get("YES"), QMessageBox.AcceptRole) msg.exec_() res = msg.clickedButton() if res == confirm: self.manager.set_deletion_behavior(DelAction.UNSYNC) return DelAction.UNSYNC return DelAction.ROLLBACK @pyqtSlot(Path) def _doc_deleted(self, path: Path) -> None: engine: Engine = self.sender() mode = self.confirm_deletion(path) if mode is DelAction.ROLLBACK: # Re-sync the document engine.rollback_delete(path) else: # Delete or filter out the document engine.delete_doc(path, mode) @pyqtSlot(Path, Path) def _file_already_exists(self, oldpath: Path, newpath: Path) -> None: msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setWindowIcon(self.icon) msg.setText(Translator.get("FILE_ALREADY_EXISTS", values=[str(oldpath)])) replace = msg.addButton(Translator.get("REPLACE"), QMessageBox.AcceptRole) msg.addButton(Translator.get("CANCEL"), QMessageBox.RejectRole) msg.exec_() if msg.clickedButton() == replace: oldpath.unlink() normalize_event_filename(newpath) else: newpath.unlink() @pyqtSlot(object) def dropped_engine(self, engine: "Engine") -> None: # Update icon in case the engine dropped was syncing self.change_systray_icon() @pyqtSlot() def change_systray_icon(self) -> None: # Update status has the precedence over other ones if self.manager.updater.status not in ( UPDATE_STATUS_UNAVAILABLE_SITE, UPDATE_STATUS_UP_TO_DATE, ): self.set_icon_state("update") return syncing = conflict = False engines = self.manager.get_engines() invalid_credentials = paused = offline = True for engine in engines.values(): syncing |= engine.is_syncing() invalid_credentials &= engine.has_invalid_credentials() paused &= engine.is_paused() offline &= engine.is_offline() conflict |= bool(engine.get_conflicts()) if offline: new_state = "error" Action(Translator.get("OFFLINE")) elif invalid_credentials: new_state = "error" Action(Translator.get("AUTH_EXPIRED")) elif not engines: new_state = "disabled" Action.finish_action() elif paused: new_state = "paused" Action.finish_action() elif syncing: new_state = "syncing" elif conflict: new_state = "conflict" else: new_state = "idle" Action.finish_action() self.set_icon_state(new_state) def refresh_conflicts(self, uid: str) -> None: """ Update the content of the conflicts/errors window. """ self.conflicts_model.empty() self.errors_model.empty() self.ignoreds_model.empty() self.conflicts_model.addFiles(self.api.get_conflicts(uid)) self.errors_model.addFiles(self.api.get_errors(uid)) self.ignoreds_model.addFiles(self.api.get_unsynchronizeds(uid)) @pyqtSlot() def show_conflicts_resolution(self, engine: "Engine") -> None: """ Display the conflicts/errors window. """ self.refresh_conflicts(engine.uid) self._window_root(self.conflicts_window).setEngine.emit(engine.uid) self.conflicts_window.show() self.conflicts_window.requestActivate() @pyqtSlot() def show_settings(self, section: str = "General") -> None: sections = {"General": 0, "Accounts": 1, "About": 2} self._window_root(self.settings_window).setSection.emit(sections[section]) self.settings_window.show() self.settings_window.requestActivate() @pyqtSlot() def show_systray(self) -> None: icon = self.tray_icon.geometry() if not icon or icon.isEmpty(): # On Ubuntu it's likely we can't retrieve the geometry. # We're simply displaying the systray in the top right corner. screen = self.desktop().screenGeometry() pos_x = screen.right() - self.systray_window.width() - 20 pos_y = 30 else: dpi_ratio = self.primaryScreen().devicePixelRatio() if WINDOWS else 1 pos_x = max( 0, (icon.x() + icon.width()) / dpi_ratio - self.systray_window.width() ) pos_y = icon.y() / dpi_ratio - self.systray_window.height() if pos_y < 0: pos_y = (icon.y() + icon.height()) / dpi_ratio self.systray_window.setX(pos_x) self.systray_window.setY(pos_y) self.systray_window.show() self.systray_window.raise_() @pyqtSlot() def hide_systray(self): self.systray_window.hide() @pyqtSlot() def open_help(self) -> None: self.manager.open_help() @pyqtSlot() def destroyed_filters_dialog(self) -> None: self.filters_dlg = None @pyqtSlot() def show_filters(self, engine: "Engine") -> None: if self.filters_dlg: self.filters_dlg.close() self.filters_dlg = None self.filters_dlg = FiltersDialog(self, engine) self.filters_dlg.destroyed.connect(self.destroyed_filters_dialog) # Close the settings window at the same time of the filters one if hasattr(self, "close_settings_too"): self.filters_dlg.destroyed.connect(self.settings_window.close) delattr(self, "close_settings_too") self.filters_dlg.show() self._show_window(self.settings_window) @pyqtSlot(str, object) def _open_authentication_dialog( self, url: str, callback_params: Dict[str, str] ) -> None: self.api._callback_params = callback_params if Options.is_frozen: """ Authenticate through the browser. This authentication requires the server's Nuxeo Drive addon to include NXP-25519. Instead of opening the server's login page in a WebKit view through the app, it opens in the browser and retrieves the login token by opening an nxdrive:// URL. """ self.manager.open_local_file(url) else: self._web_auth_not_frozen(url) def _web_auth_not_frozen(self, url: str) -> None: """ Open a dialog box to fill the credentials. Then a request will be done using the Python client to get a token. This is used when the application is not frozen as there is no custom protocol handler in this case. """ from PyQt5.QtWidgets import QLineEdit from nuxeo.client import Nuxeo dialog = QDialog() dialog.setWindowTitle(self.translate("WEB_AUTHENTICATION_WINDOW_TITLE")) dialog.setWindowIcon(self.icon) dialog.resize(250, 100) layout = QVBoxLayout() username = QLineEdit("Administrator", parent=dialog) password = QLineEdit("Administrator", parent=dialog) password.setEchoMode(QLineEdit.Password) layout.addWidget(username) layout.addWidget(password) def auth() -> None: """Retrieve a token and create the account.""" user = str(username.text()) pwd = str(password.text()) nuxeo = Nuxeo( host=url, auth=(user, pwd), proxies=self.manager.proxy.settings(url=url), verify=Options.ca_bundle or not Options.ssl_no_verify, ) try: token = nuxeo.client.request_auth_token( device_id=self.manager.device_id, app_name=APP_NAME, permission=TOKEN_PERMISSION, device=get_device(), ) except Exception as exc: log.error(f"Connection error: {exc}") token = "" finally: del nuxeo # Check we have a token and not a HTML response if "\n" in token: token = "" self.api.handle_token(token, user) dialog.close() buttons = QDialogButtonBox() buttons.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) buttons.accepted.connect(auth) buttons.rejected.connect(dialog.close) layout.addWidget(buttons) dialog.setLayout(layout) dialog.exec_() @pyqtSlot(object) def _connect_engine(self, engine: "Engine") -> None: engine.syncStarted.connect(self.change_systray_icon) engine.syncCompleted.connect(self.change_systray_icon) engine.invalidAuthentication.connect(self.change_systray_icon) engine.syncSuspended.connect(self.change_systray_icon) engine.syncResumed.connect(self.change_systray_icon) engine.offline.connect(self.change_systray_icon) engine.online.connect(self.change_systray_icon) engine.rootDeleted.connect(self._root_deleted) engine.rootMoved.connect(self._root_moved) engine.docDeleted.connect(self._doc_deleted) engine.fileAlreadyExists.connect(self._file_already_exists) engine.noSpaceLeftOnDevice.connect(self._no_space_left) self.change_systray_icon() def init_checks(self) -> None: for engine in self.manager.get_engines().values(): self._connect_engine(engine) self.manager.newEngine.connect(self._connect_engine) self.manager.notification_service.newNotification.connect( self._new_notification ) self.manager.notification_service.triggerNotification.connect( self._handle_notification_action ) self.manager.updater.updateAvailable.connect(self._update_notification) self.manager.updater.noSpaceLeftOnDevice.connect(self._no_space_left) if not self.manager.get_engines(): self.show_settings() else: for engine in self.manager.get_engines().values(): # Prompt for settings if needed if engine.has_invalid_credentials(): self.show_settings("Accounts") # f"Account_{engine.uid}" break self.manager.start() @pyqtSlot() @if_frozen def _update_notification(self) -> None: self.change_systray_icon() # Display a notification status, version = self.manager.updater.status, self.manager.updater.version msg = ("AUTOUPDATE_UPGRADE", "AUTOUPDATE_DOWNGRADE")[ status == UPDATE_STATUS_INCOMPATIBLE_SERVER ] description = Translator.get(msg, [version]) flags = Notification.FLAG_BUBBLE | Notification.FLAG_UNIQUE if LINUX: description += " " + Translator.get("AUTOUPDATE_MANUAL") flags |= Notification.FLAG_SYSTRAY log.warning(description) notification = Notification( uuid="AutoUpdate", flags=flags, title=Translator.get("NOTIF_UPDATE_TITLE", [version]), description=description, ) self.manager.notification_service.send_notification(notification) @pyqtSlot() def _server_incompatible(self) -> None: version = self.manager.version downgrade_version = self.manager.updater.version or "" msg = QMessageBox() msg.setIcon(QMessageBox.Warning) msg.setWindowIcon(self.icon) msg.setText(Translator.get("SERVER_INCOMPATIBLE", [version, downgrade_version])) if downgrade_version: msg.addButton( Translator.get("CONTINUE_USING", [version]), QMessageBox.RejectRole ) downgrade = msg.addButton( Translator.get("DOWNGRADE_TO", [downgrade_version]), QMessageBox.AcceptRole, ) else: msg.addButton(Translator.get("CONTINUE"), QMessageBox.RejectRole) msg.exec_() res = msg.clickedButton() if downgrade_version and res == downgrade: self.manager.updater.update(downgrade_version) @pyqtSlot() def _wrong_channel(self) -> None: if self.manager.prompted_wrong_channel: log.debug( "Not prompting for wrong channel, already showed it since startup" ) return self.manager.prompted_wrong_channel = True version = self.manager.version downgrade_version = self.manager.updater.version or "" version_channel = self.manager.updater.get_version_channel(version) current_channel = self.manager.get_update_channel() msg = QMessageBox() msg.setIcon(QMessageBox.Warning) msg.setWindowIcon(self.icon) msg.setText( Translator.get("WRONG_CHANNEL", [version, version_channel, current_channel]) ) switch_channel = msg.addButton( Translator.get("USE_CHANNEL", [version_channel]), QMessageBox.AcceptRole ) downgrade = msg.addButton( Translator.get("DOWNGRADE_TO", [downgrade_version]), QMessageBox.AcceptRole ) msg.exec_() res = msg.clickedButton() if downgrade_version and res == downgrade: self.manager.updater.update(downgrade_version) elif res == switch_channel: self.manager.set_update_channel(version_channel) @pyqtSlot() def message_clicked(self) -> None: if self.current_notification: self.manager.notification_service.trigger_notification( self.current_notification.uid ) def _setup_notification_center(self) -> None: if not self._delegator: self._delegator = NotificationDelegator.alloc().init() if self._delegator: self._delegator._manager = self.manager setup_delegator(self._delegator) @pyqtSlot(object) def _new_notification(self, notif: Notification) -> None: if not notif.is_bubble(): return if self._delegator is not None: # Use notification center from ..osi.darwin.pyNotificationCenter import notify user_info = {"uuid": notif.uid} if notif.uid else None return notify(notif.title, "", notif.description, user_info=user_info) icon = QSystemTrayIcon.Information if notif.level == Notification.LEVEL_WARNING: icon = QSystemTrayIcon.Warning elif notif.level == Notification.LEVEL_ERROR: icon = QSystemTrayIcon.Critical self.current_notification = notif self.tray_icon.showMessage(notif.title, notif.description, icon, 10000) @pyqtSlot(str, str) def _handle_notification_action(self, action: str, engine_uid: str) -> None: func = getattr(self.api, action, None) if not func: log.error(f"Action {action}() is not defined in {self.api}") return func(engine_uid) def set_icon_state(self, state: str, force: bool = False) -> bool: """ Execute systray icon change operations triggered by state change. The synchronization thread can update the state info but cannot directly call QtGui widget methods. This should be executed by the main thread event loop, hence the delegation to this method that is triggered by a signal to allow for message passing between the 2 threads. Return True of the icon has changed state or if force is True. """ if not force and self.icon_state == state: # Nothing to update return False self.tray_icon.setToolTip(self.get_tooltip()) self.tray_icon.setIcon(self.icons[state]) self.icon_state = state return True def get_tooltip(self) -> str: actions = Action.get_actions() if not actions: return self.default_tooltip # Display only the first action for now for action in actions.values(): if action and action.type and not action.type.startswith("_"): break else: return self.default_tooltip return f"{self.default_tooltip} - {action!r}" @if_frozen def show_release_notes(self, version: str) -> None: """ Display release notes of a given version. """ channel = self.manager.get_update_channel() log.info(f"Showing release notes, version={version!r} channel={channel}") # For now, we do care about beta only if channel != "beta": return url = ( "https://api.github.com/repos/nuxeo/nuxeo-drive" f"/releases/tags/release-{version}" ) if channel != "release": version += f" {channel}" try: # No need for the `verify` kwarg here as GitHub will never use a bad certificate. with requests.get(url) as resp: data = resp.json() html = markdown(data["body"]) except Exception: log.warning(f"[{version}] Release notes retrieval error") return dialog = QDialog() dialog.setWindowTitle(f"{APP_NAME} {version} - Release notes") dialog.setWindowIcon(self.icon) dialog.resize(600, 400) notes = QTextEdit() notes.setStyleSheet("background-color: #eee; border: none;") notes.setReadOnly(True) notes.setHtml(html) buttons = QDialogButtonBox() buttons.setStandardButtons(QDialogButtonBox.Ok) buttons.clicked.connect(dialog.accept) layout = QVBoxLayout() layout.addWidget(notes) layout.addWidget(buttons) dialog.setLayout(layout) dialog.exec_() def accept_unofficial_ssl_cert(self, hostname: str) -> bool: """Ask the user to bypass the SSL certificate verification.""" from ..utils import get_certificate_details def signature(sig: str) -> str: """ Format the certificate signature. >>> signature("0F4019D1E6C52EF9A3A929B6D5613816") 0f:40:19:d1:e6:c5:2e:f9:a3:a9:29:b6:d5:61:38:16 """ from textwrap import wrap return str.lower(":".join(wrap(sig, 2))) cert = get_certificate_details(hostname=hostname) if not cert: return False subject = [ f"<li>{details[0][0]}: {details[0][1]}</li>" for details in sorted(cert["subject"]) ] issuer = [ f"<li>{details[0][0]}: {details[0][1]}</li>" for details in sorted(cert["issuer"]) ] urls = [ f"<li><a href='{details}'>{details}</a></li>" for details in cert["caIssuers"] ] sig = f"<code><small>{signature(cert['serialNumber'])}</small></code>" message = f""" <h2>{Translator.get("SSL_CANNOT_CONNECT", [hostname])}</h2> <p style="color:red">{Translator.get("SSL_HOSTNAME_ERROR")}</p> <h2>{Translator.get("SSL_CERTIFICATE")}</h2> <ul> {"".join(subject)} <li style="margin-top: 10px;">{Translator.get("SSL_SERIAL_NUMBER")} {sig}</li> <li style="margin-top: 10px;">{Translator.get("SSL_DATE_FROM")} {cert["notBefore"]}</li> <li>{Translator.get("SSL_DATE_EXPIRATION")} {cert["notAfter"]}</li> </ul> <h2>{Translator.get("SSL_ISSUER")}</h2> <ul style="list-style-type:square;">{"".join(issuer)}</ul> <h2>{Translator.get("URL")}</h2> <ul>{"".join(urls)}</ul> """ dialog = QDialog() dialog.setWindowTitle(Translator.get("SSL_UNTRUSTED_CERT_TITLE")) dialog.setWindowIcon(self.icon) dialog.resize(600, 650) notes = QTextEdit() notes.setReadOnly(True) notes.setHtml(message) continue_with_bad_ssl_cert = False def accept() -> None: nonlocal continue_with_bad_ssl_cert continue_with_bad_ssl_cert = True dialog.accept() buttons = QDialogButtonBox() buttons.setStandardButtons(QDialogButtonBox.Ok | QDialogButtonBox.Cancel) buttons.button(QDialogButtonBox.Ok).setEnabled(False) buttons.accepted.connect(accept) buttons.rejected.connect(dialog.close) def bypass_triggered(state: int) -> None: """Enable the OK button only when the checkbox is checked.""" buttons.button(QDialogButtonBox.Ok).setEnabled(bool(state)) bypass = QCheckBox(Translator.get("SSL_TRUST_ANYWAY")) bypass.stateChanged.connect(bypass_triggered) layout = QVBoxLayout() layout.addWidget(notes) layout.addWidget(bypass) layout.addWidget(buttons) dialog.setLayout(layout) dialog.exec_() return continue_with_bad_ssl_cert def show_metadata(self, path: Path) -> None: self.manager.ctx_edit_metadata(path) @pyqtSlot(bool) def load_icons_set(self, use_light_icons: bool = False) -> None: """Load a given icons set (either the default one "dark", or the light one).""" if self.use_light_icons is use_light_icons: return suffix = ("", "_light")[use_light_icons] mask = str(find_icon("active.svg")) # Icon mask for macOS for state in { "conflict", "disabled", "error", "idle", "notification", "paused", "syncing", "update", }: icon = QIcon() icon.addFile(str(find_icon(f"{state}{suffix}.svg"))) if MAC: icon.addFile(mask, mode=QIcon.Selected) self.icons[state] = icon self.use_light_icons = use_light_icons self.manager.set_config("light_icons", use_light_icons) # Reload the current showed icon if self.icon_state: self.set_icon_state(self.icon_state, force=True) def initial_icons_set(self) -> bool: """ Try to guess the most appropriate icons set at start. The user will still have the possibility to change that in Settings. """ use_light_icons = self.manager.get_config("light_icons", default=None) if use_light_icons is None: # Default value for GNU/Linux, macOS ans Windows 7 use_light_icons = False if WINDOWS: win_ver = sys.getwindowsversion() version = (win_ver.major, win_ver.minor) if version > (6, 1): # Windows 7 # Windows 8+ has a dark them by default use_light_icons = True else: # The value stored in DTB as a string '0' or '1', convert to boolean use_light_icons = bool(int(use_light_icons)) return use_light_icons def setup_systray(self) -> None: """Setup the icon system tray and its associated menu.""" self.load_icons_set(use_light_icons=self.initial_icons_set()) self.tray_icon = DriveSystrayIcon(self) if not self.tray_icon.isSystemTrayAvailable(): log.critical("There is no system tray available!") else: self.tray_icon.setToolTip(APP_NAME) self.set_icon_state("disabled") self.tray_icon.show() def _handle_language_change(self) -> None: self.manager.set_config("locale", Translator.locale()) if not MAC: self.tray_icon.setContextMenu(self.tray_icon.get_context_menu()) self.osi.register_contextual_menu() def event(self, event: QEvent) -> bool: """ Handle URL scheme events under macOS. """ url = getattr(event, "url", None) if not url: # This is not an event for us! return super().event(event) final_url = unquote(event.url().toString()) try: return self._handle_nxdrive_url(final_url) except: log.exception(f"Error handling URL event {final_url!r}") return False def _show_msgbox_restart_needed(self) -> None: msg = QMessageBox() msg.setIcon(QMessageBox.Information) msg.setText(Translator.get("RESTART_NEEDED_MSG", values=[APP_NAME])) msg.setWindowTitle(APP_NAME) msg.addButton(Translator.get("OK"), QMessageBox.AcceptRole) msg.exec_() def _handle_nxdrive_url(self, url: str) -> bool: """ Handle an nxdrive protocol URL. """ info = parse_protocol_url(url) if not info: return False cmd = info["command"] path = normalized_path(info.get("filepath", "")) manager = self.manager log.info(f"Event URL={url}, info={info!r}") # Event fired by a context menu item func = { "access-online": manager.ctx_access_online, "copy-share-link": manager.ctx_copy_share_link, "edit-metadata": manager.ctx_edit_metadata, }.get(cmd, None) if func: func(path) elif "edit" in cmd: if self.manager.restart_needed: self._show_msgbox_restart_needed() return False manager.direct_edit.edit( info["server_url"], info["doc_id"], user=info["user"], download_url=info["download_url"], ) elif cmd == "token": self.api.handle_token(info["token"], info["username"]) else: log.warning(f"Unknown event URL={url}, info={info!r}") return False return True def init_nxdrive_listener(self) -> None: """ Set up a QLocalServer to listen to nxdrive protocol calls. On Windows, when an nxdrive:// URL is opened, it creates a new instance of Nuxeo Drive. As we want the already running instance to receive this call (particularly during the login process), we set up a QLocalServer in that instance to listen to the new ones who will send their data. The Qt implementation of QLocalSocket on Windows makes use of named pipes. We just need to connect a handler to the newConnection signal to process the URLs. """ named_pipe = f"{BUNDLE_IDENTIFIER}.protocol.{os.getpid()}" server = QLocalServer() server.setSocketOptions(QLocalServer.WorldAccessOption) server.newConnection.connect(self._handle_connection) try: server.listen(named_pipe) log.info(f"Listening for nxdrive:// calls on {server.fullServerName()}") except: log.info( f"Unable to start local server on {named_pipe}: {server.errorString()}" ) self._nxdrive_listener = server self.aboutToQuit.connect(self._nxdrive_listener.close) def _handle_connection(self) -> None: """ Retrieve the connection with other instances and handle the incoming data. """ con: QLocalSocket = None try: con = self._nxdrive_listener.nextPendingConnection() log.info("Receiving socket connection for nxdrive protocol handling") if not con or not con.waitForConnected(): log.error(f"Unable to open server socket: {con.errorString()}") return if con.waitForReadyRead(): payload = con.readAll() url = force_decode(payload.data()) self._handle_nxdrive_url(url) con.disconnectFromServer() if con.state() == QLocalSocket.ConnectedState: con.waitForDisconnected() finally: del con log.info("Successfully closed server socket") def update_status(self, engine: "Engine") -> None: """ Update the systray status for synchronization, conflicts/errors and software updates. """ sync_state = error_state = update_state = "" update_state = self.manager.updater.status self.refresh_conflicts(engine.uid) # Check synchronization state if self.manager.restart_needed: sync_state = "restart" elif engine.is_paused(): sync_state = "suspended" elif engine.is_syncing(): sync_state = "syncing" # Check error state if engine.has_invalid_credentials(): error_state = "auth_expired" elif self.conflicts_model.count: error_state = "conflicted" elif self.errors_model.count: error_state = "error" self._window_root(self.systray_window).setStatus.emit( sync_state, error_state, update_state ) @pyqtSlot() def refresh_actions(self) -> None: actions = self.api.get_actions() if actions != self.action_model.actions: self.action_model.set_actions(actions) self.action_model.fileChanged.emit() @pyqtSlot(str) def get_last_files(self, uid: str) -> None: files = self.api.get_last_files(uid, 10, "") if files != self.file_model.files: self.file_model.empty() self.file_model.addFiles(files) self.file_model.fileChanged.emit() def current_language(self) -> Optional[str]: lang = Translator.locale() for tag, name in self.language_model.languages: if tag == lang: return name return None def show_metrics_acceptance(self) -> None: """ Display a "friendly" dialog box to ask user for metrics approval. """ tr = Translator.get dialog = QDialog() dialog.setWindowTitle(tr("SHARE_METRICS_TITLE", [APP_NAME])) dialog.setWindowIcon(self.icon) dialog.setStyleSheet("background-color: #ffffff;") layout = QVBoxLayout() info = QLabel(tr("SHARE_METRICS_MSG", [COMPANY])) info.setTextFormat(Qt.RichText) info.setWordWrap(True) layout.addWidget(info) def analytics_choice(state) -> None: Options.use_analytics = bool(state) def errors_choice(state) -> None: Options.use_sentry = bool(state) # Checkboxes em_analytics = QCheckBox(tr("SHARE_METRICS_ERROR_REPORTING")) em_analytics.setChecked(True) em_analytics.stateChanged.connect(errors_choice) layout.addWidget(em_analytics) cb_analytics = QCheckBox(tr("SHARE_METRICS_ANALYTICS")) cb_analytics.stateChanged.connect(analytics_choice) layout.addWidget(cb_analytics) # Buttons buttons = QDialogButtonBox() buttons.setStandardButtons(QDialogButtonBox.Apply) buttons.clicked.connect(dialog.close) layout.addWidget(buttons) dialog.setLayout(layout) dialog.resize(400, 200) dialog.show() dialog.exec_() states = [] if Options.use_analytics: states.append("analytics") if Options.use_sentry: states.append("sentry") (Options.nxdrive_home / "metrics.state").write_text("\n".join(states)) def ask_for_metrics_approval(self) -> None: """Should we setup and use Sentry and/or Google Analytics?""" # Check the user choice first Options.nxdrive_home.mkdir(parents=True, exist_ok=True) STATE_FILE = Options.nxdrive_home / "metrics.state" if STATE_FILE.is_file(): lines = STATE_FILE.read_text().splitlines() Options.use_sentry = "sentry" in lines Options.use_analytics = "analytics" in lines # Abort now, the user already decided to use Sentry or not return # The user did not choose yet, display a message box self.show_metrics_acceptance()
class QtApplication(QApplication, Application): def __init__(self, **kwargs): plugin_path = "" if sys.platform == "win32": if hasattr(sys, "frozen"): plugin_path = os.path.join(os.path.dirname(os.path.abspath(sys.executable)), "PyQt5", "plugins") Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path)) QCoreApplication.addLibraryPath(plugin_path) else: import site for dir in site.getsitepackages(): QCoreApplication.addLibraryPath(os.path.join(dir, "PyQt5", "plugins")) elif sys.platform == "darwin": plugin_path = os.path.join(Application.getInstallPrefix(), "Resources", "plugins") if plugin_path: Logger.log("i", "Adding QT5 plugin path: %s" % (plugin_path)) QCoreApplication.addLibraryPath(plugin_path) os.environ["QSG_RENDER_LOOP"] = "basic" super().__init__(sys.argv, **kwargs) self._plugins_loaded = False #Used to determine when it's safe to use the plug-ins. self._main_qml = "main.qml" self._engine = None self._renderer = None self._main_window = None self._shutting_down = False self._qml_import_paths = [] self._qml_import_paths.append(os.path.join(os.path.dirname(sys.executable), "qml")) self._qml_import_paths.append(os.path.join(Application.getInstallPrefix(), "Resources", "qml")) self.setAttribute(Qt.AA_UseDesktopOpenGL) try: self._splash = self._createSplashScreen() except FileNotFoundError: self._splash = None else: self._splash.show() self.processEvents() signal.signal(signal.SIGINT, signal.SIG_DFL) # This is done here as a lot of plugins require a correct gl context. If you want to change the framework, # these checks need to be done in your <framework>Application.py class __init__(). i18n_catalog = i18nCatalog("uranium") self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading plugins...")) self._loadPlugins() self.parseCommandLine() Logger.log("i", "Command line arguments: %s", self._parsed_command_line) self._plugin_registry.checkRequiredPlugins(self.getRequiredPlugins()) if self._version_upgrade_manager: self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Updating configuration...")) upgraded = self._version_upgrade_manager.upgrade() if upgraded: preferences = UM.Preferences.getInstance() #Preferences might have changed. Load them again. #Note that the language can't be updated, so that will always revert to English. try: preferences.readFromFile(Resources.getPath(Resources.Preferences, self._application_name + ".cfg")) except FileNotFoundError: pass self.showSplashMessage(i18n_catalog.i18nc("@info:progress", "Loading preferences...")) try: file = Resources.getPath(Resources.Preferences, self.getApplicationName() + ".cfg") Preferences.getInstance().readFromFile(file) except FileNotFoundError: pass def run(self): pass def hideMessage(self, message): with self._message_lock: if message in self._visible_messages: self._visible_messages.remove(message) self.visibleMessageRemoved.emit(message) def showMessage(self, message): with self._message_lock: if message not in self._visible_messages: self._visible_messages.append(message) message.setTimer(QTimer()) self.visibleMessageAdded.emit(message) def setMainQml(self, path): self._main_qml = path def initializeEngine(self): # TODO: Document native/qml import trickery Bindings.register() self._engine = QQmlApplicationEngine() for path in self._qml_import_paths: self._engine.addImportPath(path) if not hasattr(sys, "frozen"): self._engine.addImportPath(os.path.join(os.path.dirname(__file__), "qml")) self._engine.rootContext().setContextProperty("QT_VERSION_STR", QT_VERSION_STR) self.registerObjects(self._engine) self._engine.load(self._main_qml) self.engineCreatedSignal.emit() engineCreatedSignal = Signal() def isShuttingDown(self): return self._shutting_down def registerObjects(self, engine): pass def getRenderer(self): if not self._renderer: self._renderer = QtRenderer() return self._renderer def addCommandLineOptions(self, parser): parser.add_argument("--disable-textures", dest="disable-textures", action="store_true", default=False, help="Disable Qt texture loading as a workaround for certain crashes.") # Overridden from QApplication::setApplicationName to call our internal setApplicationName def setApplicationName(self, name): Application.setApplicationName(self, name) mainWindowChanged = Signal() def getMainWindow(self): return self._main_window def setMainWindow(self, window): if window != self._main_window: self._main_window = window self.mainWindowChanged.emit() # Handle a function that should be called later. def functionEvent(self, event): e = _QtFunctionEvent(event) QCoreApplication.postEvent(self, e) # Handle Qt events def event(self, event): if event.type() == _QtFunctionEvent.QtFunctionEvent: event._function_event.call() return True return super().event(event) def windowClosed(self): Logger.log("d", "Shutting down %s", self.getApplicationName()) self._shutting_down = True try: Preferences.getInstance().writeToFile(Resources.getStoragePath(Resources.Preferences, self.getApplicationName() + ".cfg")) except Exception as e: Logger.log("e", "Exception while saving preferences: %s", repr(e)) try: self.applicationShuttingDown.emit() except Exception as e: Logger.log("e", "Exception while emitting shutdown signal: %s", repr(e)) try: self.getBackend().close() except Exception as e: Logger.log("e", "Exception while closing backend: %s", repr(e)) self.quit() ## Load a Qt translation catalog. # # This method will locate, load and install a Qt message catalog that can be used # by Qt's translation system, like qsTr() in QML files. # # \param file The file name to load, without extension. It will be searched for in # the i18nLocation Resources directory. If it can not be found a warning # will be logged but no error will be thrown. # \param language The language to load translations for. This can be any valid language code # or 'default' in which case the language is looked up based on system locale. # If the specified language can not be found, this method will fall back to # loading the english translations file. # # \note When `language` is `default`, the language to load can be changed with the # environment variable "LANGUAGE". def loadQtTranslation(self, file, language = "default"): #TODO Add support for specifying a language from preferences path = None if language == "default": path = self._getDefaultLanguage(file) else: path = Resources.getPath(Resources.i18n, language, "LC_MESSAGES", file + ".qm") # If all else fails, fall back to english. if not path: Logger.log("w", "Could not find any translations matching {0} for file {1}, falling back to english".format(language, file)) try: path = Resources.getPath(Resources.i18n, "en", "LC_MESSAGES", file + ".qm") except FileNotFoundError: Logger.log("w", "Could not find English translations for file {0}. Switching to developer english.".format(file)) return translator = QTranslator() if not translator.load(path): Logger.log("e", "Unable to load translations %s", file) return # Store a reference to the translator. # This prevents the translator from being destroyed before Qt has a chance to use it. self._translators[file] = translator # Finally, install the translator so Qt can use it. self.installTranslator(translator) ## Display text on the splash screen. def showSplashMessage(self, message): if self._splash: self._splash.showMessage(message , Qt.AlignHCenter | Qt.AlignVCenter) self.processEvents() ## Close the splash screen after the application has started. def closeSplash(self): if self._splash: self._splash.close() self._splash = None def _createSplashScreen(self): return QSplashScreen(QPixmap(Resources.getPath(Resources.Images, self.getApplicationName() + ".png"))) def _getDefaultLanguage(self, file): # If we have a language override set in the environment, try and use that. lang = os.getenv("URANIUM_LANGUAGE") if lang: try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # Else, try and get the current language from preferences lang = Preferences.getInstance().getValue("general/language") if lang: try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # If none of those are set, try to use the environment's LANGUAGE variable. lang = os.getenv("LANGUAGE") if lang: try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # If looking up the language from the enviroment or preferences fails, try and use Qt's system locale instead. locale = QLocale.system() # First, try and find a directory for any of the provided languages for lang in locale.uiLanguages(): try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass # If that fails, see if we can extract a language "class" from the # preferred language. This will turn "en-GB" into "en" for example. lang = locale.uiLanguages()[0] lang = lang[0:lang.find("-")] try: return Resources.getPath(Resources.i18n, lang, "LC_MESSAGES", file + ".qm") except FileNotFoundError: pass return None
# pandas model test import pandas as pd df = pd.DataFrame(columns=('code', 'name')) model = PandasModel(df) print(model.headerData(0, QtCore.Qt.Horizontal, QtCore.Qt.DisplayRole)) print("%s %s" % (id(df), id(model._dataFrame()))) print("before append model length %s" %(len(model))) df.loc[len(df)] = ['1', '1111'] df.loc[len(df)] = ['2', '2222'] df.loc[len(df)] = ['3', '3333'] df.loc[len(df)] = ['4', '4444'] index = model.index(0, 0) # print("0 row 0 col data is %s" % (model.data(index))) model.refresh() print("after append model length %s" %(len(model))) print("model list is \n %s " % model) print("model roleNames %s" % model.roleNames()) # pandas model and qml operation test from PyQt5.QtQml import QQmlApplicationEngine from PyQt5.QtWidgets import QApplication from PyQt5.QtCore import QUrl myApp = QApplication(sys.argv) qmlEngine = QQmlApplicationEngine() rootContext = qmlEngine.rootContext() rootContext.setContextProperty("cppModelCondition", model) qmlEngine.load(QUrl('main.qml')) sys.exit(myApp.exec_()) # input()