def file_import(self): (fileNames, _) = QFileDialog.getOpenFileNames(self, "Open Activity File", "", "Activity Files (*.tcx *.fit *.csv)") if fileNames: QCoreApplication.instance().import_files(*fileNames)
def move(self, i, j): tiles = self.tile.map.tiles self.tile.removeUnit(self) tiles[i][j].addUnit(self) self.tile.setChosenByDist(-1) self.tile.ensureVisible() QCoreApplication.instance().processEvents()
def __init__(self): super(STMainWindow, self).__init__() self.createActions() self.createMenus() layout = QVBoxLayout() self.tabs = QTabWidget() self.tabs.setTabPosition(QTabWidget.West) self.tabs.currentChanged[int].connect(self.tabChanged) self.sessiontab = sweattrails.qt.sessiontab.SessionTab(self) self.tabs.addTab(self.sessiontab, "Sessions") self.tabs.addTab(sweattrails.qt.fitnesstab.FitnessTab(self), "Fitness") self.tabs.addTab(sweattrails.qt.profiletab.ProfileTab(self), "Profile") self.usertab = sweattrails.qt.usertab.UserTab(self) self.tabs.addTab(self.usertab, "Users") self.usertab.hide() layout.addWidget(self.tabs) w = QWidget(self) w.setLayout(layout) self.setCentralWidget(w) self.statusmessage = QLabel() self.statusmessage.setMinimumWidth(200) self.statusBar().addPermanentWidget(self.statusmessage) self.progressbar = QProgressBar() self.progressbar.setMinimumWidth(100) self.progressbar.setMinimum(0) self.progressbar.setMaximum(100) self.statusBar().addPermanentWidget(self.progressbar) self.setWindowTitle("SweatTrails") self.setWindowIconText("SweatTrails") icon = QPixmap("image/sweatdrops.png") self.setWindowIcon(QIcon(icon)) QCoreApplication.instance().refresh.connect(self.userSet)
class SkDesktopProxy(QObject): def __init__(self, parent=None): super(SkDesktopProxy, self).__init__(parent) d = QCoreApplication.instance().desktop() d.resized.connect(self.refresh) def refresh(self): self.xChanged.emit(self.x) self.yChanged.emit(self.y) self.widthChanged.emit(self.width) self.heightChanged.emit(self.height) dprint("pass") def __property(type, method): """ @param type type @param method method """ sig = Signal(type) prop = Property(type, method, notify=sig) return prop, sig x, xChanged = __property(int, lambda _: QCoreApplication.instance().desktop().x()) y, yChanged = __property(int, lambda _: QCoreApplication.instance().desktop().y()) width, widthChanged = __property(int, lambda _: QCoreApplication.instance().desktop().width()) height, heightChanged = __property(int, lambda _: QCoreApplication.instance().desktop().height())
def __init__(self, parent = None): super(UserList, self).__init__(parent = parent) query = grizzle.User.query(keys_only = False) query.add_sort("email") self.setQueryAndColumns(query, "email", "display_name", "status") #self.setMinimumSize(400, 600) QCoreApplication.instance().refresh.connect(self.refresh)
def setUpClass(cls): if not QCoreApplication.instance(): cls.app = QApplication(sys.argv) else: cls.app = QCoreApplication.instance() cls.window = mainwidget.MainWindow() cls.form = cls.window.ui
def __init__(self, interval, parent = None): super(IntervalPage, self).__init__(parent, grumble.qt.bridge.FormButtons.AllButtons if interval.basekind() == "session" else grumble.qt.bridge.FormButtons.EditButtons) with gripe.db.Tx.begin(): interval = interval() self.interval = interval if isinstance(interval, sweattrails.session.Session): self.addProperty(sweattrails.session.Session, "sessiontype", 0, 0, readonly = True, has_label = False, rowspan = 3, bridge = grumble.qt.bridge.Image, height = 64, displayconverter = sweattrails.qt.view.SessionTypeIcon()) self.addProperty(sweattrails.session.Session, "start_time", 0, 1, readonly = True) self.addProperty(sweattrails.session.Session, "description", 1, 1, colspan = 3) col = 1 row = 2 else: self.addProperty(sweattrails.session.Interval, "timestamp", 0, 0, colspan = 3, readonly = True) col = 0 row = 1 self.addProperty(sweattrails.session.Interval, "elapsed_time", row, col, readonly = True) self.addProperty(sweattrails.session.Interval, "duration", row, col + 2, readonly = True) row += 1 self.addProperty(sweattrails.session.Interval, "distance", row, col, readonly = True, displayconverter = sweattrails.qt.view.Distance()) row += 1 self.addProperty(sweattrails.session.Interval, "average_speed", row, col, readonly = True, displayconverter = sweattrails.qt.view.PaceSpeed("Average")) self.addProperty(sweattrails.session.Interval, "max_speed", row, col + 2, readonly = True, displayconverter = sweattrails.qt.view.PaceSpeed({"Pace": "Best", "Speed": "Maximum"})) row += 1 self.setInstance(interval) intervals = sweattrails.session.Interval.query(parent = interval).fetchall() if len(intervals) > 1: page = IntervalListPage(self) self.addTab(page, "Intervals") page.list.objectSelected.connect(parent.addInterval) self.partSpecificContent(interval) self.addTab(GraphPage(self, interval), "Graphs") self.addTab(MapPage(self, interval), "Map") self.addTab(MiscDataPage(self, interval), "Other Data") if interval.basekind() == "session": self.addTab(RawDataPage(self), "Raw Data") self.statusMessage.connect(QCoreApplication.instance().status_message) self.exception.connect(QCoreApplication.instance().status_message) self.instanceSaved.connect(QCoreApplication.instance().status_message) self.instanceDeleted.connect(QCoreApplication.instance().status_message) self.setInstance(interval)
def createActions(self): self.switchUserAct = QAction("&Switch User", self, shortcut = "Ctrl+U", statusTip = "Switch User", triggered = self.switch_user) self.importFileAct = QAction("&Import", self, shortcut = "Ctrl+I", statusTip = "Import Session", triggered = self.file_import) self.downloadAct = QAction("&Download", self, shortcut = "Ctrl+D", statusTip = "Download activities from device", triggered = QCoreApplication.instance().download) self.downloadAct = QAction("&Withings", self, statusTip = "Download Withings data", triggered = QCoreApplication.instance().withings) self.exitAct = QAction("E&xit", self, shortcut = "Ctrl+Q", statusTip = "Exit SweatTrails", triggered = self.close) self.aboutAct = QAction("&About", self, triggered = self.about) self.aboutQtAct = QAction("About &Qt", self, triggered = QApplication.aboutQt)
def __init__(self, user = None, parent = None): super(SessionList, self).__init__(parent = parent) if not user: user = QCoreApplication.instance().user query = sweattrails.session.Session.query(keys_only = False) query.add_filter("athlete", "=", user) query.add_sort("start_time") self.setQueryAndColumns(query, grumble.qt.model.TableColumn("start_time", format = "%A %B %d", header = "Date"), grumble.qt.model.TableColumn("start_time", format = "%H:%M", header = "Time"), DescriptionColumn()) QCoreApplication.instance().refresh.connect(self.refresh)
def app_version(): """ Detect and return the application version for the running application. The following locations are searched, in this order, for a version string: 1. ``siding.plugins.version`` 2. :func:`PySide.QtCore.QCoreApplication.applicationVersion` 3. ``__main__.version`` 4. ``__main__.__version__`` If the version is not found in one of those locations, a :class:`RuntimeError` will be raised. """ if version: return version ver = QCoreApplication.instance().applicationVersion() if ver: return ver import __main__ if hasattr(__main__, 'version'): return __main__.version elif hasattr(__main__, '__version__'): return __main__.__version__ raise RuntimeError("Application version not set.")
def app_version(): """ Detect and return the application version for the running application. The following locations are searched, in this order, for a version string: 1. ``siding.plugins.version`` 2. :func:`PySide.QtCore.QCoreApplication.applicationVersion` 3. ``__main__.version`` 4. ``__main__.__version__`` If the version is not found in one of those locations, a :class:`RuntimeError` will be raised. """ if version: return version ver = QCoreApplication.instance().applicationVersion() if ver: return ver import __main__ if hasattr(__main__, 'version'): return __main__.version elif hasattr(__main__, '__version__'): return __main__.__version__ raise RuntimeError("Application version not set.")
def install(app=None, timeout=0.02, engine=None): """ Creates a :class:`~PySide.QtCore.QTimer` instance that will be triggered continuously to call :func:`Engine.poll() <pants.engine.Engine.poll>`, ensuring that Pants remains responsive. ========= ======== ============ Argument Default Description ========= ======== ============ app None *Optional.* The :class:`~PySide.QtCore.QCoreApplication` to attach to. If no application is provided, it will attempt to find an existing application in memory, or, failing that, create a new application instance. timeout ``0.02`` *Optional.* The maximum time to wait, in seconds, before running :func:`Engine.poll() <pants.engine.Engine.poll>`. engine *Optional.* The :class:`pants.engine.Engine` instance to use. ========= ======== ============ """ global timer global _timeout global _engine _engine = engine or Engine.instance() _engine._install_poller(_Qt()) if app is None: app = QCoreApplication.instance() if app is None: app = QCoreApplication([]) _timeout = timeout * 1000 timer = QTimer(app) timer.timeout.connect(do_poll) timer.start(_timeout)
def quit(self): if self.hasQuit: return self.hasQuit = True dprint("schedule to kill all python instances in a few seconds") skevents.runlater(lambda: os.system("tskill pythonw & tskill python"), config.QT_QUIT_TIMEOUT + config.QT_THREAD_TIMEOUT) # wait for for done or kill all threads from PySide.QtCore import QThreadPool if QThreadPool.globalInstance().activeThreadCount(): dwarn("warning: wait for active threads") QThreadPool.globalInstance().waitForDone(config.QT_THREAD_TIMEOUT) dprint("leave qthread pool") dprint("send quit signal to qApp") qApp = QCoreApplication.instance() # Make sure settings.sync is the last signal conneced with aboutToQuit #qApp.aboutToQuit.connect(self.settings.sync) skevents.runlater(qApp.quit)
def __init__(self, user, parent = None): super(UserDetails, self).__init__(parent) self.addProperty(grizzle.User, "email", 0, 0, readonly = True) self.addProperty(grizzle.User, "display_name", 1, 0) self.addProperty(grizzle.User, "status", 2, 0) self.addProperty(grizzle.User, "has_roles", 3 , 0) self.statusMessage.connect(QCoreApplication.instance().status_message)
def create(self): password = self.pwd.text() if password != self.pwd_again.text(): QMessageBox.critical(self, "Passwords don't match", "The passwords entered are different") self.reject() try: QCoreApplication.instance().add_user(self.email.text(), password, self.display_name.text(), self.savecreds.isChecked()) self.accept() except Exception as e: logger.exception("Exception creating user") QMessageBox.critical(self, "Error", str(e)) self.reject()
def __init__(self, parent = None): super(SettingsPage, self).__init__(parent) self.setMinimumSize(800, 600) self.addProperty(grizzle.User, "email", 0, 0) self.addProperty(grizzle.User, "display_name", 1, 0) self.addProperty(sweattrails.userprofile.UserProfile, "_userprofile.dob", 2, 0) self.addProperty(sweattrails.userprofile.UserProfile, "_userprofile.gender", 3, 0, style = "radio") self.addProperty(sweattrails.userprofile.UserProfile, "_userprofile.height", 4, 0, min = 100, max = 240, suffix = "cm") self.addProperty(sweattrails.userprofile.UserProfile, "_userprofile.units", 5, 0, style = "radio") withingsB = QGroupBox("Withings Support", self) withingsL = QGridLayout(withingsB) self.enableWithings = QCheckBox("Enable Withings", withingsB) self.enableWithings.toggled.connect(self.toggleWithings) withingsL.addWidget(self.enableWithings, 0, 0) withingsL.addWidget(QLabel("Withings User ID"), 1, 0) self.withingsUserID = QLineEdit(withingsB) withingsL.addWidget(self.withingsUserID, 1, 1) withingsL.addWidget(QLabel("Withings Key"), 2, 0) self.withingsKey = QLineEdit(withingsB) withingsL.addWidget(self.withingsKey, 2, 1) self.addWidget(withingsB, self.form.rowCount(), 0, 1, 2) self.addStretch() self.statusMessage.connect(QCoreApplication.instance().status_message)
def install(app=None, timeout=0.02): """ Creates a :class:`~PySide.QtCore.QTimer` instance that will be triggered continuously to call :func:`Engine.poll() <pants.engine.Engine.poll>`, ensuring that Pants remains responsive. ========= ======== ============ Argument Default Description ========= ======== ============ app None *Optional.* The :class:`~PySide.QtCore.QCoreApplication` to attach to. If no application is provided, it will attempt to find an existing application in memory, or, failing that, create a new application instance. timeout ``0.02`` *Optional.* The maximum time to wait, in seconds, before running :func:`Engine.poll() <pants.engine.Engine.poll>`. ========= ======== ============ """ global timer global _timeout Engine.instance()._install_poller(_Qt()) if app is None: app = QCoreApplication.instance() if app is None: app = QCoreApplication([]) _timeout = timeout * 1000 timer = QTimer(app) timer.timeout.connect(do_poll) timer.start(_timeout)
def init_config(self, args): save = False self.user = self.user_id = None if "qtapp" not in gripe.Config: gripe.Config.qtapp = {} self.config = gripe.Config.qtapp if "settings" not in self.config: self.config["settings"] = {} save = True if save: self.config = gripe.Config.set("qtapp", self.config) save = False if args.user and args.password: if QCoreApplication.instance().has_users(): self.authenticate(args.user, args.password, args.savecreds) else: self.add_user(args.user, args.password, args.user, args.savecreds) else: if "user" in self.config.settings: user_settings = self.config.settings.user uid = user_settings.user_id if "user_id" in user_settings else None password = user_settings.password if "password" in user_settings else None logger.debug("Auto-login uid %s", uid) if not uid or not self.authenticate(uid, password, False): del self.config.settings["user"] save = True if save: self.config = gripe.Config.set("qtapp", self.config)
def quit(self): if self.hasQuit: return self.hasQuit = True import curtheme curtheme.unload() for w in self.widgets: if w.isVisible(): w.hide() # wait for for done or kill all threads from PySide.QtCore import QThreadPool if QThreadPool.globalInstance().activeThreadCount(): dwarn("warning: wait for active threads") QThreadPool.globalInstance().waitForDone(config.QT_THREAD_TIMEOUT) dprint("leave qthread pool") dprint("send quit signal to qApp") qApp = QCoreApplication.instance() # Make sure settings.sync is the last signal conneced with aboutToQuit #qApp.aboutToQuit.connect(self.settings.sync) skevents.runlater(qApp.quit)
def doit(): try: app = QApplication([]) except RuntimeError: app = QCoreApplication.instance() main_window = main_window_factory() main_window.show() app.exec_()
def doit(): try: app = QApplication([]) except RuntimeError: app = QCoreApplication.instance() main_window = main_window_factory() main_window.show() app.exec_()
def select_user(self): ret = False if QCoreApplication.instance().user: return True elif QCoreApplication.instance().has_users(): dialog = SelectUser(self) dialog.select() ret = QCoreApplication.instance().is_authenticated() if ret: self.refresh() else: dialog = CreateUser(self) dialog.exec_() ret = QCoreApplication.instance().is_authenticated() if ret: self.refresh() return ret
def __init__(self): self._reads = {} self._writes = {} self._notifiers = {} self._timer = QTimer() self._timer.setSingleShot(True) QObject.connect(self._timer, SIGNAL("timeout()"), self.iterate) if QCoreApplication.instance() is None: # Application Object has not been started yet self.qApp=QCoreApplication([]) self._ownApp=True else: self.qApp = QCoreApplication.instance() self._ownApp=False self._blockApp = None posixbase.PosixReactorBase.__init__(self)
def __init__(self, parent=None): super(TrayIcon, self).__init__(parent) self.setIcon(rc.icon('logo-reader')) self.setToolTip(QCoreApplication.instance().applicationName()) self.activated.connect(self.onActivated) self.__d = _TrayIcon(self) TrayIcon.instance = self
def __init__(self): self._reads = {} self._writes = {} self._notifiers = {} self._timer = QTimer() self._timer.setSingleShot(True) QObject.connect(self._timer, SIGNAL("timeout()"), self.iterate) if QCoreApplication.instance() is None: # Application Object has not been started yet self.qApp = QCoreApplication([]) self._ownApp = True else: self.qApp = QCoreApplication.instance() self._ownApp = False self._blockApp = None posixbase.PosixReactorBase.__init__(self)
def __init__(self, parent=None, f=0): super(_Window, self).__init__(parent, f) self.__canClose = False self.setWindowIcon(rc.icon('logo-reader')) self.setWindowTitle(QCoreApplication.instance().applicationName()) self.showNothing() self.setStyleSheet(''.join(imap(rc.qss, config.QT_STYLESHEETS)))
def downloader(self): from dl import Downloader ret = Downloader(self.q, self.networkAccessManager) ret.finished.connect(self._continue, Qt.QueuedConnection) ret.aborted.connect(self._retry) qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(ret.abort) return ret
def wraith(): matplotlib.rcParams['mathtext.fontset'] = 'stixsans' app = QCoreApplication.instance() app.form = Form() #style choices common to both modes QApplication.setStyle(QStyleFactory.create('Plastique')) QApplication.setPalette(QApplication.style().standardPalette()) #do it app.form.show()
def __init__(self, parent=None): self.__d = _NameInputManager() from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(self.hide) import dataman dataman.manager().loginChanged.connect(lambda name: name or self.hide())
def confirmQuit(): """ @return bool """ from PySide.QtCore import QCoreApplication appName = QCoreApplication.instance().applicationName() return Yes == QMessageBox.question(_parent(), appName, my.tr("Quit {0}?").format(appName), Yes | No, No)
def __init__(self, property = "speed", **kwargs): super(PaceSpeedColumn, self).__init__(property, **kwargs) self.what = kwargs.get("what") if not self.what: interval = kwargs.get("interval") session = interval.get_session() self.what = session.sessiontype.speedPace self.units = kwargs.get("units", QCoreApplication.instance().user.get_part("userprofile").units)
def authenticate(self): password = self.pwd.text() uid = self.email.text() savecreds = self.savecreds.isChecked() if QCoreApplication.instance().authenticate(uid, password, savecreds): self.accept() else: QMessageBox.critical(self, "Wrong Password", "The user ID and password entered do not match.")
def __init__(self, parent = None): super(MainWindow, self).__init__(parent) self.app = app = QCoreApplication.instance() self.setWindowTitle('Button Size Test') self.stupidSize = 3 self.dummyWidget = QFrame() self.dummyWidget.setFrameStyle(QFrame.Box) self.organizeContent(self.dummyWidget) self.setCentralWidget(self.dummyWidget)
def __init__(self): self.__d = _SubtitleEditorManager() from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(self.hide) import dataman dataman.manager().loginChanged.connect(lambda name: name or self.hide())
def __init__(self, path, parent=None): # unicode super(WbNetworkCookieJar, self).__init__(parent) self.path = path self.load() self._injectCookies() # Automatically save cookies using timer from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(self.save)
def __init__(self, parent = None, interval = None): super(RawDataList, self).__init__(parent = parent) query = sweattrails.session.Waypoint.query(parent = interval, keys_only = False) query.add_sort("timestamp") self.setQueryAndColumns(query, grumble.qt.model.TableColumn("timestamp", header = "Timestamp"), grumble.qt.model.TableColumn("location"), grumble.qt.model.TableColumn("elevation"), grumble.qt.model.TableColumn("corrected_elevation", header = "Corrected"), grumble.qt.model.TableColumn("speed"), grumble.qt.model.TableColumn("distance"), grumble.qt.model.TableColumn("cadence"), grumble.qt.model.TableColumn("heartrate"), grumble.qt.model.TableColumn("power"), grumble.qt.model.TableColumn("torque"), grumble.qt.model.TableColumn("temperature")) QCoreApplication.instance().refresh.connect(self.refresh)
def keyPressed(self, key): """ Called when the Game Engine gets a keyPressed event """ if key == Qt.Key_Left: self.level.ship.left() elif key == Qt.Key_Right: self.level.ship.right() elif key == Qt.Key_Down: self.level.ship.down() elif key == Qt.Key_Up: self.level.ship.up() elif key == Qt.Key_Space: if len(self.level.lasers) < LevelController.MAX_LASERS and not self.level.over and not self.level.paused: self.level.addLaser() self.window.addLaser() elif key == Qt.Key_Return or key == Qt.Key_Enter: if self.level.over: QCoreApplication.instance().quit() else: self.performPauseAction()
def __init__(self, parent=None): super(TopicEditorManager, self).__init__(parent) self.__d = _TopicEditorManager() from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(self.hide) import dataman dataman.manager().loginChanged.connect(lambda name: name or name == 'guest' or self.hide())
def getConfiguration(self): iniPath = self._getConfigurationFilePath() self._parseConfigFile(iniPath) # # Watch out for the method self._overrideConfigWithArgs when you're adding custom multi-word command line arguments # if self._config['language']: setLanguage(self._config['language']) self._argparser = argparse.ArgumentParser(description=getMessage("argument-description"), epilog=getMessage("argument-epilog")) self._argparser.add_argument('--no-gui', action='store_true', help=getMessage("nogui-argument")) self._argparser.add_argument('-a', '--host', metavar='hostname', type=str, help=getMessage("host-argument")) self._argparser.add_argument('-n', '--name', metavar='username', type=str, help=getMessage("name-argument")) self._argparser.add_argument('-d', '--debug', action='store_true', help=getMessage("debug-argument")) self._argparser.add_argument('-g', '--force-gui-prompt', action='store_true', help=getMessage("force-gui-prompt-argument")) self._argparser.add_argument('--no-store', action='store_true', help=getMessage("no-store-argument")) self._argparser.add_argument('-r', '--room', metavar='room', type=str, nargs='?', help=getMessage("room-argument")) self._argparser.add_argument('-p', '--password', metavar='password', type=str, nargs='?', help=getMessage("password-argument")) self._argparser.add_argument('--player-path', metavar='path', type=str, help=getMessage("player-path-argument")) self._argparser.add_argument('--language', metavar='language', type=str, help=getMessage("language-argument")) self._argparser.add_argument('file', metavar='file', type=lambda s: unicode(s, 'utf8'), nargs='?', help=getMessage("file-argument")) self._argparser.add_argument('--clear-gui-data', action='store_true', help=getMessage("clear-gui-data-argument")) self._argparser.add_argument('-v', '--version', action='store_true', help=getMessage("version-argument")) self._argparser.add_argument('_args', metavar='options', type=str, nargs='*', help=getMessage("args-argument")) args = self._argparser.parse_args() if args.version: print getMessage("version-message").format(version, milestone) sys.exit() self._overrideConfigWithArgs(args) if not self._config['noGui']: try: from PySide import QtGui # @UnresolvedImport from PySide.QtCore import QCoreApplication from syncplay.vendor import qt4reactor if QCoreApplication.instance() is None: self.app = QtGui.QApplication(sys.argv) qt4reactor.install() except ImportError: print getMessage("unable-import-gui-error") self._config['noGui'] = True if self._config['file'] and self._config['file'][:2] == "--": self._config['playerArgs'].insert(0, self._config['file']) self._config['file'] = None # Arguments not validated yet - booleans are still text values if self._config['language']: setLanguage(self._config['language']) if (self._config['forceGuiPrompt'] == "True" or not self._config['file']) and not self._config['noGui']: self._forceGuiPrompt() self._checkConfig() self._saveConfig(iniPath) if self._config['file']: self._config['loadedRelativePaths'] = self._loadRelativeConfiguration() if self._config['language']: setLanguage(self._config['language']) return self._config
def showFrameioDialog(self): """Shows the dialog""" self.frameioMainViewController.show() if not self.frameioSession.sessionHasValidCredentials: self.frameioMainViewController.showLoginView() else: self.frameioMainViewController.showUploadFilesView() self.frameioMainViewController.move(QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def testBlockingSignal(self): app = QCoreApplication.instance() or QCoreApplication([]) eventloop = QEventLoop() emitter = Emitter() receiver = Receiver(eventloop) emitter.connect(emitter, SIGNAL("signal(int)"), receiver.receive, Qt.BlockingQueuedConnection) emitter.start() retval = eventloop.exec_() emitter.wait() self.assertEqual(retval, 0)
def __init__(self, cmd, img): """Initialize executor. Args: cmd -- command to execute (str) img -- path to resulting image (the renderer output) (str) """ super().__init__(QCoreApplication.instance()) self.thread = QThread() self.worker = Worker(cmd, img) self.thread.setObjectName("fcd-renderexec")
def __init__(self): super(PySideEventLoop, self).__init__() qapp = QCoreApplication.instance() if qapp is None: qapp = QCoreApplication(sys.argv) self._qapp = qapp self._stop = False self._timers = set() self._readers = {} self._writers = {} self._processor = EventProcessor(qapp, self)
def showFrameioWidgetWithSelection(self, selection): """Saves the Username to the uistate.ini""" print "showUploadViewController : %s" % str(selection) self.frameioMainViewController.show(selection) if not self.frameioSession.sessionAuthenticated: self.frameioMainViewController.showLoginView() else: self.frameioMainViewController.showUploadView() self.frameioMainViewController.move(QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def testBlockingSignal(self): app = QCoreApplication.instance() or QCoreApplication([]) eventloop = QEventLoop() emitter = Emitter() receiver = Receiver(eventloop) emitter.connect(emitter, SIGNAL("signal(int)"), receiver.receive, Qt.BlockingQueuedConnection) emitter.start() retval = eventloop.exec_() emitter.wait() self.assertEqual(retval, 0)
def thread(cls): # -> OnlineThread not None if not cls._thread: t = cls._thread = OnlineThread() t.start() from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(t.destroy) growl.msg(my.tr("Load {0} for TTS").format("Windows Media Player")) return cls._thread
def solver(self): from clipconv import YouTubeSolver ret = YouTubeSolver(self.q) ret.setWebView(self.window.webView()) # This could crash? #ret.setParentWidget(self.window) ret.urlSolved.connect(self._save) ret.aborted.connect(self._retry) qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(ret.stop) return ret
def process_console(self): try: while True: cmd, data = self.input_queue.get_nowait() if cmd == 'console': for line in data: self.status_list.addItem(line) self.log.write(line + '\r\n') self.status_list.scrollToBottom() elif cmd == 'result': self.done = True if data: self.close() QCoreApplication.instance().quit() return QMessageBox.critical(self, 'Build failed', 'Build failed. Please check the ' 'build log.') pass except Queue.Empty: return
def showFrameioDialogWithSelection(self, selection): """Shows the dialog from the Bin View""" # We're not using the Export dialog, so use the normal flow self.frameioMainViewController.usingExportDialog = False self.frameioMainViewController.show() if not self.frameioSession.sessionAuthenticated: self.frameioMainViewController.showLoginView() else: self.frameioMainViewController.showUploadView() self.frameioMainViewController.move(QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def showFrameioDialog(self): """Shows the dialog""" self.frameioMainViewController.show() if not self.frameioSession.sessionHasValidCredentials: self.frameioMainViewController.showLoginView() else: self.frameioMainViewController.showUploadFilesView() self.frameioMainViewController.move( QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def _setuser(self): # FIXME - gripe should read from the session, which qt.app.SweatTrails # should manage user = QCoreApplication.instance().user if user != self.user: self.user = user userdir = gripe.user_dir(user.uid()) self.inbox = os.path.join(userdir, "inbox") gripe.mkdir(self.inbox) self.queue = os.path.join(userdir, "queue") gripe.mkdir(self.queue) done = os.path.join(userdir, "done") gripe.mkdir(done)
def showFrameioDialogWithSelection(self, selection): """Shows the dialog from the Bin View""" # We're not using the Export dialog, so use the normal flow self.frameioMainViewController.usingExportDialog = False self.frameioMainViewController.show() if not self.frameioSession.sessionAuthenticated: self.frameioMainViewController.showLoginView() else: self.frameioMainViewController.showUploadView() self.frameioMainViewController.move( QCoreApplication.instance().desktop().screen().rect().center() - self.frameioMainViewController.rect().center())
def __init__(self): _assert(in_main_thread()) self._reads = {} self._writes = {} self._notifiers = {} self._timer = QTimer() self._timer.setSingleShot(True) QObject.connect(self._timer, SIGNAL("timeout()"), self.iterate) self.qApp = QCoreApplication.instance() self._ownApp=False if self.qApp is None: self.qApp=QCoreApplication([]) self._ownApp=True self._blockApp = None posixbase.PosixReactorBase.__init__(self)
def appdata(): """ Return the path that application data should be stored in. This acts a bit special on Windows machines as Qt doesn't return the right path itself. """ if os.name == 'nt': path = os.getenv('APPDATA') app = QCoreApplication.instance() if app: if app.organizationName(): path = os.path.join(path, app.organizationName()) if app.applicationName(): path = os.path.join(path, app.applicationName()) return path return QDesktopServices.storageLocation(QDesktopServices.DataLocation)
def get_data_path(): """ Returns the path that application data should be stored in. This acts a bit special on Windows machines, using the APPDATA environment variable to ensure things go to AppData\Roaming and not AppData\Local. """ if os.name == 'nt': qapp = QCoreApplication.instance() path = os.getenv('APPDATA') if qapp.organizationName(): path = os.path.join(path, qapp.organizationName()) if qapp.applicationName(): path = os.path.join(path, qapp.applicationName()) return path return QDesktopServices.storageLocation(QDesktopServices.DataLocation)
def getConfiguration(self): iniPath = self._getConfigurationFilePath() self._parseConfigFile(iniPath) args = self._argparser.parse_args() self._overrideConfigWithArgs(args) #Arguments not validated yet - booleans are still text values if (self._config['forceGuiPrompt'] == "True" or not self._config['file']): self._forceGuiPrompt() self._checkConfig() self._saveConfig(iniPath) if (self._config['file']): self._loadRelativeConfiguration() if (not self._config['noGui']): from syncplay.vendor import qt4reactor if QCoreApplication.instance() is None: self.app = QtGui.QApplication(sys.argv) qt4reactor.install() return self._config
def __init__(self, q): ss = settings.global_() self._rubyEnabled = ss.isRubyEnabled() self._ttsEnabled = ss.isTtsEnabled() # cached self._fullTranslationEnabled = ss.isFullTranslationEnabled() # cached self._translationTipEnabled = ss.isTranslationTipEnabled() # cached self.loadProgress = 100 # int [0,100] self.visitedUrls = [] # [str url] self.closedUrls = [] # [str url] import jlpman, trman, ttsman self._jlpAvailable = jlpman.manager().isAvailable() # bool self._ttsAvailable = ttsman.manager().isAvailable() # bool self._translatorAvailable = trman.manager().isAvailable() # bool #layout = QtWidgets.QVBoxLayout() #layout.addWidget(self.addressWidget) #layout.addWidget(self.tabWidget) #w = QtWidgets.QWidget() #w.setLayout(layout) #layout.setContentsMargins(0, 0, 0, 0) #q.setCentralWidget(w) q.setCentralWidget(self.tabWidget) dock = SkTitlelessDockWidget(self.addressWidget) dock.setFeatures(QtWidgets.QDockWidget.NoDockWidgetFeatures) dock.setAllowedAreas(Qt.TopDockWidgetArea) q.addDockWidget(Qt.TopDockWidgetArea, dock) self._createShortcuts(q) self._createGestures() from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(self._onQuit) #self.newTabAfterCurrentWithBlankPage() self.loadVisitedUrls() self.loadClosedUrls()
def capture_pixmap(x, y, width, height, hwnd=None): """ @param x int @param y int @param width int @param height int @param hwnd int @return QPixmap """ if width < OCR_MIN_WIDTH or height < OCR_MIN_HEIGHT: dwarn("skip image that is too small: %sx%s" % (width, height)) return if hwnd: from sakurakit import skwidgets return QPixmap.grabWindow(skwidgets.to_wid(hwnd), x, y, width, height) else: from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() wid = qApp.desktop().winId() return QPixmap.grabWindow(wid, x, y, width, height)
def thread(self): # -> QThread if not self._thread: t = self._thread = SpeechRecognitionThread() t.setOnline(self.online) t.setLanguage(self.language) t.setDeviceIndex(self.deviceIndex) t.setDetectsQuiet(self.detectsQuiet) t.setSingleShot(self.singleShot) q = self.q t.textRecognized.connect(q.textRecognized, Qt.QueuedConnection) t.recognitionFinished.connect(self.onRecognitionFinished, Qt.QueuedConnection) from PySide.QtCore import QCoreApplication qApp = QCoreApplication.instance() qApp.aboutToQuit.connect(t.destroy) t.start() dprint("create thread") return self._thread