def on_reliefClassTree_itemDoubleClicked(self, item, column):
        if not item:
            return

        if column == 0:
            d, ok = QInputDialog.getDouble(None,
                                           self.tr('Enter lower elevation class bound'),
                                           self.tr('Elevation'),
                                           float(item.text(0)),
                                           decimals=2)
            if ok:
                item.setText(0, str(d))
        elif column == 1:
            d, ok = QInputDialog.getDouble(None,
                                           self.tr('Enter upper elevation class bound'),
                                           self.tr('Elevation'),
                                           float(item.text(1)),
                                           decimals=2)
            if ok:
                item.setText(1, str(d))
        elif column == 2:
            c = QColorDialog.getColor(item.background(2).color(),
                                      None,
                                      self.tr('Select color for relief class'))
            if c.isValid():
                item.setBackground(2, QBrush(c))

 def createView(self):
     name, ok = QInputDialog.getText(None, "View name", "View name")
     if ok:
         try:
             self.db.connector.createSpatialView(name, self._getSqlQuery())
         except BaseError as e:
             DlgDbError.showError(e, self)

 def useLayerExtent(self):
     CANVAS_KEY = "Use canvas extent"
     extentsDict = {}
     extentsDict[CANVAS_KEY] = {
         "extent": iface.mapCanvas().extent(),
         "authid": iface.mapCanvas().mapSettings().destinationCrs().authid(),
     }
     extents = [CANVAS_KEY]
     layers = dataobjects.getAllLayers()
     for layer in layers:
         authid = layer.crs().authid()
         if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) and authid is not None:
             layerName = u"{} [{}]".format(layer.name(), authid)
         else:
             layerName = layer.name()
         extents.append(layerName)
         extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
     (item, ok) = QInputDialog.getItem(self, self.tr("Select extent"), self.tr("Use extent from"), extents, False)
     if ok:
         self.setValueFromRect(extentsDict[item]["extent"])
         if extentsDict[item]["authid"] != iface.mapCanvas().mapSettings().destinationCrs().authid():
             iface.messageBar().pushMessage(
                 self.tr("Warning"),
                 self.tr(
                     "The projection of the chosen layer is not the same as canvas projection! The selected extent might not be what was intended."
                 ),
                 QgsMessageBar.WARNING,
                 8,
             )

    def connect(self, selected, parent=None):
        settings = QSettings()
        settings.beginGroup(u"/%s/connections/%s" % (self.getSettingsKey(), selected))

        if not settings.contains("database"):  # non-existent entry?
            raise DbError('there is no defined database connection "%s".' % selected)

        get_value_str = lambda x: str(settings.value(x) if Utils.isSIPv2() else settings.value(x).toString())
        service, host, port, database, username, password = list(map(get_value_str, ["service", "host", "port", "database", "username", "password"]))

        # qgis1.5 use 'savePassword' instead of 'save' setting
        isSave = settings.value("save") if Utils.isSIPv2() else settings.value("save").toBool()
        isSavePassword = settings.value("savePassword") if Utils.isSIPv2() else settings.value("savePassword").toBool()
        if not (isSave or isSavePassword):
            (password, ok) = QInputDialog.getText(parent, "Enter password", 'Enter password for connection "%s":' % selected, QLineEdit.Password)
            if not ok: return

        settings.endGroup()

        uri = QgsDataSourceUri()
        if service:
            uri.setConnection(service, database, username, password)
        else:
            uri.setConnection(host, port, database, username, password)

        return Connection(uri)

    def saveToGeopackage(self):
        file_filter = self.tr('GeoPackage files (*.gpkg);;All files (*.*)', 'OutputFile')

        settings = QgsSettings()
        if settings.contains('/Processing/LastOutputPath'):
            path = settings.value('/Processing/LastOutputPath')
        else:
            path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)

        filename, filter = QFileDialog.getSaveFileName(self, self.tr("Save to GeoPackage"), path,
                                                       file_filter, options=QFileDialog.DontConfirmOverwrite)

        if not filename:
            return

        layer_name, ok = QInputDialog.getText(self, self.tr('Save to GeoPackage'), self.tr('Layer name'), text=self.parameter.name().lower())
        if ok:
            self.use_temporary = False
            if not filename.lower().endswith('.gpkg'):
                filename += '.gpkg'
            settings.setValue('/Processing/LastOutputPath',
                              os.path.dirname(filename))

            uri = QgsDataSourceUri()
            uri.setDatabase(filename)
            uri.setDataSource('', layer_name,
                              'geom' if isinstance(self.parameter, QgsProcessingParameterFeatureSink) and self.parameter.hasGeometry() else None)
            self.leText.setText("ogr:" + uri.uri())

            self.skipOutputChanged.emit(False)
            self.destinationChanged.emit()

 def showThunderforestApiKeyDialog(self):
     apiKey = QSettings().value("Plugin-OpenLayers/thunderforestApiKey")
     newApiKey, ok = QInputDialog.getText(
         self.iface.mainWindow(), "API key",
         "Enter your API key (<a href=\"https://thunderforest.com/pricing/\">https://thunderforest.com</a>)", QLineEdit.Normal, apiKey)
     if ok:
         QSettings().setValue("Plugin-OpenLayers/thunderforestApiKey",
                              newApiKey)

 def showGoogleMapsApiKeyDialog(self):
     apiKey = QSettings().value("Plugin-OpenLayers/googleMapsApiKey")
     newApiKey, ok = QInputDialog.getText(
         self.iface.mainWindow(), "API key",
         "Enter your Google Maps API key", QLineEdit.Normal, apiKey)
     if ok:
         QSettings().setValue("Plugin-OpenLayers/googleMapsApiKey",
                              newApiKey)

 def ask_for_CRS(self, set_locale):
     # USER MUST SELECT CRS FIRST!!
     if set_locale == 'sv_SE':
         default_crs = 3006
     else:
         default_crs = 4326
     EPSGID = QInputDialog.getInt(None, "Select CRS", "Give EPSG-ID (integer) corresponding to\nthe CRS you want to use in the database:",default_crs)
     return EPSGID

 def layernameValid(self):   
     if not hasattr(self, 'layerName'):
       layerName, accept = QInputDialog.getText(None,
           QCoreApplication.translate("geopunt4Qgis", 'Laag toevoegen'),
           QCoreApplication.translate("geopunt4Qgis", 'Geef een naam voor de laag op:') )
       if accept == False: 
          return False
       else: 
          self.layerName = layerName
     return True

 def saveLineClicked(self):
     if not hasattr(self, 'profileLineLayerTxt'):
        layerName, accept = QInputDialog.getText(None,
           QCoreApplication.translate("geopunt4Qgis", 'Laag toevoegen'),
           QCoreApplication.translate("geopunt4Qgis", 'Geef een naam voor de laag op:') )
        if accept == False: 
           return
        else:  
           self.profileLineLayerTxt = layerName
        
     if self.profile != None and self.Rubberline != None:
        title = self.ax.get_title()
        self.eh.save_profile( self.Rubberline.asGeometry(), self.profile, title,
                           self.profileLineLayerTxt, self.profileLineSavetoFile, sender=self )

 def savePntClicked(self):
     if not hasattr(self, 'sampleLayerTxt'):
        layerName, accept = QInputDialog.getText(None,
           QCoreApplication.translate("geopunt4Qgis", 'Laag toevoegen'),
           QCoreApplication.translate("geopunt4Qgis", 'Geef een naam voor de laag op:') )
        if accept == False: 
           return
        else:  
           self.sampleLayerTxt = layerName
   
     if self.profile != None:
        title = self.ax.get_title()
        self.eh.save_sample_points( self.profile, title, 
                                self.sampleLayerTxt, self.samplesSavetoFile, sender=self )

 def useLayerExtent(self):
     CANVAS_KEY = 'Use canvas extent'
     extentsDict = {}
     extentsDict[CANVAS_KEY] = {"extent": iface.mapCanvas().extent(),
                                "authid": iface.mapCanvas().mapSettings().destinationCrs().authid()}
     extents = [CANVAS_KEY]
     for layer in QgsProject.instance().mapLayers().values():
         authid = layer.crs().authid()
         layerName = layer.name()
         extents.append(layerName)
         extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
     (item, ok) = QInputDialog.getItem(self, self.tr('Select extent'),
                                       self.tr('Use extent from'), extents, False)
     if ok:
         self.setValue(extentsDict[item]["extent"], extentsDict[item]['authid'])

    def createSchemaActionSlot(self, item, action, parent):
        QApplication.restoreOverrideCursor()
        try:
            if not isinstance(item, (DBPlugin, Schema, Table)) or item.database() is None:
                parent.infoBar.pushMessage(
                    QApplication.translate("DBManagerPlugin", "No database selected or you are not connected to it."),
                    QgsMessageBar.INFO, parent.iface.messageTimeout())
                return
            (schema, ok) = QInputDialog.getText(parent, QApplication.translate("DBManagerPlugin", "New schema"),
                                                QApplication.translate("DBManagerPlugin", "Enter new schema name"))
            if not ok:
                return
        finally:
            QApplication.setOverrideCursor(Qt.WaitCursor)

        self.createSchema(schema)

 def _addReverse(self, adres):
     formattedAddress, locationType = adres["FormattedAddress"] , adres["LocationType"]
     xlam72, ylam72 = adres["Location"]["X_Lambert72"] , adres["Location"]["Y_Lambert72"]
 
     if not hasattr(self, 'layerName_reverse'):
        layerName, accept = QInputDialog.getText(None,
          QCoreApplication.translate("geopunt4Qgis", 'Laag toevoegen'),
          QCoreApplication.translate("geopunt4Qgis", 'Geef een naam voor de laag op:'))
        if accept == False: return
        else:  self.layerName_reverse = layerName
        
     xy = self.gh.prjPtToMapCrs([xlam72, ylam72], 31370)
     self.gh.save_adres_point(xy, formattedAddress, locationType, layername=self.layerName_reverse, 
       startFolder=os.path.join( self.startDir, self.layerName_reverse), saveToFile=self.saveToFile_reverse ,
       sender=self.iface.mainWindow())
     self.iface.messageBar().popWidget()	
     self._clearGraphicLayer()

 def useLayerExtent(self):
     extentsDict = {}
     extents = []
     layers = QgsProcessingUtils.compatibleLayers(QgsProject.instance())
     for layer in layers:
         authid = layer.crs().authid()
         if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF) \
                 and authid is not None:
             layerName = u'{} [{}]'.format(layer.name(), authid)
         else:
             layerName = layer.name()
         extents.append(layerName)
         extentsDict[layerName] = {"extent": layer.extent(), "authid": authid}
     (item, ok) = QInputDialog.getItem(self, self.tr('Select Extent'),
                                       self.tr('Use extent from'), extents, 0, False)
     if ok:
         self.setValueFromRect(QgsReferencedRectangle(extentsDict[item]["extent"], QgsCoordinateReferenceSystem(extentsDict[item]["authid"])))

	def _askTStablename(self, ps_layer, default_tblname=None):
		# utility function used to ask to the user the name of the table
		# containing time series data
		if default_tblname is None:
			default_tblname = ""

		# ask a tablename to the user
		if ps_layer.id() != self.last_ps_layerid or not self.ts_tablename:
			tblname, ok = QInputDialog.getText( self.iface.mainWindow(),
					"PS Time Series Viewer",
					"Insert the name of the table containing time-series",
					text=default_tblname )
			if not ok:
				return False

			self.ts_tablename = tblname
			self.last_ps_layerid = ps_layer.id()

		return True

 def canvasReleaseEvent(self, e):
     '''La sélection est faîte'''
     if not e.button() == Qt.LeftButton:
         return None
     self.status = 0
     if self.rb.numberOfVertices() > 3:
         self.selectionDone.emit()
     else:
         radius, ok = QInputDialog.getDouble(
             self.iface.mainWindow(), tr('Radius'),
             tr('Give a radius in m:'), min=0)
         if radius > 0 and ok:
             cp = self.toMapCoordinates(e.pos())
             cp.setX(cp.x() + radius)
             rbcircle(self.rb, self.toMapCoordinates(
                 e.pos()), cp, self.segments)
             self.rb.show()
             self.selectionDone.emit()
     return None

 def createRepo(self):
     name, ok = QInputDialog.getText(self, 'Create repository',
                                           'Enter the repository name:')
     if ok:
         group = self.comboEndpoint.currentText()
         url = repository.repoEndpoints[group]
         try:
             repo = execute(lambda: createRepoAtUrl(url, group, name))
         except GeoGigException as e:
             config.iface.messageBar().pushMessage("Error", str(e),
                            level=QgsMessageBar.CRITICAL,
                            duration=5)
             return
         item = RepoItem(self, self.repoTree, repo)
         addRepo(repo)
         self.repoTree.addTopLevelItem(item)
         config.iface.messageBar().pushMessage("Create repository", "Repository correctly created",
                                        level=QgsMessageBar.INFO,
                                        duration=5)

 def setDelim(self, idx):
     txt = self.ui.delimSelect.itemText(idx)
     accept = True
     if txt == 'Puntcomma':
         self.delimiter = ';'
         self.loadTable()
     elif txt == 'Comma':
         self.delimiter = ','
         self.loadTable()
     elif txt ==  'Tab':
         self.delimiter = '\t'
         self.loadTable()
     else:
         delimiter, accept = QInputDialog.getText(self, 
             QCoreApplication.translate("batcGeoCodedialog","Andere separator") , 
             QCoreApplication.translate("batcGeoCodedialog","Stel zelf een separator in: (Maximaal 1 karakter)"))
         if accept:
             self.delimiter = str( delimiter.strip()[0])
             self.ui.delimEdit.setText(self.delimiter)
             self.loadTable()

 def editLayerName(self, index):
     item = index.data(role=Qt.UserRole)
     name, status = QInputDialog.getText(self, self.tr('Change name'),
         self.tr('Enter new layer name for %s') % item.name,
         text = item.name)
     if status and name != item.name:
         result = self.editLayerMetadata(item, {'name':name})
         if result['layer']['name'] == name:
             self.iface.messageBar().pushMessage('DIVI',
                 self.tr('Name of layer %s was changed to %s.') % (item.name, name),
                 duration = 3
             )
             item.name = name
             index.model().dataChanged.emit(index, index)
         else:
             self.iface.messageBar().pushMessage('DIVI',
                 self.tr('Error occured while changing name.'),
                 Qgis.Critical,
                 duration = 3
             )