def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = QtCore.QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path() + "/python/plugins/DataDrivenInputMask" self.app = QgsApplication.instance() try: self.app.ddManager except AttributeError: ddManager = DdManager(self.iface) self.app.ddManager = ddManager # initialize locale localePath = "" locale = QtCore.QSettings().value("locale/userLocale")[0:2] libPath = os.path.dirname(__file__) libPathFound = False for p in sys.path: if p == libPath: libPathFound = True break if not libPathFound: sys.path.append(libPath) if QtCore.QFileInfo(self.plugin_dir).exists(): localePath = self.plugin_dir + "/i18n/datadriveninputmask_" + locale + ".qm" if QtCore.QFileInfo(localePath).exists(): self.translator = QtCore.QTranslator() self.translator.load(localePath) if QtCore.qVersion() > '4.3.3': QtCore.QCoreApplication.installTranslator(self.translator)
class ExplorerDialog(QtWidgets.QDockWidget, Ui_ExplorerDialog): layerChanged = QtCore.pyqtSignal() refreshLayers = QtCore.pyqtSignal() attributesLoaded = QtCore.pyqtSignal(int) dependentChanged = QtCore.pyqtSignal() chartChanged = QtCore.pyqtSignal() addSelection = QtCore.pyqtSignal(bool) showLinesChanged = QtCore.pyqtSignal(bool) def __init__(self, parent): QtWidgets.QDockWidget.__init__(self, parent) # Set up the user interface from Designer. self.setupUi(self) # global variables self.layer_attributes = {} self.curr_attribute = 0 self.attribute_min = 0.0 self.attribute_max = 0.0 self.symbology_settings = [] self.chart_settings = [] self.curr_chart = 0 # default symbology values self.colourRangeCombo.addItems( ["Classic", "Red - blue", "Greyscale", "Monochrome"]) # "Classic inflection" self.intervalTypeCombo.addItems([ "Equal intervals", "Quantiles", "Natural breaks", "Custom (Equal)" ]) # "Default NACh" # self.layerRefreshButton.hide() self.current_symbology = dict() # self.__clearSymbology() # statistics labels self.__addStatsLabels() self.statisticsProgressBar.hide() # charts widgets self.pLabel.hide() self.chartsProgressBar.hide() self.histogramCheck.setChecked(True) self.lineCheck.setChecked(True) self.__lockDependentGroup(True) # add a pyqtgraph Plotwidget if the package is available, otherwise use a plain graphics view for painting on if has_pyqtgraph: self.chartPlotWidget = pg.PlotWidget(self.chartsTab) self.chartPlotWidget.enableAutoRange() # Enable/disable antialiasing for prettier plots, but much slower pg.setConfigOptions(antialias=False) else: self.chartPlotWidget = QtWidgets.QGraphicsView(self.chartsTab) self.chartPlotWidget.setFrameShape(QtWidgets.QFrame.NoFrame) self.chartPlotWidget.setFrameShadow(QtWidgets.QFrame.Sunken) self.chartPlotWidget.setObjectName("chartPlotWidget") self.chartsLayout.addWidget(self.chartPlotWidget) self.chartsLayout.setStretch(1, 1) # Connect dialog's internal signals and slots # self.attributesLoaded.connect(self.__lockColourControls) self.layerRefreshButton.clicked.connect(self.__refreshLayers) self.layerCombo.activated.connect(self.__selectCurrentLayer) self.attributesList.currentRowChanged.connect(self.__lockApplyButton) self.attributesList.currentRowChanged.connect( self.__selectCurrentAttribute) # symbology colour range settings self.colourRangeCombo.currentIndexChanged.connect( self.__colourRangeSelected) self.lineWidthSpin.valueChanged.connect(self.__lineWidthChanged) self.invertColourCheck.stateChanged.connect(self.__invertColourChanged) self.displayOrderCombo.currentIndexChanged.connect( self.__displayOrderSelected) # symbology interval settings self.intervalSpin.valueChanged.connect(self.__intervalNumberChanged) self.intervalTypeCombo.activated.connect(self.__intervalTypeChanged) self.topLimitSpin.valueChanged.connect(self.__topLimitSpinClicked) self.topLimitText.editingFinished.connect(self.__topLimitTextChanged) self.bottomLimitSpin.valueChanged.connect( self.__bottomLimitSpinClicked) self.bottomLimitText.editingFinished.connect( self.__bottomLimitTextChanged) # charts self.histogramCheck.clicked.connect(self.__histogramSelected) self.scatterplotCheck.clicked.connect(self.__scatterplotSelected) self.yaxisCombo.currentIndexChanged.connect(self.yAxisChanged) self.lineCheck.stateChanged.connect(self.__extraLinesChanged) ##### # General functions of the explorer dialog def keyPressEvent(self, QKeyEvent): if QKeyEvent.key() == QtCore.Qt.Key_Shift: self.addSelection.emit(True) def keyReleaseEvent(self, QKeyEvent): if QKeyEvent.key() == QtCore.Qt.Key_Shift: self.addSelection.emit(False) # Layer and attributes group # def __refreshLayers(self): self.refreshLayers.emit() def setCurrentLayer(self, names, idx=0): # block the signal to update the attributes to avoid repeat updates when there is a layer selected # self.layerCombo.blockSignals(True) self.layerCombo.clear() self.layerCombo.addItems(names) self.layerCombo.setCurrentIndex(idx) # self.layerCombo.blockSignals(False) if idx == 0: self.__selectCurrentLayer() def __selectCurrentLayer(self): self.layerChanged.emit() def getCurrentLayer(self): return self.layerCombo.currentText() def getCurrentTab(self): return self.explorerTabs.currentIndex() def lockLayerRefresh(self, onoff): self.layerRefreshButton.setDisabled(onoff) def setAttributesList(self, data): self.layer_attributes = data self.attributesList.blockSignals(True) self.attributesList.clear() if len(data) > 0: # get the names for the list names = [attr['name'] for attr in self.layer_attributes] self.attributesList.addItems(names) self.__setYAxisCombo(names) self.__lockColourControls(False) else: self.__setYAxisCombo([]) # self.clearPlot() self.__lockColourControls(True) # self.attributesLoaded.emit(self.attributesList.count()) self.attributesList.blockSignals(False) def setAttributesSymbology(self, data): self.symbology_settings = data def setCurrentAttribute(self, idx): self.attributesList.setCurrentRow(idx) def getCurrentAttribute(self): return self.attributesList.currentRow() def __selectCurrentAttribute(self): self.curr_attribute = self.attributesList.currentRow() if self.curr_attribute >= 0: self.__loadDisplaySettings() def __loadDisplaySettings(self): attribute = self.layer_attributes[self.curr_attribute] self.attribute_max = attribute['max'] self.attribute_min = attribute['min'] # get current display settings settings = self.symbology_settings[self.curr_attribute] for key in settings.keys(): self.current_symbology[key] = settings[key] # update the interface self.setColourRanges(int(self.current_symbology['colour_range'])) self.setLineWidthSpin(float(self.current_symbology['line_width'])) self.setInvertColour(int(self.current_symbology['invert_colour'])) self.setDisplayOrder(int(self.current_symbology['display_order'])) self.setIntervalSpin(int(self.current_symbology['intervals'])) self.setIntervalType(int(self.current_symbology['interval_type'])) self.setTopLimitSpin( abs(uf.convertNumeric(self.current_symbology['top_percent']))) self.setTopLimitText(str(self.current_symbology['top_value'])) self.setBottomLimitSpin( abs(uf.convertNumeric(self.current_symbology['bottom_percent']))) self.setBottomLimitText(str(self.current_symbology['bottom_value'])) def __clearSymbology(self): # set default current display settings self.current_symbology = dict(attribute="", colour_range=0, line_width=0.25, invert_colour=0, display_order=0, intervals=10, interval_type=0, top_percent=100, top_value=0.0, bottom_percent=0, bottom_value=0.0) self.attribute_max = 0.0 self.attribute_min = 0.0 # update the interface self.setColourRanges(int(self.current_symbology['colour_range'])) self.setLineWidthSpin(float(self.current_symbology['line_width'])) self.setInvertColour(int(self.current_symbology['invert_colour'])) self.setDisplayOrder(int(self.current_symbology['display_order'])) self.setIntervalSpin(int(self.current_symbology['intervals'])) self.setIntervalType(int(self.current_symbology['interval_type'])) self.setTopLimitSpin( abs(uf.convertNumeric(self.current_symbology['top_percent']))) self.setTopLimitText(str(self.current_symbology['top_value'])) self.setBottomLimitSpin( abs(uf.convertNumeric(self.current_symbology['bottom_percent']))) self.setBottomLimitText(str(self.current_symbology['bottom_value'])) def getUpdatedDisplaySettings(self): settings = dict() for key in self.current_symbology.keys(): settings[key] = self.current_symbology[key] return settings def lockTabs(self, onoff): self.explorerTabs.setDisabled(onoff) self.__clearSymbology() self.__clearStats() self.clearPlot() # Symbology group # def __lockApplyButton(self, onoff): if not onoff and self.current_symbology[ 'top_value'] is not None and self.current_symbology[ 'bottom_value'] is not None: self.symbologyApplyButton.setDisabled(onoff) else: self.symbologyApplyButton.setDisabled(True) def __lockColourControls(self, onoff): # set all the colour and interval controls if self.attributesList.count( ) == 0 or self.current_symbology['colour_range'] == 0: self.colourRangeCombo.setDisabled(onoff) self.invertColourCheck.setDisabled(onoff) self.displayOrderCombo.setDisabled(onoff) self.lineWidthSpin.setDisabled(onoff) self.intervalSpin.setDisabled(onoff) self.intervalTypeCombo.setDisabled(onoff) if onoff == True or self.current_symbology['interval_type'] == 3: self.__lockCustomIntervalControls(onoff) self.__lockApplyButton(onoff) def __lockCustomIntervalControls(self, onoff): self.topLimitLabel.setDisabled(onoff) self.topLimitSpin.setDisabled(onoff) self.topLimitText.setDisabled(onoff) self.bottomLimitLabel.setDisabled(onoff) self.bottomLimitSpin.setDisabled(onoff) self.bottomLimitText.setDisabled(onoff) # Colour settings def setColourRanges(self, idx): if -1 < idx <= self.colourRangeCombo.maxVisibleItems(): self.colourRangeCombo.setCurrentIndex(idx) self.__colourRangeSelected(idx) def __colourRangeSelected(self, idx): self.current_symbology['colour_range'] = idx if idx > 4: self.__lockColourControls(True) else: self.__lockColourControls(False) def setLineWidthSpin(self, value): self.lineWidthSpin.setValue(value) def __lineWidthChanged(self, value): self.current_symbology['line_width'] = value def setInvertColour(self, onoff): self.invertColourCheck.setChecked(onoff) def __invertColourChanged(self, onoff): if onoff: self.current_symbology['invert_colour'] = 1 else: self.current_symbology['invert_colour'] = 0 def setDisplayOrder(self, idx): self.displayOrderCombo.setCurrentIndex(idx) # self.__displayOrderSelected(idx) def __displayOrderSelected(self, idx): self.current_symbology['display_order'] = idx # Interval settings def setIntervalSpin(self, value): self.intervalSpin.setValue(value) def __intervalNumberChanged(self, value): self.current_symbology['intervals'] = value def setIntervalType(self, idx): if -1 < idx <= self.intervalTypeCombo.maxVisibleItems(): self.intervalTypeCombo.setCurrentIndex(idx) self.__intervalTypeChanged(idx) def __intervalTypeChanged(self, idx): self.current_symbology['interval_type'] = idx if self.current_symbology['interval_type'] == 3: if self.attribute_max == 'NULL' or self.attribute_min == 'NULL': self.__lockCustomIntervalControls(True) else: self.__lockCustomIntervalControls(False) if self.current_symbology[ 'top_value'] is None and self.current_symbology[ 'top_value'] is None: self.__lockApplyButton(True) else: self.__lockApplyButton(False) else: self.__lockCustomIntervalControls(True) if self.current_symbology['interval_type'] == 4: # implementation of default NACh ranges used by Bill Hillier and SSx Ltd self.setTopLimitText("1.4") self.__topLimitTextChanged() self.setBottomLimitText("0.8") self.__bottomLimitTextChanged() # else: # self.current_symbology["top_value"] = self.attribute_max # self.current_symbology["bottom_value"] = self.attribute_min self.__lockApplyButton(False) def __topLimitSpinClicked(self, value): self.current_symbology['top_percent'] = value if value < 100: # calculate spin absolute value spin = ((self.attribute_max - self.attribute_min) * self.current_symbology['top_percent'] / 100) + self.attribute_min else: spin = self.attribute_max self.setTopLimitText(str(spin)) self.bottomLimitSpin.setMaximum(value) self.__lockApplyButton(False) def setTopLimitText(self, txt): self.topLimitText.blockSignals(True) self.topLimitText.clear() self.topLimitText.setText(txt) self.current_symbology['top_value'] = float(txt) self.topLimitText.blockSignals(False) def __topLimitTextChanged(self): value = self.topLimitText.text() if uf.isNumeric(value): self.current_symbology['top_value'] = float(value) if self.current_symbology['top_value'] >= self.current_symbology[ 'bottom_value'] and self.current_symbology[ 'top_value'] <= self.attribute_max: # calculate spin percentage spin = abs( ((self.current_symbology['top_value'] - self.attribute_min) / (self.attribute_max - self.attribute_min)) * 100) self.setTopLimitSpin(spin) self.bottomLimitSpin.setMaximum(spin) self.__lockApplyButton(False) else: self.current_symbology['top_value'] = None self.__lockApplyButton(True) else: self.current_symbology['top_value'] = None self.__lockApplyButton(True) def setTopLimitSpin(self, value): self.topLimitSpin.blockSignals(True) self.topLimitSpin.setValue(value) self.current_symbology['top_percent'] = value self.topLimitSpin.blockSignals(False) def __bottomLimitSpinClicked(self, value): self.current_symbology['bottom_percent'] = value if value > 0: # calculate spin absolute value spin = ((self.attribute_max - self.attribute_min) * self.current_symbology['bottom_percent'] / 100) + self.attribute_min else: spin = self.attribute_min self.setBottomLimitText(str(spin)) self.topLimitSpin.setMinimum(value) self.__lockApplyButton(False) def setBottomLimitText(self, txt): self.bottomLimitText.blockSignals(True) self.bottomLimitText.clear() self.bottomLimitText.setText(txt) self.current_symbology['bottom_value'] = float(txt) self.bottomLimitText.blockSignals(False) def __bottomLimitTextChanged(self): value = self.bottomLimitText.text() if uf.isNumeric(value): self.current_symbology['bottom_value'] = float(value) if self.current_symbology['bottom_value'] <= self.current_symbology[ 'top_value'] and self.current_symbology[ 'bottom_value'] >= self.attribute_min: # calculate spin percentage spin = abs(((self.current_symbology['bottom_value'] - self.attribute_min) / (self.attribute_max - self.attribute_min)) * 100) self.setBottomLimitSpin(spin) self.topLimitSpin.setMinimum(spin) self.__lockApplyButton(False) else: self.current_symbology['bottom_value'] = None self.__lockApplyButton(True) else: self.current_symbology['bottom_value'] = None self.__lockApplyButton(True) def setBottomLimitSpin(self, value): self.bottomLimitSpin.blockSignals(True) self.bottomLimitSpin.setValue(value) self.current_symbology['bottom_percent'] = value self.bottomLimitSpin.blockSignals(False) # # Statistics group # def __addStatsLabels(self): self.statisticsTable.setHorizontalHeaderLabels( ["Statistic", "Value", "Selection"]) self.statisticsTable.setRowCount(12) self.statisticsTable.setItem(0, 0, QtWidgets.QTableWidgetItem("Number")) self.statisticsTable.setItem(1, 0, QtWidgets.QTableWidgetItem("Mean")) self.statisticsTable.setItem(2, 0, QtWidgets.QTableWidgetItem("Std Dev")) self.statisticsTable.setItem(3, 0, QtWidgets.QTableWidgetItem("Variance")) self.statisticsTable.setItem(4, 0, QtWidgets.QTableWidgetItem("Median")) self.statisticsTable.setItem(5, 0, QtWidgets.QTableWidgetItem("Minimum")) self.statisticsTable.setItem(6, 0, QtWidgets.QTableWidgetItem("Maximum")) self.statisticsTable.setItem(7, 0, QtWidgets.QTableWidgetItem("Range")) self.statisticsTable.setItem(8, 0, QtWidgets.QTableWidgetItem("1st Quart")) self.statisticsTable.setItem(9, 0, QtWidgets.QTableWidgetItem("3rd Quart")) self.statisticsTable.setItem(10, 0, QtWidgets.QTableWidgetItem("IQR")) self.statisticsTable.setItem(11, 0, QtWidgets.QTableWidgetItem("Gini")) def setStats(self, stats, selection): # update the interface for row in range(self.statisticsTable.rowCount()): label = self.statisticsTable.item(row, 0).text() if label in stats: item = QtWidgets.QTableWidgetItem(str(stats[label])) self.statisticsTable.setItem(row, 1, item) if selection: if label in selection: item = QtWidgets.QTableWidgetItem(str(selection[label])) self.statisticsTable.setItem(row, 2, item) else: self.statisticsTable.setItem(row, 2, QtWidgets.QTableWidgetItem("")) self.statisticsTable.horizontalHeader().setResizeMode( 0, QtWidgets.QHeaderView.ResizeToContents) self.statisticsTable.horizontalHeader().setResizeMode( 1, QtWidgets.QHeaderView.Stretch) self.statisticsTable.horizontalHeader().setResizeMode( 2, QtWidgets.QHeaderView.Stretch) self.statisticsTable.resizeRowsToContents() def __clearStats(self): self.statisticsTable.clear() self.__addStatsLabels() self.statisticsProgressBar.setValue(0) def setStatsProgressBar(self, value): self.statisticsProgressBar.setValue(int(value)) # # Charts group # def __lockDependentGroup(self, onoff): self.yaxisCombo.setDisabled(onoff) self.yaxisLabel.setDisabled(onoff) self.rLabel.setDisabled(onoff) self.pLabel.setDisabled(onoff) self.r2Label.setDisabled(onoff) self.lineLabel.setDisabled(onoff) if onoff: self.clearDependentValues() self.lineCheck.setText("Selection lines") else: self.lineCheck.setText("Regression line") def __histogramSelected(self): self.__lockDependentGroup(True) self.curr_chart = 0 self.clearPlot() self.chartChanged.emit() def __scatterplotSelected(self): self.__lockDependentGroup(False) self.curr_chart = 1 self.clearPlot() self.chartChanged.emit() def getChartType(self): return self.curr_chart def __setYAxisCombo(self, attributes): self.yaxisCombo.clear() self.yaxisCombo.addItems(attributes) # for attr in attributes: # self.yaxisCombo.addItem(attr,attr) self.yaxisCombo.setCurrentIndex(0) def __setYAxisTooltip(self, idx): if idx > 0: self.yaxisCombo.setToolTip(self.yaxisCombo.itemText(idx)) else: self.yaxisCombo.setToolTip( 'Select y axis attribute of scatter plot.') def yAxisChanged(self): if self.curr_chart == 1: self.yaxisCombo.setToolTip( self.yaxisCombo.itemText(self.yaxisCombo.currentIndex())) self.dependentChanged.emit() def getYAxisAttribute(self): return self.yaxisCombo.currentIndex() def clearDependentValues(self): self.rLabel.setText("r: ") self.pLabel.setText("p: ") self.r2Label.setText("r2: ") self.lineLabel.setText("Y = ") def setCorrelation(self, stats): self.rLabel.setText("r: " + str(stats["r"])) self.pLabel.setText("p: " + str(stats["p"])) self.r2Label.setText("r2: " + str(stats["r2"])) self.lineLabel.setText("Y = " + str(stats["line"])) def __extraLinesChanged(self, onoff): self.showLinesChanged.emit(onoff) def clearPlot(self): if has_pyqtgraph: self.chartPlotWidget.clear()
def qInitResources(): QtCore.qRegisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources(): QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
\x00\x00\x01\x53\x8c\x29\xb3\x0e\ \x00\x00\x00\xcc\x00\x00\x00\x00\x00\x01\x00\x00\x0e\x39\ \x00\x00\x01\x53\x8c\x29\xb3\x0e\ \x00\x00\x01\x2a\x00\x00\x00\x00\x00\x01\x00\x00\x18\xbf\ \x00\x00\x01\x53\x8c\x29\xb3\x0e\ \x00\x00\x00\x9e\x00\x00\x00\x00\x00\x01\x00\x00\x08\x7d\ \x00\x00\x01\x53\x8c\x29\xb3\x0e\ \x00\x00\x01\x0e\x00\x00\x00\x00\x00\x01\x00\x00\x15\x86\ \x00\x00\x01\x53\x8c\x29\xb3\x0e\ \x00\x00\x00\x7e\x00\x00\x00\x00\x00\x01\x00\x00\x04\xc4\ \x00\x00\x01\x53\x8c\x29\xb3\x0e\ \x00\x00\x00\xde\x00\x00\x00\x00\x00\x01\x00\x00\x10\x87\ \x00\x00\x01\x53\x8c\x29\xb3\x0e\ " qt_version = QtCore.qVersion().split('.') if qt_version < ['5', '8', '0']: rcc_version = 1 qt_resource_struct = qt_resource_struct_v1 else: rcc_version = 2 qt_resource_struct = qt_resource_struct_v2 def qInitResources(): QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) def qCleanupResources(): QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) qInitResources()
def path(self): return QtCore.QRegularExpression(r"/handlertwo/(?P<code1>\d{2})/(\d{3})")
def _build_search_query( self, search_params: models.GeonodeApiSearchFilters ) -> QtCore.QUrlQuery: query = QtCore.QUrlQuery() query.addQueryItem("page", str(search_params.page)) query.addQueryItem("page_size", str(search_params.page_size)) if search_params.title is not None: query.addQueryItem("filter{title.icontains}", search_params.title) if search_params.abstract is not None: query.addQueryItem("filter{abstract.icontains}", search_params.abstract) if search_params.selected_keyword is not None: query.addQueryItem( "filter{keywords.name.icontains}", search_params.selected_keyword ) if search_params.topic_category is not None: query.addQueryItem( "filter{category.identifier}", search_params.topic_category ) if search_params.temporal_extent_start is not None: query.addQueryItem( "filter{temporal_extent_start.gte}", search_params.temporal_extent_start.toString(QtCore.Qt.ISODate), ) if search_params.temporal_extent_end is not None: query.addQueryItem( "filter{temporal_extent_end.lte}", search_params.temporal_extent_end.toString(QtCore.Qt.ISODate), ) if search_params.publication_date_start is not None: query.addQueryItem( "filter{date.gte}", search_params.publication_date_start.toString(QtCore.Qt.ISODate), ) if search_params.publication_date_end is not None: query.addQueryItem( "filter{date.lte}", search_params.publication_date_end.toString(QtCore.Qt.ISODate), ) # TODO revisit once the support for spatial extent is available on # GeoNode API V2 if ( search_params.spatial_extent is not None and not search_params.spatial_extent.isNull() ): pass if search_params.layer_types is None: types = [ models.GeonodeResourceType.VECTOR_LAYER, models.GeonodeResourceType.RASTER_LAYER, models.GeonodeResourceType.MAP, ] else: types = list(search_params.layer_types) is_vector = models.GeonodeResourceType.VECTOR_LAYER in types is_raster = models.GeonodeResourceType.RASTER_LAYER in types is_map = models.GeonodeResourceType.MAP in types if is_vector and is_raster: pass elif is_vector: query.addQueryItem("filter{subtype}", "vector") elif is_raster: query.addQueryItem("filter{subtype}", "raster") else: raise NotImplementedError if search_params.ordering_field is not None: ordering_field_value = self.get_ordering_filter_name( search_params.ordering_field, reverse_sort=search_params.reverse_ordering, ) query.addQueryItem("sort[]", ordering_field_value) return query
def get_layer_detail_url_endpoint(self, id_: int) -> QtCore.QUrl: return QtCore.QUrl(f"{self.api_url}/datasets/{id_}/")
def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # *********************************************************************** # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QtCore.QSettings().value("locale/userLocale")[0:2] locale_path = os.path.join(self.plugin_dir, "i18n", "posttelemac_{}.qm".format(locale)) if os.path.exists(locale_path): # app=QApplication(['']) self.translator = QtCore.QTranslator() # self.translator = QTranslator(app) self.translator.load(locale_path) QtCore.QCoreApplication.installTranslator(self.translator) """ if qVersion() > '4.3.3': print 'ok' QCoreApplication.installTranslator(self.translator) #app.installTranslator(self.translator) """ # *********************************************************************** self.pluginLayerType = None self.addToRegistry() self.slf = [] # Declare instance attributes self.actions = [] self.menu = self.tr(u"&PostTelemac") # TODO: We are going to let the user set this up in a future iteration # toolbar try: from qgis.PyQt.QtGui import QToolBar except: from qgis.PyQt.QtWidgets import QToolBar toolbars = self.iface.mainWindow().findChildren(QToolBar) test = True for toolbar1 in toolbars: if toolbar1.windowTitle() == u"Telemac": self.toolbar = toolbar1 test = False break if test: self.toolbar = self.iface.addToolBar(u"Telemac") self.toolbar.setObjectName(u"Telemac") self.dlg_about = None # Processing if DOPROCESSING: self.provider = PostTelemacProvider()
def __init__(self, parent, combos, coord=None): if not coord: coord = ["", None, None, ""] super(LegalRestrictionsDialog, self).__init__(parent) if platform.system() != "Linux": font = QFont() font.setFamily(u"Segoe UI Symbol") self.setFont(font) self.setupUi(self) self.setModal(True) self.restrict_dic = combos[0] self.combo_accessrestrictions.setModel( CustomComboBoxModel( self, [None] + sorted(list(combos[0].values()), key=lambda x: x.term_pt))) self.combo_userestrictions.setModel( CustomComboBoxModel( self, [None] + sorted(list(combos[0].values()), key=lambda x: x.term_pt))) self.btn_cancel.clicked.connect(lambda: self.done(QDialog.Rejected)) self.btn_add.clicked.connect(lambda: self.done(QDialog.Accepted)) self.line_uselimitations.textChanged.connect(self.checkInput) self.combo_accessrestrictions.currentIndexChanged.connect( self.checkInput) self.combo_userestrictions.currentIndexChanged.connect(self.checkInput) self.line_otherrestrictions.textEdited.connect(self.checkInput) self.line_uselimitations.setText(coord[0]) if coord[1] is not None: buf = combos[0].get(coord[1].term, None) if buf is not None: self.combo_accessrestrictions.setCurrentIndex( self.combo_accessrestrictions.findText(buf.term_pt)) if coord[2] is not None: buf = combos[0].get(coord[2].term, None) if buf is not None: self.combo_userestrictions.setCurrentIndex( self.combo_userestrictions.findText(buf.term_pt)) self.line_otherrestrictions.setText(coord[3]) self.checkInput() tla.setupMandatoryField(None, self.line_uselimitations, self.label_line_uselimitations, u"Elemento Obrigatório.") tla.setupMandatoryField(None, self.combo_accessrestrictions, self.label_combo_accessrestrictions, u"Elemento Obrigatório.") tla.setupMandatoryField(None, self.combo_userestrictions, self.label_combo_userestrictions, u"Elemento Obrigatório.") self.superParent = None temp = self.parent() while self.superParent is None: if issubclass(type(temp), restrictionsPanel.Ui_restrictions): self.superParent = temp else: temp = temp.parent() for info in self.findChildren(qgui.QPushButton, qcore.QRegExp('info_*')): info.setIcon(qgui.QIcon(':/resourcesFolder/icons/help_icon.svg')) info.setText('') info.pressed.connect(self.printHelp)
def setupUi(self, QgisCloudPlugin): QgisCloudPlugin.setObjectName("QgisCloudPlugin") QgisCloudPlugin.resize(501, 703) QgisCloudPlugin.setLocale( QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates)) self.dockWidgetContents = QtWidgets.QWidget() self.dockWidgetContents.setObjectName("dockWidgetContents") self.gridLayout_3 = QtWidgets.QGridLayout(self.dockWidgetContents) self.gridLayout_3.setObjectName("gridLayout_3") self.tabWidget = QtWidgets.QTabWidget(self.dockWidgetContents) self.tabWidget.setObjectName("tabWidget") self.mapTab = QtWidgets.QWidget() self.mapTab.setObjectName("mapTab") self.gridLayout_4 = QtWidgets.QGridLayout(self.mapTab) self.gridLayout_4.setObjectName("gridLayout_4") self.logo_2 = QtWidgets.QLabel(self.mapTab) self.logo_2.setAutoFillBackground(False) self.logo_2.setPixmap(QtGui.QPixmap(":/plugins/qgiscloud/logo.png")) self.logo_2.setScaledContents(False) self.logo_2.setAlignment(QtCore.Qt.AlignCenter) self.logo_2.setObjectName("logo_2") self.gridLayout_4.addWidget(self.logo_2, 0, 0, 1, 1) self.btnBackgroundLayer = QtWidgets.QToolButton(self.mapTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.btnBackgroundLayer.sizePolicy().hasHeightForWidth()) self.btnBackgroundLayer.setSizePolicy(sizePolicy) self.btnBackgroundLayer.setPopupMode( QtWidgets.QToolButton.InstantPopup) self.btnBackgroundLayer.setToolButtonStyle( QtCore.Qt.ToolButtonTextOnly) self.btnBackgroundLayer.setArrowType(QtCore.Qt.NoArrow) self.btnBackgroundLayer.setObjectName("btnBackgroundLayer") self.gridLayout_4.addWidget(self.btnBackgroundLayer, 1, 0, 1, 1) self.labelOpenLayersPlugin = QtWidgets.QLabel(self.mapTab) self.labelOpenLayersPlugin.setWordWrap(True) self.labelOpenLayersPlugin.setObjectName("labelOpenLayersPlugin") self.gridLayout_4.addWidget(self.labelOpenLayersPlugin, 2, 0, 1, 1) self.line_2 = QtWidgets.QFrame(self.mapTab) self.line_2.setFrameShape(QtWidgets.QFrame.HLine) self.line_2.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_2.setObjectName("line_2") self.gridLayout_4.addWidget(self.line_2, 3, 0, 1, 1) self.btnPublishMap = QtWidgets.QPushButton(self.mapTab) self.btnPublishMap.setObjectName("btnPublishMap") self.gridLayout_4.addWidget(self.btnPublishMap, 4, 0, 1, 1) self.line_3 = QtWidgets.QFrame(self.mapTab) self.line_3.setFrameShape(QtWidgets.QFrame.HLine) self.line_3.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_3.setObjectName("line_3") self.gridLayout_4.addWidget(self.line_3, 5, 0, 1, 1) self.widgetServices = QtWidgets.QWidget(self.mapTab) self.widgetServices.setObjectName("widgetServices") self.gridLayout = QtWidgets.QGridLayout(self.widgetServices) self.gridLayout.setObjectName("gridLayout") self.label = QtWidgets.QLabel(self.widgetServices) self.label.setObjectName("label") self.gridLayout.addWidget(self.label, 1, 0, 1, 1) self.lblWMS = QtWidgets.QLabel(self.widgetServices) self.lblWMS.setOpenExternalLinks(True) self.lblWMS.setObjectName("lblWMS") self.gridLayout.addWidget(self.lblWMS, 1, 1, 1, 1) self.label_5 = QtWidgets.QLabel(self.widgetServices) self.label_5.setObjectName("label_5") self.gridLayout.addWidget(self.label_5, 2, 0, 1, 1) self.lblMaps = QtWidgets.QLabel(self.widgetServices) self.lblMaps.setOpenExternalLinks(True) self.lblMaps.setObjectName("lblMaps") self.gridLayout.addWidget(self.lblMaps, 2, 1, 1, 1) self.label_8 = QtWidgets.QLabel(self.widgetServices) self.label_8.setObjectName("label_8") self.gridLayout.addWidget(self.label_8, 3, 0, 1, 1) self.lblMobileMap_2 = QtWidgets.QLabel(self.widgetServices) self.lblMobileMap_2.setEnabled(True) self.lblMobileMap_2.setOpenExternalLinks(True) self.lblMobileMap_2.setObjectName("lblMobileMap_2") self.gridLayout.addWidget(self.lblMobileMap_2, 3, 1, 1, 1) self.label_3 = QtWidgets.QLabel(self.widgetServices) self.label_3.setObjectName("label_3") self.gridLayout.addWidget(self.label_3, 0, 0, 1, 1) self.lblWebmap = QtWidgets.QLabel(self.widgetServices) self.lblWebmap.setOpenExternalLinks(True) self.lblWebmap.setObjectName("lblWebmap") self.gridLayout.addWidget(self.lblWebmap, 0, 1, 1, 1) self.gridLayout_4.addWidget(self.widgetServices, 6, 0, 1, 1) spacerItem = QtWidgets.QSpacerItem(20, 20, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Fixed) self.gridLayout_4.addItem(spacerItem, 7, 0, 1, 1) self.frame = QtWidgets.QFrame(self.mapTab) self.frame.setEnabled(True) self.frame.setFrameShape(QtWidgets.QFrame.NoFrame) self.frame.setFrameShadow(QtWidgets.QFrame.Raised) self.frame.setLineWidth(1) self.frame.setObjectName("frame") self.gridLayout_6 = QtWidgets.QGridLayout(self.frame) self.gridLayout_6.setObjectName("gridLayout_6") self.widgetMaps = QtWidgets.QWidget(self.frame) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.widgetMaps.sizePolicy().hasHeightForWidth()) self.widgetMaps.setSizePolicy(sizePolicy) self.widgetMaps.setObjectName("widgetMaps") self.gridLayout_2 = QtWidgets.QGridLayout(self.widgetMaps) self.gridLayout_2.setObjectName("gridLayout_2") self.lblMaps_3 = QtWidgets.QLabel(self.widgetMaps) font = QtGui.QFont() font.setBold(True) font.setWeight(75) self.lblMaps_3.setFont(font) self.lblMaps_3.setObjectName("lblMaps_3") self.gridLayout_2.addWidget(self.lblMaps_3, 0, 0, 1, 1) self.tabMaps = QtWidgets.QListWidget(self.widgetMaps) self.tabMaps.setObjectName("tabMaps") self.gridLayout_2.addWidget(self.tabMaps, 1, 0, 1, 3) self.btnMapLoad = QtWidgets.QPushButton(self.widgetMaps) self.btnMapLoad.setObjectName("btnMapLoad") self.gridLayout_2.addWidget(self.btnMapLoad, 2, 0, 1, 1) self.btnMapDelete = QtWidgets.QPushButton(self.widgetMaps) self.btnMapDelete.setEnabled(False) self.btnMapDelete.setObjectName("btnMapDelete") self.gridLayout_2.addWidget(self.btnMapDelete, 2, 1, 1, 1) spacerItem1 = QtWidgets.QSpacerItem(145, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.gridLayout_2.addItem(spacerItem1, 2, 2, 1, 1) self.gridLayout_6.addWidget(self.widgetMaps, 0, 0, 1, 1) self.gridLayout_4.addWidget(self.frame, 8, 0, 1, 1) self.tabWidget.addTab(self.mapTab, "") self.uploadTab = QtWidgets.QWidget() self.uploadTab.setEnabled(True) self.uploadTab.setObjectName("uploadTab") self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.uploadTab) self.verticalLayout_6.setObjectName("verticalLayout_6") self.horizontalLayout_3 = QtWidgets.QHBoxLayout() self.horizontalLayout_3.setObjectName("horizontalLayout_3") self.label_10 = QtWidgets.QLabel(self.uploadTab) self.label_10.setObjectName("label_10") self.horizontalLayout_3.addWidget(self.label_10) self.cbUploadDatabase = QtWidgets.QComboBox(self.uploadTab) self.cbUploadDatabase.setObjectName("cbUploadDatabase") self.horizontalLayout_3.addWidget(self.cbUploadDatabase) self.verticalLayout_6.addLayout(self.horizontalLayout_3) self.lblDbSizeUpload = QtWidgets.QLabel(self.uploadTab) self.lblDbSizeUpload.setText("") self.lblDbSizeUpload.setObjectName("lblDbSizeUpload") self.verticalLayout_6.addWidget(self.lblDbSizeUpload) self.tblLocalLayers = QtWidgets.QTableWidget(self.uploadTab) self.tblLocalLayers.setSelectionBehavior( QtWidgets.QAbstractItemView.SelectRows) self.tblLocalLayers.setObjectName("tblLocalLayers") self.tblLocalLayers.setColumnCount(0) self.tblLocalLayers.setRowCount(0) self.tblLocalLayers.horizontalHeader().setStretchLastSection(True) self.tblLocalLayers.verticalHeader().setVisible(False) self.verticalLayout_6.addWidget(self.tblLocalLayers) self.horizontalLayout_7 = QtWidgets.QHBoxLayout() self.horizontalLayout_7.setObjectName("horizontalLayout_7") spacerItem2 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_7.addItem(spacerItem2) self.btnRefreshLocalLayers = QtWidgets.QPushButton(self.uploadTab) self.btnRefreshLocalLayers.setObjectName("btnRefreshLocalLayers") self.horizontalLayout_7.addWidget(self.btnRefreshLocalLayers) self.verticalLayout_6.addLayout(self.horizontalLayout_7) self.btnUploadData = QtWidgets.QPushButton(self.uploadTab) self.btnUploadData.setObjectName("btnUploadData") self.verticalLayout_6.addWidget(self.btnUploadData) self.progressWidget = QtWidgets.QWidget(self.uploadTab) self.progressWidget.setObjectName("progressWidget") self.horizontalLayout_6 = QtWidgets.QHBoxLayout(self.progressWidget) self.horizontalLayout_6.setObjectName("horizontalLayout_6") self.spinner = Spinner(self.progressWidget) self.spinner.setObjectName("spinner") self.horizontalLayout_6.addWidget(self.spinner) self.lblProgress = QtWidgets.QLabel(self.progressWidget) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.lblProgress.sizePolicy().hasHeightForWidth()) self.lblProgress.setSizePolicy(sizePolicy) self.lblProgress.setText("") self.lblProgress.setObjectName("lblProgress") self.horizontalLayout_6.addWidget(self.lblProgress) self.verticalLayout_6.addWidget(self.progressWidget) self.tabWidget.addTab(self.uploadTab, "") self.accountTab = QtWidgets.QWidget() self.accountTab.setObjectName("accountTab") self.gridLayout_5 = QtWidgets.QGridLayout(self.accountTab) self.gridLayout_5.setObjectName("gridLayout_5") self.horizontalLayout_4 = QtWidgets.QHBoxLayout() self.horizontalLayout_4.setObjectName("horizontalLayout_4") self.label_2 = QtWidgets.QLabel(self.accountTab) self.label_2.setObjectName("label_2") self.horizontalLayout_4.addWidget(self.label_2) self.editServer = QtWidgets.QLineEdit(self.accountTab) self.editServer.setEnabled(True) self.editServer.setObjectName("editServer") self.horizontalLayout_4.addWidget(self.editServer) self.resetUrlBtn = QtWidgets.QToolButton(self.accountTab) icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(":/plugins/qgiscloud/icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.resetUrlBtn.setIcon(icon) self.resetUrlBtn.setObjectName("resetUrlBtn") self.horizontalLayout_4.addWidget(self.resetUrlBtn) self.gridLayout_5.addLayout(self.horizontalLayout_4, 0, 0, 1, 1) self.horizontalLayout_5 = QtWidgets.QHBoxLayout() self.horizontalLayout_5.setObjectName("horizontalLayout_5") self.btnLogin = QtWidgets.QPushButton(self.accountTab) self.btnLogin.setObjectName("btnLogin") self.horizontalLayout_5.addWidget(self.btnLogin) self.lblSignup = QtWidgets.QLabel(self.accountTab) self.lblSignup.setAlignment(QtCore.Qt.AlignCenter) self.lblSignup.setOpenExternalLinks(True) self.lblSignup.setObjectName("lblSignup") self.horizontalLayout_5.addWidget(self.lblSignup) self.lblLoginStatus = QtWidgets.QLabel(self.accountTab) self.lblLoginStatus.setObjectName("lblLoginStatus") self.horizontalLayout_5.addWidget(self.lblLoginStatus) spacerItem3 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_5.addItem(spacerItem3) self.btnLogout = QtWidgets.QPushButton(self.accountTab) self.btnLogout.setObjectName("btnLogout") self.horizontalLayout_5.addWidget(self.btnLogout) self.gridLayout_5.addLayout(self.horizontalLayout_5, 1, 0, 1, 1) self.widgetDatabases = QtWidgets.QWidget(self.accountTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.widgetDatabases.sizePolicy().hasHeightForWidth()) self.widgetDatabases.setSizePolicy(sizePolicy) self.widgetDatabases.setObjectName("widgetDatabases") self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.widgetDatabases) self.verticalLayout_3.setContentsMargins(0, 0, 0, 0) self.verticalLayout_3.setObjectName("verticalLayout_3") self.line = QtWidgets.QFrame(self.widgetDatabases) self.line.setFrameShape(QtWidgets.QFrame.HLine) self.line.setFrameShadow(QtWidgets.QFrame.Sunken) self.line.setObjectName("line") self.verticalLayout_3.addWidget(self.line) self.horizontalLayout_2 = QtWidgets.QHBoxLayout() self.horizontalLayout_2.setObjectName("horizontalLayout_2") self.label_29 = QtWidgets.QLabel(self.widgetDatabases) font = QtGui.QFont() font.setBold(True) font.setWeight(75) self.label_29.setFont(font) self.label_29.setObjectName("label_29") self.horizontalLayout_2.addWidget(self.label_29) self.lblDbSize = QtWidgets.QLabel(self.widgetDatabases) self.lblDbSize.setText("") self.lblDbSize.setObjectName("lblDbSize") self.horizontalLayout_2.addWidget(self.lblDbSize) self.verticalLayout_3.addLayout(self.horizontalLayout_2) self.tabDatabases = QtWidgets.QListWidget(self.widgetDatabases) self.tabDatabases.setSelectionBehavior( QtWidgets.QAbstractItemView.SelectRows) self.tabDatabases.setObjectName("tabDatabases") self.verticalLayout_3.addWidget(self.tabDatabases) self.horizontalLayout = QtWidgets.QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") self.btnDbCreate = QtWidgets.QPushButton(self.widgetDatabases) self.btnDbCreate.setObjectName("btnDbCreate") self.horizontalLayout.addWidget(self.btnDbCreate) self.btnDbDelete = QtWidgets.QPushButton(self.widgetDatabases) self.btnDbDelete.setEnabled(False) self.btnDbDelete.setObjectName("btnDbDelete") self.horizontalLayout.addWidget(self.btnDbDelete) spacerItem4 = QtWidgets.QSpacerItem(37, 17, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout.addItem(spacerItem4) self.btnDbRefresh = QtWidgets.QPushButton(self.widgetDatabases) self.btnDbRefresh.setObjectName("btnDbRefresh") self.horizontalLayout.addWidget(self.btnDbRefresh) self.verticalLayout_3.addLayout(self.horizontalLayout) self.gridLayout_5.addWidget(self.widgetDatabases, 2, 0, 1, 1) self.line_4 = QtWidgets.QFrame(self.accountTab) self.line_4.setFrameShape(QtWidgets.QFrame.HLine) self.line_4.setFrameShadow(QtWidgets.QFrame.Sunken) self.line_4.setObjectName("line_4") self.gridLayout_5.addWidget(self.line_4, 3, 0, 1, 1) self.tabWidget.addTab(self.accountTab, "") self.aboutTab = QtWidgets.QWidget() self.aboutTab.setObjectName("aboutTab") self.verticalLayout = QtWidgets.QVBoxLayout(self.aboutTab) self.verticalLayout.setObjectName("verticalLayout") self.logo = QtWidgets.QLabel(self.aboutTab) self.logo.setAutoFillBackground(False) self.logo.setPixmap(QtGui.QPixmap(":/plugins/qgiscloud/logo.png")) self.logo.setScaledContents(False) self.logo.setAlignment(QtCore.Qt.AlignCenter) self.logo.setObjectName("logo") self.verticalLayout.addWidget(self.logo) self.horizontalLayout_8 = QtWidgets.QHBoxLayout() self.horizontalLayout_8.setObjectName("horizontalLayout_8") self.label_6 = QtWidgets.QLabel(self.aboutTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred, QtWidgets.QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.label_6.sizePolicy().hasHeightForWidth()) self.label_6.setSizePolicy(sizePolicy) self.label_6.setObjectName("label_6") self.horizontalLayout_8.addWidget(self.label_6) self.lblVersionPlugin = QtWidgets.QLabel(self.aboutTab) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( self.lblVersionPlugin.sizePolicy().hasHeightForWidth()) self.lblVersionPlugin.setSizePolicy(sizePolicy) self.lblVersionPlugin.setText("") self.lblVersionPlugin.setObjectName("lblVersionPlugin") self.horizontalLayout_8.addWidget(self.lblVersionPlugin) self.verticalLayout.addLayout(self.horizontalLayout_8) self.aboutText = QtWidgets.QTextEdit(self.aboutTab) self.aboutText.setObjectName("aboutText") self.verticalLayout.addWidget(self.aboutText) self.tabWidget.addTab(self.aboutTab, "") self.gridLayout_3.addWidget(self.tabWidget, 1, 0, 1, 1) QgisCloudPlugin.setWidget(self.dockWidgetContents) self.label_2.setBuddy(self.editServer) self.retranslateUi(QgisCloudPlugin) self.tabWidget.setCurrentIndex(2) QtCore.QMetaObject.connectSlotsByName(QgisCloudPlugin)
class ElementTableGUI(QWidget): """Create the periodic element gui with toggleble buttons for element selection and preview signal triggered with mouse hover events and right click for optional menu/ window. Initialisation can take python list with elements for which buttons is pre-toggled: ----------- args: prechecked -- python list with elements (abbrevations), the buttons which should be initially pushed. state_list = python list -- list of elements (abbrevations) for buttons which should be disabled (by default) or enabled (if state_list_enables is True. state_list_enables = False (default) -- set interpretation of state_list silent_disabled = False (default) -- controls the behaviour of disabled element buttons if True, then disabled buttons do not emit any signal disable_fancy = False (default) -- controls if do button geometry changes with hover over/off events buttons_auto_depress = False (Default) -- controls if element buttons hold its state or only triggers when pushed (and automatically depresses). ----------- additionally to native QtGui.QWidget provides such signals: elementConsidered -- signal which emits element abbrevation when mouse hovers over the button, or the coresponding button gets focus, or is emitted by text input interface. elementUnconsidered -- emits element abrevation at moment mouse leaves the button area elementChecked -- emits the element abbrevation when button changes to checked possition. elementUnchecked -- emits the element abbrevation when button changes to unchecked possition. elementRightClicked -- emits the element abbrevation when button gets right clicked. elementTriggered -- emits the element abbrevation when button gets triggered (intended to be used with buttons_auto_depress=True) allElementsCleared -- emits, when the clear all button clicked. Alternatively the element by element could be dissabled, however this signal can be much faster. """ # preview slots: elementConsidered = QtCore.pyqtSignal(str) elementUnconsidered = QtCore.pyqtSignal(str) # button press slots: elementChecked = QtCore.pyqtSignal(str) elementUnchecked = QtCore.pyqtSignal(str) elementTriggered = QtCore.pyqtSignal(str) # right_mouse_button_press_slot: elementRightClicked = QtCore.pyqtSignal(str) allElementsCleared = QtCore.pyqtSignal() def __init__(self, parent=None, prechecked=[], state_list=[], state_list_enables=False, silent_disabled=False, disable_fancy=False, buttons_auto_depress=False): super().__init__() if type(state_list) == str: state_list = parse_elements(state_list) if (len(prechecked) > 0) and buttons_auto_depress: warnings.warn( "element table is initialised with opposite" " arguements - seting buttons to auto depress rules out" " using prechecked element list. The list is ignored") prechecked = [] self.setWindowTitle('Element Table') layout = QGridLayout(self) self.setLayout(layout) layout.setSpacing(0) layout.setContentsMargins(4, 4, 4, 4) partly_disabled = not silent_disabled self._setup_table(prechecked, state_list, state_list_enables, partly_disabled, disable_fancy, buttons_auto_depress) self._setup_text_interface() self._setup_clear_all() if not buttons_auto_depress: self.set_table_mode('multi') # default else: self.set_table_mode('single') self.resize(400, 250) def _setup_clear_all(self): self.clear_all_button = QPushButton('Clear all') self.layout().addWidget(self.clear_all_button, 7, 0, 2, 3) self.clear_all_button.pressed.connect(self.clear_all) self.clear_all_button.setMinimumSize(32, 32) self.clear_all_button.setMaximumSize(512, 512) def _setup_text_interface(self): self.textInterface = QLineEdit() self.textInterface.setMinimumSize(16, 16) self.layout().addWidget(self.textInterface, 8, 9, 1, 9) self.textInterface.returnPressed.connect(self.toggle_elements) self.textInterface.textChanged.connect(self.consider_element) self.textInterface.setMaximumSize(512, 1024) def set_extended_completer(self): completer = QCompleter( list(pt_indexes.keys()) + list(geo_groups.keys()) + list(names_abbrv.keys())) self.textInterface.setCompleter(completer) def set_simple_completer(self): completer = QCompleter(list(pt_indexes.keys())) self.textInterface.setCompleter(completer) def set_table_mode(self, mode): if mode == 'multi': self.textInterface.setEnabled(True) self.set_extended_completer() self.textInterface.setToolTip( "text interface.\n" "Input abbrevations of elements:\n" " without any space:\n" " AlSiNaK\n" " with any separators like comma/space:\n" " Al;Br K,La\n" "abbrevations of element groups (in all caps):\n" " HFSE, REE, REE_SEM, LILE, MAJOR\n" "Use '-' (minus) sign to disable elements:\n" " -AlCa, K; P -> toggles off Al, Ca, K, P\n" "HFSE - Nb -> toggles on HFSE elements, but switches off Nb") self.clear_all_button.setEnabled(True) self.textInterface.setInputMask("") elif mode == 'single': self.textInterface.setEnabled(False) # self.set_simple_completer() # self.textInterface.setToolTip( # "Enter a single element abbreviation") self.clear_all_button.setEnabled(False) # self.textInterface.setInputMask(">A<a") for i in geo_groups['ALL']: self.getButton_by_name(i).change_mode(mode) def getButton(self, index): """helper function to get button by position index - tuple (row, column)""" item = self.layout().itemAtPosition(*index) return item.widget() def getButton_by_name(self, name): """helper function to get button by abbrevation of the element""" item = self.layout().itemAtPosition(*pt_indexes[name]) return item.widget() def toggle_elements(self): ptext = self.textInterface.text() positive_text, negative_text = separate_text(ptext) # clear text interface: self.textInterface.clear() # parse what to add first: positive_list = parse_elements(positive_text) self.toggle_on(positive_list) # parse what to remove: negative_list = parse_elements(negative_text) self.toggle_off(negative_list) def consider_element(self, text): positive_text = separate_text(text)[0] positive_list = parse_elements(positive_text) self.elementUnconsidered.emit('') for i in positive_list: self.elementConsidered.emit(i) def toggle_on(self, toggle_list): for i in toggle_list: button = self.getButton(pt_indexes[i]) if button.isEnabled(): button.setChecked(True) def toggle_off(self, toggle_list): for i in toggle_list: button = self.getButton(pt_indexes[i]) if button.isEnabled(): button.setChecked(False) def clear_all(self): """uncheck all buttons, and send single signal instead of many per button, which allows to do related action in more snappy maner.""" self.blockSignals(True) self.toggle_off(geo_groups['ALL']) self.blockSignals(False) self.allElementsCleared.emit() def _setup_table(self, prechecked_elements, state_list, state_list_enables, partly_disabled, disable_fancy, auto_depresso): self.signalMapper = QtCore.QSignalMapper(self) self.signalMapper.mapped[QWidget].connect(self.previewToggler) self.signalMapper2 = QtCore.QSignalMapper(self) self.signalMapper2.mapped[QWidget].connect(self.elementToggler) self.signalMapper3 = QtCore.QSignalMapper(self) self.signalMapper3.mapped[QWidget].connect(self.emit_right_clicked) self.signalMapper4 = QtCore.QSignalMapper(self) self.signalMapper4.mapped[QWidget].connect(self.focus_on_toggler) self.signalMapper5 = QtCore.QSignalMapper(self) self.signalMapper5.mapped[QWidget].connect(self.focus_off_toggler) self.signalMapper6 = QtCore.QSignalMapper(self) self.signalMapper6.mapped[QWidget].connect(self.emit_triggered) is_checkable = not auto_depresso for i in pt_indexes: pt_button = HoverableButton(i, partly_disabled=partly_disabled, disable_fancy=disable_fancy, is_checkable=is_checkable) pt_button.setMinimumSize(16, 16) pt_button.setMaximumSize(512, 512) if i in prechecked_elements: pt_button.setChecked(True) self.layout().addWidget(pt_button, pt_indexes[i][0], pt_indexes[i][1]) # pt_button.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) pt_button.hoverChanged.connect(self.signalMapper.map) pt_button.toggled.connect(self.signalMapper2.map) pt_button.rightClicked.connect(self.signalMapper3.map) pt_button.gainedFocus.connect(self.signalMapper4.map) pt_button.lostFocus.connect(self.signalMapper5.map) pt_button.pressed.connect(self.signalMapper6.map) self.signalMapper.setMapping(pt_button, pt_button) self.signalMapper2.setMapping(pt_button, pt_button) self.signalMapper3.setMapping(pt_button, pt_button) self.signalMapper4.setMapping(pt_button, pt_button) self.signalMapper5.setMapping(pt_button, pt_button) self.signalMapper6.setMapping(pt_button, pt_button) line = QFrame() line.setFrameShape(QFrame.HLine) line.setFrameShadow(QFrame.Sunken) line.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.layout().addWidget(line, 6, 3, 1, 15) # dissable elements/buttons for provided list: if state_list_enables: disabled_elements = set(pt_indexes).difference(state_list) else: disabled_elements = state_list for i in disabled_elements: self.getButton(pt_indexes[i]).setEnabled(False) lant_text = QLabel('Lan') act_text = QLabel('Act') lant_text.setAlignment(QtCore.Qt.AlignCenter) act_text.setAlignment(QtCore.Qt.AlignCenter) self.layout().addWidget(lant_text, 5, 2) self.layout().addWidget(act_text, 6, 2) lant_text.setEnabled(False) act_text.setEnabled(False) def update_state(self, element, enable=True): """update state of button for given element (enable, disable); this method is intended to be used when model containing element list is updated (new element added or removed)""" self.signalMapper2.blockSignals(True) button = self.getButton_by_name(element) if not enable and button.isChecked(): button.setChecked(False) button.setEnabled(enable) self.signalMapper2.blockSignals(False) def keyPressEvent(self, event): """Jump to text interface at shift key press""" if event.key() == QtCore.Qt.Key_Shift: self.textInterface.setFocus() # @QtCore.pyqtSlot(QtCore.QObject) # NOTE decorators are commented out # as pyQt5.7 made regression with using QObject or QWidget in signals # or is it the problem with mapping of signals? def previewToggler(self, button): # if button.isEnabled(): if button.hover_state: self.elementConsidered.emit(button.text()) else: self.elementUnconsidered.emit(button.text()) def focus_on_toggler(self, button): """this is for sending same signal as with hovering, but by "Tab" jumping through buttons""" self.elementConsidered.emit(button.text()) def focus_off_toggler(self, button): """this is for sending same signal as with hovering, but by "Tab" jumping through buttons""" self.elementUnconsidered.emit(button.text()) # @QtCore.pyqtSlot(QtCore.QObject) def elementToggler(self, button): if button.isChecked(): self.elementChecked.emit(button.text()) if button.hover_state and button.fancy: button.setGeometry(button.orig_size) else: self.elementUnchecked.emit(button.text()) # @QtCore.pyqtSlot(QtCore.QObject) def emit_right_clicked(self, button): self.elementRightClicked.emit(button.text()) def emit_triggered(self, button): self.elementTriggered.emit(button.text()) def switch_button_wo_trigger(self, elements, press=True): """This method is intended to be connected with list model signal; it blocks signal so that there would be no loop of triggering back and forth between button and list model if state of checkbox in list is bined with state of button.""" self.signalMapper2.blockSignals(True) if press: self.toggle_on(elements) else: self.toggle_off(elements) self.signalMapper2.blockSignals(False)
class HoverableButton(QToolButton): """A Customised QToolButton, which emit additional signals when hovered over/off, right clicked or focuse changed with Tabulator ---------------- initialisation arguments: name -- text which will be shown on button partly_disabled = True (default) -- controls behaviour, when set to True, the button when disabled, still emit custom signals and if fancy is enabled, react to mouse over events. disable_fancy = False --if set to True, then does not do the graphic geometric changes when hovered over/off. is_checkable = True (default) -- controls if button stays pushed when clicked, utill depressed by next click. """ hoverChanged = QtCore.pyqtSignal() gainedFocus = QtCore.pyqtSignal() lostFocus = QtCore.pyqtSignal() rightClicked = QtCore.pyqtSignal() def __init__(self, name, partly_disabled=True, disable_fancy=False, is_checkable=True): QAbstractButton.__init__(self) self.partly_disabled = partly_disabled self.fancy = not disable_fancy self.setMouseTracking(1) self.setText(name) if is_checkable: self.setCheckable(True) if not self.fancy: self.setAutoRaise(True) self.hover_state = False self.orig_size = self.geometry() self.installEventFilter(self) def change_mode(self, mode): if mode == "single": self.setCheckable(False) elif mode == "multi": self.setCheckable(True) def focusInEvent(self, event): self.gainedFocus.emit() super().focusInEvent(event) def focusOutEvent(self, event): self.lostFocus.emit() super().focusOutEvent(event) def enterEvent(self, event): # signaling if self.isEnabled() or self.partly_disabled: self.hover_state = True self.hoverChanged.emit() # graphics if self.fancy and (self.isEnabled() or self.partly_disabled): self.orig_size = self.geometry() # some fancy graphic effects (inspired by KDE kalzium): self.setGeometry(self.orig_size.x() - self.orig_size.width() / 5, self.orig_size.y() - self.orig_size.height() / 5, self.orig_size.width() * 1.4, self.orig_size.height() * 1.4) self.raise_() def leaveEvent(self, event): if self.isEnabled() or self.partly_disabled: self.hover_state = False self.hoverChanged.emit() if self.fancy and (self.isEnabled() or self.partly_disabled): self.setGeometry(self.orig_size) def eventFilter(self, QObject, event): if event.type() == QtCore.QEvent.MouseButtonPress: if event.button() == QtCore.Qt.RightButton: self.rightClicked.emit() return False
def createMapTips(self): """ Create MapTips on the map """ self.timer_map_tips = QtCore.QTimer(self.canvas) self.map_tip = QgsMapTip() self.canvas.xyCoordinates.connect(self.mapTipXYChanged) self.timer_map_tips.timeout.connect(self.showMapTip)
import requests import site from qgis.PyQt import QtCore from qgis.core import QgsMessageLog from qgis.utils import iface # Ensure that the ext-libs for the plugin are near the front of the path # (important on Linux) dirpath = os.path.abspath(os.path.join(os.path.dirname(__file__), 'ext-libs')) sys.path, remainder = sys.path[:1], sys.path[1:] site.addsitedir(dirpath) sys.path.extend(remainder) debug = QtCore.QSettings().value('LDMP/debug', True) def log(message, level=0): if debug: QgsMessageLog.logMessage(message, tag="trends.earth", level=level) # noinspection PyPep8Naming def classFactory(iface): # pylint: disable=invalid-name """Load LDMPPlugin class from file LDMP. :param iface: A QGIS interface instance. :type iface: QgsInterface
def _test_operations(self, md, conn): """Common tests""" capabilities = conn.capabilities() # Schema operations if (capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema and capabilities & QgsAbstractDatabaseProviderConnection.Schemas and capabilities & QgsAbstractDatabaseProviderConnection.DropSchema): # Start clean if 'myNewSchema' in conn.schemas(): conn.dropSchema('myNewSchema', True) # Create conn.createSchema('myNewSchema') schemas = conn.schemas() self.assertTrue('myNewSchema' in schemas) # Create again with self.assertRaises(QgsProviderConnectionException) as ex: conn.createSchema('myNewSchema') # Test rename if capabilities & QgsAbstractDatabaseProviderConnection.RenameSchema: # Rename conn.renameSchema('myNewSchema', 'myVeryNewSchema') schemas = conn.schemas() self.assertTrue('myVeryNewSchema' in schemas) self.assertFalse('myNewSchema' in schemas) conn.renameSchema('myVeryNewSchema', 'myNewSchema') schemas = conn.schemas() self.assertFalse('myVeryNewSchema' in schemas) self.assertTrue('myNewSchema' in schemas) # Drop conn.dropSchema('myNewSchema') schemas = conn.schemas() self.assertFalse('myNewSchema' in schemas) # UTF8 schema conn.createSchema('myUtf8\U0001f604NewSchema') schemas = conn.schemas() conn.dropSchema('myUtf8\U0001f604NewSchema') schemas = conn.schemas() self.assertFalse('myUtf8\U0001f604NewSchema' in schemas) # Table operations if (capabilities & QgsAbstractDatabaseProviderConnection.CreateVectorTable and capabilities & QgsAbstractDatabaseProviderConnection.Tables and capabilities & QgsAbstractDatabaseProviderConnection.DropVectorTable): if capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema: schema = 'myNewSchema' conn.createSchema('myNewSchema') else: schema = 'public' # Start clean if 'myNewTable' in self._table_names(conn.tables(schema)): conn.dropVectorTable(schema, 'myNewTable') fields = QgsFields() fields.append(QgsField("string_t", QVariant.String)) fields.append(QgsField("long_t", QVariant.LongLong)) fields.append(QgsField("double_t", QVariant.Double)) fields.append(QgsField("integer_t", QVariant.Int)) fields.append(QgsField("date_t", QVariant.Date)) fields.append(QgsField("datetime_t", QVariant.DateTime)) fields.append(QgsField("time_t", QVariant.Time)) options = {} crs = QgsCoordinateReferenceSystem.fromEpsgId(3857) typ = QgsWkbTypes.LineString # Create conn.createVectorTable(schema, 'myNewTable', fields, typ, crs, True, options) table_names = self._table_names(conn.tables(schema)) self.assertTrue('myNewTable' in table_names) # Create UTF8 table conn.createVectorTable(schema, 'myUtf8\U0001f604Table', fields, typ, crs, True, options) table_names = self._table_names(conn.tables(schema)) self.assertTrue('myNewTable' in table_names) self.assertTrue('myUtf8\U0001f604Table' in table_names) conn.dropVectorTable(schema, 'myUtf8\U0001f604Table') table_names = self._table_names(conn.tables(schema)) self.assertFalse('myUtf8\U0001f604Table' in table_names) self.assertTrue('myNewTable' in table_names) # insert something, because otherwise MSSQL cannot guess if self.providerKey in ['hana', 'mssql']: f = QgsFeature(fields) f.setGeometry( QgsGeometry.fromWkt('LineString (-72.345 71.987, -80 80)')) vl = QgsVectorLayer(conn.tableUri('myNewSchema', 'myNewTable'), 'vl', self.providerKey) vl.dataProvider().addFeatures([f]) # Check table information table_properties = conn.tables(schema) table_property = self._table_by_name(table_properties, 'myNewTable') self.assertEqual(table_property.maxCoordinateDimensions(), 2) self.assertIsNotNone(table_property) self.assertEqual(table_property.tableName(), 'myNewTable') self.assertEqual(table_property.geometryColumnCount(), 1) self.assertEqual(table_property.geometryColumnTypes()[0].wkbType, QgsWkbTypes.LineString) cols = table_property.geometryColumnTypes() self.assertEqual(cols[0].crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(table_property.defaultName(), 'myNewTable') # Check aspatial tables conn.createVectorTable(schema, 'myNewAspatialTable', fields, QgsWkbTypes.NoGeometry, crs, True, options) table_properties = conn.tables( schema, QgsAbstractDatabaseProviderConnection.Aspatial) table_property = self._table_by_name(table_properties, 'myNewAspatialTable') self.assertIsNotNone(table_property) self.assertEqual(table_property.maxCoordinateDimensions(), 0) self.assertEqual(table_property.tableName(), 'myNewAspatialTable') self.assertEqual(table_property.geometryColumnCount(), 0) self.assertEqual(table_property.geometryColumn(), '') self.assertEqual(table_property.defaultName(), 'myNewAspatialTable') cols = table_property.geometryColumnTypes() # We always return geom col types, even when there is no geometry self.assertEqual(cols[0].wkbType, QgsWkbTypes.NoGeometry) self.assertFalse(cols[0].crs.isValid()) self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Raster) self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Vector) self.assertTrue(table_property.flags() & QgsAbstractDatabaseProviderConnection.Aspatial) # Check executeSql has_schema = capabilities & QgsAbstractDatabaseProviderConnection.Schemas if capabilities & QgsAbstractDatabaseProviderConnection.ExecuteSql: if has_schema: table = "\"%s\".\"myNewAspatialTable\"" % schema else: table = 'myNewAspatialTable' # MSSQL literal syntax for UTF8 requires 'N' prefix sql = "INSERT INTO %s (\"string_t\", \"long_t\", \"double_t\", \"integer_t\", \"date_t\", \"datetime_t\", \"time_t\") VALUES (%s'QGIS Rocks - \U0001f604', 666, 1.234, 1234, '2019-07-08', '2019-07-08T12:00:12', '12:00:13.00')" % ( table, 'N' if self.providerKey == 'mssql' else '') res = conn.executeSql(sql) self.assertEqual(res, []) sql = "SELECT \"string_t\", \"long_t\", \"double_t\", \"integer_t\", \"date_t\", \"datetime_t\" FROM %s" % table res = conn.executeSql(sql) # GPKG and spatialite have no type for time self.assertEqual(res, [[ 'QGIS Rocks - \U0001f604', 666, 1.234, 1234, QtCore.QDate(2019, 7, 8) if not self.treat_date_as_string() else '2019-07-08', QtCore.QDateTime(2019, 7, 8, 12, 0, 12) ]]) # Test column names res = conn.execSql(sql) rows = res.rows() self.assertEqual(rows, [[ 'QGIS Rocks - \U0001f604', 666, 1.234, 1234, QtCore.QDate(2019, 7, 8) if not self.treat_date_as_string() else '2019-07-08', QtCore.QDateTime(2019, 7, 8, 12, 0, 12) ]]) self.assertEqual(res.columns(), [ 'string_t', 'long_t', 'double_t', 'integer_t', 'date_t', 'datetime_t' ]) # Test iterator old_rows = rows res = conn.execSql(sql) rows = [] self.assertTrue(res.hasNextRow()) for row in res: rows.append(row) self.assertEqual(rows, old_rows) # Java style res = conn.execSql(sql) rows = [] self.assertTrue(res.hasNextRow()) while res.hasNextRow(): rows.append(res.nextRow()) self.assertFalse(res.hasNextRow()) # Test time_t sql = "SELECT \"time_t\" FROM %s" % table res = conn.executeSql(sql) # This does not work in MSSQL and returns a QByteArray, we have no way to know that it is a time # value and there is no way we can convert it. if self.providerKey != 'mssql': self.assertIn( res, ([[QtCore.QTime(12, 0, 13)]], [['12:00:13.00']])) sql = "DELETE FROM %s WHERE \"string_t\" = %s'QGIS Rocks - \U0001f604'" % ( table, 'N' if self.providerKey == 'mssql' else '') res = conn.executeSql(sql) self.assertEqual(res, []) sql = "SELECT \"string_t\", \"integer_t\" FROM %s" % table res = conn.executeSql(sql) self.assertEqual(res, []) # Check that we do NOT get the aspatial table when querying for vectors table_names = self._table_names( conn.tables(schema, QgsAbstractDatabaseProviderConnection.Vector)) self.assertTrue('myNewTable' in table_names) self.assertFalse('myNewAspatialTable' in table_names) # Query for rasters (in qgis_test schema or no schema for GPKG, spatialite has no support) if self.providerKey not in ('spatialite', 'mssql', 'hana'): table_properties = conn.tables( 'qgis_test', QgsAbstractDatabaseProviderConnection.Raster) # At least one raster should be there (except for spatialite) self.assertTrue(len(table_properties) >= 1) table_property = table_properties[0] self.assertTrue(table_property.flags() & QgsAbstractDatabaseProviderConnection.Raster) self.assertFalse( table_property.flags() & QgsAbstractDatabaseProviderConnection.Vector) self.assertFalse( table_property.flags() & QgsAbstractDatabaseProviderConnection.Aspatial) if capabilities & QgsAbstractDatabaseProviderConnection.RenameVectorTable: # Rename conn.renameVectorTable(schema, 'myNewTable', 'myVeryNewTable') tables = self._table_names(conn.tables(schema)) self.assertFalse('myNewTable' in tables) self.assertTrue('myVeryNewTable' in tables) # Rename it back conn.renameVectorTable(schema, 'myVeryNewTable', 'myNewTable') tables = self._table_names(conn.tables(schema)) self.assertTrue('myNewTable' in tables) self.assertFalse('myVeryNewTable' in tables) # Vacuum if capabilities & QgsAbstractDatabaseProviderConnection.Vacuum: conn.vacuum('myNewSchema', 'myNewTable') # Spatial index spatial_index_exists = False # we don't initially know if a spatial index exists -- some formats may create them by default, others not if capabilities & QgsAbstractDatabaseProviderConnection.SpatialIndexExists: spatial_index_exists = conn.spatialIndexExists( 'myNewSchema', 'myNewTable', 'geom') if capabilities & QgsAbstractDatabaseProviderConnection.DeleteSpatialIndex: if spatial_index_exists: conn.deleteSpatialIndex('myNewSchema', 'myNewTable', 'geom') if capabilities & QgsAbstractDatabaseProviderConnection.SpatialIndexExists: self.assertFalse( conn.spatialIndexExists('myNewSchema', 'myNewTable', 'geom')) if capabilities & ( QgsAbstractDatabaseProviderConnection.CreateSpatialIndex | QgsAbstractDatabaseProviderConnection.SpatialIndexExists): options = QgsAbstractDatabaseProviderConnection.SpatialIndexOptions( ) options.geometryColumnName = 'geom' if not conn.spatialIndexExists('myNewSchema', 'myNewTable', options.geometryColumnName): conn.createSpatialIndex('myNewSchema', 'myNewTable', options) self.assertTrue( conn.spatialIndexExists('myNewSchema', 'myNewTable', 'geom')) # now we know for certain a spatial index exists, let's retry dropping it if capabilities & QgsAbstractDatabaseProviderConnection.DeleteSpatialIndex: conn.deleteSpatialIndex('myNewSchema', 'myNewTable', 'geom') if capabilities & QgsAbstractDatabaseProviderConnection.SpatialIndexExists: self.assertFalse( conn.spatialIndexExists('myNewSchema', 'myNewTable', 'geom')) if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema: # Drop schema (should fail) with self.assertRaises(QgsProviderConnectionException) as ex: conn.dropSchema('myNewSchema') # Check some column types operations table = self._table_by_name(conn.tables(schema), 'myNewTable') self.assertEqual(len(table.geometryColumnTypes()), 1) ct = table.geometryColumnTypes()[0] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) # Add a new (existing type) table.addGeometryColumnType( QgsWkbTypes.LineString, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(len(table.geometryColumnTypes()), 1) ct = table.geometryColumnTypes()[0] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) # Add a new one table.addGeometryColumnType( QgsWkbTypes.LineString, QgsCoordinateReferenceSystem.fromEpsgId(4326)) self.assertEqual(len(table.geometryColumnTypes()), 2) ct = table.geometryColumnTypes()[0] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) ct = table.geometryColumnTypes()[1] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(4326)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) # Check fields fields = conn.fields('myNewSchema', 'myNewTable') for f in [ 'string_t', 'long_t', 'double_t', 'integer_t', 'date_t', 'datetime_t', 'time_t' ]: self.assertTrue(f in fields.names()) if capabilities & QgsAbstractDatabaseProviderConnection.AddField: field = QgsField('short_lived_field', QVariant.Int, 'integer') conn.addField(field, 'myNewSchema', 'myNewTable') fields = conn.fields('myNewSchema', 'myNewTable') self.assertTrue('short_lived_field' in fields.names()) if capabilities & QgsAbstractDatabaseProviderConnection.DeleteField: conn.deleteField('short_lived_field', 'myNewSchema', 'myNewTable') # This fails on Travis for spatialite, for no particular reason if self.providerKey == 'spatialite' and not os.environ.get( 'TRAVIS', False): fields = conn.fields('myNewSchema', 'myNewTable') self.assertFalse('short_lived_field' in fields.names()) # Drop table conn.dropVectorTable(schema, 'myNewTable') conn.dropVectorTable(schema, 'myNewAspatialTable') table_names = self._table_names(conn.tables(schema)) self.assertFalse('myNewTable' in table_names) if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema: # Drop schema conn.dropSchema('myNewSchema') self.assertFalse('myNewSchema' in conn.schemas()) conns = md.connections() self.assertTrue( isinstance( list(conns.values())[0], QgsAbstractDatabaseProviderConnection)) # Remove connection spy_deleted = QSignalSpy(md.connectionDeleted) md.deleteConnection('qgis_test1') self.assertEqual(list(md.connections().values()), []) self.assertEqual(len(spy_deleted), 1)
def _test_operations(self, md, conn): """Common tests""" capabilities = conn.capabilities() # Schema operations if (capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema and capabilities & QgsAbstractDatabaseProviderConnection.Schemas and capabilities & QgsAbstractDatabaseProviderConnection.RenameSchema and capabilities & QgsAbstractDatabaseProviderConnection.DropSchema): if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema and 'myNewSchema' in conn.schemas(): conn.dropSchema('myNewSchema', True) # Create conn.createSchema('myNewSchema') schemas = conn.schemas() self.assertTrue('myNewSchema' in schemas) # Create again with self.assertRaises(QgsProviderConnectionException) as ex: conn.createSchema('myNewSchema') # Rename conn.renameSchema('myNewSchema', 'myVeryNewSchema') schemas = conn.schemas() self.assertTrue('myVeryNewSchema' in schemas) self.assertFalse('myNewSchema' in schemas) # Drop conn.dropSchema('myVeryNewSchema') schemas = conn.schemas() self.assertFalse('myVeryNewSchema' in schemas) # Table operations if (capabilities & QgsAbstractDatabaseProviderConnection.CreateVectorTable and capabilities & QgsAbstractDatabaseProviderConnection.Tables and capabilities & QgsAbstractDatabaseProviderConnection.RenameVectorTable and capabilities & QgsAbstractDatabaseProviderConnection.DropVectorTable): if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema and 'myNewSchema' in conn.schemas(): conn.dropSchema('myNewSchema', True) if capabilities & QgsAbstractDatabaseProviderConnection.CreateSchema: schema = 'myNewSchema' conn.createSchema('myNewSchema') else: schema = 'public' if 'myNewTable' in self._table_names(conn.tables(schema)): conn.dropVectorTable(schema, 'myNewTable') fields = QgsFields() fields.append(QgsField("string", QVariant.String)) fields.append(QgsField("long", QVariant.LongLong)) fields.append(QgsField("double", QVariant.Double)) fields.append(QgsField("integer", QVariant.Int)) fields.append(QgsField("date", QVariant.Date)) fields.append(QgsField("datetime", QVariant.DateTime)) fields.append(QgsField("time", QVariant.Time)) options = {} crs = QgsCoordinateReferenceSystem.fromEpsgId(3857) typ = QgsWkbTypes.LineString # Create conn.createVectorTable(schema, 'myNewTable', fields, typ, crs, True, options) table_names = self._table_names(conn.tables(schema)) self.assertTrue('myNewTable' in table_names) # Check table information table_properties = conn.tables(schema) table_property = self._table_by_name(table_properties, 'myNewTable') self.assertEqual(table_property.maxCoordinateDimensions(), 2) self.assertIsNotNone(table_property) self.assertEqual(table_property.tableName(), 'myNewTable') self.assertEqual(table_property.geometryColumnCount(), 1) self.assertEqual(table_property.geometryColumnTypes()[0].wkbType, QgsWkbTypes.LineString) cols = table_property.geometryColumnTypes() self.assertEqual(cols[0].crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(table_property.defaultName(), 'myNewTable') # Check aspatial tables conn.createVectorTable(schema, 'myNewAspatialTable', fields, QgsWkbTypes.NoGeometry, crs, True, options) table_properties = conn.tables(schema, QgsAbstractDatabaseProviderConnection.Aspatial) table_property = self._table_by_name(table_properties, 'myNewAspatialTable') self.assertIsNotNone(table_property) self.assertEqual(table_property.maxCoordinateDimensions(), 0) self.assertEqual(table_property.tableName(), 'myNewAspatialTable') self.assertEqual(table_property.geometryColumnCount(), 0) self.assertEqual(table_property.geometryColumn(), '') self.assertEqual(table_property.defaultName(), 'myNewAspatialTable') cols = table_property.geometryColumnTypes() self.assertEqual(cols[0].wkbType, QgsWkbTypes.NoGeometry) self.assertFalse(cols[0].crs.isValid()) self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Raster) self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Vector) self.assertTrue(table_property.flags() & QgsAbstractDatabaseProviderConnection.Aspatial) # Check executeSql has_schema = capabilities & QgsAbstractDatabaseProviderConnection.Schemas if capabilities & QgsAbstractDatabaseProviderConnection.ExecuteSql: if has_schema: table = "\"%s\".\"myNewAspatialTable\"" % schema else: table = 'myNewAspatialTable' sql = "INSERT INTO %s (string, long, double, integer, date, datetime, time) VALUES ('QGIS Rocks - \U0001f604', 666, 1.234, 1234, '2019-07-08', '2019-07-08T12:00:12', '12:00:13.00')" % table res = conn.executeSql(sql) self.assertEqual(res, []) sql = "SELECT string, long, double, integer, date, datetime FROM %s" % table res = conn.executeSql(sql) # GPKG has no type for time and spatialite has no support for dates and time ... if self.providerKey == 'spatialite': self.assertEqual(res, [['QGIS Rocks - \U0001f604', 666, 1.234, 1234, '2019-07-08', '2019-07-08T12:00:12']]) else: self.assertEqual(res, [['QGIS Rocks - \U0001f604', 666, 1.234, 1234, QtCore.QDate(2019, 7, 8), QtCore.QDateTime(2019, 7, 8, 12, 0, 12)]]) sql = "SELECT time FROM %s" % table res = conn.executeSql(sql) self.assertIn(res, ([[QtCore.QTime(12, 0, 13)]], [['12:00:13.00']])) sql = "DELETE FROM %s WHERE string = 'QGIS Rocks - \U0001f604'" % table res = conn.executeSql(sql) self.assertEqual(res, []) sql = "SELECT string, integer FROM %s" % table res = conn.executeSql(sql) self.assertEqual(res, []) # Check that we do NOT get the aspatial table when querying for vectors table_names = self._table_names(conn.tables(schema, QgsAbstractDatabaseProviderConnection.Vector)) self.assertTrue('myNewTable' in table_names) self.assertFalse('myNewAspatialTable' in table_names) # Query for rasters (in qgis_test schema or no schema for GPKG, spatialite has no support) if self.providerKey != 'spatialite': table_properties = conn.tables('qgis_test', QgsAbstractDatabaseProviderConnection.Raster) # At least one raster should be there (except for spatialite) self.assertTrue(len(table_properties) >= 1) table_property = table_properties[0] self.assertTrue(table_property.flags() & QgsAbstractDatabaseProviderConnection.Raster) self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Vector) self.assertFalse(table_property.flags() & QgsAbstractDatabaseProviderConnection.Aspatial) # Rename conn.renameVectorTable(schema, 'myNewTable', 'myVeryNewTable') tables = self._table_names(conn.tables(schema)) self.assertFalse('myNewTable' in tables) self.assertTrue('myVeryNewTable' in tables) # Vacuum if capabilities & QgsAbstractDatabaseProviderConnection.Vacuum: conn.vacuum('myNewSchema', 'myVeryNewTable') if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema: # Drop schema (should fail) with self.assertRaises(QgsProviderConnectionException) as ex: conn.dropSchema('myNewSchema') # Check some column types operations table = self._table_by_name(conn.tables(schema), 'myVeryNewTable') self.assertEqual(len(table.geometryColumnTypes()), 1) ct = table.geometryColumnTypes()[0] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) # Add a new (existing type) table.addGeometryColumnType(QgsWkbTypes.LineString, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(len(table.geometryColumnTypes()), 1) ct = table.geometryColumnTypes()[0] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) # Add a new one table.addGeometryColumnType(QgsWkbTypes.LineString, QgsCoordinateReferenceSystem.fromEpsgId(4326)) self.assertEqual(len(table.geometryColumnTypes()), 2) ct = table.geometryColumnTypes()[0] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(3857)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) ct = table.geometryColumnTypes()[1] self.assertEqual(ct.crs, QgsCoordinateReferenceSystem.fromEpsgId(4326)) self.assertEqual(ct.wkbType, QgsWkbTypes.LineString) # Drop table conn.dropVectorTable(schema, 'myVeryNewTable') conn.dropVectorTable(schema, 'myNewAspatialTable') table_names = self._table_names(conn.tables(schema)) self.assertFalse('myVeryNewTable' in table_names) if capabilities & QgsAbstractDatabaseProviderConnection.DropSchema: # Drop schema conn.dropSchema('myNewSchema') self.assertFalse('myNewSchema' in conn.schemas()) conns = md.connections() self.assertTrue(isinstance(list(conns.values())[0], QgsAbstractDatabaseProviderConnection)) # Remove connection md.deleteConnection('qgis_test1') self.assertEqual(list(md.connections().values()), [])
def _csmapToFile(self, dem, layer_set, outdir): if dem.rasterUnitsPerPixelX() == dem.rasterUnitsPerPixelY(): dx = dem.rasterUnitsPerPixelX() dy = dem.rasterUnitsPerPixelY() w = dem.dataProvider().xSize() h = dem.dataProvider().ySize() elif dem.rasterUnitsPerPixelX() > dem.rasterUnitsPerPixelY(): dx = dem.rasterUnitsPerPixelY() dy = dem.rasterUnitsPerPixelY() w = int(dem.dataProvider().xSize() * (dem.rasterUnitsPerPixelX() / dem.rasterUnitsPerPixelY())) h = dem.dataProvider().ySize() else: dx = dem.rasterUnitsPerPixelX() dy = dem.rasterUnitsPerPixelX() w = dem.dataProvider().xSize() h = int(dem.dataProvider().ySize() * (dem.rasterUnitsPerPixelY() / dem.rasterUnitsPerPixelX())) img = QtGui.QImage(QtCore.QSize(w, h), QtGui.QImage.Format_ARGB32_Premultiplied) color = QtGui.QColor(255, 255, 255) img.fill(color.rgb()) setting = QgsMapSettings() setting.setExtent(dem.dataProvider().extent()) setting.setDestinationCrs(dem.crs()) setting.setOutputSize(QtCore.QSize(w, h)) setting.setLayers(layer_set) setting.updateDerived() p = QtGui.QPainter() p.begin(img) render = QgsMapRendererCustomPainterJob(setting, p) render.start() render.waitForFinished() p.end() temp = tempfile.NamedTemporaryFile() img.save(temp.name + ".tif", "tif") src_ds = gdal.Open(temp.name + ".tif") driver = gdal.GetDriverByName("GTiff") filepath, filename = os.path.split( str(dem.dataProvider().dataSourceUri())) dst_file = outdir + r"/csmap_" + filename dst_ds = driver.CreateCopy(dst_file, src_ds, 0) geo_trans = [ dem.dataProvider().extent().xMinimum(), dx, 0, dem.dataProvider().extent().yMaximum(), 0, dy * -1 ] dst_ds.SetGeoTransform(geo_trans) dst_ds.SetProjection(str(dem.crs().toWkt())) dst_ds = None src_ds = None temp.close() self.result_files.append(dst_file)
def get_layer_styles_url_endpoint(self, layer_id: int): return QtCore.QUrl(f"{self.api_url}/datasets/{layer_id}/styles/")
def get_qgis_app(requested_locale='en_US', qsetting=''): """ Start one QGIS application to test against. :param locale: The locale we want the qgis to launch with. :type locale: str :param qsetting: String to specify the QSettings. By default, use empty string. :type qsetting: str :returns: Handle to QGIS app, canvas, iface and parent. If there are any errors the tuple members will be returned as None. :rtype: (QgsApplication, CANVAS, IFACE, PARENT) If QGIS is already running the handle to that app will be returned. """ global QGIS_APP, PARENT, IFACE, CANVAS # pylint: disable=W0603 from qgis.PyQt.QtCore import QSettings if qsetting: settings = QSettings(qsetting) else: settings = QSettings() default_user_directory = setting('defaultUserDirectory') current_locale = general_setting('locale/userLocale', default='en_US', qsettings=settings) locale_match = current_locale == requested_locale if iface and locale_match: from qgis.core import QgsApplication QGIS_APP = QgsApplication CANVAS = iface.mapCanvas() PARENT = iface.mainWindow() IFACE = iface try: from qgis.core import QgsApplication from qgis.gui import QgsMapCanvas # pylint: disable=no-name-in-module # noinspection PyPackageRequirements from qgis.PyQt import QtWidgets, QtCore # pylint: disable=W0621 # noinspection PyPackageRequirements from qgis.PyQt.QtCore import QCoreApplication, QSettings from safe.test.qgis_interface import QgisInterface except ImportError: return None, None, None, None if qsetting: settings = QSettings(qsetting) else: settings = QSettings() if not QGIS_APP: gui_flag = True # All test will run qgis in gui mode # AG: For testing purposes, we use our own configuration file # instead of using the QGIS apps conf of the host # noinspection PyCallByClass,PyArgumentList QCoreApplication.setOrganizationName('QGIS') # noinspection PyCallByClass,PyArgumentList QCoreApplication.setOrganizationDomain('qgis.org') # noinspection PyCallByClass,PyArgumentList QCoreApplication.setApplicationName('QGIS2InaSAFETesting') # We disabled message bars for now for extent selector as # we don't have a main window to show them in TS - version 3.2 set_setting('show_extent_warnings', False, settings) set_setting('showRubberBands', True, settings) set_setting('show_extent_confirmations', False, settings) set_setting('analysis_extents_mode', HAZARD_EXPOSURE, settings) if default_user_directory: set_setting('defaultUserDirectory', default_user_directory, settings) # noinspection PyPep8Naming if 'argv' in dir(sys): QGIS_APP = QgsApplication([p.encode('utf-8') for p in sys.argv], gui_flag) else: QGIS_APP = QgsApplication([], gui_flag) # Make sure QGIS_PREFIX_PATH is set in your env if needed! QGIS_APP.initQgis() # Initialize processing processing.Processing.initialize() s = QGIS_APP.showSettings() LOGGER.debug(s) if not locale_match: """Setup internationalisation for the plugin.""" # Save some settings set_general_setting('locale/overrideFlag', True, settings) set_general_setting('locale/userLocale', requested_locale, settings) locale_name = str(requested_locale).split('_')[0] # Also set the system locale to the user overridden local # so that the inasafe library functions gettext will work # .. see:: :py:func:`common.utilities` os.environ['LANG'] = str(locale_name) inasafe_translation_path = os.path.join( safe_dir('i18n'), 'inasafe_' + str(locale_name) + '.qm') if os.path.exists(inasafe_translation_path): if isinstance(QGIS_APP, sip.wrappertype): translator = QTranslator() else: translator = QTranslator(QGIS_APP) result = translator.load(inasafe_translation_path) if not result: message = 'Failed to load translation for %s' % locale_name raise Exception(message) # noinspection PyTypeChecker,PyCallByClass QCoreApplication.installTranslator(translator) # at the end, reload InaSAFE modules so it will get translated too reload_inasafe_modules() if PARENT is None: # noinspection PyPep8Naming PARENT = QtWidgets.QWidget() if CANVAS is None: # noinspection PyPep8Naming CANVAS = QgsMapCanvas(PARENT) CANVAS.resize(QtCore.QSize(400, 400)) if IFACE is None: # QgisInterface is a stub implementation of the QGIS plugin interface # noinspection PyPep8Naming IFACE = QgisInterface(CANVAS) return QGIS_APP, CANVAS, IFACE, PARENT
def path(self): return QtCore.QRegularExpression("/handlerone")
def testOgcApiHandler(self): """Test OGC API Handler""" project = QgsProject() project.read(unitTestDataPath('qgis_server') + '/test_project_api.qgs') request = QgsBufferServerRequest( 'http://server.qgis.org/wfs3/collections/testlayer%20èé/items?limit=-1' ) response = QgsBufferServerResponse() ctx = QgsServerApiContext('/services/api1', request, response, project, self.server.serverInterface()) h = Handler1() self.assertTrue( h.staticPath(ctx).endswith('/resources/server/api/ogc/static')) self.assertEqual(h.path(), QtCore.QRegularExpression("/handlerone")) self.assertEqual(h.description(), 'The first handler ever') self.assertEqual(h.operationId(), 'handlerOne') self.assertEqual(h.summary(), 'First of its name') self.assertEqual(h.linkTitle(), 'Handler One Link Title') self.assertEqual(h.linkType(), QgsServerOgcApi.data) with self.assertRaises(QgsServerApiBadRequestException) as ex: h.handleRequest(ctx) self.assertEqual(str(ex.exception), 'Missing required argument: \'value1\'') r = ctx.response() self.assertEqual(r.data(), '') with self.assertRaises(QgsServerApiBadRequestException) as ex: h.values(ctx) self.assertEqual(str(ex.exception), 'Missing required argument: \'value1\'') # Add handler to API and test for /api2 ctx = QgsServerApiContext('/services/api2', request, response, project, self.server.serverInterface()) api = QgsServerOgcApi(self.server.serverInterface(), '/api2', 'apitwo', 'a second api', '1.2') api.registerHandler(h) # Add a second handler (will be tested later) h2 = Handler2() api.registerHandler(h2) ctx.request().setUrl(QtCore.QUrl('http://www.qgis.org/services/api1')) with self.assertRaises(QgsServerApiBadRequestException) as ex: api.executeRequest(ctx) self.assertEqual( str(ex.exception), 'Requested URI does not match any registered API handler') ctx.request().setUrl(QtCore.QUrl('http://www.qgis.org/services/api2')) with self.assertRaises(QgsServerApiBadRequestException) as ex: api.executeRequest(ctx) self.assertEqual( str(ex.exception), 'Requested URI does not match any registered API handler') ctx.request().setUrl( QtCore.QUrl('http://www.qgis.org/services/api2/handlerone')) with self.assertRaises(QgsServerApiBadRequestException) as ex: api.executeRequest(ctx) self.assertEqual(str(ex.exception), 'Missing required argument: \'value1\'') ctx.request().setUrl( QtCore.QUrl( 'http://www.qgis.org/services/api2/handlerone?value1=not+a+double' )) with self.assertRaises(QgsServerApiBadRequestException) as ex: api.executeRequest(ctx) self.assertEqual( str(ex.exception), 'Argument \'value1\' could not be converted to Double') ctx.request().setUrl( QtCore.QUrl( 'http://www.qgis.org/services/api2/handlerone?value1=1.2345')) params = h.values(ctx) self.assertEqual(params, {'value1': 1.2345}) api.executeRequest(ctx) self.assertEqual( json.loads(bytes(ctx.response().data()))['value1'], 1.2345) # Test path fragments extraction ctx.request().setUrl( QtCore.QUrl( 'http://www.qgis.org/services/api2/handlertwo/00/555?value1=1.2345' )) params = h2.values(ctx) self.assertEqual(params, { 'code1': '00', 'value1': 1.2345, 'value2': None }) # Test string encoding ctx.request().setUrl( QtCore.QUrl( 'http://www.qgis.org/services/api2/handlertwo/00/555?value1=1.2345&value2=a%2Fstring%20some' )) params = h2.values(ctx) self.assertEqual(params, { 'code1': '00', 'value1': 1.2345, 'value2': 'a/string some' }) # Test links self.assertEqual( h2.href(ctx), 'http://www.qgis.org/services/api2/handlertwo/00/555?value1=1.2345&value2=a%2Fstring%20some' ) self.assertEqual( h2.href(ctx, '/extra'), 'http://www.qgis.org/services/api2/handlertwo/00/555/extra?value1=1.2345&value2=a%2Fstring%20some' ) self.assertEqual( h2.href(ctx, '/extra', 'json'), 'http://www.qgis.org/services/api2/handlertwo/00/555/extra.json?value1=1.2345&value2=a%2Fstring%20some' ) # Test template path self.assertTrue( h2.templatePath(ctx).endswith( '/resources/server/api/ogc/templates/services/api2/handlerTwo.html' ))
def path(self): return QtCore.QRegularExpression(r"/handlerthree")
def test_append_path(self): path = QgsServerApiUtils.appendMapParameter( '/wfs3', QtCore.QUrl('https://www.qgis.org/wfs3?MAP=/some/path')) self.assertEquals(path, '/wfs3?MAP=/some/path')
def qInitResources(): QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data)
def qCleanupResources(): QtCore.qUnregisterResourceData(0x01, qt_resource_struct, qt_resource_name, qt_resource_data)
def setMask(self): """ REGEx closely related to the valid chars method 'setValidCharacters' """ if self.scaleCombo.currentText() == '1000k': regex = QtCore.QRegExp('[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}') validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '500k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}') validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '250k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}') validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '100k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}' ) validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '50k': self.inomLineEdit.setInputMask('NN-NN-N-N-Nnn-0') regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}' ) validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '25k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}' ) validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '10k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}' ) validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '5k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}\-[IViv]{1,3}' ) validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '2k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}\-[IViv]{1,3}\-[1-6]{1}' ) validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator) elif self.scaleCombo.currentText() == '1k': regex = QtCore.QRegExp( '[NSns]{1}[A-Za-z]{1}\-[0-9]{1,2}\-[V-Zv-z]{1}\-[A-Da-d]{1}\-[IViv]{1,3}\-[1-4]{1}\-[NSns]{1}[OEoe]{1}\-[A-Fa-f]{1}\-[IViv]{1,3}\-[1-6]{1}\-[A-Da-d]{1}' ) validator = QtGui.QRegExpValidator(regex, self.inomLineEdit) self.inomLineEdit.setValidator(validator)
class Communicate(QtCore.QObject): M = QtCore.pyqtSignal()