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 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 _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 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 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 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 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 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 __setupModelData(self):
dsList = DataSourcesList().data_sources.values()
groupInfoList = GroupsList().groups
groupsItems = []
groups = []
for ds in dsList:
if ds.group in groups:
group_item = groupsItems[groups.index(ds.group)]
else:
group_item = QTreeWidgetItem()
group_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.group)
group_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
group_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole, ds.category)
group_item.setCheckState(self.COLUMN_VISIBILITY, Qt.Unchecked)
groupInfo = groupInfoList.get(ds.group)
if groupInfo is not None:
group_item.setIcon(self.COLUMN_GROUP_DS, QIcon(groupInfo.icon))
else:
group_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.group + " (%s!)" % self.tr("group not found"))
group_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole, groupInfo)
groups.append(ds.group)
groupsItems.append(group_item)
self.rootItem.addChild(group_item)
ds_item = QTreeWidgetItem()
ds_item.setData(self.COLUMN_GROUP_DS, Qt.DisplayRole, ds.alias)
ds_item.setIcon(self.COLUMN_GROUP_DS, QIcon(ds.icon_path))
ds_item.setData(self.COLUMN_GROUP_DS, Qt.UserRole, ds)
ds_item.setData(self.COLUMN_VISIBILITY, Qt.DisplayRole, "")
ds_item.setData(self.COLUMN_SOURCE, Qt.DisplayRole, ds.category)
ds_check_state = Qt.Checked
if ds.id in PluginSettings.get_hide_ds_id_list():
ds_check_state = Qt.Unchecked
ds_item.setCheckState(self.COLUMN_VISIBILITY, ds_check_state)
if group_item.childCount() != 0 and group_item.checkState(1) != ds_check_state:
group_item.setCheckState(self.COLUMN_VISIBILITY, Qt.PartiallyChecked)
else:
group_item.setCheckState(self.COLUMN_VISIBILITY, ds_check_state)
group_item.addChild(
ds_item
)
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 __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 updateUiManyToManyPolymorphic(self):
layer = self.relation().referencingLayer()
request = self.relation().getRelatedFeaturesRequest(self.feature())
layerFeature = dict()
for linkFeature in layer.getFeatures(request):
for relation in self._polymorphicRelation.generateRelations():
referencedFeatureRequest = relation.getReferencedFeatureRequest(
linkFeature)
filterExpression = referencedFeatureRequest.filterExpression()
nmRequest = QgsFeatureRequest()
nmRequest.setFilterExpression(filterExpression.expression())
finalLayer = relation.referencedLayer()
for finalFeature in finalLayer.getFeatures(nmRequest):
features = finalFeature, linkFeature
if finalLayer in layerFeature:
layerFeature[finalLayer].append(features)
else:
layerFeature[finalLayer] = [features]
for layer in layerFeature:
treeWidgetItemLayer = QTreeWidgetItem(self.mFeaturesTreeWidget,
[layer.name()])
treeWidgetItemLayer.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Layer)
treeWidgetItemLayer.setData(0, TreeWidgetItemRole.Layer, layer)
treeWidgetItemLayer.setIcon(0, QgsIconUtils.iconForLayer(layer))
for feature, linkFeature in layerFeature[layer]:
treeWidgetItem = QTreeWidgetItem(treeWidgetItemLayer, [
QgsVectorLayerUtils.getFeatureDisplayString(
layer, feature)
])
treeWidgetItem.setData(0, TreeWidgetItemRole.Type,
TreeWidgetItemType.Feature)
treeWidgetItem.setData(0, TreeWidgetItemRole.Layer, layer)
treeWidgetItem.setData(0, TreeWidgetItemRole.Feature, feature)
treeWidgetItem.setData(0, TreeWidgetItemRole.LinkFeature,
linkFeature)
treeWidgetItemLayer.setExpanded(True)
def is_folder(self, tree, tree_element, path_info, check_format, sorting):
"""
Add folder to the tree structure in QTreeWidget
:param tree: QTreeWidget element where to display the folder and file architecture
:type tree: QTreeWidget
:param tree_element: Current element in the os.listdir(startpath)
:type tree_element: list
:param path_info: Path of the current element in the os.listdir(startpath)
:type path_info: str
:param check_format: Dict of extension user choose to see
:type check_format: dict
"""
parent_itm = QTreeWidgetItem(tree, tree_element)
self.load_project_structure(path_info, parent_itm, check_format,
sorting)
parent_itm.setIcon(
0, QIcon(':/plugins/plugin_compiler/icons/mIconFolder.png'))
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 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 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 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()
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()
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 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)
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()
class MapStoryExplorer(BASE, WIDGET):
def __init__(self):
super(MapStoryExplorer, self).__init__(None)
self.story = None
self.currentLayerItem = None
self.setupUi(self)
self.setAllowedAreas(Qt.RightDockWidgetArea | Qt.LeftDockWidgetArea)
self.layersTree.itemClicked.connect(self.treeItemClicked)
self.layerDescription.setOpenLinks(False)
self.layerDescription.anchorClicked.connect(self.layerDescriptionLinkClicked)
self.layerDescription.setFocusPolicy(Qt.NoFocus)
self.storyDescription.setOpenLinks(False)
self.storyDescription.anchorClicked.connect(self.storyDescriptionLinkClicked)
self.storyDescription.setFocusPolicy(Qt.NoFocus)
with open(resourceFile("layerdescription.css")) as f:
sheet = "".join(f.readlines())
self.layerDescription.document().setDefaultStyleSheet(sheet)
self.storyDescription.document().setDefaultStyleSheet(sheet)
if qtVersion < 5:
self.layersTree.header().setResizeMode(0, QHeaderView.Stretch)
self.layersTree.header().setResizeMode(1, QHeaderView.ResizeToContents)
self.updateCurrentStory(None)
def storyDescriptionLinkClicked(self, url):
url = url.toString()
if url == "search":
dlg = SearchDialog()
dlg.exec_()
if dlg.mapstory is not None:
story = Story.storyFromNumberId(dlg.mapstory)
if story is None:
QMessageBox.warning(iface.mainWindow(), "MapStory", "Cannot get MapStory data.\nCheck that the provided ID is correct.")
else:
self.updateCurrentStory(story)
elif url == "download":
outDir = QFileDialog.getExistingDirectory(self,
self.tr("Select output directory"),
"."
)
if not outDir:
return
QDir().mkpath(outDir)
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
startProgressBar(len(self.story.storyLayers()), "Download layers for off-line use:")
for i, layer in enumerate(self.story.storyLayers()):
filename = os.path.join(outDir, layer.name() + ".shp")
uri = "%s?srsname=%s&typename=geonode:%s&version=1.0.0&request=GetFeature&service=WFS" % (layer.wfsUrl(), layer.crs(), layer.name())
qgslayer = QgsVectorLayer(uri, layer.name(), "WFS")
writer = QgsVectorFileWriter(filename, systemEncoding,
qgslayer.pendingFields(),
qgslayer.dataProvider().geometryType(),
qgslayer.crs())
for feat in qgslayer.getFeatures():
writer.addFeature(feat)
del writer
fieldname = self._getTimeField(qgslayer)
if fieldname is not None:
filename = os.path.join(outDir, layer.name() + ".timefield")
with open(filename, "w") as f:
f.write(fieldname)
setProgress(i+1)
closeProgressBar()
iface.messageBar().pushMessage("MapStory", "Layers have been correctly saved as QGIS project.", level=QgsMessageBar.INFO, duration=3)
def _getTimeField(self, layer):
fields = layer.pendingFields()
for f in fields:
if f.typeName() == "xsd:dateTime":
return f.name()
def layerDescriptionLinkClicked(self, url):
url = url.toString()
service, url, name, crs = url.split("|")
if service == "wms":
uri = "url=%s&styles=&layers=%s&format=image/png&crs=%s" % (url,name, crs)
qgslayer = execute(lambda: QgsRasterLayer(uri, name, "wms"))
if not qgslayer.isValid():
raise Exception ("Layer at %s is not a valid layer" % uri)
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
timeValues = self.story.storyLayerFromName(name).wmsTimeValues()
addWmsAnimation(qgslayer, timeValues)
elif service == "wfs":
def f():
crs = iface.mapCanvas().mapRenderer().destinationCrs()
uri = "%s?srsname=%s&typename=geonode:%s&version=1.0.0&request=GetFeature&service=WFS" % (url, crs.authid(), name)
qgslayer = QgsVectorLayer(uri, name, "WFS")
if not qgslayer.isValid():
raise Exception ("Layer at %s is not a valid layer" % uri)
fieldname = self._getTimeField(qgslayer)
if fieldname is None:
QgsMapLayerRegistry.instance().addMapLayers([qgslayer])
else:
memlayer = QgsVectorLayer("%s?crs=%s" % (GEOM_TYPE_MAP[qgslayer.wkbType()], crs.authid()), name, "memory")
memlayer.startEditing()
for field in qgslayer.pendingFields():
memlayer.addAttribute(field)
for feat in qgslayer.getFeatures():
memlayer.addFeatures([feat])
memlayer.commitChanges()
QgsMapLayerRegistry.instance().addMapLayers([memlayer])
memlayer.setSelectedFeatures([])
addWfsAnimation(memlayer, fieldname)
execute(f)
def updateCurrentStory(self, story):
self.layersTree.clear()
self.currentLayerItem = None
self.story = story
if story is None:
self.storyDescription.setText("No MapStory selected. <a href='search'>[Click to open a MapStory]</a>")
return
self.storyDescription.setText(story.description())
self.layersItem = QTreeWidgetItem()
self.layersItem.setText(0, "Layers")
self.layersItem.setIcon(0, layersIcon)
for layer in story.storyLayers():
item = LayerItem(layer)
self.layersItem.addChild(item)
self.layersTree.addTopLevelItem(self.layersItem)
self.layersItem.setExpanded(True)
def treeItemClicked(self, item, i):
if self.currentLayerItem == item:
return
self.currentLayerItem = item
if isinstance(item, LayerItem):
self.updateCurrentLayer()
def updateCurrentLayer(self):
self.layerDescription.setText(self.currentLayerItem.layer.description())
def __init__(self, parent=None):
"""Constructor."""
QDialog.__init__(self)
self.parent = parent
self.setupUi(self)
self.menu.clicked.connect(self.expand)
self.menu.clicked.connect(self.display_content)
self.tree_menu = [
{
'label':
'Import',
'icon':
resource('import.png'),
'content': [{
'label': 'Shapefile',
'icon': resource('shp.png'),
'content': {
'widget': OpenShapefileWidget(),
'help': help_open_shapefile()
}
}, {
'label': 'Raster',
'icon': resource('raster.png'),
'content': {
'widget': OpenRasterWidget(),
'help': help_open_raster()
}
}, {
'label': 'Table XLS/DBF',
'icon': resource('xls.png'),
'content': {
'widget': OpenXlsDbfFileWidget(),
'help': help_open_table()
}
}, {
'label': 'Table CSV',
'icon': resource('csv.png'),
'content': {
'widget': OpenCsv(),
'help': help_open_csv()
}
}, {
'label': 'XY to map',
'icon': resource('xy.png'),
'content': {
'widget': OpenCsv(),
'help': help_open_csv()
}
}]
},
{
'label':
'Analyse',
'icon':
resource('gears.png'),
'content': [{
'label':
'Blur',
'icon':
resource('blur.png'),
'content': [{
'label': 'Blur',
'icon': resource('blur.png'),
'content': {
'widget': BlurWidget(),
'help': help_blur()
}
}, {
'label': 'Stats',
'icon': resource('sigma.png'),
'content': {
'widget': StatsWidget(),
'help': help_stats_blurring()
}
}]
}, {
'label':
'Autocorrelation',
'icon':
resource('autocorrelation.png'),
'content': [{
'label': 'Polygon layer only',
'icon': resource('autocorrelation.png'),
'content': {
'widget': AutocorrelationDialog(),
'help': help_autocorrelation()
}
}]
}, {
'label':
'Composite Index',
'icon':
resource('composite_index.png'),
'content': [{
'label': 'Polygon layer only',
'icon': resource('composite_index.png'),
'content': {
'widget': CompositeIndexDialog(),
'help': help_composite_index()
}
}]
}, {
'label':
'Incidence',
'icon':
resource('incidence.png'),
'content': [{
'label': 'Polygon layer only',
'icon': resource('incidence.png'),
'content': {
'widget': IncidenceDialog(),
'help': help_incidence()
}
}, {
'label': 'Case and aggregation layers',
'icon': resource('incidence.png'),
'content': {
'widget': IncidencePointDialog(),
'help': help_incidence_point()
}
}]
}, {
'label':
'Density',
'icon':
resource('incidence.png'),
'content': [{
'label': 'Polygon layer only',
'icon': resource('incidence.png'),
'content': {
'widget': DensityDialog(),
'help': help_density()
}
}, {
'label': 'Case and aggregation layers',
'icon': resource('incidence.png'),
'content': {
'widget': DensityPointDialog(),
'help': help_density_point()
}
}]
}]
},
{
'label':
'Export',
'icon':
resource('export.png'),
'content': [
{
'label': 'Attribute table',
'icon': resource('csv.png'),
'content': {
'widget': CsvExport(),
'help': help_attribute_table()
}
},
{ # ajoute par Rachel Goree 30/05/2017
'label': 'KML',
'icon': resource('kml.png'),
'content': {
'widget': KmlExport(),
'help': help_export_kml()
}
}
]
}
]
self.stack.addWidget(AboutWidget())
self.help_list = []
# A category is import, process and export.
for category_def in self.tree_menu:
category_menu = QTreeWidgetItem(self.menu)
category_menu.setIcon(0, QIcon(category_def['icon']))
category_menu.setText(0, category_def['label'])
# Sub item
for sub_category_def in category_def['content']:
menu_entry = QTreeWidgetItem(category_menu)
menu_entry.setIcon(0, QIcon(sub_category_def['icon']))
menu_entry.setText(0, sub_category_def['label'])
# Add widget or add tab
if isinstance(sub_category_def['content'], dict):
widget = sub_category_def['content']['widget']
self.stack.addWidget(widget)
self.help_list.append(sub_category_def['content']['help'])
else:
tab = QTabWidget(self.stack)
tab.setIconSize(QSize(32, 32))
self.stack.addWidget(tab)
tab_help = []
tab_bar = sub_category_def['content']
for item in tab_bar:
label = item['label']
icon = QIcon(item['icon'])
widget = item['content']['widget']
help_widget = item['content']['help']
tab_help.append(help_widget)
tab.addTab(widget, icon, label)
self.help_list.append(tab_help)
self.stack.setCurrentIndex(1)
# https://github.com/Gustry/GeoPublicHealth/issues/20
self.menu.setAttribute(Qt.WA_MacShowFocusRect, False)
