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)
