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 addWFS(self):
if self.wfs == None: return
try:
lyrs = getWFSLayerNames(self.wfs, self.proxy)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
if len(lyrs) == 0:
self.bar.pushMessage("WFS",
QCoreApplication.translate("geopunt4QgisDataCatalog",
"Kan geen lagen vinden in: %s" % self.wfs), level=Qgis.Warning, duration=10)
return
elif len(lyrs) == 1:
layerTitle = lyrs[0][1]
else:
layerTitle, accept = QInputDialog.getItem(self, "WFS toevoegen",
"Kies een laag om toe te voegen", [n[1] for n in lyrs],
editable=0)
if not accept: return
layerName = [n[0] for n in lyrs if n[1] == layerTitle][0]
crs = [n[2] for n in lyrs if n[1] == layerTitle][0]
url = self.wfs.split('?')[0]
wfsUri = makeWFSuri(url, layerName, crs )
try:
vlayer = QgsVectorLayer(wfsUri, layerTitle, "WFS")
QgsProject.instance().addMapLayer(vlayer)
except:
self.bar.pushMessage("Error", str(sys.exc_info()[1]), level=Qgis.Critical, duration=10)
return
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 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 exportLayer(self):
if self.tabWidget.count() != 0:
index = self.tabWidget.currentIndex()
table = self.tabWidget.widget(index).findChildren(QTableWidget)[0]
items = table.selectedItems()
if len(items) > 0:
type = ''
if items[0].feature.geometry().type() == QgsWkbTypes.PointGeometry:
type = 'Point'
elif items[0].feature.geometry().type() == QgsWkbTypes.LineGeometry:
type = 'LineString'
else:
type = 'Polygon'
features = []
for item in items:
if item.feature not in features:
features.append(item.feature)
name = ''
ok = True
while not name.strip() and ok == True:
name, ok = QInputDialog.getText(self, self.tr('Layer name'), self.tr('Give a name to the layer:'))
if ok:
layer = QgsVectorLayer(type+"?crs="+table.crs.authid(),name,"memory")
layer.startEditing()
layer.dataProvider().addAttributes(features[0].fields().toList())
layer.dataProvider().addFeatures(features)
layer.commitChanges()
QgsProject.instance().addMapLayer(layer)
else:
self.mb.pushWarning(self.tr('Warning'), self.tr('There is no selected feature !'))
def rename_maptheme(self):
theme = self.dockwidget.PresetComboBox.currentText()
quest = QInputDialog.getText(None,
self.tr(u'Rename Theme'),
self.tr(u'New Name:'),
0,
theme
)
root = QgsProject.instance().layerTreeRoot()
model = iface.layerTreeView().layerTreeModel()
name, ok = quest
if ok and name != "":
rec = QgsProject.instance().mapThemeCollection().createThemeFromCurrentState(root, model)
QgsProject.instance().mapThemeCollection().insert(name, rec)
self.populate()
QgsProject.instance().mapThemeCollection().applyTheme(
name, root, model
)
QgsProject.instance().mapThemeCollection().removeMapTheme(theme)
self.populate()
self.theme_changed()
self.set_combo_text(name)
return
else:
return
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)
def dbCreateSchema(self):
schemaName, ok = QInputDialog.getText(self, 'New schema', 'New schema name:')
if ok:
self.rdb.create_schema(schemaName)
self.connChanged(self.curConnName, schema_name=schemaName)
else:
self.addInfo('Creating new schema cancelled.')
def authenticate():
# PKCE. Generates a challenge that the server will use to ensure that the
# auth_code only works with our verifier. https://tools.ietf.org/html/rfc7636
code_verifier = ee.oauth._base64param(os.urandom(32))
code_challenge = ee.oauth._base64param(hashlib.sha256(code_verifier).digest())
auth_url = ee.oauth.get_authorization_url(code_challenge)
tiny_url_ok, auth_url = tiny_url(auth_url)
webbrowser.open_new(auth_url)
print('\nGoogle Earth Engine Authorization:\n'
'If the web browser does not start automatically, '
'start it manually and open the following URL:\n"{}"'.format(auth_url))
token, ok = QInputDialog.getText(None, 'Authorization',
'Google Earth Engine Python is not detected on this machine.\n'
'This plugin uses Google Earth Engine Python API and requires\n'
'users to be authorized, please follow the instructions in the\n'
'opened web page and paste the resulting auth token here.\n\n'
'If the web page does not open automatically,\n'
+ ('visit the following link manually:\nURL: {}'.format(auth_url)
if tiny_url_ok else 'visit the link that appears in the python console'))
if ok and token:
ee.oauth._obtain_and_write_token(token.strip(), code_verifier)
return True
else:
return False
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 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 _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):
CANVAS_KEY = 'Use canvas extent'
extentsDict = {}
extentsDict[CANVAS_KEY] = {
"extent": iface.mapCanvas().extent(),
"authid":
iface.mapCanvas().mapSettings().destinationCrs().authid()
}
extents = [CANVAS_KEY]
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,
False)
if ok:
self.setValueFromRect(
QgsReferencedRectangle(
extentsDict[item]["extent"],
QgsCoordinateReferenceSystem(extentsDict[item]["authid"])))
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 = 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,
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 linkFeatureManyToManyPolymorphic(self):
nmRelations = dict()
for relation in self._polymorphicRelation.generateRelations():
nmRelations[relation.referencedLayer().name()] = relation
layerName, ok = QInputDialog.getItem(self,
self.tr("Please selct a layer"),
self.tr("Layer:"),
nmRelations.keys())
if not ok:
return
nmRelation = nmRelations[layerName]
selectionDlg = QgsFeatureSelectionDlg(nmRelation.referencedLayer(),
self.editorContext(), self)
selectionDlg.setWindowTitle(
self.tr("Please select the features to link. Layer: {0}").format(
layerName))
if not selectionDlg.exec():
return
# Fields of the linking table
fields = self.relation().referencingLayer().fields()
linkAttributes = dict()
linkAttributes[fields.indexFromName(
self._polymorphicRelation.referencedLayerField(
))] = self._polymorphicRelation.layerRepresentation(
nmRelation.referencedLayer())
for key in self.relation().fieldPairs():
linkAttributes[fields.indexOf(key)] = self.feature().attribute(
self.relation().fieldPairs()[key])
# Expression context for the linking table
context = self.relation().referencingLayer().createExpressionContext()
featureIterator = nmRelation.referencedLayer().getFeatures(
QgsFeatureRequest().setFilterFids(
selectionDlg.selectedFeatures()).setSubsetOfAttributes(
nmRelation.referencedFields()))
relatedFeature = QgsFeature()
newFeatures = []
while featureIterator.nextFeature(relatedFeature):
for key in nmRelation.fieldPairs():
linkAttributes[fields.indexOf(key)] = relatedFeature.attribute(
nmRelation.fieldPairs()[key])
linkFeature = QgsVectorLayerUtils.createFeature(
self.relation().referencingLayer(), QgsGeometry(),
linkAttributes, context)
newFeatures.append(linkFeature)
self.relation().referencingLayer().addFeatures(newFeatures)
ids = []
for feature in newFeatures:
ids.append(feature.id())
self.relation().referencingLayer().selectByIds(ids)
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 forkRepo(self):
name = self.repo if not self.belongsToLoggedUser else self.repo + "_2"
repoName, okPressed = QInputDialog.getText(navigatorInstance,
"Fork repo",
"Name for forked repo:",
text=name)
if okPressed:
self.server.forkRepo(self.user, self.repo, repoName)
def ask_url(self, default_text=None):
text, ok = QInputDialog.getText(
self,
tr("Add new model repository"),
tr("Repository URL:"),
QLineEdit.Normal,
default_text)
return text, ok
def createTag(self, item):
tagname, ok = QInputDialog.getText(self, 'Tag name',
'Enter the tag name:')
if ok:
self.repo.createtag(item.commit.commitid, tagname)
w = self.itemWidget(item, 0)
w.tags.append(tagname)
w.updateText()
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 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 update_space_info_json(self):
# dialog = PlainTextDialog("")
space_info = self.get_space_info()
txt = json.dumps(space_info,indent=4)
txt, ok = QInputDialog.getMultiLineText(None, "Edit Space JSON", "Only change this if you know what you're doing", txt)
if ok:
space_info = json.loads(txt)
self.set_space_info(space_info)
def set_personal_api_key(self):
"""Setting active Personal API Key."""
pak, accept = QInputDialog.getText(self, "Personal API Key",
"Paste your Personal API Key:")
if accept is False:
return
self.set_3di_auth(pak)
self.set_personal_api_key_label(True)
def get_eid(self, events_npz):
self.events_npz = events_npz
events = events_npz['array']
self.eid = -1 # assuming events start from 0
if 'GEM_QGIS_TEST' in os.environ:
self.eid = self.get_closest_element(self.eid, events['id'])
ok = True
elif 'scenario' in self.calculation_mode:
range_width = self.oqparam['number_of_ground_motion_fields']
ranges = {}
for gsim_idx, gsim in enumerate(self.gsims):
ranges[gsim] = (gsim_idx * range_width,
gsim_idx * range_width + range_width - 1)
ranges_str = ''
for gsim in ranges:
ranges_str += '\n%s: %s' % (gsim, ranges[gsim])
input_msg = "Ranges:%s" % ranges_str
else:
input_msg = "Range (%s - %s)" % (events[0]['id'], events[-1]['id'])
if 'GEM_QGIS_TEST' not in os.environ:
while self.eid not in events['id']:
if self.eid == -1:
is_first_iteration = True
self.eid = self.get_closest_element(self.eid, events['id'])
if is_first_iteration:
msg = 'The first relevant event id is %s' % self.eid
level = 'I'
else:
msg = 'The closest relevant event id is %s' % self.eid
level = 'W'
log_msg(msg, level=level, message_bar=self.iface.messageBar())
self.eid, ok = QInputDialog.getInt(self.drive_engine_dlg,
'Select an event ID',
input_msg, self.eid,
events[0]['id'],
events[-1]['id'])
if not ok:
self.reject()
return
if not ok:
self.reject()
return
log_msg(
'Extracting ground motion fields.'
' Watch progress in QGIS task bar',
level='I',
message_bar=self.iface.messageBar())
self.extract_npz_task = ExtractNpzTask('Extract ground motion fields',
QgsTask.CanCancel,
self.session,
self.hostname,
self.calc_id,
self.output_type,
self.finalize_init,
self.on_extract_error,
params={'event_id': self.eid})
QgsApplication.taskManager().addTask(self.extract_npz_task)
def get_password():
"""Return Linux user Password."""
password, ok = QInputDialog.getText(
None,
"Enter Linux user password for install missing dependencies",
"Password:"******""
def on_clone_btn_clicked(self):
title = (self.selected_proj_def['title'] +
' (copy)' if 'title' in self.selected_proj_def else '(copy)')
title, ok = QInputDialog().getText(self,
tr('Assign a title'),
tr('Project definition title'),
text=title)
if ok:
self.add_proj_def(title, self.selected_proj_def)
def dbDeleteSchema(self):
schemaName, ok = QInputDialog.getText(self, 'Delete schema', 'Schema name:')
if ok:
self.rdb.drop_schema(schemaName, cascade=True)
if self.rdb.SCHEMA == schemaName:
self.connChanged()
else:
self.ui.schemasCbo.removeItem(self.ui.schemasCbo.findText(schemaName))
else:
self.addInfo('Droping schema cancelled.')
def _save_configuration(self):
service_type = self.get_current_service_type()
name, ok = QInputDialog.getText(self, self.tr('Save Service Configuration'),
self.tr('Save the current service configuration as'))
if not name or not ok:
return
filter_widget = self.get_service_filter_widget(service_type)
SERVICE_MANAGER.save_service(service_type, name, filter_widget.to_service_definition())
self.set_current_service(service_type, name)
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 insertExtension(self):
'''
Inserts a new extension to be analyzed
'''
text = QInputDialog.getText(self,
self.tr('Type the extension'),
self.tr('File extension'),
mode=QLineEdit.Normal)
item = QTreeWidgetItem(self.treeWidget.invisibleRootItem())
item.setText(0, text[0])
def configurar(self):
contras = QInputDialog.getText(None, 'CONTRASEÑA',
'Introduce la contraseña')
print(contras)
if contras[0] == 'SIGMENITA':
self.dlg2.show()
else:
iface.messageBar().pushMessage(
"PARA CONFIGURAR INRODUCIR CONTRASEÑA", qgisCore.Qgis.Warning,
5)
def user_input_label(label_req, question):
label = ''
qid = QInputDialog()
#communiceer met de gebruiker voor input, waarbij question de vraag is die wordt gesteld
if label_req < '2':
while True:
label, ok = QInputDialog.getText(
qid,
"Label:",
question,
QLineEdit.Normal,
)
if ok:
if label != '' or label_req == '0':
return label
break
else:
label = 'Cancel'
return label
break
def pick_item(self, title, message, parent=None, *items):
"""Getting item from list of items."""
parent = parent if parent is not None else self.iface.mainWindow()
item, accept = QInputDialog.getItem(parent,
title,
message,
items,
editable=False)
if accept is False:
return None
return item
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 set_display_name_button_clicked(self):
"""
Method to change display name
"""
layer_names_ids = pg_layerNamesIDMapping().reverse
layer = self.iface.activeLayer()
if layer is not None:
table_name = layer_names_ids.get(layer.id(), '')
if table_name:
# Check if the table name is in the current profile
if table_name in self._profile_spatial_layers:
prompt = \
"Set the display name for '{0}' layer".format(
layer.name()
)
display_name, ok = QInputDialog.getText(
self, 'Spatial Unit '
'Manager', prompt)
if ok and display_name:
# Get layer table and columns names
table, column = self._layer_table_column(layer)
if table and column:
idx, layer_info = \
self._layer_info_from_table_column(
table,
column
)
# Get item in the combo corresponding to the layer
if idx != -1:
self.stdm_layers_combo.setItemText(
idx, display_name)
layer.setName(display_name)
# Update configuration item
config_item = layer_info.get('item', None)
if config_item is not None:
config_item.layer_display_name = \
display_name
# Update configuration
save_configuration()
else:
msg = QApplication.translate(
"Spatial Unit Manager", "The layer does not "
"belong in the '{0}' "
"profile.\nThe display name "
"will not be set."
"".format(self._curr_profile.name))
QMessageBox.critical(self.iface.mainWindow(),
'Spatial Unit Manager', msg)
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 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 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 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 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 _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 _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 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 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 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
)
def __init__(self, question="YesNo", msg = '', dialogtitle='User input needed', parent=None):
self.result = ''
if question == 'YesNo': # Yes/No dialog
reply = QMessageBox.information(parent, dialogtitle, msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.Yes)
if reply==QMessageBox.Yes:
self.result = 1 #1 = "yes"
else:
self.result = 0 #0="no"
elif question == 'AllSelected': # All or Selected Dialog
btnAll = QPushButton("All") # = "0"
btnSelected = QPushButton("Selected") # = "1"
#btnAll.clicked.connect(lambda x: self.DoForAll())
#btnSelected.clicked.connect(lambda x: self.DoForSelected())
msgBox = QMessageBox(parent)
msgBox.setText(msg)
msgBox.setWindowTitle(dialogtitle)
#msgBox.setWindowModality(Qt.ApplicationModal)
msgBox.addButton(btnAll, QMessageBox.ActionRole)
msgBox.addButton(btnSelected, QMessageBox.ActionRole)
msgBox.addButton(QMessageBox.Cancel)
reply = msgBox.exec_()
self.result = reply # ALL=0, SELECTED=1
elif question == 'DateShift':
supported_units = ['microseconds', 'milliseconds', 'seconds', 'minutes', 'hours', 'days', 'weeks']
while True:
answer = str(QInputDialog.getText(None, "User input needed", "Give needed adjustment of date/time for the data.\nSupported format: +- X <resolution>\nEx: 1 hours, -1 hours, -1 days\nSupported units:\n%s"%', '.join(supported_units), QLineEdit.Normal, '0 hours')[0])
if not answer:
self.result = 'cancel'
break
else:
adjustment_unit = answer.split()
if len(adjustment_unit) == 2:
if adjustment_unit[1] in supported_units:
self.result = adjustment_unit
break
else:
pop_up_info("Failure:\nOnly support resolutions\n%s"%', '.join(supported_units))
else:
pop_up_info("Failure:\nMust write time resolution also.\n")
def createTag(self, item):
tagname, ok = QInputDialog.getText(self, 'Tag name',
'Enter the tag name:')
if ok:
self.repo.createtag(item.commit.commitid, tagname)
self.updateTags(item.commit.commitid, tagname)
def createBranch(self):
text, ok = QInputDialog.getText(self.tree, 'Create New Branch',
'Enter the name for the new branch:')
if ok:
self.repo.createbranch(self.branch, text.replace(" ", "_"))
repoWatcher.repoChanged.emit(self.repo)
def changeHeader(self, index):
txt, ok = QInputDialog.getText(self, self.tr("Enter column name"), self.tr("Column name"))
if ok:
self.tblView.model().setHeaderData(index, Qt.Horizontal, txt)
def draw(self):
rb = self.tool.rb
g = rb.asGeometry()
ok = True
warning = False
errBuffer_noAtt = False
errBuffer_Vertices = False
layer = self.iface.layerTreeView().currentLayer()
if self.toolname == 'drawBuffer':
if self.bGeom is None:
warning = True
errBuffer_noAtt = True
else:
perim, ok = QInputDialog.getDouble(
self.iface.mainWindow(), self.tr('Perimeter'),
self.tr('Give a perimeter in m:')
+ '\n'+self.tr('(works only with metric crs)'),
min=0)
g = self.bGeom.buffer(perim, 40)
rb.setToGeometry(g, QgsVectorLayer(
"Polygon?crs="+layer.crs().authid(), "", "memory"))
if g.length() == 0 and ok:
warning = True
errBuffer_Vertices = True
if self.toolname == 'drawCopies':
if g.length() < 0:
warning = True
errBuffer_noAtt = True
if ok and not warning:
name = ''
ok = True
add = False
index = 0
layers = []
while not name.strip() and not add and ok:
dlg = QDrawLayerDialog(self.iface, self.drawShape)
name, add, index, layers, ok = dlg.getName(
self.iface, self.drawShape)
if ok and not warning:
layer = None
if add:
layer = layers[index]
if self.drawShape in ['point', 'XYpoint']:
g = g.centroid()
else:
if self.drawShape == 'point':
layer = QgsVectorLayer("Point?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
g = g.centroid() # force geometry as point
elif self.drawShape == 'XYpoint':
layer = QgsVectorLayer("Point?crs="+self.XYcrs.authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
g = g.centroid()
elif self.drawShape == 'line':
layer = QgsVectorLayer("LineString?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
# fix_print_with_import
print("LineString?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)")
else:
layer = QgsVectorLayer("Polygon?crs="+self.iface.mapCanvas().mapSettings().destinationCrs().authid()+"&field="+self.tr('Drawings')+":string(255)", name, "memory")
layer.startEditing()
symbols = layer.renderer().symbols(QgsRenderContext()) # todo which context ?
symbols[0].setColor(self.settings.getColor())
feature = QgsFeature()
feature.setGeometry(g)
feature.setAttributes([name])
layer.dataProvider().addFeatures([feature])
layer.commitChanges()
if not add:
pjt = QgsProject.instance()
pjt.addMapLayer(layer, False)
if pjt.layerTreeRoot().findGroup(self.tr('Drawings')) is None:
pjt.layerTreeRoot().insertChildNode(
0, QgsLayerTreeGroup(self.tr('Drawings')))
group = pjt.layerTreeRoot().findGroup(
self.tr('Drawings'))
group.insertLayer(0, layer)
self.iface.layerTreeView().refreshLayerSymbology(layer.id())
self.iface.mapCanvas().refresh()
else:
if warning:
if errBuffer_noAtt:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You didn\'t click on a layer\'s attribute !'))
elif errBuffer_Vertices:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('You must give a non-null value for a \
point\'s or line\'s perimeter !'))
else:
self.iface.messageBar().pushWarning(
self.tr('Warning'),
self.tr('There is no selected layer, or it is not \
vector nor visible !'))
self.tool.reset()
self.resetSB()
self.bGeom = None
def accept(self):
try:
nodata = self.ui.IDC_tbNoDataExport.text()
self.settings.nodata_value = int(nodata) if nodata != "" else None
QgsMessageLog.logMessage("Maindlg: nodata: {0}".format(self.settings.nodata_value), "VoGis", Qgis.Info)
if self.settings.onlyHektoMode is True and self.settings.mapData.rasters.count() > 0:
self.settings.onlyHektoMode = False
if self.settings.onlyHektoMode is False:
if self.settings.mapData.rasters.count() < 1:
retVal = QMessageBox.warning(self.iface.mainWindow(),
"VoGIS-Profiltool",
QApplication.translate("code", "Keine Rasterebene vorhanden oder sichtbar! Nur hektometrieren?"),
QMessageBox.Yes | QMessageBox.No,
QMessageBox.Yes)
if retVal == QMessageBox.No:
return
else:
self.settings.onlyHektoMode = True
self.settings.createHekto = True
if self.__getSettingsFromGui() is False:
return
if self.settings.onlyHektoMode is False:
if len(self.settings.mapData.rasters.selectedRasters()) < 1:
QMessageBox.warning(self.iface.mainWindow(),
"VoGIS-Profiltool",
QApplication.translate("code", "Kein Raster selektiert!"))
return
QgsMessageLog.logMessage("modeLine!=line: {0}".format(self.settings.modeLine != enumModeLine.line), "VoGis", Qgis.Info)
QgsMessageLog.logMessage("customLine is None: {0}".format(self.settings.mapData.customLine is None), "VoGis", Qgis.Info)
if self.settings.modeLine != enumModeLine.line and self.settings.mapData.customLine is None:
QMessageBox.warning(self.iface.mainWindow(),
"VoGIS-Profiltool",
QApplication.translate("code", "Keine Profillinie vorhanden!"))
return
if len(self.settings.mapData.polygons.selected_polygons()) > 0 and len(self.settings.mapData.rasters.selectedRasters()) > 1:
raster_names = list(raster.name for raster in self.settings.mapData.rasters.selectedRasters())
sel_raster, ok_clicked = QInputDialog.getItem(
self.iface.mainWindow(),
"DHM?",
"Welches DHM soll zur Flächenverschneidung verwendet werden?",
raster_names,
0,
False
)
if ok_clicked is False:
return
self.settings.intersection_dhm_idx = raster_names.index(sel_raster)
QApplication.setOverrideCursor(Qt.WaitCursor)
create_profile = CreateProfile(self.iface, self.settings)
thread = QThread(self)
create_profile.moveToThread(thread)
create_profile.finished.connect(self.profiles_finished)
create_profile.error.connect(self.profiles_error)
create_profile.progress.connect(self.profiles_progress)
thread.started.connect(create_profile.create)
thread.start(QThread.LowestPriority)
self.thread = thread
self.create_profile = create_profile
self.ui.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
except:
QApplication.restoreOverrideCursor()
ex = "{0}".format(traceback.format_exc())
msg = "Unexpected ERROR:\n\n{0}".format(ex[:2000])
QMessageBox.critical(self.iface.mainWindow(), "VoGIS-Profiltool", msg)
