def load(check_string): line = self.p.jekyll_process.stdout.readline() if check_string in line: loadPreview() else: self.previewBox.setHtml(str(line)) QTimer.singleShot(20, lambda: load(check_string))
def shutdown(self, status=0): """Try to shutdown everything cleanly. For some reason lastWindowClosing sometimes seem to get emitted twice, so we make sure we only run once here. Args: status: The status code to exit with. """ if self._shutting_down: return self._shutting_down = True log.destroy.debug("Shutting down with status {}...".format(status)) deferrer = False for win_id in objreg.window_registry: prompter = objreg.get('prompter', None, scope='window', window=win_id) if prompter is not None and prompter.shutdown(): deferrer = True if deferrer: # If shutdown was called while we were asking a question, we're in # a still sub-eventloop (which gets quitted now) and not in the # main one. # This means we need to defer the real shutdown to when we're back # in the real main event loop, or we'll get a segfault. log.destroy.debug("Deferring real shutdown because question was " "active.") QTimer.singleShot(0, functools.partial(self._shutdown, status)) else: # If we have no questions to shut down, we are already in the real # event loop, so we can shut down immediately. self._shutdown(status)
def test_normal_exec(self): """Test exec_ without double-executing.""" self.loop = qtutils.EventLoop() QTimer.singleShot(100, self._assert_executing) QTimer.singleShot(200, self.loop.quit) self.loop.exec_() assert not self.loop._executing
def exceptionCaught(self, message, package = '', block = False): self.runPreExceptionMethods() if any(warning in message for warning in ('urlopen error','Socket Error', 'PYCURL ERROR')): errorTitle = i18n("Network Error") errorMessage = i18n("Please check your network connections and try again.") elif "Access denied" in message or "tr.org.pardus.comar.Comar.PolicyKit" in message: errorTitle = i18n("Authorization Error") errorMessage = i18n("You are not authorized for this operation.") elif "HTTP Error 404" in message and not package == '': errorTitle = i18n("Pisi Error") errorMessage = unicode(i18n("Package <b>%s</b> not found in repositories.<br>"\ "It may be upgraded or removed from the repository.<br>"\ "Please try upgrading repository informations.")) % package elif "MIXING PACKAGES" in message: errorTitle = i18n("Pisi Error") errorMessage = i18n("Mixing file names and package names not supported yet.") elif "FILE NOT EXISTS" in message: errorTitle = i18n("Pisi Error") errorMessage = unicode(i18n("File <b>%s</b> doesn't exists.")) % package elif "ALREADY RUNNING" in message: errorTitle = i18n("Pisi Error") errorMessage = i18n("Another instance of PiSi is running. Only one instance is allowed.") else: errorTitle = i18n("Pisi Error") errorMessage = message self.messageBox = QMessageBox(errorTitle, errorMessage, QMessageBox.Critical, QMessageBox.Ok, 0, 0) if block: self.messageBox.exec_() self.runPostExceptionMethods() else: QTimer.singleShot(0, self.messageBox.exec_) self.messageBox.buttonClicked.connect(self.runPostExceptionMethods)
def _call_cb(self, callback, found, text, flags, caller): """Call the given callback if it's non-None. Delays the call via a QTimer so the website is re-rendered in between. Args: callback: What to call found: If the text was found text: The text searched for flags: The flags searched with caller: Name of the caller. """ found_text = 'found' if found else "didn't find" # Removing FindWrapsAroundDocument to get the same logging as with # QtWebEngine debug_flags = debug.qflags_key( QWebPage, flags & ~QWebPage.FindWrapsAroundDocument, klass=QWebPage.FindFlag) if debug_flags != '0x0000': flag_text = 'with flags {}'.format(debug_flags) else: flag_text = '' log.webview.debug(' '.join([caller, found_text, text, flag_text]) .strip()) if callback is not None: QTimer.singleShot(0, functools.partial(callback, found))
def __send(self, fx, lang, fn, data): """ Private method to send a job request to one of the clients. @param fx remote function name to execute (str) @param lang language to connect to (str) @param fn filename for identification (str) @param data function argument(s) (any basic datatype) """ connection = self.connections.get(lang) if connection is None: if fx != 'INIT': # Avoid growing recursion deep which could itself result in an # exception QTimer.singleShot( 0, lambda: self.serviceNotAvailable.emit( fx, lang, fn, self.tr( '{0} not configured.').format(lang))) # Reset flag and continue processing queue self.isWorking = None self.__processQueue() else: packedData = json.dumps([fx, fn, data]) if sys.version_info[0] == 3: packedData = bytes(packedData, 'utf-8') header = struct.pack( b'!II', len(packedData), adler32(packedData) & 0xffffffff) connection.write(header) connection.write(packedData)
def on_newConnection(self): """ Private slot for new incomming connections from the clients. """ connection = self.nextPendingConnection() if not connection.waitForReadyRead(1000): return lang = connection.read(64) if sys.version_info[0] == 3: lang = lang.decode('utf-8') # Avoid hanging of eric on shutdown if self.connections.get(lang): self.connections[lang].close() if self.isWorking == lang: self.isWorking = None self.connections[lang] = connection connection.readyRead.connect( lambda x=lang: self.__receive(x)) connection.disconnected.connect( lambda x=lang: self.on_disconnectSocket(x)) for (fx, lng), args in self.services.items(): if lng == lang: # Register service with modulepath and module self.enqueueRequest('INIT', lng, fx, args[:2]) # Syntax check the open editors again try: vm = e5App().getObject("ViewManager") except KeyError: return for editor in vm.getOpenEditors(): if editor.getLanguage() == lang: QTimer.singleShot(0, editor.checkSyntax)
def mouseMoveEvent(self, evt): """ Protected method to handle mouse move events. @param evt reference to the mouse move event (QMouseEvent) """ if self.count() == 1: return E5WheelTabBar.mouseMoveEvent(self, evt) if Preferences.getHelp("ShowPreview"): # Find the tab under the mouse i = 0 tabIndex = -1 while i < self.count() and tabIndex == -1: if self.tabRect(i).contains(evt.pos()): tabIndex = i i += 1 # If found and not the current tab then show tab preview if tabIndex != -1 and \ tabIndex != self.currentIndex() and \ self.__currentTabPreviewIndex != tabIndex and \ evt.buttons() == Qt.NoButton: self.__currentTabPreviewIndex = tabIndex QTimer.singleShot(200, self.__showTabPreview) # If current tab or not found then hide previous tab preview if tabIndex == self.currentIndex() or \ tabIndex == -1: if self.__previewPopup is not None: self.__previewPopup.hide() self.__currentTabPreviewIndex = -1
def search(self, text, flags): """Search for text in the current page. Args: text: The text to search for. flags: The QWebPage::FindFlags. """ log.webview.debug("Searching with text '{}' and flags " "0x{:04x}.".format(text, int(flags))) widget = self.currentWidget() old_scroll_pos = widget.scroll_pos found = widget.findText(text, flags) if not found and not flags & QWebPage.HighlightAllOccurrences and text: message.error(self._win_id, "Text '{}' not found on " "page!".format(text), immediately=True) else: backward = int(flags) & QWebPage.FindBackward def check_scroll_pos(): """Check if the scroll position got smaller and show info.""" if not backward and widget.scroll_pos < old_scroll_pos: message.info(self._win_id, "Search hit BOTTOM, continuing " "at TOP", immediately=True) elif backward and widget.scroll_pos > old_scroll_pos: message.info(self._win_id, "Search hit TOP, continuing at " "BOTTOM", immediately=True) # We first want QWebPage to refresh. QTimer.singleShot(0, check_scroll_pos)
def __finish(self): """ Private slot called when the process finished or the user pressed the button. """ if self.process is not None and \ self.process.state() != QProcess.NotRunning: self.process.terminate() QTimer.singleShot(2000, self.process.kill) self.process.waitForFinished(3000) self.buttonBox.button(QDialogButtonBox.Close).setEnabled(True) self.buttonBox.button(QDialogButtonBox.Cancel).setEnabled(False) self.buttonBox.button(QDialogButtonBox.Close).setDefault(True) self.inputGroup.setEnabled(False) self.inputGroup.hide() if len(self.changeListsDict) == 0: self.changeLists.addItem(self.tr("No changelists found")) self.buttonBox.button(QDialogButtonBox.Close).setFocus( Qt.OtherFocusReason) else: self.changeLists.addItems(sorted(self.changeListsDict.keys())) self.changeLists.setCurrentRow(0) self.changeLists.setFocus(Qt.OtherFocusReason)
def __init__(self, filepath=None): QObject.__init__(self) QTimer.singleShot(0, self.__launchTimerTimedOut) self.prefs = Preferences() self.prefs.load() global APP_PREFS APP_PREFS = self.prefs locale = QLocale.system() dateFormat = self.prefs.dateFormat decimalSep = locale.decimalPoint() groupingSep = locale.groupSeparator() cachePath = QStandardPaths.standardLocations(QStandardPaths.CacheLocation)[0] DateEdit.DATE_FORMAT = dateFormat self.model = MoneyGuruModel( view=self, date_format=dateFormat, decimal_sep=decimalSep, grouping_sep=groupingSep, cache_path=cachePath ) self.mainWindow = MainWindow(app=self) self.preferencesPanel = PreferencesPanel(self.mainWindow, app=self) self.aboutBox = AboutBox(self.mainWindow, self) self.initialFilePath = None if filepath and op.exists(filepath): self.initialFilePath = filepath elif self.prefs.recentDocuments: self.initialFilePath = self.prefs.recentDocuments[0] self.finishedLaunching.connect(self.applicationFinishedLaunching) QCoreApplication.instance().aboutToQuit.connect(self.applicationWillTerminate)
def load(self, name, temp=False): """Load a named session. Args: name: The name of the session to load. temp: If given, don't set the current session. """ path = self._get_session_path(name, check_exists=True) try: with open(path, encoding='utf-8') as f: data = yaml.load(f, Loader=YamlLoader) except (OSError, UnicodeDecodeError, yaml.YAMLError) as e: raise SessionError(e) log.sessions.debug("Loading session {} from {}...".format(name, path)) for win in data['windows']: window = mainwindow.MainWindow(geometry=win['geometry']) window.show() tabbed_browser = objreg.get('tabbed-browser', scope='window', window=window.win_id) tab_to_focus = None for i, tab in enumerate(win['tabs']): new_tab = tabbed_browser.tabopen() self._load_tab(new_tab, tab) if tab.get('active', False): tab_to_focus = i if tab_to_focus is not None: tabbed_browser.setCurrentIndex(tab_to_focus) if win.get('active', False): QTimer.singleShot(0, tabbed_browser.activateWindow) self.did_load = True if not name.startswith('_') and not temp: self._current = name
def newScreenshot(self): if self.hideThisWindowCheckBox.isChecked(): self.hide() self.newScreenshotButton.setDisabled(True) QTimer.singleShot(self.delaySpinBox.value() * 1000, self.shootScreen)
def __init__(self): """ Constructor """ super(SnapshotFreehandGrabber, self).__init__( None, Qt.X11BypassWindowManagerHint | Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint | Qt.Tool) self.__selection = QPolygon() self.__mouseDown = False self.__newSelection = False self.__handleSize = 10 self.__showHelp = True self.__grabbing = False self.__dragStartPoint = QPoint() self.__selectionBeforeDrag = QPolygon() self.__locale = QLocale() self.__helpTextRect = QRect() self.__helpText = self.tr( "Select a region using the mouse. To take the snapshot," " press the Enter key or double click. Press Esc to quit.") self.__pixmap = QPixmap() self.__pBefore = QPoint() self.setMouseTracking(True) QTimer.singleShot(200, self.__initialize)
def __finish(self): """ Private slot called when the process finished or the user pressed the button. """ if self.process is not None and \ self.process.state() != QProcess.NotRunning: self.process.terminate() QTimer.singleShot(2000, self.process.kill) self.process.waitForFinished(3000) self.inputGroup.setEnabled(False) self.inputGroup.hide() self.buttonBox.button(QDialogButtonBox.Close).setEnabled(True) self.buttonBox.button(QDialogButtonBox.Cancel).setEnabled(False) self.buttonBox.button(QDialogButtonBox.Close).setDefault(True) self.buttonBox.button(QDialogButtonBox.Close).setFocus( Qt.OtherFocusReason) if self.patchesList.topLevelItemCount() == 0: # no patches present self.__generateItem( 0, "", self.tr("no patches found"), "", True) self.__resizeColumns() self.__resort()
def _setup(self): core.pe.photo.PLAT_SPECIFIC_PHOTO_CLASS = PlatSpecificPhoto self._setupActions() self._update_options() self.recentResults = Recent(self, 'recentResults') self.recentResults.mustOpenItem.connect(self.model.load_from) self.resultWindow = None self.details_dialog = None self.directories_dialog = DirectoriesDialog(self) self.progress_window = ProgressWindow(self.directories_dialog, self.model.progress_window) self.problemDialog = ProblemDialog(parent=self.directories_dialog, model=self.model.problem_dialog) self.ignoreListDialog = IgnoreListDialog(parent=self.directories_dialog, model=self.model.ignore_list_dialog) self.deletionOptions = DeletionOptions(parent=self.directories_dialog, model=self.model.deletion_options) self.about_box = AboutBox(self.directories_dialog, self) self.directories_dialog.show() self.model.load() self.SIGTERM.connect(self.handleSIGTERM) # The timer scheme is because if the nag is not shown before the application is # completely initialized, the nag will be shown before the app shows up in the task bar # In some circumstances, the nag is hidden by other window, which may make the user think # that the application haven't launched. QTimer.singleShot(0, self.finishedLaunching)
def execute(self): if not self.timer.isActive() or self.is_date_changed: QTimer.singleShot(500, self.setTime) self.timer.stop() index = self.ui.countryList.currentIndex() ctx.installData.timezone = self.ui.countryList.itemData(index) ctx.logger.debug("Time zone selected as %s " % ctx.installData.timezone) if ctx.flags.install_type == ctx.STEP_BASE: #FIXME:Refactor hacky code ctx.installData.rootPassword = ctx.consts.default_password ctx.installData.hostName = yali.util.product_release() if ctx.storageInitialized: disks = filter(lambda d: not d.format.hidden, ctx.storage.disks) if len(disks) == 1: ctx.storage.clearPartDisks = [disks[0].name] ctx.mainScreen.step_increment = 2 else: ctx.mainScreen.step_increment = 1 return True else: self.pds_messagebox.setMessage(_("Storage Devices initialising...")) self.pds_messagebox.animate(start=MIDCENTER, stop=MIDCENTER) ctx.mainScreen.step_increment = 0 self.pthread.start() QTimer.singleShot(2, self.startStorageInitialize) return False return True
def _click(self, elem, context): """Click an element. Args: elem: The QWebElement to click. context: The HintContext to use. """ target_mapping = { Target.normal: usertypes.ClickTarget.normal, Target.current: usertypes.ClickTarget.normal, Target.tab_fg: usertypes.ClickTarget.tab, Target.tab_bg: usertypes.ClickTarget.tab_bg, Target.window: usertypes.ClickTarget.window, Target.hover: usertypes.ClickTarget.normal, } if config.get('tabs', 'background-tabs'): target_mapping[Target.tab] = usertypes.ClickTarget.tab_bg else: target_mapping[Target.tab] = usertypes.ClickTarget.tab # FIXME Instead of clicking the center, we could have nicer heuristics. # e.g. parse (-webkit-)border-radius correctly and click text fields at # the bottom right, and everything else on the top left or so. # https://github.com/The-Compiler/qutebrowser/issues/70 pos = elem.rect_on_view().center() action = "Hovering" if context.target == Target.hover else "Clicking" log.hints.debug("{} on '{}' at {}/{}".format( action, elem, pos.x(), pos.y())) self.start_hinting.emit(target_mapping[context.target]) if context.target in [Target.tab, Target.tab_fg, Target.tab_bg, Target.window]: modifiers = Qt.ControlModifier else: modifiers = Qt.NoModifier events = [ QMouseEvent(QEvent.MouseMove, pos, Qt.NoButton, Qt.NoButton, Qt.NoModifier), ] if context.target != Target.hover: events += [ QMouseEvent(QEvent.MouseButtonPress, pos, Qt.LeftButton, Qt.LeftButton, modifiers), QMouseEvent(QEvent.MouseButtonRelease, pos, Qt.LeftButton, Qt.NoButton, modifiers), ] if context.target in [Target.normal, Target.current]: # Set the pre-jump mark ', so we can jump back here after following tabbed_browser = objreg.get('tabbed-browser', scope='window', window=self._win_id) tabbed_browser.set_mark("'") if context.target == Target.current: elem.remove_blank_target() for evt in events: self.mouse_event.emit(evt) if elem.is_text_input() and elem.is_editable(): QTimer.singleShot(0, functools.partial( elem.webFrame().page().triggerAction, QWebPage.MoveToEndOfDocument)) QTimer.singleShot(0, self.stop_hinting.emit)
def startShellGui(workflow_cmdline_args, preinit_funcs, postinit_funcs): """ Create an application and launch the shell in it. """ """ The next two lines fix the following xcb error on Ubuntu by calling X11InitThreads before loading the QApplication: [xcb] Unknown request in queue while dequeuing [xcb] Most likely this is a multi-threaded client and XInitThreads has not been called [xcb] Aborting, sorry about that. python: ../../src/xcb_io.c:178: dequeue_pending_request: Assertion !xcb_xlib_unknown_req_in_deq failed. """ platform_str = platform.platform().lower() if 'ubuntu' in platform_str or 'fedora' in platform_str or 'debian' in platform_str: QApplication.setAttribute(Qt.AA_X11InitThreads, True) if ilastik.config.cfg.getboolean("ilastik", "debug"): QApplication.setAttribute(Qt.AA_DontUseNativeMenuBar, True) app = QApplication([]) _applyStyleSheet(app) splashScreen.showSplashScreen() app.processEvents() QTimer.singleShot( 0, functools.partial(launchShell, workflow_cmdline_args, preinit_funcs, postinit_funcs ) ) QTimer.singleShot( 0, splashScreen.hideSplashScreen) return app.exec_()
def slot_handlePatchbayClientAddedCallback(self, clientId, clientIcon, pluginId, clientName): pcSplit = patchcanvas.SPLIT_UNDEF pcIcon = patchcanvas.ICON_APPLICATION if clientIcon == PATCHBAY_ICON_PLUGIN: pcIcon = patchcanvas.ICON_PLUGIN if clientIcon == PATCHBAY_ICON_HARDWARE: pcIcon = patchcanvas.ICON_HARDWARE elif clientIcon == PATCHBAY_ICON_CARLA: pass elif clientIcon == PATCHBAY_ICON_DISTRHO: pcIcon = patchcanvas.ICON_DISTRHO elif clientIcon == PATCHBAY_ICON_FILE: pcIcon = patchcanvas.ICON_FILE patchcanvas.addGroup(clientId, clientName, pcSplit, pcIcon) QTimer.singleShot(0, self.fMiniCanvasPreview.update) if pluginId < 0: return if pluginId >= self.fPluginCount: print("sorry, can't map this plugin to canvas client", pluginId, self.fPluginCount) return patchcanvas.setGroupAsPlugin(clientId, pluginId, bool(self.host.get_plugin_info(pluginId)['hints'] & PLUGIN_HAS_CUSTOM_UI))
def loadSettings(self, firstTime): qsettings = QSettings() websettings = self.ui.webview.settings() self.fSavedSettings = { # WebView MOD_KEY_WEBVIEW_INSPECTOR: qsettings.value(MOD_KEY_WEBVIEW_INSPECTOR, MOD_DEFAULT_WEBVIEW_INSPECTOR, type=bool), MOD_KEY_WEBVIEW_SHOW_INSPECTOR: qsettings.value(MOD_KEY_WEBVIEW_SHOW_INSPECTOR, MOD_DEFAULT_WEBVIEW_SHOW_INSPECTOR, type=bool) } inspectorEnabled = self.fSavedSettings[MOD_KEY_WEBVIEW_INSPECTOR] and not USING_LIVE_ISO websettings.setAttribute(QWebSettings.DeveloperExtrasEnabled, inspectorEnabled) if firstTime: self.restoreGeometry(qsettings.value("Geometry", "")) if inspectorEnabled and self.fSavedSettings[MOD_KEY_WEBVIEW_SHOW_INSPECTOR]: QTimer.singleShot(1000, self.ui.webinspector.show) self.ui.act_file_inspect.setVisible(inspectorEnabled) if self.fIdleTimerId != 0: self.killTimer(self.fIdleTimerId) self.fIdleTimerId = self.startTimer(MOD_DEFAULT_MAIN_REFRESH_INTERVAL)
def cb_import_extract(result): script_instance = script_instance_ref[0] if script_instance != None: aborted = script_instance.abort else: aborted = False script_instance_ref[0] = None if aborted: return if not report_script_result(result, 'Import Error', 'Could not extract archive', before_message_box=self.progress.close): return def cb_restart_reboot_shutdown(result): self.progress.close() report_script_result(result, 'Import Error', 'Could not reboot RED Brick to finish program import') # step 4/4: reboot self.progress.setLabelText('Step 4 of 4: Rebooting RED Brick') self.progress.setRange(0, 0) self.script_manager.execute_script('restart_reboot_shutdown_systemd', cb_restart_reboot_shutdown, ['1']) def close_progress(): # use a closure to capture self and ansure that it's safe # to call this even if the tab was official destroyed already self.progress.close() QTimer.singleShot(1500, close_progress)
def play(self, fromStart=True, force=False): item = self.targetObject() # If the item that this animation controls in currently under the # control of another animation, stop that animation first. if item.currentAnimation is not None: item.currentAnimation.stop() item.currentAnimation = self if Colors.noAnimations and not force: # If animations are disabled just move to the end position. item.setPos(self.endValue()) else: if self.isVisible(): # If the item is already visible, start the animation from the # item's current position rather than from the start. self.setStartValue(item.pos()) if fromStart: self.setCurrentTime(0) item.setPos(self.startValue()) if self._inOrOut == DemoItemAnimation.ANIM_IN: item.setRecursiveVisible(True) if not Colors.noAnimations or force: if self._startDelay: QTimer.singleShot(self._startDelay, self.start) else: self.start()
def show_alert(self, title, text, urgency = None, force = False, buttons = None): # NOTE: there is no support for buttons via QSystemTrayIcon. if ((title, text) == self.last_alert) and not force: return def _action_activate_cb(action_num): if not buttons: return try: action_info = buttons[action_num - 1] except IndexError: return _action_id, _button_name, button_callback = action_info button_callback() def do_show(): if not self._window.supportsMessages(): const_debug_write("show_alert", "messages not supported.") return icon_id = QSystemTrayIcon.Information if urgency == "critical": icon_id = QSystemTrayIcon.Critical self._window.showMessage(title, text, icon_id) self.last_alert = (title, text) QTimer.singleShot(0, do_show)
def extract(self, location: Location, directory_watcher, stdio) -> Optional[ArchiveExtractor]: extractor = self._extractors.get(location, None) if extractor is not None: return extractor # extraction already running or queued outdir = self._make_extractor_outdir(location) if not os.path.isdir(outdir): extractor = ArchiveExtractor(stdio.get_stdio_name(location.origin()), outdir) self._extractors[location] = extractor extractor.sig_started.connect(lambda extractor: self._on_archive_extractor_started(extractor)) extractor.sig_finished.connect(lambda extractor, d=directory_watcher: self._on_archive_extractor_finished(extractor, d)) if self.get_running_extractor_count() < self._max_extractors: extractor.start() else: self._queued_extractors.append(extractor) return extractor else: status_file = os.path.join(outdir, "status.json") status = ExtractorStatus.from_file(status_file) if status.status() == ExtractorResult.FAILURE: def send_message(dw=directory_watcher, message=status.message()): dw.sig_message.emit(status.message()) # FIXME: this is a bit of a crude hack to # communicate the message to the user QTimer.singleShot(0, send_message) logger.error("%s: archive exist, but is broken: %s", location, status.message()) return None
def handlelink(self, url): urlstr = url.toString() log("handling link : %s" % urlstr) #check if url is for the current page if url.matches(self.url(), QUrl.RemoveFragment): #do nothing, probably a JS link return True #check other windows to see if url is loaded there for window in self.parent.windows: if url.matches(window.url(), QUrl.RemoveFragment): window.raise_() window.activateWindow() #if this is a tree window and not the main one, close it if self.url().toString().startswith(self.parent.homepage + "/tree") and not self.main: QTimer.singleShot(0, self.close) #calling self.close() is no good return True if "/files/" in urlstr: #save, don't load new page self.parent.savefile(url) elif "/tree/" in urlstr or urlstr.startswith(self.parent.homepage + "/tree"): #keep in same window self.load(url) else: #open in new window newwindow = self.createWindow(QWebPage.WebBrowserWindow, js=False) newwindow.load(url) #if this is a tree window and not the main one, close it if self.url().toString().startswith(self.parent.homepage + "/tree") and not self.main: QTimer.singleShot(0, self.close) #calling self.close() is no good return True
def main() -> None: signal.signal(signal.SIGINT, signal.SIG_DFL) app = QCoreApplication([]) testo = Testo() # This is causing the problem def a() -> None: # Using 'app' in a local function seems to be what requires # the manual 'del app' call, otherwise the garbage collector # needs to do the cleanup and probably comes to late, as # another QCoreApplication instance might have already been # created. print(app) # As long as the function isn't using 'app' everything seems to be # ok. def b() -> None: print("nothing") # If 'b' is used instead of 'a' the problem goes away testo.sig_test.connect(a) QTimer.singleShot(1000, app.quit) print("exec") app.exec() print("exec:done")
def test_collector(self): app = QApplication([]) try: vfs = StdioFilesystem("/tmp") metadata_collector = MetaDataCollector(vfs) def on_metadata(filename, metadata): print(filename) print(metadata) print() metadata_collector.sig_metadata_ready.connect(on_metadata) metadata_collector.request_metadata(Location.from_path("dirtools/fileview/icons/noun_409399_cc.png")) QTimer.singleShot(500, metadata_collector.close) QTimer.singleShot(1500, app.quit) app.exec() except Exception as err: print(err) finally: metadata_collector.close() vfs.close()
def on_current_changed(self, idx): """Set last-focused-tab and leave hinting mode when focus changed.""" if idx == -1 or self._shutting_down: # closing the last tab (before quitting) or shutting down return tab = self.widget(idx) log.modes.debug("Current tab changed, focusing {!r}".format(tab)) tab.setFocus() for mode in (usertypes.KeyMode.hint, usertypes.KeyMode.insert, usertypes.KeyMode.caret, usertypes.KeyMode.passthrough): modeman.maybe_leave(self._win_id, mode, 'tab changed') if self._now_focused is not None: objreg.register('last-focused-tab', self._now_focused, update=True, scope='window', window=self._win_id) ai = False for r in pt_masks: if re.match(r, tab.url().host()) is not None: ai = True break if ai: modeman.enter(self._win_id, usertypes.KeyMode.passthrough, 'load finished', only_if_normal=True) self._now_focused = tab self.current_tab_changed.emit(tab) QTimer.singleShot(0, self.update_window_title) self._tab_insert_idx_left = self.currentIndex() self._tab_insert_idx_right = self.currentIndex() + 1
def cancel(self): self.widget.hide() self.busy.show() self.actionLabel.setText(i18n("<b>Cancelling operation...</b>")) self.disableCancel() QTimer.singleShot(100, self.iface.cancel)
def __init__(self, win_id, parent=None): super().__init__(parent) objreg.register('statusbar', self, scope='window', window=win_id) self.setObjectName(self.__class__.__name__) self.setAttribute(Qt.WA_StyledBackground) style.set_register_stylesheet(self) self.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed) self._win_id = win_id self._option = None self._stopwatch = QTime() self._hbox = QHBoxLayout(self) self.set_hbox_padding() objreg.get('config').changed.connect(self.set_hbox_padding) self._hbox.setSpacing(5) self._stack = QStackedLayout() self._hbox.addLayout(self._stack) self._stack.setContentsMargins(0, 0, 0, 0) self.cmd = command.Command(win_id) self._stack.addWidget(self.cmd) objreg.register('status-command', self.cmd, scope='window', window=win_id) self.txt = textwidget.Text() self._stack.addWidget(self.txt) self._timer_was_active = False self._text_queue = collections.deque() self._text_pop_timer = usertypes.Timer(self, 'statusbar_text_pop') self._text_pop_timer.timeout.connect(self._pop_text) self.set_pop_timer_interval() objreg.get('config').changed.connect(self.set_pop_timer_interval) self.prompt = prompt.Prompt(win_id) self._stack.addWidget(self.prompt) self._previous_widget = PreviousWidget.none self.cmd.show_cmd.connect(self._show_cmd_widget) self.cmd.hide_cmd.connect(self._hide_cmd_widget) self._hide_cmd_widget() prompter = objreg.get('prompter', scope='window', window=self._win_id) prompter.show_prompt.connect(self._show_prompt_widget) prompter.hide_prompt.connect(self._hide_prompt_widget) self._hide_prompt_widget() self.keystring = keystring.KeyString() self._hbox.addWidget(self.keystring) self.url = url.UrlText() self._hbox.addWidget(self.url) self.percentage = percentage.Percentage() self._hbox.addWidget(self.percentage) self.tabindex = tabindex.TabIndex() self._hbox.addWidget(self.tabindex) # We add a parent to Progress here because it calls self.show() based # on some signals, and if that happens before it's added to the layout, # it will quickly blink up as independent window. self.prog = progress.Progress(self) self._hbox.addWidget(self.prog) objreg.get('config').changed.connect(self.maybe_hide) QTimer.singleShot(0, self.maybe_hide)
def __init__(self): super(MainWindow, self).__init__() self.ui = loadUi(join(execPath, "../share/imblproc/imbl-bct.ui"), self) self.ui.tabWidget.tabBar().setExpanding(True) for errLabel in self.ui.findChildren(QtWidgets.QLabel, QtCore.QRegExp("^err\\w+")): self.showWdg(errLabel, False) self.ui.distanceR.addItems(list(distances)) self.ui.energyR.addItems(list(energies)) self.proc.setProgram("/bin/bash") if isdir(dataPath) : selection = self.ui.expSelect selection.setEnabled(False) selection.clear() selection.addItem("Loading...") self.update() QtCore.QCoreApplication.processEvents() for name in sorted(os.listdir(dataPath)) : expPath = join(dataPath, name) if isdir(join(expPath, "input")): selection.addItem(name, expPath) selection.removeItem(0) # Loading... if selection.count() : selection.setEnabled(True) else : selection.addItem("<none>") self.configObjects = ( self.ui.outAuto, self.ui.expPath, self.ui.inPath, self.ui.outPath, self.ui.trimL, self.ui.trimR, self.ui.trimT, self.ui.trimB, self.ui.energyR, self.ui.distanceR, self.ui.ring, self.ui.autoCor, self.ui.cor, self.ui.set1, self.ui.set2, self.ui.set4 ) for swdg in self.configObjects: if isinstance(swdg, QtWidgets.QLineEdit): swdg.textChanged.connect(self.saveConfiguration) elif isinstance(swdg, QtWidgets.QCheckBox): swdg.toggled.connect(self.saveConfiguration) elif isinstance(swdg, QtWidgets.QAbstractSpinBox): swdg.valueChanged.connect(self.saveConfiguration) elif isinstance(swdg, QtWidgets.QComboBox): swdg.currentTextChanged.connect(self.saveConfiguration) def onBrowse(target, lineEdit): newPath = QFileDialog.getExistingDirectory(self, target + " directory", lineEdit.text()) setVText(lineEdit, newPath, str) def onSelect(lineEdit): newPath = self.sender().currentData() setVText(lineEdit, newPath, str) self.ui.expBrowse.clicked.connect(lambda: onBrowse("Experiment", self.ui.expPath)) self.ui.expSelect.activated.connect(lambda: onSelect(self.ui.expPath)) self.ui.expPath.textChanged.connect(self.onNewExperiment) self.ui.inBrowse.clicked.connect(lambda: onBrowse("Sample input", self.ui.inPath)) self.ui.inSelect.activated.connect(lambda: onSelect(self.ui.inPath)) self.ui.inPath.textChanged.connect(lambda: (self.onNewSample(), self.setOutPath())) self.ui.outBrowse.clicked.connect(lambda: onBrowse("Sample output", self.ui.outPath)) self.ui.outAuto.toggled.connect(self.setOutPath) self.ui.outPath.textChanged.connect(lambda: self.setOutPath(False)) self.ui.ring.valueChanged[int].connect(lambda val: self.ui.ring.setStyleSheet("" if not val or val % 2 else badStyle)) self.ui.goStitch.clicked.connect(self.onStitch) self.ui.testMe.clicked.connect(self.onRec) self.ui.goRec.clicked.connect(self.onRec) QtCore.QTimer.singleShot(100, self.loadConfiguration) QTimer.singleShot(0, (lambda: self.resize(self.minimumSizeHint())))
def showWdg(self, wdg, showme=True): wdg.setVisible(showme) QTimer.singleShot(0, (lambda: self.resize(self.minimumSizeHint())))
def __init__(self, parent=None): QDialog.__init__(self, parent) self.setWindowTitle('show_gif') self.setWindowIcon(QIcon('image/Capture_64px.png')) self.setWindowFlags(self.windowFlags() | Qt.WindowMinMaxButtonsHint) # self.resize(400,400) self.setFixedSize(800, 600) mainl = QVBoxLayout(self) self.labelShow = QLabel() self.labelShow.setContentsMargins(0, 0, 0, 0) pat = self.labelShow.palette() pat.setBrush(QPalette.Background, Qt.darkGray) self.labelShow.setAutoFillBackground(True) self.labelShow.setPalette(pat) self.labelShow.setAlignment(Qt.AlignCenter) # self.labelShow.setScaledContents(True) mainl.addWidget(self.labelShow, 1) line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) mainl.addWidget(line) btnLay = QHBoxLayout() frmLay = QFormLayout() self._spinBox = QSpinBox() frmLay.addRow('跳转:', self._spinBox) btnGo = QPushButton('Go', self) btnPrev = QPushButton('上一张', self) self.btnNext = QPushButton('下一张', self) btnPrev.clicked.connect(self.on_prev) self.btnNext.clicked.connect(self.on_next) btnGo.clicked.connect(lambda: self.flashMovie(self._spinBox.value())) self._spinBox.valueChanged.connect(lambda n: self.flashMovie(n)) btnLay.addStretch() btnLay.addLayout(frmLay) btnLay.addWidget(btnGo) btnLay.addWidget(btnPrev) btnLay.addWidget(self.btnNext) btnLay.addStretch() mainl.addLayout(btnLay) labLay = QHBoxLayout() labLay.setSpacing(10) self._label = QLabel() frm1 = QFormLayout() frm1.addRow('共:', self._label) frm1.setRowWrapPolicy(QFormLayout.WrapLongRows) labLay.addStretch() labLay.addLayout(frm1) frm1 = QFormLayout() self._labInfo = QLabel() # self._labInfo.setWordWrap(True) frm1.addRow('当前:', self._labInfo) # frm1.setFieldGrowthPolicy(QFormLayout.ExpandingFieldsGrow) frm1.setRowWrapPolicy(QFormLayout.WrapLongRows) labLay.addLayout(frm1) frm1 = QFormLayout() self._labPlay = QLabel() frm1.addRow('播放帧号:', self._labPlay) labLay.addLayout(frm1) frm1.setRowWrapPolicy(QFormLayout.WrapLongRows) labLay.addStretch() labLay.setSpacing(10) line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) mainl.addWidget(line) mainl.addLayout(labLay) self._gifs = [] self._movie = QMovie() self.labelShow.setMovie(self._movie) QTimer.singleShot(0, self.on_firstShow) self._picIndex = 0 self._movie.frameChanged.connect(self.on_frameChange)
def __init__(self, parent, view1, view2, view3, view4=None): QWidget.__init__(self, parent) self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.installEventFilter(self) self.dockableContainer = [] self.layout = QVBoxLayout() self.setLayout(self.layout) self.layout.setContentsMargins(0, 0, 0, 0) self.layout.setSpacing(0) self.splitVertical = QSplitter(Qt.Vertical, self) self.layout.addWidget(self.splitVertical) self.splitHorizontal1 = QSplitter(Qt.Horizontal, self.splitVertical) self.splitHorizontal1.setObjectName("splitter1") self.splitHorizontal2 = QSplitter(Qt.Horizontal, self.splitVertical) self.splitHorizontal2.setObjectName("splitter2") self.splitHorizontal1.splitterMoved.connect( self.horizontalSplitterMoved) self.splitHorizontal2.splitterMoved.connect( self.horizontalSplitterMoved) self.imageView2D_1 = view1 self.imageView2D_2 = view2 self.imageView2D_3 = view3 self.dock1_ofSplitHorizontal1 = ImageView2DDockWidget( self.imageView2D_1) self.dock1_ofSplitHorizontal1.connectHud() self.dockableContainer.append(self.dock1_ofSplitHorizontal1) self.dock1_ofSplitHorizontal1.onDockButtonClicked.connect( lambda arg=self.dock1_ofSplitHorizontal1: self.on_dock(arg)) self.dock1_ofSplitHorizontal1.onMaxButtonClicked.connect( lambda arg=self.dock1_ofSplitHorizontal1: self.on_max(arg)) self.dock1_ofSplitHorizontal1.onMinButtonClicked.connect( lambda arg=self.dock1_ofSplitHorizontal1: self.on_min(arg)) self.splitHorizontal1.addWidget(self.dock1_ofSplitHorizontal1) self.dock2_ofSplitHorizontal1 = ImageView2DDockWidget( self.imageView2D_2) self.dock2_ofSplitHorizontal1.onDockButtonClicked.connect( lambda arg=self.dock2_ofSplitHorizontal1: self.on_dock(arg)) self.dock2_ofSplitHorizontal1.onMaxButtonClicked.connect( lambda arg=self.dock2_ofSplitHorizontal1: self.on_max(arg)) self.dock2_ofSplitHorizontal1.onMinButtonClicked.connect( lambda arg=self.dock2_ofSplitHorizontal1: self.on_min(arg)) self.dock2_ofSplitHorizontal1.connectHud() self.dockableContainer.append(self.dock2_ofSplitHorizontal1) self.splitHorizontal1.addWidget(self.dock2_ofSplitHorizontal1) self.dock1_ofSplitHorizontal2 = ImageView2DDockWidget( self.imageView2D_3) self.dock1_ofSplitHorizontal2.onDockButtonClicked.connect( lambda arg=self.dock1_ofSplitHorizontal2: self.on_dock(arg)) self.dock1_ofSplitHorizontal2.onMaxButtonClicked.connect( lambda arg=self.dock1_ofSplitHorizontal2: self.on_max(arg)) self.dock1_ofSplitHorizontal2.onMinButtonClicked.connect( lambda arg=self.dock1_ofSplitHorizontal2: self.on_min(arg)) self.dock1_ofSplitHorizontal2.connectHud() self.dockableContainer.append(self.dock1_ofSplitHorizontal2) self.splitHorizontal2.addWidget(self.dock1_ofSplitHorizontal2) self.dock2_ofSplitHorizontal2 = ImageView2DDockWidget(view4) self.dockableContainer.append(self.dock2_ofSplitHorizontal2) self.splitHorizontal2.addWidget(self.dock2_ofSplitHorizontal2) # this is a hack: with 0 ms it does not work... QTimer.singleShot(250, self._resizeEqual)
def hgLfconvert(self, direction, projectFile): """ Public slot to convert the repository format of the current project. @param direction direction of the conversion (string, one of 'largefiles' or 'normal') @param projectFile file name of the current project file (string) """ assert direction in ["largefiles", "normal"] projectDir = os.path.dirname(projectFile) # find the root of the repo repodir = projectDir while not os.path.isdir(os.path.join(repodir, self.vcs.adminDir)): repodir = os.path.dirname(repodir) if os.path.splitdrive(repodir)[1] == os.sep: return from .LfConvertDataDialog import LfConvertDataDialog dlg = LfConvertDataDialog(projectDir, direction) if dlg.exec_() == QDialog.Accepted: newName, minSize, patterns = dlg.getData() newProjectFile = os.path.join(newName, os.path.basename(projectFile)) # step 1: convert the current project to new project args = self.vcs.initCommand("lfconvert") if direction == 'normal': args.append('--to-normal') else: args.append("--size") args.append(str(minSize)) args.append(projectDir) args.append(newName) if direction == 'largefiles' and patterns: args.extend(patterns) dia = HgDialog(self.tr('Convert Project - Converting'), self.vcs) res = dia.startProcess(args, repodir) if res: dia.exec_() res = dia.normalExit() and os.path.isdir( os.path.join(newName, self.vcs.adminDir)) # step 2: create working directory contents if res: args = self.vcs.initCommand("update") args.append("--verbose") dia = HgDialog(self.tr('Convert Project - Extracting'), self.vcs, useClient=False) res = dia.startProcess(args, newName) if res: dia.exec_() res = dia.normalExit() and os.path.isfile(newProjectFile) # step 3: close current project and open new one if res: if direction == 'largefiles': self.vcs.hgEditConfig(newName, largefilesData={ "minsize": minSize, "pattern": patterns }) else: self.vcs.hgEditConfig(newName, withLargefiles=False) QTimer.singleShot( 0, lambda: e5App().getObject("Project").openProject( newProjectFile))
def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.mdi = QMdiArea() self.setCentralWidget(self.mdi) fileNewAction = self.createAction("&New", self.fileNew, QKeySequence.New, "filenew", "Create a text file") fileOpenAction = self.createAction("&Open...", self.fileOpen, QKeySequence.Open, "fileopen", "Open an existing text file") fileSaveAction = self.createAction("&Save", self.fileSave, QKeySequence.Save, "filesave", "Save the text") fileSaveAsAction = self.createAction( "Save &As...", self.fileSaveAs, icon="filesaveas", tip="Save the text using a new filename") fileSaveAllAction = self.createAction("Save A&ll", self.fileSaveAll, "filesave", tip="Save all the files") fileQuitAction = self.createAction("&Quit", self.close, "Ctrl+Q", "filequit", "Close the application") editCopyAction = self.createAction("&Copy", self.editCopy, QKeySequence.Copy, "editcopy", "Copy text to the clipboard") editCutAction = self.createAction("Cu&t", self.editCut, QKeySequence.Cut, "editcut", "Cut text to the clipboard") editPasteAction = self.createAction("&Paste", self.editPaste, QKeySequence.Paste, "editpaste", "Paste in the clipboard's text") self.windowNextAction = self.createAction( "&Next", self.mdi.activateNextSubWindow, QKeySequence.NextChild) self.windowPrevAction = self.createAction( "&Previous", self.mdi.activatePreviousSubWindow, QKeySequence.PreviousChild) self.windowCascadeAction = self.createAction( "Casca&de", self.mdi.cascadeSubWindows) self.windowTileAction = self.createAction("&Tile", self.mdi.tileSubWindows) self.windowRestoreAction = self.createAction("&Restore All", self.windowRestoreAll) self.windowMinimizeAction = self.createAction("&Iconize All", self.windowMinimizeAll) #self.windowArrangeIconsAction = self.createAction( # "&Arrange Icons", self.mdi.arrangeIcons) self.windowArrangeIconsAction = self.createAction( "&Arrange Icons", self.windowMinimizeAll) self.windowCloseAction = self.createAction( "&Close", self.mdi.closeActiveSubWindow, QKeySequence.Close) self.windowMapper = QSignalMapper(self) self.windowMapper.mapped[QWidget].connect(self.mdi.setActiveSubWindow) fileMenu = self.menuBar().addMenu("&File") self.addActions( fileMenu, (fileNewAction, fileOpenAction, fileSaveAction, fileSaveAsAction, fileSaveAllAction, None, fileQuitAction)) editMenu = self.menuBar().addMenu("&Edit") self.addActions(editMenu, (editCopyAction, editCutAction, editPasteAction)) self.windowMenu = self.menuBar().addMenu("&Window") self.windowMenu.aboutToShow.connect(self.updateWindowMenu) fileToolbar = self.addToolBar("File") fileToolbar.setObjectName("FileToolbar") self.addActions(fileToolbar, (fileNewAction, fileOpenAction, fileSaveAction)) editToolbar = self.addToolBar("Edit") editToolbar.setObjectName("EditToolbar") self.addActions(editToolbar, (editCopyAction, editCutAction, editPasteAction)) settings = QSettings() if settings.value("MainWindow/Geometry") or settings.value( "MainWindow/State"): self.restoreGeometry( QByteArray(settings.value("MainWindow/Geometry"))) self.restoreState(QByteArray(settings.value("MainWindow/State"))) status = self.statusBar() status.setSizeGripEnabled(False) status.showMessage("Ready", 5000) self.updateWindowMenu() self.setWindowTitle("Text Editor") QTimer.singleShot(0, self.loadFiles)
def _pop_later(self): """Helper to call self._pop as soon as everything else is done.""" QTimer.singleShot(0, self._pop)
def __init__(self, geometry=None, parent=None): """Create a new main window. Args: geometry: The geometry to load, as a bytes-object (or None). parent: The parent the window should get. """ super().__init__(parent) self.setAttribute(Qt.WA_DeleteOnClose) self._commandrunner = None self.win_id = next(win_id_gen) self.registry = objreg.ObjectRegistry() objreg.window_registry[self.win_id] = self objreg.register('main-window', self, scope='window', window=self.win_id) tab_registry = objreg.ObjectRegistry() objreg.register('tab-registry', tab_registry, scope='window', window=self.win_id) message_bridge = message.MessageBridge(self) objreg.register('message-bridge', message_bridge, scope='window', window=self.win_id) self.setWindowTitle('qutebrowser') if geometry is not None: self._load_geometry(geometry) elif self.win_id == 0: self._load_state_geometry() else: self._set_default_geometry() log.init.debug("Initial main window geometry: {}".format( self.geometry())) self._vbox = QVBoxLayout(self) self._vbox.setContentsMargins(0, 0, 0, 0) self._vbox.setSpacing(0) log.init.debug("Initializing downloads...") download_manager = downloads.DownloadManager(self.win_id, self) objreg.register('download-manager', download_manager, scope='window', window=self.win_id) self._downloadview = downloadview.DownloadView(self.win_id) self._tabbed_browser = tabbedbrowser.TabbedBrowser(self.win_id) objreg.register('tabbed-browser', self._tabbed_browser, scope='window', window=self.win_id) # We need to set an explicit parent for StatusBar because it does some # show/hide magic immediately which would mean it'd show up as a # window. self.status = bar.StatusBar(self.win_id, parent=self) self._add_widgets() self._downloadview.show() self._completion = completionwidget.CompletionView(self.win_id, self) self._commandrunner = runners.CommandRunner(self.win_id) log.init.debug("Initializing modes...") modeman.init(self.win_id, self) self._connect_signals() # When we're here the statusbar might not even really exist yet, so # resizing will fail. Therefore, we use singleShot QTimers to make sure # we defer this until everything else is initialized. QTimer.singleShot(0, self._connect_resize_completion) objreg.get('config').changed.connect(self.on_config_changed) if config.get('ui', 'hide-mouse-cursor'): self.setCursor(Qt.BlankCursor)
def set_timeout(self, timeout): """Hide the widget after the given timeout.""" QTimer.singleShot(timeout, self._on_timeout)
def call_later(interval, function, *args, **kw): QTimer.singleShot(int(interval * 1000), lambda: function(*args, **kw))
def SingleShotEscape(message_box): """aux function to close messagebox""" close_delay = 0 # [ms] QTimer.singleShot(close_delay, lambda: QTest.keyClick(message_box, Qt.Key_Escape))
def create_objects(self): if not (self.isValid() and self.shareWidget.initialized): self.invalid_count += 1 print( 'ND: Context not valid in create_objects, or shareWidget not yet initialized' ) QTimer.singleShot(100, self.create_objects) return # Make the nd widget context current, necessary when create_objects is not called from initializeGL self.makeCurrent() # Use the same font as the radarwidget self.font = self.shareWidget.font.copy() self.font.init_shader(self.text_shader) edge = np.zeros(120, dtype=np.float32) edge[0:120:2] = 1.4 * np.sin(np.radians(np.arange(-60, 60, 2))) edge[1:120:2] = 1.4 * np.cos(np.radians(np.arange(-60, 60, 2))) self.edge = RenderObject(gl.GL_LINE_STRIP, vertex=edge, color=white) arcs = [] for i in range(1, 4): for angle in range(-60, 60, max(2, 6 - 2 * i)): arcs.append(float(i) * 0.35 * sin(radians(angle))) arcs.append(float(i) * 0.35 * cos(radians(angle))) if i == 4: arcs.append(float(i) * 0.35 * sin(radians(angle + 2))) arcs.append(float(i) * 0.35 * cos(radians(angle + 2))) arcs = np.array(arcs, dtype=np.float32) self.arcs = RenderObject(gl.GL_LINES, vertex=arcs, color=white) mask = [] for angle in range(-60, 60, 2): mask.append(1.4 * sin(radians(angle))) mask.append(10.0) mask.append(1.4 * sin(radians(angle))) mask.append(1.4 * cos(radians(angle))) mask = np.array(mask, dtype=np.float32) self.mask = RenderObject(gl.GL_TRIANGLE_STRIP, vertex=mask, color=black) ticks = np.zeros(288, dtype=np.float32) for i in range(72): ticktop = 1.46 if i % 6 == 0 else (1.44 if i % 2 == 0 else 1.42) ticks[4 * i:4 * i + 2] = (1.4 * sin(radians(i * 5)), 1.4 * cos(radians(i * 5))) ticks[4 * i + 2:4 * i + 4] = (ticktop * sin(radians(i * 5)), ticktop * cos(radians(i * 5))) self.ticks = RenderObject(gl.GL_LINES, vertex=ticks, color=white) ticklbls = np.zeros(24 * 36, dtype=np.float32) texcoords = np.zeros(36 * 36, dtype=np.float32) for i in range(36): if i % 3 == 0: w, h, y = 0.045, 0.09, 1.48 else: w, h, y = 0.035, 0.07, 1.46 tmp = [(-w, h + y), (-w, y), (0.0, h + y), (0.0, h + y), (-w, y), (0.0, y), (0.0, h + y), (0.0, y), (w, h + y), (w, h + y), (0.0, y), (w, y)] # numerics start at ASCII 48 c1 = i / 10 + 48 c2 = i % 10 + 48 texcoords[36 * i:36 * i + 18] = [ 0, 0, c1, 0, 1, c1, 1, 0, c1, 1, 0, c1, 0, 1, c1, 1, 1, c1 ] texcoords[36 * i + 18:36 * i + 36] = [ 0, 0, c2, 0, 1, c2, 1, 0, c2, 1, 0, c2, 0, 1, c2, 1, 1, c2 ] angle = radians(10 * (36 - i)) rot = np.array([[cos(angle), -sin(angle)], [sin(angle), cos(angle)]]) for j in range(12): ticklbls[24 * i + 2 * j:24 * i + 2 * j + 2] = rot.dot(tmp[j]) self.ticklbls = RenderObject(gl.GL_TRIANGLES, vertex=ticklbls, color=white, texcoords=texcoords) vown = np.array([ 0.0, 0.0, 0.0, -0.12, 0.065, -0.03, -0.065, -0.03, 0.022, -0.1, -0.022, -0.1 ], dtype=np.float32) self.ownship = RenderObject(gl.GL_LINES, vertex=vown, color=yellow) self.spdlabel_text = self.font.prepare_text_string( 'GS TAS', 0.05, white, (-0.98, 1.6)) self.spdlabel_val = self.font.prepare_text_string( ' 000 000', 0.05, green, (-0.97, 1.6)) self.waypoints = RenderObject.copy(self.shareWidget.waypoints) self.wptlabels = RenderObject.copy(self.shareWidget.wptlabels) self.airports = RenderObject.copy(self.shareWidget.airports) self.aptlabels = RenderObject.copy(self.shareWidget.aptlabels) self.protectedzone = RenderObject.copy(self.shareWidget.protectedzone) self.ac_symbol = RenderObject.copy(self.shareWidget.ac_symbol) self.aclabels = RenderObject.copy(self.shareWidget.aclabels) # Unbind VAO, VBO RenderObject.unbind_all() # Done initializing self.initialized = True
def delayed_rebuild(self): """Fire a rebuild indirectly so widgets get a chance to update.""" QTimer.singleShot(0, self.rebuild)
def call_next(self, fn): QTimer.singleShot(0, fn)
def load(self): if self.Page == -1: return self.loadStarted.emit(True) # 延迟一秒后调用目的在于显示进度条 QTimer.singleShot(1000, self._load)
def SingleShotOkKlick(message_box): """aux function to close messagebox""" close_delay = 0 # [ms] ok_btn = message_box.button(QMessageBox.Ok) QTimer.singleShot(close_delay, ok_btn.click)
def autoUpdateDevice(self, flag): logger.debug('autoUpdateDevice') autosetproperty = self.sender().objectName() autosetmethod = getattr(self.device, autosetproperty) autosetmethod() QTimer.singleShot(1000, self.updateUi)
def _shutdown(self, status, restart): # noqa """Second stage of shutdown.""" log.destroy.debug("Stage 2 of shutting down...") if qApp is None: # No QApplication exists yet, so quit hard. sys.exit(status) # Remove eventfilter try: log.destroy.debug("Removing eventfilter...") event_filter = objreg.get('event-filter', None) if event_filter is not None: qApp.removeEventFilter(event_filter) except AttributeError: pass # Close all windows QApplication.closeAllWindows() # Shut down IPC try: ipc.server.shutdown() except KeyError: pass # Save everything try: save_manager = objreg.get('save-manager') except KeyError: log.destroy.debug("Save manager not initialized yet, so not " "saving anything.") else: for key in save_manager.saveables: try: save_manager.save(key, is_exit=True) except OSError as e: error.handle_fatal_exc( e, self._args, "Error while saving!", pre_text="Error while saving {}".format(key)) # Disable storage so removing tempdir will work websettings.shutdown() # Disable application proxy factory to fix segfaults with Qt 5.10.1 proxy.shutdown() # Re-enable faulthandler to stdout, then remove crash log log.destroy.debug("Deactivating crash log...") objreg.get('crash-handler').destroy_crashlogfile() # Delete temp basedir if ((self._args.temp_basedir or self._args.temp_basedir_restarted) and not restart): atexit.register(shutil.rmtree, self._args.basedir, ignore_errors=True) # Delete temp download dir downloads.temp_download_manager.cleanup() # If we don't kill our custom handler here we might get segfaults log.destroy.debug("Deactivating message handler...") qInstallMessageHandler(None) # Now we can hopefully quit without segfaults log.destroy.debug("Deferring QApplication::exit...") objreg.get('signal-handler').deactivate() session_manager = objreg.get('session-manager', None) if session_manager is not None: session_manager.delete_autosave() # We use a singleshot timer to exit here to minimize the likelihood of # segfaults. QTimer.singleShot(0, functools.partial(qApp.exit, status))
def update(): QTimer.singleShot(2,lambda : update_blocking())
def run(): app = QApplication(sys.argv) ex = Pycomics() QTimer.singleShot(1, ex.InitLastScene) sys.exit(app.exec_())
def setViewScale(self, scale: float): self.fScale = scale if self.fRealParent is not None: QTimer.singleShot(0, self.fRealParent.slot_miniCanvasCheckAll)
def run(self, scenario, run_info): """ Run the model on the remote worker using the settings specified in model_input. The worker will return a job ID corresponding to the row ID of the final results stored in the remote database. :param Scenario scenario: Scenario for which to run the model :param dict run_info: Supplementary info for this run: 'reference_point': (lat, lon, depth) reference for coord. conversion 'injection_point': (lat, lon, depth) of current injection point """ forecast = scenario.forecast_input.forecast forecast_schema = ForecastSchema() serialized = forecast_schema.dump(forecast).data data = { 'forecast': serialized, 'parameters': self.model_config['parameters'], 'scenario id': scenario.id } # Add cartesian coordinates ref = forecast.forecast_set.project.reference_point try: catalog = data['forecast']['input']['input_catalog'] for e in catalog['seismic_events']: x, y, z = geodetic2ned(e['lat'], e['lon'], e['depth'], ref['lat'], ref['lon'], ref['h']) e['x'], e['y'], e['z'] = x, y, z except TypeError: self.logger.info('No seismic events') # Request model run self.results = None self.logger.info('Starting remote worker for {}'.format(self.model_id)) notification = ErrorNotification(calc_id=self.model_id) try: r = requests.post(self.url, json=data, timeout=5) except (ConnectionError, Timeout) as ex: self.logger.error('Can' 't connect to worker: {}'.format(repr(ex))) else: notification.response = r if r.status_code == requests.codes.accepted: notification = RunningNotification(self.model_id, response=r) QTimer.singleShot(self.poll_interval, self._get_results) elif r.status_code == requests.codes.bad_request: self.logger.error( 'The worker did not accept our request: {}'.format( r.content)) elif r.status_code == requests.codes.server_error: self.logger.error('The worker reported an error: {}'.format( r.content)) elif r.status_code == requests.codes.unavailable: self.logger.error( 'The worker did not accept our job: {}'.format(r.content)) else: self.logger.error( 'Unexpected response received: [{}] {}'.format( r.status_code, r.content)) self.client_notification.emit(notification)
def _log_later(self, *lines): """Log the given text line-wise with a QTimer.""" for line in lines: QTimer.singleShot(0, functools.partial(log.destroy.info, line))
def timer_event(): try: func(*args, **kwargs) finally: QTimer.singleShot(timeout, timer_event)
def unlock_window(self): self.label.setText("Windows unlocked") self.label.adjustSize() QTimer.singleShot(300, self.close) #close window unhide_taskbar() print('test')
features["Standard"] = {} features["Standard"]["Count"] = {} features["Standard"]["Count"]["displaytext"] = "Size in pixels" features["Standard"]["Count"][ "detailtext"] = "Total size of the object in pixels. No correction for anisotropic resolution or anything else." features["Standard"]["Count"]["group"] = "Shape" features["Standard"]["Count"] = {} features["Standard"]["Count"]["displaytext"] = "Size in pixels" features["Standard"]["Count"][ "detailtext"] = "Total size of the object in pixels. No correction for anisotropic resolution or anything else." features["Standard"]["Count"]["group"] = "Shape" features["Standard"]["Coord<Minimum>"] = {} features["Standard"]["Coord<Minimum>"][ "displaytext"] = "Bounding Box Minimum" features["Standard"]["Coord<Minimum>"][ "detailtext"] = "The coordinates of the lower left corner of the object's bounding box. The first axis is x, then y, then z (if available)." features["Standard"]["Coord<Minimum>"]["group"] = "Location" features["Standard"]["Coord<Maximum>"] = {} features["Standard"]["Coord<Maximum>"][ "displaytext"] = "Bounding Box Maximum" features["Standard"]["Coord<Maximum>"][ "detailtext"] = "The coordinates of the upper right corner of the object's bounding box. The first axis is x, then y, then z (if available)." features["Standard"]["Coord<Maximum>"]["group"] = "Location" dlg = FeatureSelectionDialog(featureDict=features) QTimer.singleShot(100, dlg.raise_) dlg.exec_()
class MainController: # States # class Idle: pass @dataclass class Preview: image: QImage @dataclass class Printing: image: QImage @dataclass class Error: message: str def __init__( self, main_window: MainWindow, idle_widget: IdleWidget, preview_widget: PreviewWidget, printing_widget: PrintingWidget, error_widget: ErrorWidget, printer: LibCupsPrinter, config, ): super().__init__() self._main_window = main_window self._idle_widget = idle_widget self._preview_widget = preview_widget self._printing_widget = printing_widget self._error_widget = error_widget self._printer = printer self._error_timeout_seconds = config.getint("errorTimeoutSeconds") self._preview_timeout_seconds = config.getint("previewTimeoutSeconds") self._timeout_timer = QTimer() # Connect signals # self._idle_widget.error.connect(self._switch_to_error) self._idle_widget.image_captured.connect( self._expect_state_then_switch(MainController.Idle, self._switch_to_preview)) self._preview_widget.accept.connect( self._expect_state_then_switch(MainController.Preview, self._switch_to_printing)) self._preview_widget.reject.connect( self._expect_state_then_switch(MainController.Preview, self._switch_to_idle)) self._printer.error.connect(self._switch_to_error) self._printer.success.connect( self._expect_state_then_switch( MainController.Printing, self._switch_to_idle, )) self._error_widget.accept.connect( self._expect_state_then_switch(MainController.Error, self._switch_to_idle)) self._main_window.quit.connect(self._main_window.deleteLater) # Initialise state # self._switch_to_idle() def _cancel_timeouts(self): self._timeout_timer.stop() def _expect_state_then_switch(self, expected_state, switch_to): def _inner(*args, **kwargs): caller = inspect.stack()[1][3] if isinstance(self.state, expected_state): logger.debug("Caught %s while in %s state", caller, self.state) switch_to(*args, **kwargs) else: logger.warning("Dropping unexpected %s while in %s state", caller, self.state) return _inner def _switch_to_idle(self): self._cancel_timeouts() self.state = MainController.Idle() self._idle_widget.reload() self._main_window.select_idle() def _switch_to_preview(self, image): self._cancel_timeouts() self.state = MainController.Preview(image) self.last_captured_image = image self._preview_widget.set_image(image) self._main_window.select_preview() self._timeout_timer.singleShot( self._preview_timeout_seconds * 1000, self._expect_state_then_switch(MainController.Preview, self._switch_to_idle), ) def _switch_to_printing(self): self._cancel_timeouts() self.state = MainController.Printing(self.state.image) self._printing_widget.set_image(self.state.image) self._main_window.select_printing() self._printer.print(self.state.image) def _switch_to_error(self, message: str): logger.error("_on_error: %s", message) self._cancel_timeouts() self.state = MainController.Error(message) self._main_window.select_error() self._error_widget.set_error_message(message) self._timeout_timer.singleShot( self._error_timeout_seconds * 1000, self._expect_state_then_switch(MainController.Error, self._switch_to_idle), )
def CursorChangedEvent(self, obj, evt): """Called when the CursorChangedEvent fires on the render window.""" # This indirection is needed since when the event fires, the current # cursor is not yet set so we defer this by which time the current # cursor should have been set. QTimer.singleShot(0, self.ShowCursor)