def testCalculateDateTimesFromISO8601(self): # invalid duration string vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601( 'x') self.assertFalse(ok) vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601( 'a-03-23T00:00:00Z/2021-03-24T12:00:00Z/PT12H') self.assertFalse(ok) vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601( '2021-03-23T00:00:00Z/b-03-24T12:00:00Z/PT12H') self.assertFalse(ok) vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601( '2021-03-23T00:00:00Z/2021-03-24T12:00:00Z/xc') self.assertFalse(ok) vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601( '2021-03-23T00:00:00Z/2021-03-24T12:00:00Z/PT12H') self.assertEqual(vals, [ QDateTime(2021, 3, 23, 0, 0, 0, 0, Qt.TimeSpec(1)), QDateTime(2021, 3, 23, 12, 0, 0, 0, Qt.TimeSpec(1)), QDateTime(2021, 3, 24, 0, 0, 0, 0, Qt.TimeSpec(1)), QDateTime(2021, 3, 24, 12, 0, 0, 0, Qt.TimeSpec(1)) ]) self.assertTrue(ok) self.assertFalse(exceeded)
def fetchAvailablePlugins(self, reloadMode): """ Fetch plugins from all enabled repositories.""" """ reloadMode = true: Fully refresh data from QgsSettings to mRepositories """ """ reloadMode = false: Fetch unready repositories only """ QApplication.setOverrideCursor(Qt.WaitCursor) if reloadMode: repositories.load() plugins.clearRepoCache() plugins.getAllInstalled() for key in repositories.allEnabled(): if reloadMode or repositories.all()[key]["state"] == 3: # if state = 3 (error or not fetched yet), try to fetch once again repositories.requestFetching(key) if repositories.fetchingInProgress(): fetchDlg = QgsPluginInstallerFetchingDialog(iface.mainWindow()) fetchDlg.exec_() del fetchDlg for key in repositories.all(): repositories.killConnection(key) QApplication.restoreOverrideCursor() # display error messages for every unavailable reposioty, unless Shift pressed nor all repositories are unavailable keepQuiet = QgsApplication.keyboardModifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier) if repositories.allUnavailable() and repositories.allUnavailable() != repositories.allEnabled(): for key in repositories.allUnavailable(): if not keepQuiet: QMessageBox.warning(iface.mainWindow(), self.tr("QGIS Python Plugin Installer"), self.tr("Error reading repository:") + " " + key + "\n\n" + repositories.all()[key]["error"]) if QgsApplication.keyboardModifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier): keepQuiet = True # finally, rebuild plugins from the caches plugins.rebuild()
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()): QDialog.__init__(self, parent, flags) #load the ui uic.loadUi(UI_PATH, self) self.iface = iface self.HelpButton.clicked.connect(self.Help)
def paint_extent(self, rec): self.roi_x_max = rec.xMaximum() self.ui.XMaxLineEdit.setText(str(round(rec.xMaximum(), 3))) self.roi_y_min = rec.yMinimum() self.ui.YMinLineEdit.setText(str(round(rec.yMinimum(), 3))) self.roi_x_min = rec.xMinimum() self.ui.XMinLineEdit.setText(str(round(rec.xMinimum(), 3))) self.roi_y_max = rec.yMaximum() self.ui.YMaxLineEdit.setText(str(round(rec.yMaximum(), 3))) if self.extent: self.canvas.scene().removeItem(self.extent) self.extent = None self.extent = QgsRubberBand(self.canvas, True) points = [ QgsPoint(self.roi_x_max, self.roi_y_min), QgsPoint(self.roi_x_max, self.roi_y_max), QgsPoint(self.roi_x_min, self.roi_y_max), QgsPoint(self.roi_x_min, self.roi_y_min), QgsPoint(self.roi_x_max, self.roi_y_min) ] self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None) self.extent.setColor(QColor(227, 26, 28, 255)) self.extent.setWidth(3) self.extent.setLineStyle(Qt.PenStyle(Qt.DashLine)) self.canvas.refresh()
def flags(self, idx): if idx.column() == self.LAYER_COL: return Qt.ItemIsEnabled layer = self.map_layer(idx) if not layer: return Qt.NoItemFlags else: enabled_flags = Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsUserCheckable if idx.column() == self.LAYER_COL: return Qt.ItemIsEnabled elif idx.column() == self.PACK_COL: return enabled_flags if layer.id() in self.packable else Qt.ItemFlags() elif idx.column() in (self.KEEP_COL, self.IGNORE_COL): return enabled_flags return Qt.ItemFlags()
def tableContentSet(self, file, rows): """Dodanie APP do tabeli zbioru""" def path_leaf(file): head, tail = ntpath.split(file) return tail or ntpath.basename(head) file2 = path_leaf(file) flags = Qt.ItemFlags(32) self.zbiorPrzygotowanieDialog.appTable_widget.setRowCount(rows + 1) # pierwsza kolumna idIIP = utils.getIPPapp(file) itemIIP = QTableWidgetItem(idIIP) itemIIP.setFlags(flags) self.zbiorPrzygotowanieDialog.appTable_widget.setItem( rows, 0, itemIIP) # druga kolumna self.zbiorPrzygotowanieDialog.appTable_widget.setItem( rows, 1, QTableWidgetItem(file2)) test = self.zbiorPrzygotowanieDialog.appTable_widget.item(rows, 1) test.setToolTip(file) # trzecia kolumna t = os.path.getmtime(file) mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(t)) item = QTableWidgetItem(mtime) item.setFlags(flags) # dodanie do tabeli self.zbiorPrzygotowanieDialog.appTable_widget.setItem(rows, 2, item)
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()): QDialog.__init__(self, parent, flags) uic.loadUi(UI_PATH, self) self.iface = iface self.input_layer = None self.raster_layer = None self.raster_layer_box.setFilters(QgsMapLayerProxyModel.RasterLayer) self.raster_layer_box.layerChanged.connect(self.setRasterLayer) self.raster_band_box.setEnabled(False) self.method_box.addItem('nearest neighbor (downscaling/upscaling)') self.method_box.addItem('bi-linear (downscaling)') self.method_box.addItem('bi-cubic (downscaling)') #connect by signal and slot self.browse_button.clicked.connect(self.onBrowseButtonClicked) self.interpolation_group.clicked.connect(self.change_interpolation) self.HelpButton.clicked.connect(self.Help) self.iface.currentLayerChanged.connect(self.setInputLayer) self.setInputLayer(self.iface.activeLayer()) self.setRasterLayer(self.raster_layer_box.currentLayer())
def fill_to_sld(symbolLayer, document, element, brushStyle, color): patternName = '' if brushStyle == Qt.NoBrush: return elif brushStyle == Qt.SolidPattern: if color.isValid(): cssElement = createCssParameterElement(document, 'fill', color.name()) element.appendChild(cssElement) if color.alpha() < 255: cssElement = createCssParameterElement( document, 'fill-opacity', QgsSymbolLayerV2Utils.encodeSldAlpha(color.alpha())) element.appendChild() return elif brushStyle in ( Qt.CrossPattern, Qt.CrossPattern, Qt.DiagCrossPattern, Qt.HorPattern, Qt.VerPattern, Qt.BDiagPattern, Qt.FDiagPattern, Qt.Dense1Pattern, Qt.Dense2Pattern, Qt.Dense3Pattern, Qt.Dense4Pattern, Qt.Dense5Pattern, Qt.Dense6Pattern, Qt.Dense7Pattern, ): patternName = QgsSymbolLayerV2Utils.encodeSldBrushStyle(brushStyle) return else: element.appendChild(document.createComment('Brush not supported')) graphicFillElem = document.createElement('sld:GraphicFill') element.appendChild(graphicFillElem) graphicElem = document.createElement('sld:Graphic') element.appendChild(graphicElem) fillColor = color if patternName.startswith('brush://') else Qt.QColor() borderColor = \ color if not patternName.startswith('brush://') else Qt.QColor() # Use WellKnownName tag to handle QT brush styles. QgsSymbolLayerV2Utils.wellKnownMarkerToSld(document, graphicElem, patternName, fillColor, borderColor, Qt.SolidLine, -1, -1)
def flags(self, index): column_def = self.columns[index.column()] flags = Qt.ItemFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) if column_def['name'] != 'constraints': flags = flags | Qt.ItemIsEditable return flags
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()): QDialog.__init__(self, parent, flags) uic.loadUi(UI_PATH, self) self.iface = iface self.input_layer = None self.browse_button.clicked.connect(self.onBrowseButtonClicked) self.iface.currentLayerChanged.connect(self.setInputLayer) self.setInputLayer(self.iface.activeLayer())
def __init__(self, canvas, callback): self.canvas = canvas QgsMapTool.__init__(self, self.canvas) self.callback = callback self.rubberBand = QgsRubberBand(self.canvas, True) self.rubberBand.setColor(QColor(227, 26, 28, 255)) self.rubberBand.setWidth(3) self.rubberBand.setLineStyle(Qt.PenStyle(Qt.DashLine)) self.reset()
def validateCurrentPage(self): if self.currentId() == 0: if self.importRadioButton.checkState() == Qt.Unchecked( ) and self.createNewRadioButton.checkState() == Qt.Unchecked( ) and self.installRadioButton.checkState() == Qt.Unchecked(): errorMsg = self.tr('An option must be chosen!\n') QMessageBox.warning(self, self.tr('Error!'), errorMsg) return False if self.installRadioButton.checkState() == Qt.Checked(): if self.settingComboBox.currentIndex() == 0: errorMsg = self.tr('A setting must be chosen!\n') QMessageBox.warning(self, self.tr('Error!'), errorMsg) return False else: return True return True else: return True
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()): QDialog.__init__(self, parent=parent, flags=flags) uic.loadUi(UI_PATH, self) self.iface = iface self.db_host.editingFinished.connect(self.onConnectionSettingsEdited) self.db_name.editingFinished.connect(self.onConnectionSettingsEdited) self.db_user.editingFinished.connect(self.onConnectionSettingsEdited) self.db_pass.editingFinished.connect(self.onConnectionSettingsEdited) self.browse_button.clicked.connect(self.onBrowseButtonClicked) self.connect_button.clicked.connect(self.onConnectClicked)
def paint_extent(self, rectParams): width = rectParams["width"] height = rectParams["height"] points = getPointsFromRectangleParams(rectParams) # 0 W 1 # +---------------+ # | | # H | + AuxPto # | | # +---------------+ ----------> rotation # 3 W 2 self.roi_x_max = points[1][0] self.ui.XMaxLineEdit.setText(str(round(self.roi_x_max, 3))) self.roi_y_min = points[3][1] self.ui.YMinLineEdit.setText(str(round(self.roi_y_min, 3))) self.roi_x_min = points[3][0] self.ui.XMinLineEdit.setText(str(round(self.roi_x_min, 3))) self.roi_y_max = points[1][1] self.ui.YMaxLineEdit.setText(str(round(self.roi_y_max, 3))) self.ui.WidthGeoLineEdit.setText(str(round(width, 3))) self.ui.HeightGeoLineEdit.setText(str(round(height, 3))) if self.extent: self.canvas.scene().removeItem(self.extent) self.extent = None if self.divisions: self.canvas.scene().removeItem(self.divisions) self.divisions = [] self.extent = QgsRubberBand(self.canvas, True) points = [ QgsPoint(points[0][0], points[0][1]), QgsPoint(points[1][0], points[1][1]), QgsPoint(points[2][0], points[2][1]), QgsPoint(points[3][0], points[3][1]), QgsPoint(points[0][0], points[0][1]) ] self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None) self.extent.setColor(QColor(227, 26, 28, 255)) self.extent.setWidth(3) self.extent.setLineStyle(Qt.PenStyle(Qt.DashLine)) self.paint_model_division() self.canvas.refresh()
def show_test_dialog(self): test_dialog = QgsDialog(parent=self.iface.mainWindow(), fl=Qt.WindowFlags(), buttons=QDialogButtonBox.Close) test_dialog.setWindowTitle("TEST DIALOG") test_dialog.resize(300, 150) date_time_edit = QgsDateTimeEdit(test_dialog) date_time_edit.setMinimumSize(150, 30) date_time_edit.move(20, 30) btn_accept = QPushButton(test_dialog) btn_accept.move(20, 80) btn_accept.setText("Accept") btn_accept.clicked.connect(self.test_dialog_signal) test_dialog.open()
def tableContentGML(self, file, rows): # data modyfikacji def path_leaf(file): head, tail = ntpath.split(file) return tail or ntpath.basename(head) file2 = path_leaf(file) flags = Qt.ItemFlags(32) self.generowanieGMLDialog.filesTable_widget.setRowCount(rows + 1) self.generowanieGMLDialog.filesTable_widget.setItem( rows, 0, QTableWidgetItem(file2)) test = self.generowanieGMLDialog.filesTable_widget.item(rows, 0) test.setToolTip(file) t = os.path.getmtime(file) mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(t)) item = QTableWidgetItem(mtime) item.setFlags(flags) self.generowanieGMLDialog.filesTable_widget.setItem(rows, 2, item) # Ustawianie rodzaju dokumentu docNames = { 'AktPlanowaniaPrzestrzennego': 'APP', 'RysunekAktuPlanowaniaPrzestrzennego': 'Rysunek APP', 'DokumentFormalny': 'Dokument Formalny' } docName = docNames[utils.getDocType(file)] rodzaj = ['Dokument Formalny', 'APP', 'Rysunek APP'] item2 = QTableWidgetItem(docName) item2.setFlags(flags) self.generowanieGMLDialog.filesTable_widget.setItem(rows, 1, item2) # relacja z APP if self.generowanieGMLDialog.filesTable_widget.item(rows, 1).text() == 'Dokument Formalny': c = QComboBox() c.addItems(dictionaries.relacjeDokumentu.keys()) i = self.generowanieGMLDialog.filesTable_widget.model().index(rows, 3) self.generowanieGMLDialog.filesTable_widget.setCellWidget( rows, 3, c) else: empty = QTableWidgetItem('') empty.setFlags(flags) self.generowanieGMLDialog.filesTable_widget.setItem(rows, 3, empty)
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()): QDialog.__init__(self, parent, flags) uic.loadUi(UI_PATH, self) self.iface = iface self.input_layer = None self.iface.currentLayerChanged.connect(self.setInputLayer) self.setInputLayer(self.iface.activeLayer()) # self.listWidget.currentRowChanged.connect(self.updateRasterPropertiesGroup) self.addButton_2source.clicked.connect(self.add2sourcelist) self.addButton_2sink.clicked.connect(self.add2sinklist) self.addButton_2source_sink_pair.clicked.connect(self.merge2pair) self.removeButton.clicked.connect(self.remove_pair) self.browseButton.clicked.connect(self.onBrowseButtonClicked) self.browseButton.setAutoDefault(False) self.comboBox_conTypes.addItem('physical') self.comboBox_conTypes.addItem('cyber') self.comboBox_conTypes.addItem('geographic') self.comboBox_conTypes.addItem('logical')
def tableContentAddSet(self, iip, file, rows): """Dodanie zbioru do tabeli zbioru""" flags = Qt.ItemFlags(32) self.zbiorPrzygotowanieDialog.appTable_widget.setRowCount(rows + 1) # pierwsza kolumna idIIP = iip itemIIP = QTableWidgetItem(idIIP) itemIIP.setFlags(flags) self.zbiorPrzygotowanieDialog.appTable_widget.setItem( rows, 0, itemIIP) # druga kolumna self.zbiorPrzygotowanieDialog.appTable_widget.setItem( rows, 1, QTableWidgetItem(file)) # trzecia kolumna t = os.path.getmtime(file) mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(t)) item = QTableWidgetItem(mtime) item.setFlags(flags) # dodanie do tabeli self.zbiorPrzygotowanieDialog.appTable_widget.setItem(rows, 2, item)
def paint_model_division(self): if self.rect_Params is None: return if self.divisions: self.canvas.scene().removeItem(self.divisions) self.divisions = [] x_models = int(self.ui.ColPartsSpinBox.value()) y_models = int(self.ui.RowPartsSpinBox.value()) points = getPointsFromRectangleParams(self.rect_Params) lines = [] if y_models > 1: model_height = self.rect_Params["height"] / y_models custRot = self.rect_Params['rotation'] - math.pi * 0.5 for i in range(1, y_models): p1 = getPolarPoint(points[0][0], points[0][1], custRot, model_height * i) p2 = getPolarPoint(points[1][0], points[1][1], custRot, model_height * i) lines.append( [QgsPointXY(p1[0], p1[1]), QgsPointXY(p2[0], p2[1])]) if x_models > 1: model_width = self.rect_Params["width"] / x_models for i in range(1, x_models): p1 = getPolarPoint(points[3][0], points[3][1], self.rect_Params['rotation'], model_width * i) p2 = getPolarPoint(points[0][0], points[0][1], self.rect_Params['rotation'], model_width * i) lines.append( [QgsPointXY(p1[0], p1[1]), QgsPointXY(p2[0], p2[1])]) if lines: self.divisions = QgsRubberBand(self.canvas, False) self.divisions.setColor(QColor(227, 26, 28, 255)) self.divisions.setWidth(3) self.divisions.setLineStyle(Qt.PenStyle(Qt.DashDotLine)) self.divisions.setToGeometry( QgsGeometry.fromMultiPolylineXY(lines), None)
def __init__(self, model=None): super().__init__(None) self.setAttribute(Qt.WA_DeleteOnClose) self.setupUi(self) # LOTS of bug reports when we include the dock creation in the UI file # see e.g. #16428, #19068 # So just roll it all by hand......! self.propertiesDock = QgsDockWidget(self) self.propertiesDock.setFeatures( QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable) self.propertiesDock.setObjectName("propertiesDock") propertiesDockContents = QWidget() self.verticalDockLayout_1 = QVBoxLayout(propertiesDockContents) self.verticalDockLayout_1.setContentsMargins(0, 0, 0, 0) self.verticalDockLayout_1.setSpacing(0) self.scrollArea_1 = QgsScrollArea(propertiesDockContents) sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.scrollArea_1.sizePolicy().hasHeightForWidth()) self.scrollArea_1.setSizePolicy(sizePolicy) self.scrollArea_1.setFocusPolicy(Qt.WheelFocus) self.scrollArea_1.setFrameShape(QFrame.NoFrame) self.scrollArea_1.setFrameShadow(QFrame.Plain) self.scrollArea_1.setWidgetResizable(True) self.scrollAreaWidgetContents_1 = QWidget() self.gridLayout = QGridLayout(self.scrollAreaWidgetContents_1) self.gridLayout.setContentsMargins(6, 6, 6, 6) self.gridLayout.setSpacing(4) self.label_1 = QLabel(self.scrollAreaWidgetContents_1) self.gridLayout.addWidget(self.label_1, 0, 0, 1, 1) self.textName = QLineEdit(self.scrollAreaWidgetContents_1) self.gridLayout.addWidget(self.textName, 0, 1, 1, 1) self.label_2 = QLabel(self.scrollAreaWidgetContents_1) self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1) self.textGroup = QLineEdit(self.scrollAreaWidgetContents_1) self.gridLayout.addWidget(self.textGroup, 1, 1, 1, 1) self.label_1.setText(self.tr("Name")) self.textName.setToolTip(self.tr("Enter model name here")) self.label_2.setText(self.tr("Group")) self.textGroup.setToolTip(self.tr("Enter group name here")) self.scrollArea_1.setWidget(self.scrollAreaWidgetContents_1) self.verticalDockLayout_1.addWidget(self.scrollArea_1) self.propertiesDock.setWidget(propertiesDockContents) self.addDockWidget(Qt.DockWidgetArea(1), self.propertiesDock) self.propertiesDock.setWindowTitle(self.tr("Model properties")) self.inputsDock = QgsDockWidget(self) self.inputsDock.setFeatures(QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable) self.inputsDock.setObjectName("inputsDock") self.inputsDockContents = QWidget() self.verticalLayout_3 = QVBoxLayout(self.inputsDockContents) self.verticalLayout_3.setContentsMargins(0, 0, 0, 0) self.scrollArea_2 = QgsScrollArea(self.inputsDockContents) sizePolicy.setHeightForWidth(self.scrollArea_2.sizePolicy().hasHeightForWidth()) self.scrollArea_2.setSizePolicy(sizePolicy) self.scrollArea_2.setFocusPolicy(Qt.WheelFocus) self.scrollArea_2.setFrameShape(QFrame.NoFrame) self.scrollArea_2.setFrameShadow(QFrame.Plain) self.scrollArea_2.setWidgetResizable(True) self.scrollAreaWidgetContents_2 = QWidget() self.verticalLayout = QVBoxLayout(self.scrollAreaWidgetContents_2) self.verticalLayout.setContentsMargins(0, 0, 0, 0) self.verticalLayout.setSpacing(0) self.inputsTree = QTreeWidget(self.scrollAreaWidgetContents_2) self.inputsTree.setAlternatingRowColors(True) self.inputsTree.header().setVisible(False) self.verticalLayout.addWidget(self.inputsTree) self.scrollArea_2.setWidget(self.scrollAreaWidgetContents_2) self.verticalLayout_3.addWidget(self.scrollArea_2) self.inputsDock.setWidget(self.inputsDockContents) self.addDockWidget(Qt.DockWidgetArea(1), self.inputsDock) self.inputsDock.setWindowTitle(self.tr("Inputs")) self.algorithmsDock = QgsDockWidget(self) self.algorithmsDock.setFeatures(QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable) self.algorithmsDock.setObjectName("algorithmsDock") self.algorithmsDockContents = QWidget() self.verticalLayout_4 = QVBoxLayout(self.algorithmsDockContents) self.verticalLayout_4.setContentsMargins(0, 0, 0, 0) self.scrollArea_3 = QgsScrollArea(self.algorithmsDockContents) sizePolicy.setHeightForWidth(self.scrollArea_3.sizePolicy().hasHeightForWidth()) self.scrollArea_3.setSizePolicy(sizePolicy) self.scrollArea_3.setFocusPolicy(Qt.WheelFocus) self.scrollArea_3.setFrameShape(QFrame.NoFrame) self.scrollArea_3.setFrameShadow(QFrame.Plain) self.scrollArea_3.setWidgetResizable(True) self.scrollAreaWidgetContents_3 = QWidget() self.verticalLayout_2 = QVBoxLayout(self.scrollAreaWidgetContents_3) self.verticalLayout_2.setContentsMargins(0, 0, 0, 0) self.verticalLayout_2.setSpacing(4) self.searchBox = QgsFilterLineEdit(self.scrollAreaWidgetContents_3) self.verticalLayout_2.addWidget(self.searchBox) self.algorithmTree = QgsProcessingToolboxTreeView(None, QgsApplication.processingRegistry()) self.algorithmTree.setAlternatingRowColors(True) self.algorithmTree.header().setVisible(False) self.verticalLayout_2.addWidget(self.algorithmTree) self.scrollArea_3.setWidget(self.scrollAreaWidgetContents_3) self.verticalLayout_4.addWidget(self.scrollArea_3) self.algorithmsDock.setWidget(self.algorithmsDockContents) self.addDockWidget(Qt.DockWidgetArea(1), self.algorithmsDock) self.algorithmsDock.setWindowTitle(self.tr("Algorithms")) self.searchBox.setToolTip(self.tr("Enter algorithm name to filter list")) self.searchBox.setShowSearchIcon(True) self.bar = QgsMessageBar() self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) self.centralWidget().layout().insertWidget(0, self.bar) try: self.setDockOptions(self.dockOptions() | QMainWindow.GroupedDragging) except: pass if iface is not None: self.mToolbar.setIconSize(iface.iconSize()) self.setStyleSheet(iface.mainWindow().styleSheet()) self.mActionOpen.setIcon( QgsApplication.getThemeIcon('/mActionFileOpen.svg')) self.mActionSave.setIcon( QgsApplication.getThemeIcon('/mActionFileSave.svg')) self.mActionSaveAs.setIcon( QgsApplication.getThemeIcon('/mActionFileSaveAs.svg')) self.mActionSaveInProject.setIcon( QgsApplication.getThemeIcon('/mAddToProject.svg')) self.mActionZoomActual.setIcon( QgsApplication.getThemeIcon('/mActionZoomActual.svg')) self.mActionZoomIn.setIcon( QgsApplication.getThemeIcon('/mActionZoomIn.svg')) self.mActionZoomOut.setIcon( QgsApplication.getThemeIcon('/mActionZoomOut.svg')) self.mActionExportImage.setIcon( QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg')) self.mActionZoomToItems.setIcon( QgsApplication.getThemeIcon('/mActionZoomFullExtent.svg')) self.mActionExportPdf.setIcon( QgsApplication.getThemeIcon('/mActionSaveAsPDF.svg')) self.mActionExportSvg.setIcon( QgsApplication.getThemeIcon('/mActionSaveAsSVG.svg')) #self.mActionExportPython.setIcon( # QgsApplication.getThemeIcon('/mActionSaveAsPython.svg')) self.mActionEditHelp.setIcon( QgsApplication.getThemeIcon('/mActionEditHelpContent.svg')) self.mActionRun.setIcon( QgsApplication.getThemeIcon('/mActionStart.svg')) self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock) self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock) self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock) self.tabifyDockWidget(self.inputsDock, self.algorithmsDock) self.inputsDock.raise_() self.zoom = 1 self.setWindowFlags(Qt.WindowMinimizeButtonHint | Qt.WindowMaximizeButtonHint | Qt.WindowCloseButtonHint) settings = QgsSettings() self.restoreState(settings.value("/Processing/stateModeler", QByteArray())) self.restoreGeometry(settings.value("/Processing/geometryModeler", QByteArray())) self.scene = ModelerScene(self, dialog=self) self.scene.setSceneRect(QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE)) self.view.setScene(self.scene) self.view.setAcceptDrops(True) self.view.ensureVisible(0, 0, 10, 10) def _dragEnterEvent(event): if event.mimeData().hasText() or event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'): event.acceptProposedAction() else: event.ignore() def _dropEvent(event): if event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'): data = event.mimeData().data('application/x-vnd.qgis.qgis.algorithmid') stream = QDataStream(data, QIODevice.ReadOnly) algorithm_id = stream.readQString() alg = QgsApplication.processingRegistry().createAlgorithmById(algorithm_id) if alg is not None: self._addAlgorithm(alg, event.pos()) else: assert False, algorithm_id elif event.mimeData().hasText(): itemId = event.mimeData().text() if itemId in [param.id() for param in QgsApplication.instance().processingRegistry().parameterTypes()]: self.addInputOfType(itemId, event.pos()) event.accept() else: event.ignore() def _dragMoveEvent(event): if event.mimeData().hasText() or event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'): event.accept() else: event.ignore() def _wheelEvent(event): self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse) settings = QgsSettings() factor = settings.value('/qgis/zoom_favor', 2.0) # "Normal" mouse has an angle delta of 120, precision mouses provide data # faster, in smaller steps factor = 1.0 + (factor - 1.0) / 120.0 * abs(event.angleDelta().y()) if (event.modifiers() == Qt.ControlModifier): factor = 1.0 + (factor - 1.0) / 20.0 if event.angleDelta().y() < 0: factor = 1 / factor self.view.scale(factor, factor) def _enterEvent(e): QGraphicsView.enterEvent(self.view, e) self.view.viewport().setCursor(Qt.ArrowCursor) def _mouseReleaseEvent(e): QGraphicsView.mouseReleaseEvent(self.view, e) self.view.viewport().setCursor(Qt.ArrowCursor) def _mousePressEvent(e): if e.button() == Qt.MidButton: self.previousMousePos = e.pos() else: QGraphicsView.mousePressEvent(self.view, e) def _mouseMoveEvent(e): if e.buttons() == Qt.MidButton: offset = self.previousMousePos - e.pos() self.previousMousePos = e.pos() self.view.verticalScrollBar().setValue(self.view.verticalScrollBar().value() + offset.y()) self.view.horizontalScrollBar().setValue(self.view.horizontalScrollBar().value() + offset.x()) else: QGraphicsView.mouseMoveEvent(self.view, e) self.view.setDragMode(QGraphicsView.ScrollHandDrag) self.view.dragEnterEvent = _dragEnterEvent self.view.dropEvent = _dropEvent self.view.dragMoveEvent = _dragMoveEvent self.view.wheelEvent = _wheelEvent self.view.enterEvent = _enterEvent self.view.mousePressEvent = _mousePressEvent self.view.mouseMoveEvent = _mouseMoveEvent def _mimeDataInput(items): mimeData = QMimeData() text = items[0].data(0, Qt.UserRole) mimeData.setText(text) return mimeData self.inputsTree.mimeData = _mimeDataInput self.inputsTree.setDragDropMode(QTreeWidget.DragOnly) self.inputsTree.setDropIndicatorShown(True) self.algorithms_model = ModelerToolboxModel(self, QgsApplication.processingRegistry()) self.algorithmTree.setToolboxProxyModel(self.algorithms_model) self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly) self.algorithmTree.setDropIndicatorShown(True) self.algorithmTree.setFilters(QgsProcessingToolboxProxyModel.FilterModeler) if hasattr(self.searchBox, 'setPlaceholderText'): self.searchBox.setPlaceholderText(QCoreApplication.translate('ModelerDialog', 'Search…')) if hasattr(self.textName, 'setPlaceholderText'): self.textName.setPlaceholderText(self.tr('Enter model name here')) if hasattr(self.textGroup, 'setPlaceholderText'): self.textGroup.setPlaceholderText(self.tr('Enter group name here')) # Connect signals and slots self.inputsTree.doubleClicked.connect(self.addInput) self.searchBox.textChanged.connect(self.algorithmTree.setFilterString) self.algorithmTree.doubleClicked.connect(self.addAlgorithm) # Ctrl+= should also trigger a zoom in action ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self) ctrlEquals.activated.connect(self.zoomIn) self.mActionOpen.triggered.connect(self.openModel) self.mActionSave.triggered.connect(self.save) self.mActionSaveAs.triggered.connect(self.saveAs) self.mActionSaveInProject.triggered.connect(self.saveInProject) self.mActionZoomIn.triggered.connect(self.zoomIn) self.mActionZoomOut.triggered.connect(self.zoomOut) self.mActionZoomActual.triggered.connect(self.zoomActual) self.mActionZoomToItems.triggered.connect(self.zoomToItems) self.mActionExportImage.triggered.connect(self.exportAsImage) self.mActionExportPdf.triggered.connect(self.exportAsPdf) self.mActionExportSvg.triggered.connect(self.exportAsSvg) #self.mActionExportPython.triggered.connect(self.exportAsPython) self.mActionEditHelp.triggered.connect(self.editHelp) self.mActionRun.triggered.connect(self.runModel) if model is not None: self.model = model.create() self.model.setSourceFilePath(model.sourceFilePath()) self.textGroup.setText(self.model.group()) self.textName.setText(self.model.displayName()) self.repaintModel() else: self.model = QgsProcessingModelAlgorithm() self.model.setProvider(QgsApplication.processingRegistry().providerById('model')) self.fillInputsTree() self.view.centerOn(0, 0) self.help = None self.hasChanged = False
def flags(self, index): flags = (Qt.ItemIsSelectable + Qt.ItemIsEditable + Qt.ItemIsEnabled) return Qt.ItemFlags(flags)
def test_tool(self): """ Test some plot tool logic """ canvas = QgsElevationProfileCanvas() canvas.setCrs(QgsCoordinateReferenceSystem('EPSG:4326')) canvas.setFrameStyle(0) canvas.resize(600, 400) canvas.setProject(QgsProject.instance()) canvas.show() self.assertEqual(canvas.width(), 600) self.assertEqual(canvas.height(), 400) ls = QgsLineString() ls.fromWkt('LineString(0 2, 10 2, 10 4)') canvas.setProfileCurve(ls) canvas.setVisiblePlotRange(0, ls.length(), 0, 100) self.assertFalse(canvas.tool()) tool = TestTool(canvas) self.assertFalse(tool.isActive()) canvas.setTool(tool) self.assertEqual(canvas.tool(), tool) key_press_event = QKeyEvent(QEvent.KeyPress, 54, Qt.ShiftModifier) canvas.keyPressEvent(key_press_event) self.assertEqual(tool.events[-1].type(), QEvent.KeyPress) key_release_event = QKeyEvent(QEvent.KeyRelease, 54, Qt.ShiftModifier) canvas.keyReleaseEvent(key_release_event) self.assertEqual(tool.events[-1].type(), QEvent.KeyRelease) mouse_dbl_click_event = QMouseEvent(QEvent.MouseButtonDblClick, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier) canvas.mouseDoubleClickEvent(mouse_dbl_click_event) self.assertEqual(tool.events[-1].type(), QEvent.MouseButtonDblClick) self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent) self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.92, delta=0.6) self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4) self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5) mouse_move_event = QMouseEvent(QEvent.MouseMove, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier) canvas.mouseMoveEvent(mouse_move_event) self.assertEqual(tool.events[-1].type(), QEvent.MouseMove) self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent) self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.92, delta=10) self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4) self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5) mouse_press_event = QMouseEvent(QEvent.MouseButtonPress, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier) canvas.mousePressEvent(mouse_press_event) self.assertEqual(tool.events[-1].type(), QEvent.MouseButtonPress) self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent) self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.927, delta=1) self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4) self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5) mouse_release_event = QMouseEvent(QEvent.MouseButtonRelease, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier) canvas.mouseReleaseEvent(mouse_release_event) self.assertEqual(tool.events[-1].type(), QEvent.MouseButtonRelease) self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent) self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.927, delta=1) self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4) self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5) wheel_event = QWheelEvent(QPointF(300, 200), QPointF(300, 200), QPoint(1, 2), QPoint(3, 4), Qt.NoButton, Qt.NoModifier, Qt.ScrollBegin, False) canvas.wheelEvent(wheel_event) self.assertEqual(tool.events[-1].type(), QEvent.Wheel)
def list_item_changed(self): p_index = self.lst_list.currentRow() flags = Qt.ItemFlags() flags != Qt.ItemIsEnabled # Clear table self.clear_table() self.need_to_update_graph = False if p_index >= 0: self.table.setRowCount(0) if self.edit_type == self.edit_patterns: self.current = self.params.patterns[ self.lst_list.currentItem().text()] for v in range(len(self.current.values)): row_pos = self.table.rowCount() self.table.insertRow(row_pos) item = QTableWidgetItem(str(v)) item.setFlags(flags) self.table.setItem(v, 0, item) self.table.setItem( v, 1, QTableWidgetItem(str(self.current.values[v]))) elif self.edit_type == self.edit_curves: self.current = self.params.curves[ self.lst_list.currentItem().text()] for v in range(len(self.current.xs)): row_pos = self.table.rowCount() self.table.insertRow(row_pos) self.table.setItem( v, 0, QTableWidgetItem(str(self.current.xs[v]))) self.table.setItem( v, 1, QTableWidgetItem(str(self.current.ys[v]))) curve_type = self.current.type self.cbo_pump_type.setCurrentIndex(curve_type) # Update GUI self.txt_id.setText(self.current.id) self.txt_desc.setText(self.current.desc) self.update_table_headers() # Update graph self.need_to_update_graph = True self.update_graph() else: # No curves self.txt_id.setText('') self.txt_desc.setText('') # Update table and chart self.need_to_update_graph = False for v in range(self.table.columnCount()): self.table.setItem(v, 1, QTableWidgetItem('')) self.need_to_update_graph = True self.update_graph()
def show_complete_md(self, md: dict, tags: dict): """Open the pop up window that shows the metadata sheet details. :param md dict: Isogeo metadata dict """ logger.info("Displaying the whole metadata sheet.") isogeo_tr = IsogeoTranslator(qsettings.value("locale/userLocale")[0:2]) # clean map canvas vec_lyr = [ i.id() for i in self.complete_md.wid_bbox.layers() if i.type() == 0 ] QgsProject.instance().removeMapLayers(vec_lyr) self.complete_md.wid_bbox.refresh() # -- GENERAL --------------------------------------------------------- if md.get("title"): self.complete_md.lbl_title.setText(md.get("title")) elif md.get("name"): self.complete_md.lbl_title.setText(md.get("name")) else: self.complete_md.lbl_title.setTextFormat(Qt.TextFormat(1)) self.complete_md.lbl_title.setText("<i>{}</i>".format( self.tr("Undefined", context=__class__.__name__))) self.complete_md.val_owner.setText( md.get("_creator").get("contact").get("name", "NR")) # Keywords kwords = tags.get("keywords", {"none": "NR"}) self.complete_md.val_keywords.setText(" ; ".join(kwords.keys())) # INSPIRE themes and conformity themes = tags.get("inspire", {"none": "NR"}) self.complete_md.val_inspire_themes.setText(" ; ".join(themes.keys())) if tags.get("compliance"): self.complete_md.ico_inspire_conformity.setEnabled(1) self.complete_md.ico_inspire_conformity.setToolTip( isogeo_tr.tr("quality", "isConform") + " INSPIRE") else: self.complete_md.ico_inspire_conformity.setDisabled(1) self.complete_md.ico_inspire_conformity.setToolTip( isogeo_tr.tr("quality", "isNotConform") + " INSPIRE") # Abstract self.complete_md.val_abstract.setText(md.get("abstract", "NR")) # -- FEATURE ATTRIBUTES ---------------------------------------------- if md.get("type") == "vectorDataset": # display menu_list = self.complete_md.li_menu item = menu_list.item(1) item.setHidden(0) # fillfull tbl_attr = self.complete_md.tbl_attributes fields = md.get("feature-attributes", dict()) tbl_attr.setRowCount(len(fields)) idx = 0 for i in fields: tbl_attr.setItem(idx, 0, QTableWidgetItem(i.get("name", "NR"))) tbl_attr.setItem(idx, 1, QTableWidgetItem(i.get("alias", ""))) tbl_attr.setItem(idx, 2, QTableWidgetItem(i.get("dataType", ""))) tbl_attr.setItem(idx, 3, QTableWidgetItem(i.get("description", ""))) idx += 1 # adapt size tbl_attr.horizontalHeader().setStretchLastSection(True) tbl_attr.verticalHeader().setSectionResizeMode(3) else: menu_list = self.complete_md.li_menu item = menu_list.item(1) item.setHidden(1) pass # -- CONTACTS -------------------------------------------------------- contacts = md.get("contacts", dict()) contacts_pt_cct = [] contacts_other_cct = [] for ctact in sorted(contacts, key=lambda i: i.get("contact").get("name")): item = ctact.get("contact") if ctact.get("role", "NR") == "pointOfContact": content = "<b>{1}</b> ({2})<br><a href='mailto:{3}' target='_top'>{3}</a><br>{4}" "<br>{5} {6}<br>{7} {8}<br>{8}<br>{9}".format( isogeo_tr.tr("roles", ctact.get("role")), item.get("name", "NR"), item.get("organization", "NR"), item.get("email", "NR"), item.get("phone", "NR"), item.get("addressLine1", ""), item.get("addressLine2", ""), item.get("zipCode", ""), item.get("city", ""), item.get("country", ""), ) contacts_pt_cct.append(content) else: content = ( "<b>{0} - {1}</b> ({2})<br><a href='mailto:{3}' target='_blank'>{3}" "</a><br>{4}<br>{5} {6}<br>{7} {8}<br>{9}".format( isogeo_tr.tr("roles", ctact.get("role")), item.get("name", "NR"), item.get("organization", "NR"), item.get("email", "NR"), item.get("phone", ""), item.get("addressLine1", ""), item.get("addressLine2", ""), item.get("zipCode", ""), item.get("city", ""), item.get("country", ""), )) contacts_other_cct.append(content) # write self.complete_md.val_ct_pointof.setText( "<br><hr><br>".join(contacts_pt_cct)) self.complete_md.val_ct_other.setText( "<br><hr><br>".join(contacts_other_cct)) # -- HISTORY --------------------------------------------------------- # Data creation and last update dates self.complete_md.val_data_crea.setText( plg_tools.handle_date(md.get("_created", "NR"))) self.complete_md.val_data_update.setText( plg_tools.handle_date(md.get("_modified", "NR"))) # Update frequency information if md.get("updateFrequency", None): freq = md.get("updateFrequency") frequency_info = "{}{} {}".format( isogeo_tr.tr("frequencyTypes", "frequencyUpdateHelp"), "".join(i for i in freq if i.isdigit()), isogeo_tr.tr("frequencyShortTypes", freq[-1]), ) self.complete_md.val_frequency.setText(frequency_info) else: self.complete_md.val_frequency.setText("NR") # Validity self.complete_md.val_valid_start.setText( plg_tools.handle_date(md.get("validFrom", "NR"))) self.complete_md.val_valid_end.setText( plg_tools.handle_date(md.get("validTo", "NR"))) self.complete_md.val_valid_comment.setText( md.get("validityComment", "NR")) # Collect information self.complete_md.val_method.setText(md.get("collectionMethod", "NR")) self.complete_md.val_context.setText(md.get("collectionContext", "NR")) # last modifications events = md.get("events", dict()) tbl_events = self.complete_md.tbl_events tbl_events.setRowCount(len(events)) idx = 0 for e in events: if e.get("kind") == "update": tbl_events.setItem( idx, 0, QTableWidgetItem(plg_tools.handle_date(e.get("date", "NR")))) tbl_events.setItem(idx, 1, QTableWidgetItem(e.get("description", ""))) idx += 1 else: pass # adapt size tbl_events.horizontalHeader().setStretchLastSection(True) tbl_events.verticalHeader().setSectionResizeMode(3) # -- TECHNICAL ------------------------------------------------------- # SRS coord_sys = md.get("coordinate-system", {"None": "NR"}) self.complete_md.val_srs.setText("{} (EPSG:{})".format( coord_sys.get("name", "NR"), coord_sys.get("code", "NR"))) # Set the data format if tags.get("formats") != {}: self.complete_md.val_format.setText( list(tags.get("formats").keys())[0]) else: self.complete_md.val_format.setText("NR") # feature info self.complete_md.val_feat_count.setText(str(md.get("features", "/"))) self.complete_md.val_geometry.setText(md.get("geometry", "")) self.complete_md.val_resolution.setText( str(md.get("distance", "")) + " m") self.complete_md.val_scale.setText("1:" + str(md.get("scale", ""))) # Quality self.complete_md.val_topology.setText( md.get("topologicalConsistency", "")) # Specifications specs_in = md.get("specifications", dict()) specs_out = [] for s_in in specs_in: # translate specification conformity if s_in.get("conformant"): s_conformity = isogeo_tr.tr("quality", "isConform") else: s_conformity = isogeo_tr.tr("quality", "isNotConform") # make data human readable if s_in.get("specification").get("published"): s_date = datetime.strptime( s_in.get("specification").get("published"), "%Y-%m-%dT%H:%M:%S") s_date = s_date.strftime("%Y-%m-%d") else: s_date = "<i>Date de publication non renseignée</i>" # prepare text spec_text = "<a href='{1}'><b>{0} ({2})</b></a>: {3}".format( s_in.get("specification").get("name", "NR"), s_in.get("specification").get("link", ""), s_date, s_conformity, ) # store into the final list specs_out.append(spec_text) # write self.complete_md.val_specifications.setText( "<br><hr><br>".join(specs_out)) # Geography if "envelope" in md: qgs_prj = QgsProject.instance() # display self.complete_md.wid_bbox.setDisabled(0) # get convex hull coordinates and create the polygon md_lyr = self.envelope2layer(md.get("envelope")) # add layers qgs_prj.addMapLayers( [md_lyr, li_lyrs_refs[0], li_lyrs_refs[1], li_lyrs_refs[2]], 0) map_canvas_layer_list = [ qgs_prj.mapLayer(md_lyr.id()), qgs_prj.mapLayer(li_lyrs_refs[0].id()), qgs_prj.mapLayer(li_lyrs_refs[1].id()), qgs_prj.mapLayer(li_lyrs_refs[2].id()), ] self.complete_md.wid_bbox.setLayers(map_canvas_layer_list) self.complete_md.wid_bbox.setExtent(md_lyr.extent()) self.complete_md.wid_bbox.zoomOut() else: self.complete_md.grp_bbox.setDisabled(1) # -- CGUs ------------------------------------------------------------ # Licences cgus_in = md.get("conditions", dict()) cgus_out = [] for c_in in cgus_in: if "license" in c_in: cgu_text = "<a href='{1}'><b>{0}</b></a><br>{2}<br>{3}".format( c_in.get("license").get("name", "NR"), c_in.get("license").get("link", ""), c_in.get("description", ""), c_in.get("license").get("content", ""), ) else: cgu_text = "<b>{0}</b><br>{1}".format( isogeo_tr.tr("conditions", "noLicense"), c_in.get("description", "")) # store into the final list cgus_out.append(cgu_text) # write self.complete_md.val_licenses.setText("<br><hr><br>".join(cgus_out)) # Limitations lims_in = md.get("limitations", dict()) lims_out = [] for l_in in lims_in: lim_text = "<b>{0}</b><br>{1}".format( isogeo_tr.tr("limitations", l_in.get("type")), l_in.get("description", ""), ) # legal type if l_in.get("type") == "legal": lim_text += "<br>" + isogeo_tr.tr("restrictions", l_in.get("restriction")) else: pass # INSPIRE precision if "directive" in l_in: lim_text += ( "<br><u>INSPIRE</u><br><ul><li>{}</li><li>{}</li></ul>". format( l_in.get("directive").get("name"), l_in.get("directive").get("description"), )) else: pass # store into the final list lims_out.append(lim_text) # write self.complete_md.val_limitations.setText("<br><hr><br>".join(lims_out)) # -- ADVANCED TAB --------------------------------------------------- # Workgroup owner wg_id = md.get("_creator").get("_id") wg_contact = md.get("_creator").get("contact") self.complete_md.val_owner_name.setText(wg_contact.get("name", "")) self.complete_md.val_owner_email.setText(wg_contact.get("email", "")) self.complete_md.val_owner_phone.setText(wg_contact.get("phone", "")) self.complete_md.val_owner_address.setText("{}<br>{}".format( wg_contact.get("addressLine1", "NR"), wg_contact.get("addressLine2", ""))) self.complete_md.val_owner_city.setText(wg_contact.get("zipCode", "")) self.complete_md.val_owner_country.setText( wg_contact.get("countryCode", "")) # Metadata self.complete_md.val_md_lang.setText(md.get("language", "NR")) self.complete_md.val_md_date_crea.setText( plg_tools.handle_date(md.get("_modified")[:19])) self.complete_md.val_md_date_update.setText( plg_tools.handle_date(md.get("_created")[:19])) # -- EDIT LINK ------------------------------------------------------- self.url_edition = plg_tools.get_edit_url(md_id=md.get("_id"), md_type=md.get("type"), owner_id=wg_id) # only if user declared himself as Isogeo editor in authentication form self.complete_md.btn_md_edit.setEnabled( int(qsettings.value("isogeo/user/editor", 1))) # -- ADD OPTIONS ------------------------------------------------------ self.complete_md.btn_addtomap.setHidden(1) self.complete_md.btn_xml_dl.setHidden(1) # -- DISPLAY --------------------------------------------------------- self.fields_displayer(md.get("type"), md.get("series")) # Finally open the damned window self.complete_md.show() try: QgsMessageLog.logMessage( message="Detailed metadata displayed: {}".format( self.complete_md.lbl_title.text()), tag="Isogeo", level=0, ) except UnicodeEncodeError: QgsMessageLog.logMessage( message="Detailed metadata displayed: {}".format( self.complete_md.lbl_title.text()), tag="Isogeo", level=0, )
def flags(self, index): return Qt.ItemFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled)
def style_maps(self, layer=None, style_by=None): if layer is None: layer = self.layer if style_by is None: style_by = self.default_field_name symbol = QgsSymbolV2.defaultSymbol(layer.geometryType()) # see properties at: # https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073 symbol.setAlpha(1) # opacity if isinstance(symbol, QgsMarkerSymbolV2): # do it only for the layer with points self._set_symbol_size(symbol) symbol.symbolLayer(0).setOutlineStyle(Qt.PenStyle(Qt.NoPen)) style = get_style(layer, self.iface.messageBar()) # this is the default, as specified in the user settings ramp = QgsVectorGradientColorRampV2(style['color_from'], style['color_to']) mode = style['mode'] # in most cases, we override the user-specified setting, and use # instead a setting that was required by scientists if self.output_type in OQ_TO_LAYER_TYPES: default_qgs_style = QgsStyleV2().defaultStyle() default_color_ramp_names = default_qgs_style.colorRampNames() if self.output_type in ('dmg_by_asset', 'losses_by_asset', 'avg_losses-stats'): # options are EqualInterval, Quantile, Jenks, StdDev, Pretty # jenks = natural breaks mode = QgsGraduatedSymbolRendererV2.Jenks ramp_type_idx = default_color_ramp_names.index('Reds') inverted = False elif self.output_type in ('hmaps', 'gmf_data', 'ruptures'): # options are EqualInterval, Quantile, Jenks, StdDev, Pretty if self.output_type == 'ruptures': mode = QgsGraduatedSymbolRendererV2.Pretty else: mode = QgsGraduatedSymbolRendererV2.EqualInterval ramp_type_idx = default_color_ramp_names.index('Spectral') inverted = True ramp = default_qgs_style.colorRamp( default_color_ramp_names[ramp_type_idx]) graduated_renderer = QgsGraduatedSymbolRendererV2.createRenderer( layer, style_by, style['classes'], mode, symbol, ramp, inverted=inverted) label_format = graduated_renderer.labelFormat() # label_format.setTrimTrailingZeroes(True) # it might be useful label_format.setPrecision(2) graduated_renderer.setLabelFormat(label_format, updateRanges=True) # add a class for 0 values, unless while styling ruptures if self.output_type != 'ruptures': VERY_SMALL_VALUE = 1e-20 graduated_renderer.updateRangeLowerValue(0, VERY_SMALL_VALUE) symbol_zeros = QgsSymbolV2.defaultSymbol(layer.geometryType()) symbol_zeros.setColor(QColor(240, 240, 240)) # very light grey if isinstance(symbol, QgsMarkerSymbolV2): # do it only for the layer with points self._set_symbol_size(symbol_zeros) symbol_zeros.symbolLayer(0).setOutlineStyle( Qt.PenStyle(Qt.NoPen)) zeros_min = 0.0 zeros_max = VERY_SMALL_VALUE range_zeros = QgsRendererRangeV2( zeros_min, zeros_max, symbol_zeros, " %.2f - %.2f" % (zeros_min, zeros_max), True) graduated_renderer.addClassRange(range_zeros) graduated_renderer.moveClass( len(graduated_renderer.ranges()) - 1, 0) layer.setRendererV2(graduated_renderer) layer.setLayerTransparency(30) # percent layer.triggerRepaint() self.iface.legendInterface().refreshLayerSymbology(layer) self.iface.mapCanvas().refresh()
def setAvoidStyleSnapRubberBand(self): self.rubberBand.setLineStyle(Qt.PenStyle(Qt.DashDotLine)) self.rubberBand.setSecondaryStrokeColor(QColor(255, 255, 0, 200)) self.rubberBand.setFillColor(QColor(255, 0, 0, 40))
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()): QDialog.__init__(self, parent, flags) uic.loadUi(UI_PATH, self) self.iface = iface self.input_layer = None self.raster_layer = None self.roughness_layer = None #add channel info self.channel_info = None # self.name_box.setExpression('') # self.station_box.setExpression('') self.delta_box.setExpression('0.1') self.connection_box.setExpression("'standard'") self.type_box.setExpression("'river'") self.initial_box.setExpression('0.5') self.point_bc_enabled_box.setExpression('False') self.point_bc_stationary_box.setExpression('True') self.point_bc_value_box.setExpression('0') self.lateral_bc_enabled_box.setExpression('False') self.lateral_bc_stationary_box.setExpression('True') self.lateral_bc_value_box.setExpression('0') self.overflow_left_enabled_box.setExpression('True') self.overflow_left_poleni_box.setExpression('0.577') self.overflow_right_enabled_box.setExpression('True') self.overflow_right_poleni_box.setExpression('0.577') self.localbridgeheight_box.setExpression('1.5') self.bridgebodyheight_box.setExpression('4.0') self.groupBox_bridge.setCollapsed(True) self.mGroupBox_6.setCollapsed(True) self.mGroupBox.setCollapsed(True) self.mGroupBox_4.setCollapsed(True) self.mGroupBox_3.setCollapsed(True) self.mGroupBox_2.setCollapsed(True) self.groupBox_main.setCollapsed(True) self.mGroupBox_4.setCollapsed(False) #set DGM layer self.raster_layer_box.setFilters(QgsMapLayerProxyModel.RasterLayer) self.raster_layer_box.layerChanged.connect(self.setRasterLayer) self.raster_band_box.setEnabled(False) self.method_box.addItem('nearest neighbor (downscaling/upscaling)') self.method_box.addItem('bi-linear (downscaling)') self.method_box.addItem('bi-cubic (downscaling)') #set roughness layer self.roughness_layer_box.setFilters(QgsMapLayerProxyModel.RasterLayer) self.roughness_layer_box.layerChanged.connect(self.setRoughnessLayer) self.roughness_layer_box.setLayer(None) #set channel layer self.comboBox_main.setFilters(QgsMapLayerProxyModel.PolygonLayer) self.comboBox_main.layerChanged.connect(self.setChannelLayer) self.comboBox_main.setLayer(None) self.browse_button.clicked.connect(self.onBrowseButtonClicked) self.HelpButton.clicked.connect(self.Help) self.iface.currentLayerChanged.connect(self.setInputLayer) ############################################# #autostationing button function def autoclicked(state): if state > 0: self.profileid_box.setEnabled(True) self.station_box.setEnabled(False) self.preview_button.setDisabled(True) else: self.profileid_box.setEnabled(False) self.station_box.setEnabled(True) self.preview_button.setDisabled(False) self.profileid_box.setEnabled(False) self.autostation_box.stateChanged.connect(autoclicked) ############################################# if PREVIEW_ENABLED: self.figure = Figure(figsize=(10, 4), dpi=100) self.axes = self.figure.add_subplot(111) self.axes.set_xlabel('Stationing') self.axes.set_ylabel('Elevation [m+NHN]') self.figure.tight_layout() self.canvas = Canvas(self.figure) self.canvas.setParent(self) self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.layout().addWidget(self.canvas) self.canvas.setVisible(False) self.cursor = None self.preview_button.toggled.connect(self.canvas.setVisible) self.preview_button.toggled.connect(self.update_button.setEnabled) self.update_button.clicked.connect(self.updateLongitudinalPreview) else: self.preview_button.setDisabled(True) self.figure = None self.axes = None self.canvas = None self.cursor = None self.setInputLayer(self.iface.activeLayer()) self.setRasterLayer(self.raster_layer_box.currentLayer())
def setAllowedStyleSnapRubberBand(self): self.rubberBand.setLineStyle(Qt.PenStyle(Qt.SolidLine)) self.rubberBand.setSecondaryStrokeColor(QColor(255, 0, 0, 200)) self.rubberBand.setFillColor(QColor(255, 0, 0, 40))
def style_maps(layer, style_by, iface, output_type='damages-rlzs', perils=None, add_null_class=False, render_higher_on_top=False, repaint=True, use_sgc_style=False): symbol = QgsSymbol.defaultSymbol(layer.geometryType()) # see properties at: # https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073 symbol.setOpacity(1) if isinstance(symbol, QgsMarkerSymbol): # do it only for the layer with points symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen)) style = get_style(layer, iface.messageBar()) # this is the default, as specified in the user settings ramp = QgsGradientColorRamp(style['color_from'], style['color_to']) style_mode = style['style_mode'] # in most cases, we override the user-specified setting, and use # instead a setting that was required by scientists if output_type in OQ_TO_LAYER_TYPES: default_qgs_style = QgsStyle().defaultStyle() default_color_ramp_names = default_qgs_style.colorRampNames() if output_type in ( 'damages-rlzs', 'avg_losses-rlzs', 'avg_losses-stats', ): # options are EqualInterval, Quantile, Jenks, StdDev, Pretty # jenks = natural breaks if Qgis.QGIS_VERSION_INT < 31000: style_mode = QgsGraduatedSymbolRenderer.Jenks else: style_mode = 'Jenks' ramp_type_idx = default_color_ramp_names.index('Reds') symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top'])) inverted = False elif (output_type in ('gmf_data', 'ruptures') or (output_type == 'hmaps' and not use_sgc_style)): # options are EqualInterval, Quantile, Jenks, StdDev, Pretty # jenks = natural breaks if output_type == 'ruptures': if Qgis.QGIS_VERSION_INT < 31000: style_mode = QgsGraduatedSymbolRenderer.Pretty else: style_mode = 'PrettyBreaks' else: if Qgis.QGIS_VERSION_INT < 31000: style_mode = QgsGraduatedSymbolRenderer.EqualInterval else: style_mode = 'EqualInterval' ramp_type_idx = default_color_ramp_names.index('Spectral') inverted = True symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top'])) elif output_type == 'hmaps' and use_sgc_style: # FIXME: for SGC they were using size 10000 map units # options are EqualInterval, Quantile, Jenks, StdDev, Pretty # jenks = natural breaks if Qgis.QGIS_VERSION_INT < 31000: style_mode = QgsGraduatedSymbolRenderer.Pretty else: style_mode = 'PrettyBreaks' try: ramp_type_idx = default_color_ramp_names.index( 'SGC_Green2Red_Hmap_Color_Ramp') except ValueError: raise ValueError( 'Color ramp SGC_Green2Red_Hmap_Color_Ramp was ' 'not found. Please import it from ' 'Settings -> Style Manager, loading ' 'svir/resources/sgc_green2red_hmap_color_ramp.xml') inverted = False registry = QgsApplication.symbolLayerRegistry() symbol_props = { 'name': 'square', 'color': '0,0,0', 'color_border': '0,0,0', 'offset': '0,0', 'size': '1.5', # FIXME 'angle': '0', } square = registry.symbolLayerMetadata( "SimpleMarker").createSymbolLayer(symbol_props) symbol = QgsSymbol.defaultSymbol(layer.geometryType()).clone() symbol.deleteSymbolLayer(0) symbol.appendSymbolLayer(square) symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen)) elif output_type in ['asset_risk', 'input']: # options are EqualInterval, Quantile, Jenks, StdDev, Pretty # jenks = natural breaks if Qgis.QGIS_VERSION_INT < 31000: style_mode = QgsGraduatedSymbolRenderer.EqualInterval else: style_mode = 'EqualInterval' # exposure_strings = ['number', 'occupants', 'value'] # setting exposure colors by default colors = { 'single': RAMP_EXTREME_COLORS['Blues']['top'], 'ramp_name': 'Blues' } inverted = False if output_type == 'asset_risk': damage_strings = perils for damage_string in damage_strings: if damage_string in style_by: colors = { 'single': RAMP_EXTREME_COLORS['Spectral']['top'], 'ramp_name': 'Spectral' } inverted = True break else: # 'input' colors = { 'single': RAMP_EXTREME_COLORS['Greens']['top'], 'ramp_name': 'Greens' } symbol.symbolLayer(0).setShape( QgsSimpleMarkerSymbolLayerBase.Square) single_color = colors['single'] ramp_name = colors['ramp_name'] ramp_type_idx = default_color_ramp_names.index(ramp_name) symbol.setColor(QColor(single_color)) else: raise NotImplementedError( 'Undefined color ramp for output type %s' % output_type) ramp = default_qgs_style.colorRamp( default_color_ramp_names[ramp_type_idx]) if inverted: ramp.invert() # get unique values fni = layer.fields().indexOf(style_by) unique_values = layer.dataProvider().uniqueValues(fni) num_unique_values = len(unique_values - {NULL}) if num_unique_values > 2: if Qgis.QGIS_VERSION_INT < 31000: renderer = QgsGraduatedSymbolRenderer.createRenderer( layer, style_by, min(num_unique_values, style['classes']), style_mode, symbol.clone(), ramp) else: renderer = QgsGraduatedSymbolRenderer(style_by, []) # NOTE: the following returns an instance of one of the # subclasses of QgsClassificationMethod classification_method = \ QgsApplication.classificationMethodRegistry().method( style_mode) renderer.setClassificationMethod(classification_method) renderer.updateColorRamp(ramp) renderer.updateSymbols(symbol.clone()) renderer.updateClasses( layer, min(num_unique_values, style['classes'])) if not use_sgc_style: if Qgis.QGIS_VERSION_INT < 31000: label_format = renderer.labelFormat() # NOTE: the following line might be useful # label_format.setTrimTrailingZeroes(True) label_format.setPrecision(2) renderer.setLabelFormat(label_format, updateRanges=True) else: renderer.classificationMethod().setLabelPrecision(2) renderer.calculateLabelPrecision() elif num_unique_values == 2: categories = [] for unique_value in unique_values: symbol = symbol.clone() try: symbol.setColor( QColor(RAMP_EXTREME_COLORS[ramp_name] ['bottom' if unique_value == min(unique_values) else 'top'])) except Exception: symbol.setColor( QColor(style['color_from'] if unique_value == min(unique_values) else style['color_to'])) category = QgsRendererCategory(unique_value, symbol, str(unique_value)) # entry for the list of category items categories.append(category) renderer = QgsCategorizedSymbolRenderer(style_by, categories) else: renderer = QgsSingleSymbolRenderer(symbol.clone()) if add_null_class and NULL in unique_values: # add a class for NULL values rule_renderer = QgsRuleBasedRenderer(symbol.clone()) root_rule = rule_renderer.rootRule() not_null_rule = root_rule.children()[0].clone() # strip parentheses from stringified color HSL not_null_rule.setFilterExpression( '%s IS NOT NULL' % QgsExpression.quotedColumnRef(style_by)) not_null_rule.setLabel('%s:' % style_by) root_rule.appendChild(not_null_rule) null_rule = root_rule.children()[0].clone() null_rule.setSymbol( QgsFillSymbol.createSimple({ 'color': '160,160,160', 'style': 'diagonal_x' })) null_rule.setFilterExpression( '%s IS NULL' % QgsExpression.quotedColumnRef(style_by)) null_rule.setLabel(tr('No points')) root_rule.appendChild(null_rule) if isinstance(renderer, QgsGraduatedSymbolRenderer): # create value ranges rule_renderer.refineRuleRanges(not_null_rule, renderer) # remove default rule elif isinstance(renderer, QgsCategorizedSymbolRenderer): rule_renderer.refineRuleCategoris(not_null_rule, renderer) for rule in rule_renderer.rootRule().children()[1].children(): label = rule.label() # by default, labels are like: # ('"collapse-structural-ASH_DRY_sum" >= 0.0000 AND # "collapse-structural-ASH_DRY_sum" <= 2.3949') first, second = label.split(" AND ") bottom = first.rsplit(" ", 1)[1] top = second.rsplit(" ", 1)[1] simplified = "%s - %s" % (bottom, top) rule.setLabel(simplified) root_rule.removeChildAt(0) renderer = rule_renderer if render_higher_on_top: renderer.setUsingSymbolLevels(True) symbol_items = [item for item in renderer.legendSymbolItems()] for i in range(len(symbol_items)): sym = symbol_items[i].symbol().clone() key = symbol_items[i].ruleKey() for lay in range(sym.symbolLayerCount()): sym.symbolLayer(lay).setRenderingPass(i) renderer.setLegendSymbolItem(key, sym) layer.setRenderer(renderer) if not use_sgc_style: layer.setOpacity(0.7) if repaint: layer.triggerRepaint() iface.setActiveLayer(layer) iface.zoomToActiveLayer() # NOTE QGIS3: probably not needed # iface.layerTreeView().refreshLayerSymbology(layer.id()) iface.mapCanvas().refresh()