def _show_backup_decision(self, error=None): text = '<p>{0}</p><p>{1}</p>'.format( self.BACKUP_INTRO_TEXT if error is None else error, self.BACKUP_PROMPT_TEXT, ) dialog = QMessageBox( QMessageBox.Question if error is None else QMessageBox.Critical, self.BACKUP_DIALOG_CAPTION if error is None else self.BACKUP_DIALOG_ERROR_CAPTION, text, ) revert_button = dialog.addButton(self.REVERT_BACKUP_BUTTON_TEXT, QMessageBox.AcceptRole) delete_button = dialog.addButton(self.DELETE_BACKUP_BUTTON_TEXT, QMessageBox.DestructiveRole) examine_button = dialog.addButton(self.EXAMINE_BACKUP_BUTTON_TEXT, QMessageBox.ActionRole) dialog.addButton(self.QUIT_BUTTON_TEXT, QMessageBox.RejectRole) dialog.exec() clicked_button = dialog.clickedButton() if clicked_button == examine_button: QMetaObject.invokeMethod(self, '_examine_backup', Qt.QueuedConnection) elif clicked_button == revert_button: self._progress_dialog = QProgressDialog(None) self._progress_dialog.setLabelText(self.REVERT_BACKUP_PROGRESS_TEXT) self._progress_dialog.setCancelButton(None) self._progress_dialog.setRange(0, 0) self._progress_dialog.forceShow() self.request_revert_backup.emit() elif clicked_button == delete_button: self.request_delete_backup.emit() else: self.quit()
def run(self): """ Reimplemented from `QRunnable.run` """ self.eventLoop = QEventLoop() self.eventLoop.processEvents() # Move the task to the current thread so it's events, signals, slots # are triggered from this thread. assert isinstance(self.task.thread(), _TaskDepotThread) QMetaObject.invokeMethod(self.task.thread(), "transfer", Qt.BlockingQueuedConnection, Q_ARG(object, self.task), Q_ARG(object, QThread.currentThread())) self.eventLoop.processEvents() # Schedule task.run from the event loop. self.task.start() # Quit the loop and exit when task finishes or is cancelled. # TODO: If the task encounters an critical error it might not emit # these signals and this Runnable will never complete. self.task.finished.connect(self.eventLoop.quit) self.task.cancelled.connect(self.eventLoop.quit) self.eventLoop.exec_()
def run(self): """ Reimplemented from `QRunnable.run` """ self.eventLoop = QEventLoop() self.eventLoop.processEvents() # Move the task to the current thread so it's events, signals, slots # are triggered from this thread. assert isinstance(self.task.thread(), _TaskDepotThread) QMetaObject.invokeMethod( self.task.thread(), "transfer", Qt.BlockingQueuedConnection, Q_ARG(object, self.task), Q_ARG(object, QThread.currentThread()) ) self.eventLoop.processEvents() # Schedule task.run from the event loop. self.task.start() # Quit the loop and exit when task finishes or is cancelled. # TODO: If the task encounters an critical error it might not emit # these signals and this Runnable will never complete. self.task.finished.connect(self.eventLoop.quit) self.task.cancelled.connect(self.eventLoop.quit) self.eventLoop.exec_()
def run(self): """ Reimplemented from `QRunnable.run` """ self.eventLoop = QEventLoop() self.eventLoop.processEvents() # Move the task to the current thread so it's events, signals, slots # are triggered from this thread. assert self.task.thread() is _TaskDepotThread.instance() QMetaObject.invokeMethod( self.task.thread(), "transfer", Qt.BlockingQueuedConnection, Q_ARG(object, self.task), Q_ARG(object, QThread.currentThread()) ) self.eventLoop.processEvents() # Schedule task.run from the event loop. self.task.start() # Quit the loop and exit when task finishes or is cancelled. self.task.finished.connect(self.eventLoop.quit) self.task.cancelled.connect(self.eventLoop.quit) self.eventLoop.exec_()
def run(self): ret = None try: if self.object is not None and self.method is not None: # TODO Get return value. QMetaObject.invokeMethod(self.object, self.method, self.connection) except Exception, e: self.error.emit(e, traceback.format_exc())
def done(self): self.timer.stop() self.popup.hide() self.editor.setFocus() item = self.popup.currentItem() if item: self.editor.setText(item.text(0)) QMetaObject.invokeMethod(self.editor, "returnPressed")
def doneCompletion(self): self.timer.stop() self.ui.popup.hide() self.ui.editor.setFocus() item = self.ui.popup.currentItem() if item != None: self.currentItem = self.ui.popup.currentItem().data(0, 0) self.ui.editor.setText(item.text(self.textplacetoeditor)) QMetaObject.invokeMethod(self.ui.editor, "returnPressed")
def doneCompletion(self): self.timer.stop() self.ui.popup.hide() self.ui.editor.setFocus() item = self.ui.popup.currentItem() if item != None: self.currentItem = self.ui.popup.currentItem().data(0,0) self.ui.editor.setText(item.text(self.textplacetoeditor)) QMetaObject.invokeMethod(self.ui.editor, "returnPressed");
def run(self): self.eventLoop = QEventLoop() self.eventLoop.processEvents() QObject.connect(self._call, SIGNAL("finished(QString)"), lambda str: self.eventLoop.quit()) QMetaObject.invokeMethod( self._call, "moveToAndInit", Qt.QueuedConnection, Q_ARG("PyQt_PyObject", QThread.currentThread())) self.eventLoop.processEvents() self.eventLoop.exec_()
def run(self): self.eventLoop = QEventLoop() self.eventLoop.processEvents() QObject.connect(self._call, SIGNAL("finished(QString)"), lambda str: self.eventLoop.quit()) QMetaObject.invokeMethod(self._call, "moveToAndInit", Qt.QueuedConnection, Q_ARG("PyQt_PyObject", QThread.currentThread())) self.eventLoop.processEvents() self.eventLoop.exec_()
def run(self): try: result = self.func(*(self.args), **(self.kwargs)) except Exception as e: logger.exception("deferToThread caught exception: %r", e) QMetaObject.invokeMethod(DeferCallThread.mainThreadStub, "_slot_errback", Qt.QueuedConnection, Q_ARG("PyQt_PyObject", self.done), Q_ARG("PyQt_PyObject", e)) else: QMetaObject.invokeMethod(DeferCallThread.mainThreadStub, "_slot_callback", Qt.QueuedConnection, Q_ARG("PyQt_PyObject", self.done), Q_ARG("PyQt_PyObject", result)) finally: del self.func, self.done, self.args, self.kwargs
def func(): try: QMetaObject.invokeMethod(self, "_on_start", Qt.QueuedConnection) if allow_partial_results: kwargs['should_break'] = should_break res = method(self, *args, on_progress=on_progress, **kwargs) except StopExecution: res = None QMetaObject.invokeMethod(self, "_on_result", Qt.QueuedConnection, Q_ARG(object, res)) self.running = False
def shutdown(self, wait=True): """ Shutdown the executor and free all resources. If `wait` is True then wait until all pending futures are executed or cancelled. """ if self._depot_thread is not None: QMetaObject.invokeMethod( self._depot_thread, "quit", Qt.AutoConnection) if wait: self._threadPool.waitForDone() if self._depot_thread: self._depot_thread.wait() self._depot_thread = None
def shutdown(self, wait=True): """ Shutdown the executor and free all resources. If `wait` is True then wait until all pending futures are executed or cancelled. """ if self._depot_thread is not None: QMetaObject.invokeMethod(self._depot_thread, "quit", Qt.AutoConnection) if wait: self._threadPool.waitForDone() if self._depot_thread: self._depot_thread.wait() self._depot_thread = None
def handleRequest(self): request = WebServerRequest(self) response = WebServerResponse(self) for server in servers: # verify which server this request is for if self.server == server.httpd: connectionType = Qt.BlockingQueuedConnection if QThread.currentThread() == server.thread(): connectionType = Qt.DirectConnection QMetaObject.invokeMethod(server, 'newRequest', connectionType, Q_ARG(WebServerRequest, request), Q_ARG(WebServerResponse, response)) break
def cardScanned(self, card): self.statusLabel.setText("Loading ...") userid = self.uf.read(card)[1] user = InternetClient.getUserDetails(userid) status = InternetClient.getUserStatus(userid, 0) statusDetails = None if status == "in": statusDetails = InternetClient.getUserStatus(userid, 1) QMetaObject.invokeMethod(self.parent, "startLogin", Qt.QueuedConnection, Q_ARG(QString, userid), Q_ARG(QString, user["realname"]), Q_ARG(QString, status), Q_ARG(QString, user["last_visit"])) self.statusLabel.setText("")
def fetchFiles(self, urls, renderContext): downloader = Downloader(None, self.maxConnections, self.cacheExpiry, self.userAgent) downloader.moveToThread(QgsApplication.instance().thread()) downloader.timer.moveToThread(QgsApplication.instance().thread()) self.logT("TileLayer.fetchFiles() starts") # create a QEventLoop object that belongs to the current worker thread eventLoop = QEventLoop() downloader.allRepliesFinished.connect(eventLoop.quit) if self.iface: # for download progress downloader.replyFinished.connect(self.networkReplyFinished) self.downloader = downloader # create a timer to watch whether rendering is stopped watchTimer = QTimer() watchTimer.timeout.connect(eventLoop.quit) # fetch files QMetaObject.invokeMethod(self.downloader, "fetchFilesAsync", Qt.QueuedConnection, Q_ARG(list, urls), Q_ARG(int, self.plugin.downloadTimeout)) # wait for the fetch to finish tick = 0 interval = 500 timeoutTick = self.plugin.downloadTimeout * 1000 / interval watchTimer.start(interval) while tick < timeoutTick: # run event loop for 0.5 seconds at maximum eventLoop.exec_() if downloader.unfinishedCount() == 0 or renderContext.renderingStopped(): break tick += 1 watchTimer.stop() if downloader.unfinishedCount() > 0: downloader.abort(False) if tick == timeoutTick: downloader.errorStatus = Downloader.TIMEOUT_ERROR self.log("fetchFiles(): timeout") # watchTimer.timeout.disconnect(eventLoop.quit) # downloader.allRepliesFinished.disconnect(eventLoop.quit) self.logT("TileLayer.fetchFiles() ends") return downloader.fetchedFiles
def wrapper(obj, *args): # XXX: support kwargs? qargs = [Q_ARG(t, v) for t, v in zip(self.args, args)] invoke_args = [obj._instance, self.name] invoke_args.append(Qt.DirectConnection) rtype = self.returnType if rtype: invoke_args.append(Q_RETURN_ARG(rtype)) invoke_args.extend(qargs) try: result = QMetaObject.invokeMethod(*invoke_args) error_msg = str(qApp.property("MIKRO_EXCEPTION").toString()) if error_msg: # clear message qApp.setProperty("MIKRO_EXCEPTION", QVariant()) raise Error(error_msg) except RuntimeError, e: raise TypeError, \ "%s.%s(%r) call failed: %s" % (obj, self.name, args, e)
def stop(self): QMetaObject.invokeMethod(self.player, 'stop')
def seek(self, pos): QMetaObject.invokeMethod(self.player, 'seek', Q_ARG("qlonglong", pos))
def wakeUp(self): QMetaObject.invokeMethod(self, "_timerSlot", Qt.QueuedConnection)
def pause(self): QMetaObject.invokeMethod(self.player, 'pause')
def call(*args): args = [Q_ARG(atype, arg) for atype, arg in zip(sig, args)] return QMetaObject.invokeMethod(obj, name, conntype, *args)
def update(f): QMetaObject.invokeMethod( self, "_update_info", Qt.QueuedConnection)
def __call__(self, *args): args = [Q_ARG(atype, arg) for atype, arg in zip(self.arg_types, args)] QMetaObject.invokeMethod( self.obj, self.method, Qt.QueuedConnection, *args )
def setCurrentItem(self, item): print('setCurrentItem: ', item) self.currentItem = item self.ui.editor.setText(item.stringList()[self.textplacetoeditor]) QMetaObject.invokeMethod(self.ui.editor, "returnPressed")
def setVolumeFactor(self, volume): """ Change the volume factor (0 - 20) """ QMetaObject.invokeMethod(self.player, 'setVolumeFactor', Q_ARG("double", volume / 10.0))
def _report_updated_status(self): # This mechanism will cause a status update to only be emitted after the core has finished processing all other # events self._defer_status_update_level += 1 QMetaObject.invokeMethod(self, '_report_updated_status_impl', Qt.QueuedConnection)
def paintEvent(self, event): option = QStyleOption() option.initFrom(self) contents_rect = self.style().subElementRect(QStyle.SE_FrameContents, option, self) or self.contentsRect() # the SE_FrameContents rect is Null unless the stylesheet defines decorations if self.graphStyle == self.BarStyle: graph_width = self.__dict__['graph_width'] = int(ceil(float(contents_rect.width()) / self.horizontalPixelsPerUnit)) else: graph_width = self.__dict__['graph_width'] = int(ceil(float(contents_rect.width() - 1) / self.horizontalPixelsPerUnit) + 1) max_value = self.__dict__['max_value'] = max(chain([0], *(islice(reversed(graph.data), graph_width) for graph in self.graphs if graph.enabled))) if self.graphHeight == self.AutomaticHeight or self.graphHeight < 0: graph_height = self.__dict__['graph_height'] = max(self.scaler.get_height(max_value), self.minHeight) else: graph_height = self.__dict__['graph_height'] = max(self.graphHeight, self.minHeight) if self.graphStyle == self.BarStyle: height_scaling = float(contents_rect.height()) / graph_height else: height_scaling = float(contents_rect.height() - self.lineThickness) / graph_height painter = QStylePainter(self) painter.drawPrimitive(QStyle.PE_Widget, option) painter.setClipRect(contents_rect) painter.save() painter.translate(contents_rect.x() + contents_rect.width() - 1, contents_rect.y() + contents_rect.height() - 1) painter.scale(-1, -1) painter.setRenderHint(QStylePainter.Antialiasing, self.graphStyle != self.BarStyle) for graph in (graph for graph in self.graphs if graph.enabled and graph.data): if self.boundary is not None and 0 < self.boundary < graph_height: boundary_width = min(5.0/height_scaling, self.boundary-0, graph_height-self.boundary) pen_color = QLinearGradient(0, (self.boundary - boundary_width) * height_scaling, 0, (self.boundary + boundary_width) * height_scaling) pen_color.setColorAt(0, graph.color) pen_color.setColorAt(1, graph.over_boundary_color) brush_color = QLinearGradient(0, (self.boundary - boundary_width) * height_scaling, 0, (self.boundary + boundary_width) * height_scaling) brush_color.setColorAt(0, self.color_with_alpha(graph.color, self.fillTransparency)) brush_color.setColorAt(1, self.color_with_alpha(graph.over_boundary_color, self.fillTransparency)) else: pen_color = graph.color brush_color = self.color_with_alpha(graph.color, self.fillTransparency) dataset = islice(reversed(graph.data), graph_width) if self.graphStyle == self.BarStyle: lines = [QLine(x*self.horizontalPixelsPerUnit, 0, x*self.horizontalPixelsPerUnit, y*height_scaling) for x, y in enumerate(dataset)] painter.setPen(QPen(pen_color, self.lineThickness)) painter.drawLines(lines) else: painter.translate(0, +self.lineThickness/2 - 1) if self.smoothEnvelope and self.smoothFactor > 0: min_value = 0 max_value = graph_height * height_scaling cx_offset = self.horizontalPixelsPerUnit / 3.0 smoothness = self.smoothFactor last_values = deque(3*[dataset.next() * height_scaling], maxlen=3) # last 3 values: 0 last, 1 previous, 2 previous previous envelope = QPainterPath() envelope.moveTo(0, last_values[0]) for x, y in enumerate(dataset, 1): x = x * self.horizontalPixelsPerUnit y = y * height_scaling * (1 - smoothness) + last_values[0] * smoothness last_values.appendleft(y) c1x = x - cx_offset * 2 c2x = x - cx_offset c1y = limit((1 + smoothness) * last_values[1] - smoothness * last_values[2], min_value, max_value) # same gradient as previous previous value to previous value c2y = limit((1 - smoothness) * last_values[0] + smoothness * last_values[1], min_value, max_value) # same gradient as previous value to last value envelope.cubicTo(c1x, c1y, c2x, c2y, x, y) else: envelope = QPainterPath() envelope.addPolygon(QPolygonF([QPointF(x*self.horizontalPixelsPerUnit, y*height_scaling) for x, y in enumerate(dataset)])) if self.fillEnvelope or graph.fill_envelope: first_element = envelope.elementAt(0) last_element = envelope.elementAt(envelope.elementCount() - 1) fill_path = QPainterPath() fill_path.moveTo(last_element.x, last_element.y) fill_path.lineTo(last_element.x + 1, last_element.y) fill_path.lineTo(last_element.x + 1, -self.lineThickness) fill_path.lineTo(-self.lineThickness, -self.lineThickness) fill_path.lineTo(-self.lineThickness, first_element.y) fill_path.connectPath(envelope) painter.fillPath(fill_path, brush_color) painter.strokePath(envelope, QPen(pen_color, self.lineThickness, join=Qt.RoundJoin)) painter.translate(0, -self.lineThickness/2 + 1) if self.boundary is not None and self.boundaryColor: painter.setRenderHint(QStylePainter.Antialiasing, False) painter.setPen(QPen(self.boundaryColor, 1.0)) painter.drawLine(0, self.boundary*height_scaling, contents_rect.width(), self.boundary*height_scaling) painter.restore() # queue the 'updated' signal to be emited after returning to the main loop QMetaObject.invokeMethod(self, 'updated', Qt.QueuedConnection)
def trigger(self): self.set_data(True) QMetaObject.invokeMethod(self, '_untrigger', Qt.QueuedConnection)
def __call__(self, *args): args = [Q_ARG(atype, arg) for atype, arg in zip(self.arg_types, args)] QMetaObject.invokeMethod(self.obj, self.method, Qt.QueuedConnection, *args)
def _start_core(self): QMetaObject.invokeMethod(self._core, 'start', Qt.QueuedConnection)
def setCurrentItem(self, item): print('setCurrentItem: ',item) self.currentItem = item self.ui.editor.setText(item.stringList()[self.textplacetoeditor]) QMetaObject.invokeMethod(self.ui.editor, "returnPressed")
def _load(self): url = self._url config = get_config() searcher_hp = self._searcher_hp searcher_de = self._searcher_de mime = None error = False if url.scheme() == 'static': try: self._data = _load_static_data(url.path().lstrip('/')) except EnvironmentError: self._data = '<h2>Static File Not Found</h2>' mime = 'text/html' error = True elif url.scheme() == 'dict': try: path = url.path().split('#', 1)[0] ldoce5 = LDOCE5(config.get('dataDir', ''), config.filemap_path) (self._data, mime) = ldoce5.get_content(path) except NotFoundError: self._data = '<h2>Content Not Found</h2>' mime = 'text/html' error = True except FilemapError: self._data = '<h2>File-Location Map Not Available</h2>' mime = 'text/html' error = True except ArchiveError: self._data = '<h2>Dictionary Data Not Available</h2>' mime = 'text/html' error = True elif url.scheme() == 'search': if searcher_hp and searcher_de: try: self._data = enc_utf8(search_and_render( url, searcher_hp, searcher_de)) mime = 'text/html' except: s = u"<h2>Error</h2><div>{0}</div>".format( '<br>'.join(traceback.format_exc().splitlines())) self._data = enc_utf8(s) mime = 'text/html' error = True else: mime = 'text/html' self._data = ("""<p>The full-text search index """ """has not been created yet or broken.</p>""") error = True if mime: self.setHeader(QNetworkRequest.ContentTypeHeader, mime) self.setHeader(QNetworkRequest.ContentLengthHeader, len(self._data)) self.setOpenMode(self.ReadOnly | self.Unbuffered) if error: nwerror = QNetworkReply.ContentNotFoundError error_msg = u'Content Not Found' self.setError(nwerror, error_msg) QMetaObject.invokeMethod( self, 'error', Qt.QueuedConnection, Q_ARG(QNetworkReply.NetworkError, nwerror)) QMetaObject.invokeMethod(self, 'metaDataChanged', Qt.QueuedConnection) QMetaObject.invokeMethod(self, 'downloadProgress', Qt.QueuedConnection, Q_ARG('qint64', len(self._data)), Q_ARG('qint64', len(self._data))) QMetaObject.invokeMethod(self, 'readyRead', Qt.QueuedConnection) QMetaObject.invokeMethod(self, 'finished', Qt.QueuedConnection) self._finished = True
def on_progress(i): if not self.running and not allow_partial_results: raise StopExecution QMetaObject.invokeMethod(self, "_on_progress", Qt.QueuedConnection, Q_ARG(float, i))
def _load(self): url = self._url config = get_config() searcher_hp = self._searcher_hp searcher_de = self._searcher_de mime = None error = False if url.scheme() == 'static': try: self._data = _load_static_data(url.path().lstrip('/')) except EnvironmentError: self._data = '<h2>Static File Not Found</h2>' mime = 'text/html' error = True elif url.scheme() == 'dict': try: path = url.path().split('#', 1)[0] ldoce5 = LDOCE5(config.get('dataDir', ''), config.filemap_path) (self._data, mime) = ldoce5.get_content(path) except NotFoundError: self._data = '<h2>Content Not Found</h2>' mime = 'text/html' error = True except FilemapError: self._data = '<h2>File-Location Map Not Available</h2>' mime = 'text/html' error = True except ArchiveError: self._data = '<h2>Dictionary Data Not Available</h2>' mime = 'text/html' error = True elif url.scheme() == 'search': if searcher_hp and searcher_de: try: self._data = enc_utf8( search_and_render(url, searcher_hp, searcher_de)) mime = 'text/html' except: s = u"<h2>Error</h2><div>{0}</div>".format('<br>'.join( traceback.format_exc().splitlines())) self._data = enc_utf8(s) mime = 'text/html' error = True else: mime = 'text/html' self._data = ("""<p>The full-text search index """ """has not been created yet or broken.</p>""") error = True if mime: self.setHeader(QNetworkRequest.ContentTypeHeader, mime) self.setHeader(QNetworkRequest.ContentLengthHeader, len(self._data)) self.setOpenMode(self.ReadOnly | self.Unbuffered) if error: nwerror = QNetworkReply.ContentNotFoundError error_msg = u'Content Not Found' self.setError(nwerror, error_msg) QMetaObject.invokeMethod( self, 'error', Qt.QueuedConnection, Q_ARG(QNetworkReply.NetworkError, nwerror)) QMetaObject.invokeMethod(self, 'metaDataChanged', Qt.QueuedConnection) QMetaObject.invokeMethod(self, 'downloadProgress', Qt.QueuedConnection, Q_ARG('qint64', len(self._data)), Q_ARG('qint64', len(self._data))) QMetaObject.invokeMethod(self, 'readyRead', Qt.QueuedConnection) QMetaObject.invokeMethod(self, 'finished', Qt.QueuedConnection) self._finished = True
def _handle_frame(self, frame): self._image = QImage(frame.data, frame.width, frame.height, QImage.Format_ARGB32) if self._clock is None: QMetaObject.invokeMethod(self, 'update', Qt.QueuedConnection)
def update(f): QMetaObject.invokeMethod(self, "_update_info", Qt.QueuedConnection)
def play(self): QMetaObject.invokeMethod(self.player, 'play')