Exemplo n.º 1
0
    def __init__(self, source, root=None):
        super(Launcher, self).__init__()

        engine = QtQml.QQmlApplicationEngine()
        engine.objectCreated.connect(self.on_object_created)
        # engine.warnings.connect(self.on_warnings)
        engine.addImportPath(QML_IMPORT_DIR)

        try:
            io.install()
        except IOError:
            raise  # Server refused to connect

        # Install actions
        from . import install
        install()

        terminal.init()
        app_root = os.path.dirname(__file__).replace('\\', '/')
        res_path = "file:///{}/res/".format(app_root)

        controller = control.Controller(root, self)
        engine.rootContext().setContextProperty("controller", controller)
        engine.rootContext().setContextProperty("terminal", terminal.model)
        engine.rootContext().setContextProperty("res_path", res_path)

        self._icon = QtGui.QIcon(ICON_PATH)
        self._tray = None
        self.window = None
        self.engine = engine
        self.controller = controller
        # self.window = object
        self.controller.init()
        engine.load(QtCore.QUrl.fromLocalFile(source))
Exemplo n.º 2
0
    def __init__(self, root, source):
        super(Application, self).__init__(sys.argv)
        self.setWindowIcon(QtGui.QIcon(ICON_PATH))

        engine = QtQml.QQmlApplicationEngine()
        engine.objectCreated.connect(self.on_object_created)
        engine.warnings.connect(self.on_warnings)
        engine.addImportPath(QML_IMPORT_DIR)

        try:
            io.install()
        except IOError:
            raise  # Server refused to connect

        # Install actions
        from . import install
        install()

        terminal.init()

        controller = control.Controller(root, self)
        engine.rootContext().setContextProperty("controller", controller)
        engine.rootContext().setContextProperty("terminal", terminal.model)

        self._tray = None
        self.window = None
        self.engine = engine
        self.controller = controller

        engine.load(QtCore.QUrl.fromLocalFile(source))

        self.setQuitOnLastWindowClosed(False)
Exemplo n.º 3
0
 def __init__(self,
              qmlSrc: Union[str, Path],
              qmlFile: Optional[Union[str, Path, QtCore.QUrl]] = None,
              parent: QtCore.QObject = None):
     """Parameters
     ----------
     qmlSrc
         Either QML source code or :py:class:`Path` pointing to source
         file.
     qmlFile
         If `qmlSrc` is source code, behave as if it had been loaded from a
         file named `qmlFile`.
     parent
         Parent QObject
     """
     super().__init__(parent)
     self._status = self.Status.Error
     if qmlFile is None:
         qmlFile = QtCore.QUrl()
     elif isinstance(qmlFile, (str, Path)):
         qmlFile = QtCore.QUrl.fromLocalFile(str(qmlFile))
     self._engine = QtQml.QQmlApplicationEngine()
     self._engine.addImportPath(qmlPath)
     useBundledIconTheme()
     self._engine.objectCreated.connect(self._instanceCreated)
     # TODO: A user can only connect to status_Changed after __init__
     # finishes and will therefore miss this signal and also the one
     # emitted by _instanceCreated. Maybe add callback parameter to
     # __init__?
     self._status = self.Status.Loading
     self.status_Changed.emit(self._status)
     if isinstance(qmlSrc, Path):
         self._engine.load(str(qmlSrc))
     else:
         self._engine.loadData(qmlSrc.encode(), qmlFile)
Exemplo n.º 4
0
    def __init__(self, argv):
        super(Application, self).__init__(argv)

        self._console_ctrl = console.Controller()
        self._tray = None
        self._popen = None
        self._window = None

        # Virtual host properties
        self._vhost_ctrl = virtual_host.Controller()

        with open(self.THEMEPATH) as f:
            self._theme = json.load(f)

        self.engine = QtQml.QQmlApplicationEngine()
        self.engine.addImportPath(self.QMLPATH)
        self.engine.objectCreated.connect(self.on_object_created)

        self.focusWindowChanged.connect(self.on_focus_changed)
        self._console_ctrl.autohideChanged.connect(self.on_autohide_changed)

        context = self.engine.rootContext()
        context.setContextProperty("applicationTheme", self._theme)
        context.setContextProperty("consoleCtrl", self._console_ctrl)
        context.setContextProperty("hostCtrl", self._vhost_ctrl)

        # Toggles
        self.toggles = {"autoHide": True}

        # Timers
        keep_visible = QtCore.QTimer(self)
        keep_visible.setInterval(1000)
        keep_visible.setSingleShot(True)

        self.timers = {"keepVisible": keep_visible}
Exemplo n.º 5
0
    def __init__(self, gates=None, allow_mouse_wheel_updates: bool = True):
        """ Parameter viewer for gates

        Args:
            gates: Gate instrument to use. If None, use qcodes.Station.default.gates
            allow_mouse_wheel_updates: If True, then allow changing parameter values using mouse scrolling
        """
        super().__init__()
        self.app = QtCore.QCoreApplication.instance()
        self.instance_ready = True

        if self.app is None:
            self.instance_ready = False
            self.app = QtWidgets.QApplication([])

        self.engine = QtQml.QQmlApplicationEngine()

        if gates is None:
            if hasattr(qc.Station.default, 'gates'):
                gates = qc.Station.default.gates
            else:
                raise ValueError(
                    'No gates Instrument found in the station, pleasse add manually.'
                )

        self.real_gate_model = gate_model(
            gates,
            list(gates.hardware.dac_gate_map.keys()),
            allow_mouse_wheel_updates=allow_mouse_wheel_updates)
        self.engine.rootContext().setContextProperty("real_gate_model",
                                                     self.real_gate_model)

        v_gates = list()
        for i in gates.v_gates.values():
            v_gates += i

        self.virtual_gate_model = gate_model(
            gates,
            v_gates,
            allow_mouse_wheel_updates=allow_mouse_wheel_updates)
        self.engine.rootContext().setContextProperty("virtual_gate_model",
                                                     self.virtual_gate_model)

        self.engine.rootContext().setContextProperty("param_viewer", self)

        filename = os.path.join(qml_in.__file__[:-12], "param_viewer.qml")
        self.engine.load(QtCore.QUrl.fromLocalFile(filename))
        self.win = self.engine.rootObjects()[0]

        self.timer_real = QtCore.QTimer()
        self.timer_real.timeout.connect(self.real_gate_model.update_model)
        self.timer_real.start(500)
        self.timer_virt = QtCore.QTimer()
        self.timer_virt.timeout.connect(self.virtual_gate_model.update_model)
        self.timer_virt.start(500)

        if self.instance_ready == False:
            self.app.exec_()
            print('exec')
Exemplo n.º 6
0
    def __init__(self):
        super().__init__()
        self.app = QtCore.QCoreApplication.instance()
        self.instance_ready = True
        if self.app is None:
            self.instance_ready = False
            self.app = QtWidgets.QApplication([])

        self.engine = QtQml.QQmlApplicationEngine()

        self.date_model = date_model([])
        self.data_overview_model = data_overview_model([])

        self.project_model = combobox_model(['any', sample_info.project])
        self.set_up_model = combobox_model(['any', sample_info.set_up])
        self.sample_model = combobox_model(['any', sample_info.sample])

        self.signal_handler = signale_handler(self.project_model,
                                              self.set_up_model,
                                              self.sample_model,
                                              self.date_model,
                                              self.data_overview_model)

        self.engine.rootContext().setContextProperty("combobox_project_model",
                                                     self.project_model)
        self.engine.rootContext().setContextProperty("combobox_set_up_model",
                                                     self.set_up_model)
        self.engine.rootContext().setContextProperty("combobox_sample_model",
                                                     self.sample_model)

        self.engine.rootContext().setContextProperty("date_list_model",
                                                     self.date_model)
        self.engine.rootContext().setContextProperty("data_content_view_model",
                                                     self.data_overview_model)

        self.engine.rootContext().setContextProperty("local_conn_status", True)
        self.engine.rootContext().setContextProperty("remote_conn_status",
                                                     True)

        self.engine.rootContext().setContextProperty("signal_handler",
                                                     self.signal_handler)

        # grab directory from the import!
        filename = os.path.join(qml_in.__file__[:-11], "data_browser.qml")
        self.engine.load(QtCore.QUrl.fromLocalFile(filename))
        self.win = self.engine.rootObjects()[0]
        self.signal_handler.init_gui_variables(self.win)

        if self.instance_ready == False:
            self.app.exec_()
            print('exec')
Exemplo n.º 7
0
    def __init__(self, args, qml: str):
        """
        Args:
            args: system level arguments
            qml : main qml file
        """
        self._app = create_application(args)
        self._engine = QtQml.QQmlApplicationEngine()
        self._settings = ApplicationSettings()
        self._engine.rootContext().setContextProperty("qtVersion", QtCore.QT_VERSION_STR)

        self.register_qml_types()

        self._engine.load(QtCore.QUrl(qml))
        assert(len(self._engine.rootObjects()) > 0)
Exemplo n.º 8
0
def main(qml_file="millerLauncher.qml", path=""):
    # _root = os.path.abspath(path)
    # List._root = os.path.abspath(path)

    # Show QML Window
    full_directory = os.path.dirname(os.path.abspath(__file__))

    app = pigui.pyqt5.widget.QApplication(sys.argv)
    # app = QtWidgets.QApplication(sys.argv)

    QtQml.qmlRegisterType(Controller, 'Controller', 1, 0, 'Controller')
    engine = QtQml.QQmlApplicationEngine()
    qml_file = os.path.join(full_directory, qml_file)
    engine.load(str(qml_file))
    window = engine.rootObjects()[0]
    window.show()
    sys.exit(app.exec_())
    def launch(self):
        global VhclSpeed
        myApp = QtGui.QGuiApplication(sys.argv)
        myEngine = QtQml.QQmlApplicationEngine()
        self.manager = SpeedMeterManager()
        myEngine.rootContext().setContextProperty("smManager", self.manager)
        directory = os.path.dirname(os.path.abspath(__file__))
        myEngine.load(QtCore.QUrl.fromLocalFile(os.path.join(directory, 'speedMeter.qml')))
    
        if not myEngine.rootObjects():
            return -1
        self.dashB = myEngine.rootObjects()[0]
        timer = QtCore.QTimer(interval=500)
#         timer.timeout.connect(partial(self.updateSpeed, VhclSpeed))
        timer.timeout.connect(self.fetchBrake)
        timer.timeout.connect(self.fetchAccl)
        timer.start()
        return myApp.exec_()
Exemplo n.º 10
0
    def __init__(self, root, source):
        super(Application, self).__init__(sys.argv)
        self.setWindowIcon(QtGui.QIcon(ICON_PATH))

        pixmap = QtGui.QPixmap(SPLASH_PATH)
        splash = QtWidgets.QSplashScreen(pixmap)
        splash.show()
        self._splash = splash

        engine = QtQml.QQmlApplicationEngine()
        engine.objectCreated.connect(self.on_object_created)
        engine.warnings.connect(self.on_warnings)
        engine.addImportPath(QML_IMPORT_DIR)

        self._splash.showMessage("Connecting database...",
                                 QtCore.Qt.AlignBottom, QtCore.Qt.black)

        try:
            io.install()
        except IOError:
            raise  # Server refused to connect

        # Install actions
        from . import install

        install()

        self._splash.showMessage("Starting Studio Launcher...",
                                 QtCore.Qt.AlignBottom, QtCore.Qt.black)

        terminal.init()

        controller = control.Controller(root, self)
        engine.rootContext().setContextProperty("controller", controller)
        engine.rootContext().setContextProperty("terminal", terminal.model)

        self._tray = None
        self.window = None
        self.engine = engine
        self.controller = controller

        engine.load(QtCore.QUrl.fromLocalFile(source))

        self.setQuitOnLastWindowClosed(False)
Exemplo n.º 11
0
    def __init__(self):
        super().__init__()
        # self.app =  QtGui.QGuiApplication(sys.argv)
        self.app = QtCore.QCoreApplication.instance()
        self.instance_ready = True
        if self.app is None:
            self.instance_ready = False
            self.app = QtWidgets.QApplication([])

        hw = hardware()
        self.engine = QtQml.QQmlApplicationEngine()

        self.attenuation_model = attenuation_model(hw.awg2dac_ratios)
        self.engine.rootContext().setContextProperty("attenuation_model",
                                                     self.attenuation_model)

        if len(hw.virtual_gates) > 0:
            self.row_header_model = table_header_model(
                hw.virtual_gates[0].gates)
            self.column_header_model = table_header_model(
                hw.virtual_gates[0].v_gates)
            self.vg_matrix_model = vg_matrix_model(hw.virtual_gates[0])

            self.engine.rootContext().setContextProperty(
                'row_header_model', self.row_header_model)
            self.engine.rootContext().setContextProperty(
                'column_header_model', self.column_header_model)
            self.engine.rootContext().setContextProperty(
                'vg_matrix_model', self.vg_matrix_model)
        # grab directory from the import!

        filename = os.path.join(qml_in.__file__[:-12],
                                "virt_gate_matrix_gui.qml")
        self.engine.load(QtCore.QUrl.fromLocalFile(filename))
        self.win = self.engine.rootObjects()[0]

        timer = QtCore.QTimer()
        timer.timeout.connect(lambda: None)
        timer.start(100)

        if self.instance_ready == False:
            self.app.exec_()
            print('exec')
Exemplo n.º 12
0
def main():
    app = QtWidgets.QApplication(sys.argv)
    app.setFont(QtGui.QFont("Ubuntu Mono"))
    engine = QtQml.QQmlApplicationEngine()
    interfaces = Interfaces()
    engine.rootContext().setContextProperty('interfaces', interfaces)
    sniffer = Sniffer()
    engine.rootContext().setContextProperty('sniffer', sniffer)

    packetItemModel = sniffer.packetItemModel
    engine.rootContext().setContextProperty('packetItemModel', packetItemModel)
    engine.load(QUrl('main.qml'))

    topLevel = QtCore.QObject()
    topLevel = engine.rootObjects()[0]

    window = QtQuick.QQuickWindow()
    window = topLevel

    window.show()
    sys.exit(app.exec_())
Exemplo n.º 13
0
    def setup(self):
        if not os.path.exists(self.THUMB_DIR):
            os.makedirs(self.THUMB_DIR)
        user_database.setup()

        self.qml_engine = QtQml.QQmlApplicationEngine()
        self.qml_engine.addImportPath(self.QML_PATH)
        # self.qml_engine.addPluginPath(self.QML_PATH)
        self.setAttribute(QtCore.Qt.AA_UseOpenGLES, True)
        self.qml_engine.load(os.path.join(self.QML_PATH, "main.qml"))
        self.app_window = self.qml_engine.rootObjects()[0]
        self.app_window.updateGalleryRating.connect(self.update_gallery_rating)
        self.app_window.askForTags.connect(self.get_tags_from_search)
        self.app_window.saveSettings.connect(self.update_config)
        self.app_window.setSortMethod.connect(self.set_sorting)
        self.app_window.setSearchText.connect(self.update_search)
        self.app_window.pageChange.connect(self.switch_page)
        self.app_window.scanGalleries.connect(self.find_galleries)
        self.app_window.openGallery.connect(self.open_gallery)
        self.app_window.openGalleryFolder.connect(self.open_gallery_folder)
        self.app_window.metadataSearch.connect(self.get_metadata)
        self.app_window.removeGallery.connect(self.remove_gallery_by_uuid)
        self.app_window.openOnEx.connect(self.open_on_ex)
        self.app_window.saveGallery.connect(self.save_gallery_customization)
        self.app_window.searchForDuplicates.connect(self.remove_duplicates)
        self.app_window.closedUI.connect(self.close)
        self.app_window.getDetailedGallery.connect(self.get_detailed_gallery)
        self.app_window.getGalleryImageFolder.connect(
            self.get_gallery_image_folder)
        self.app_window.setGalleryImage.connect(self.set_gallery_image)
        self.app_window.setUISort.emit(Config.sort_type,
                                       1 if Config.sort_mode_reversed else 0)
        self.completer_line = QtWidgets.QLineEdit()
        self.completer_line.hide()
        self.setup_completer()
        self.setWindowIcon(
            QtGui.QIcon(Utils.convert_from_relative_path("icon.ico")))
        self.set_ui_config()
        self.app_window.show()
Exemplo n.º 14
0
    def __init__(self, data):
        super().__init__()
        # self.app =  QtGui.QGuiApplication(sys.argv)
        self.app = QtCore.QCoreApplication.instance()
        self.instance_ready = True
        if self.app is None:
            self.instance_ready = False
            self.app = QtWidgets.QApplication([])

        self.engine = QtQml.QQmlApplicationEngine()
        self.categories_model = categories_model(list(data.keys()))
        self.data = data
        if len(data) == 0:
            self.data_model = name_value_model({})
        else:
            self.data_model = name_value_model(data[list(data.keys())[0]])
        self.singal_hander = singal_hander_4_variable_exporer(
            self.categories_model, self.data_model, data)

        self.engine.rootContext().setContextProperty("cat_model",
                                                     self.categories_model)
        self.engine.rootContext().setContextProperty(
            "variable_name_value_pair_list", self.data_model)
        self.engine.rootContext().setContextProperty("test_function",
                                                     self.singal_hander)

        # grab directory from the import!
        filename = os.path.join(qml_in.__file__[:-11],
                                "variable_mgr_window.qml")
        self.engine.load(QtCore.QUrl.fromLocalFile(filename))
        self.win = self.engine.rootObjects()[0]

        timer = QtCore.QTimer()
        timer.timeout.connect(lambda: None)
        timer.start(100)

        if self.instance_ready == False:
            self.app.exec_()
            print('exec')
Exemplo n.º 15
0
        return True

    def lprint(self, message):
        # 日志打印
        global GTime
        k = GTime[0:2]
        if not self.log.get(str(k)):
            self.log[str(k)] = []
        self.log[str(k)].append(message)
        json.dump(self.log, open("log.json", "w"), ensure_ascii=False)


if __name__ == '__main__':
    # 界面初始化
    app = QtWidgets.QApplication(sys.argv)
    engine = QtQml.QQmlApplicationEngine()
    context = engine.rootContext()

    # 配置qml属性
    system = System()
    context.setContextProperty("system", system)

    timer = Timer()
    context.setContextProperty("timer", timer)

    # 加载qml属性
    engine.addImportPath(absPath + "qtquickcontrols2.conf")
    engine.load(QUrl(absPath + 'main.qml'))
    engine.load(QUrl(absPath + 'loginPage.qml'))

    # 信号与槽连接
Exemplo n.º 16
0
    def __init__(self, virtual_gate_name: Union[str, int] = 0):
        """
        Args:
            virtual_gate_name: Name or index of virtual gate to display
        """
        super().__init__()
        # self.app =  QtGui.QGuiApplication(sys.argv)
        self.app = QtCore.QCoreApplication.instance()
        self.instance_ready = True
        if self.app is None:
            self.instance_ready = False
            self.app = QtWidgets.QApplication([])

        hw = hardware()
        self.engine = QtQml.QQmlApplicationEngine()

        self.attenuation_model = attenuation_model(hw.awg2dac_ratios)
        self.engine.rootContext().setContextProperty("attenuation_model",
                                                     self.attenuation_model)

        if isinstance(virtual_gate_name, int):
            self.virtual_gate_index = virtual_gate_name
        else:
            self.virtual_gate_index = (
                hw.virtual_gates.virtual_gate_names).index(virtual_gate_name)

        if len(hw.virtual_gates) > self.virtual_gate_index:
            hw = hardware()
            vg = hw.virtual_gates[self.virtual_gate_index]
            logging.info(
                f'creating objects for index {self.virtual_gate_index}')
            self.vg_matrix_model = vg_matrix_model(vg)
            self.vg_matrix_model._manipulate_callback = self.set_table_headers

            self.gates_header_model = table_header_model(vg.gates)
            self.vgates_header_model = table_header_model(vg.v_gates)

            root_context = self.engine.rootContext()
            root_context.setContextProperty('virt_gate_matrix_GUI', self)
            root_context.setContextProperty('vg_matrix_model',
                                            self.vg_matrix_model)
            root_context.setContextProperty('row_header_model',
                                            self.gates_header_model)
            root_context.setContextProperty('column_header_model',
                                            self.vgates_header_model)
        else:
            print('virtual gate name {virtual_gate_name} could not be found')

        # grab directory from the import!
        filename = os.path.join(qml_in.__file__[:-12],
                                "virt_gate_matrix_gui.qml")
        logging.info(f'loading qml from {filename}')
        self.engine.load(QtCore.QUrl.fromLocalFile(filename))
        self.win = self.engine.rootObjects()[0]

        self._mat_inv_switch = self.engine.rootObjects()[0].findChild(
            QtCore.QObject, "mat_inv_switch")
        self.set_table_headers()

        timer = QtCore.QTimer()
        timer.timeout.connect(lambda: None)
        timer.start(100)

        if self.instance_ready == False:
            self.app.exec_()
            print('exec')
Exemplo n.º 17
0
    @QtCore.pyqtSlot()
    def GetServerNames(self):
        def go():
            serverNames = ["one", "two", "three"]
            self.serverNames.emit(serverNames)

        threading.Thread(target=go).start()

    @QtCore.pyqtSlot()
    def GetLastLogin(self):
        def go():
            login = "******"
            self.lastLogin.emit(login)

        threading.Thread(target=go).start()

    @QtCore.pyqtSlot()
    def GetLastServerName(self):
        def go():
            serverName = "three"
            self.lastServer.emit(serverName)

        threading.Thread(target=go).start()


app = QtGui.QGuiApplication(sys.argv)
QtQml.qmlRegisterType(LoginManager, 'LoginManager', 1, 0, 'LoginManager')
engine = QtQml.QQmlApplicationEngine("Main.qml")
app.exec_()
Exemplo n.º 18
0
    def __init__(self, parent=None):
        super().__init__(parent)

        self.api_v = "5.101"
        self.app_id = "7285008"
        self.scope = "groups,wall,photos"

        self._current_page = ""
        self.vk_session = None

        self._engine = QtQml.QQmlApplicationEngine()

        self._authentication = AuthenticationManager()
        self._manager = ComponentCacheManager(self._engine)
        self._db_manager = DataBaseManager()
        self._reader = FileReader()


        self._authentication.login_signal.connect(self.on_login_signal)
        self._authentication.logout_signal.connect(self.on_logout_signal)
        self._authentication.close_signal.connect(self.on_close_signal)
        self._db_manager.choose_group_signal.connect(self.on_choose_group)
        self._db_manager.update_signal.connect(self.on_update)

        self._db_manager.load_posts_signal.connect(self.on_load_posts)

        self._db_manager.get_post_signal.connect(self.on_get_post)
        self._db_manager.get_posts_by_time_signal.connect(self.on_get_posts_by_time)
        self._db_manager.get_tags_signal.connect(self.on_get_tags)
        self._db_manager.get_templates_signal.connect(self.on_get_templates)
        self._db_manager.get_groups_signal.connect(self.on_get_groups)
        self._db_manager.add_tag_signal.connect(self.on_add_tag)
        self._db_manager.save_post_signal.connect(self.on_save_post)
        self._db_manager.publish_post_signal.connect(self.on_publish_post)
        self._db_manager.delete_post_signal.connect(self.on_delete_post)

        self._db_manager.get_template_signal.connect(self.on_get_template)
        self._db_manager.save_template_signal.connect(self.on_save_template)
        self._db_manager.delete_template_signal.connect(self.on_delete_template)

        self._authentication.get_wall_posts_signal.connect(self.on_get_wall_posts)
        self._authentication.get_wall_postponed_signal.connect(self.on_get_wall_postponed)

        self._engine.rootContext().setContextProperty(
            "authentication", self._authentication
        )
        self._engine.rootContext().setContextProperty(
            "componentCache", self._manager
        )
        self._engine.rootContext().setContextProperty(
            "db_manager", self._db_manager
        )
        self._engine.rootContext().setContextProperty(
            "APIv", self.api_v
        )
        self._engine.rootContext().setContextProperty(
            "app_id", self.app_id
        )
        self._engine.rootContext().setContextProperty(
            "scope", self.scope
        )
        self._engine.rootContext().setContextProperty(
            "fileReader", self._reader
        )
Exemplo n.º 19
0
import os
import sys

from PyQt5 import QtQml, QtWidgets

if __name__ == '__main__':
    if 'CONFIG' in os.environ:
        print(os.environ['CONFIG'])
    app = QtWidgets.QApplication(sys.argv + ["-nograb"])
    engine = QtQml.QQmlApplicationEngine("Debug.qml")
    sys.exit(app.exec_())
Exemplo n.º 20
0
            if self.player.isRunning():
                self.player.terminate()

    @QtCore.pyqtSlot(float)
    def scrub(self, where):
        if self.isPlaying:
            self.isPlaying = False
            self.progress = where
            self.isPlaying = True
        else:
            self.progress = where

    filename_changed, filename = autoProperty(str, 'filename')
    isPlaying_changed, isPlaying = autoProperty(bool, 'isPlaying')
    progress_changed, progress = autoProperty(float, 'progress')
    waveform_changed, waveform = autoProperty(QtCore.QVariant,
                                              'waveform',
                                              readonly=True)
    length_changed, length = autoProperty(float, 'length', readonly=True)


if __name__ == "__main__":
    if not QtGui.QGuiApplication.instance():
        app = QtGui.QGuiApplication(sys.argv)
    QtQml.qmlRegisterType(Player, 'Player', 1, 0, 'Player')
    engine = QtQml.QQmlApplicationEngine('main.qml')
    if len(engine.rootObjects()) > 0:
        mainWindow = engine.rootObjects()[0]
        mainWindow.setVisible(True)
    app.exec()
Exemplo n.º 21
0
import sys

from PyQt5 import QtQml
from PyQt5.QtWidgets import QApplication

app = QApplication(sys.argv)
engine = QtQml.QQmlApplicationEngine("example.qml")
app.exec_()
Exemplo n.º 22
0
def main():
    app = QtGui.QGuiApplication(sys.argv)
    QtQml.qmlRegisterType(JSManager, 'JSManager', 1, 0, 'JSManager')
    engine = QtQml.QQmlApplicationEngine(os.path.join(THIS_DIR, "main.qml"))
    app.exec_()