def refresh(self, user):
cloud_connections_key = u"/qgiscloud/connections/%s" % user
settings = QSettings()
cloud_dbs_from_server = list(self._dbs.keys())
stored_connections = settings.value(cloud_connections_key) or []
cloud_dbs_from_settings = [str(conn) for conn in stored_connections]
# remove obsolete connections
for db_name in (set(cloud_dbs_from_settings) - set(cloud_dbs_from_server)):
for connection in DbConnectionCfg.get_cloud_db_connections(db_name):
DbConnectionCfg.remove_connection(connection)
# add missing or changed connections
for db_name in cloud_dbs_from_server:
cfg = self.db(db_name)
if len(DbConnectionCfg.get_cloud_db_connections(db_name)) == 0 or \
cfg.changed:
cfg.store_connection()
# store cloud db names in settings
if len(cloud_dbs_from_server) > 0:
settings.setValue(cloud_connections_key, cloud_dbs_from_server)
else:
settings.remove(cloud_connections_key)
self._dbs_refreshed = True
def showSelectionDialog(self):
# Find the file dialog's working directory
settings = QSettings()
text = self.leText.text()
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif settings.contains('/Processing/LastInputPath'):
path = settings.value('/Processing/LastInputPath')
else:
path = ''
if self.isFolder:
folder = QFileDialog.getExistingDirectory(self,
self.tr('Select folder'), path)
if folder:
self.leText.setText(folder)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(folder))
else:
filenames, selected_filter = QFileDialog.getOpenFileNames(self,
self.tr('Select file'), path, '*.' + self.ext)
if filenames:
self.leText.setText(u';'.join(filenames))
settings.setValue('/Processing/LastInputPath',
os.path.dirname(filenames[0]))
def execute(self):
settings = QSettings()
lastDir = settings.value('Processing/lastScriptsDir', '')
filenames, selected_filter = QFileDialog.getOpenFileNames(self.toolbox,
self.tr('Script files', 'AddScriptFromFileAction'), lastDir,
self.tr('Script files (*.py *.PY)', 'AddScriptFromFileAction'))
if filenames:
validAlgs = 0
wrongAlgs = []
for filename in filenames:
try:
settings.setValue('Processing/lastScriptsDir',
QFileInfo(filename).absoluteDir().absolutePath())
script = ScriptAlgorithm(filename)
destFilename = os.path.join(ScriptUtils.scriptsFolders()[0], os.path.basename(filename))
with open(destFilename, 'w') as f:
f.write(script.script)
validAlgs += 1
except WrongScriptException:
wrongAlgs.append(os.path.basename(filename))
if validAlgs:
algList.reloadProvider('script')
if wrongAlgs:
QMessageBox.warning(self.toolbox,
self.tr('Error reading scripts', 'AddScriptFromFileAction'),
self.tr('The following files do not contain a valid script:\n-', 'AddScriptFromFileAction')
+ "\n-".join(wrongAlgs))
def execute(self):
settings = QSettings()
lastDir = settings.value('Processing/lastModelsDir', '')
filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
self.tr('Open model', 'AddModelFromFileAction'), lastDir,
self.tr('Processing model files (*.model *.MODEL)', 'AddModelFromFileAction'))
if filename:
try:
settings.setValue('Processing/lastModelsDir',
QFileInfo(filename).absoluteDir().absolutePath())
ModelerAlgorithm.fromFile(filename)
except WrongModelException:
QMessageBox.warning(
self.toolbox,
self.tr('Error reading model', 'AddModelFromFileAction'),
self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
return
except:
QMessageBox.warning(self.toolbox,
self.tr('Error reading model', 'AddModelFromFileAction'),
self.tr('Cannot read file', 'AddModelFromFileAction'))
return
destFilename = os.path.join(ModelerUtils.modelsFolders()[0], os.path.basename(filename))
shutil.copyfile(filename, destFilename)
algList.reloadProvider('model')
def fetch_online_directories(self):
"""Fetch online directory of repositories."""
downloader = NetworkManager(self.DIRECTORY_URL)
status, _ = downloader.fetch()
if status:
directory_file = QTemporaryFile()
if directory_file.open():
directory_file.write(downloader.content)
directory_file.close()
with open(directory_file.fileName()) as csv_file:
reader = csv.DictReader(csv_file, fieldnames=('name', 'url'))
for row in reader:
self._online_directories[row['name']] = row['url'].strip()
# Save it to cache
settings = QSettings()
settings.beginGroup(repo_settings_group())
settings.setValue('online_directories', self._online_directories)
settings.endGroup()
else:
# Just use cache from previous use
settings = QSettings()
settings.beginGroup(repo_settings_group())
self._online_directories = settings.value('online_directories', {})
settings.endGroup()
def browse(self):
settings = QSettings()
key = '/UI/lastShapefileDir'
outDir = settings.value(key)
home = outDir
#outDir = expanduser("~")
#filter = (self.DEFAULTPROVIDER + " (*" +
# self.DEFAULTEXTENSION + ");;All files (*)")
filter = (self.DEFAULTPROVIDER + " (*" +
self.DEFAULTEXTENSION + self.EXTRAEXTENSION + ")")
#if (self.gdalprovider != self.DEFAULTPROVIDER and
# (self.canCreateCopy or
# self.canCreate)):
# filter = (self.gdalprovider + " (*" + self.gdalext +
# ");;" + filter)
outFilePath = QFileDialog.getSaveFileName(self,
'Specify file name for skeleton',
outDir, filter)
outFilePath = unicode(outFilePath)
if outFilePath:
root, ext = splitext(outFilePath)
if ext.lower() != '.tif' and ext.lower() != '.tiff':
outFilePath = '%s.tif' % outFilePath
outDir = dirname(outFilePath)
settings.setValue(key, outDir)
# (self.canCreateCopy or self.canCreate):
# fileName = splitext(str(fileName))[0]+self.gdalext
self.outputRaster.setText(outFilePath)
def selectFile(self):
output = self.alg.getOutputFromName("OUTPUT_LAYER")
fileFilter = output.getFileFilter(self.alg)
settings = QSettings()
if settings.contains("/Processing/LastOutputPath"):
path = settings.value("/Processing/LastOutputPath")
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
lastEncoding = settings.value("/Processing/encoding", "System")
fileDialog = QgsEncodingFileDialog(self, self.tr("Save file"), path, fileFilter, lastEncoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setOption(QFileDialog.DontConfirmOverwrite, False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = str(fileDialog.encoding())
output.encoding = encoding
filename = str(files[0])
selectedFileFilter = str(fileDialog.selectedNameFilter())
if not filename.lower().endswith(tuple(re.findall("\*(\.[a-z]{1,10})", fileFilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
filename = filename + ext.group(1)
self.leOutputFile.setText(filename)
settings.setValue("/Processing/LastOutputPath", os.path.dirname(filename))
settings.setValue("/Processing/encoding", encoding)
def save_state(self):
"""Store current state of GUI to configuration file.
.. versionadded: 3.3
"""
settings = QSettings()
settings.setValue('directory', self.output_directory.text())
def showFileSelectionDialog(self):
settings = QSettings()
text = str(self.text.text())
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif settings.contains('/Processing/LastInputPath'):
path = str(settings.value('/Processing/LastInputPath'))
else:
path = ''
ret, selected_filter = QFileDialog.getOpenFileNames(self, self.tr('Open file'), path,
self.tr('All files(*.*);;') + self.param.getFileFilter())
if ret:
files = list(ret)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(files[0])))
for i, filename in enumerate(files):
files[i] = dataobjects.getRasterSublayer(filename, self.param)
if len(files) == 1:
self.text.setText(files[0])
self.textEditingFinished()
else:
if isinstance(self.param, ParameterMultipleInput):
self.text.setText(';'.join(str(f) for f in files))
else:
rowdif = len(files) - (self._table().rowCount() - self.row)
for i in range(rowdif):
self._panel().addRow()
for i, f in enumerate(files):
self._table().cellWidget(i + self.row,
self.col).setValue(f)
def main():
datestamp = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
if QT5:
ini_out_dir = QStandardPaths.writableLocation(QStandardPaths.DesktopLocation)
else:
ini_out_dir = QDesktopServices.storageLocation(QDesktopServices.DesktopLocation)
ini_name = 'org.qgis.{0}-settings_{1}.ini'.format(QGIS_APP_NAME, datestamp)
ini_out = QDir(ini_out_dir).absoluteFilePath(ini_name)
if not os.path.exists(ini_out_dir):
print('INI output directory does not exist: {0}'.format(ini_out_dir))
return
if not os.access(ini_out_dir, os.W_OK | os.X_OK):
print('INI output directory is not writeable: {0}'.format(ini_out_dir))
return
# QGIS settings
if HAS_QGSSETTINGS:
qgis_settings = QgsSettings()
else:
qgis_settings = QSettings()
# Output INI settings
ini_settings = QSettings(ini_out, QSettings.IniFormat)
qgis_keys = qgis_settings.allKeys()
for k in qgis_keys:
ini_settings.setValue(k, qgis_settings.value(k))
ini_settings.sync()
print("Settings output to: {0}".format(QDir.toNativeSeparators(ini_out)))
def load(self):
""" populate the mRepositories dict"""
self.mRepositories = {}
settings = QSettings()
settings.beginGroup(reposGroup)
# first, update repositories in QSettings if needed
officialRepoPresent = False
for key in settings.childGroups():
url = settings.value(key + "/url", "", type=unicode)
if url == officialRepo[1]:
officialRepoPresent = True
if url == officialRepo[2]:
settings.setValue(key + "/url", officialRepo[1]) # correct a depreciated url
officialRepoPresent = True
if not officialRepoPresent:
settings.setValue(officialRepo[0] + "/url", officialRepo[1])
for key in settings.childGroups():
self.mRepositories[key] = {}
self.mRepositories[key]["url"] = settings.value(key + "/url", "", type=unicode)
self.mRepositories[key]["authcfg"] = settings.value(key + "/authcfg", "", type=unicode)
self.mRepositories[key]["enabled"] = settings.value(key + "/enabled", True, type=bool)
self.mRepositories[key]["valid"] = settings.value(key + "/valid", True, type=bool)
self.mRepositories[key]["Relay"] = Relay(key)
self.mRepositories[key]["xmlData"] = None
self.mRepositories[key]["state"] = 0
self.mRepositories[key]["error"] = ""
settings.endGroup()
def showSelectionDialog(self):
if isinstance(self.output, OutputDirectory):
self.selectDirectory()
return
filefilter = self.output.getFileFilter(self.alg)
settings = QSettings()
if settings.contains('/Processing/LastBatchOutputPath'):
path = str(settings.value('/Processing/LastBatchOutputPath'))
else:
path = ''
filename, selectedFileFilter = QFileDialog.getSaveFileName(self,
self.tr('Save file'), path, filefilter)
if filename:
if not filename.lower().endswith(
tuple(re.findall("\*(\.[a-z]{1,10})", filefilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
filename += ext.group(1)
settings.setValue('/Processing/LastBatchOutputPath', os.path.dirname(filename))
dlg = AutofillDialog(self.alg)
dlg.exec_()
if dlg.mode is not None:
try:
if dlg.mode == AutofillDialog.DO_NOT_AUTOFILL:
self.table.cellWidget(self.row,
self.col).setValue(filename)
elif dlg.mode == AutofillDialog.FILL_WITH_NUMBERS:
n = self.table.rowCount() - self.row
for i in range(n):
name = filename[:filename.rfind('.')] \
+ str(i + 1) + filename[filename.rfind('.'):]
self.table.cellWidget(i + self.row,
self.col).setValue(name)
elif dlg.mode == AutofillDialog.FILL_WITH_PARAMETER:
n = self.table.rowCount() - self.row
for i in range(n):
widget = self.table.cellWidget(i + self.row,
dlg.param)
param = self.alg.parameters[dlg.param]
if isinstance(param, (ParameterRaster,
ParameterVector, ParameterTable,
ParameterMultipleInput)):
s = str(widget.getText())
s = os.path.basename(s)
s = os.path.splitext(s)[0]
elif isinstance(param, ParameterBoolean):
s = str(widget.currentIndex() == 0)
elif isinstance(param, ParameterSelection):
s = str(widget.currentText())
elif isinstance(param, ParameterFixedTable):
s = str(widget.table)
else:
s = str(widget.text())
name = filename[:filename.rfind('.')] + s \
+ filename[filename.rfind('.'):]
self.table.cellWidget(i + self.row,
self.col).setValue(name)
except:
pass
def export(self):
""" Export the results to a CSV file """
# Remember the last location in which we saved
settings = QSettings()
lastFolder = str(settings.value("constraintchecker/lastSaveFolder", os.sep))
outFileName, ext_selector = QFileDialog.getSaveFileName(self, 'Save Query Results', lastFolder,
'Comma Separated Variable Files (*.csv)')
# Store the path we just looked in
head, tail = os.path.split(outFileName)
if head != os.sep and head.lower() != 'c:\\' and head != '':
settings.setValue("constraintchecker/lastSaveFolder", head)
if len(outFileName) == 0:
# User hit cancel
return
# Export the file
try:
csvfile = open(outFileName+'.csv', 'w')
except:
msg = 'Failed to open %s for writing - perhaps it is open in another application?' % outFileName
QMessageBox.critical(self, 'Failed to Open File', msg)
return
resWriter = csv.writer(csvfile)
resWriter.writerow(self.resultModel.headerNames)
for i in range(self.resultModel.rowCount()):
resWriter.writerow(self.resultModel.fetchRow(i))
csvfile.close()
def selectFile(self):
fileFilter = self.output.getFileFilter(self.alg)
settings = QSettings()
if settings.contains('/Processing/LastOutputPath'):
path = settings.value('/Processing/LastOutputPath')
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
encoding = settings.value('/Processing/encoding', 'System')
fileDialog = QgsEncodingFileDialog(
self, self.tr('Save file'), path, fileFilter, encoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setOption(QFileDialog.DontConfirmOverwrite, False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = str(fileDialog.encoding())
self.output.encoding = encoding
fileName = str(files[0])
selectedFileFilter = str(fileDialog.selectedNameFilter())
if not fileName.lower().endswith(
tuple(re.findall("\\*(\\.[a-z]{1,10})", fileFilter))):
ext = re.search("\\*(\\.[a-z]{1,10})", selectedFileFilter)
if ext:
fileName += ext.group(1)
self.leText.setText(fileName)
settings.setValue('/Processing/LastOutputPath',
os.path.dirname(fileName))
settings.setValue('/Processing/encoding', encoding)
def chooseOutputFile(self):
# get last used dir
settings = QSettings()
lastUsedDir = settings.value(self.lastUsedVectorDirSettingsKey, ".")
# get selected filter
selectedFilter = self.cboFileFormat.itemData(self.cboFileFormat.currentIndex())
# ask for a filename
filename, filter = QFileDialog.getSaveFileName(self, self.tr("Choose where to save the file"), lastUsedDir,
selectedFilter)
if filename == "":
return
filterString = QgsVectorFileWriter.filterForDriver(selectedFilter)
ext = filterString[filterString.find('.'):]
ext = ext[:ext.find(' ')]
if not filename.lower().endswith(ext):
filename += ext
# store the last used dir
settings.setValue(self.lastUsedVectorDirSettingsKey, QFileInfo(filename).filePath())
self.editOutputFile.setText(filename)
def saveToSpatialite(self):
fileFilter = self.output.tr("Spatialite files(*.sqlite)", "OutputFile")
settings = QSettings()
if settings.contains("/Processing/LastOutputPath"):
path = settings.value("/Processing/LastOutputPath")
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
encoding = settings.value("/Processing/encoding", "System")
fileDialog = QgsEncodingFileDialog(self, self.tr("Save Spatialite"), path, fileFilter, encoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setConfirmOverwrite(False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = unicode(fileDialog.encoding())
self.output.encoding = encoding
fileName = unicode(files[0])
selectedFileFilter = unicode(fileDialog.selectedNameFilter())
if not fileName.lower().endswith(tuple(re.findall("\*(\.[a-z]{1,10})", fileFilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
fileName += ext.group(1)
settings.setValue("/Processing/LastOutputPath", os.path.dirname(fileName))
settings.setValue("/Processing/encoding", encoding)
uri = QgsDataSourceUri()
uri.setDatabase(fileName)
uri.setDataSource("", self.output.name.lower(), "the_geom" if self.output.hasGeometry() else None)
self.leText.setText("spatialite:" + uri.uri())
def setLastUsedDir(filePath):
settings = QSettings()
fileInfo = QFileInfo(filePath)
if fileInfo.isDir():
dirPath = fileInfo.filePath()
else:
dirPath = fileInfo.path()
settings.setValue("/GdalTools/lastUsedDir", dirPath)
def updateSeenPluginsList(self):
""" update the list of all seen plugins """
settings = QSettings()
seenPlugins = settings.value(seenPluginGroup, self.mPlugins.keys(), type=unicode)
for i in self.mPlugins.keys():
if seenPlugins.count(i) == 0:
seenPlugins += [i]
settings.setValue(seenPluginGroup, seenPlugins)
def connect(self):
selected = self.text()
conn = ConnectionManager.getConnection(self.type).connect(selected, self.parent())
# set as default in QSettings
settings = QSettings()
settings.setValue("/%s/connections/selected" % conn.getSettingsKey(), selected)
return conn
class NewConnectionDialog(QDialog, BASE_CLASS):
"""Dialogue to add a new CSW entry"""
def __init__(self, conn_name=None):
"""init"""
QDialog.__init__(self)
self.setupUi(self)
self.settings = QSettings()
self.conn_name = None
self.conn_name_orig = conn_name
def accept(self):
"""add CSW entry"""
conn_name = self.leName.text().strip()
conn_url = self.leURL.text().strip()
if any([conn_name == '', conn_url == '']):
QMessageBox.warning(self, self.tr('Save connection'),
self.tr('Both Name and URL must be provided'))
return
if '/' in conn_name:
QMessageBox.warning(self, self.tr('Save connection'),
self.tr('Name cannot contain \'/\''))
return
if conn_name is not None:
key = '/MetaSearch/%s' % conn_name
keyurl = '%s/url' % key
key_orig = '/MetaSearch/%s' % self.conn_name_orig
# warn if entry was renamed to an existing connection
if all([self.conn_name_orig != conn_name,
self.settings.contains(keyurl)]):
res = QMessageBox.warning(self, self.tr('Save connection'),
self.tr('Overwrite %s?') % conn_name,
QMessageBox.Ok | QMessageBox.Cancel)
if res == QMessageBox.Cancel:
return
# on rename delete original entry first
if all([self.conn_name_orig is not None,
self.conn_name_orig != conn_name]):
self.settings.remove(key_orig)
self.settings.setValue(keyurl, conn_url)
self.settings.setValue('/MetaSearch/selected', conn_name)
QDialog.accept(self)
def reject(self):
"""back out of dialogue"""
QDialog.reject(self)
def loadAPIFile(self):
settings = QSettings()
lastDirPath = settings.value("pythonConsole/lastDirAPIPath", "", type=str)
fileAPI = QFileDialog.getOpenFileName(
self, "Open API File", lastDirPath, "API file (*.api)")
if fileAPI:
self.addAPI(fileAPI)
lastDirPath = QFileInfo(fileAPI).path()
settings.setValue("pythonConsole/lastDirAPIPath", fileAPI)
def commitClicked(self):
feature = self.listWidget.currentItem().feature
geom = None
self.attributesTable.setRowCount(len(feature))
for idx, attrname in enumerate(feature):
value = feature[attrname]
font = QFont()
font.setBold(True)
font.setWeight(75)
item = QTableWidgetItem(attrname)
item.setFont(font)
self.attributesTable.setItem(idx, 0, item);
self.attributesTable.setItem(idx, 1, QTableWidgetItem(str(value)));
if geom is None:
try:
geom = QgsGeometry.fromWkt(value)
except:
pass
self.attributesTable.resizeRowsToContents()
self.attributesTable.horizontalHeader().setMinimumSectionSize(150)
self.attributesTable.horizontalHeader().setStretchLastSection(True)
settings = QSettings()
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
types = ["Point", "LineString", "Polygon"]
layers = []
if geom is not None:
geomtype = types[int(geom.type())]
layer = loadLayerNoCrsDialog(geomtype + "?crs=EPSG:4326", "temp", "memory")
pr = layer.dataProvider()
feat = QgsFeature()
feat.setGeometry(geom)
pr.addFeatures([feat])
layer.updateExtents()
layer.selectAll()
layer.setExtent(layer.boundingBoxOfSelected())
layer.invertSelection()
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol.setColor(Qt.green)
symbol.setAlpha(0.5)
if QGis.QGIS_VERSION_INT < 29900:
layer.setRendererV2(QgsSingleSymbolRendererV2(symbol))
else:
layer.setRenderer(QgsSingleSymbolRenderer(symbol))
self.mapCanvas.setRenderFlag(False)
self.mapCanvas.setLayerSet([QgsMapCanvasLayer(layer)])
QgsMapLayerRegistry.instance().addMapLayer(layer, False)
self.mapCanvas.setExtent(layer.extent())
self.mapCanvas.setRenderFlag(True)
layers.append(layer)
else:
self.mapCanvas.setLayerSet([])
settings.setValue('/Projections/defaultBehaviour', prjSetting)
def saveResults(self, saveAll=False):
currentItem = self.resultsTree.currentItem()
if not saveAll and not hasattr(currentItem, "result"):
QMessageBox.warning(self, "Save results", "No test item selected")
return
settings = QSettings('Boundless', 'qgistester')
lastDirectory = settings.value('lastDirectory', '.')
fileName, __ = QFileDialog.getSaveFileName(self,
self.tr('Save file'),
lastDirectory,
self.tr('HTML files (*.html)'))
# Needed to handle different return values in Qt4 and Qt5
if isinstance(fileName, tuple):
fileName = fileName[0]
if fileName == '':
return
if not fileName.lower().endswith('.html'):
fileName += '.html'
settings.setValue('lastDirectory', QFileInfo(fileName).absoluteDir().absolutePath())
out = '<html><head>'
out += '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /></head><body>'
if saveAll:
for i in range(self.resultsTree.topLevelItemCount()):
groupItem = self.resultsTree.topLevelItem(i)
out += '<h3>{}</h3>'.format(groupItem.text(0))
out += '<ul>'
for j in range(groupItem.childCount()):
results = groupItem.child(j).result
out += '<li>[{}] {}'.format(self.resultTag[results.status], results.test.name)
if results.status not in [results.SKIPPED, results.PASSED]:
out += '<p>Failed at step {} with message</p>'.format(results.errorStep)
out += '<code>{}</code>'.format(results.errorMessage)
out += '</li>'
out += '</ul>'
else:
results = self.resultsTree.currentItem().result
out += '<h3>{}</h3>'.format(results.test.group)
out += '<ul>'
out += '<li>[{}] {}'.format(self.resultTag[results.status], results.test.name)
if results.status not in [results.SKIPPED, results.PASSED]:
out += '<p>Failed at step {} with message</p>'.format(results.errorStep)
out += '<code>{}</code>'.format(results.errorMessage)
out += '</li></ul>'
out += '</body></html>'
with codecs.open(fileName, 'w', encoding='utf-8') as f:
f.write(out)
def closeEvent(self, e):
self.unregisterAllActions()
# clear preview, this will delete the layer in preview tab
self.preview.loadPreview(None)
# save the window state
settings = QSettings()
settings.setValue("/DB_Manager/mainWindow/windowState", self.saveState())
settings.setValue("/DB_Manager/mainWindow/geometry", self.saveGeometry())
QMainWindow.closeEvent(self, e)
def processAlgorithm(self, progress):
settings = QSettings()
initial_method_setting = settings.value(settings_method_key, 1)
method = self.getParameterValue(self.METHOD)
if method != 0:
settings.setValue(settings_method_key, method)
try:
self.doCheck(progress)
finally:
settings.setValue(settings_method_key, initial_method_setting)
def selectDirectory(self):
settings = QSettings()
if settings.contains('/Processing/LastBatchOutputPath'):
lastDir = str(settings.value('/Processing/LastBatchOutputPath'))
else:
lastDir = ''
dirName = QFileDialog.getExistingDirectory(self,
self.tr('Select directory'), lastDir, QFileDialog.ShowDirsOnly)
if dirName:
self.table.cellWidget(self.row, self.col).setValue(dirName)
settings.setValue('/Processing/LastBatchOutputPath', dirName)
def loadLayerNoCrsDialog(filename, name=None):
'''
Tries to load a layer from the given file
Same as the loadLayer method, but it does not ask for CRS, regardless of current
configuration in QGIS settings
'''
settings = QSettings()
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
try:
layer = loadLayer(filename, name)
finally:
settings.setValue('/Projections/defaultBehaviour', prjSetting)
return layer
def export_view(self):
'''
Export current view to PDF
'''
# Load template from file
s = QSettings()
f = s.value("cadastre/composerTemplateFile", '', type=str)
if not os.path.exists(f):
f = os.path.join(str(Path(__file__).resolve().parent), 'composers', 'paysage_a4.qpt')
s.setValue("cadastre/composerTemplateFile", f)
QApplication.setOverrideCursor(Qt.WaitCursor)
template_content = None
with open(f, 'rt', encoding="utf-8") as ff:
template_content = ff.read()
if not template_content:
return
d = QDomDocument()
d.setContent(template_content)
c = QgsPrintLayout(QgsProject.instance())
c.loadFromTemplate(d, QgsReadWriteContext() )
# Set scale and extent
cm=c.referenceMap()
canvas = self.iface.mapCanvas()
extent = canvas.extent()
scale = canvas.scale()
if extent:
cm.zoomToExtent(extent)
if scale:
cm.setScale(scale)
# Export
tempDir = s.value("cadastre/tempDir", '%s' % tempfile.gettempdir(), type=str)
self.targetDir = tempfile.mkdtemp('', 'cad_export_', tempDir)
temp = int(time()*100)
temppath = os.path.join(tempDir, 'export_cadastre_%s.pdf' % temp)
exporter = QgsLayoutExporter(c)
exportersettings = QgsLayoutExporter.PdfExportSettings()
exportersettings.dpi = 300
exportersettings.forceVectorOutput = True
exportersettings.rasterizeWholeImage = False #rasterizeWholeImage = false
exporter.exportToPdf(temppath, exportersettings )
QApplication.restoreOverrideCursor()
if os.path.exists(temppath):
cadastre_common.openFile(temppath)
def __init__(self):
""" Initialize data objects, starts fetching if appropriate, and warn about/removes obsolete plugins """
QObject.__init__(self) # initialize QObject in order to to use self.tr()
repositories.load()
plugins.getAllInstalled()
if repositories.checkingOnStart() and repositories.timeForChecking() and repositories.allEnabled():
# start fetching repositories
self.statusLabel = QLabel(self.tr("Looking for new plugins...") + " ", iface.mainWindow().statusBar())
iface.mainWindow().statusBar().insertPermanentWidget(0, self.statusLabel)
self.statusLabel.linkActivated.connect(self.showPluginManagerWhenReady)
repositories.checkingDone.connect(self.checkingDone)
for key in repositories.allEnabled():
repositories.requestFetching(key)
else:
# no fetching at start, so mark all enabled repositories as requesting to be fetched.
for key in repositories.allEnabled():
repositories.setRepositoryData(key, "state", 3)
# look for obsolete plugins (the user-installed one is newer than core one)
for key in plugins.obsoletePlugins:
plugin = plugins.localCache[key]
msg = QMessageBox()
msg.setIcon(QMessageBox.Warning)
msg.setWindowTitle(self.tr("QGIS Python Plugin Installer"))
msg.addButton(self.tr("Uninstall (recommended)"), QMessageBox.AcceptRole)
msg.addButton(self.tr("I will uninstall it later"), QMessageBox.RejectRole)
msg.setText(
"%s <b>%s</b><br/><br/>%s"
% (
self.tr("Obsolete plugin:"),
plugin["name"],
self.tr(
"QGIS has detected an obsolete plugin that masks its more recent version shipped with this copy of QGIS. This is likely due to files associated with a previous installation of QGIS. Do you want to remove the old plugin right now and unmask the more recent version?"
),
)
)
msg.exec_()
if not msg.result():
# uninstall, update utils and reload if enabled
self.uninstallPlugin(key, quiet=True)
updateAvailablePlugins()
settings = QSettings()
if settings.value("/PythonPlugins/" + key, False, type=bool):
settings.setValue("/PythonPlugins/watchDog/" + key, True)
loadPlugin(key)
startPlugin(key)
settings.remove("/PythonPlugins/watchDog/" + key)
def loadLayerNoCrsDialog(filename, name=None):
""" Tries to load a layer from the given file
Same as the loadLayer method, but it does not ask for CRS, regardless of
the current configuration in QGIS settings
:param filename: the path to the file to load.
:param name: the name to use for adding the layer to the current project.
If not passed or None, it will use the filename basename
"""
settings = QSettings()
prjSetting = settings.value("/Projections/defaultBehaviour")
settings.setValue("/Projections/defaultBehaviour", "")
layer = loadLayer(filename, name)
settings.setValue("/Projections/defaultBehaviour", prjSetting)
return layer
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue('QgisModelBaker/ili2db/ilifile',
configuration.ilifile)
settings.setValue('QgisModelBaker/ili2db/epsg', self.epsg)
settings.setValue('QgisModelBaker/importtype',
self.type_combo_box.currentData().name)
mode = self.type_combo_box.currentData()
db_factory = self.db_simple_factory.create_factory(mode)
config_manager = db_factory.get_db_command_config_manager(
configuration)
config_manager.save_config_in_qsettings()
def accept(self, *args, **kwargs):
# Save keys
auth.set_app_id_and_api_key(self.appIDLineEdit.text(),
self.apiKeyLineEdit.text())
# Save settings
s = QSettings()
# warning enabled
s.setValue("traveltime_platform/warning_enabled",
self.warningGroupBox.isChecked())
# warning limit
s.setValue("traveltime_platform/warning_limit",
self.warningSpinBox.value())
# logs calls
s.setValue("traveltime_platform/log_calls",
self.logCallsCheckBox.isChecked())
# disable https
s.setValue("traveltime_platform/disable_https",
self.disableHttpsCheckBox.isChecked())
super().accept(*args, **kwargs)
def load(fileName, name=None, crs=None, style=None):
"""Loads a layer/table into the current project, given its file.
"""
if fileName is None:
return
prjSetting = None
settings = QSettings()
if crs is not None:
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
if name is None:
name = os.path.split(fileName)[1]
qgslayer = QgsVectorLayer(fileName, name, 'ogr')
if qgslayer.isValid():
if crs is not None and qgslayer.crs() is None:
qgslayer.setCrs(crs, False)
if style is None:
if qgslayer.geometryType() == QgsWkbTypes.PointGeometry:
style = ProcessingConfig.getSetting(
ProcessingConfig.VECTOR_POINT_STYLE)
elif qgslayer.geometryType() == QgsWkbTypes.LineGeometry:
style = ProcessingConfig.getSetting(
ProcessingConfig.VECTOR_LINE_STYLE)
else:
style = ProcessingConfig.getSetting(
ProcessingConfig.VECTOR_POLYGON_STYLE)
qgslayer.loadNamedStyle(style)
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
else:
qgslayer = QgsRasterLayer(fileName, name)
if qgslayer.isValid():
if crs is not None and qgslayer.crs() is None:
qgslayer.setCrs(crs, False)
if style is None:
style = ProcessingConfig.getSetting(
ProcessingConfig.RASTER_STYLE)
qgslayer.loadNamedStyle(style)
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
iface.legendInterface().refreshLayerLegend(qgslayer)
else:
if prjSetting:
settings.setValue('/Projections/defaultBehaviour', prjSetting)
raise RuntimeError(
'Could not load layer: ' + unicode(fileName) +
'\nCheck the processing framework log to look for errors')
if prjSetting:
settings.setValue('/Projections/defaultBehaviour', prjSetting)
return qgslayer
def save_configuration(self, configuration):
settings = QSettings()
settings.setValue("QgisModelBaker/ili2pg/xtffile_import",
configuration.xtffile)
settings.setValue("QgisModelBaker/ili2pg/deleteData",
configuration.delete_data)
settings.setValue("QgisModelBaker/importtype",
self.type_combo_box.currentData().name)
mode = self.type_combo_box.currentData()
db_factory = self.db_simple_factory.create_factory(mode)
config_manager = db_factory.get_db_command_config_manager(
configuration)
config_manager.save_config_in_qsettings()
def accept(self):
'''Accept the settings and save them for next time.'''
settings = QSettings()
self.nominatimURL = self.nomServiceLineEdit.text().strip()
settings.setValue('/BulkNominatim/URL', self.nominatimURL)
try:
self.maxAddress = int(self.maxRequestLineEdit.text())
except:
self.maxAddress = 100
self.maxRequestLineEdit.setText(str(self.maxAddress))
settings.setValue('/BulkNominatim/maxAddress', self.maxAddress)
self.levelOfDetail = self.detailSpinBox.value()
settings.setValue('/BulkNominatim/levelOfDetail', self.levelOfDetail)
self.close()
def save_defaults():
"""Saves the default values"""
settings = QSettings()
settings.beginGroup("CityJSON Loader")
settings.beginWriteArray("semantic_colors")
i = 0
for surface, colors in semantic_colors.items():
settings.setArrayIndex(i)
settings.setValue("surface", surface)
settings.setValue("diffuse", get_color_int(colors["diffuse"]))
settings.setValue("ambient", get_color_int(colors["ambient"]))
settings.setValue("specular", get_color_int(colors["specular"]))
i = i + 1
settings.endArray()
settings.endGroup()
def recordSearch(self, postgisSearch):
searchId = postgisSearch.searchId
# always remove existing search with same id
self.deleteSearch(searchId)
settings = QSettings()
settings.setValue(self.searchSetting(searchId, 'searchName'),
postgisSearch.searchName)
settings.setValue(self.searchSetting(searchId, 'expression'),
postgisSearch.expression)
settings.setValue(self.searchSetting(searchId, 'priority'),
postgisSearch.priority)
settings.setValue(self.searchSetting(searchId, 'srid'),
postgisSearch.srid)
# Project
ids = self.settings.value("postgisSearches")
if searchId not in ids:
ids.append(searchId)
self.settings.setValue("postgisSearches", ids)
return True, ""
def addLayerNoCrsDialog(layer, loadInLegend=True):
'''
Tries to add a layer from layer object
Same as the addLayer method, but it does not ask for CRS, regardless of current
configuration in QGIS settings
'''
settings = QSettings()
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
# QGIS3
prjSetting3 = settings.value('/Projections/defaultBehavior')
settings.setValue('/Projections/defaultBehavior', '')
layer = addLayer(layer, loadInLegend)
settings.setValue('/Projections/defaultBehaviour', prjSetting)
settings.setValue('/Projections/defaultBehavior', prjSetting3)
return layer
def loadLayerNoCrsDialog(filename, name=None, provider=None):
'''
Tries to load a layer from the given file
Same as the loadLayer method, but it does not ask for CRS, regardless of current
configuration in QGIS settings
'''
settings = QSettings()
prjSetting = settings.value('/Projections/defaultBehaviour')
settings.setValue('/Projections/defaultBehaviour', '')
# QGIS3:
prjSetting3 = settings.value('/Projections/defaultBehavior')
settings.setValue('/Projections/defaultBehavior', '')
layer = loadLayer(filename, name, provider)
settings.setValue('/Projections/defaultBehaviour', prjSetting)
settings.setValue('/Projections/defaultBehavior', prjSetting3)
return layer
def add_mosaics_to_qgis_project(mosaics,
name,
proc="default",
ramp="",
zmin=0,
zmax=22,
add_xyz_server=False):
mosaic_names = [(mosaic_title(mosaic), mosaic[NAME]) for mosaic in mosaics]
tile_url = f"{mosaics[0][LINKS][TILES]}&ua={user_agent()}"
uri = f"type=xyz&url={tile_url}&zmin={zmin}&zmax={zmax}"
layer = QgsRasterLayer(uri, name, "wms")
layer.setCustomProperty(PLANET_CURRENT_MOSAIC, mosaic_title(mosaics[0]))
layer.setCustomProperty(PLANET_MOSAIC_PROC, proc)
layer.setCustomProperty(PLANET_MOSAIC_RAMP, ramp)
layer.setCustomProperty(PLANET_MOSAIC_DATATYPE, mosaics[0][DATATYPE])
layer.setCustomProperty(PLANET_MOSAICS, json.dumps(mosaic_names))
QgsProject.instance().addMapLayer(layer)
layer.setCustomProperty("embeddedWidgets/count", 1)
layer.setCustomProperty("embeddedWidgets/0/id", WIDGET_PROVIDER_NAME)
view = iface.layerTreeView()
view.layerTreeModel().refreshLayerLegend(view.currentNode())
view.currentNode().setExpanded(True)
if add_xyz_server:
s = QSettings()
s.setValue(f"qgis/connections-xyz/{name}/zmin", zmin)
s.setValue(f"qgis/connections-xyz/{name}/zmax", zmax)
s.setValue(f"qgis/connections-xyz/{name}/username", "")
s.setValue(f"qgis/connections-xyz/{name}/password", "")
s.setValue(f"qgis/connections-xyz/{name}/authcfg", "")
procparam = quote(f"&proc={proc}") if proc != "rgb" else ""
rampparam = quote(f"&color={ramp}") if ramp else ""
full_uri = f"{tile_url}{procparam}{rampparam}"
s.setValue(
f"qgis/connections-xyz/{name}/url",
full_uri.replace(PlanetClient.getInstance().api_key(), ""),
)
def load(self):
""" populate the mRepositories dict"""
self.mRepositories = {}
settings = QSettings()
settings.beginGroup(reposGroup)
# first, update repositories in QSettings if needed
officialRepoPresent = False
nextGISRepoPresent = False
for key in settings.childGroups():
url = settings.value(key + "/url", "", type=unicode)
if url == officialRepo[1]:
officialRepoPresent = True
if url == officialRepo[2]:
settings.setValue(key + "/url",
officialRepo[1]) # correct a depreciated url
officialRepoPresent = True
if url == nextGISRepo[1]:
nextGISRepoPresent = True
if not officialRepoPresent:
settings.setValue(officialRepo[0] + "/url", officialRepo[1])
if not nextGISRepoPresent:
settings.setValue(nextGISRepo[0] + "/url", nextGISRepo[1])
for key in settings.childGroups():
self.mRepositories[key] = {}
self.mRepositories[key]["url"] = settings.value(key + "/url",
"",
type=unicode)
self.mRepositories[key]["authcfg"] = settings.value(key +
"/authcfg",
"",
type=unicode)
self.mRepositories[key]["enabled"] = settings.value(key +
"/enabled",
True,
type=bool)
self.mRepositories[key]["valid"] = settings.value(key + "/valid",
True,
type=bool)
self.mRepositories[key]["Relay"] = Relay(key)
self.mRepositories[key]["xmlData"] = None
self.mRepositories[key]["state"] = 0
self.mRepositories[key]["error"] = ""
settings.endGroup()
def checkAccessControlIsActive(self):
settings = QSettings("PostNAS", "PostNAS-Suche")
if (settings.contains("accessControl") == True):
if (settings.value("accessControl", 0) == 1):
if (self.checkAccessTable() == False):
settings.setValue("accessControl", 0)
return False
else:
return True
else:
return False
else:
if (self.checkAccessTable() == True):
settings.setValue("accessControl", 1)
return True
else:
settings.setValue("accessControl", 0)
return False
def editRepository(self, reposName):
""" edit repository connection """
if not reposName:
return
reposName = reposName.decode('utf-8')
checkState = {False: Qt.Unchecked, True: Qt.Checked}
dlg = QgsPluginInstallerRepositoryDialog(iface.mainWindow())
dlg.editName.setText(reposName)
dlg.editURL.setText(repositories.all()[reposName]["url"])
dlg.editAuthCfg.setText(repositories.all()[reposName]["authcfg"])
dlg.editParams.setText(repositories.urlParams())
dlg.checkBoxEnabled.setCheckState(checkState[repositories.all()[reposName]["enabled"]])
if repositories.all()[reposName]["valid"]:
dlg.checkBoxEnabled.setEnabled(True)
dlg.labelInfo.setText("")
else:
dlg.checkBoxEnabled.setEnabled(False)
dlg.labelInfo.setText(self.tr("This repository is blocked due to incompatibility with your QGIS version"))
dlg.labelInfo.setFrameShape(QFrame.Box)
if not dlg.exec_():
return # nothing to do if cancelled
for i in repositories.all().values():
if dlg.editURL.text().strip() == i["url"] and dlg.editURL.text().strip() != repositories.all()[reposName]["url"]:
iface.pluginManagerInterface().pushMessage(self.tr("Unable to add another repository with the same URL!"), QgsMessageBar.WARNING)
return
# delete old repo from QSettings and create new one
settings = QSettings()
settings.beginGroup(reposGroup)
settings.remove(reposName)
newName = dlg.editName.text()
if newName in repositories.all() and newName != reposName:
newName = newName + "(2)"
settings.setValue(newName + "/url", dlg.editURL.text().strip())
settings.setValue(newName + "/authcfg", dlg.editAuthCfg.text().strip())
settings.setValue(newName + "/enabled", bool(dlg.checkBoxEnabled.checkState()))
if dlg.editAuthCfg.text().strip() != repositories.all()[reposName]["authcfg"]:
repositories.all()[reposName]["authcfg"] = dlg.editAuthCfg.text().strip()
if dlg.editURL.text().strip() == repositories.all()[reposName]["url"] and dlg.checkBoxEnabled.checkState() == checkState[repositories.all()[reposName]["enabled"]]:
repositories.rename(reposName, newName)
self.exportRepositoriesToManager()
return # nothing else to do if only repository name was changed
plugins.removeRepository(reposName)
self.reloadAndExportData()
def addRepository(self):
""" add new repository connection """
dlg = QgsPluginInstallerRepositoryDialog(iface.mainWindow())
dlg.editParams.setText(repositories.urlParams())
dlg.checkBoxEnabled.setCheckState(Qt.Checked)
if not dlg.exec_():
return
for i in repositories.all().values():
if dlg.editURL.text().strip() == i["url"]:
iface.pluginManagerInterface().pushMessage(self.tr("Unable to add another repository with the same URL!"), QgsMessageBar.WARNING)
return
settings = QSettings()
settings.beginGroup(reposGroup)
reposName = dlg.editName.text()
reposURL = dlg.editURL.text().strip()
if reposName in repositories.all():
reposName = reposName + "(2)"
# add to settings
settings.setValue(reposName + "/url", reposURL)
settings.setValue(reposName + "/authcfg", dlg.editAuthCfg.text().strip())
settings.setValue(reposName + "/enabled", bool(dlg.checkBoxEnabled.checkState()))
# refresh lists and populate widgets
plugins.removeRepository(reposName)
self.reloadAndExportData()
def save_settings(self):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/wizards/building_load_data_type',
'digitizing' if self.rad_digitizing.isChecked() else 'refactor')
def setGdalBinPath(path):
settings = QSettings()
settings.setValue("/GdalTools/gdalPath", path)
def store(self, iniFile=None, properties=None):
if iniFile is not None:
s = QSettings(iniFile, QSettings.IniFormat)
else:
s = QSettings()
if properties is None:
properties = self.properties()
s.beginGroup('PosiView')
s.remove('Mobiles')
s.remove('DataProvider')
idx = 0
s.beginWriteArray('Mobiles')
try:
for v in list(properties['Mobiles'].values()):
s.setArrayIndex(idx)
for k1, v1 in list(v.items()):
s.setValue(k1, str(v1))
idx += 1
except KeyError:
pass
s.endArray()
idx = 0
s.beginWriteArray('DataProvider')
try:
for v in list(properties['Provider'].values()):
s.setArrayIndex(idx)
for k1, v1 in list(v.items()):
s.setValue(k1, str(v1))
idx += 1
except KeyError:
pass
s.endArray()
s.setValue('Mission/Cruise', properties['Mission']['cruise'])
s.setValue('Mission/Dive', properties['Mission']['dive'])
s.setValue('Mission/Station', properties['Mission']['station'])
s.setValue('Recorder/Path', properties['RecorderPath'])
s.setValue('Recorder/AutoRecord', properties['AutoRecord'])
s.setValue('Misc/NotifyDuration', properties['NotifyDuration'])
s.setValue('Misc/ShowUtcClock', properties['ShowUtcClock'])
s.setValue('Misc/DefaultFormat', properties['DefaultFormat'])
s.endGroup()
def addServicesForGeodataServer(name, url, authcfg):
s = QSettings()
s.setValue('qgis/WMS/{0}/password'.format(name), '')
s.setValue('qgis/WMS/{0}/username'.format(name), '')
s.setValue('qgis/WMS/{0}/authcfg'.format(name), authcfg)
s.setValue('qgis/connections-wms/{0}/dpiMode'.format(name), 7)
s.setValue('qgis/connections-wms/{0}/ignoreAxisOrientation'.format(name), False)
s.setValue('qgis/connections-wms/{0}/ignoreGetFeatureInfoURI'.format(name), False)
s.setValue('qgis/connections-wms/{0}/ignoreGetMapURI'.format(name), False)
s.setValue('qgis/connections-wms/{0}/invertAxisOrientation'.format(name), False)
s.setValue('qgis/connections-wms/{0}/referer'.format(name), '')
s.setValue('qgis/connections-wms/{0}/smoothPixmapTransform'.format(name), False)
s.setValue('qgis/connections-wms/{0}/url'.format(name), url + '/wms')
s.setValue('qgis/WFS/{0}/username'.format(name), '')
s.setValue('qgis/WFS/{0}/password'.format(name), '')
s.setValue('qgis/connections-wfs/{0}/referer'.format(name), '')
s.setValue('qgis/connections-wfs/{0}/url'.format(name), url + '/wfs')
s.setValue('qgis/WFS/{0}/authcfg'.format(name), authcfg)
def setFilter(self, typeName, aFilter):
settings = QSettings()
settings.setValue("/GdalTools/" + typeName + "FileFilter", aFilter)
class settings:
def __init__(self):
self.dlg = settingsDiag()
self.settings = QSettings('ManySplendid', 'HabitatFitness')
def run(self):
self.dlg.show()
result = self.dlg.exec_()
if result == 1:
self.settings.setValue('depAttr',
self.dlg.depthAttrCombo.currentText())
self.settings.setValue('xAttr',
self.dlg.xDirAttrCombo.currentText())
self.settings.setValue('yAttr',
self.dlg.yDirAttrCombo.currentText())
self.settings.setValue('bedDiaAttr',
self.dlg.diameterAttrCombo.currentText())
self.settings.setValue('depthUnit',
self.dlg.depthUnit.currentText())
self.settings.setValue('xDirUnit', self.dlg.xDirUnit.currentText())
self.settings.setValue('yDirUnit', self.dlg.yDirUnit.currentText())
self.settings.setValue('useBedDia',
self.dlg.useDiameterChkBox.checkState())
def setAttribute(self, attributeList):
self.dlg.setAttributes(attributeList)
def setHelpPath(path):
settings = QSettings()
settings.setValue("/GdalTools/helpPath", path)
class FmvOptions(QDialog, Ui_OptionsDialog):
""" Options Dialog """
def __init__(self):
""" Contructor """
QDialog.__init__(self)
self.setupUi(self)
self.settings = QSettings()
self.NameSpace = getNameSpace()
self.sl_Size.enterEvent = self.showSizeTip
draw.setValues(self)
def showSizeTip(self, _):
""" Size Slider Tooltip Trick """
self.style = self.sl_Size.style()
self.opt = QStyleOptionSlider()
self.sl_Size.initStyleOption(self.opt)
rectHandle = self.style.subControlRect(self.style.CC_Slider, self.opt,
self.style.SC_SliderHandle,
self.sl_Size)
self.tip_offset = QPoint(5, 15)
pos_local = rectHandle.topLeft() + self.tip_offset
pos_global = self.sl_Size.mapToGlobal(pos_local)
QToolTip.showText(pos_global, str(self.sl_Size.value()) + " px", self)
def SaveOptions(self):
""" Save Options """
# Magnifier Glass #
# Shape Type
if self.rB_Square_m.isChecked():
self.settings.setValue(self.NameSpace + "/Options/magnifier/shape",
0) # Square
else:
self.settings.setValue(self.NameSpace + "/Options/magnifier/shape",
1) # Circle
self.settings.setValue(self.NameSpace + "/Options/magnifier/size",
self.sl_Size.value())
self.settings.setValue(self.NameSpace + "/Options/magnifier/factor",
self.sb_factor.value())
# Drawings #
self.settings.setValue(
self.NameSpace + "/Options/drawings/polygons/width",
self.poly_width.value())
self.settings.setValue(
self.NameSpace + "/Options/drawings/polygons/pen",
self.poly_pen.color())
self.settings.setValue(
self.NameSpace + "/Options/drawings/polygons/brush",
self.poly_brush.color())
self.settings.setValue(
self.NameSpace + "/Options/drawings/points/width",
self.point_width.value())
self.settings.setValue(self.NameSpace + "/Options/drawings/points/pen",
self.point_pen.color())
self.settings.setValue(
self.NameSpace + "/Options/drawings/lines/width",
self.lines_width.value())
self.settings.setValue(self.NameSpace + "/Options/drawings/lines/pen",
self.lines_pen.color())
self.settings.setValue(
self.NameSpace + "/Options/drawings/measures/width",
self.measures_width.value(),
)
self.settings.setValue(
self.NameSpace + "/Options/drawings/measures/pen",
self.measures_pen.color())
self.settings.setValue(
self.NameSpace + "/Options/drawings/measures/brush",
self.measures_brush.color(),
)
draw.setValues(self)
# UpdateStylesDrawLayers(self.NameSpace)
self.close()
return
class NewSchematisationWizard(QWizard):
"""New schematisation wizard."""
def __init__(self, plugin_dock, parent=None):
super().__init__(parent)
self.settings = QSettings()
self.setWizardStyle(QWizard.ClassicStyle)
self.plugin_dock = plugin_dock
self.working_dir = self.plugin_dock.plugin_settings.working_dir
self.tc = ThreediCalls(self.plugin_dock.threedi_api)
self.new_schematisation = None
self.new_local_schematisation = None
self.schematisation_name_page = SchematisationNamePage(
self.plugin_dock.organisations, self)
self.schematisation_explain_page = SchematisationExplainPage(self)
self.schematisation_settings_page = SchematisationSettingsPage(self)
self.addPage(self.schematisation_name_page)
self.addPage(self.schematisation_explain_page)
self.addPage(self.schematisation_settings_page)
self.setButtonText(QWizard.FinishButton, "Create schematisation")
self.finish_btn = self.button(QWizard.FinishButton)
self.finish_btn.clicked.connect(self.create_schematisation)
self.cancel_btn = self.button(QWizard.CancelButton)
self.cancel_btn.clicked.connect(self.cancel_wizard)
self.setWindowTitle("New schematisation")
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.setOption(QWizard.HaveNextButtonOnLastPage, False)
self.resize(
self.settings.value("threedi/new_schematisation_wizard_size",
QSize(790, 700)))
def create_schematisation(self):
if self.schematisation_name_page.field("from_spatialite"):
self.create_schematisation_from_spatialite()
else:
self.create_new_schematisation()
def create_new_schematisation(self):
"""Get settings from the wizard and create new schematisation (locally and remotely)."""
if not self.schematisation_settings_page.settings_are_valid:
return
name, tags, owner = self.schematisation_name_page.main_widget.get_new_schematisation_name_data(
)
schematisation_settings = self.schematisation_settings_page.main_widget.collect_new_schematisation_settings(
)
raster_filepaths = self.schematisation_settings_page.main_widget.rasters_filepaths(
)
aggregation_settings_queries = self.schematisation_settings_page.main_widget.aggregation_settings_queries
try:
schematisation = self.tc.create_schematisation(name,
owner,
tags=tags)
local_schematisation = LocalSchematisation(
self.working_dir,
schematisation.id,
name,
parent_revision_number=0,
create=True)
wip_revision = local_schematisation.wip_revision
sqlite_filename = f"{name}.sqlite"
sqlite_filepath = os.path.join(wip_revision.schematisation_dir,
sqlite_filename)
shutil.copyfile(EMPTY_DB_PATH, sqlite_filepath)
wip_revision.sqlite_filename = sqlite_filename
for raster_filepath in raster_filepaths:
if raster_filepath:
new_raster_filepath = os.path.join(
wip_revision.raster_dir,
os.path.basename(raster_filepath))
shutil.copyfile(raster_filepath, new_raster_filepath)
for table_name, table_settings in schematisation_settings.items():
table_layer = sqlite_layer(wip_revision.sqlite,
table_name,
geom_column=None)
table_layer.startEditing()
table_fields = table_layer.fields()
table_fields_names = {f.name() for f in table_fields}
new_settings_feat = QgsFeature(table_fields)
for field_name, field_value in table_settings.items():
if field_name in table_fields_names:
new_settings_feat[field_name] = field_value
table_layer.addFeature(new_settings_feat)
success = table_layer.commitChanges()
if not success:
commit_errors = table_layer.commitErrors()
errors_str = "\n".join(commit_errors)
error = CommitErrors(
f"{table_name} commit errors:\n{errors_str}")
raise error
time.sleep(0.5)
execute_sqlite_queries(wip_revision.sqlite,
aggregation_settings_queries)
self.new_schematisation = schematisation
self.new_local_schematisation = local_schematisation
msg = f"Schematisation '{name} ({schematisation.id})' created!"
self.plugin_dock.communication.bar_info(msg,
log_text_color=QColor(
Qt.darkGreen))
except ApiException as e:
self.new_schematisation = None
self.new_local_schematisation = None
error_msg = extract_error_message(e)
self.plugin_dock.communication.bar_error(error_msg,
log_text_color=QColor(
Qt.red))
except Exception as e:
self.new_schematisation = None
self.new_local_schematisation = None
error_msg = f"Error: {e}"
self.plugin_dock.communication.bar_error(error_msg,
log_text_color=QColor(
Qt.red))
@staticmethod
def get_paths_from_sqlite(sqlite_path):
"""Search SQLite database tables for attributes with file paths."""
paths = defaultdict(dict)
for table_name, raster_info in SchematisationRasterReferences.raster_reference_tables(
).items():
settings_fields = list(raster_info.keys())
settings_lyr = sqlite_layer(sqlite_path,
table_name,
geom_column=None)
if not settings_lyr.isValid():
raise SpatialiteError(
f"'{table_name}' table could not be loaded from {sqlite_path}"
)
try:
set_feat = next(settings_lyr.getFeatures())
except StopIteration:
continue
for field_name in settings_fields:
field_value = set_feat[field_name]
paths[table_name][
field_name] = field_value if field_value else None
return paths
def create_schematisation_from_spatialite(self):
"""Get settings from existing Spatialite and create new schematisation (locally and remotely)."""
try:
name, tags, owner = self.schematisation_name_page.main_widget.get_new_schematisation_name_data(
)
schematisation = self.tc.create_schematisation(name,
owner,
tags=tags)
local_schematisation = LocalSchematisation(
self.working_dir,
schematisation.id,
name,
parent_revision_number=0,
create=True)
wip_revision = local_schematisation.wip_revision
sqlite_filename = f"{name}.sqlite"
sqlite_filepath = os.path.join(wip_revision.schematisation_dir,
sqlite_filename)
src_db = self.schematisation_name_page.field("spatialite_path")
raster_paths = self.get_paths_from_sqlite(src_db)
src_dir = os.path.dirname(src_db)
shutil.copyfile(src_db, sqlite_filepath)
wip_revision.sqlite_filename = sqlite_filename
new_paths = defaultdict(dict)
missing_rasters = []
for table_name, raster_paths_info in raster_paths.items():
for raster_name, raster_rel_path in raster_paths_info.items():
if not raster_rel_path:
continue
raster_full_path = os.path.join(src_dir, raster_rel_path)
if os.path.exists(raster_full_path):
new_raster_filepath = os.path.join(
wip_revision.raster_dir,
os.path.basename(raster_rel_path))
shutil.copyfile(raster_full_path, new_raster_filepath)
new_paths[table_name][raster_name] = os.path.relpath(
new_raster_filepath,
wip_revision.schematisation_dir)
else:
new_paths[table_name][raster_name] = None
missing_rasters.append((raster_name, raster_rel_path))
if missing_rasters:
missing_rasters.sort(key=itemgetter(0))
missing_rasters_string = "\n".join(
f"{rname}: {rpath}" for rname, rpath in missing_rasters)
warn_msg = f"Warning: the following raster files where not found:\n{missing_rasters_string}"
self.plugin_dock.communication.show_warn(warn_msg)
self.plugin_dock.communication.bar_warn(
"Schematisation creation aborted!")
return
for settings_table_name, new_raster_paths_info in new_paths.items(
):
settings_layer = sqlite_layer(wip_revision.sqlite,
settings_table_name,
geom_column=None)
settings_layer.startEditing()
s_fields = settings_layer.fields()
s_feat = next(settings_layer.getFeatures())
new_values = dict()
for field_name, field_value in new_raster_paths_info.items():
f_idx = s_fields.lookupField(field_name)
if f_idx > 0 and field_value is not None:
new_values[f_idx] = field_value
settings_layer.changeAttributeValues(s_feat.id(), new_values)
success = settings_layer.commitChanges()
if not success:
commit_errors = settings_layer.commitErrors()
errors_str = "\n".join(commit_errors)
error = CommitErrors(
f"{settings_table_name} commit errors:\n{errors_str}")
raise error
time.sleep(0.5)
self.new_local_schematisation = local_schematisation
msg = f"Schematisation '{name} ({schematisation.id})' created!"
self.plugin_dock.communication.bar_info(msg,
log_text_color=QColor(
Qt.darkGreen))
except ApiException as e:
self.new_schematisation = None
self.new_local_schematisation = None
error_msg = extract_error_message(e)
self.plugin_dock.communication.bar_error(error_msg,
log_text_color=QColor(
Qt.red))
except Exception as e:
self.new_schematisation = None
self.new_local_schematisation = None
error_msg = f"Error: {e}"
self.plugin_dock.communication.bar_error(error_msg,
log_text_color=QColor(
Qt.red))
def cancel_wizard(self):
"""Handling canceling wizard action."""
self.settings.setValue("threedi/new_schematisation_wizard_size",
self.size())
self.reject()
def create_preview_group(group_name: str,
images: List[dict],
footprints_filename=None,
catalog_layer_name=None,
tile_service: str = 'xyz',
search_query: str = None,
sort_order: Tuple[str, str] = None) -> None:
if tile_service.lower() not in ['wmts', 'xyz']:
log.debug(f'Incorrect tile service passed for preview group: '
f'{tile_service} (must be wmts or xyz)')
return
item_ids = [f"{img['properties'][ITEM_TYPE]}:{img[ID]}" for img in images]
uri = tile_service_data_src_uri(item_ids, service=tile_service)
if uri:
log.debug(f'Tile datasource URI:\n{uri}')
rlayer = QgsRasterLayer(uri, 'Image previews', 'wms')
rlayer.setCustomProperty(PLANET_PREVIEW_ITEM_IDS, json.dumps(item_ids))
if tile_service == 'xyz' and catalog_layer_name is not None:
url = uri.split("url=")[-1]
s = QSettings()
s.setValue(f'qgis/connections-xyz/{catalog_layer_name}/username',
"")
s.setValue(f'qgis/connections-xyz/{catalog_layer_name}/password',
"")
s.setValue(f'qgis/connections-xyz/{catalog_layer_name}/authcfg',
"")
s.setValue(f'qgis/connections-xyz/{catalog_layer_name}/url',
url.replace(PlanetClient.getInstance().api_key(), ""))
else:
log.debug('No tile URI for preview group')
return
vlayer = None
if images:
vlayer = create_preview_vector_layer(images[0])
vlayer.startEditing()
dp = vlayer.dataProvider()
fields: List[QgsField] = vlayer.fields()
for img in images:
feat = QgsFeature()
feat.setFields(fields)
qgs_geom = qgsgeometry_from_geojson(img['geometry'])
feat.setGeometry(qgs_geom)
f_names = [f.name() for f in fields]
if 'item_id' in f_names:
feat['item_id'] = img[ID]
if search_query and 'search_query' in f_names:
feat['search_query'] = json.dumps(search_query)
if (sort_order and 'sort_order' in f_names
and len(sort_order) > 1):
feat['sort_order'] = ' '.join(sort_order)
props: dict = img['properties']
for k, v in props.items():
if k in f_names:
feat[k] = v
dp.addFeature(feat)
vlayer.commitChanges()
if footprints_filename:
QgsVectorFileWriter.writeAsVectorFormat(vlayer,
footprints_filename,
"UTF-8")
gpkglayer = QgsVectorLayer(footprints_filename, 'Footprints')
gpkglayer.setRenderer(vlayer.renderer().clone())
vlayer = gpkglayer
QgsProject.instance().addMapLayer(vlayer, False)
# noinspection PyArgumentList
QgsProject.instance().addMapLayer(rlayer, False)
# noinspection PyArgumentList
root: QgsLayerTree = QgsProject.instance().layerTreeRoot()
group = root.insertGroup(0, f'{group_name} {tile_service.upper()} preview')
if vlayer:
group.addLayer(vlayer)
group.addLayer(rlayer)
if vlayer:
iface.setActiveLayer(vlayer)
def save_settings(self):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/wizards/geoeconomic_zone_valuation_load_data_type',
'digitizing' if self.rad_digitizing.isChecked() else 'refactor')
def save_settings(self):
settings = QSettings()
settings.setValue(
'Asistente-LADM_COL/wizards/natural_party_load_data_type',
'create_manually'
if self.rad_create_manually.isChecked() else 'refactor')
class TestQgsSettings(unittest.TestCase):
cnt = 0
def setUp(self):
self.cnt += 1
h, path = tempfile.mkstemp('.ini')
assert QgsSettings.setGlobalSettingsPath(path)
self.settings = QgsSettings('testqgissettings',
'testqgissettings%s' % self.cnt)
self.globalsettings = QSettings(self.settings.globalSettingsPath(),
QSettings.IniFormat)
def tearDown(self):
settings_file = self.settings.fileName()
settings_default_file = self.settings.globalSettingsPath()
del (self.settings)
try:
os.unlink(settings_file)
except:
pass
try:
os.unlink(settings_default_file)
except:
pass
def addToDefaults(self, key, value):
self.globalsettings.setValue(key, value)
self.globalsettings.sync()
def addArrayToDefaults(self, prefix, key, values):
defaults = QSettings(self.settings.globalSettingsPath(),
QSettings.IniFormat) # NOQA
self.globalsettings.beginWriteArray(prefix)
i = 0
for v in values:
self.globalsettings.setArrayIndex(i)
self.globalsettings.setValue(key, v)
i += 1
self.globalsettings.endArray()
self.globalsettings.sync()
def addGroupToDefaults(self, prefix, kvp):
defaults = QSettings(self.settings.globalSettingsPath(),
QSettings.IniFormat) # NOQA
self.globalsettings.beginGroup(prefix)
for k, v in kvp.items():
self.globalsettings.setValue(k, v)
self.globalsettings.endGroup()
self.globalsettings.sync()
def test_basic_functionality(self):
self.assertEqual(
self.settings.value('testqgissettings/doesnotexists', 'notexist'),
'notexist')
self.settings.setValue('testqgissettings/name', 'qgisrocks')
self.settings.sync()
self.assertEqual(self.settings.value('testqgissettings/name'),
'qgisrocks')
def test_defaults(self):
self.assertIsNone(self.settings.value('testqgissettings/name'))
self.addToDefaults('testqgissettings/name', 'qgisrocks')
self.assertEqual(self.settings.value('testqgissettings/name'),
'qgisrocks')
def test_allkeys(self):
self.assertEqual(self.settings.allKeys(), [])
self.addToDefaults('testqgissettings/name', 'qgisrocks')
self.addToDefaults('testqgissettings/name2', 'qgisrocks2')
self.settings.setValue('nepoti/eman', 'osaple')
self.assertEqual(3, len(self.settings.allKeys()))
self.assertIn('testqgissettings/name', self.settings.allKeys())
self.assertIn('nepoti/eman', self.settings.allKeys())
self.assertEqual('qgisrocks',
self.settings.value('testqgissettings/name'))
self.assertEqual('qgisrocks2',
self.settings.value('testqgissettings/name2'))
self.assertEqual('qgisrocks',
self.globalsettings.value('testqgissettings/name'))
self.assertEqual('osaple', self.settings.value('nepoti/eman'))
self.assertEqual(3, len(self.settings.allKeys()))
self.assertEqual(2, len(self.globalsettings.allKeys()))
def test_precedence_simple(self):
self.assertEqual(self.settings.allKeys(), [])
self.addToDefaults('testqgissettings/names/name1', 'qgisrocks1')
self.settings.setValue('testqgissettings/names/name1', 'qgisrocks-1')
self.assertEqual(self.settings.value('testqgissettings/names/name1'),
'qgisrocks-1')
def test_precedence_group(self):
"""Test if user can override a group value"""
self.assertEqual(self.settings.allKeys(), [])
self.addGroupToDefaults(
'connections-xyz', {
'OSM': 'http://a.tile.openstreetmap.org/{z}/{x}/{y}.png',
'OSM-b': 'http://b.tile.openstreetmap.org/{z}/{x}/{y}.png',
})
self.settings.beginGroup('connections-xyz')
self.assertEqual(self.settings.value('OSM'),
'http://a.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.assertEqual(self.settings.value('OSM-b'),
'http://b.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.settings.endGroup()
# Override edit
self.settings.beginGroup('connections-xyz')
self.settings.setValue(
'OSM', 'http://c.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.settings.endGroup()
# Check it again!
self.settings.beginGroup('connections-xyz')
self.assertEqual(self.settings.value('OSM'),
'http://c.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.assertEqual(self.settings.value('OSM-b'),
'http://b.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.settings.endGroup()
# Override remove: the global value will be resumed!!!
self.settings.beginGroup('connections-xyz')
self.settings.remove('OSM')
self.settings.endGroup()
# Check it again!
self.settings.beginGroup('connections-xyz')
self.assertEqual(self.settings.value('OSM'),
'http://a.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.assertEqual(self.settings.value('OSM-b'),
'http://b.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.settings.endGroup()
# Override remove: store a blank!
self.settings.beginGroup('connections-xyz')
self.settings.setValue('OSM', '')
self.settings.endGroup()
# Check it again!
self.settings.beginGroup('connections-xyz')
self.assertEqual(self.settings.value('OSM'), '')
self.assertEqual(self.settings.value('OSM-b'),
'http://b.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.settings.endGroup()
# Override remove: store a None: will resume the global setting!
self.settings.beginGroup('connections-xyz')
self.settings.setValue('OSM', None)
self.settings.endGroup()
# Check it again!
self.settings.beginGroup('connections-xyz')
self.assertEqual(self.settings.value('OSM'),
'http://a.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.assertEqual(self.settings.value('OSM-b'),
'http://b.tile.openstreetmap.org/{z}/{x}/{y}.png')
self.settings.endGroup()
def test_uft8(self):
self.assertEqual(self.settings.allKeys(), [])
self.addToDefaults('testqgissettings/names/namèé↓1', 'qgisrocks↓1')
self.assertEqual(self.settings.value('testqgissettings/names/namèé↓1'),
'qgisrocks↓1')
self.settings.setValue('testqgissettings/names/namèé↓2', 'qgisrocks↓2')
self.assertEqual(self.settings.value('testqgissettings/names/namèé↓2'),
'qgisrocks↓2')
self.settings.setValue('testqgissettings/names/namèé↓1',
'qgisrocks↓-1')
self.assertEqual(self.settings.value('testqgissettings/names/namèé↓1'),
'qgisrocks↓-1')
def test_groups(self):
self.assertEqual(self.settings.allKeys(), [])
self.addToDefaults('testqgissettings/names/name1', 'qgisrocks1')
self.addToDefaults('testqgissettings/names/name2', 'qgisrocks2')
self.addToDefaults('testqgissettings/names/name3', 'qgisrocks3')
self.addToDefaults('testqgissettings/name', 'qgisrocks')
self.settings.beginGroup('testqgissettings')
self.assertEqual(['names'], self.settings.childGroups())
self.settings.setValue('surnames/name1', 'qgisrocks-1')
self.assertEqual(['surnames', 'names'], self.settings.childGroups())
self.settings.setValue('names/name1', 'qgisrocks-1')
self.assertEqual('qgisrocks-1', self.settings.value('names/name1'))
self.settings.endGroup()
self.settings.beginGroup('testqgissettings/names')
self.settings.setValue('name4', 'qgisrocks-4')
keys = sorted(self.settings.childKeys())
self.assertEqual(keys, ['name1', 'name2', 'name3', 'name4'])
self.settings.endGroup()
self.assertEqual('qgisrocks-1',
self.settings.value('testqgissettings/names/name1'))
self.assertEqual('qgisrocks-4',
self.settings.value('testqgissettings/names/name4'))
def test_global_groups(self):
self.assertEqual(self.settings.allKeys(), [])
self.assertEqual(self.globalsettings.allKeys(), [])
self.addToDefaults('testqgissettings/foo/first', 'qgis')
self.addToDefaults('testqgissettings/foo/last', 'rocks')
self.settings.beginGroup('testqgissettings')
self.assertEqual(['foo'], self.settings.childGroups())
self.assertEqual(['foo'], self.settings.globalChildGroups())
self.settings.endGroup()
self.settings.setValue('testqgissettings/bar/first', 'qgis')
self.settings.setValue('testqgissettings/bar/last', 'rocks')
self.settings.beginGroup('testqgissettings')
self.assertEqual(sorted(['bar', 'foo']),
sorted(self.settings.childGroups()))
self.assertEqual(['foo'], self.settings.globalChildGroups())
self.settings.endGroup()
self.globalsettings.remove('testqgissettings/foo')
self.settings.beginGroup('testqgissettings')
self.assertEqual(['bar'], self.settings.childGroups())
self.assertEqual([], self.settings.globalChildGroups())
self.settings.endGroup()
def test_group_section(self):
# Test group by using Section
self.settings.beginGroup('firstgroup', section=QgsSettings.Core)
self.assertEqual([], self.settings.childGroups())
self.settings.setValue('key', 'value')
self.settings.setValue('key2/subkey1', 'subvalue1')
self.settings.setValue('key2/subkey2', 'subvalue2')
self.settings.setValue('key3', 'value3')
self.assertEqual(['key', 'key2/subkey1', 'key2/subkey2', 'key3'],
self.settings.allKeys())
self.assertEqual(['key', 'key3'], self.settings.childKeys())
self.assertEqual(['key2'], self.settings.childGroups())
self.settings.endGroup()
# Set value by writing the group manually
self.settings.setValue('firstgroup/key4',
'value4',
section=QgsSettings.Core)
# Checking the value that have been set
self.assertEqual(
self.settings.value('firstgroup/key', section=QgsSettings.Core),
'value')
self.assertEqual(
self.settings.value('firstgroup/key2/subkey1',
section=QgsSettings.Core), 'subvalue1')
self.assertEqual(
self.settings.value('firstgroup/key2/subkey2',
section=QgsSettings.Core), 'subvalue2')
self.assertEqual(
self.settings.value('firstgroup/key3', section=QgsSettings.Core),
'value3')
self.assertEqual(
self.settings.value('firstgroup/key4', section=QgsSettings.Core),
'value4')
# Clean up firstgroup
self.settings.remove('firstgroup', section=QgsSettings.Core)
def test_array(self):
self.assertEqual(self.settings.allKeys(), [])
self.addArrayToDefaults('testqgissettings', 'key',
['qgisrocks1', 'qgisrocks2', 'qgisrocks3'])
self.assertEqual(self.settings.allKeys(), [
'testqgissettings/1/key', 'testqgissettings/2/key',
'testqgissettings/3/key', 'testqgissettings/size'
])
self.assertEqual(self.globalsettings.allKeys(), [
'testqgissettings/1/key', 'testqgissettings/2/key',
'testqgissettings/3/key', 'testqgissettings/size'
])
self.assertEqual(
3, self.globalsettings.beginReadArray('testqgissettings'))
self.globalsettings.endArray()
self.assertEqual(3, self.settings.beginReadArray('testqgissettings'))
values = []
for i in range(3):
self.settings.setArrayIndex(i)
values.append(self.settings.value("key"))
self.assertEqual(values, ['qgisrocks1', 'qgisrocks2', 'qgisrocks3'])
def test_array_overrides(self):
"""Test if an array completely shadows the global one"""
self.assertEqual(self.settings.allKeys(), [])
self.addArrayToDefaults('testqgissettings', 'key',
['qgisrocks1', 'qgisrocks2', 'qgisrocks3'])
self.assertEqual(self.settings.allKeys(), [
'testqgissettings/1/key', 'testqgissettings/2/key',
'testqgissettings/3/key', 'testqgissettings/size'
])
self.assertEqual(self.globalsettings.allKeys(), [
'testqgissettings/1/key', 'testqgissettings/2/key',
'testqgissettings/3/key', 'testqgissettings/size'
])
self.assertEqual(
3, self.globalsettings.beginReadArray('testqgissettings'))
self.globalsettings.endArray()
self.assertEqual(3, self.settings.beginReadArray('testqgissettings'))
# Now override!
self.settings.beginWriteArray('testqgissettings')
self.settings.setArrayIndex(0)
self.settings.setValue('key', 'myqgisrocksmore1')
self.settings.setArrayIndex(1)
self.settings.setValue('key', 'myqgisrocksmore2')
self.settings.endArray()
# Check it!
self.assertEqual(2, self.settings.beginReadArray('testqgissettings'))
values = []
for i in range(2):
self.settings.setArrayIndex(i)
values.append(self.settings.value("key"))
self.assertEqual(values, ['myqgisrocksmore1', 'myqgisrocksmore2'])
def test_section_getters_setters(self):
self.assertEqual(self.settings.allKeys(), [])
self.settings.setValue('key1', 'core1', section=QgsSettings.Core)
self.settings.setValue('key2', 'core2', section=QgsSettings.Core)
self.settings.setValue('key1', 'server1', section=QgsSettings.Server)
self.settings.setValue('key2', 'server2', section=QgsSettings.Server)
self.settings.setValue('key1', 'gui1', section=QgsSettings.Gui)
self.settings.setValue('key2', 'gui2', QgsSettings.Gui)
self.settings.setValue('key1', 'plugins1', section=QgsSettings.Plugins)
self.settings.setValue('key2', 'plugins2', section=QgsSettings.Plugins)
self.settings.setValue('key1', 'misc1', section=QgsSettings.Misc)
self.settings.setValue('key2', 'misc2', section=QgsSettings.Misc)
self.settings.setValue('key1', 'auth1', section=QgsSettings.Auth)
self.settings.setValue('key2', 'auth2', section=QgsSettings.Auth)
self.settings.setValue('key1', 'app1', section=QgsSettings.App)
self.settings.setValue('key2', 'app2', section=QgsSettings.App)
self.settings.setValue('key1',
'provider1',
section=QgsSettings.Providers)
self.settings.setValue('key2',
'provider2',
section=QgsSettings.Providers)
self.settings.setValue('key1', 'auth1', section=QgsSettings.Auth)
self.settings.setValue('key2', 'auth2', section=QgsSettings.Auth)
# Test that the values are namespaced
self.assertEqual(self.settings.value('core/key1'), 'core1')
self.assertEqual(self.settings.value('core/key2'), 'core2')
self.assertEqual(self.settings.value('server/key1'), 'server1')
self.assertEqual(self.settings.value('server/key2'), 'server2')
self.assertEqual(self.settings.value('gui/key1'), 'gui1')
self.assertEqual(self.settings.value('gui/key2'), 'gui2')
self.assertEqual(self.settings.value('plugins/key1'), 'plugins1')
self.assertEqual(self.settings.value('plugins/key2'), 'plugins2')
self.assertEqual(self.settings.value('misc/key1'), 'misc1')
self.assertEqual(self.settings.value('misc/key2'), 'misc2')
# Test getters
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.Core),
'core1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.Core),
'core2')
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.Server),
'server1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.Server),
'server2')
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.Gui), 'gui1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.Gui), 'gui2')
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.Plugins),
'plugins1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.Plugins),
'plugins2')
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.Misc),
'misc1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.Misc),
'misc2')
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.Auth),
'auth1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.Auth),
'auth2')
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.App), 'app1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.App), 'app2')
self.assertEqual(
self.settings.value('key1', None, section=QgsSettings.Providers),
'provider1')
self.assertEqual(
self.settings.value('key2', None, section=QgsSettings.Providers),
'provider2')
# Test default values on Section getter
self.assertEqual(
self.settings.value('key_not_exist',
'misc_not_exist',
section=QgsSettings.Misc), 'misc_not_exist')
def test_contains(self):
self.assertEqual(self.settings.allKeys(), [])
self.addToDefaults('testqgissettings/name', 'qgisrocks1')
self.addToDefaults('testqgissettings/name2', 'qgisrocks2')
self.assertTrue(self.settings.contains('testqgissettings/name'))
self.assertTrue(self.settings.contains('testqgissettings/name2'))
self.settings.setValue('testqgissettings/name3', 'qgisrocks3')
self.assertTrue(self.settings.contains('testqgissettings/name3'))
def test_remove(self):
self.settings.setValue('testQgisSettings/temp', True)
self.assertEqual(self.settings.value('testQgisSettings/temp'), True)
self.settings.remove('testQgisSettings/temp')
self.assertEqual(self.settings.value('testqQgisSettings/temp'), None)
# Test remove by using Section
self.settings.setValue('testQgisSettings/tempSection',
True,
section=QgsSettings.Core)
self.assertEqual(
self.settings.value('testQgisSettings/tempSection',
section=QgsSettings.Core), True)
self.settings.remove('testQgisSettings/temp', section=QgsSettings.Core)
self.assertEqual(
self.settings.value('testqQgisSettings/temp',
section=QgsSettings.Core), None)
def test_enumValue(self):
self.settings.setValue('enum', 'LayerUnits')
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels),
QgsTolerance.LayerUnits)
self.settings.setValue('enum', 'dummy_setting')
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels),
QgsTolerance.Pixels)
self.assertEqual(
type(self.settings.enumValue('enum', QgsTolerance.Pixels)),
QgsTolerance.UnitType)
def test_setEnumValue(self):
self.settings.setValue('enum', 'LayerUnits')
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels),
QgsTolerance.LayerUnits)
self.settings.setEnumValue('enum', QgsTolerance.Pixels)
self.assertEqual(self.settings.enumValue('enum', QgsTolerance.Pixels),
QgsTolerance.Pixels)
def test_flagValue(self):
pointAndLine = QgsMapLayerProxyModel.Filters(
QgsMapLayerProxyModel.PointLayer | QgsMapLayerProxyModel.LineLayer)
pointAndPolygon = QgsMapLayerProxyModel.Filters(
QgsMapLayerProxyModel.PointLayer
| QgsMapLayerProxyModel.PolygonLayer)
self.settings.setValue('flag', 'PointLayer|PolygonLayer')
self.assertEqual(self.settings.flagValue('flag', pointAndLine),
pointAndPolygon)
self.settings.setValue('flag', 'dummy_setting')
self.assertEqual(self.settings.flagValue('flag', pointAndLine),
pointAndLine)
self.assertEqual(type(self.settings.flagValue('enum', pointAndLine)),
QgsMapLayerProxyModel.Filters)
def setLastUsedEncoding(encoding):
settings = QSettings()
settings.setValue("/UI/encoding", encoding)
def testStyle(self):
# First test with invalid URI
vl = QgsVectorLayer('/idont/exist.gpkg', 'test', 'ogr')
self.assertFalse(
vl.dataProvider().isSaveAndLoadStyleToDatabaseSupported())
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, -1)
self.assertEqual(idlist, [])
self.assertEqual(namelist, [])
self.assertEqual(desclist, [])
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("1")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, success = vl.loadNamedStyle('/idont/exist.gpkg')
self.assertFalse(success)
errorMsg = vl.saveStyleToDatabase("name", "description", False, "")
self.assertNotEqual(errorMsg, "")
# Now with valid URI
tmpfile = os.path.join(self.basetestpath, 'testStyle.gpkg')
ds = ogr.GetDriverByName('GPKG').CreateDataSource(tmpfile)
lyr = ds.CreateLayer('test', geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'bar'
lyr.CreateFeature(f)
f = None
lyr = ds.CreateLayer('test2', geom_type=ogr.wkbMultiPolygon)
lyr.CreateField(ogr.FieldDefn('foo', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['foo'] = 'bar'
lyr.CreateFeature(f)
f = None
ds = None
vl = QgsVectorLayer('{}|layername=test'.format(tmpfile), 'test', 'ogr')
self.assertTrue(vl.isValid())
vl2 = QgsVectorLayer('{}|layername=test2'.format(tmpfile), 'test2',
'ogr')
self.assertTrue(vl2.isValid())
self.assertTrue(
vl.dataProvider().isSaveAndLoadStyleToDatabaseSupported())
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 0)
self.assertEqual(idlist, [])
self.assertEqual(namelist, [])
self.assertEqual(desclist, [])
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("not_existing")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, success = vl.loadNamedStyle('{}|layerid=0'.format(tmpfile))
self.assertFalse(success)
errorMsg = vl.saveStyleToDatabase("name", "description", False, "")
self.assertEqual(errorMsg, "")
qml, errmsg = vl.getStyleFromDatabase("not_existing")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description'])
qml, errmsg = vl.getStyleFromDatabase("100")
self.assertEqual(qml, "")
self.assertNotEqual(errmsg, "")
qml, errmsg = vl.getStyleFromDatabase("1")
self.assertTrue(qml.startswith('<!DOCTYPE qgis'), qml)
self.assertEqual(errmsg, "")
# Try overwrite it but simulate answer no
settings = QSettings()
settings.setValue("/qgis/overwriteStyle", False)
errorMsg = vl.saveStyleToDatabase("name", "description_bis", False, "")
self.assertNotEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description'])
# Try overwrite it and simulate answer yes
settings = QSettings()
settings.setValue("/qgis/overwriteStyle", True)
errorMsg = vl.saveStyleToDatabase("name", "description_bis", False, "")
self.assertEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 1)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1'])
self.assertEqual(namelist, ['name'])
self.assertEqual(desclist, ['description_bis'])
errorMsg = vl2.saveStyleToDatabase("name_test2", "description_test2",
True, "")
self.assertEqual(errorMsg, "")
errorMsg = vl.saveStyleToDatabase("name2", "description2", True, "")
self.assertEqual(errorMsg, "")
errorMsg = vl.saveStyleToDatabase("name3", "description3", True, "")
self.assertEqual(errorMsg, "")
related_count, idlist, namelist, desclist, errmsg = vl.listStylesInDatabase(
)
self.assertEqual(related_count, 3)
self.assertEqual(errmsg, "")
self.assertEqual(idlist, ['1', '3', '4', '2'])
self.assertEqual(namelist, ['name', 'name2', 'name3', 'name_test2'])
self.assertEqual(
desclist,
['description_bis', 'description2', 'description3', 'name_test2'])
# Check that layers_style table is not list in subLayers()
vl = QgsVectorLayer(tmpfile, 'test', 'ogr')
sublayers = vl.dataProvider().subLayers()
self.assertEqual(len(sublayers), 2, sublayers)
class Photo2ShapeDialog(BASE, WIDGET):
def __init__(self, iface, parent=None):
super(Photo2ShapeDialog, self).__init__(parent)
self.setupUi(self)
self.iface = iface
self.settings = QSettings('alexbruy', 'photo2shape')
self.thread = QThread()
self.importer = PhotoImporter()
self.btnOk = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.btnSelectInput.clicked.connect(self.selectDirectory)
self.btnSelectOutput.clicked.connect(self.selectFile)
self.importer.moveToThread(self.thread)
self.importer.importError.connect(self.thread.quit)
self.importer.importError.connect(self.importCanceled)
self.importer.importMessage.connect(self.logMessage)
self.importer.importFinished.connect(self.thread.quit)
self.importer.importFinished.connect(self.importCompleted)
self.importer.photoProcessed.connect(self.updateProgress)
self.thread.started.connect(self.importer.importPhotos)
self.encoding = self.settings.value('encoding', 'System')
self.manageGui()
def manageGui(self):
self.chkRecurse.setChecked(self.settings.value('recurse', True, bool))
self.chkAppend.setChecked(self.settings.value('append', True, bool))
self.chkLoadLayer.setChecked(
self.settings.value('loadLayer', True, bool))
def closeEvent(self, event):
self._saveSettings()
QDialog.closeEvent(self, event)
def selectDirectory(self):
lastDir = self.settings.value('lastPhotosDir', '.')
dirName = QFileDialog.getExistingDirectory(
self, self.tr('Select directory'), lastDir)
if dirName == '':
return
self.lePhotosPath.setText(dirName)
self.settings.setValue('lastPhotosDir', os.path.dirname(dirName))
def selectFile(self):
lastDir = self.settings.value('lastShapeDir', '.')
shpFilter = self.tr('ESRI Shapefiles (*.shp *.SHP)')
self.encoding = self.settings.value('encoding', 'System')
fileDialog = QgsEncodingFileDialog(
self, self.tr('Save file'), lastDir, shpFilter, self.encoding)
fileDialog.setDefaultSuffix('shp')
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setConfirmOverwrite(True)
if fileDialog.exec_():
fileName = fileDialog.selectedFiles()[0]
self.encoding = fileDialog.encoding()
self.leOutputShape.setText(fileName)
self.settings.setValue('lastShapeDir',
QFileInfo(fileName).absoluteDir().absolutePath())
self.settings.setValue('encoding', self.encoding)
def reject(self):
self._saveSettings()
QDialog.reject(self)
def accept(self):
self._saveSettings()
dirName = self.lePhotosPath.text()
if dirName == '':
self.iface.messageBar().pushWarning(
self.tr('Path not set'),
self.tr('Path to photos is not set. Please specify directory '
'with photos and try again.'))
return
fileName = self.leOutputShape.text()
if fileName == '':
self.iface.messageBar().pushWarning(
self.tr('Output file is not set'),
self.tr('Output file name is missing. Please specify correct '
'output file and try again.'))
return
# make sure output file always has correct suffix
if not fileName.lower().endswith('.shp'):
fileName += '.shp'
self.leOutputShape.setText(fileName)
if self.chkAppend.isChecked() and not os.path.isfile(fileName):
self.iface.messageBar().pushWarning(
self.tr('Appending is not possible'),
self.tr('Output file is a new file and can not be used '
'in "append" mode. Either specify existing file '
'or uncheck corresponding checkbox.'))
return
self.importer.setPhotosDirectory(dirName)
self.importer.setOutputPath(fileName)
self.importer.setEncoding(self.encoding)
self.importer.setRecurseDirs(self.chkRecurse.isChecked())
self.importer.setAppendFile(self.chkAppend.isChecked())
self.thread.start()
self.btnOk.setEnabled(False)
self.btnClose.setEnabled(False)
def updateProgress(self, value):
self.progressBar.setValue(value)
def logMessage(self, message, level=QgsMessageLog.INFO):
QgsMessageLog.logMessage(message, 'Photo2Shape', level)
def importCanceled(self, message):
self.iface.messageBar().pushWarning(self.tr('Import error'),
message)
self._restoreGui()
def importCompleted(self):
self.iface.messageBar().pushSuccess(
self.tr('Import completed'),
self.tr('Shapefile from photos sucessfully created'))
if self.chkLoadLayer.isChecked():
self._loadLayer()
self._restoreGui()
def _loadLayer(self):
fName = self.leOutputShape.text()
layer = QgsVectorLayer(fName, QFileInfo(fName).baseName(), 'ogr')
if layer.isValid():
layer.loadNamedStyle(
os.path.join(pluginPath, 'resources', 'photos.qml'))
QgsMapLayerRegistry.instance().addMapLayer(layer)
else:
self.iface.messageBar().pushWarning(
self.tr('No output'),
self.tr('Cannot load output shapefile'))
def _restoreGui(self):
self.progressBar.setValue(0)
self.btnOk.setEnabled(True)
self.btnClose.setEnabled(True)
def _saveSettings(self):
self.settings.setValue('recurse', self.chkRecurse.isChecked())
self.settings.setValue('append', self.chkAppend.isChecked())
self.settings.setValue('loadLayer', self.chkLoadLayer.isChecked())
