def __init__(self):
super(ScriptSelector, self).__init__(None)
self.setupUi(self)
self.scripts = None
allScripts = defaultdict(list)
alglist = algList.getProviderFromName("script").algs
for script in alglist:
allScripts[script.group].append(script)
for group, groupScripts in list(allScripts.items()):
groupItem = QTreeWidgetItem()
groupItem.setText(0, group)
groupItem.setFlags(groupItem.flags() | Qt.ItemIsTristate)
for script in groupScripts:
scriptItem = QTreeWidgetItem()
scriptItem.setFlags(scriptItem.flags() | Qt.ItemIsUserCheckable)
scriptItem.setCheckState(0, Qt.Checked)
scriptItem.script = script
scriptItem.setText(0, script.name)
groupItem.addChild(scriptItem)
self.scriptsTree.addTopLevelItem(groupItem)
self.scriptsTree.expandAll()
self.selectAllLabel.linkActivated.connect(lambda: self.checkScripts(True))
self.unselectAllLabel.linkActivated.connect(lambda: self.checkScripts(False))
self.folderButton.clicked.connect(self.selectFolder)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
def computeDiffs(self):
self.featuresTree.clear()
self.changes = self.localChanges(self.layer)
layerItem = QTreeWidgetItem()
layerItem.setText(0, self.layer.name())
layerItem.setIcon(0, layerIcon)
self.featuresTree.addTopLevelItem(layerItem)
addedItem = QTreeWidgetItem()
addedItem.setText(0, "Added")
addedItem.setIcon(0, addedIcon)
removedItem = QTreeWidgetItem()
removedItem.setText(0, "Removed")
removedItem.setIcon(0, removedIcon)
modifiedItem = QTreeWidgetItem()
modifiedItem.setText(0, "Modified")
modifiedItem.setIcon(0, modifiedIcon)
layerSubItems = {LOCAL_FEATURE_ADDED: addedItem,
LOCAL_FEATURE_REMOVED: removedItem,
LOCAL_FEATURE_MODIFIED: modifiedItem}
for c in list(self.changes.values()):
item = QTreeWidgetItem()
item.setText(0, c.fid)
item.setIcon(0, featureIcon)
layerSubItems[c.changetype].addChild(item)
for i in [LOCAL_FEATURE_ADDED, LOCAL_FEATURE_REMOVED, LOCAL_FEATURE_MODIFIED]:
layerItem.addChild(layerSubItems[i])
layerSubItems[i].setText(0, "%s [%i features]" % (layerSubItems[i].text(0), layerSubItems[i].childCount()))
self.attributesTable.clear()
self.attributesTable.verticalHeader().hide()
self.attributesTable.horizontalHeader().hide()
self.featuresTree.expandAll()
def addRecentAlgorithms(self, updating):
showRecent = ProcessingConfig.getSetting(
ProcessingConfig.SHOW_RECENT_ALGORITHMS)
if showRecent:
recent = ProcessingLog.getRecentAlgorithms()
if len(recent) != 0:
found = False
if updating:
recentItem = self.algorithmTree.topLevelItem(0)
if recentItem.text(0) == self.tr('Recently used'):
treeWidget = recentItem.treeWidget()
treeWidget.takeTopLevelItem(
treeWidget.indexOfTopLevelItem(recentItem))
recentItem = QTreeWidgetItem()
recentItem.setText(0, self.tr('Recently used'))
for algname in recent:
alg = QgsApplication.processingRegistry().createAlgorithmById(algname)
if alg is not None:
algItem = TreeAlgorithmItem(alg)
recentItem.addChild(algItem)
found = True
if found:
self.algorithmTree.insertTopLevelItem(0, recentItem)
recentItem.setExpanded(True)
self.algorithmTree.setWordWrap(True)
def showCompletion(self, rows):
# Rows is an iterable of tuples like [("text",object1),("text2", object2),...]
pal = self.editor.palette()
color = pal.color(QPalette.Disabled, QPalette.WindowText)
self.popup.setUpdatesEnabled(False)
self.popup.clear()
if rows is None or len( rows ) < 1:
return
for row in rows:
item = QTreeWidgetItem(self.popup)
item.setText(0, row[0])
#item.setText(1, hit['type'])
item.setTextAlignment(1, Qt.AlignRight)
item.setForeground(1, color)
item.setData(2, Qt.UserRole, (row[1],)) # Try immutable py obj #http://stackoverflow.com/questions/9257422/how-to-get-the-original-python-data-from-qvariant
self.popup.setCurrentItem(self.popup.topLevelItem(0))
self.popup.resizeColumnToContents(0)
#self.popup.resizeColumnToContents(1)
self.popup.adjustSize()
self.popup.setUpdatesEnabled(True)
h = self.popup.sizeHintForRow(0) * min(15, len(rows)) + 3
w = max(self.popup.width(), self.editor.width())
self.popup.resize(w, h)
self.popup.move(self.editor.mapToGlobal(QPoint(0, self.editor.height())))
self.popup.setFocus()
self.popup.show()
def on_btnLoad_clicked(self):
fileName, _ = QFileDialog.getOpenFileName(None,
self.tr('Import Colors and elevations from XML'),
QDir.homePath(),
self.tr('XML files (*.xml *.XML)'))
if fileName == '':
return
doc = QDomDocument()
with codecs.open(fileName, 'r', encoding='utf-8') as f:
content = f.read()
if not doc.setContent(content):
QMessageBox.critical(None,
self.tr('Error parsing XML'),
self.tr('The XML file could not be loaded'))
return
self.reliefClassTree.clear()
reliefColorList = doc.elementsByTagName('ReliefColor')
for i in range(reliefColorList.length()):
elem = reliefColorList.at(i).toElement()
item = QTreeWidgetItem()
item.setText(0, elem.attribute('MinElevation'))
item.setText(1, elem.attribute('MaxElevation'))
item.setBackground(2, QBrush(QColor(int(elem.attribute('red')),
int(elem.attribute('green')),
int(elem.attribute('blue')))))
self.reliefClassTree.addTopLevelItem(item)
def populate(self):
groups = {}
count = 0
provider = algList.algs[self.providerName]
algs = list(provider.values())
name = "ACTIVATE_" + self.providerName.upper().replace(" ", "_")
active = ProcessingConfig.getSetting(name)
# Add algorithms
for alg in algs:
if not alg.showInToolbox:
continue
if alg.group in groups:
groupItem = groups[alg.group]
else:
groupItem = QTreeWidgetItem()
name = alg.i18n_group or alg.group
if not active:
groupItem.setForeground(0, Qt.darkGray)
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groups[alg.group] = groupItem
algItem = TreeAlgorithmItem(alg)
if not active:
algItem.setForeground(0, Qt.darkGray)
groupItem.addChild(algItem)
count += 1
actions = Processing.actions[self.providerName]
for action in actions:
if action.group in groups:
groupItem = groups[action.group]
else:
groupItem = QTreeWidgetItem()
groupItem.setText(0, action.group)
groups[action.group] = groupItem
algItem = TreeActionItem(action)
groupItem.addChild(algItem)
text = self.provider.getDescription()
if not active:
def activateProvider():
self.toolbox.activateProvider(self.providerName)
label = QLabel(text + " <a href='%s'>Activate</a>")
label.setStyleSheet("QLabel {background-color: white; color: grey;}")
label.linkActivated.connect(activateProvider)
self.tree.setItemWidget(self, 0, label)
else:
text += QCoreApplication.translate("TreeProviderItem", " [{0} geoalgorithms]").format(count)
self.setText(0, text)
self.setToolTip(0, self.text(0))
for groupItem in list(groups.values()):
self.addChild(groupItem)
self.setHidden(self.childCount() == 0)
def populateColors(self, colors):
self.reliefClassTree.clear()
for c in colors:
item = QTreeWidgetItem()
item.setText(0, str(c.minElevation))
item.setText(1, str(c.maxElevation))
item.setBackground(2, QBrush(c.color))
self.reliefClassTree.addTopLevelItem(item)
def _getItem(self, name, icon, params):
icon = QIcon(icon)
item = QTreeWidgetItem()
item.setText(0, name)
item.setIcon(0, icon)
for param in params:
subItem = TreeSettingItem(item, self.tree, name, param)
item.addChild(subItem)
return item
def populate(self):
groups = {}
count = 0
algs = self.provider.algorithms()
active = self.provider.isActive()
# Add algorithms
for alg in algs:
if alg.flags() & QgsProcessingAlgorithm.FlagHideFromToolbox:
continue
if alg.group() in groups:
groupItem = groups[alg.group()]
else:
groupItem = QTreeWidgetItem()
name = alg.group()
if not active:
groupItem.setForeground(0, Qt.darkGray)
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groups[alg.group()] = groupItem
algItem = TreeAlgorithmItem(alg)
if not active:
algItem.setForeground(0, Qt.darkGray)
groupItem.addChild(algItem)
count += 1
if self.provider.id() in ProviderActions.actions:
actions = ProviderActions.actions[self.provider.id()]
for action in actions:
if action.group in groups:
groupItem = groups[action.group]
else:
groupItem = QTreeWidgetItem()
groupItem.setText(0, action.group)
groups[action.group] = groupItem
algItem = TreeActionItem(action)
groupItem.addChild(algItem)
text = self.provider.name()
if not active:
def activateProvider():
self.toolbox.activateProvider(self.provider.id())
label = QLabel(text + " <a href='%s'>Activate</a>")
label.setStyleSheet("QLabel {background-color: white; color: grey;}")
label.linkActivated.connect(activateProvider)
self.tree.setItemWidget(self, 0, label)
else:
text += QCoreApplication.translate("TreeProviderItem", " [{0} geoalgorithms]").format(count)
self.setText(0, text)
self.setToolTip(0, self.text(0))
for groupItem in list(groups.values()):
self.addChild(groupItem)
self.setHidden(self.childCount() == 0)
def populateSchemas(self):
if self.childCount() != 0:
return
geodb = GeoDB.from_name(self.connection)
schemas = geodb.list_schemas()
for oid, name, owner, perms in schemas:
item = QTreeWidgetItem()
item.setText(0, name)
item.setIcon(0, self.schemaIcon)
self.addChild(item)
def fillTree(self):
self.tree.clear()
entries = ProcessingLog.getLogEntries()
groupItem = QTreeWidgetItem()
groupItem.setText(0, 'ALGORITHM')
groupItem.setIcon(0, self.groupIcon)
for entry in entries:
item = TreeLogEntryItem(entry, True)
item.setIcon(0, self.keyIcon)
groupItem.insertChild(0, item)
self.tree.addTopLevelItem(groupItem)
def setValue(self, value):
self.reliefClassTree.clear()
rows = value.split(';')
for r in rows:
v = r.split(',')
item = QTreeWidgetItem()
item.setText(0, v[0])
item.setText(1, v[1])
color = QColor(int(v[2]), int(v[3]), int(v[4]))
item.setBackground(2, QBrush(color))
self.reliefClassTree.addTopLevelItem(item)
def fillAlgorithmTreeUsingProviders(self):
self.algorithmTree.clear()
text = str(self.searchBox.text())
search_strings = text.split(' ')
allAlgs = algList.algs
for provider_id in list(allAlgs.keys()):
name = 'ACTIVATE_' + provider_id.upper().replace(' ', '_')
if not ProcessingConfig.getSetting(name):
continue
groups = {}
algs = list(allAlgs[provider_id].values())
# Add algorithms
for alg in algs:
if not alg.showInModeler:
continue
if alg.commandLineName() == self.alg.commandLineName():
continue
item_text = [alg.name.lower()]
item_text.extend(alg.tags.split(','))
show = not search_strings or all(
any(part in t for t in item_text)
for part in search_strings)
if show:
if alg.group in groups:
groupItem = groups[alg.group]
else:
groupItem = QTreeWidgetItem()
name = alg.i18n_group or alg.group
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groups[alg.group] = groupItem
algItem = TreeAlgorithmItem(alg)
groupItem.addChild(algItem)
if len(groups) > 0:
providerItem = QTreeWidgetItem()
provider = QgsApplication.processingRegistry().providerById(provider_id)
providerItem.setText(0, provider.name())
providerItem.setToolTip(0, provider.name())
providerItem.setIcon(0, provider.icon())
for groupItem in list(groups.values()):
providerItem.addChild(groupItem)
self.algorithmTree.addTopLevelItem(providerItem)
providerItem.setExpanded(text != '')
for groupItem in list(groups.values()):
if text != '':
groupItem.setExpanded(True)
self.algorithmTree.sortItems(0, Qt.AscendingOrder)
def fillInputsTree(self):
icon = QIcon(os.path.join(pluginPath, 'images', 'input.png'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
for paramType in ModelerParameterDefinitionDialog.paramTypes:
paramItem = QTreeWidgetItem()
paramItem.setText(0, paramType)
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def addLayerData(self, layerName, attribute):
item = QTreeWidgetItem()
item.setText(0, layerName)
item.setText(1, attribute)
self.layersTree.addTopLevelItem(item)
comboBox = QComboBox()
comboBox.addItem(self.tr('Points'))
comboBox.addItem(self.tr('Structure lines'))
comboBox.addItem(self.tr('Break lines'))
comboBox.setCurrentIndex(0)
self.layersTree.setItemWidget(item, 2, comboBox)
def fillTree(self):
self.tree.clear()
elements = ProcessingLog.getLogEntries()
for category in list(elements.keys()):
groupItem = QTreeWidgetItem()
groupItem.setText(0, category)
groupItem.setIcon(0, self.groupIcon)
for entry in elements[category]:
item = TreeLogEntryItem(entry, category == ProcessingLog.LOG_ALGORITHM)
item.setIcon(0, self.keyIcon)
groupItem.insertChild(0, item)
self.tree.addTopLevelItem(groupItem)
def fillTree(self):
allLessons = defaultdict(list)
for lesson in lessons:
allLessons[lesson.group].append(lesson)
self.lessonsTree.clear()
lessonIcon = QIcon(os.path.dirname(__file__) + "/lesson.gif")
for group, groupLessons in list(allLessons.items()):
groupItem = QTreeWidgetItem()
groupItem.setText(0, group)
groupItem.description = groups.get(group, "")
for lesson in groupLessons:
lessonItem = QTreeWidgetItem()
lessonItem.lesson = lesson
lessonItem.setText(0, lesson.name)
lessonItem.setIcon(0, lessonIcon)
groupItem.addChild(lessonItem)
if lesson.version[0] is not None and str(lesson.version[0]) > QGis.QGIS_VERSION:
lessonItem.setText(0, lesson.name + " (requires QGIS >= {})".format(lesson.version[0]))
lessonItem.setDisabled(True)
if lesson.version[1] is not None and str(lesson.version[1]) < QGis.QGIS_VERSION:
lessonItem.setText(0, lesson.name + " (requires QGIS <= {})".format(lesson.version[1]))
lessonItem.setDisabled(True)
self.lessonsTree.addTopLevelItem(groupItem)
self.lessonsTree.sortItems(0, 0)
self.lessonsTree.expandAll()
def fillAlgorithmTreeUsingProviders(self):
self.algorithmTree.clear()
text = str(self.searchBox.text())
search_strings = text.split(' ')
for provider in QgsApplication.processingRegistry().providers():
if not provider.isActive():
continue
groups = {}
# Add algorithms
for alg in provider.algorithms():
if alg.flags() & QgsProcessingAlgorithm.FlagHideFromModeler:
continue
if alg.id() == self.alg.id():
continue
item_text = [alg.displayName().lower()]
item_text.extend(alg.tags())
show = not search_strings or all(
any(part in t for t in item_text)
for part in search_strings)
if show:
if alg.group() in groups:
groupItem = groups[alg.group()]
else:
groupItem = QTreeWidgetItem()
name = alg.group()
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groups[alg.group()] = groupItem
algItem = TreeAlgorithmItem(alg)
groupItem.addChild(algItem)
if len(groups) > 0:
providerItem = QTreeWidgetItem()
providerItem.setText(0, provider.name())
providerItem.setToolTip(0, provider.name())
providerItem.setIcon(0, provider.icon())
for groupItem in list(groups.values()):
providerItem.addChild(groupItem)
self.algorithmTree.addTopLevelItem(providerItem)
providerItem.setExpanded(text != '')
for groupItem in list(groups.values()):
if text != '':
groupItem.setExpanded(True)
self.algorithmTree.sortItems(0, Qt.AscendingOrder)
def fillConflictsTree(self):
topTreeItems = {}
for c in self.conflicts:
path = os.path.dirname(c.path)
if path in topTreeItems:
topItem = topTreeItems[path]
else:
topItem = QTreeWidgetItem()
topItem.setText(0, path)
topItem.setIcon(0, layerIcon)
topTreeItems[path] = topItem
conflictItem = ConflictItem(c)
topItem.addChild(conflictItem)
for item in list(topTreeItems.values()):
self.conflictsTree.addTopLevelItem(item)
def __init__(self, report):
super(ReportDialog, self).__init__()
self.setupUi(self)
self.actionSaveAll.setIcon(QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.actionSaveSelected.setIcon(QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.actionOpenTracker.setIcon(QgsApplication.getThemeIcon('/mActionHelpAPI.png'))
self.actionSaveAll.triggered.connect(lambda: self.saveResults(True))
self.actionSaveSelected.triggered.connect(lambda: self.saveResults(False))
self.resultsTree.clear()
results = report.results
self.saveFailed(results)
self.reopen = False
allResults = defaultdict(list)
for result in results:
test = result.test
allResults[test.group].append(result)
for group, groupResults in list(allResults.items()):
groupItem = QTreeWidgetItem()
groupItem.setText(0, group)
for result in groupResults:
resultItem = QTreeWidgetItem()
resultItem.result = result
resultItem.setText(0, result.test.name)
resultItem.setForeground(0, self.resultColor[result.status])
groupItem.addChild(resultItem)
self.resultsTree.addTopLevelItem(groupItem)
self.resultsTree.expandAll()
self.resultsTree.itemClicked.connect(self.itemClicked)
self.resultsTree.customContextMenuRequested.connect(self.showPopupMenu)
button = QPushButton("Re-open test selector");
def _reopen():
self.reopen = True
self.close()
button.clicked.connect(_reopen)
self.buttonBox.addButton(button, QDialogButtonBox.ActionRole);
self.buttonBox.rejected.connect(self.close)
def fillInputsTree(self):
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(QgsApplication.instance().processingRegistry().parameterTypes(), key=lambda pt: pt.name())
for param in sortedParams:
if param.flags() & QgsProcessingParameterType.ExposeToModeler:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param.name())
paramItem.setData(0, Qt.UserRole, param.id())
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param.description())
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def fillAlgorithmTreeUsingProviders(self):
self.algorithmTree.clear()
text = unicode(self.searchBox.text())
allAlgs = ModelerUtils.allAlgs
for providerName in allAlgs.keys():
name = 'ACTIVATE_' + providerName.upper().replace(' ', '_')
if not ProcessingConfig.getSetting(name):
continue
groups = {}
provider = allAlgs[providerName]
algs = provider.values()
# Add algorithms
for alg in algs:
if not alg.showInModeler or alg.allowOnlyOpenedLayers:
continue
if alg.commandLineName() == self.alg.commandLineName():
continue
if text == '' or text.lower() in alg.name.lower():
if alg.group in groups:
groupItem = groups[alg.group]
else:
groupItem = QTreeWidgetItem()
name = alg.i18n_group or alg.group
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groups[alg.group] = groupItem
algItem = TreeAlgorithmItem(alg)
groupItem.addChild(algItem)
if len(groups) > 0:
providerItem = QTreeWidgetItem()
providerItem.setText(0,
ModelerUtils.providers[providerName].getDescription())
providerItem.setToolTip(0,
ModelerUtils.providers[providerName].getDescription())
providerItem.setIcon(0,
ModelerUtils.providers[providerName].getIcon())
for groupItem in groups.values():
providerItem.addChild(groupItem)
self.algorithmTree.addTopLevelItem(providerItem)
providerItem.setExpanded(text != '')
for groupItem in groups.values():
if text != '':
groupItem.setExpanded(True)
self.algorithmTree.sortItems(0, Qt.AscendingOrder)
def fillInputsTree(self):
from processing.core.Processing import Processing
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(Processing.registeredParameters().items())
for param in sortedParams:
if param[1]['exposeToModeller']:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param[1]['name'])
paramItem.setData(0, Qt.UserRole, param[0])
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param[1]['description'])
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def fillInputsTree(self):
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(
QgsApplication.instance().processingRegistry().parameterTypes(),
key=lambda pt: pt.name())
for param in sortedParams:
if param.flags() & QgsProcessingParameterType.ExposeToModeler:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param.name())
paramItem.setData(0, Qt.UserRole, param.id())
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param.description())
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def fillInputsTree(self):
from processing.core.Processing import Processing
icon = QIcon(os.path.join(pluginPath, 'images', 'input.svg'))
parametersItem = QTreeWidgetItem()
parametersItem.setText(0, self.tr('Parameters'))
sortedParams = sorted(Processing.registeredParameters().items())
for param in sortedParams:
if param[1]['exposeToModeller']:
paramItem = QTreeWidgetItem()
paramItem.setText(0, param[1]['name'])
paramItem.setData(0, Qt.UserRole, param[0])
paramItem.setIcon(0, icon)
paramItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
paramItem.setToolTip(0, param[1]['description'])
parametersItem.addChild(paramItem)
self.inputsTree.addTopLevelItem(parametersItem)
parametersItem.setExpanded(True)
def computeDiffs(self):
self.featuresTree.clear()
self.changes = self.localChanges(self.layer)
layerItem = QTreeWidgetItem()
layerItem.setText(0, self.layer.name())
layerItem.setIcon(0, layerIcon)
self.featuresTree.addTopLevelItem(layerItem)
addedItem = QTreeWidgetItem()
addedItem.setText(0, "Added")
addedItem.setIcon(0, addedIcon)
removedItem = QTreeWidgetItem()
removedItem.setText(0, "Removed")
removedItem.setIcon(0, removedIcon)
modifiedItem = QTreeWidgetItem()
modifiedItem.setText(0, "Modified")
modifiedItem.setIcon(0, modifiedIcon)
layerSubItems = {
LOCAL_FEATURE_ADDED: addedItem,
LOCAL_FEATURE_REMOVED: removedItem,
LOCAL_FEATURE_MODIFIED: modifiedItem
}
for c in list(self.changes.values()):
item = QTreeWidgetItem()
item.setText(0, c.fid)
item.setIcon(0, featureIcon)
layerSubItems[c.changetype].addChild(item)
for i in [
LOCAL_FEATURE_ADDED, LOCAL_FEATURE_REMOVED,
LOCAL_FEATURE_MODIFIED
]:
layerItem.addChild(layerSubItems[i])
layerSubItems[i].setText(
0, "%s [%i features]" %
(layerSubItems[i].text(0), layerSubItems[i].childCount()))
self.attributesTable.clear()
self.attributesTable.verticalHeader().hide()
self.attributesTable.horizontalHeader().hide()
self.featuresTree.expandAll()
def populate_repositories_widget(self):
"""Populate the current dictionary repositories to the tree widget."""
# Clear the current tree widget
self.tree_repositories.clear()
installed_collections = self.collection_manager.get_installed_collections(
)
# Export the updated ones from the repository manager
repo_Font = QFont()
repo_with_installed_Font = QFont()
repo_with_installed_Font.setWeight(60)
collection_brush = QBrush(Qt.darkGray)
installed_collection_brush = QBrush(QColor(60, 25, 10))
for repo_name in self.repository_manager.directories:
url = self.repository_manager.directories[repo_name]["url"]
item = QTreeWidgetItem(self.tree_repositories, REPOSITORY_ITEM)
# Is the repository in the QGIS resource directory?
if url in self.repository_manager._online_directories.values():
repo_with_installed_Font.setUnderline(True)
repo_Font.setUnderline(True)
else:
repo_with_installed_Font.setUnderline(False)
repo_Font.setUnderline(False)
item.setText(0, repo_name)
item.setText(1, url)
item.setFont(0, repo_Font)
for coll_id in config.COLLECTIONS:
if ("repository_name" in config.COLLECTIONS[coll_id].keys()
and config.COLLECTIONS[coll_id]["repository_name"]
== repo_name):
coll_name = config.COLLECTIONS[coll_id]["name"]
coll_tags = config.COLLECTIONS[coll_id]["tags"]
collectionItem = QTreeWidgetItem(item, COLLECTION_ITEM)
brush = collection_brush
collectionFont = QFont()
collectionFont.setStyle(QFont.StyleItalic)
collitemtext = coll_name
if (installed_collections
and coll_id in installed_collections.keys()):
collitemtext = coll_name + " (installed)"
brush = installed_collection_brush
item.setFont(0, repo_with_installed_Font)
item.setForeground(0, brush)
item.setForeground(1, brush)
collectionItem.setFont(0, collectionFont)
collectionItem.setForeground(0, brush)
collectionItem.setText(0, collitemtext)
collectionItem.setFont(1, collectionFont)
collectionItem.setForeground(1, brush)
collectionItem.setText(1, coll_tags)
self.tree_repositories.resizeColumnToContents(0)
self.tree_repositories.resizeColumnToContents(1)
self.tree_repositories.sortItems(1, Qt.AscendingOrder)
def set_items(self, data=None):
"""" Build the tree afresh with no selections """
self.tree_products.clear()
data = data if data else {}
self._data = json.loads(data) if isinstance(data, str) else data
for product, measurements in self._data.items():
parent = QTreeWidgetItem(self.tree_products)
parent.setText(0, product)
# noinspection PyTypeChecker
parent.setFlags(parent.flags() | Qt.ItemIsTristate
| Qt.ItemIsUserCheckable)
for measurement in measurements:
child = QTreeWidgetItem(parent)
# noinspection PyTypeChecker
child.setFlags(child.flags() | Qt.ItemIsUserCheckable)
child.setText(0, measurement)
child.setCheckState(0, Qt.Unchecked)
class TreeGroupItem(QTreeWidgetItem):
groupIcon = QIcon(
os.path.join(os.path.dirname(__file__), "icons", "group.gif"))
def __init__(self, name, layers, tree):
QTreeWidgetItem.__init__(self)
self.layers = layers
self.name = name
self.setText(0, name)
self.setIcon(0, self.groupIcon)
self.setCheckState(0, Qt.Checked)
self.visibleItem = QTreeWidgetItem(self)
self.visibleCheck = QCheckBox()
self.visibleCheck.setChecked(True)
self.visibleItem.setText(0, "Layers visibility")
self.addChild(self.visibleItem)
tree.setItemWidget(self.visibleItem, 1, self.visibleCheck)
@property
def visible(self):
return self.visibleCheck.isChecked()
def display_results(self):
"""display search results"""
self.treeRecords.clear()
position = self.catalog.returned + self.startfrom - 1
msg = self.tr('Showing {0} - {1} of %n result(s)', 'number of results',
self.catalog.matches).format(self.startfrom, position)
self.lblResults.setText(msg)
for rec in self.catalog.records():
item = QTreeWidgetItem(self.treeRecords)
if rec['type']:
item.setText(0, normalize_text(rec['type']))
else:
item.setText(0, 'unknown')
if rec['title']:
item.setText(1, normalize_text(rec['title']))
if rec['identifier']:
set_item_data(item, 'identifier', rec['identifier'])
self.btnViewRawAPIResponse.setEnabled(True)
if self.catalog.matches < self.maxrecords:
disabled = False
else:
disabled = True
self.btnFirst.setEnabled(disabled)
self.btnPrev.setEnabled(disabled)
self.btnNext.setEnabled(disabled)
self.btnLast.setEnabled(disabled)
self.btnRawAPIResponse.setEnabled(False)
def __init__(self):
super(LessonSelector, self).__init__()
self.setupUi(self)
self.lesson = None
allLessons = defaultdict(list)
for lesson in lessons:
allLessons[lesson.group].append(lesson)
lessonIcon = QIcon(os.path.dirname(__file__) + '/lesson.gif')
for group, groupLessons in allLessons.items():
groupItem = QTreeWidgetItem()
groupItem.setText(0, group)
groupItem.description = groups.get(group, "")
for lesson in groupLessons:
lessonItem = QTreeWidgetItem()
lessonItem.lesson = lesson
lessonItem.setText(0, lesson.name)
lessonItem.setIcon(0, lessonIcon)
groupItem.addChild(lessonItem)
self.lessonsTree.addTopLevelItem(groupItem)
self.lessonsTree.sortItems(0, 0)
self.lessonsTree.expandAll()
self.lessonsTree.itemDoubleClicked.connect(self.itemDoubleClicked)
self.btnRunLesson.setDefault(True)
self.btnRunLesson.clicked.connect(self.okPressed)
self.btnRemove.clicked.connect(self.remove)
self.btnClose.clicked.connect(self.close)
self.btnRemove.setEnabled(False)
self.lessonsTree.currentItemChanged.connect(self.currentItemChanged)
self.lessonsTree.setCurrentItem(
self.lessonsTree.invisibleRootItem().child(0).child(0))
def computeDiffs(self):
self.commit1 = self.commit1Panel.getRef()
self.commit2 = self.commit2Panel.getRef()
self.featuresTree.clear()
changes = execute(lambda: self.repo.diff(self.commit1.commitid, self.
commit2.commitid))
layerItems = {}
layerSubItems = {}
self.changes = {}
for c in changes:
self.changes[c.path] = c
layername = c.path.split("/")[0]
featureid = c.path.split("/")[-1]
if layername not in layerItems:
item = QTreeWidgetItem()
item.setText(0, layername)
item.setIcon(0, layerIcon)
layerItems[layername] = item
addedItem = QTreeWidgetItem()
addedItem.setText(0, "Added")
addedItem.setIcon(0, addedIcon)
removedItem = QTreeWidgetItem()
removedItem.setText(0, "Removed")
removedItem.setIcon(0, removedIcon)
modifiedItem = QTreeWidgetItem()
modifiedItem.setText(0, "Modified")
modifiedItem.setIcon(0, modifiedIcon)
layerSubItems[layername] = {
FEATURE_ADDED: addedItem,
FEATURE_REMOVED: removedItem,
FEATURE_MODIFIED: modifiedItem
}
item = FeatureItem(layername, featureid)
layerSubItems[layername][c.changetype].addChild(item)
for layername, item in layerItems.iteritems():
for i in [FEATURE_ADDED, FEATURE_REMOVED, FEATURE_MODIFIED]:
subItem = layerSubItems[layername][i]
item.addChild(subItem)
subItem.setText(
0, "%s [%i features]" %
(subItem.text(0), subItem.childCount()))
self.featuresTree.addTopLevelItem(item)
self.attributesTable.clear()
self.attributesTable.verticalHeader().hide()
self.attributesTable.horizontalHeader().hide()
self.featuresTree.expandAll()
def loadEarthCoverage(self):
"""
Loads a previously saved earth coverage configuration
"""
try:
self.clearTree()
if self.earthCoverageDict == dict():
self.getEarthCoverageDict()
rootItem = self.earthCoverageTreeWidget.invisibleRootItem()
#database item
for key in list(self.earthCoverageDict.keys()):
item = QTreeWidgetItem(rootItem)
item.setText(0, key)
item.setExpanded(True)
for cl in self.earthCoverageDict[key]:
covItem = QTreeWidgetItem(item)
covItem.setText(1, cl)
covItem.setExpanded(True)
except Exception as e:
QgsMessageLog.logMessage(
self.tr('Earth Coverage not loaded! Check log for details.') +
':'.join(e.args), "DSGTools Plugin", Qgis.Critical)
def populateTree(self):
for layer in self.layers:
item = QTreeWidgetItem()
item.setText(0, layer)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish symbology")
subitem.setIcon(0, SYMBOLOGY_ICON)
item.addChild(subitem)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish data")
subitem.setIcon(0, DATA_ICON)
item.addChild(subitem)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish metadata")
subitem.setIcon(0, METADATA_ICON)
item.addChild(subitem)
self.treeWidget.addTopLevelItem(item)
item.setExpanded(False)
item = QTreeWidgetItem()
item.setText(0, "Create layer groups")
item.setIcon(0, GROUPS_ICON)
self.treeWidget.addTopLevelItem(item)
QCoreApplication.processEvents()
def populateSchemas(self):
if self.childCount() != 0:
return
settings = QSettings()
connSettings = '/PostgreSQL/connections/' + self.connection
database = settings.value(connSettings + '/database')
user = settings.value(connSettings + '/username')
host = settings.value(connSettings + '/host')
port = settings.value(connSettings + '/port')
passwd = settings.value(connSettings + '/password')
uri = QgsDataSourceURI()
uri.setConnection(host, str(port), database, user, passwd)
connInfo = uri.connectionInfo()
(success, user, passwd) = QgsCredentials.instance().get(connInfo, None, None)
if success:
QgsCredentials.instance().put(connInfo, user, passwd)
geodb = GeoDB(host, int(port), database, user, passwd)
schemas = geodb.list_schemas()
for oid, name, owner, perms in schemas:
item = QTreeWidgetItem()
item.setText(0, name)
item.setIcon(0, self.schemaIcon)
self.addChild(item)
def populateTree(self):
for lyr_name in (lyr_utils.getLayerById(id_).name() for id_ in self.layer_ids):
item = QTreeWidgetItem()
item.setText(0, lyr_name)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish symbology")
subitem.setIcon(0, SYMBOLOGY_ICON)
item.addChild(subitem)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish data")
subitem.setIcon(0, DATA_ICON)
item.addChild(subitem)
subitem = QTreeWidgetItem()
subitem.setText(0, "Publish metadata")
subitem.setIcon(0, METADATA_ICON)
item.addChild(subitem)
self.treeWidget.addTopLevelItem(item)
item.setExpanded(False)
item = QTreeWidgetItem()
item.setText(0, "Create layer groups")
item.setIcon(0, GROUPS_ICON)
self.treeWidget.addTopLevelItem(item)
QCoreApplication.processEvents()
def __init__(self):
super(ScriptSelector, self).__init__(None)
self.setupUi(self)
self.scripts = None
allScripts = defaultdict(list)
alglist = QgsApplication.processingRegistry().providerById(
"script").algs
for script in alglist:
allScripts[script.group()].append(script)
for group, groupScripts in list(allScripts.items()):
groupItem = QTreeWidgetItem()
groupItem.setText(0, group)
groupItem.setFlags(groupItem.flags() | Qt.ItemIsTristate)
for script in groupScripts:
scriptItem = QTreeWidgetItem()
scriptItem.setFlags(scriptItem.flags()
| Qt.ItemIsUserCheckable)
scriptItem.setCheckState(0, Qt.Checked)
scriptItem.script = script
scriptItem.setText(0, script.name)
groupItem.addChild(scriptItem)
self.scriptsTree.addTopLevelItem(groupItem)
self.scriptsTree.expandAll()
self.selectAllLabel.linkActivated.connect(
lambda: self.checkScripts(True))
self.deselectAllLabel.linkActivated.connect(
lambda: self.checkScripts(False))
self.folderButton.clicked.connect(self.selectFolder)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
def display(self):
'''
Initialize top-level items
'''
if len(self.items) == 0:
return
self.tree.clear()
# If there is only one item then set it as the root item
if len(self.items) == 1:
rootItem = self.items[0]
# Set root font
rtFont = rootItem.font(0)
rtFont.setBold(True)
rootItem.setFont(0, rtFont)
# Add the tree item to the tree widget
self.tree.addTopLevelItem(rootItem)
rootItem.setExpanded(True)
else:
rootItem = QTreeWidgetItem(self.tree)
rootItem.setText(0, self.title)
rootItem.setIcon(0, QIcon(self.rootResource))
# Set root font
rtFont = rootItem.font(0)
rtFont.setBold(True)
rootItem.setFont(0, rtFont)
rootItem.addChildren(self.items)
rootItem.setExpanded(True)
# Force the horizontal scrollbar to show
self.tree.header().setSectionResizeMode(QHeaderView.ResizeToContents)
def computeDiffs(self):
self.commit1 = self.commit1Panel.getRef()
self.commit2 = self.commit2Panel.getRef()
self.featuresTree.clear()
changes = execute(lambda: self.repo.diff(self.commit1.commitid, self.commit2.commitid))
layerItems = {}
layerSubItems = {}
self.changes = {}
for c in changes:
self.changes[c.path] = c
layername = c.path.split("/")[0]
featureid = c.path.split("/")[-1]
if layername not in layerItems:
item = QTreeWidgetItem()
item.setText(0, layername)
item.setIcon(0, layerIcon)
layerItems[layername] = item
addedItem = QTreeWidgetItem()
addedItem.setText(0, "Added")
addedItem.setIcon(0, addedIcon)
removedItem = QTreeWidgetItem()
removedItem.setText(0, "Removed")
removedItem.setIcon(0, removedIcon)
modifiedItem = QTreeWidgetItem()
modifiedItem.setText(0, "Modified")
modifiedItem.setIcon(0, modifiedIcon)
layerSubItems[layername] = {FEATURE_ADDED: addedItem,
FEATURE_REMOVED: removedItem,
FEATURE_MODIFIED:modifiedItem}
item = FeatureItem(layername, featureid)
layerSubItems[layername][c.changetype].addChild(item)
for layername, item in layerItems.iteritems():
for i in [FEATURE_ADDED, FEATURE_REMOVED, FEATURE_MODIFIED]:
subItem = layerSubItems[layername][i]
item.addChild(subItem)
subItem.setText(0, "%s [%i features]" %
(subItem.text(0),
subItem.childCount()))
self.featuresTree.addTopLevelItem(item)
self.attributesTable.clear()
self.attributesTable.verticalHeader().hide()
self.attributesTable.horizontalHeader().hide()
self.featuresTree.expandAll()
def add_item(root, text, template_data):
item = QTreeWidgetItem(root)
if template_data:
if type(template_data) == dict:
item.setText(0, str(text).format(**template_data))
else:
item.setText(0, str(text).format(*template_data))
else:
item.setText(0, str(text))
return item
def display_results(self):
"""display search results"""
self.treeRecords.clear()
position = self.catalog.results['returned'] + self.startfrom
msg = self.tr('Showing %d - %d of %n result(s)', 'number of results',
self.catalog.results['matches']) % (self.startfrom + 1,
position)
self.lblResults.setText(msg)
for rec in self.catalog.records:
item = QTreeWidgetItem(self.treeRecords)
if self.catalog.records[rec].type:
item.setText(0, normalize_text(self.catalog.records[rec].type))
else:
item.setText(0, 'unknown')
if self.catalog.records[rec].title:
item.setText(1,
normalize_text(self.catalog.records[rec].title))
if self.catalog.records[rec].identifier:
set_item_data(item, 'identifier',
self.catalog.records[rec].identifier)
self.btnShowXml.setEnabled(True)
if self.catalog.results["matches"] < self.maxrecords:
disabled = False
else:
disabled = True
self.btnFirst.setEnabled(disabled)
self.btnPrev.setEnabled(disabled)
self.btnNext.setEnabled(disabled)
self.btnLast.setEnabled(disabled)
def display_results(self):
"""display search results"""
self.treeRecords.clear()
position = self.catalog.results['returned'] + self.startfrom
msg = self.tr('Showing {0} - {1} of %n result(s)', 'number of results',
self.catalog.results['matches']).format(
self.startfrom + 1, position)
self.lblResults.setText(msg)
for rec in self.catalog.records:
item = QTreeWidgetItem(self.treeRecords)
if self.catalog.records[rec].type:
item.setText(0, normalize_text(self.catalog.records[rec].type))
else:
item.setText(0, 'unknown')
if self.catalog.records[rec].title:
item.setText(1,
normalize_text(self.catalog.records[rec].title))
if self.catalog.records[rec].identifier:
set_item_data(item, 'identifier',
self.catalog.records[rec].identifier)
self.btnShowXml.setEnabled(True)
if self.catalog.results["matches"] < self.maxrecords:
disabled = False
else:
disabled = True
self.btnFirst.setEnabled(disabled)
self.btnPrev.setEnabled(disabled)
self.btnNext.setEnabled(disabled)
self.btnLast.setEnabled(disabled)
def fillTree(self):
layersItem = QTreeWidgetItem()
layersItem.setText(0, self.tr('Values from data layers extents'))
self.treeValues.addTopLevelItem(layersItem)
layers = dataobjects.getAllLayers()
for layer in layers:
layerItem = QTreeWidgetItem()
layerItem.setText(0, str(layer.name()))
layerItem.addChild(TreeValueItem(self.tr('Min X'),
layer.extent().xMinimum()))
layerItem.addChild(TreeValueItem(self.tr('Max X'),
layer.extent().xMaximum()))
layerItem.addChild(TreeValueItem(self.tr('Min Y'),
layer.extent().yMinimum()))
layerItem.addChild(TreeValueItem(self.tr('Max Y'),
layer.extent().yMaximum()))
if isinstance(layer, QgsRasterLayer):
cellsize = (layer.extent().xMaximum()
- layer.extent().xMinimum()) / layer.width()
layerItem.addChild(TreeValueItem(self.tr('Cellsize'),
cellsize))
layersItem.addChild(layerItem)
layersItem = QTreeWidgetItem()
layersItem.setText(0, self.tr('Values from raster layers statistics'))
self.treeValues.addTopLevelItem(layersItem)
layers = dataobjects.getRasterLayers()
for layer in layers:
for i in range(layer.bandCount()):
stats = layer.dataProvider().bandStatistics(i + 1)
layerItem = QTreeWidgetItem()
layerItem.setText(0, str(layer.name()))
layerItem.addChild(TreeValueItem(self.tr('Mean'), stats.mean))
layerItem.addChild(TreeValueItem(self.tr('Std. deviation'),
stats.stdDev))
layerItem.addChild(TreeValueItem(self.tr('Max value'),
stats.maximumValue))
layerItem.addChild(TreeValueItem(self.tr('Min value'),
stats.minimumValue))
layersItem.addChild(layerItem)
canvasItem = QTreeWidgetItem()
canvasItem.setText(0, self.tr('Values from QGIS map canvas'))
self.treeValues.addTopLevelItem(canvasItem)
extent = iface.mapCanvas().extent()
extentItem = QTreeWidgetItem()
extentItem.setText(0, self.tr('Current extent'))
extentItem.addChild(TreeValueItem(self.tr('Min X'), extent.xMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max X'), extent.xMaximum()))
extentItem.addChild(TreeValueItem(self.tr('Min Y'), extent.yMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max Y'), extent.yMaximum()))
canvasItem.addChild(extentItem)
extent = iface.mapCanvas().fullExtent()
extentItem = QTreeWidgetItem()
extentItem.setText(0,
self.tr('Full extent of all layers in map canvas'))
extentItem.addChild(TreeValueItem(self.tr('Min X'), extent.xMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max X'), extent.xMaximum()))
extentItem.addChild(TreeValueItem(self.tr('Min Y'), extent.yMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max Y'), extent.yMaximum()))
canvasItem.addChild(extentItem)
class GetScriptsAndModelsDialog(BASE, WIDGET):
HELP_TEXT = QCoreApplication.translate(
'GetScriptsAndModelsDialog', '<h3> Processing resources manager </h3>'
'<p>Check/uncheck algorithms in the tree to select the ones that you '
'want to install or remove</p>'
'<p>Algorithms are divided in 3 groups:</p>'
'<ul><li><b>Installed:</b> Algorithms already in your system, with '
'the latest version available</li>'
'<li><b>Updatable:</b> Algorithms already in your system, but with '
'a newer version available in the server</li>'
'<li><b>Not installed:</b> Algorithms not installed in your '
'system</li></ul>')
MODELS = 0
SCRIPTS = 1
tr_disambiguation = {0: 'GetModelsAction', 1: 'GetScriptsAction'}
def __init__(self, resourceType):
super(GetScriptsAndModelsDialog, self).__init__(iface.mainWindow())
self.setupUi(self)
if hasattr(self.leFilter, 'setPlaceholderText'):
self.leFilter.setPlaceholderText(self.tr('Search...'))
self.manager = QgsNetworkAccessManager.instance()
repoUrl = ProcessingConfig.getSetting(
ProcessingConfig.MODELS_SCRIPTS_REPO)
self.resourceType = resourceType
if self.resourceType == self.MODELS:
self.folder = ModelerUtils.modelsFolders()[0]
self.urlBase = '{}/models/'.format(repoUrl)
self.icon = QgsApplication.getThemeIcon("/processingModel.svg")
elif self.resourceType == self.SCRIPTS:
self.folder = ScriptUtils.scriptsFolders()[0]
self.urlBase = '{}/scripts/'.format(repoUrl)
self.icon = QgsApplication.getThemeIcon("/processingScript.svg")
self.lastSelectedItem = None
self.updateProvider = False
self.data = None
self.populateTree()
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.tree.currentItemChanged.connect(self.currentItemChanged)
self.leFilter.textChanged.connect(self.fillTree)
def popupError(self, error=None, url=None):
"""Popups an Error message bar for network errors."""
disambiguation = self.tr_disambiguation[self.resourceType]
widget = iface.messageBar().createMessage(
self.tr('Connection problem', disambiguation),
self.tr('Could not connect to scripts/models repository',
disambiguation))
if error and url:
QgsMessageLog.logMessage(
self.tr(u"Network error code: {} on URL: {}").format(
error, url), self.tr(u"Processing"),
QgsMessageLog.CRITICAL)
button = QPushButton(QCoreApplication.translate(
"Python", "View message log"),
pressed=show_message_log)
widget.layout().addWidget(button)
iface.messageBar().pushWidget(widget,
level=QgsMessageBar.CRITICAL,
duration=5)
def grabHTTP(self, url, loadFunction, arguments=None):
"""Grab distant content via QGIS internal classes and QtNetwork."""
QApplication.setOverrideCursor(Qt.WaitCursor)
request = QUrl(url)
reply = self.manager.get(QNetworkRequest(request))
if arguments:
reply.finished.connect(partial(loadFunction, reply, arguments))
else:
reply.finished.connect(partial(loadFunction, reply))
while not reply.isFinished():
QCoreApplication.processEvents()
def populateTree(self):
self.grabHTTP(self.urlBase + 'list.txt', self.treeLoaded)
def treeLoaded(self, reply):
"""
update the tree of scripts/models whenever
HTTP request is finished
"""
QApplication.restoreOverrideCursor()
if reply.error() != QNetworkReply.NoError:
self.popupError(reply.error(), reply.request().url().toString())
else:
resources = bytes(reply.readAll()).decode('utf8').splitlines()
resources = [r.split(',', 2) for r in resources]
self.resources = {f: (v, n) for f, v, n in resources}
reply.deleteLater()
self.fillTree()
def fillTree(self):
self.tree.clear()
self.uptodateItem = QTreeWidgetItem()
self.uptodateItem.setText(0, self.tr('Installed'))
self.toupdateItem = QTreeWidgetItem()
self.toupdateItem.setText(0, self.tr('Updatable'))
self.notinstalledItem = QTreeWidgetItem()
self.notinstalledItem.setText(0, self.tr('Not installed'))
self.toupdateItem.setIcon(0, self.icon)
self.uptodateItem.setIcon(0, self.icon)
self.notinstalledItem.setIcon(0, self.icon)
text = str(self.leFilter.text())
for i in sorted(list(self.resources.keys()),
key=lambda kv: kv[2].lower()):
filename = i
version = self.resources[filename][0]
name = self.resources[filename][1]
treeBranch = self.getTreeBranchForState(filename, float(version))
if text == '' or text.lower() in filename.lower():
item = TreeItem(filename, name, self.icon)
treeBranch.addChild(item)
if treeBranch != self.notinstalledItem:
item.setCheckState(0, Qt.Checked)
self.tree.addTopLevelItem(self.toupdateItem)
self.tree.addTopLevelItem(self.notinstalledItem)
self.tree.addTopLevelItem(self.uptodateItem)
if text != '':
self.tree.expandAll()
self.txtHelp.setHtml(self.HELP_TEXT)
def setHelp(self, reply, item):
"""Change the HTML content"""
QApplication.restoreOverrideCursor()
if reply.error() != QNetworkReply.NoError:
html = self.tr(
'<h2>No detailed description available for this script</h2>')
else:
content = bytes(reply.readAll()).decode('utf8')
try:
descriptions = json.loads(content)
except json.decoder.JSONDecodeError:
html = self.tr(
'<h2>JSON Decoding Error - could not load help</h2>')
except Exception:
html = self.tr(
'<h2>Unspecified Error - could not load help</h2>')
html = '<h2>%s</h2>' % item.name
html += self.tr('<p><b>Description:</b> {0}</p>').format(
getDescription(ALG_DESC, descriptions))
html += self.tr('<p><b>Created by:</b> {0}').format(
getDescription(ALG_CREATOR, descriptions))
html += self.tr('<p><b>Version:</b> {0}').format(
getDescription(ALG_VERSION, descriptions))
reply.deleteLater()
self.txtHelp.setHtml(html)
def currentItemChanged(self, item, prev):
if isinstance(item, TreeItem):
url = self.urlBase + item.filename.replace(' ', '%20') + '.help'
self.grabHTTP(url, self.setHelp, item)
else:
self.txtHelp.setHtml(self.HELP_TEXT)
def getTreeBranchForState(self, filename, version):
if not os.path.exists(os.path.join(self.folder, filename)):
return self.notinstalledItem
else:
helpFile = os.path.join(self.folder, filename + '.help')
try:
with open(helpFile) as f:
helpContent = json.load(f)
currentVersion = float(helpContent[Help2Html.ALG_VERSION])
except Exception:
currentVersion = 0
if version > currentVersion:
return self.toupdateItem
else:
return self.uptodateItem
def cancelPressed(self):
super(GetScriptsAndModelsDialog, self).reject()
def storeFile(self, reply, filename):
"""store a script/model that has been downloaded"""
QApplication.restoreOverrideCursor()
if reply.error() != QNetworkReply.NoError:
if os.path.splitext(filename)[1].lower() == '.help':
content = '{"ALG_VERSION" : %s}' % self.resources[
filename[:-5]][0]
else:
self.popupError(reply.error(),
reply.request().url().toString())
content = None
else:
content = bytes(reply.readAll()).decode('utf8')
reply.deleteLater()
if content:
path = os.path.join(self.folder, filename)
with open(path, 'w') as f:
f.write(content)
self.progressBar.setValue(self.progressBar.value() + 1)
def okPressed(self):
toDownload = []
for i in range(self.toupdateItem.childCount()):
item = self.toupdateItem.child(i)
if item.checkState(0) == Qt.Checked:
toDownload.append(item.filename)
for i in range(self.notinstalledItem.childCount()):
item = self.notinstalledItem.child(i)
if item.checkState(0) == Qt.Checked:
toDownload.append(item.filename)
if toDownload:
self.progressBar.setMaximum(len(toDownload) * 2)
for i, filename in enumerate(toDownload):
QCoreApplication.processEvents()
url = self.urlBase + filename.replace(' ', '%20')
self.grabHTTP(url, self.storeFile, filename)
url += '.help'
self.grabHTTP(url, self.storeFile, filename + '.help')
toDelete = []
for i in range(self.uptodateItem.childCount()):
item = self.uptodateItem.child(i)
if item.checkState(0) == Qt.Unchecked:
toDelete.append(item.filename)
# Remove py and help files if they exist
for filename in toDelete:
for pathname in (filename, filename + u".help"):
path = os.path.join(self.folder, pathname)
if os.path.exists(path):
os.remove(path)
self.updateProvider = len(toDownload) + len(toDelete) > 0
super(GetScriptsAndModelsDialog, self).accept()
class TreeLayerItem(QTreeWidgetItem):
layerIcon = QIcon(
os.path.join(os.path.dirname(__file__), "icons", "layer.png"))
def __init__(self, iface, layer, tree, dlg):
QTreeWidgetItem.__init__(self)
self.iface = iface
self.layer = layer
self.setText(0, layer.name())
self.setIcon(0, self.layerIcon)
project = QgsProject.instance()
if project.layerTreeRoot().findLayer(layer.id()).isVisible():
self.setCheckState(0, Qt.Checked)
else:
self.setCheckState(0, Qt.Unchecked)
self.visibleItem = QTreeWidgetItem(self)
self.visibleCheck = QCheckBox()
vis = layer.customProperty("qgis2web/Visible", True)
if vis == 0 or str(vis).lower() == "false":
self.visibleCheck.setChecked(False)
else:
self.visibleCheck.setChecked(True)
self.visibleItem.setText(0, "Visible")
self.addChild(self.visibleItem)
tree.setItemWidget(self.visibleItem, 1, self.visibleCheck)
self.interactiveItem = QTreeWidgetItem(self)
self.interactiveCheck = QCheckBox()
int = True
if int == 0 or str(int).lower() == "false":
self.interactiveCheck.setChecked(False)
else:
self.interactiveCheck.setChecked(True)
self.interactiveItem.setText(0, "Popups")
self.addChild(self.interactiveItem)
tree.setItemWidget(self.interactiveItem, 1, self.interactiveCheck)
if layer.type() == layer.VectorLayer:
if layer.providerType() == 'WFS':
self.jsonItem = QTreeWidgetItem(self)
self.jsonCheck = QCheckBox()
if layer.customProperty("qgis2web/Encode to JSON") == 2:
self.jsonCheck.setChecked(True)
self.jsonItem.setText(0, "Encode to JSON")
self.jsonCheck.stateChanged.connect(self.changeJSON)
self.addChild(self.jsonItem)
tree.setItemWidget(self.jsonItem, 1, self.jsonCheck)
if layer.geometryType() == QgsWkbTypes.PointGeometry:
self.clusterItem = QTreeWidgetItem(self)
self.clusterCheck = QCheckBox()
if layer.customProperty("qgis2web/Cluster") == 2:
self.clusterCheck.setChecked(True)
self.clusterItem.setText(0, "Cluster")
self.clusterCheck.stateChanged.connect(self.changeCluster)
self.addChild(self.clusterItem)
tree.setItemWidget(self.clusterItem, 1, self.clusterCheck)
self.popupItem = QTreeWidgetItem(self)
self.popupItem.setText(0, "Popup fields")
options = []
fields = self.layer.fields()
for f in fields:
fieldIndex = fields.indexFromName(f.name())
editorWidget = layer.editorWidgetSetup(fieldIndex).type()
if editorWidget == 'Hidden':
continue
options.append(f.name())
for option in options:
self.attr = QTreeWidgetItem(self)
self.attrWidget = QComboBox()
self.attrWidget.addItem("no label")
self.attrWidget.addItem("inline label")
self.attrWidget.addItem("header label")
custProp = layer.customProperty("qgis2web/popup/" + option)
if (custProp != "" and custProp is not None):
self.attrWidget.setCurrentIndex(
self.attrWidget.findText(
layer.customProperty("qgis2web/popup/" + option)))
self.attr.setText(1, option)
self.popupItem.addChild(self.attr)
tree.setItemWidget(self.attr, 2, self.attrWidget)
self.addChild(self.popupItem)
else:
if layer.providerType() == 'wms':
self.getFeatureInfoItem = QTreeWidgetItem(self)
self.getFeatureInfoCheck = QCheckBox()
if layer.customProperty("qgis2web/GetFeatureInfo") == 2:
self.getFeatureInfoCheck.setChecked(True)
self.getFeatureInfoItem.setText(0, "Enable GetFeatureInfo?")
self.getFeatureInfoCheck.stateChanged.connect(
self.changeGetFeatureInfo)
self.addChild(self.getFeatureInfoItem)
tree.setItemWidget(self.getFeatureInfoItem, 1,
self.getFeatureInfoCheck)
@property
def popup(self):
popup = []
self.tree = self.treeWidget()
for p in range(self.childCount()):
item = self.child(p).text(1)
if item != "":
popupVal = self.tree.itemWidget(self.child(p), 2).currentText()
pair = (item, popupVal)
popup.append(pair)
popup = OrderedDict(popup)
return popup
@property
def visible(self):
return self.visibleCheck.isChecked()
@property
def interactive(self):
return self.interactiveCheck.isChecked()
@property
def json(self):
try:
return self.jsonCheck.isChecked()
except Exception:
return False
@property
def cluster(self):
try:
return self.clusterCheck.isChecked()
except Exception:
return False
@property
def getFeatureInfo(self):
try:
return self.getFeatureInfoCheck.isChecked()
except Exception:
return False
def changeJSON(self, isJSON):
self.layer.setCustomProperty("qgis2web/Encode to JSON", isJSON)
def changeCluster(self, isCluster):
self.layer.setCustomProperty("qgis2web/Cluster", isCluster)
def changeGetFeatureInfo(self, isGetFeatureInfo):
self.layer.setCustomProperty("qgis2web/GetFeatureInfo",
isGetFeatureInfo)
class MainDialog(QDialog, FORM_CLASS):
"""The main dialog of QGIS2Web plugin."""
items = {}
def __init__(self, iface, parent=None):
super(MainDialog, self).__init__(parent)
QDialog.__init__(self)
self.setupUi(self)
self.iface = iface
self.previewUrl = None
self.layer_search_combo = None
self.layer_filter_select = None
self.exporter_combo = None
self.feedback = FeedbackDialog(self)
self.feedback.setModal(True)
stgs = QSettings()
self.restoreGeometry(
stgs.value("qgis2web/MainDialogGeometry",
QByteArray(),
type=QByteArray))
self.verticalLayout_2.addStretch()
self.horizontalLayout_6.addStretch()
if stgs.value("qgis2web/previewOnStartup", Qt.Checked) == Qt.Checked:
self.previewOnStartup.setCheckState(Qt.Checked)
else:
self.previewOnStartup.setCheckState(Qt.Unchecked)
if stgs.value("qgis2web/closeFeedbackOnSuccess",
Qt.Checked) == Qt.Checked:
self.closeFeedbackOnSuccess.setCheckState(Qt.Checked)
else:
self.closeFeedbackOnSuccess.setCheckState(Qt.Unchecked)
self.previewFeatureLimit.setText(
stgs.value("qgis2web/previewFeatureLimit", "1000"))
self.appearanceParams.setSelectionMode(
QAbstractItemView.SingleSelection)
self.preview = None
if webkit_available:
widget = QWebView()
self.preview = widget
try:
# if os.environ["TRAVIS"]:
self.preview.setPage(WebPage())
except Exception:
print("Failed to set custom webpage")
webview = self.preview.page()
webview.setNetworkAccessManager(QgsNetworkAccessManager.instance())
self.preview.settings().setAttribute(
QWebSettings.DeveloperExtrasEnabled, True)
self.preview.settings().setAttribute(
QWebSettings.DnsPrefetchEnabled, True)
else:
widget = QTextBrowser()
widget.setText(
self.tr('Preview is not available since QtWebKit '
'dependency is missing on your system'))
self.right_layout.insertWidget(0, widget)
self.populateConfigParams(self)
self.populate_layers_and_groups(self)
self.populateLayerSearch()
self.populateAttrFilter()
writer = WRITER_REGISTRY.createWriterFromProject()
self.setStateToWriter(writer)
self.exporter = EXPORTER_REGISTRY.createFromProject()
self.exporter_combo.setCurrentIndex(
self.exporter_combo.findText(self.exporter.name()))
self.exporter_combo.currentIndexChanged.connect(
self.exporterTypeChanged)
self.toggleOptions()
if webkit_available:
if self.previewOnStartup.checkState() == Qt.Checked:
self.autoUpdatePreview()
self.buttonPreview.clicked.connect(self.previewMap)
else:
self.buttonPreview.setDisabled(True)
QgsProject.instance().cleared.connect(self.reject)
self.layersTree.model().dataChanged.connect(self.populateLayerSearch)
self.layersTree.model().dataChanged.connect(self.populateAttrFilter)
self.ol3.clicked.connect(self.changeFormat)
self.leaflet.clicked.connect(self.changeFormat)
self.mapbox.clicked.connect(self.changeFormat)
self.buttonExport.clicked.connect(self.saveMap)
helpText = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"helpFile.md")
self.helpField.setSource(QUrl.fromLocalFile(helpText))
if webkit_available:
self.devConsole = QWebInspector(self.preview)
self.devConsole.setFixedHeight(0)
self.devConsole.setObjectName("devConsole")
self.devConsole.setPage(self.preview.page())
self.devConsole.hide()
self.right_layout.insertWidget(1, self.devConsole)
self.filter = devToggleFilter()
self.filter.devToggle.connect(self.showHideDevConsole)
self.installEventFilter(self.filter)
self.setModal(False)
@pyqtSlot(bool)
def showHideDevConsole(self, visible):
self.devConsole.setVisible(visible)
def changeFormat(self):
self.autoUpdatePreview()
self.toggleOptions()
def exporterTypeChanged(self):
new_exporter_name = self.exporter_combo.currentText()
try:
self.exporter = [
e for e in EXPORTER_REGISTRY.getExporters()
if e.name() == new_exporter_name
][0]()
except Exception:
pass
def currentMapFormat(self):
"""
Returns the currently selected map writer type
"""
return self.getWriterFactory().type()
def getWriterFactory(self):
"""
Returns a factory to create the currently selected map writer
"""
if self.mapFormat.checkedButton() == self.ol3:
return OpenLayersWriter
elif self.mapFormat.checkedButton() == self.leaflet:
return LeafletWriter
elif self.mapFormat.checkedButton() == self.mapbox:
return MapboxWriter
def createWriter(self):
"""
Creates a writer object reflecting the current settings
in the dialog
"""
writer = self.getWriterFactory()()
(writer.layers, writer.groups, writer.popup, writer.visible,
writer.interactive, writer.json, writer.cluster,
writer.getFeatureInfo) = self.getLayersAndGroups()
writer.params = self.getParameters()
return writer
def showErrorMessage(self, error):
"""
Shows an error message in the preview window
"""
html = "<html>"
html += "<head></head>"
html += "<style>body {font-family: sans-serif;}</style>"
html += "<body><h1>Error</h1>"
html += "<p>qgis2web produced an error:</p><code>"
html += error
html += "</code></body></html>"
if self.preview:
self.preview.setHtml(html)
def showFeedbackMessage(self, title, message):
"""
Shows a feedback message in the preview window
"""
html = "<html>"
html += "<head></head>"
html += "<style>body {font-family: sans-serif;}</style>"
html += "<body><h1>{}</h1>".format(title)
html += "<p>{}</p>".format(message)
html += "</body></html>"
if self.preview:
self.preview.setHtml(html)
def toggleOptions(self):
currentWriter = self.getWriterFactory()
for param, value in specificParams.items():
treeParam = self.appearanceParams.findItems(
param, Qt.MatchExactly | Qt.MatchRecursive)[0]
if currentWriter == OpenLayersWriter:
if value == "OL3":
treeParam.setDisabled(False)
if treeParam.combo:
treeParam.combo.setEnabled(True)
else:
treeParam.setDisabled(True)
if treeParam.combo:
treeParam.combo.setEnabled(False)
else:
if value == "OL3":
treeParam.setDisabled(True)
if treeParam.combo:
treeParam.combo.setEnabled(False)
else:
treeParam.setDisabled(False)
if treeParam.combo:
treeParam.combo.setEnabled(True)
for option, value in specificOptions.items():
treeOptions = self.layersTree.findItems(
option, Qt.MatchExactly | Qt.MatchRecursive)
for treeOption in treeOptions:
if currentWriter == OpenLayersWriter:
if value == "OL3":
treeOption.setDisabled(False)
else:
treeOption.setDisabled(True)
else:
if value == "OL3":
treeOption.setDisabled(True)
else:
treeOption.setDisabled(False)
def createPreview(self):
writer = self.createWriter()
return writer.write(self.iface,
dest_folder=utils.tempFolder()).index_file
def shouldAutoPreview(self):
"""
Returns a tuple, with a bool for whether the preview should
automatically be generated, and a string for explanations
as to why the preview cannot be automatically generated
"""
writer = self.createWriter()
total_features = 0
for layer in writer.layers:
if isinstance(layer, QgsVectorLayer):
total_features += layer.featureCount()
if total_features > int(self.previewFeatureLimit.text()):
# Too many features => too slow!
return (False,
self.tr('<p>A large number of features are '
'present in the map. Generating the '
'preview may take some time.</p>'
'<p>Click Update Preview to generate the '
'preview anyway.</p>'))
return (True, None)
def autoUpdatePreview(self):
"""
Triggered when a preview will be automatically generated, i.e.
not as a result of the user manually clicking the
Update Preview button.
"""
(auto_preview, message) = self.shouldAutoPreview()
if not auto_preview:
self.showFeedbackMessage(self.tr('Preview Map'), message)
else:
self.previewMap()
def previewMap(self):
preview_file = self.createPreview()
self.loadPreviewFile(preview_file)
def saveMap(self):
writer = self.createWriter()
write_folder = self.exporter.exportDirectory()
if not write_folder:
return
self.feedback.reset()
self.feedback.show()
results = writer.write(self.iface,
dest_folder=write_folder,
feedback=self.feedback)
self.feedback.showFeedback('Success')
if self.closeFeedbackOnSuccess.checkState() == Qt.Checked:
self.feedback.close()
result = self.exporter.postProcess(results, feedback=self.feedback)
if result and (not os.environ.get('CI')
and not os.environ.get('TRAVIS')):
webbrowser.open_new_tab(self.exporter.destinationUrl())
def populate_layers_and_groups(self, dlg):
"""Populate layers on QGIS into our layers and group tree view."""
root_node = QgsProject.instance().layerTreeRoot()
tree_groups = []
tree_layers = root_node.findLayers()
self.layers_item = QTreeWidgetItem()
self.layers_item.setText(0, "Layers and Groups")
self.layersTree.setColumnCount(3)
for tree_layer in tree_layers:
layer = tree_layer.layer()
if (layer.type() != QgsMapLayer.PluginLayer
and (layer.type() != QgsMapLayer.VectorLayer
or layer.wkbType() != QgsWkbTypes.NoGeometry)
and layer.customProperty("ol_layer_type") is None):
try:
# if layer.type() == QgsMapLayer.VectorLayer:
# testDump = layer.renderer().dump()
layer_parent = tree_layer.parent()
if layer_parent.parent() is None:
item = TreeLayerItem(self.iface, layer,
self.layersTree, dlg)
self.layers_item.addChild(item)
else:
if layer_parent not in tree_groups:
tree_groups.append(layer_parent)
except Exception:
QgsMessageLog.logMessage(traceback.format_exc(),
"qgis2web",
level=Qgis.Critical)
for tree_group in tree_groups:
group_name = tree_group.name()
group_layers = [
tree_layer.layer() for tree_layer in tree_group.findLayers()
]
item = TreeGroupItem(group_name, group_layers, self.layersTree)
self.layers_item.addChild(item)
self.layersTree.addTopLevelItem(self.layers_item)
self.layersTree.expandAll()
self.layersTree.resizeColumnToContents(0)
self.layersTree.resizeColumnToContents(1)
for i in range(self.layers_item.childCount()):
item = self.layers_item.child(i)
if item.checkState(0) != Qt.Checked:
item.setExpanded(False)
def populateLayerSearch(self):
self.layer_search_combo.clear()
self.layer_search_combo.addItem("None")
(layers, groups, popup, visible, interactive, json, cluster,
getFeatureInfo) = self.getLayersAndGroups()
for count, layer in enumerate(layers):
if layer.type() == layer.VectorLayer:
options = []
fields = layer.fields()
for f in fields:
fieldIndex = fields.indexFromName(f.name())
editorWidget = layer.editorWidgetSetup(fieldIndex).type()
if editorWidget == 'Hidden':
continue
options.append(f.name())
for option in options:
displayStr = layer.name() + ": " + option
self.layer_search_combo.insertItem(0, displayStr)
sln = utils.safeName(layer.name())
self.layer_search_combo.setItemData(
self.layer_search_combo.findText(displayStr),
sln + "_" + str(count))
def populateAttrFilter(self):
self.layer_filter_select.clear()
(layers, groups, popup, visible, interactive, json, cluster,
getFeatureInfo) = self.getLayersAndGroups()
options = []
for count, layer in enumerate(layers):
if layer.type() == layer.VectorLayer:
fields = layer.fields()
for f in fields:
fieldIndex = fields.indexFromName(f.name())
editorWidget = layer.editorWidgetSetup(fieldIndex).type()
if editorWidget == 'Hidden':
continue
if utils.boilType(f.typeName()) in [
"int", "str", "real", "date", "bool", "time",
"datetime"
]:
options.append([
f.name() + ": " + utils.boilType(f.typeName()),
layer.name()
])
preCleanOptions = {}
for entry in options:
if entry[0] not in list(preCleanOptions.keys()):
preCleanOptions[entry[0]] = ": " + entry[1]
else:
preCleanOptions[entry[0]] = "| ".join(
[preCleanOptions[entry[0]], entry[1]])
options = []
for key, value in preCleanOptions.items():
options.append(key + value)
cleanOptions = list(set(options))
for option in cleanOptions:
self.layer_filter_select.insertItem(0, option)
def configureExporter(self):
self.exporter.configure()
def populateConfigParams(self, dlg):
""" Populates the dialog with option items and widgets """
self.items = defaultdict(dict)
tree = dlg.appearanceParams
configure_export_action = QAction('...', self)
configure_export_action.triggered.connect(self.configureExporter)
params = getParams(configure_exporter_action=configure_export_action)
for group, settings in params.items():
if group != "Data export":
item = QTreeWidgetItem()
item.setText(0, group)
for param, value in settings.items():
subitem = self.createOptionItem(tree_widget=tree,
parent_item=item,
parameter=param,
default_value=value)
item.addChild(subitem)
self.items[group][param] = subitem
self.appearanceParams.addTopLevelItem(item)
item.sortChildren(0, Qt.AscendingOrder)
self.appearanceParams.expandAll()
self.appearanceParams.resizeColumnToContents(0)
self.appearanceParams.resizeColumnToContents(1)
self.layer_search_combo.removeItem(1)
self.layer_filter_select.takeItem(1)
# configure export params in separate tab
exportTree = dlg.exportParams
for group, settings in params.items():
if group == "Data export":
item = QTreeWidgetItem()
item.setText(0, group)
for param, value in settings.items():
subitem = self.createOptionItem(tree_widget=exportTree,
parent_item=item,
parameter=param,
default_value=value)
item.addChild(subitem)
self.items[group][param] = subitem
self.exportParams.addTopLevelItem(item)
item.sortChildren(0, Qt.AscendingOrder)
self.exportParams.expandAll()
self.exportParams.resizeColumnToContents(0)
self.exportParams.resizeColumnToContents(1)
def createOptionItem(self, tree_widget, parent_item, parameter,
default_value):
"""create the tree item corresponding to an option parameter"""
action = None
if isinstance(default_value, dict):
action = default_value['action']
default_value = default_value['option']
subitem = TreeSettingItem(parent_item, tree_widget, parameter,
default_value, action)
if parameter == 'Layer search':
self.layer_search_combo = subitem.combo
if parameter == 'Attribute filter':
self.layer_filter_select = subitem.list
elif parameter == 'Exporter':
self.exporter_combo = subitem.combo
return subitem
def setStateToWriter(self, writer):
"""
Sets the dialog state to match the specified writer
"""
self.selectMapFormat(writer)
self.setStateToParams(writer.params)
def setStateToParams(self, params):
"""
Sets the dialog state to match the specified parameters
"""
for group, settings in self.items.items():
for param, item in settings.items():
value = params[group][param]
item.setValue(value)
def selectMapFormat(self, writer):
"""
Updates dialog state to match the specified writer format
"""
self.ol3.setChecked(isinstance(writer, OpenLayersWriter))
self.leaflet.setChecked(isinstance(writer, LeafletWriter))
self.mapbox.setChecked(isinstance(writer, MapboxWriter))
def loadPreviewFile(self, file):
"""
Loads a web based preview from a local file path
"""
self.previewUrl = QUrl.fromLocalFile(file)
if self.preview:
self.preview.settings().clearMemoryCaches()
self.preview.setUrl(self.previewUrl)
def getParameters(self):
parameters = defaultdict(dict)
for group, settings in self.items.items():
for param, item in settings.items():
if param in ('Widget Icon', 'Widget Background'):
parameters[group][param] = item._value.color().name()
else:
parameters[group][param] = item.value()
if param == "Layer search":
parameters["Appearance"]["Search layer"] = (
self.layer_search_combo.itemData(
self.layer_search_combo.currentIndex()))
if param == "Attribute filter":
parameters["Appearance"]["Attribute filter"] = (
self.layer_filter_select.selectedItems())
return parameters
def saveParameters(self):
"""
Saves current dialog state to project
"""
WRITER_REGISTRY.saveWriterToProject(self.createWriter())
EXPORTER_REGISTRY.writeToProject(self.exporter)
def getLayersAndGroups(self):
layers = []
groups = {}
popup = []
visible = []
interactive = []
json = []
cluster = []
getFeatureInfo = []
for i in range(self.layers_item.childCount()):
item = self.layers_item.child(i)
if isinstance(item, TreeLayerItem):
if item.checkState(0) == Qt.Checked:
layers.append(item.layer)
popup.append(item.popup)
visible.append(item.visible)
interactive.append(item.interactive)
json.append(item.json)
cluster.append(item.cluster)
getFeatureInfo.append(item.getFeatureInfo)
else:
group = item.name
groupLayers = []
if item.checkState(0) != Qt.Checked:
continue
for layer in item.layers:
groupLayers.append(layer)
layers.append(layer)
popup.append({})
if item.visible:
visible.append(True)
else:
visible.append(False)
if item.interactive:
interactive.append(True)
else:
interactive.append(False)
if hasattr(item, "json") and item.json:
json.append(True)
else:
json.append(False)
if hasattr(item, "cluster") and item.cluster:
cluster.append(True)
else:
cluster.append(False)
if hasattr(item, "getFeatureInfo") and item.getFeatureInfo:
getFeatureInfo.append(True)
else:
getFeatureInfo.append(False)
groups[group] = groupLayers[::-1]
return (layers[::-1], groups, popup[::-1], visible[::-1],
interactive[::-1], json[::-1], cluster[::-1],
getFeatureInfo[::-1])
def reject(self):
self.saveParameters()
(layers, groups, popup, visible, interactive, json, cluster,
getFeatureInfo) = self.getLayersAndGroups()
try:
for layer, pop, vis, int in zip(layers, popup, visible,
interactive):
attrDict = {}
for attr in pop:
attrDict['attr'] = pop[attr]
layer.setCustomProperty("qgis2web/popup/" + attr,
pop[attr])
layer.setCustomProperty("qgis2web/Visible", vis)
layer.setCustomProperty("qgis2web/Interactive", int)
except Exception:
pass
QSettings().setValue("qgis2web/MainDialogGeometry",
self.saveGeometry())
QSettings().setValue("qgis2web/previewOnStartup",
self.previewOnStartup.checkState())
QSettings().setValue("qgis2web/closeFeedbackOnSuccess",
self.closeFeedbackOnSuccess.checkState())
QSettings().setValue("qgis2web/previewFeatureLimit",
self.previewFeatureLimit.text())
QDialog.close(self)
def closeEvent(self, event):
try:
if self.devConsole or self.devConsole.isVisible() and self.preview:
del self.devConsole
del self.preview
self.reject()
event.accept()
except Exception:
pass
def fillAlgorithmTreeUsingProviders(self):
self.algorithmTree.clear()
text = str(self.searchBox.text())
search_strings = text.split(' ')
qgis_groups = {}
for provider in QgsApplication.processingRegistry().providers():
if not provider.isActive():
continue
groups = {}
# Add algorithms
for alg in provider.algorithms():
if alg.flags() & QgsProcessingAlgorithm.FlagHideFromModeler:
continue
if alg.id() == self.model.id():
continue
item_text = [alg.displayName().lower()]
item_text.extend(alg.tags())
show = not search_strings or all(
any(part in t for t in item_text)
for part in search_strings)
if show:
if alg.group() in groups:
groupItem = groups[alg.group()]
elif provider.id() in (
'qgis', 'native') and alg.group() in qgis_groups:
groupItem = qgis_groups[alg.group()]
else:
groupItem = QTreeWidgetItem()
name = alg.group()
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groupItem.setFlags(Qt.ItemIsEnabled
| Qt.ItemIsSelectable)
if provider.id() in ('qgis', 'native'):
groupItem.setIcon(0, provider.icon())
qgis_groups[alg.group()] = groupItem
else:
groups[alg.group()] = groupItem
algItem = TreeAlgorithmItem(alg)
groupItem.addChild(algItem)
if len(groups) > 0:
providerItem = QTreeWidgetItem()
providerItem.setText(0, provider.name())
providerItem.setToolTip(0, provider.name())
providerItem.setIcon(0, provider.icon())
providerItem.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
for groupItem in list(groups.values()):
providerItem.addChild(groupItem)
self.algorithmTree.addTopLevelItem(providerItem)
providerItem.setExpanded(text != '')
for groupItem in list(groups.values()):
if text != '':
groupItem.setExpanded(True)
if len(qgis_groups) > 0:
for groupItem in list(qgis_groups.values()):
self.algorithmTree.addTopLevelItem(groupItem)
for groupItem in list(qgis_groups.values()):
if text != '':
groupItem.setExpanded(True)
self.algorithmTree.sortItems(0, Qt.AscendingOrder)
def collect_base_layer_summary(root, layer_data):
sublayers = layer_data.get('layers')
if sublayers:
item = QTreeWidgetItem(root)
item.setText(0, layer_data['name'])
for sublayer_data in sublayers:
collect_base_layer_summary(item, sublayer_data)
else:
resolutions = layer_data['resolutions']
if 'min_resolution' in layer_data:
resolutions = [
res for res in resolutions if res >= layer_data['min_resolution'] \
and res <= layer_data['max_resolution']]
scales = self.plugin.resolutions_to_scales(resolutions)
# Regular QGIS base layers
if layer_data['type'] not in ('blank', 'osm', 'mapbox',
'bing'):
if 'visibility_scale_max' in layer_data:
scale_visibility = 'Maximum (inclusive): {0}, Minimum (exclusive): {1}'.format(
layer_data['visibility_scale_max'],
layer_data['visibility_scale_min'])
else:
scale_visibility = ''
create_formatted_tree(
root, {
'{0}': [
"Extent: {1}", "CRS: {2}",
"Scale based visibility: {3}",
"Visible scales: {4}",
"Visible resolutions: {5}",
"Provider type: {6}", "Attribution",
["Title: {7}", "URL: {8}"], "Metadata",
[
"Title: {9}", "Abstract: {10}",
"Keyword list: {11}"
]
]
}, [
layer_data['name'], layer_data['extent'],
layer_data['projection'], scale_visibility, scales,
resolutions,
layer_data.get('provider_type', ''),
opt_value(layer_data, 'attribution.title'),
opt_value(layer_data, 'attribution.url'),
layer_data['metadata']['title'],
layer_data['metadata']['abstract'],
layer_data['metadata']['keyword_list']
])
# Special base layers
else:
layer_summary = [
"Name: {0}", "Abstract: {1}", "Keywords: {2}",
"Extent: {3}", "Visible scales: {4}",
"Visible resolutions: {5}"
]
if layer_data['type'] == 'mapbox':
layer_summary.append("MapId: {}".format(
layer_data['mapid']))
layer_summary.append("ApiKey: {}".format(
layer_data['apikey']))
elif layer_data['type'] == 'bing':
layer_summary.append("ApiKey: {}".format(
layer_data['apikey']))
create_formatted_tree(root, {'{0}': layer_summary}, [
layer_data['name'],
opt_value(layer_data, 'metadata.abstract'),
opt_value(layer_data, 'metadata.keyword_list'),
layer_data['extent'],
scales,
resolutions,
])
class GetScriptsAndModelsDialog(BASE, WIDGET):
HELP_TEXT = QCoreApplication.translate('GetScriptsAndModelsDialog',
'<h3> Processing resources manager </h3>'
'<p>Check/uncheck algorithms in the tree to select the ones that you '
'want to install or remove</p>'
'<p>Algorithms are divided in 3 groups:</p>'
'<ul><li><b>Installed:</b> Algorithms already in your system, with '
'the latest version available</li>'
'<li><b>Updatable:</b> Algorithms already in your system, but with '
'a newer version available in the server</li>'
'<li><b>Not installed:</b> Algorithms not installed in your '
'system</li></ul>')
MODELS = 0
SCRIPTS = 1
RSCRIPTS = 2
tr_disambiguation = {0: 'GetModelsAction',
1: 'GetScriptsAction',
2: 'GetRScriptsAction'}
def __init__(self, resourceType):
super(GetScriptsAndModelsDialog, self).__init__(iface.mainWindow())
self.setupUi(self)
self.manager = QgsNetworkAccessManager.instance()
repoUrl = ProcessingConfig.getSetting(ProcessingConfig.MODELS_SCRIPTS_REPO)
self.resourceType = resourceType
if self.resourceType == self.MODELS:
self.folder = ModelerUtils.modelsFolders()[0]
self.urlBase = '{}/models/'.format(repoUrl)
self.icon = QIcon(os.path.join(pluginPath, 'images', 'model.png'))
elif self.resourceType == self.SCRIPTS:
self.folder = ScriptUtils.scriptsFolders()[0]
self.urlBase = '{}/scripts/'.format(repoUrl)
self.icon = QIcon(os.path.join(pluginPath, 'images', 'script.png'))
else:
self.folder = RUtils.RScriptsFolders()[0]
self.urlBase = '{}/rscripts/'.format(repoUrl)
self.icon = QIcon(os.path.join(pluginPath, 'images', 'r.svg'))
self.lastSelectedItem = None
self.updateProvider = False
self.populateTree()
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.tree.currentItemChanged.connect(self.currentItemChanged)
def popupError(self, error=None, url=None):
"""Popups an Error message bar for network errors."""
disambiguation = self.tr_disambiguation[self.resourceType]
widget = iface.messageBar().createMessage(self.tr('Connection problem', disambiguation),
self.tr('Could not connect to scripts/models repository', disambiguation))
if error and url:
QgsMessageLog.logMessage(self.tr(u"Network error code: {} on URL: {}").format(error, url), self.tr(u"Processing"), QgsMessageLog.CRITICAL)
button = QPushButton(QCoreApplication.translate("Python", "View message log"), pressed=show_message_log)
widget.layout().addWidget(button)
iface.messageBar().pushWidget(widget, level=QgsMessageBar.CRITICAL, duration=5)
def grabHTTP(self, url, loadFunction, arguments=None):
"""Grab distant content via QGIS internal classes and QtNetwork."""
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
request = QUrl(url)
reply = self.manager.get(QNetworkRequest(request))
if arguments:
reply.finished.connect(partial(loadFunction, reply, arguments))
else:
reply.finished.connect(partial(loadFunction, reply))
def populateTree(self):
self.uptodateItem = QTreeWidgetItem()
self.uptodateItem.setText(0, self.tr('Installed'))
self.toupdateItem = QTreeWidgetItem()
self.toupdateItem.setText(0, self.tr('Updatable'))
self.notinstalledItem = QTreeWidgetItem()
self.notinstalledItem.setText(0, self.tr('Not installed'))
self.toupdateItem.setIcon(0, self.icon)
self.uptodateItem.setIcon(0, self.icon)
self.notinstalledItem.setIcon(0, self.icon)
self.grabHTTP(self.urlBase + 'list.txt', self.treeLoaded)
def treeLoaded(self, reply):
"""
update the tree of scripts/models whenever
HTTP request is finished
"""
QApplication.restoreOverrideCursor()
if reply.error() != QNetworkReply.NoError:
self.popupError(reply.error(), reply.request().url().toString())
else:
resources = unicode(reply.readAll()).splitlines()
resources = [r.split(',') for r in resources]
self.resources = {f: (v, n) for f, v, n in resources}
for filename, version, name in sorted(resources, key=lambda kv: kv[2].lower()):
treeBranch = self.getTreeBranchForState(filename, float(version))
item = TreeItem(filename, name, self.icon)
treeBranch.addChild(item)
if treeBranch != self.notinstalledItem:
item.setCheckState(0, Qt.Checked)
reply.deleteLater()
self.tree.addTopLevelItem(self.toupdateItem)
self.tree.addTopLevelItem(self.notinstalledItem)
self.tree.addTopLevelItem(self.uptodateItem)
self.txtHelp.setHtml(self.HELP_TEXT)
def setHelp(self, reply, item):
"""Change the HTML content"""
QApplication.restoreOverrideCursor()
if reply.error() != QNetworkReply.NoError:
html = self.tr('<h2>No detailed description available for this script</h2>')
else:
content = unicode(reply.readAll())
descriptions = json.loads(content)
html = '<h2>%s</h2>' % item.name
html += self.tr('<p><b>Description:</b> %s</p>') % getDescription(ALG_DESC, descriptions)
html += self.tr('<p><b>Created by:</b> %s') % getDescription(ALG_CREATOR, descriptions)
html += self.tr('<p><b>Version:</b> %s') % getDescription(ALG_VERSION, descriptions)
reply.deleteLater()
self.txtHelp.setHtml(html)
def currentItemChanged(self, item, prev):
if isinstance(item, TreeItem):
url = self.urlBase + item.filename.replace(' ', '%20') + '.help'
self.grabHTTP(url, self.setHelp, item)
else:
self.txtHelp.setHtml(self.HELP_TEXT)
def getTreeBranchForState(self, filename, version):
if not os.path.exists(os.path.join(self.folder, filename)):
return self.notinstalledItem
else:
helpFile = os.path.join(self.folder, filename + '.help')
try:
with open(helpFile) as f:
helpContent = json.load(f)
currentVersion = float(helpContent[Help2Html.ALG_VERSION])
except Exception:
currentVersion = 0
if version > currentVersion:
return self.toupdateItem
else:
return self.uptodateItem
def cancelPressed(self):
super(GetScriptsAndModelsDialog, self).reject()
def storeFile(self, reply, filename):
"""store a script/model that has been downloaded"""
QApplication.restoreOverrideCursor()
if reply.error() != QNetworkReply.NoError:
if os.path.splitext(filename)[1].lower() == '.help':
content = '{"ALG_VERSION" : %s}' % self.resources[filename[:-5]][0]
else:
self.popupError(reply.error(), reply.request().url().toString())
content = None
else:
content = reply.readAll()
reply.deleteLater()
if content:
path = os.path.join(self.folder, filename)
with open(path, 'w') as f:
f.write(content)
self.progressBar.setValue(self.progressBar.value() + 1)
def okPressed(self):
toDownload = []
for i in xrange(self.toupdateItem.childCount()):
item = self.toupdateItem.child(i)
if item.checkState(0) == Qt.Checked:
toDownload.append(item.filename)
for i in xrange(self.notinstalledItem.childCount()):
item = self.notinstalledItem.child(i)
if item.checkState(0) == Qt.Checked:
toDownload.append(item.filename)
if toDownload:
self.progressBar.setMaximum(len(toDownload) * 2)
for i, filename in enumerate(toDownload):
QCoreApplication.processEvents()
url = self.urlBase + filename.replace(' ', '%20')
self.grabHTTP(url, self.storeFile, filename)
url += '.help'
self.grabHTTP(url, self.storeFile, filename + '.help')
toDelete = []
for i in xrange(self.uptodateItem.childCount()):
item = self.uptodateItem.child(i)
if item.checkState(0) == Qt.Unchecked:
toDelete.append(item.filename)
# Remove py and help files if they exist
for filename in toDelete:
for pathname in (filename, filename + u".help"):
path = os.path.join(self.folder, pathname)
if os.path.exists(path):
os.remove(path)
self.updateProvider = len(toDownload) + len(toDelete) > 0
super(GetScriptsAndModelsDialog, self).accept()
def on_btnAdd_clicked(self):
item = QTreeWidgetItem()
item.setText(0, '0.00')
item.setText(1, '0.00')
item.setBackground(2, QBrush(QColor(127, 127, 127)))
self.reliefClassTree.addTopLevelItem(item)
def populate(self):
groups = {}
count = 0
provider = algList.algs[self.providerName]
algs = list(provider.values())
name = 'ACTIVATE_' + self.providerName.upper().replace(' ', '_')
active = ProcessingConfig.getSetting(name)
# Add algorithms
for alg in algs:
if not alg.showInToolbox:
continue
if alg.group in groups:
groupItem = groups[alg.group]
else:
groupItem = QTreeWidgetItem()
name = alg.i18n_group or alg.group
if not active:
groupItem.setForeground(0, Qt.darkGray)
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groups[alg.group] = groupItem
algItem = TreeAlgorithmItem(alg)
if not active:
algItem.setForeground(0, Qt.darkGray)
groupItem.addChild(algItem)
count += 1
actions = Processing.actions[self.providerName]
for action in actions:
if action.group in groups:
groupItem = groups[action.group]
else:
groupItem = QTreeWidgetItem()
groupItem.setText(0, action.group)
groups[action.group] = groupItem
algItem = TreeActionItem(action)
groupItem.addChild(algItem)
text = self.provider.getDescription()
if not active:
def activateProvider():
self.toolbox.activateProvider(self.providerName)
label = QLabel(text +
" <a href='%s'>Activate</a>")
label.setStyleSheet(
"QLabel {background-color: white; color: grey;}")
label.linkActivated.connect(activateProvider)
self.tree.setItemWidget(self, 0, label)
else:
text += QCoreApplication.translate(
"TreeProviderItem", " [{0} geoalgorithms]").format(count)
self.setText(0, text)
self.setToolTip(0, self.text(0))
for groupItem in list(groups.values()):
self.addChild(groupItem)
self.setHidden(self.childCount() == 0)
def populate(self):
groups = {}
count = 0
algs = self.provider.algorithms()
active = self.provider.isActive()
# Add algorithms
for alg in algs:
if alg.flags() & QgsProcessingAlgorithm.FlagHideFromToolbox:
continue
if alg.group() in groups:
groupItem = groups[alg.group()]
else:
groupItem = QTreeWidgetItem()
name = alg.group()
if not active:
groupItem.setForeground(0, Qt.darkGray)
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
groups[alg.group()] = groupItem
algItem = TreeAlgorithmItem(alg)
if not active:
algItem.setForeground(0, Qt.darkGray)
groupItem.addChild(algItem)
count += 1
if self.provider.id() in ProviderActions.actions:
actions = ProviderActions.actions[self.provider.id()]
for action in actions:
if action.group in groups:
groupItem = groups[action.group]
else:
groupItem = QTreeWidgetItem()
groupItem.setText(0, action.group)
groups[action.group] = groupItem
algItem = TreeActionItem(action)
groupItem.addChild(algItem)
text = self.provider.name()
if not active:
def activateProvider():
self.toolbox.activateProvider(self.provider.id())
label = QLabel(text +
" <a href='%s'>Activate</a>")
label.setStyleSheet(
"QLabel {background-color: white; color: grey;}")
label.linkActivated.connect(activateProvider)
self.tree.setItemWidget(self, 0, label)
else:
text += QCoreApplication.translate(
"TreeProviderItem", " [{0} geoalgorithms]").format(count)
self.setText(0, text)
self.setToolTip(0, self.text(0))
for groupItem in list(groups.values()):
self.addChild(groupItem)
self.setHidden(self.childCount() == 0)
def addAlgorithmsFromProvider(self, provider, parent):
groups = {}
count = 0
algs = provider.algorithms()
active = provider.isActive()
# Add algorithms
for alg in algs:
if alg.flags() & QgsProcessingAlgorithm.FlagHideFromToolbox:
continue
groupItem = None
if alg.group() in groups:
groupItem = groups[alg.group()]
else:
# check if group already exists
for i in range(parent.childCount()):
if parent.child(i).text(0) == alg.group():
groupItem = parent.child(i)
groups[alg.group()] = groupItem
break
if not groupItem:
groupItem = QTreeWidgetItem()
name = alg.group()
if not active:
groupItem.setForeground(0, Qt.darkGray)
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
if provider.id() in ('qgis', 'native'):
groupItem.setIcon(0, provider.icon())
groups[alg.group()] = groupItem
algItem = TreeAlgorithmItem(alg)
if not active:
algItem.setForeground(0, Qt.darkGray)
groupItem.addChild(algItem)
count += 1
if provider.id() in ProviderActions.actions:
actions = ProviderActions.actions[provider.id()]
for action in actions:
if action.group in groups:
groupItem = groups[action.group]
else:
groupItem = QTreeWidgetItem()
groupItem.setText(0, action.group)
groups[action.group] = groupItem
algItem = TreeActionItem(action)
groupItem.addChild(algItem)
text = provider.name()
if not provider.id() in ('qgis', 'native'):
if not active:
def activateProvider():
self.activateProvider(provider.id())
label = QLabel(text + " <a href='%s'>Activate</a>")
label.setStyleSheet("QLabel {background-color: white; color: grey;}")
label.linkActivated.connect(activateProvider)
self.algorithmTree.setItemWidget(item, 0, label)
else:
text += QCoreApplication.translate("TreeProviderItem", " [{0} geoalgorithms]").format(count)
parent.setText(0, text)
parent.setToolTip(0, parent.text(0))
for groupItem in list(groups.values()):
parent.addChild(groupItem)
if not provider.id() in ('qgis', 'native'):
parent.setHidden(parent.childCount() == 0)
def addAlgorithmsFromProvider(self, provider, parent):
groups = {}
count = 0
algs = provider.algorithms()
active = provider.isActive()
# Add algorithms
for alg in algs:
if alg.flags() & QgsProcessingAlgorithm.FlagHideFromToolbox:
continue
groupItem = None
if alg.group() in groups:
groupItem = groups[alg.group()]
else:
# check if group already exists
for i in range(parent.childCount()):
if parent.child(i).text(0) == alg.group():
groupItem = parent.child(i)
groups[alg.group()] = groupItem
break
if not groupItem:
groupItem = QTreeWidgetItem()
name = alg.group()
if not active:
groupItem.setForeground(0, Qt.darkGray)
groupItem.setText(0, name)
groupItem.setToolTip(0, name)
if provider.id() in ('qgis', 'native'):
groupItem.setIcon(0, provider.icon())
groups[alg.group()] = groupItem
algItem = TreeAlgorithmItem(alg)
if not active:
algItem.setForeground(0, Qt.darkGray)
groupItem.addChild(algItem)
count += 1
if provider.id() in ProviderActions.actions:
actions = ProviderActions.actions[provider.id()]
for action in actions:
if action.group in groups:
groupItem = groups[action.group]
else:
groupItem = QTreeWidgetItem()
groupItem.setText(0, action.group)
groups[action.group] = groupItem
algItem = TreeActionItem(action)
groupItem.addChild(algItem)
text = provider.name()
if not provider.id() in ('qgis', 'native'):
if not active:
def activateProvider():
self.activateProvider(provider.id())
label = QLabel(text + " <a href='%s'>Activate</a>")
label.setStyleSheet("QLabel {background-color: white; color: grey;}")
label.linkActivated.connect(activateProvider)
self.algorithmTree.setItemWidget(item, 0, label)
else:
text += QCoreApplication.translate("TreeProviderItem", " [{0} geoalgorithms]").format(count)
parent.setText(0, text)
parent.setToolTip(0, parent.text(0))
for groupItem in list(groups.values()):
parent.addChild(groupItem)
if not provider.id() in ('qgis', 'native'):
parent.setHidden(parent.childCount() == 0)
def update_available_layers(self):
self.trw_layers.setUpdatesEnabled(
False) # Don't render until we're ready
# Grab some context data
show_domains = self.chk_show_domains.isChecked()
show_structures = self.chk_show_structures.isChecked()
show_associations = self.chk_show_associations.isChecked()
top_level_items_expanded_info = []
for i in range(self.trw_layers.topLevelItemCount()):
top_level_items_expanded_info.append(
self.trw_layers.topLevelItem(i).isExpanded())
# Save selection
self.update_selected_items()
# Iterate models adding children
self.trw_layers.blockSignals(
True) # We don't want to get itemSelectionChanged here
self.trw_layers.clear()
self.trw_layers.blockSignals(False)
sorted_models = sorted(self.models_tree.keys())
for model in sorted_models:
children = []
model_item = QTreeWidgetItem([model])
# Filter by search text
list_tables = self.filter_tables_by_search_text(
self.models_tree[model].keys(), self.txt_search_text.text())
sorted_tables = sorted(list_tables)
for table in sorted_tables:
current_table_info = self.models_tree[model][table]
if current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_DOMAIN and not show_domains \
or current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_STRUCTURE and not show_structures \
or current_table_info[QueryNames.KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_ASSOCIATION and not show_associations:
continue
table_item = QTreeWidgetItem([table])
table_item.setData(0, Qt.UserRole,
self.models_tree[model][table])
geometry_type = QgsWkbTypes().geometryType(
QgsWkbTypes().parseType(current_table_info[
QueryNames.GEOMETRY_TYPE_MODEL_BAKER])
) if current_table_info[
QueryNames.GEOMETRY_TYPE_MODEL_BAKER] else None
icon_name = self.icon_names[
3 if geometry_type is None else geometry_type]
# Is the layer already loaded in canvas?
if self.app.core.get_ladm_layer_from_qgis(
self._db,
current_table_info[QueryNames.TABLE_NAME_MODEL_BAKER],
EnumLayerRegistryType.IN_LAYER_TREE) is not None:
table_item.setText(
0, table + QCoreApplication.translate(
"LoadLayersDialog", " [already loaded]"))
table_item.setData(0, Qt.ForegroundRole,
QBrush(Qt.lightGray))
table_item.setFlags(Qt.ItemIsEnabled) # Not selectable
else: # Laye not in QGIS Layer Tree
if not current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER]: # This is a class
font = QFont()
font.setBold(True)
table_item.setData(0, Qt.FontRole, font)
if current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_DOMAIN:
icon_name = self.icon_names[4]
elif current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_STRUCTURE:
if geometry_type is None:
icon_name = self.icon_names[5]
elif current_table_info[
QueryNames.
KIND_SETTINGS_MODEL_BAKER] == ILI2DBNames.TABLE_PROP_ASSOCIATION:
icon_name = self.icon_names[6]
icon = QIcon(":/Asistente-LADM-COL/resources/images/{}".format(
icon_name))
table_item.setData(0, Qt.DecorationRole, icon)
children.append(table_item)
model_item.addChildren(children)
self.trw_layers.addTopLevelItem(model_item)
# Set selection
iterator = QTreeWidgetItemIterator(self.trw_layers,
QTreeWidgetItemIterator.Selectable)
self.trw_layers.blockSignals(
True) # We don't want to get itemSelectionChanged here
while iterator.value():
item = iterator.value()
if item.text(0) in self.selected_items_dict:
item.setSelected(True)
iterator += 1
self.trw_layers.blockSignals(False)
# Make model items non selectable
# Set expand taking previous states into account
for i in range(self.trw_layers.topLevelItemCount()):
self.trw_layers.topLevelItem(i).setFlags(
Qt.ItemIsEnabled) # Not selectable
self.trw_layers.topLevelItem(i).setExpanded(
top_level_items_expanded_info[i]
if top_level_items_expanded_info else True)
self.trw_layers.setUpdatesEnabled(True) # Now render!
def on_btnAdd_clicked(self):
item = QTreeWidgetItem()
item.setText(0, '0.00')
item.setText(1, '0.00')
item.setBackground(2, QBrush(QColor(127, 127, 127)))
self.reliefClassTree.addTopLevelItem(item)
def populate_classified_values(
unassigned_values, assigned_values, default_classes,
list_unique_values, tree_mapping_widget):
"""Populate lstUniqueValues and treeClasses.from the parameters.
:param unassigned_values: List of values that haven't been assigned
to a class. It will be put in list_unique_values.
:type unassigned_values: list
:param assigned_values: Dictionary with class as the key and list of
value as the value of the dictionary. It will be put in
tree_mapping_widget.
:type assigned_values: dict
:param default_classes: Default classes from unit.
:type default_classes: list
:param list_unique_values: List Widget for unique values
:type list_unique_values: QListWidget
:param tree_mapping_widget: Tree Widget for classifying.
:type tree_mapping_widget: QTreeWidget
"""
# Populate the unique values list
list_unique_values.clear()
list_unique_values.setSelectionMode(
QAbstractItemView.ExtendedSelection)
for value in unassigned_values:
value_as_string = value is not None and str(value) or 'NULL'
list_item = QListWidgetItem(list_unique_values)
list_item.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
list_item.setData(Qt.UserRole, value)
list_item.setText(value_as_string)
list_unique_values.addItem(list_item)
# Populate assigned values tree
tree_mapping_widget.clear()
bold_font = QFont()
bold_font.setItalic(True)
bold_font.setBold(True)
bold_font.setWeight(75)
tree_mapping_widget.invisibleRootItem().setFlags(
Qt.ItemIsEnabled)
for default_class in default_classes:
# Create branch for class
tree_branch = QTreeWidgetItem(tree_mapping_widget)
tree_branch.setFlags(
Qt.ItemIsDropEnabled | Qt.ItemIsEnabled)
tree_branch.setExpanded(True)
tree_branch.setFont(0, bold_font)
if 'name' in default_class:
default_class_name = default_class['name']
else:
default_class_name = default_class['key']
tree_branch.setText(0, default_class_name)
tree_branch.setData(0, Qt.UserRole, default_class['key'])
if 'description' in default_class:
tree_branch.setToolTip(0, default_class['description'])
# Assign known values
for value in assigned_values[default_class['key']]:
string_value = value is not None and str(value) or 'NULL'
tree_leaf = QTreeWidgetItem(tree_branch)
tree_leaf.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
tree_leaf.setData(0, Qt.UserRole, value)
tree_leaf.setText(0, string_value)
def data(self, profile_data):
"""Set data for the widget.
:param profile_data: profile data.
:type profile_data: dict
It will replace the previous data.
"""
default_profile = generate_default_profile()
self.clear()
for hazard in sorted(default_profile.keys()):
classifications = default_profile[hazard]
hazard_widget_item = QTreeWidgetItem()
hazard_widget_item.setData(0, Qt.UserRole, hazard)
hazard_widget_item.setText(0, get_name(hazard))
for classification in sorted(classifications.keys()):
# Filter out classification that doesn't support population.
# TODO(IS): This is not the best place to put the filtering.
# It's more suitable in the generate_default_profile method
# in safe/definitions/utilities.
classification_definition = definition(classification)
supported_exposures = classification_definition.get(
'exposures', [])
# Empty list means support all exposure
if supported_exposures != []:
if exposure_population not in supported_exposures:
continue
classes = classifications[classification]
classification_widget_item = QTreeWidgetItem()
classification_widget_item.setData(0, Qt.UserRole,
classification)
classification_widget_item.setText(0, get_name(classification))
hazard_widget_item.addChild(classification_widget_item)
for the_class, the_value in list(classes.items()):
the_class_widget_item = QTreeWidgetItem()
the_class_widget_item.setData(0, Qt.UserRole, the_class)
the_class_widget_item.setText(
0, get_class_name(the_class, classification))
classification_widget_item.addChild(the_class_widget_item)
# Adding widget must be happened after addChild
affected_check_box = QCheckBox(self)
# Set from profile_data if exist, else get default
profile_value = profile_data.get(hazard, {}).get(
classification, {}).get(the_class, the_value)
affected_check_box.setChecked(profile_value['affected'])
self.setItemWidget(the_class_widget_item, 1,
affected_check_box)
displacement_rate_spinbox = PercentageSpinBox(self)
displacement_rate_spinbox.setValue(
profile_value['displacement_rate'])
displacement_rate_spinbox.setEnabled(
profile_value['affected'])
self.setItemWidget(the_class_widget_item, 2,
displacement_rate_spinbox)
# Behaviour when the check box is checked
# noinspection PyUnresolvedReferences
affected_check_box.stateChanged.connect(
displacement_rate_spinbox.setEnabled)
if hazard_widget_item.childCount() > 0:
self.widget_items.append(hazard_widget_item)
self.addTopLevelItems(self.widget_items)
self.expandAll()
def fillTree(self):
layersItem = QTreeWidgetItem()
layersItem.setText(0, self.tr('Values from data layers extents'))
self.treeValues.addTopLevelItem(layersItem)
layers = dataobjects.getAllLayers()
for layer in layers:
layerItem = QTreeWidgetItem()
layerItem.setText(0, unicode(layer.name()))
layerItem.addChild(TreeValueItem(self.tr('Min X'),
layer.extent().xMinimum()))
layerItem.addChild(TreeValueItem(self.tr('Max X'),
layer.extent().xMaximum()))
layerItem.addChild(TreeValueItem(self.tr('Min Y'),
layer.extent().yMinimum()))
layerItem.addChild(TreeValueItem(self.tr('Max Y'),
layer.extent().yMaximum()))
if isinstance(layer, QgsRasterLayer):
cellsize = (layer.extent().xMaximum()
- layer.extent().xMinimum()) / layer.width()
layerItem.addChild(TreeValueItem(self.tr('Cellsize'),
cellsize))
layersItem.addChild(layerItem)
layersItem = QTreeWidgetItem()
layersItem.setText(0, self.tr('Values from raster layers statistics'))
self.treeValues.addTopLevelItem(layersItem)
layers = dataobjects.getRasterLayers()
for layer in layers:
for i in range(layer.bandCount()):
stats = layer.dataProvider().bandStatistics(i + 1)
layerItem = QTreeWidgetItem()
layerItem.setText(0, unicode(layer.name()))
layerItem.addChild(TreeValueItem(self.tr('Mean'), stats.mean))
layerItem.addChild(TreeValueItem(self.tr('Std. deviation'),
stats.stdDev))
layerItem.addChild(TreeValueItem(self.tr('Max value'),
stats.maximumValue))
layerItem.addChild(TreeValueItem(self.tr('Min value'),
stats.minimumValue))
layersItem.addChild(layerItem)
canvasItem = QTreeWidgetItem()
canvasItem.setText(0, self.tr('Values from QGIS map canvas'))
self.treeValues.addTopLevelItem(canvasItem)
extent = iface.mapCanvas().extent()
extentItem = QTreeWidgetItem()
extentItem.setText(0, self.tr('Current extent'))
extentItem.addChild(TreeValueItem(self.tr('Min X'), extent.xMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max X'), extent.xMaximum()))
extentItem.addChild(TreeValueItem(self.tr('Min Y'), extent.yMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max Y'), extent.yMaximum()))
canvasItem.addChild(extentItem)
extent = iface.mapCanvas().fullExtent()
extentItem = QTreeWidgetItem()
extentItem.setText(0,
self.tr('Full extent of all layers in map canvas'))
extentItem.addChild(TreeValueItem(self.tr('Min X'), extent.xMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max X'), extent.xMaximum()))
extentItem.addChild(TreeValueItem(self.tr('Min Y'), extent.yMinimum()))
extentItem.addChild(TreeValueItem(self.tr('Max Y'), extent.yMaximum()))
canvasItem.addChild(extentItem)
