class initRunGetMax(QtCore.QObject): def __init__(self): QtCore.QObject.__init__(self) self.thread = QtCore.QThread() self.worker = None def start(self, selafinlayer, tool, intensite, direction, submersion, duree): # Launch worker self.worker = runGetMax(selafinlayer, tool, intensite, direction, submersion, duree) self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.run) self.worker.status.connect(self.writeOutput) self.worker.finished.connect(self.workerFinished) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.worker.finished.connect(self.thread.quit) self.thread.start() def writeOutput(self, str1): self.status.emit(str(str1)) def workerFinished(self, str1): self.finished1.emit(str1) status = QtCore.pyqtSignal(str) finished1 = QtCore.pyqtSignal(str)
class ItemProcessor(QtCore.QThread): """ This class can be used to process a list of items using a given function. The processing is done on a separate (non-blocking) thread and emits signals, which can be connected to a progress indicator for example. """ progress = QtCore.pyqtSignal(int) finished = QtCore.pyqtSignal(list) def __init__(self, items: list, func): super().__init__() self._items = items self._func = func self._stop = False def run(self): results = [] for count, item in enumerate(self._items, 1): try: results.append(self._func(item)) except Exception as e: # Log a QGIS error message (should be thread-safe) logError(e) self.progress.emit(count) if self._stop: break self.finished.emit(results) def stop(self): self._stop = True
class Config(QtCore.QObject): kf_con_error = QtCore.pyqtSignal() kf_settings_warning = QtCore.pyqtSignal() loaded = QtCore.pyqtSignal() def __init__(self, settings): super(Config, self).__init__() self.settings = settings self.categories = [] self.categories_list = [] self.kf_categories = [] self.local_categories = [] self.kf_config = KfConfig(settings) self.kf_config.kf_con_error.connect(self.propagate_kf_con_error) self.kf_config.kf_settings_warning.connect( self.propagate_kf_settings_warning) self.kf_config.loaded.connect(self._handle_kf_config_loaded) self.local_config = LocalConfig(settings) def propagate_kf_settings_warning(self): self.kf_settings_warning.emit() def propagate_kf_con_error(self): self.kf_con_error.emit() def begin_load(self): self.kf_config.begin_load() def _handle_kf_config_loaded(self): self.categories = [] self.categories_list = [] if self.settings.value("use_custom_file") and self.settings.value( "only_background"): self.kf_categories = [] background_category = self.kf_config.get_background_category() if background_category: self.kf_categories.append(background_category) else: self.kf_categories = self.kf_config.get_categories() self.local_categories = self.local_config.get_categories() self.categories = self.kf_categories + self.local_categories self.categories_list.append(self.kf_categories) self.categories_list.append(self.local_categories) # Tell the world self.loaded.emit() def get_category_lists(self): return self.categories_list def get_categories(self): return self.categories def get_kf_maplayer_node(self, id): return self.kf_config.get_maplayer_node(id) def get_local_maplayer_node(self, id): return self.local_config.get_maplayer_node(id)
class DtMoveSideByArea_Dialog(QtWidgets.QDialog, FORM_CLASS): unsetTool = QtCore.pyqtSignal() moveSide = QtCore.pyqtSignal() def __init__(self, parent, flags): super().__init__(parent, flags) self.setupUi(self) self.method = "fixed" def initGui(self): self.radioFixed.setChecked(True) self.radioVariable.setChecked(False) pass def writeArea(self, area): self.area_label.setText(str(area)) self.targetArea.setText(str(area)) @QtCore.pyqtSlot() def on_radioFixed_clicked(self): self.method = "fixed" @QtCore.pyqtSlot() def on_radioVariable_clicked(self): self.method = "variable" @QtCore.pyqtSlot() def on_buttonClose_clicked(self): self.unsetTool.emit() self.close() @QtCore.pyqtSlot() def on_moveButton_clicked(self): self.moveSide.emit() pass
class ModuleBaseRunWorker(QtCore.QObject): def __init__(self, module): QtCore.QObject.__init__(self) self.module = module self.killed = [False] def run(self): try: self.module.run(statusSignal=self.status, killSignal=self.killed) if not self.killed[0]: self.progress.emit(100) except Exception as e: self.error.emit(e, str(e), self.module) # fix_print_with_import print(("Error:", str(e))) ret = (None, "", self.module) self.finished.emit(ret) @pyqtSlot() def stop(self): self.killed[0] = True finished = QtCore.pyqtSignal(object) error = QtCore.pyqtSignal(Exception, str, object) progress = QtCore.pyqtSignal(float) status = QtCore.pyqtSignal(str)
class ModuleLoadWorker(QtCore.QObject): def __init__(self, module): QtCore.QObject.__init__(self) self.module = module self.killed = False def run(self): ret = None try: self.module.paramClass.load() if not self.killed: self.progress.emit(100) ret = ( self.module, "42", ) except Exception as e: self.error.emit(e, str(e), self.module) self.finished.emit(ret) def kill(self): self.killed = True finished = QtCore.pyqtSignal(object) error = QtCore.pyqtSignal(Exception, str, object) progress = QtCore.pyqtSignal(float)
class GwMainWindowDialog(QMainWindow): dlg_closed = QtCore.pyqtSignal() key_escape = QtCore.pyqtSignal() key_enter = QtCore.pyqtSignal() def __init__(self, subtag=None): super().__init__() self.setupUi(self) self.subtag = subtag # Enable event filter self.installEventFilter(self) def closeEvent(self, event): try: self.dlg_closed.emit() return super().closeEvent(event) except RuntimeError: # This exception jumps, for example, when closing the mincut dialog when it is in docker # RuntimeError: wrapped C/C++ object of type Mincut has been deleted pass def eventFilter(self, object, event): if event.type( ) == QtCore.QEvent.EnterWhatsThisMode and self.isActiveWindow(): QWhatsThis.leaveWhatsThisMode() parser = configparser.ConfigParser() path = os.path.dirname( __file__) + os.sep + 'config' + os.sep + 'init.config' if not os.path.exists(path): print(f"File not found: {path}") webbrowser.open_new_tab('https://giswater.org/giswater-manual') return True parser.read(path) if self.subtag is not None: tag = f'{self.objectName()}_{self.subtag}' else: tag = str(self.objectName()) try: web_tag = parser.get('web_tag', tag) webbrowser.open_new_tab( f'https://giswater.org/giswater-manual/#{web_tag}') except Exception: webbrowser.open_new_tab('https://giswater.org/giswater-manual') return True return False def keyPressEvent(self, event): if event.key() == QtCore.Qt.Key_Escape: self.key_escape.emit() return super().keyPressEvent(event) if event.key() == QtCore.Qt.Key_Return or event.key( ) == QtCore.Qt.Key_Enter: self.key_enter.emit() return super().keyPressEvent(event)
class ListenerWorker(QtCore.QObject): def __init__(self, conn, notify_key): """ Constructor for the ListenerWorker. It required the psycopg2 connection and the notification key (string). :param conn: The psycopg2 connection to the server. It is required to listen notification. :param notify_key: The notification to wait for """ # Call the parent constructor QtCore.QObject.__init__(self) # Field: notification key self.notify_key = notify_key # Field: psycopg2 connection self.conn = conn # Boolean to know if the thread is killed or not self.killed = False def run(self): """ Run action. It is listening for new notification (specially for the notify_key one) """ # Try-except is only to avoid a crash on reload due to async conn close. # It could be improve with full exception management try: while not self.killed: # Wait and retrieve an event appears onto the SQL connection if not select.select([self.conn], [], [], 10) == ([], [], []): # 10 is for the timeout in seconds self.conn.poll() # Get back the information waiting onto the SQL connection while self.conn.notifies: # Iterate on all waiting notification notify = self.conn.notifies.pop(0) # Get the last insert notification # Trigger the refresh only if the notification is the notify_key if notify.channel == self.notify_key: # Emit a progress notification # The progress notification is only used to trigger the refresh self.progress.emit(0) except: pass # When the notification listening is over, trig the progress status with finish. Do not require layers refresh. # To not refresh and kill properly the thread, send a -1 value to the refresh method (via the finished) self.finished.emit(-1) def kill(self): """ Method to stop the thread. """ self.killed = True # Use default method for the finished, error and progress methods (it call the associated callable - refresh - with # a float in param finished = QtCore.pyqtSignal(object) error = QtCore.pyqtSignal(Exception, basestring) progress = QtCore.pyqtSignal(float)
class InfoFeatureUi(GwMainWindow, FORM_CLASS): key_escape = QtCore.pyqtSignal() key_enter = QtCore.pyqtSignal() def keyPressEvent(self, event): if event.key() == QtCore.Qt.Key_Escape: self.key_escape.emit() return super(InfoFeatureUi, self).keyPressEvent(event) elif event.key() == QtCore.Qt.Key_Enter: self.key_enter.emit() return super(InfoFeatureUi, self).keyPressEvent(event)
class VolumeMapTool(qgis.gui.QgsMapTool): def __init__(self, canvas, button): qgis.gui.QgsMapTool.__init__(self, canvas) self.canvas = canvas self.cursor = QtGui.QCursor(QtCore.Qt.CrossCursor) self.button = button def canvasMoveEvent(self, event): # self.emit( QtCore.SIGNAL("moved"), {'x': event.pos().x(), 'y': event.pos().y()} ) self.moved.emit({"x": event.pos().x(), "y": event.pos().y()}) def canvasReleaseEvent(self, event): if event.button() == QtCore.Qt.RightButton: # self.emit( QtCore.SIGNAL("rightClicked"), {'x': event.pos().x(), 'y': event.pos().y()} ) self.rightClicked.emit({ "x": event.pos().x(), "y": event.pos().y() }) else: # self.emit( QtCore.SIGNAL("leftClicked"), {'x': event.pos().x(), 'y': event.pos().y()} ) self.leftClicked.emit({"x": event.pos().x(), "y": event.pos().y()}) def canvasDoubleClickEvent(self, event): # self.emit( QtCore.SIGNAL("doubleClicked"), {'x': event.pos().x(), 'y': event.pos().y()} ) self.doubleClicked.emit({"x": event.pos().x(), "y": event.pos().y()}) def activate(self): qgis.gui.QgsMapTool.activate(self) self.canvas.setCursor(self.cursor) # print 'activate' # self.button.setEnabled(False) # self.button.setCheckable(True) # self.button.setChecked(True) def deactivate(self): # self.emit( QtCore.SIGNAL("deactivate") ) self.desactivate.emit() # self.button.setCheckable(False) # self.button.setEnabled(True) # print 'deactivate' qgis.gui.QgsMapTool.deactivate(self) def setCursor(self, cursor): self.cursor = QtGui.QCursor(cursor) moved = QtCore.pyqtSignal(dict) rightClicked = QtCore.pyqtSignal(dict) leftClicked = QtCore.pyqtSignal(dict) doubleClicked = QtCore.pyqtSignal(dict) desactivate = QtCore.pyqtSignal()
class InitComputeVolume(QtCore.QObject): def __init__(self): QtCore.QObject.__init__(self) self.thread = QtCore.QThread() self.worker = None self.processtype = 0 def start(self, selafin, tool, line): # Launch worker self.worker = computeVolume(selafin, tool, line) self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.computeVolumeMain) self.worker.status.connect(self.writeOutput) self.worker.emitpoint.connect(self.emitPoint) self.worker.error.connect(self.raiseError) self.worker.emitprogressbar.connect(self.updateProgressBar) self.worker.finished.connect(self.workerFinished) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.worker.finished.connect(self.thread.quit) self.thread.start() def raiseError(self, str): if self.processtype == 0: self.error.emit(str) elif self.processtype in [1, 2, 3]: raise GeoAlgorithmExecutionException(str) elif self.processtype == 4: print(str) sys.exit(0) def writeOutput(self, str1): self.status.emit(str(str1)) def workerFinished(self, list1, list2, list3): self.finished1.emit(list1, list2, list3) def emitPoint(self, x, y): self.emitpoint.emit(x, y) def updateProgressBar(self, float1): self.emitprogressbar.emit(float1) status = QtCore.pyqtSignal(str) error = QtCore.pyqtSignal(str) finished1 = QtCore.pyqtSignal(list, list, list) emitpoint = QtCore.pyqtSignal(list, list) emitprogressbar = QtCore.pyqtSignal(float)
class FindDialog(QtWidgets.QDialog, GUI): finished = QtCore.pyqtSignal(str) def __init__(self): super(FindDialog, self).__init__() self.setupUi(self) self.initVariables() self.initSignals() def initVariables(self): self.iface = iface def initSignals(self): self.buttonBox.accepted.connect(self.sendData) self.buttonBox.rejected.connect(self.cancelButton) def sendData(self): if self.smallScale.isChecked(): choice = 'small' elif self.bigScale.isChecked(): choice = 'big' self.finished.emit(choice) def cancelButton(self): self.close()
class DimensioningUi(GwMainWindow, FORM_CLASS): key_escape = QtCore.pyqtSignal() def keyPressEvent(self, event): if event.key() == QtCore.Qt.Key_Escape: self.key_escape.emit() return super(DimensioningUi, self).keyPressEvent(event)
class ChooseLayersDialog(QtWidgets.QDialog, ChooseLayersDialogBase): selected = QtCore.pyqtSignal(object) def __init__(self, parent=None): """Constructor.""" super(ChooseLayersDialog, self).__init__(parent) # Set up the user interface from Designer. # After setupUI you can access any designer object by doing # self.<objectname>, and you can use autoconnect slots - see # http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html # #widgets-and-dialogs-with-auto-connect self.setupUi(self) self.accepted.connect(self.on_accept) def show(self, choices): if not choices: raise CircleCraterError( 'No choice of layers available. ' 'Please create polygon type vector layers.') self.layer_select.clear() for layer in choices: # Add these layers to the combobox (dropdown menu) self.layer_select.addItem(layer.name(), layer) super(ChooseLayersDialog, self).show() def get_layer(self): return self.layer_select.itemData(self.layer_select.currentIndex()) def on_accept(self): self.selected.emit(self.get_layer())
class GwDocker(QDockWidget): dlg_closed = QtCore.pyqtSignal() def __init__(self, subtag=None): super().__init__() # TODO: Check try/catch. Strange error: "GwDocker object has no attribute 'setupUi" try: self.setupUi(self) except Exception: pass self.subtag = subtag def closeEvent(self, event): self.dlg_closed.emit() return super().closeEvent(event) def event(self, event): if (event.type() == QtCore.QEvent.WindowActivate or event.type() == QtCore.QEvent.Show) \ and self.isActiveWindow(): if hasattr(self, "subtag") and self.subtag is not None: tag = f'{self.widget().objectName()}_{self.subtag}' else: tag = str(self.widget().objectName()) global_vars.session_vars['last_focus'] = tag return super().event(event)
class Settings(SettingManager): settings_updated = QtCore.pyqtSignal() def __init__(self): SettingManager.__init__(self, 'Kortforsyningen') self.add_setting(String('username', Scope.Global, '')) self.add_setting(String('password', Scope.Global, '')) self.add_setting(Bool('use_custom_file', Scope.Global, False)) self.add_setting(String('custom_qlr_file', Scope.Global, '')) self.add_setting(Bool('only_background', Scope.Global, False)) path = QFileInfo(os.path.realpath(__file__)).path() kf_path = path + '/kf/' if not os.path.exists(kf_path): os.makedirs(kf_path) self.add_setting(String('cache_path', Scope.Global, kf_path)) self.add_setting(String('kf_qlr_url', Scope.Global, CONFIG_FILE_URL)) def is_set(self): if self.value('username') and self.value('password'): return True return False def emit_updated(self): self.settings_updated.emit()
class Settings(SettingManager): settings_updated = QtCore.pyqtSignal() def __init__(self): SettingManager.__init__(self, 'Dataforsyningen') self.add_setting(String('token', Scope.Global, '')) self.add_setting(Bool('use_custom_file', Scope.Global, False)) self.add_setting(String('custom_qlr_file', Scope.Global, '')) self.add_setting(Bool('only_background', Scope.Global, False)) path = QFileInfo(os.path.realpath(__file__)).path() df_path = path + '/df/' if not os.path.exists(df_path): os.makedirs(df_path) self.add_setting(String('cache_path', Scope.Global, df_path)) self.add_setting(String('df_qlr_url', Scope.Global, CONFIG_FILE_URL)) def is_set(self): is_set = False if self.value('token'): is_set = True elif "Kortforsyningen" in active_plugins: # Take the token from kortforsyning plugin s = QtCore.QSettings() kortforsyningen_token = s.value("plugins/Kortforsyningen/token") if kortforsyningen_token: self.set_value('token', kortforsyningen_token) is_set = True return is_set def emit_updated(self): self.settings_updated.emit()
class ApiCfUi(GwMainWindow, FORM_CLASS): key_pressed = QtCore.pyqtSignal() def keyPressEvent(self, event): if event.key() == QtCore.Qt.Key_Escape: self.key_pressed.emit() return super(ApiCfUi, self).keyPressEvent(event)
class Settings(SettingManager): settings_updated = QtCore.pyqtSignal() def __init__(self): SettingManager.__init__(self, 'GeoAtlas') self.add_setting(String('username', Scope.Global, '')) self.add_setting(String('password', Scope.Global, '')) self.add_setting(String('role', Scope.Global, '')) self.add_setting(Bool('use_custom_file', Scope.Global, False)) path = QFileInfo(os.path.realpath(__file__)).path() geo_path = path + '/geo/' if not os.path.exists(geo_path): os.makedirs(geo_path) self.add_setting(String('cache_path', Scope.Global, geo_path)) self.add_setting(String('custom_qpt_file', Scope.Global, '')) def is_set(self): if self.value('username') and self.value('password') and self.value( 'role'): return True return False def emit_updated(self): self.settings_updated.emit() def getlayout(self): if self.value('use_custom_file'): return self.value('custom_qpt_file') else: return ''
class SelectTool(QG.QgsMapToolIdentify, QG.QgsMapTool): """select geometry on the map""" whichConfig = '' expectedLayerName = None def __init__(self, canvas): self.canvas = canvas QG.QgsMapToolIdentify.__init__(self, canvas) geomSelected = PQtC.pyqtSignal(['QgsVectorLayer', 'QgsFeature']) def canvasReleaseEvent(self, mouseEvent): """handle mouse release event and return indetified feature""" results = self.identify(mouseEvent.x(), mouseEvent.y(), self.TopDownStopAtFirst, self.VectorLayer) if not results == []: idlayer = results[0].mLayer if self.expectedLayerName and idlayer.name() != self.expectedLayerName: MSG.showMsgBox('wronglayeridentified') else: allFeatures = [] if len(results) > 1: for result in results: allFeatures.append(result.mFeature) tempfeature = self.ask_user_for_feature(idlayer, allFeatures) else: tempfeature = results[0].mFeature self.geomSelected.emit(idlayer, tempfeature) else: MSG.showMsgBox('noidentifiedobject') def ask_user_for_feature(self, idLayer, allFeatures): """if more features are identified ask user which one to choose""" targetFeature = None query = "SELECT identifier, type_layer_name FROM {} WHERE child_layer = '{}'".format(self.whichConfig, idLayer.name()) attrs = UC.read_settings(query, False) sortList = [] for feat in allFeatures: if len(attrs) > 1: typeValue = feat[attrs[0]] if isinstance(typeValue, (int, float)): req = '"id" = {}'.format(typeValue) request = QC.QgsFeatureRequest().setFilterExpression(req) type_layer = UC.getlayer_byname(attrs[1]) tempFeature = next(type_layer.getFeatures(request)) sortList.append([feat["id"], tempFeature["naam"]]) else: sortList.append([feat["id"], typeValue]) elif attrs: sortList.append([feat["id"], feat[attrs[0]]]) else: sortList = None if sortList: AskFeatureDialog.askList = sortList chosen, dummy = AskFeatureDialog.askFeature() for feat in allFeatures: if feat["id"] == int(chosen): targetFeature = feat return targetFeature
class Config(QtCore.QObject): dfd_con_error = QtCore.pyqtSignal() dfd_settings_warning = QtCore.pyqtSignal() def __init__(self, settings): super(Config, self).__init__() self.settings = settings self.dfd_config = DfdConfig(settings) self.dfd_config.dfd_con_error.connect(self.propagate_dfd_con_error) self.dfd_config.dfd_settings_warning.connect( self.propagate_dfd_settings_warning) self.local_config = LocalConfig(settings) def propagate_dfd_settings_warning(self): self.dfd_settings_warning.emit() def propagate_dfd_con_error(self): self.dfd_con_error.emit() def load(self): self.dfd_config.load() self.categories = [] self.categories_list = [] self.dfd_categories = self.dfd_config.get_categories() self.categories = self.dfd_categories self.categories_list.append(self.dfd_categories) def get_category_lists(self): return self.categories_list def get_categories(self): return self.categories def get_dfd_maplayer_node(self, id): return self.dfd_config.get_maplayer_node(id) def get_local_maplayer_node(self, id): return self.local_config.get_maplayer_node(id)
class AbstractWorker(QtCore.QObject): """Abstract worker, ihnerit from this and implement the work method""" # available signals finished = QtCore.pyqtSignal(object) error = QtCore.pyqtSignal(Exception, basestring) progress = QtCore.pyqtSignal(float) toggle_show_progress = QtCore.pyqtSignal(bool) toggle_show_cancel = QtCore.pyqtSignal(bool) set_message = QtCore.pyqtSignal(str) # private signal, don't use in concrete workers this is automatically # emitted if the result is not None successfully_finished = QtCore.pyqtSignal(object) def __init__(self): QtCore.QObject.__init__(self) self.is_killed = False def run(self): try: result = self.work() self.finished.emit(result) except UserAbortedNotification: self.finished.emit(None) except Exception, e: # forward the exception upstream self.error.emit(e, traceback.format_exc()) self.finished.emit(None)
class graphicsWindow(QtWidgets.QMainWindow): keyPressed = QtCore.pyqtSignal(QtGui.QKeyEvent) def __init__(self, nom): QtWidgets.QMainWindow.__init__(self) self.ui = Ui_graphicsWindow() self.ui.setupUi(self, nom) self.ui.graphicsView.resizeEvent = self.gwResizeEvent self.currentRect = None self.myRect = QtCore.QRect() self.myPen = QtGui.QPen() self.rayon = 20 self.ui.widget.paintEvent = self.draw cursorPath = ":/Anaglyph/Icons/cursor3x3.png" cursorImage = QtGui.QImage(cursorPath) cursorPix = QtGui.QPixmap.fromImage(cursorImage) self.invisibleCursor = QtGui.QCursor(cursorPix) self.normalCursor = self.cursor() #self.setWindowFlags(Qt.Window | Qt.WindowTitleHint | Qt.CustomizeWindowHint | Qt.WindowMaximizeButtonHint | Qt.WindowMinimizeButtonHint) def keyPressEvent(self, event): self.keyPressed.emit(event) def keyReleaseEvent(self, event): self.keyPressed.emit(event) #Détermine la position du curseur def cursorRectInit(self, x, y): x = int(x / 2) y = int(y / 2) r = self.rayon self.myRect = QtCore.QRect(x - r, y - r, 2 * r, 2 * r) self.vLine = QtCore.QLineF(x - r, y, x + r, y) self.hLine = QtCore.QLineF(x, y - r, x, y + r) self.ui.widget.update() #Fonction qui dessine le curseur au centre de l'image def draw(self, event): p = QtGui.QPainter() p.begin(self.ui.widget) pen = QtGui.QPen(QtGui.QColor(0, 255, 255), 3, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin) rect = self.myRect p.setPen(pen) p.setRenderHint(QtGui.QPainter.Antialiasing) #p.drawEllipse(rect) p.drawLine(self.vLine) p.drawLine(self.hLine) p.end() def gwResizeEvent(self, event): if self.currentRect: self.ui.graphicsView.fitInView(self.currentRect, Qt.KeepAspectRatio) QtWidgets.QGraphicsView.resizeEvent(self.ui.graphicsView, event)
class InitRasterize(QtCore.QObject): def __init__(self): QtCore.QObject.__init__(self) self.thread = None self.worker = None self.processtype = 0 def start(self, selafin, tool): #Launch worker self.thread = QtCore.QThread() self.worker = rasterize(selafin, tool) #self.graphtemp.points = qgspoints #self.worker = self.graphtemp self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.createRaster) self.worker.status.connect(self.writeOutput) self.worker.error.connect(self.raiseError) self.worker.finished.connect(self.workerFinished) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.worker.finished.connect(self.thread.quit) self.thread.start() def raiseError(self, str): if self.processtype == 0: self.status.emit(str) elif self.processtype in [1, 2, 3]: raise GeoAlgorithmExecutionException(str) elif self.processtype == 4: print(str) sys.exit(0) def writeOutput(self, str1): self.status.emit(str(str1)) def workerFinished(self, str): self.finished1.emit(str) status = QtCore.pyqtSignal(str) error = QtCore.pyqtSignal(str) finished1 = QtCore.pyqtSignal(str)
class DtMoveSideByDistance_Dialog(QtWidgets.QDialog, FORM_CLASS): unsetTool = QtCore.pyqtSignal() moveSide = QtCore.pyqtSignal() def __init__(self, parent, flags): super().__init__(parent, flags) self.setupUi(self) def initGui(self): pass @QtCore.pyqtSlot() def on_buttonClose_clicked(self): self.unsetTool.emit() self.close() @QtCore.pyqtSlot() def on_moveButton_clicked(self): self.moveSide.emit() pass
class RunWorker(QtCore.QObject): def __init__(self, SOURCE_LINES, tempf, dtm, dtm_thres, split_size, max_elements): QtCore.QObject.__init__(self) self.SOURCE_LINES = SOURCE_LINES self.tempf = tempf self.split_size = split_size self.max_elements = max_elements self.dtm = dtm self.dtm_thres = dtm_thres def run(self): try: main(self.SOURCE_LINES, self.tempf, self.split_size, self.max_elements, self.progress, self.dtm, self.dtm_thres) except Exception as e: self.error.emit((str(e), e, self)) ret = 1 self.finished.emit(ret) finished = QtCore.pyqtSignal(int) progress = QtCore.pyqtSignal(float) error = QtCore.pyqtSignal(tuple)
class GwDockWidget(QDockWidget): dlg_closed = QtCore.pyqtSignal() def __init__(self, subtag=None, position=None): super().__init__() self.setupUi(self) self.subtag = subtag def closeEvent(self, event): self.dlg_closed.emit() return super().closeEvent(event)
class ClassNamesQComboBox(QW.QComboBox): nextFeatSignal = QtCore.pyqtSignal() def __init__(self, parent=None): super(ClassNamesQComboBox, self).__init__(parent) self.setEditable(False) def keyPressEvent(self, event): if (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_1): if self.count() > 0: self.setCurrentIndex(0) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_2): if self.count() > 1: self.setCurrentIndex(1) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_3): if self.count() > 2: self.setCurrentIndex(2) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_4): if self.count() > 3: self.setCurrentIndex(3) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_5): if self.count() > 4: self.setCurrentIndex(4) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_6): if self.count() > 5: self.setCurrentIndex(5) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_7): if self.count() > 6: self.setCurrentIndex(6) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_8): if self.count() > 7: self.setCurrentIndex(7) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_9): if self.count() > 8: self.setCurrentIndex(8) elif (event.type() == QtCore.QEvent.KeyPress) and (event.key() == QtCore.Qt.Key_0): if self.count() > 9: self.setCurrentIndex(9) elif (event.type() == QtCore.QEvent.KeyPress) and ( (event.key() == QtCore.Qt.Key_Return) or (event.key() == QtCore.Qt.Key_Enter)): self.nextFeatSignal.emit()
class SPARQLCompleter(QCompleter): insertText = QtCore.pyqtSignal(str) def __init__(self, autocomplete, parent=None): QCompleter.__init__(self, autocomplete, parent) self.setCompletionMode(QCompleter.PopupCompletion) #self.setFilterMode(Qt.MatchContains) #self.highlighted.connect(self.setHighlighted) def setHighlighted(self, text): self.lastSelected = text def getSelected(self): return self.lastSelected
class GwDockWidget(QDockWidget): dlg_closed = QtCore.pyqtSignal() def __init__(self, subtag=None): super().__init__() self.setupUi(self) self.subtag = subtag print(f'{type(self)}: {self.objectName()}') def closeEvent(self, event): self.dlg_closed.emit() return super().closeEvent(event)