def __init__(self, parent = None): # Initialization of the superclass super(MainWindow, self).__init__(parent) qInstallMessageHandler(qt_message_handler) self.backend = Backend() # Expose the Python "Backend" object to QML self.engine = QQmlApplicationEngine() self.context = self.engine.rootContext() self.context.setContextProperty("backend", self.backend) # Load the GUI self.engine.load(os.path.join(os.path.dirname(__file__), "SpecPXA_QML.qml")) if not self.engine.rootObjects(): sys.exit(-1) self.win = self.engine.rootObjects()[0] # Execute a function if "Start" button clicked startbutton = self.win.findChild(QObject, "startbutton") startbutton.startclicked.connect(self.startclicked) # Execute a function if "Stop" button clicked stopbutton = self.win.findChild(QObject, "stopbutton") stopbutton.stopclicked.connect(self.stopclicked)
def __init__(self): super().__init__() self.load(os.path.join(os.getcwd(), "view.qml")) qInstallMessageHandler(qt_message_handler) self.rootContext().setContextProperty("MainWindow", self) if os.name == "nt": self.prefix = "file:///" else: self.prefix = "file://" self.tmp_dir = "tmp" if not os.path.exists("tmp"): os.makedirs("tmp") self.fileName = None self.colorImage = None self.image = None self.bwImage = None self.model = None self.modelFolderName = None if self.rootObjects(): self.window = self.rootObjects()[0] self.imageField = self.window.findChild(QObject, "imagePreview") self.modelText = self.window.findChild(QObject, "modelPreview") else: sys.exit(-1)
def main(): qInstallMessageHandler(lambda x, y, msg: print(msg)) 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(FigureCanvasQTAgg, "Backend", 1, 0, "FigureCanvasByPython") view = QQuickView() view.setResizeMode(QQuickView.SizeRootObjectToView) view.setSource(QUrl(str(pathlib.Path(__file__).parent / 'Figure.qml'))) view.show() win = view.rootObject() qml_figure_canvas = win.findChild(QObject, "figure") fig = qml_figure_canvas.getFigure() print(fig) ax = fig.add_subplot(111) x = np.linspace(-5, 5) ax.plot(x, np.sin(x)) 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 __init__(self, args): QtArgs = [args[0], '-style', 'fusion'] + args[1:] # force Fusion style by default super(MeshroomApp, self).__init__(QtArgs) self.setOrganizationName('AliceVision') self.setApplicationName('Meshroom') self.setAttribute(Qt.AA_EnableHighDpiScaling) self.setApplicationVersion(meshroom.__version__) font = self.font() font.setPointSize(9) self.setFont(font) pwd = os.path.dirname(__file__) self.setWindowIcon(QIcon(os.path.join(pwd, "img/meshroom.svg"))) # QML engine setup qmlDir = os.path.join(pwd, "qml") url = os.path.join(qmlDir, "main.qml") self.engine = QmlInstantEngine() self.engine.addFilesFromDirectory(qmlDir, recursive=True) self.engine.setWatching(os.environ.get("MESHROOM_INSTANT_CODING", False)) # whether to output qml warnings to stderr (disable by default) self.engine.setOutputWarningsToStandardError(MessageHandler.outputQmlWarnings) qInstallMessageHandler(MessageHandler.handler) self.engine.addImportPath(qmlDir) components.registerTypes() # expose available node types that can be instantiated self.engine.rootContext().setContextProperty("_nodeTypes", sorted(nodesDesc.keys())) # instantiate Reconstruction object r = Reconstruction(parent=self) self.engine.rootContext().setContextProperty("_reconstruction", r) # those helpers should be available from QML Utils module as singletons, but: # - qmlRegisterUncreatableType is not yet available in PySide2 # - declaring them as singleton in qmldir file causes random crash at exit # => expose them as context properties instead self.engine.rootContext().setContextProperty("Filepath", FilepathHelper(parent=self)) self.engine.rootContext().setContextProperty("Scene3DHelper", Scene3DHelper(parent=self)) self.engine.rootContext().setContextProperty("Clipboard", ClipboardHelper(parent=self)) # additional context properties self.engine.rootContext().setContextProperty("_PaletteManager", PaletteManager(self.engine, parent=self)) self.engine.rootContext().setContextProperty("MeshroomApp", self) # request any potential computation to stop on exit self.aboutToQuit.connect(r.stopChildThreads) parser = argparse.ArgumentParser(prog=args[0], description='Launch Meshroom UI.') parser.add_argument('--project', metavar='MESHROOM_FILE', type=str, required=False, help='Meshroom project file (e.g. myProject.mg).') args = parser.parse_args(args[1:]) if args.project: r.loadUrl(QUrl.fromLocalFile(args.project)) self.engine.load(os.path.normpath(url))
def run(args, field): qInstallMessageHandler(msg_handler) if "QT_QUICK_CONTROLS_STYLE" not in os.environ: os.environ["QT_QUICK_CONTROLS_STYLE"] = "Fusion" app = QGuiApplication(args) eng = QQmlApplicationEngine() eng.rootContext().setContextProperty("field", field) eng.load(QUrl("ui.qml")) app.exec_()
def main(): qInstallMessageHandler(lambda x, y, msg: print(msg)) argv = sys.argv # Trick to set the style / not found how to do it in pythonic way #argv.extend(["-style", "universal"]) app = QApplication(argv) qmlRegisterType(FigureCanvasQTAgg, "Backend", 1, 0, "FigureCanvasByPython") qmlRegisterType(FigureCanvasQTAggToolbar, "Backend", 1, 0, "FigureToolbarByPython") # this should work in the future # qmlRegisterType( # QUrl.fromLocalFile( str(pathlib.Path(backend_qquick5agg.__file__)/'SubplotTool.qml')), # "Backend", 1, 0, "SubplotTool") 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(str(pathlib.Path(__file__).parent / 'main_mpl_qtquick_main.qml'))) win = engine.rootObjects()[0] figure = win.findChild(QObject, "figure") mainApp.figure = 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 setup_logging(initial_verbosity): module_log_handler = logging.StreamHandler() module_log_handler.setFormatter(logging.Formatter("%(levelname)s %(module)s %(funcName)s %(message)s")) module_logger.addHandler(module_log_handler) module_logger.setLevel(logging.INFO) # set this again later after getting QSettings # Apparently Windows version of PySide2 doesn't have QML logging feature turn on so we fill this gap if platform.system() == 'Windows': qml_log_handler = logging.StreamHandler() qml_log_handler.setFormatter(logging.Formatter("[QML] %(levelname)s %(message)s")) qml_logger.addHandler(qml_log_handler) qInstallMessageHandler(qt_message_handler) # Use "singleton" real logger for all projects just wrapping it into the LoggingAdapter for every project projects_logger.setLevel(logging.DEBUG if initial_verbosity else logging.INFO) projects_logger_handler.setFormatter(_projects_logger_formatter) projects_logger.addHandler(projects_logger_handler) set_verbosity(initial_verbosity) # set initial verbosity settings based on the saved state
def __init__(self): """App constructor""" self.streamingAPI = CHOSEN_STREAMING_API print(self.streamingAPI) QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) sys_argv = sys.argv sys_argv += ['--style', 'fusion'] app = QApplication(sys_argv) QCoreApplication.setAttribute(Qt.AA_UseHighDpiPixmaps) # Set up the application window pwd = os.path.dirname(__file__) qmlDir = os.path.join(pwd, "UIPkg") self.engine = QmlInstantEngine() self.engine.addFilesFromDirectory(qmlDir, recursive=True) self.engine.setWatching( os.environ.get("MESHROOM_INSTANT_CODING", False)) # whether to output qml warnings to stderr (disable by default) self.engine.setOutputWarningsToStandardError( MessageHandler.outputQmlWarnings) qInstallMessageHandler(MessageHandler.handler) ctx = self.engine.rootContext() # Create a Backend object to communicate with QML self.backend = Backend() ctx.setContextProperty("backend", self.backend) ctx.setContextProperty("preview", self.backend.preview) ctx.setContextProperty("acquisition", self.backend.acquisition) self.engine.addImageProvider("imageProvider", self.backend.preview.imageProvider) # Apply palette darkPalette = Palette(self.engine) # Run app self.engine.load("UIPkg/App.qml") sys.exit(app.exec_())
def __init__( self, plugin_path=['/usr/lib/mozilla/plugins', ], defaults=None, display_size=(1600, 900), ): self.logger = logger.getChild('application') if ( sys.platform.startswith('linux') and 'DISPLAY' not in os.environ ): try: self.xvfb = Xvfb( width=display_size[0], height=display_size[1], ) self.xvfb.start() except OSError: raise Error('Xvfb is required to a ghost run outside ' + 'an X instance') self.logger.info('Initializing QT application') Ghost._app = QApplication.instance() or QApplication(['ghost']) qInstallMessageHandler(QTMessageProxy(logging.getLogger('qt'))) if plugin_path: for p in plugin_path: Ghost._app.addLibraryPath(p) self.display_size = display_size _defaults = dict(viewport_size=display_size) _defaults.update(defaults or dict()) self.defaults = _defaults
def __init__(self, args): QtArgs = [args[0], '-style', 'fusion' ] + args[1:] # force Fusion style by default parser = argparse.ArgumentParser(prog=args[0], description='Launch Meshroom UI.', add_help=True) parser.add_argument( 'project', metavar='PROJECT', type=str, nargs='?', help= 'Meshroom project file (e.g. myProject.mg) or folder with images to reconstruct.' ) parser.add_argument( '-i', '--import', metavar='IMAGES/FOLDERS', type=str, nargs='*', help='Import images or folder with images to reconstruct.') parser.add_argument( '-I', '--importRecursive', metavar='FOLDERS', type=str, nargs='*', help= 'Import images to reconstruct from specified folder and sub-folders.' ) parser.add_argument('-s', '--save', metavar='PROJECT.mg', type=str, default='', help='Save the created scene.') parser.add_argument( '-p', '--pipeline', metavar='MESHROOM_FILE/photogrammetry/hdri', type=str, default=os.environ.get("MESHROOM_DEFAULT_PIPELINE", "photogrammetry"), help= 'Override the default Meshroom pipeline with this external graph.') parser.add_argument( "--verbose", help="Verbosity level", default='warning', choices=['fatal', 'error', 'warning', 'info', 'debug', 'trace'], ) args = parser.parse_args(args[1:]) logStringToPython = { 'fatal': logging.FATAL, 'error': logging.ERROR, 'warning': logging.WARNING, 'info': logging.INFO, 'debug': logging.DEBUG, 'trace': logging.DEBUG, } logging.getLogger().setLevel(logStringToPython[args.verbose]) QApplication.setAttribute(Qt.AA_EnableHighDpiScaling) super(MeshroomApp, self).__init__(QtArgs) self.setOrganizationName('AliceVision') self.setApplicationName('Meshroom') self.setApplicationVersion(meshroom.__version_name__) font = self.font() font.setPointSize(9) self.setFont(font) pwd = os.path.dirname(__file__) self.setWindowIcon(QIcon(os.path.join(pwd, "img/meshroom.svg"))) # QML engine setup qmlDir = os.path.join(pwd, "qml") url = os.path.join(qmlDir, "main.qml") self.engine = QmlInstantEngine() self.engine.addFilesFromDirectory(qmlDir, recursive=True) self.engine.setWatching( os.environ.get("MESHROOM_INSTANT_CODING", False)) # whether to output qml warnings to stderr (disable by default) self.engine.setOutputWarningsToStandardError( MessageHandler.outputQmlWarnings) qInstallMessageHandler(MessageHandler.handler) self.engine.addImportPath(qmlDir) components.registerTypes() # expose available node types that can be instantiated self.engine.rootContext().setContextProperty("_nodeTypes", sorted(nodesDesc.keys())) # instantiate Reconstruction object r = Reconstruction(defaultPipeline=args.pipeline, parent=self) self.engine.rootContext().setContextProperty("_reconstruction", r) # those helpers should be available from QML Utils module as singletons, but: # - qmlRegisterUncreatableType is not yet available in PySide2 # - declaring them as singleton in qmldir file causes random crash at exit # => expose them as context properties instead self.engine.rootContext().setContextProperty( "Filepath", FilepathHelper(parent=self)) self.engine.rootContext().setContextProperty( "Scene3DHelper", Scene3DHelper(parent=self)) self.engine.rootContext().setContextProperty( "Clipboard", ClipboardHelper(parent=self)) # additional context properties self.engine.rootContext().setContextProperty( "_PaletteManager", PaletteManager(self.engine, parent=self)) self.engine.rootContext().setContextProperty("MeshroomApp", self) # request any potential computation to stop on exit self.aboutToQuit.connect(r.stopChildThreads) if args.project and not os.path.isfile(args.project): raise RuntimeError( "Meshroom Command Line Error: 'PROJECT' argument should be a Meshroom project file (.mg).\n" "Invalid value: '{}'".format(args.project)) if args.project: r.load(args.project) else: r.new() # import is a python keyword, so we have to access the attribute by a string if getattr(args, "import", None): r.importImagesFromFolder(getattr(args, "import"), recursive=False) if args.importRecursive: r.importImagesFromFolder(args.importRecursive, recursive=True) if args.save: if os.path.isfile(args.save): raise RuntimeError( "Meshroom Command Line Error: Cannot save the new Meshroom project as the file (.mg) already exists.\n" "Invalid value: '{}'".format(args.save)) projectFolder = os.path.dirname(args.save) if not os.path.isdir(projectFolder): if not os.path.isdir(os.path.dirname(projectFolder)): raise RuntimeError( "Meshroom Command Line Error: Cannot save the new Meshroom project file (.mg) as the parent of the folder does not exists.\n" "Invalid value: '{}'".format(args.save)) os.mkdir(projectFolder) r.saveAs(args.save) self.engine.load(os.path.normpath(url))
def main(): # call this before application starts from PySide2.QtCore import qInstallMessageHandler qInstallMessageHandler(log)
:param line: line of log message statement :return: """ logger.log(level, message, extra=(file, line)) @staticmethod def qtMessageHandler(qtMsgType, qMessageLogContext, msg): """ Qt message handler for handling qt messages in normal logging. :param qtMsgType: qt log level :param qMessageLogContext: qt log context :param msg: message as a string :return: """ typeMap = { QtMsgType.QtDebugMsg: logging.DEBUG, QtMsgType.QtInfoMsg: logging.INFO, QtMsgType.QtWarningMsg: logging.WARNING, QtMsgType.QtCriticalMsg: logging.CRITICAL, QtMsgType.QtFatalMsg: logging.FATAL } logger.log(typeMap[qtMsgType], msg, extra=(qMessageLogContext.file if qMessageLogContext.file is not None else "<qt>", qMessageLogContext.line)) qInstallMessageHandler(ConsoleLogger.qtMessageHandler) sys.excepthook = excepthook
module_log_handler = logging.StreamHandler() module_log_handler.setFormatter( logging.Formatter("%(levelname)s %(funcName)s %(message)s")) module_logger.addHandler(module_log_handler) module_logger.setLevel(logging.INFO) module_logger.info('Starting stm32pio-gui...') # Apparently Windows version of PySide2 doesn't have QML logging feature turn on so we fill this gap # TODO: set up for other platforms too (separate console.debug, console.warn, etc.) if stm32pio.settings.my_os == 'Windows': qml_logger = logging.getLogger('qml') qml_log_handler = logging.StreamHandler() qml_log_handler.setFormatter( logging.Formatter("[QML] %(levelname)s %(message)s")) qml_logger.addHandler(qml_log_handler) qInstallMessageHandler(qt_message_handler) # Most Linux distros should be linked with the QWidgets' QApplication instead of the QGuiApplication to enable # QtDialogs if stm32pio.settings.my_os == 'Linux': app = QApplication(sys.argv) else: app = QGuiApplication(sys.argv) # Used as a settings identifier too app.setOrganizationName('ussserrr') app.setApplicationName('stm32pio') app.setWindowIcon(QIcon('stm32pio-gui/icons/icon.svg')) settings = Settings(parent=app) # settings.remove('app/settings')
def main(sys_argv: List[str] = None) -> int: if sys_argv is None: sys_argv = sys.argv[1:] args = parse_args(sys_argv) module_log_handler = logging.StreamHandler() module_log_handler.setFormatter( logging.Formatter("%(levelname)s %(funcName)s %(message)s")) module_logger.addHandler(module_log_handler) module_logger.setLevel( logging.INFO) # set this again later after getting QSettings module_logger.info('Starting stm32pio_gui...') def qt_message_handler(mode, context, message): """ Register this logging handler for the Qt stuff if your platform doesn't provide a built-in one or if you want to customize it """ if mode == QtInfoMsg: mode = logging.INFO elif mode == QtWarningMsg: mode = logging.WARNING elif mode == QtCriticalMsg: mode = logging.ERROR elif mode == QtFatalMsg: mode = logging.CRITICAL else: mode = logging.DEBUG qml_logger.log(mode, message) # Apparently Windows version of PySide2 doesn't have QML logging feature turn on so we fill this gap # TODO: set up for other platforms too (separate console.debug, console.warn, etc.) qml_logger = logging.getLogger('stm32pio_gui.qml') if platform.system() == 'Windows': qml_log_handler = logging.StreamHandler() qml_log_handler.setFormatter( logging.Formatter("[QML] %(levelname)s %(message)s")) qml_logger.addHandler(qml_log_handler) qInstallMessageHandler(qt_message_handler) # Most Linux distros should be "linked" with QWidgets' QApplication instead of QGuiApplication to enable QtDialogs if platform.system() == 'Linux': app = QApplication(sys.argv) else: app = QGuiApplication(sys.argv) # These are used as a settings identifier too app.setOrganizationName('ussserrr') app.setApplicationName('stm32pio') app.setWindowIcon(QIcon(str(MODULE_PATH.joinpath('icons/icon.svg')))) global settings def verbose_setter(value): """Use this to toggle the verbosity of all loggers at once""" module_logger.setLevel(logging.DEBUG if value else logging.INFO) qml_logger.setLevel(logging.DEBUG if value else logging.INFO) projects_logger.setLevel(logging.DEBUG if value else logging.INFO) formatter.verbosity = stm32pio.util.Verbosity.VERBOSE if value else stm32pio.util.Verbosity.NORMAL settings = Settings(prefix='app/settings/', qs_kwargs={'parent': app}, external_triggers={'verbose': verbose_setter}) # Use "singleton" real logger for all projects just wrapping it into the LoggingAdapter for every project projects_logger = logging.getLogger('stm32pio_gui.projects') projects_logger.setLevel( logging.DEBUG if settings.get('verbose') else logging.INFO) formatter = stm32pio.util.DispatchingFormatter( general={ stm32pio.util.Verbosity.NORMAL: logging.Formatter("%(levelname)-8s %(message)s"), stm32pio.util.Verbosity.VERBOSE: logging.Formatter( f"%(levelname)-8s %(funcName)-{stm32pio.settings.log_fieldwidth_function}s %(message)s" ) }) projects_logger_handler.setFormatter(formatter) projects_logger.addHandler(projects_logger_handler) verbose_setter(settings.get( 'verbose')) # set initial verbosity settings based on the saved state settings.beginGroup('app') restored_projects_paths: List[str] = [] for index in range(settings.beginReadArray('projects')): settings.setArrayIndex(index) restored_projects_paths.append(settings.value('path')) settings.endArray() settings.endGroup() engine = QQmlApplicationEngine(parent=app) qmlRegisterType(ProjectListItem, 'ProjectListItem', 1, 0, 'ProjectListItem') qmlRegisterType(Settings, 'Settings', 1, 0, 'Settings') projects_model = ProjectsList(parent=engine) boards_model = QStringListModel(parent=engine) engine.rootContext().setContextProperty('appVersion', stm32pio.app.__version__) engine.rootContext().setContextProperty('Logging', stm32pio.util.logging_levels) engine.rootContext().setContextProperty('projectsModel', projects_model) engine.rootContext().setContextProperty('boardsModel', boards_model) engine.rootContext().setContextProperty('appSettings', settings) engine.load(QUrl.fromLocalFile(str(MODULE_PATH.joinpath('main.qml')))) main_window = engine.rootObjects()[0] # Getting PlatformIO boards can take a long time when the PlatformIO cache is outdated but it is important to have # them before the projects list is restored, so we start a dedicated loading thread. We actually can add other # start-up operations here if there will be a need to. Use the same Worker class to spawn the thread at the pool def loading(): boards = ['None'] + stm32pio.util.get_platformio_boards('platformio') boards_model.setStringList(boards) def loaded(_: str, success: bool): try: # Qt objects cannot be parented from the different thread so we restore the projects list in the main thread for path in restored_projects_paths: projects_model.addListItem(path, go_to_this=False, list_item_kwargs={ 'from_startup': True, 'parent': projects_model }) # At the end, append (or jump to) a CLI-provided project, if there is one if args is not None: list_item_kwargs = { 'from_startup': True, 'parent': projects_model } if args.board: list_item_kwargs['project_kwargs'] = { 'parameters': { 'project': { 'board': args.board } } } # pizdec konechno... projects_model.addListItem(str(pathlib.Path(args.path)), go_to_this=True, list_item_kwargs=list_item_kwargs) projects_model.saveInSettings() except Exception: stm32pio.util.log_current_exception(module_logger) success = False main_window.backendLoaded.emit(success) # inform the GUI loader = Worker(loading, logger=module_logger) loader.finished.connect(loaded) QThreadPool.globalInstance().start(loader) return app.exec_()