def __init__(self, parameter, parent=None):
"""Constructor
:param parameter: A DefaultSelectParameter object.
:type parameter: DefaultSelectParameter
"""
super(DefaultSelectParameterWidget, self).__init__(parameter, parent)
self.default_layout = QHBoxLayout()
self.radio_button_layout = QHBoxLayout()
self.radio_button_widget = QWidget()
self.default_label = QLabel(tr('Default'))
# Create radio button group
self.default_input_button_group = QButtonGroup()
# Define string enabler for radio button
self.radio_button_enabler = self.input.itemData(0, Qt.UserRole)
for i in range(len(self._parameter.default_labels)):
if '%s' in self._parameter.default_labels[i]:
label = (self._parameter.default_labels[i] %
self._parameter.default_values[i])
else:
label = self._parameter.default_labels[i]
radio_button = QRadioButton(label)
self.radio_button_layout.addWidget(radio_button)
self.default_input_button_group.addButton(radio_button, i)
if self._parameter.default_value == \
self._parameter.default_values[i]:
radio_button.setChecked(True)
# Create double spin box for custom value
self.custom_value = QDoubleSpinBox()
if self._parameter.default_values[-1]:
self.custom_value.setValue(self._parameter.default_values[-1])
has_min = False
if self._parameter.minimum is not None:
has_min = True
self.custom_value.setMinimum(self._parameter.minimum)
has_max = False
if self._parameter.maximum is not None:
has_max = True
self.custom_value.setMaximum(self._parameter.maximum)
if has_min and has_max:
step = (self._parameter.maximum - self._parameter.minimum) / 100.0
self.custom_value.setSingleStep(step)
self.radio_button_layout.addWidget(self.custom_value)
self.toggle_custom_value()
# Reset the layout
self.input_layout.setParent(None)
self.help_layout.setParent(None)
self.label.setParent(None)
self.inner_input_layout.setParent(None)
self.input_layout = QGridLayout()
self.input_layout.setSpacing(0)
self.input_layout.addWidget(self.label, 0, 0)
self.input_layout.addLayout(self.inner_input_layout, 0, 1)
self.input_layout.addWidget(self.default_label, 1, 0)
self.input_layout.addLayout(self.radio_button_layout, 1, 1)
self.main_layout.addLayout(self.input_layout)
self.main_layout.addLayout(self.help_layout)
# check every added combobox, it could have been toggled by
# the existing keyword
self.toggle_input()
# Connect
# noinspection PyUnresolvedReferences
self.input.currentIndexChanged.connect(self.toggle_input)
self.default_input_button_group.buttonClicked.connect(
self.toggle_custom_value)
def fillTreeUsingProviders(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels(
[self.tr('Setting'), self.tr('Value')])
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
"""
Filter 'General', 'Models' and 'Scripts' items
"""
priorityKeys = [
self.tr('General'),
self.tr('Models'),
self.tr('Scripts')
]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
if not group in settings:
continue
# add menu item only if it has any search matches
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
"""
Filter 'Providers' items
"""
providersItem = QStandardItem(self.tr('Providers'))
icon = QgsApplication.getThemeIcon("/processingAlgorithm.svg")
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in list(settings.keys()):
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
"""
Filter 'Menus' items
"""
self.menusItem = QStandardItem(self.tr('Menus'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
self.menusItem.setIcon(icon)
self.menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [self.menusItem, emptyItem])
button = QPushButton(self.tr('Reset to defaults'))
button.clicked.connect(self.resetMenusToDefaults)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(button)
layout.addStretch()
widget = QWidget()
widget.setLayout(layout)
self.tree.setIndexWidget(emptyItem.index(), widget)
for provider in QgsApplication.processingRegistry().providers():
providerDescription = provider.name()
groupItem = QStandardItem(providerDescription)
icon = provider.icon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algorithms():
algItem = QStandardItem(alg.displayName())
algItem.setIcon(icon)
algItem.setEditable(False)
try:
settingMenu = ProcessingConfig.settings["MENU_" + alg.id()]
settingButton = ProcessingConfig.settings["BUTTON_" +
alg.id()]
settingIcon = ProcessingConfig.settings["ICON_" + alg.id()]
except:
continue
self.items[settingMenu] = SettingItem(settingMenu)
self.items[settingButton] = SettingItem(settingButton)
self.items[settingIcon] = SettingItem(settingIcon)
menuLabelItem = QStandardItem("Menu path")
menuLabelItem.setEditable(False)
buttonLabelItem = QStandardItem("Add button in toolbar")
buttonLabelItem.setEditable(False)
iconLabelItem = QStandardItem("Icon")
iconLabelItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
algItem.insertRow(0, [menuLabelItem, self.items[settingMenu]])
algItem.insertRow(0,
[buttonLabelItem, self.items[settingButton]])
algItem.insertRow(0, [iconLabelItem, self.items[settingIcon]])
groupItem.insertRow(0, [algItem, emptyItem])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
self.menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def initWidgets(self):
# If there are advanced parameters — show corresponding groupbox
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.grpAdvanced.show()
break
# Create widgets and put them in layouts
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if param.isDestination():
continue
else:
wrapper = WidgetWrapperFactory.create_wrapper(
param, self.parent)
self.wrappers[param.name()] = wrapper
widget = wrapper.widget
if widget is not None:
if isinstance(param, QgsProcessingParameterFeatureSource):
layout = QHBoxLayout()
layout.setSpacing(6)
layout.setMargin(0)
layout.addWidget(widget)
button = QToolButton()
icon = QIcon(
os.path.join(pluginPath, 'images', 'iterate.png'))
button.setIcon(icon)
button.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Expanding)
button.setToolTip(
self.
tr('Iterate over this layer, creating a separate output for every feature in the layer'
))
button.setCheckable(True)
layout.addWidget(button)
layout.setAlignment(button, Qt.AlignTop)
self.iterateButtons[param.name()] = button
button.toggled.connect(self.buttonToggled)
widget = QWidget()
widget.setLayout(layout)
widget.setToolTip(param.toolTip())
if wrapper.label is not None:
if param.flags(
) & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(wrapper.label)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, wrapper.label)
else:
desc = param.description()
if isinstance(param, QgsProcessingParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
if isinstance(param, QgsProcessingParameterPoint):
desc += self.tr(' (x, y)')
if param.flags(
) & QgsProcessingParameterDefinition.FlagOptional:
desc += self.tr(' [optional]')
widget.setText(desc)
if param.flags(
) & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, widget)
for output in self.alg.destinationParameterDefinitions():
if output.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
label = QLabel(output.description())
widget = DestinationSelectionPanel(output, self.alg)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (QgsProcessingParameterRasterDestination,
QgsProcessingParameterFeatureSink,
QgsProcessingParameterVectorDestination)):
check = QCheckBox()
check.setText(
QCoreApplication.translate(
'ParametersPanel',
'Open output file after running algorithm'))
def skipOutputChanged(checkbox, skipped):
checkbox.setEnabled(not skipped)
if skipped:
checkbox.setChecked(False)
check.setChecked(not widget.outputIsSkipped())
check.setEnabled(not widget.outputIsSkipped())
widget.skipOutputChanged.connect(
partial(skipOutputChanged, check))
self.layoutMain.insertWidget(self.layoutMain.count() - 1,
check)
self.checkBoxes[output.name()] = check
widget.setToolTip(param.toolTip())
self.outputWidgets[output.name()] = widget
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
def __init__(self, model=None):
super().__init__(None)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi(self)
# LOTS of bug reports when we include the dock creation in the UI file
# see e.g. #16428, #19068
# So just roll it all by hand......!
self.propertiesDock = QgsDockWidget(self)
self.propertiesDock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.propertiesDock.setObjectName("propertiesDock")
propertiesDockContents = QWidget()
self.verticalDockLayout_1 = QVBoxLayout(propertiesDockContents)
self.verticalDockLayout_1.setContentsMargins(0, 0, 0, 0)
self.verticalDockLayout_1.setSpacing(0)
self.scrollArea_1 = QgsScrollArea(propertiesDockContents)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.scrollArea_1.sizePolicy().hasHeightForWidth())
self.scrollArea_1.setSizePolicy(sizePolicy)
self.scrollArea_1.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_1.setFrameShape(QFrame.NoFrame)
self.scrollArea_1.setFrameShadow(QFrame.Plain)
self.scrollArea_1.setWidgetResizable(True)
self.scrollAreaWidgetContents_1 = QWidget()
self.gridLayout = QGridLayout(self.scrollAreaWidgetContents_1)
self.gridLayout.setContentsMargins(6, 6, 6, 6)
self.gridLayout.setSpacing(4)
self.label_1 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_1, 0, 0, 1, 1)
self.textName = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textName, 0, 1, 1, 1)
self.label_2 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
self.textGroup = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textGroup, 1, 1, 1, 1)
self.label_1.setText(self.tr("Name"))
self.textName.setToolTip(self.tr("Enter model name here"))
self.label_2.setText(self.tr("Group"))
self.textGroup.setToolTip(self.tr("Enter group name here"))
self.scrollArea_1.setWidget(self.scrollAreaWidgetContents_1)
self.verticalDockLayout_1.addWidget(self.scrollArea_1)
self.propertiesDock.setWidget(propertiesDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.propertiesDock)
self.propertiesDock.setWindowTitle(self.tr("Model properties"))
self.inputsDock = QgsDockWidget(self)
self.inputsDock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.inputsDock.setObjectName("inputsDock")
self.inputsDockContents = QWidget()
self.verticalLayout_3 = QVBoxLayout(self.inputsDockContents)
self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
self.scrollArea_2 = QgsScrollArea(self.inputsDockContents)
sizePolicy.setHeightForWidth(
self.scrollArea_2.sizePolicy().hasHeightForWidth())
self.scrollArea_2.setSizePolicy(sizePolicy)
self.scrollArea_2.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_2.setFrameShape(QFrame.NoFrame)
self.scrollArea_2.setFrameShadow(QFrame.Plain)
self.scrollArea_2.setWidgetResizable(True)
self.scrollAreaWidgetContents_2 = QWidget()
self.verticalLayout = QVBoxLayout(self.scrollAreaWidgetContents_2)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(0)
self.inputsTree = QTreeWidget(self.scrollAreaWidgetContents_2)
self.inputsTree.setAlternatingRowColors(True)
self.inputsTree.header().setVisible(False)
self.verticalLayout.addWidget(self.inputsTree)
self.scrollArea_2.setWidget(self.scrollAreaWidgetContents_2)
self.verticalLayout_3.addWidget(self.scrollArea_2)
self.inputsDock.setWidget(self.inputsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.inputsDock)
self.inputsDock.setWindowTitle(self.tr("Inputs"))
self.algorithmsDock = QgsDockWidget(self)
self.algorithmsDock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.algorithmsDock.setObjectName("algorithmsDock")
self.algorithmsDockContents = QWidget()
self.verticalLayout_4 = QVBoxLayout(self.algorithmsDockContents)
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
self.scrollArea_3 = QgsScrollArea(self.algorithmsDockContents)
sizePolicy.setHeightForWidth(
self.scrollArea_3.sizePolicy().hasHeightForWidth())
self.scrollArea_3.setSizePolicy(sizePolicy)
self.scrollArea_3.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_3.setFrameShape(QFrame.NoFrame)
self.scrollArea_3.setFrameShadow(QFrame.Plain)
self.scrollArea_3.setWidgetResizable(True)
self.scrollAreaWidgetContents_3 = QWidget()
self.verticalLayout_2 = QVBoxLayout(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setSpacing(4)
self.searchBox = QgsFilterLineEdit(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.addWidget(self.searchBox)
self.algorithmTree = QgsProcessingToolboxTreeView(
None, QgsApplication.processingRegistry())
self.algorithmTree.setAlternatingRowColors(True)
self.algorithmTree.header().setVisible(False)
self.verticalLayout_2.addWidget(self.algorithmTree)
self.scrollArea_3.setWidget(self.scrollAreaWidgetContents_3)
self.verticalLayout_4.addWidget(self.scrollArea_3)
self.algorithmsDock.setWidget(self.algorithmsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.algorithmsDock)
self.algorithmsDock.setWindowTitle(self.tr("Algorithms"))
self.searchBox.setToolTip(
self.tr("Enter algorithm name to filter list"))
self.searchBox.setShowSearchIcon(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.centralWidget().layout().insertWidget(0, self.bar)
try:
self.setDockOptions(self.dockOptions()
| QMainWindow.GroupedDragging)
except:
pass
if iface is not None:
self.mToolbar.setIconSize(iface.iconSize())
self.setStyleSheet(iface.mainWindow().styleSheet())
self.mActionOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.mActionSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.mActionSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.mActionSaveInProject.setIcon(
QgsApplication.getThemeIcon('/mAddToProject.svg'))
self.mActionZoomActual.setIcon(
QgsApplication.getThemeIcon('/mActionZoomActual.svg'))
self.mActionZoomIn.setIcon(
QgsApplication.getThemeIcon('/mActionZoomIn.svg'))
self.mActionZoomOut.setIcon(
QgsApplication.getThemeIcon('/mActionZoomOut.svg'))
self.mActionExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.mActionZoomToItems.setIcon(
QgsApplication.getThemeIcon('/mActionZoomFullExtent.svg'))
self.mActionExportPdf.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsPDF.svg'))
self.mActionExportSvg.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsSVG.svg'))
#self.mActionExportPython.setIcon(
# QgsApplication.getThemeIcon('/mActionSaveAsPython.svg'))
self.mActionEditHelp.setIcon(
QgsApplication.getThemeIcon('/mActionEditHelpContent.svg'))
self.mActionRun.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock)
self.tabifyDockWidget(self.inputsDock, self.algorithmsDock)
self.inputsDock.raise_()
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
settings = QgsSettings()
self.restoreState(
settings.value("/Processing/stateModeler", QByteArray()))
self.restoreGeometry(
settings.value("/Processing/geometryModeler", QByteArray()))
self.scene = ModelerScene(self, dialog=self)
self.scene.setSceneRect(
QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat(
'application/x-vnd.qgis.qgis.algorithmid'):
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasFormat(
'application/x-vnd.qgis.qgis.algorithmid'):
data = event.mimeData().data(
'application/x-vnd.qgis.qgis.algorithmid')
stream = QDataStream(data, QIODevice.ReadOnly)
algorithm_id = stream.readQString()
alg = QgsApplication.processingRegistry().createAlgorithmById(
algorithm_id)
if alg is not None:
self._addAlgorithm(alg, event.pos())
else:
assert False, algorithm_id
elif event.mimeData().hasText():
itemId = event.mimeData().text()
if itemId in [
param.id() for param in QgsApplication.instance().
processingRegistry().parameterTypes()
]:
self.addInputOfType(itemId, event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat(
'application/x-vnd.qgis.qgis.algorithmid'):
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QgsSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
# "Normal" mouse has an angle delta of 120, precision mouses provide data
# faster, in smaller steps
factor = 1.0 + (factor - 1.0) / 120.0 * abs(event.angleDelta().y())
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(
self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(
self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].data(0, Qt.UserRole)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
self.algorithms_model = ModelerToolboxModel(
self, QgsApplication.processingRegistry())
self.algorithmTree.setToolboxProxyModel(self.algorithms_model)
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
self.algorithmTree.setFilters(
QgsProcessingToolboxProxyModel.FilterModeler)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(
QCoreApplication.translate('ModelerDialog', 'Search…'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(self.tr('Enter model name here'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(self.tr('Enter group name here'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.algorithmTree.setFilterString)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
# Ctrl+= should also trigger a zoom in action
ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self)
ctrlEquals.activated.connect(self.zoomIn)
self.mActionOpen.triggered.connect(self.openModel)
self.mActionSave.triggered.connect(self.save)
self.mActionSaveAs.triggered.connect(self.saveAs)
self.mActionSaveInProject.triggered.connect(self.saveInProject)
self.mActionZoomIn.triggered.connect(self.zoomIn)
self.mActionZoomOut.triggered.connect(self.zoomOut)
self.mActionZoomActual.triggered.connect(self.zoomActual)
self.mActionZoomToItems.triggered.connect(self.zoomToItems)
self.mActionExportImage.triggered.connect(self.exportAsImage)
self.mActionExportPdf.triggered.connect(self.exportAsPdf)
self.mActionExportSvg.triggered.connect(self.exportAsSvg)
#self.mActionExportPython.triggered.connect(self.exportAsPython)
self.mActionEditHelp.triggered.connect(self.editHelp)
self.mActionRun.triggered.connect(self.runModel)
if model is not None:
self.model = model.create()
self.model.setSourceFilePath(model.sourceFilePath())
self.textGroup.setText(self.model.group())
self.textName.setText(self.model.displayName())
self.repaintModel()
else:
self.model = QgsProcessingModelAlgorithm()
self.model.setProvider(
QgsApplication.processingRegistry().providerById('model'))
self.fillInputsTree()
self.view.centerOn(0, 0)
self.help = None
self.hasChanged = False
def testAnchor(self):
""" test setting anchor point for widget """
main_frame = QWidget()
gl = QGridLayout()
main_frame.setLayout(gl)
main_frame.setMinimumSize(800, 600)
anchor_widget = QWidget(main_frame)
anchor_widget.setMinimumSize(300, 200)
main_frame.layout().addWidget(anchor_widget, 1, 1)
gl.setColumnStretch(0, 1)
gl.setColumnStretch(1, 0)
gl.setColumnStretch(2, 1)
gl.setRowStretch(0, 1)
gl.setRowStretch(1, 0)
gl.setRowStretch(2, 1)
# 103 = WA_DontShowOnScreen (not available in PyQt)
main_frame.setAttribute(103)
main_frame.show()
fw = qgis.gui.QgsFloatingWidget(main_frame)
fw.setMinimumSize(100, 50)
fw.setAnchorWidget(anchor_widget)
tests = [{
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 250,
'y': 200
}, {
'anchorPoint': QgsFloatingWidget.TopMiddle,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 200,
'y': 200
}, {
'anchorPoint': QgsFloatingWidget.TopRight,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 150,
'y': 200
}, {
'anchorPoint': QgsFloatingWidget.MiddleLeft,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 250,
'y': 175
}, {
'anchorPoint': QgsFloatingWidget.Middle,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 200,
'y': 175
}, {
'anchorPoint': QgsFloatingWidget.MiddleRight,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 150,
'y': 175
}, {
'anchorPoint': QgsFloatingWidget.BottomLeft,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 250,
'y': 150
}, {
'anchorPoint': QgsFloatingWidget.BottomMiddle,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 200,
'y': 150
}, {
'anchorPoint': QgsFloatingWidget.BottomRight,
'widgetAnchorPoint': QgsFloatingWidget.TopLeft,
'x': 150,
'y': 150
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.TopMiddle,
'x': 400,
'y': 200
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.TopRight,
'x': 550,
'y': 200
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.MiddleLeft,
'x': 250,
'y': 300
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.Middle,
'x': 400,
'y': 300
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.MiddleRight,
'x': 550,
'y': 300
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.BottomLeft,
'x': 250,
'y': 400
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.BottomMiddle,
'x': 400,
'y': 400
}, {
'anchorPoint': QgsFloatingWidget.TopLeft,
'widgetAnchorPoint': QgsFloatingWidget.BottomRight,
'x': 550,
'y': 400
}]
for t in tests:
fw.setAnchorPoint(t['anchorPoint'])
fw.setAnchorWidgetPoint(t['widgetAnchorPoint'])
self.assertEqual(fw.pos().x(), t['x'])
self.assertEqual(fw.pos().y(), t['y'])
def __init__(self, tree, parent, repo, layer, branch, branchCommitId):
QTreeWidgetItem.__init__(self, parent)
self.repo = repo
self.tree = tree
self.layer = layer
self.branch = branch
self.currentCommitId = None
self.setIcon(0, layerIcon)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.label = QLabel()
self.label.setText(layer)
self.labelLinks = QLabel()
self.labelLinks.setText("<a href='#'>Add to QGIS</a>")
self.label.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
layout.addWidget(self.label)
layout.addWidget(self.labelLinks)
layout.addStretch()
def add():
if self.status == self.NOT_IN_SYNC:
msgBox = QMessageBox()
msgBox.setText(
"This layer was exported already at a different version.\nWhich version would you like to add to your QGIS project?"
)
msgBox.addButton(QPushButton('Use exported version'),
QMessageBox.YesRole)
msgBox.addButton(QPushButton('Use version from this branch'),
QMessageBox.NoRole)
msgBox.addButton(QPushButton('Cancel'), QMessageBox.RejectRole)
QApplication.restoreOverrideCursor()
ret = msgBox.exec_()
if ret == 0:
checkoutLayer(self.repo, self.layer, None,
self.currentCommitId)
elif ret == 1:
try:
layer = checkoutLayer(self.repo, self.layer, None,
branchCommitId)
repoWatcher.layerUpdated.emit(layer)
except HasLocalChangesError:
QMessageBox.warning(
config.iface.mainWindow(), 'Cannot change version',
"There are local changes that would be overwritten.\n"
"Revert them before changing version.",
QMessageBox.Ok)
else:
checkoutLayer(self.repo, self.layer, None, branchCommitId)
self.labelLinks.linkActivated.connect(add)
w = QWidget()
w.setLayout(layout)
self.tree.setItemWidget(self, 0, w)
self.status = self.NOT_EXPORTED
trackedlayer = getTrackingInfoForGeogigLayer(self.repo.url, layer)
if trackedlayer:
try:
con = sqlite3.connect(trackedlayer.geopkg)
cursor = con.cursor()
cursor.execute(
"SELECT commit_id FROM geogig_audited_tables WHERE table_name='%s';"
% layer)
self.currentCommitId = cursor.fetchone()[0]
cursor.close()
con.close()
if branchCommitId == self.currentCommitId:
self.status = self.IN_SYNC
else:
self.status = self.NOT_IN_SYNC
self.label.setText("<font color='orange'>%s</font>" %
layer)
except:
pass
def testCreateExpression(self):
""" Test creating an expression using the widget"""
layer = QgsVectorLayer(
"Point?field=fldtxt:string&field=fldint:integer&field=flddate:datetime",
"test", "memory")
parent = QWidget()
w = QgsDefaultSearchWidgetWrapper(layer, 0)
w.initWidget(parent)
line_edit = w.lineEdit()
line_edit.setText('test')
case_sensitive = w.caseSensitiveCheckBox()
case_sensitive.setChecked(False)
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNull),
'"fldtxt" IS NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.IsNotNull),
'"fldtxt" IS NOT NULL')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo),
'lower("fldtxt")=lower(\'test\')')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo),
'lower("fldtxt")<>lower(\'test\')')
case_sensitive.setChecked(True)
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo),
'"fldtxt"=\'test\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo),
'"fldtxt"<>\'test\'')
case_sensitive.setChecked(False)
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.Contains),
'"fldtxt" ILIKE \'%test%\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.DoesNotContain),
'NOT ("fldtxt" ILIKE \'%test%\')')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.StartsWith),
'"fldtxt" ILIKE \'test%\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EndsWith),
'"fldtxt" ILIKE \'%test\'')
case_sensitive.setChecked(True)
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.Contains),
'"fldtxt" LIKE \'%test%\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.DoesNotContain),
'NOT ("fldtxt" LIKE \'%test%\')')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.StartsWith),
'"fldtxt" LIKE \'test%\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EndsWith),
'"fldtxt" LIKE \'%test\'')
case_sensitive.setChecked(False)
# numeric field
parent = QWidget()
w = QgsDefaultSearchWidgetWrapper(layer, 1)
w.initWidget(parent)
# may need updating if widget layout changes:
line_edit = w.lineEdit()
line_edit.setText('5.5')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo),
'"fldint"=5.5')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo),
'"fldint"<>5.5')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThan),
'"fldint">5.5')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.LessThan),
'"fldint"<5.5')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThanOrEqualTo),
'"fldint">=5.5')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.LessThanOrEqualTo),
'"fldint"<=5.5')
# date/time/datetime
parent = QWidget()
w = QgsDefaultSearchWidgetWrapper(layer, 2)
w.initWidget(parent)
# may need updating if widget layout changes:
line_edit = w.lineEdit()
line_edit.setText('2015-06-03')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.EqualTo),
'"flddate"=\'2015-06-03\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.NotEqualTo),
'"flddate"<>\'2015-06-03\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThan),
'"flddate">\'2015-06-03\'')
self.assertEqual(w.createExpression(QgsSearchWidgetWrapper.LessThan),
'"flddate"<\'2015-06-03\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.GreaterThanOrEqualTo),
'"flddate">=\'2015-06-03\'')
self.assertEqual(
w.createExpression(QgsSearchWidgetWrapper.LessThanOrEqualTo),
'"flddate"<=\'2015-06-03\'')
def __init__(self, parent, alg):
ParametersPanel.__init__(
self, parent,
alg) ## Création le l'interface Qt pour les paramètres
## Add console command
w = QWidget() # New Qt Windows
layout = QVBoxLayout() # New Qt vertical Layout
layout.setMargin(0)
layout.setSpacing(6)
label = QLabel() # New Qt label (text)
label.setText(self.tr("Chloe/Java console call"))
layout.addWidget(label) # Add label in layout
self.text = QPlainTextEdit() # New Qt champs de text in/out
self.text.setReadOnly(True) # Read only
layout.addWidget(self.text) # Add in layout
w.setLayout(layout) # layout -in-> Windows
self.layoutMain.addWidget(w) # windows -in-> Windows system
self.types_of_metrics = {}
for output in self.alg.outputs:
if isinstance(output, (OutputRaster, OutputVector, OutputTable)):
self.checkBoxes[output.name].setText(
self.tr('Open output file after running algorithm'))
self.connectParameterSignals()
self.parametersHaveChanged()
# === param:GRID_SIZES Widget:IntListSelectionPanel ===
lineEdit = self.widgets["GRID_SIZES"].lineEdit
lineEdit.setReadOnly(True)
sbInt = self.widgets["GRID_SIZES"].sbInt
sbInt.setValue(3)
# === param:METRICS Widget:ListSelectionPanel ===
# === Init cbFilter
cbFilter = self.widgets["METRICS"].cbFilter
cbFilter.addItems(self.alg.types_of_metrics.keys())
# === Init listSrc
value = cbFilter.currentText()
listSrc = self.widgets["METRICS"].listSrc
listSrc.clear()
if self.types_of_metrics:
if value in self.types_of_metrics.keys():
listSrc.addItems(self.types_of_metrics[value])
# === Init listDest
listDest = self.widgets["METRICS"].listDest
listDest.clear()
self.metrics_selected = set()
self.grid_sizes_selected = set()
lineEdit = self.widgets["METRICS"].lineEdit
lineEdit.setReadOnly(True)
if no == 1:
self._angle = -9999.9
elif no == 2:
self._angle2 = -9999.9
else:
self._angle = -9999.9
self._angle2 = -9999.9
self.update()
if __name__ == "__main__":
from qgis.PyQt.Qt import QApplication
app = QApplication(sys.argv)
window = QWidget()
compass = CompassWidget()
spinBox = QSpinBox()
spinBox.setRange(0, 719)
spinBox.valueChanged.connect(compass.setAngle)
spinBox2 = QSpinBox()
spinBox2.setRange(0, 719)
spinBox2.valueChanged.connect(compass.setAngle2)
layout = QVBoxLayout()
layout.addWidget(compass)
layout.addWidget(spinBox)
layout.addWidget(spinBox2)
window.setLayout(layout)
window.show()
def __init__(self, iface):
self.translator = None
self.iface = iface
self.project = None # type: Project
self.link_layer = None # type: QgsVectorLayer
self.node_layer = None # type: QgsVectorLayer
self.dock = QDockWidget(self.trlt('AequilibraE'))
self.manager = QWidget()
# The self.toolbar will hold everything
self.toolbar = QToolBar()
self.toolbar.setOrientation(2)
# # ########################################################################
# # ####################### PROJECT SUB-MENU ############################
projectMenu = QMenu()
self.open_project_action = QAction(self.trlt('Open Project'),
self.manager)
self.open_project_action.triggered.connect(self.run_load_project)
projectMenu.addAction(self.open_project_action)
self.project_from_osm_action = QAction(
self.trlt('Create project from OSM'), self.manager)
self.project_from_osm_action.triggered.connect(
self.run_project_from_osm)
projectMenu.addAction(self.project_from_osm_action)
self.create_transponet_action = QAction(
self.trlt('Create Project from layers'), self.manager)
self.create_transponet_action.triggered.connect(
self.run_create_transponet)
projectMenu.addAction(self.create_transponet_action)
projectButton = QToolButton()
projectButton.setText(self.trlt('Project'))
projectButton.setPopupMode(2)
projectButton.setMenu(projectMenu)
self.toolbar.addWidget(projectButton)
# # ########################################################################
# # ################# NETWORK MANIPULATION SUB-MENU #######################
netMenu = QMenu()
self.action_netPrep = QAction(self.trlt('Network Preparation'),
self.manager)
self.action_netPrep.triggered.connect(self.run_net_prep)
netMenu.addAction(self.action_netPrep)
self.add_connectors_action = QAction(
self.trlt('Add centroid connectors'), self.manager)
self.add_connectors_action.triggered.connect(self.run_add_connectors)
netMenu.addAction(self.add_connectors_action)
netbutton = QToolButton()
netbutton.setText(self.trlt('Network Manipulation'))
netbutton.setMenu(netMenu)
netbutton.setPopupMode(2)
self.toolbar.addWidget(netbutton)
# # ########################################################################
# # #################### DATA UTILITIES SUB-MENU #########################
dataMenu = QMenu()
self.display_custom_formats_action = QAction(
self.trlt('Display AequilibraE formats'), self.manager)
self.display_custom_formats_action.triggered.connect(
self.run_display_aequilibrae_formats)
dataMenu.addAction(self.display_custom_formats_action)
self.load_matrix_action = QAction(self.trlt('Import matrices'),
self.manager)
self.load_matrix_action.triggered.connect(self.run_load_matrices)
dataMenu.addAction(self.load_matrix_action)
self.load_database_action = QAction(self.trlt('Import dataset'),
self.manager)
self.load_database_action.triggered.connect(self.run_load_database)
dataMenu.addAction(self.load_database_action)
databutton = QToolButton()
databutton.setText(self.trlt('Data'))
databutton.setPopupMode(2)
databutton.setMenu(dataMenu)
self.toolbar.addWidget(databutton)
# # # ########################################################################
# # # ################## TRIP DISTRIBUTION SUB-MENU ########################
distributionButton = QToolButton()
distributionButton.setText(self.trlt('Trip Distribution'))
distributionButton.clicked.connect(self.run_distribution_models)
self.toolbar.addWidget(distributionButton)
# # ########################################################################
# # ################### PATH COMPUTATION SUB-MENU #######################
pathMenu = QMenu()
self.shortest_path_action = QAction(self.trlt('Shortest path'),
self.manager)
self.shortest_path_action.triggered.connect(self.run_shortest_path)
pathMenu.addAction(self.shortest_path_action)
self.dist_matrix_action = QAction(self.trlt('Impedance matrix'),
self.manager)
self.dist_matrix_action.triggered.connect(self.run_dist_matrix)
pathMenu.addAction(self.dist_matrix_action)
self.traffic_assignment_action = QAction(
self.trlt('Traffic Assignment'), self.manager)
self.traffic_assignment_action.triggered.connect(
self.run_traffic_assig)
pathMenu.addAction(self.traffic_assignment_action)
pathButton = QToolButton()
pathButton.setText(self.trlt('Paths and assignment'))
pathButton.setPopupMode(2)
pathButton.setMenu(pathMenu)
self.toolbar.addWidget(pathButton)
# # ########################################################################
# # ####################### ROUTING SUB-MENU ###########################
if has_ortools:
routingMenu = QMenu()
self.tsp_action = QAction(self.trlt('Travelling Salesman Problem'),
self.manager)
self.tsp_action.triggered.connect(self.run_tsp)
routingMenu.addAction(self.tsp_action)
routingButton = QToolButton()
routingButton.setText(self.trlt('Routing'))
routingButton.setPopupMode(2)
routingButton.setMenu(routingMenu)
self.toolbar.addWidget(routingButton)
# # ########################################################################
# # ####################### TRANSIT SUB-MENU ###########################
transitMenu = QMenu()
self.gtfs_import_action = QAction(
self.trlt('Convert GTFS to SpatiaLite'), self.manager)
self.gtfs_import_action.triggered.connect(self.run_import_gtfs)
transitMenu.addAction(self.gtfs_import_action)
transitButton = QToolButton()
transitButton.setText(self.trlt('Public Transport'))
transitButton.setPopupMode(2)
transitButton.setMenu(transitMenu)
self.toolbar.addWidget(transitButton)
# ########################################################################
# ################# GIS TOOLS SUB-MENU #########################
gisMenu = QMenu()
self.simple_tag_action = QAction(self.trlt('Simple tag'), self.manager)
self.simple_tag_action.triggered.connect(self.run_simple_tag)
gisMenu.addAction(self.simple_tag_action)
self.lcd_action = QAction(self.trlt('Lowest common denominator'),
self.manager)
self.lcd_action.triggered.connect(self.run_lcd)
gisMenu.addAction(self.lcd_action)
self.dlines_action = QAction(self.trlt('Desire Lines'), self.manager)
self.dlines_action.triggered.connect(self.run_dlines)
gisMenu.addAction(self.dlines_action)
self.bandwidth_action = QAction(self.trlt('Stacked Bandwidth'),
self.manager)
self.bandwidth_action.triggered.connect(self.run_bandwidth)
gisMenu.addAction(self.bandwidth_action)
self.scenario_comparison_action = QAction(
self.trlt('Scenario Comparison'), self.manager)
self.scenario_comparison_action.triggered.connect(
self.run_scenario_comparison)
gisMenu.addAction(self.scenario_comparison_action)
gisButton = QToolButton()
gisButton.setText(self.trlt('GIS'))
gisButton.setPopupMode(2)
gisButton.setMenu(gisMenu)
self.toolbar.addWidget(gisButton)
# ########################################################################
# ################# LOOSE STUFF #########################
parametersButton = QToolButton()
parametersButton.setText(self.trlt('Parameters'))
parametersButton.clicked.connect(self.run_change_parameters)
self.toolbar.addWidget(parametersButton)
aboutButton = QToolButton()
aboutButton.setText(self.trlt('About'))
aboutButton.clicked.connect(self.run_about)
self.toolbar.addWidget(aboutButton)
logButton = QToolButton()
logButton.setText(self.trlt('logfile'))
logButton.clicked.connect(self.run_log)
self.toolbar.addWidget(logButton)
helpButton = QToolButton()
helpButton.setText(self.trlt('Help'))
helpButton.clicked.connect(self.run_help)
self.toolbar.addWidget(helpButton)
if no_binary:
binariesButton = QToolButton()
binariesButton.setText(self.trlt('Download binaries'))
binariesButton.clicked.connect(self.run_binary_download)
self.toolbar.addWidget(binariesButton)
if not extra_packages:
xtrapkgButton = QToolButton()
xtrapkgButton.setText(self.trlt('Install extra packages'))
xtrapkgButton.clicked.connect(self.install_extra_packages)
self.toolbar.addWidget(xtrapkgButton)
# ########################################################################
# ################# PROJECT MANAGER #########################
self.showing = QCheckBox()
self.showing.setText('Show project info')
self.showing.setChecked(True)
self.toolbar.addWidget(self.showing)
self.showing.toggled.connect(self.hide_info_pannel)
self.projectManager = QTabWidget()
self.toolbar.addWidget(self.projectManager)
# # # ########################################################################
self.tabContents = []
self.toolbar.setIconSize(QSize(16, 16))
p1_vertical = QVBoxLayout()
p1_vertical.setContentsMargins(0, 0, 0, 0)
p1_vertical.addWidget(self.toolbar)
self.manager.setLayout(p1_vertical)
self.dock.setWidget(self.manager)
self.dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock)
def api_search(self, dlg_mincut=None):
form = ""
if self.dlg_search is None and dlg_mincut is None:
self.init_dialog()
if dlg_mincut:
self.dlg_search = dlg_mincut
self.is_mincut = True
form = f'"singleTab":"tab_address"'
self.dlg_search.lbl_msg.setStyleSheet("QLabel{color:red;}")
self.dlg_search.lbl_msg.setVisible(False)
project_vars = global_vars.get_project_vars()
qgis_project_add_schema = project_vars['add_schema']
self.controller.set_user_settings_value('open_search', 'true')
if qgis_project_add_schema is None:
body = self.create_body(form=form)
else:
extras = f'"addSchema":"{qgis_project_add_schema}"'
body = self.create_body(form=form, extras=extras)
function_name = "gw_fct_getsearch"
complet_list = self.controller.get_json(function_name, body)
if not complet_list:
return False
main_tab = self.dlg_search.findChild(QTabWidget, 'main_tab')
if dlg_mincut and len(complet_list["form"]) == 1:
main_tab = self.dlg_search.findChild(QTabWidget, 'main_tab')
main_tab.setStyleSheet(
"QTabBar::tab { background-color: transparent; text-align:left;"
"border: 1px solid transparent;}"
"QTabWidget::pane { background-color: #fcfcfc; border: 1 solid #dadada;}"
)
first_tab = None
self.lineedit_list = []
for tab in complet_list["form"]:
if first_tab is None:
first_tab = tab['tabName']
tab_widget = QWidget(main_tab)
tab_widget.setObjectName(tab['tabName'])
main_tab.addTab(tab_widget, tab['tabLabel'])
gridlayout = QGridLayout()
tab_widget.setLayout(gridlayout)
x = 0
for field in tab['fields']:
label = QLabel()
label.setObjectName('lbl_' + field['label'])
label.setText(field['label'].capitalize())
widget = None
if field['widgettype'] == 'typeahead':
completer = QCompleter()
widget = self.add_lineedit(field)
widget = self.set_typeahead_completer(widget, completer)
self.lineedit_list.append(widget)
elif field['widgettype'] == 'combo':
widget = self.add_combobox(field)
gridlayout.addWidget(label, x, 0)
gridlayout.addWidget(widget, x, 1)
x += 1
vertical_spacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
gridlayout.addItem(vertical_spacer1)
if self.is_mincut is False:
self.controller.manage_translation('search', self.dlg_search)
def initWidgets(self):
# If there are advanced parameters — show corresponding groupbox
for param in self.alg.parameters:
if param.isAdvanced:
self.grpAdvanced.show()
break
# Create widgets and put them in layouts
for param in self.alg.parameters:
if param.hidden:
continue
desc = param.description
if isinstance(param, ParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
if isinstance(param, ParameterPoint):
desc += self.tr(' (x, y)')
try:
if param.optional:
desc += self.tr(' [optional]')
except:
pass
widget = self.getWidgetFromParameter(param)
self.valueItems[param.name] = widget
if isinstance(param, ParameterVector) and \
not self.alg.allowOnlyOpenedLayers:
layout = QHBoxLayout()
layout.setSpacing(2)
layout.setMargin(0)
layout.addWidget(widget)
button = QToolButton()
icon = QIcon(os.path.join(pluginPath, 'images', 'iterate.png'))
button.setIcon(icon)
button.setToolTip(self.tr('Iterate over this layer'))
button.setCheckable(True)
layout.addWidget(button)
self.iterateButtons[param.name] = button
button.toggled.connect(self.buttonToggled)
widget = QWidget()
widget.setLayout(layout)
tooltips = self.alg.getParameterDescriptions()
widget.setToolTip(tooltips.get(param.name, param.description))
if isinstance(param, ParameterBoolean):
widget.setText(desc)
if param.isAdvanced:
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(self.layoutMain.count() - 2,
widget)
else:
label = QLabel(desc)
#label.setToolTip(tooltip)
self.labels[param.name] = label
if param.isAdvanced:
self.layoutAdvanced.addWidget(label)
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(self.layoutMain.count() - 2,
label)
self.layoutMain.insertWidget(self.layoutMain.count() - 2,
widget)
self.widgets[param.name] = widget
for output in self.alg.outputs:
if output.hidden:
continue
label = QLabel(output.description)
widget = OutputSelectionPanel(output, self.alg)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (OutputRaster, OutputVector, OutputTable)):
check = QCheckBox()
check.setText(
self.tr('Open output file after running algorithm'))
check.setChecked(True)
self.layoutMain.insertWidget(self.layoutMain.count() - 1,
check)
self.checkBoxes[output.name] = check
self.valueItems[output.name] = widget
if isinstance(output, OutputVector):
if output.base_input in self.dependentItems:
items = self.dependentItems[output.base_input]
else:
items = []
self.dependentItems[output.base_input] = items
items.append(output)
base_input = self.alg.getParameterFromName(output.base_input)
if isinstance(base_input, ParameterVector):
layers = dataobjects.getVectorLayers(base_input.shapetype)
else:
layers = dataobjects.getTables()
if len(layers) > 0:
output.base_layer = layers[0]
def __init__(self, parent, confHandler):
"""
:type confHandler: configHandler.ConfigHandler
"""
QDialog.__init__(self, parent)
self.confHandler = confHandler
self.doSave = False
self.setWindowTitle(self.tr('Output Optionen'))
main_widget = QWidget(self)
# Build up gui
# Project title
hbox1 = QHBoxLayout()
projectNameLabel = QLabel(self.tr('Projektname'))
projectNameLabel.setMinimumWidth(100)
self.projectField = QLineEdit()
self.projectField.setMinimumWidth(400)
self.projectField.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
hbox1.addWidget(projectNameLabel)
hbox1.addWidget(self.projectField)
# Save path
hbox2 = QHBoxLayout()
saveLabel = QLabel(self.tr('Speicherpfad'))
saveLabel.setMinimumWidth(100)
self.pathField = QComboBox()
self.pathField.setMinimumWidth(400)
self.pathField.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed))
openButton = QPushButton()
openButton.setMaximumSize(QSize(27, 27))
icon = QIcon()
iconPath = os.path.join(os.path.dirname(__file__), 'icons',
'icon_open.png')
icon.addPixmap(QPixmap(iconPath), QIcon.Normal, QIcon.Off)
openButton.setIcon(icon)
openButton.setIconSize(QSize(24, 24))
openButton.clicked.connect(self.onOpenDialog)
hbox2.addWidget(saveLabel)
hbox2.addWidget(self.pathField)
hbox2.addWidget(openButton)
# Create checkboxes
questionLabel = QLabel(
self.tr('Welche Produkte sollen erzeugt werden?'))
self.checkBoxShortReport = QCheckBox(self.tr('Kurzbericht'))
self.checkBoxReport = QCheckBox(self.tr('Technischer Bericht'))
self.checkBoxPlot = QCheckBox(self.tr('Diagramm'))
self.checkBoxGeodata = QCheckBox(
self.tr('Shape-Daten der Stuetzen und Seillinie'))
self.checkBoxKML = QCheckBox(
self.tr('KML-Daten der Stuetzen und Seillinie'))
self.checkBoxCoords = QCheckBox(
self.tr('Koordinaten-Tabellen der Stuetzen und Seillinie'))
# Set tick correctly
self.checkBoxShortReport.setChecked(
self.confHandler.outputOptions['shortReport'])
self.checkBoxReport.setChecked(
self.confHandler.outputOptions['report'])
self.checkBoxPlot.setChecked(self.confHandler.outputOptions['plot'])
self.checkBoxGeodata.setChecked(
self.confHandler.outputOptions['geodata'])
self.checkBoxKML.setChecked(self.confHandler.outputOptions['kml'])
self.checkBoxCoords.setChecked(
self.confHandler.outputOptions['coords'])
# Create Ok/Cancel Button and connect signal
buttonBox = QDialogButtonBox(main_widget)
buttonBox.setStandardButtons(QDialogButtonBox.Save
| QDialogButtonBox.Cancel)
buttonBox.button(QDialogButtonBox.Save).setText(self.tr("Speichern"))
buttonBox.button(QDialogButtonBox.Cancel).setText(self.tr("Abbrechen"))
buttonBox.button(QDialogButtonBox.Cancel).clicked.connect(
self.onCancel)
buttonBox.button(QDialogButtonBox.Save).clicked.connect(self.onSave)
# Layout
container = QVBoxLayout(main_widget)
container.addLayout(hbox1)
container.addLayout(hbox2)
container.addWidget(QLabel(''))
container.addWidget(questionLabel)
container.addWidget(self.checkBoxShortReport)
container.addWidget(self.checkBoxReport)
container.addWidget(self.checkBoxPlot)
container.addWidget(self.checkBoxGeodata)
container.addWidget(self.checkBoxKML)
container.addWidget(self.checkBoxCoords)
container.addWidget(buttonBox)
container.setAlignment(Qt.AlignLeft)
self.setLayout(container)
self.fillInData()
def treeItemChanged(self, current, previous):
qgsgeom1 = None
qgsgeom2 = None
crs = "EPSG:4326"
if not isinstance(current, FeatureItem):
self.attributesTable.clear()
self.attributesTable.setRowCount(0)
return
color = {
"MODIFIED": QColor(255, 170, 0),
"ADDED": Qt.green,
"REMOVED": Qt.red,
"NO_CHANGE": Qt.white
}
path = current.layername + "/" + current.featureid
featurediff = self.changes[path].featurediff()
self.attributesTable.clear()
self.attributesTable.verticalHeader().show()
self.attributesTable.horizontalHeader().show()
self.attributesTable.setRowCount(len(featurediff))
self.attributesTable.setVerticalHeaderLabels(
[a["attributename"] for a in featurediff])
self.attributesTable.setHorizontalHeaderLabels(
["Old value", "New value", "Change type"])
for i, attrib in enumerate(featurediff):
try:
if attrib["changetype"] == "MODIFIED":
oldvalue = attrib["oldvalue"]
newvalue = attrib["newvalue"]
elif attrib["changetype"] == "ADDED":
newvalue = attrib["newvalue"]
oldvalue = ""
elif attrib["changetype"] == "REMOVED":
oldvalue = attrib["oldvalue"]
newvalue = ""
else:
oldvalue = newvalue = attrib["oldvalue"]
except:
oldvalue = newvalue = ""
self.attributesTable.setItem(i, 0, DiffItem(oldvalue))
self.attributesTable.setItem(i, 1, DiffItem(newvalue))
try:
self.attributesTable.setItem(i, 2, QTableWidgetItem(""))
if qgsgeom1 is None or qgsgeom2 is None:
if "crs" in attrib:
crs = attrib["crs"]
qgsgeom1 = QgsGeometry.fromWkt(oldvalue)
qgsgeom2 = QgsGeometry.fromWkt(newvalue)
if qgsgeom1 is not None and qgsgeom2 is not None:
widget = QWidget()
btn = QPushButton()
btn.setText("View detail")
btn.clicked.connect(lambda: self.viewGeometryChanges(
qgsgeom1, qgsgeom2, crs))
label = QLabel()
label.setText(attrib["changetype"])
layout = QHBoxLayout(widget)
layout.addWidget(label)
layout.addWidget(btn)
layout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
self.attributesTable.setCellWidget(i, 2, widget)
else:
self.attributesTable.setItem(
i, 2, QTableWidgetItem(attrib["changetype"]))
else:
self.attributesTable.setItem(
i, 2, QTableWidgetItem(attrib["changetype"]))
except:
self.attributesTable.setItem(
i, 2, QTableWidgetItem(attrib["changetype"]))
for col in range(3):
self.attributesTable.item(i, col).setBackgroundColor(
color[attrib["changetype"]])
self.attributesTable.resizeColumnsToContents()
self.attributesTable.horizontalHeader().setResizeMode(
QHeaderView.Stretch)
def modelerPanel(self):
"""
Returns the table prepared for the modeler Processing GUI.
:return: (OrderedTableWidget) DSGTools customized table widget.
"""
widget = QWidget()
layout = QVBoxLayout()
# added as an attribute in order to make it easier to be read
widget.cb = QCheckBox()
widget.cb.setText(self.tr("Use DE-9IM inputs"))
layout.addWidget(widget.cb)
widget.otw = OrderedTableWidget(
headerMap={
0: {
"header": self.tr("Rule name"),
"type": "widget",
"widget": self.ruleNameWidget,
"setter": "setText",
"getter": "text"
},
1: {
"header": self.tr("Layer A"),
"type": "widget",
"widget": self.mapLayerModelDialog,
"setter": "setText",
"getter": "text"
},
2: {
"header": self.tr("Filter A"),
"type": "widget",
"widget": self.filterExpressionWidget,
"setter": "setExpression_",
"getter": "currentText_"
},
3: {
"header": self.tr("Predicate"),
"type": "widget",
"widget": self.predicateComboBox,
"setter": "setCurrentIndex",
"getter": "currentIndex"
},
4: {
"header": self.tr("DE-9IM mask predicate"),
"type": "widget",
"widget": self.de9imWidget,
"setter": "setText",
"getter": "text"
},
5: {
"header": self.tr("Layer B"),
"type": "widget",
"widget": self.mapLayerModelDialog,
"setter": "setText",
"getter": "text"
},
6: {
"header": self.tr("Filter B"),
"type": "widget",
"widget": self.filterExpressionWidget,
"setter": "setExpression_",
"getter": "currentText_"
},
7: {
"header": self.tr("Cardinality"),
"type": "widget",
"widget": self.cardinalityWidget,
"setter": "setText",
"getter": "text"
}
})
def handlePredicateColumns(checked):
"""
Predicate input widgets are mutually exclusively: the user may only
input data through either of them. This method manages hiding and
showing correct columns in accord to the user selection.
:param checked: (bool) whether the DE-9IM usage checkbox is ticked.
"""
widget.otw.tableWidget.hideColumn(3 if checked else 4)
widget.otw.tableWidget.showColumn(4 if checked else 3)
widget.cb.toggled.connect(handlePredicateColumns)
widget.cb.toggled.emit(widget.cb.isChecked())
widget.otw.setHeaderDoubleClickBehaviour("replicate")
widget.otw.rowAdded.connect(self.postAddRowModeler)
layout.addWidget(widget.otw)
widget.setLayout(layout)
return widget
def initGui(self):
icon = QIcon()
icon.addPixmap(
QPixmap(
"C:/Roberto/Visual_Studio_Code/GisBike/programa/IMG/Qgis.png"),
QIcon.Normal, QIcon.Off)
self.setWindowIcon(icon)
self.setWindowModality(Qt.WindowModal)
self.setWindowFlags(Qt.Window
| Qt.WindowSystemMenuHint
| Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
self.resize(1200, 600)
self.verticalLayout_2 = QVBoxLayout(self)
self.splitter = QSplitter(self)
self.splitter.setOrientation(Qt.Horizontal)
self.actionZoomIn = QPushButton("Zoom in", self.splitter)
self.actionZoomOut = QPushButton("Zoom out", self.splitter)
self.actionPan = QPushButton("Pan", self.splitter)
self.actionFile = QPushButton("File", self.splitter)
self.project = QgsProject.instance()
self.project.read('C:/Users/Fcc/Desktop/QGis/pruebas2.qgz')
self.root = QgsProject.instance().layerTreeRoot()
self.bridge = QgsLayerTreeMapCanvasBridge(self.root, self.canvas)
self.bridge.setCanvasLayers()
self.bridge.setAutoSetupOnFirstLayer(True)
#https://gis.stackexchange.com/questions/141516/adding-legend-to-canvas-in-standalone-pyqgis-application
self.model = QgsLayerTreeModel(self.root)
self.model.setFlag(QgsLayerTreeModel.AllowNodeReorder)
self.model.setFlag(QgsLayerTreeModel.AllowNodeRename)
self.model.setFlag(QgsLayerTreeModel.AllowNodeChangeVisibility)
self.model.setFlag(QgsLayerTreeModel.ShowLegend)
self.view = QgsLayerTreeView(self.splitter)
self.view.setModel(self.model)
self.view.setFixedWidth(150)
#self.view.resize(150,600)
self.widget = QWidget(self.splitter)
self.verticalLayout = QVBoxLayout(self.widget)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.addWidget(self.actionZoomIn)
self.horizontalLayout.addWidget(self.actionZoomOut)
self.horizontalLayout.addWidget(self.actionPan)
self.horizontalLayout.addWidget(self.actionFile)
self.verticalLayout.addLayout(self.horizontalLayout)
self.verticalLayout.addWidget(self.canvas)
self.verticalLayout_2.addWidget(self.splitter)
self.actionZoomIn.clicked.connect(self.zoomIn)
self.actionZoomOut.clicked.connect(self.zoomOut)
self.actionPan.clicked.connect(self.pan)
self.actionFile.clicked.connect(self.file)
# create the map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
def initWidgets(self):
# If there are advanced parameters — show corresponding groupbox
for param in self.alg.parameters:
if param.isAdvanced:
self.grpAdvanced.show()
break
# Create widgets and put them in layouts
for param in self.alg.parameters:
if param.hidden:
continue
desc = param.description
if isinstance(param, ParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
if isinstance(param, ParameterPoint):
desc += self.tr(' (x, y)')
if param.optional:
desc += self.tr(' [optional]')
wrapper = self.getWidgetWrapperFromParameter(param)
self.wrappers[param.name] = wrapper
widget = wrapper.widget
if widget is not None:
if isinstance(param, ParameterVector):
layout = QHBoxLayout()
layout.setSpacing(2)
layout.setMargin(0)
layout.addWidget(widget)
button = QToolButton()
icon = QIcon(
os.path.join(pluginPath, 'images', 'iterate.png'))
button.setIcon(icon)
button.setToolTip(self.tr('Iterate over this layer'))
button.setCheckable(True)
layout.addWidget(button)
self.iterateButtons[param.name] = button
button.toggled.connect(self.buttonToggled)
widget = QWidget()
widget.setLayout(layout)
tooltips = self.alg.getParameterDescriptions()
widget.setToolTip(tooltips.get(param.name, param.description))
if type(widget) is QCheckBox:
# checkbox widget - so description is embedded in widget rather than a separate
# label
widget.setText(desc)
else:
label = QLabel(desc)
# label.setToolTip(tooltip)
self.labels[param.name] = label
if param.isAdvanced:
self.layoutAdvanced.addWidget(label)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, label)
if param.isAdvanced:
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(self.layoutMain.count() - 2,
widget)
for output in self.alg.outputs:
if output.hidden:
continue
label = QLabel(output.description)
widget = OutputSelectionPanel(output, self.alg)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (OutputRaster, OutputVector, OutputTable)):
check = QCheckBox()
check.setText(
self.tr('Open output file after running algorithm'))
check.setChecked(True)
self.layoutMain.insertWidget(self.layoutMain.count() - 1,
check)
self.checkBoxes[output.name] = check
self.outputWidgets[output.name] = widget
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
def createWidget(self):
if self.dialogType == DIALOG_STANDARD:
widget = QWidget()
layout = QHBoxLayout()
layout.setMargin(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
self.combo = QgsMapLayerComboBox()
layout.addWidget(self.combo)
btn = QToolButton()
btn.setText('...')
btn.setToolTip(self.tr("Select file"))
btn.clicked.connect(self.selectFile)
layout.addWidget(btn)
widget.setLayout(layout)
filters = QgsMapLayerProxyModel.Filters()
if self.param.datatype == [-1] or -1 in self.param.datatype:
filters = QgsMapLayerProxyModel.HasGeometry
if QgsWkbTypes.PointGeometry in self.param.datatype:
filters |= QgsMapLayerProxyModel.PointLayer
if QgsWkbTypes.LineGeometry in self.param.datatype:
filters |= QgsMapLayerProxyModel.LineLayer
if QgsWkbTypes.PolygonGeometry in self.param.datatype:
filters |= QgsMapLayerProxyModel.PolygonLayer
if self.param.optional:
self.combo.setAllowEmptyLayer(True)
if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF):
self.combo.setShowCrs(True)
self.combo.setFilters(filters)
self.combo.setExcludedProviders(['grass'])
self.combo.currentIndexChanged.connect(
lambda: self.widgetValueHasChanged.emit(self))
self.combo.currentTextChanged.connect(
lambda: self.widgetValueHasChanged.emit(self))
return widget
elif self.dialogType == DIALOG_BATCH:
widget = BatchInputSelectionPanel(self.param, self.row, self.col,
self.dialog)
widget.valueChanged.connect(
lambda: self.widgetValueHasChanged.emit(self))
return widget
else:
self.combo = QComboBox()
layers = self.dialog.getAvailableValuesOfType(
ParameterVector, OutputVector)
self.combo.setEditable(True)
for layer in layers:
self.combo.addItem(self.dialog.resolveValueDescription(layer),
layer)
if self.param.optional:
self.combo.setEditText("")
widget = QWidget()
layout = QHBoxLayout()
layout.setMargin(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
layout.addWidget(self.combo)
btn = QToolButton()
btn.setText('...')
btn.setToolTip(self.tr("Select file"))
btn.clicked.connect(self.selectFile)
layout.addWidget(btn)
widget.setLayout(layout)
return widget
def setupUi(self):
self.labels = {}
self.widgets = {}
self.checkBoxes = {}
self.showAdvanced = False
self.valueItems = {}
self.dependentItems = {}
self.resize(650, 450)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
tooltips = self._alg.getParameterDescriptions()
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setSpacing(5)
self.verticalLayout.setMargin(20)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.addWidget(self.bar)
hLayout = QHBoxLayout()
hLayout.setSpacing(5)
hLayout.setMargin(0)
descriptionLabel = QLabel(self.tr("Description"))
self.descriptionBox = QLineEdit()
self.descriptionBox.setText(self._alg.name)
hLayout.addWidget(descriptionLabel)
hLayout.addWidget(self.descriptionBox)
self.verticalLayout.addLayout(hLayout)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.verticalLayout.addWidget(line)
for param in self._alg.parameters:
if param.isAdvanced:
self.advancedButton = QPushButton()
self.advancedButton.setText(
self.tr('Show advanced parameters'))
self.advancedButton.clicked.connect(
self.showAdvancedParametersClicked)
advancedButtonHLayout = QHBoxLayout()
advancedButtonHLayout.addWidget(self.advancedButton)
advancedButtonHLayout.addStretch()
self.verticalLayout.addLayout(advancedButtonHLayout)
break
for param in self._alg.parameters:
if param.hidden:
continue
desc = param.description
if isinstance(param, ParameterExtent):
desc += self.tr('(xmin, xmax, ymin, ymax)')
if isinstance(param, ParameterPoint):
desc += self.tr('(x, y)')
label = QLabel(desc)
self.labels[param.name] = label
widget = self.getWidgetFromParameter(param)
self.valueItems[param.name] = widget
if param.name in tooltips.keys():
tooltip = tooltips[param.name]
else:
tooltip = param.description
label.setToolTip(tooltip)
widget.setToolTip(tooltip)
if param.isAdvanced:
label.setVisible(self.showAdvanced)
widget.setVisible(self.showAdvanced)
self.widgets[param.name] = widget
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(widget)
for output in self._alg.outputs:
if output.hidden:
continue
if isinstance(output, (OutputRaster, OutputVector, OutputTable,
OutputHTML, OutputFile, OutputDirectory)):
label = QLabel(output.description + '<' +
output.__class__.__name__ + '>')
item = QLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME)
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(item)
self.valueItems[output.name] = item
label = QLabel(' ')
self.verticalLayout.addWidget(label)
label = QLabel(self.tr('Parent algorithms'))
self.dependenciesPanel = self.getDependenciesPanel()
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(self.dependenciesPanel)
self.verticalLayout.addStretch(1000)
self.setLayout(self.verticalLayout)
self.setPreviousValues()
self.setWindowTitle(self._alg.name)
self.verticalLayout2 = QVBoxLayout()
self.verticalLayout2.setSpacing(2)
self.verticalLayout2.setMargin(0)
self.tabWidget = QTabWidget()
self.tabWidget.setMinimumWidth(300)
self.paramPanel = QWidget()
self.paramPanel.setLayout(self.verticalLayout)
self.scrollArea = QScrollArea()
self.scrollArea.setWidget(self.paramPanel)
self.scrollArea.setWidgetResizable(True)
self.tabWidget.addTab(self.scrollArea, self.tr('Parameters'))
self.txtHelp = QTextBrowser()
html = None
isText, algHelp = self._alg.help()
if algHelp is not None:
algHelp = algHelp if isText else QUrl(algHelp)
try:
if isText:
self.txtHelp.setHtml(algHelp)
else:
html = self.tr(
'<p>Downloading algorithm help... Please wait.</p>')
self.txtHelp.setHtml(html)
self.reply = QgsNetworkAccessManager.instance().get(
QNetworkRequest(algHelp))
self.reply.finished.connect(self.requestFinished)
except:
self.txtHelp.setHtml(
self.tr('<h2>No help available for this algorithm</h2>'))
self.tabWidget.addTab(self.txtHelp, 'Help')
self.verticalLayout2.addWidget(self.tabWidget)
self.verticalLayout2.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout2)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
QMetaObject.connectSlotsByName(self)
def createWidget(self):
if self.dialogType == DIALOG_STANDARD:
widget = QWidget()
layout = QHBoxLayout()
layout.setMargin(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
self.combo = QgsMapLayerComboBox()
layout.addWidget(self.combo)
btn = QToolButton()
btn.setText('...')
btn.setToolTip(self.tr("Select file"))
btn.clicked.connect(self.selectFile)
layout.addWidget(btn)
widget.setLayout(layout)
if self.param.optional:
self.combo.setAllowEmptyLayer(True)
self.combo.setFilters(QgsMapLayerProxyModel.VectorLayer)
self.combo.setExcludedProviders(['grass'])
self.combo.currentIndexChanged.connect(
lambda: self.widgetValueHasChanged.emit(self))
self.combo.currentTextChanged.connect(
lambda: self.widgetValueHasChanged.emit(self))
return widget
elif self.dialogType == DIALOG_BATCH:
return BatchInputSelectionPanel(self.param, self.row, self.col,
self.dialog)
else:
self.combo = QComboBox()
layers = self.dialog.getAvailableValuesOfType(
ParameterRaster, OutputRaster)
self.combo.setEditable(True)
tables = self.dialog.getAvailableValuesOfType(
ParameterTable, OutputTable)
layers = self.dialog.getAvailableValuesOfType(
ParameterVector, OutputVector)
if self.param.optional:
self.combo.addItem(self.NOT_SELECTED, None)
for table in tables:
self.combo.addItem(self.dialog.resolveValueDescription(table),
table)
for layer in layers:
self.combo.addItem(self.dialog.resolveValueDescription(layer),
layer)
widget = QWidget()
layout = QHBoxLayout()
layout.setMargin(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
layout.addWidget(self.combo)
btn = QToolButton()
btn.setText('...')
btn.setToolTip(self.tr("Select file"))
btn.clicked.connect(self.selectFile)
layout.addWidget(btn)
widget.setLayout(layout)
return widget
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle(QCoreApplication.translate("PythonConsole", "Python Console"))
self.settings = QgsSettings()
self.shell = ShellScintilla(self)
self.setFocusProxy(self.shell)
self.shellOut = ShellOutputScintilla(self)
self.tabEditorWidget = EditorTabWidget(self)
# ------------ UI -------------------------------
self.splitterEditor = QSplitter(self)
self.splitterEditor.setOrientation(Qt.Horizontal)
self.splitterEditor.setHandleWidth(6)
self.splitterEditor.setChildrenCollapsible(True)
self.shellOutWidget = QWidget(self)
self.shellOutWidget.setLayout(QVBoxLayout())
self.shellOutWidget.layout().setContentsMargins(0, 0, 0, 0)
self.shellOutWidget.layout().addWidget(self.shellOut)
self.splitter = QSplitter(self.splitterEditor)
self.splitter.setOrientation(Qt.Vertical)
self.splitter.setHandleWidth(3)
self.splitter.setChildrenCollapsible(False)
self.splitter.addWidget(self.shellOutWidget)
self.splitter.addWidget(self.shell)
# self.splitterEditor.addWidget(self.tabEditorWidget)
self.splitterObj = QSplitter(self.splitterEditor)
self.splitterObj.setHandleWidth(3)
self.splitterObj.setOrientation(Qt.Horizontal)
# self.splitterObj.setSizes([0, 0])
# self.splitterObj.setStretchFactor(0, 1)
self.widgetEditor = QWidget(self.splitterObj)
self.widgetFind = QWidget(self)
self.listClassMethod = QTreeWidget(self.splitterObj)
self.listClassMethod.setColumnCount(2)
objInspLabel = QCoreApplication.translate("PythonConsole", "Object Inspector")
self.listClassMethod.setHeaderLabels([objInspLabel, ''])
self.listClassMethod.setColumnHidden(1, True)
self.listClassMethod.setAlternatingRowColors(True)
# self.splitterEditor.addWidget(self.widgetEditor)
# self.splitterObj.addWidget(self.listClassMethod)
# self.splitterObj.addWidget(self.widgetEditor)
# Hide side editor on start up
self.splitterObj.hide()
self.listClassMethod.hide()
# Hide search widget on start up
self.widgetFind.hide()
icon_size = iface.iconSize(dockedToolbar=True) if iface else QSize(16, 16)
sizes = self.splitter.sizes()
self.splitter.setSizes(sizes)
# ----------------Restore Settings------------------------------------
self.restoreSettingsConsole()
# ------------------Toolbar Editor-------------------------------------
# Action for Open File
openFileBt = QCoreApplication.translate("PythonConsole", "Open Script...")
self.openFileButton = QAction(self)
self.openFileButton.setCheckable(False)
self.openFileButton.setEnabled(True)
self.openFileButton.setIcon(QgsApplication.getThemeIcon("console/iconOpenConsole.png"))
self.openFileButton.setMenuRole(QAction.PreferencesRole)
self.openFileButton.setIconVisibleInMenu(True)
self.openFileButton.setToolTip(openFileBt)
self.openFileButton.setText(openFileBt)
openExtEditorBt = QCoreApplication.translate("PythonConsole", "Open in External Editor")
self.openInEditorButton = QAction(self)
self.openInEditorButton.setCheckable(False)
self.openInEditorButton.setEnabled(True)
self.openInEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.openInEditorButton.setMenuRole(QAction.PreferencesRole)
self.openInEditorButton.setIconVisibleInMenu(True)
self.openInEditorButton.setToolTip(openExtEditorBt)
self.openInEditorButton.setText(openExtEditorBt)
# Action for Save File
saveFileBt = QCoreApplication.translate("PythonConsole", "Save")
self.saveFileButton = QAction(self)
self.saveFileButton.setCheckable(False)
self.saveFileButton.setEnabled(False)
self.saveFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveConsole.png"))
self.saveFileButton.setMenuRole(QAction.PreferencesRole)
self.saveFileButton.setIconVisibleInMenu(True)
self.saveFileButton.setToolTip(saveFileBt)
self.saveFileButton.setText(saveFileBt)
# Action for Save File As
saveAsFileBt = QCoreApplication.translate("PythonConsole", "Save As...")
self.saveAsFileButton = QAction(self)
self.saveAsFileButton.setCheckable(False)
self.saveAsFileButton.setEnabled(True)
self.saveAsFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveAsConsole.png"))
self.saveAsFileButton.setMenuRole(QAction.PreferencesRole)
self.saveAsFileButton.setIconVisibleInMenu(True)
self.saveAsFileButton.setToolTip(saveAsFileBt)
self.saveAsFileButton.setText(saveAsFileBt)
# Action Cut
cutEditorBt = QCoreApplication.translate("PythonConsole", "Cut")
self.cutEditorButton = QAction(self)
self.cutEditorButton.setCheckable(False)
self.cutEditorButton.setEnabled(True)
self.cutEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditCut.svg"))
self.cutEditorButton.setMenuRole(QAction.PreferencesRole)
self.cutEditorButton.setIconVisibleInMenu(True)
self.cutEditorButton.setToolTip(cutEditorBt)
self.cutEditorButton.setText(cutEditorBt)
# Action Copy
copyEditorBt = QCoreApplication.translate("PythonConsole", "Copy")
self.copyEditorButton = QAction(self)
self.copyEditorButton.setCheckable(False)
self.copyEditorButton.setEnabled(True)
self.copyEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditCopy.svg"))
self.copyEditorButton.setMenuRole(QAction.PreferencesRole)
self.copyEditorButton.setIconVisibleInMenu(True)
self.copyEditorButton.setToolTip(copyEditorBt)
self.copyEditorButton.setText(copyEditorBt)
# Action Paste
pasteEditorBt = QCoreApplication.translate("PythonConsole", "Paste")
self.pasteEditorButton = QAction(self)
self.pasteEditorButton.setCheckable(False)
self.pasteEditorButton.setEnabled(True)
self.pasteEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditPaste.svg"))
self.pasteEditorButton.setMenuRole(QAction.PreferencesRole)
self.pasteEditorButton.setIconVisibleInMenu(True)
self.pasteEditorButton.setToolTip(pasteEditorBt)
self.pasteEditorButton.setText(pasteEditorBt)
# Action Run Script (subprocess)
runScriptEditorBt = QCoreApplication.translate("PythonConsole", "Run script")
self.runScriptEditorButton = QAction(self)
self.runScriptEditorButton.setCheckable(False)
self.runScriptEditorButton.setEnabled(True)
self.runScriptEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconRunScriptConsole.png"))
self.runScriptEditorButton.setMenuRole(QAction.PreferencesRole)
self.runScriptEditorButton.setIconVisibleInMenu(True)
self.runScriptEditorButton.setToolTip(runScriptEditorBt)
self.runScriptEditorButton.setText(runScriptEditorBt)
# Action Run Script (subprocess)
commentEditorBt = QCoreApplication.translate("PythonConsole", "Comment")
self.commentEditorButton = QAction(self)
self.commentEditorButton.setCheckable(False)
self.commentEditorButton.setEnabled(True)
self.commentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconCommentEditorConsole.png"))
self.commentEditorButton.setMenuRole(QAction.PreferencesRole)
self.commentEditorButton.setIconVisibleInMenu(True)
self.commentEditorButton.setToolTip(commentEditorBt)
self.commentEditorButton.setText(commentEditorBt)
# Action Run Script (subprocess)
uncommentEditorBt = QCoreApplication.translate("PythonConsole", "Uncomment")
self.uncommentEditorButton = QAction(self)
self.uncommentEditorButton.setCheckable(False)
self.uncommentEditorButton.setEnabled(True)
self.uncommentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconUncommentEditorConsole.png"))
self.uncommentEditorButton.setMenuRole(QAction.PreferencesRole)
self.uncommentEditorButton.setIconVisibleInMenu(True)
self.uncommentEditorButton.setToolTip(uncommentEditorBt)
self.uncommentEditorButton.setText(uncommentEditorBt)
# Action for Object browser
objList = QCoreApplication.translate("PythonConsole", "Object Inspector...")
self.objectListButton = QAction(self)
self.objectListButton.setCheckable(True)
self.objectListButton.setEnabled(self.settings.value("pythonConsole/enableObjectInsp",
False, type=bool))
self.objectListButton.setIcon(QgsApplication.getThemeIcon("console/iconClassBrowserConsole.png"))
self.objectListButton.setMenuRole(QAction.PreferencesRole)
self.objectListButton.setIconVisibleInMenu(True)
self.objectListButton.setToolTip(objList)
self.objectListButton.setText(objList)
# Action for Find text
findText = QCoreApplication.translate("PythonConsole", "Find Text")
self.findTextButton = QAction(self)
self.findTextButton.setCheckable(True)
self.findTextButton.setEnabled(True)
self.findTextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchEditorConsole.png"))
self.findTextButton.setMenuRole(QAction.PreferencesRole)
self.findTextButton.setIconVisibleInMenu(True)
self.findTextButton.setToolTip(findText)
self.findTextButton.setText(findText)
# ----------------Toolbar Console-------------------------------------
# Action Show Editor
showEditor = QCoreApplication.translate("PythonConsole", "Show Editor")
self.showEditorButton = QAction(self)
self.showEditorButton.setEnabled(True)
self.showEditorButton.setCheckable(True)
self.showEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.showEditorButton.setMenuRole(QAction.PreferencesRole)
self.showEditorButton.setIconVisibleInMenu(True)
self.showEditorButton.setToolTip(showEditor)
self.showEditorButton.setText(showEditor)
# Action for Clear button
clearBt = QCoreApplication.translate("PythonConsole", "Clear Console")
self.clearButton = QAction(self)
self.clearButton.setCheckable(False)
self.clearButton.setEnabled(True)
self.clearButton.setIcon(QgsApplication.getThemeIcon("console/iconClearConsole.png"))
self.clearButton.setMenuRole(QAction.PreferencesRole)
self.clearButton.setIconVisibleInMenu(True)
self.clearButton.setToolTip(clearBt)
self.clearButton.setText(clearBt)
# Action for settings
optionsBt = QCoreApplication.translate("PythonConsole", "Options...")
self.optionsButton = QAction(self)
self.optionsButton.setCheckable(False)
self.optionsButton.setEnabled(True)
self.optionsButton.setIcon(QgsApplication.getThemeIcon("console/iconSettingsConsole.png"))
self.optionsButton.setMenuRole(QAction.PreferencesRole)
self.optionsButton.setIconVisibleInMenu(True)
self.optionsButton.setToolTip(optionsBt)
self.optionsButton.setText(optionsBt)
# Action for Run script
runBt = QCoreApplication.translate("PythonConsole", "Run Command")
self.runButton = QAction(self)
self.runButton.setCheckable(False)
self.runButton.setEnabled(True)
self.runButton.setIcon(QgsApplication.getThemeIcon("console/iconRunConsole.png"))
self.runButton.setMenuRole(QAction.PreferencesRole)
self.runButton.setIconVisibleInMenu(True)
self.runButton.setToolTip(runBt)
self.runButton.setText(runBt)
# Help action
helpBt = QCoreApplication.translate("PythonConsole", "Help...")
self.helpButton = QAction(self)
self.helpButton.setCheckable(False)
self.helpButton.setEnabled(True)
self.helpButton.setIcon(QgsApplication.getThemeIcon("console/iconHelpConsole.png"))
self.helpButton.setMenuRole(QAction.PreferencesRole)
self.helpButton.setIconVisibleInMenu(True)
self.helpButton.setToolTip(helpBt)
self.helpButton.setText(helpBt)
self.toolBar = QToolBar()
self.toolBar.setEnabled(True)
self.toolBar.setFocusPolicy(Qt.NoFocus)
self.toolBar.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBar.setLayoutDirection(Qt.LeftToRight)
self.toolBar.setIconSize(icon_size)
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
self.toolBar.addAction(self.clearButton)
self.toolBar.addAction(self.runButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.showEditorButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.optionsButton)
self.toolBar.addAction(self.helpButton)
self.toolBarEditor = QToolBar()
self.toolBarEditor.setEnabled(False)
self.toolBarEditor.setFocusPolicy(Qt.NoFocus)
self.toolBarEditor.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBarEditor.setLayoutDirection(Qt.LeftToRight)
self.toolBarEditor.setIconSize(icon_size)
self.toolBarEditor.setMovable(False)
self.toolBarEditor.setFloatable(False)
self.toolBarEditor.addAction(self.openFileButton)
self.toolBarEditor.addAction(self.openInEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.saveFileButton)
self.toolBarEditor.addAction(self.saveAsFileButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.runScriptEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.findTextButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.cutEditorButton)
self.toolBarEditor.addAction(self.copyEditorButton)
self.toolBarEditor.addAction(self.pasteEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.commentEditorButton)
self.toolBarEditor.addAction(self.uncommentEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.objectListButton)
self.widgetButton = QWidget()
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widgetButton.sizePolicy().hasHeightForWidth())
self.widgetButton.setSizePolicy(sizePolicy)
self.widgetButtonEditor = QWidget(self.widgetEditor)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widgetButtonEditor.sizePolicy().hasHeightForWidth())
self.widgetButtonEditor.setSizePolicy(sizePolicy)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.shellOut.sizePolicy().hasHeightForWidth())
self.shellOut.setSizePolicy(sizePolicy)
self.shellOut.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.shell.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
# ------------ Layout -------------------------------
self.mainLayout = QGridLayout(self)
self.mainLayout.setMargin(0)
self.mainLayout.setSpacing(0)
self.mainLayout.addWidget(self.widgetButton, 0, 0, 1, 1)
self.mainLayout.addWidget(self.splitterEditor, 0, 1, 1, 1)
self.shellOutWidget.layout().insertWidget(0, self.toolBar)
self.layoutEditor = QGridLayout(self.widgetEditor)
self.layoutEditor.setMargin(0)
self.layoutEditor.setSpacing(0)
self.layoutEditor.addWidget(self.toolBarEditor, 0, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetButtonEditor, 1, 0, 2, 1)
self.layoutEditor.addWidget(self.tabEditorWidget, 1, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetFind, 2, 1, 1, 1)
# Layout for the find widget
self.layoutFind = QGridLayout(self.widgetFind)
self.layoutFind.setContentsMargins(0, 0, 0, 0)
self.lineEditFind = QgsFilterLineEdit()
placeHolderTxt = QCoreApplication.translate("PythonConsole", "Enter text to find...")
self.lineEditFind.setPlaceholderText(placeHolderTxt)
self.findNextButton = QToolButton()
self.findNextButton.setEnabled(False)
toolTipfindNext = QCoreApplication.translate("PythonConsole", "Find Next")
self.findNextButton.setToolTip(toolTipfindNext)
self.findNextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchNextEditorConsole.png"))
self.findNextButton.setIconSize(QSize(24, 24))
self.findNextButton.setAutoRaise(True)
self.findPrevButton = QToolButton()
self.findPrevButton.setEnabled(False)
toolTipfindPrev = QCoreApplication.translate("PythonConsole", "Find Previous")
self.findPrevButton.setToolTip(toolTipfindPrev)
self.findPrevButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchPrevEditorConsole.png"))
self.findPrevButton.setIconSize(QSize(24, 24))
self.findPrevButton.setAutoRaise(True)
self.caseSensitive = QCheckBox()
caseSensTr = QCoreApplication.translate("PythonConsole", "Case Sensitive")
self.caseSensitive.setText(caseSensTr)
self.wholeWord = QCheckBox()
wholeWordTr = QCoreApplication.translate("PythonConsole", "Whole Word")
self.wholeWord.setText(wholeWordTr)
self.wrapAround = QCheckBox()
self.wrapAround.setChecked(True)
wrapAroundTr = QCoreApplication.translate("PythonConsole", "Wrap Around")
self.wrapAround.setText(wrapAroundTr)
self.layoutFind.addWidget(self.lineEditFind, 0, 1, 1, 1)
self.layoutFind.addWidget(self.findPrevButton, 0, 2, 1, 1)
self.layoutFind.addWidget(self.findNextButton, 0, 3, 1, 1)
self.layoutFind.addWidget(self.caseSensitive, 0, 4, 1, 1)
self.layoutFind.addWidget(self.wholeWord, 0, 5, 1, 1)
self.layoutFind.addWidget(self.wrapAround, 0, 6, 1, 1)
# ------------ Add first Tab in Editor -------------------------------
# self.tabEditorWidget.newTabEditor(tabName='first', filename=None)
# ------------ Signal -------------------------------
self.findTextButton.triggered.connect(self._toggleFind)
self.objectListButton.toggled.connect(self.toggleObjectListWidget)
self.commentEditorButton.triggered.connect(self.commentCode)
self.uncommentEditorButton.triggered.connect(self.uncommentCode)
self.runScriptEditorButton.triggered.connect(self.runScriptEditor)
self.cutEditorButton.triggered.connect(self.cutEditor)
self.copyEditorButton.triggered.connect(self.copyEditor)
self.pasteEditorButton.triggered.connect(self.pasteEditor)
self.showEditorButton.toggled.connect(self.toggleEditor)
self.clearButton.triggered.connect(self.shellOut.clearConsole)
self.optionsButton.triggered.connect(self.openSettings)
self.runButton.triggered.connect(self.shell.entered)
self.openFileButton.triggered.connect(self.openScriptFile)
self.openInEditorButton.triggered.connect(self.openScriptFileExtEditor)
self.saveFileButton.triggered.connect(self.saveScriptFile)
self.saveAsFileButton.triggered.connect(self.saveAsScriptFile)
self.helpButton.triggered.connect(self.openHelp)
self.listClassMethod.itemClicked.connect(self.onClickGoToLine)
self.lineEditFind.returnPressed.connect(self._findNext)
self.findNextButton.clicked.connect(self._findNext)
self.findPrevButton.clicked.connect(self._findPrev)
self.lineEditFind.textChanged.connect(self._textFindChanged)
self.findScut = QShortcut(QKeySequence.Find, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._openFind)
self.findNextScut = QShortcut(QKeySequence.FindNext, self.widgetEditor)
self.findNextScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findNextScut.activated.connect(self._findNext)
self.findPreviousScut = QShortcut(QKeySequence.FindPrevious, self.widgetEditor)
self.findPreviousScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findPreviousScut.activated.connect(self._findPrev)
# Escape on editor hides the find bar
self.findScut = QShortcut(Qt.Key_Escape, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._closeFind)
def fill_tree_with_element(widget,
treeItem,
elt,
ns_imap={},
custom_viewers={},
ns_map={}):
"""
:param widget: the QTreeWidget
:param treeItem: a QTreeWidgetItem to fill
:param elt: the XML node
:param ns_imap: an "inverse" namespace map { uri : prefix }
:param custom_viewers: a dict giving a custom viewer plugin (QWidget) for some elements {tag : constructor}
:param ns_map: a namespace map { prefix : uri }
"""
is_root = treeItem == widget.invisibleRootItem()
# tag
ns, tag = split_tag(elt.tag)
if ns and ns_imap.get(ns):
treeItem.setText(0, ns_imap[ns] + ":" + tag)
else:
treeItem.setText(0, tag)
f = treeItem.font(0)
f.setBold(True)
treeItem.setFont(0, f)
# custom viewer
if elt.tag in custom_viewers:
custom_viewer_widget, filter = custom_viewers[elt.tag]
if filter is None or elt.find(filter, ns_map) is not None:
btn = QToolButton(widget)
btn.setIcon(custom_viewer_widget.icon())
btn.setIconSize(QSize(32, 32))
def show_viewer(btn):
widget.w = custom_viewer_widget.init_from_xml(elt)
widget.w.setWindowModality(Qt.WindowModal)
widget.w.show()
btn.clicked.connect(show_viewer)
w = QWidget(widget)
l = QHBoxLayout()
l.addWidget(btn)
l.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding))
w.setLayout(l)
if is_root:
# insert an item
child = QTreeWidgetItem()
treeItem.addChild(child)
widget.setItemWidget(child, 0, w)
else:
widget.setItemWidget(treeItem, 1, w)
# attributes
for k, v in elt.attrib.items():
child = QTreeWidgetItem()
treeItem.addChild(child)
if "}" in k:
i = k.index("}")
ns = k[1:i]
# get ns prefix from ns uri
p = ns_imap.get(ns)
if p is not None:
n = p + ":" + k[i + 1:]
else:
n = k[i + 1:]
else:
n = no_prefix(k)
child.setText(0, "@" + n)
if n == "xlink:href" and v.startswith("http"):
html = QLabel(widget)
html.setOpenExternalLinks(True)
html.setTextFormat(Qt.RichText)
html.setText('<a href="{}">{}</a>'.format(v, v))
child.setData(1, Qt.UserRole, v)
widget.setItemWidget(child, 1, html)
else:
child.setText(1, v)
# text
if elt.text:
treeItem.setText(1, elt.text)
# children
for xmlChild in elt:
child = QTreeWidgetItem()
treeItem.addChild(child)
fill_tree_with_element(widget, child, xmlChild, ns_imap,
custom_viewers, ns_map)
def initWidgets(self):
# If there are advanced parameters — show corresponding groupbox
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.grpAdvanced.show()
break
widget_context = QgsProcessingParameterWidgetContext()
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
# Create widgets and put them in layouts
for param in self.alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if param.isDestination():
continue
else:
wrapper = WidgetWrapperFactory.create_wrapper(param, self.parent)
self.wrappers[param.name()] = wrapper
# For compatibility with 3.x API, we need to check whether the wrapper is
# the deprecated WidgetWrapper class. If not, it's the newer
# QgsAbstractProcessingParameterWidgetWrapper class
# TODO QGIS 4.0 - remove
is_python_wrapper = issubclass(wrapper.__class__, WidgetWrapper)
if not is_python_wrapper:
wrapper.setWidgetContext(widget_context)
widget = wrapper.createWrappedWidget(self.processing_context)
wrapper.registerProcessingContextGenerator(self.context_generator)
else:
widget = wrapper.widget
if self.in_place and param.name() in ('INPUT', 'OUTPUT'):
# don't show the input/output parameter widgets in in-place mode
# we still need to CREATE them, because other wrappers may need to interact
# with them (e.g. those parameters which need the input layer for field
# selections/crs properties/etc)
continue
if widget is not None:
if is_python_wrapper:
widget.setToolTip(param.toolTip())
if isinstance(param, QgsProcessingParameterFeatureSource):
layout = QHBoxLayout()
layout.setSpacing(6)
layout.setMargin(0)
layout.addWidget(widget)
button = QToolButton()
icon = QIcon(os.path.join(pluginPath, 'images', 'iterate.png'))
button.setIcon(icon)
button.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
button.setToolTip(self.tr('Iterate over this layer, creating a separate output for every feature in the layer'))
button.setCheckable(True)
layout.addWidget(button)
layout.setAlignment(button, Qt.AlignTop)
self.iterateButtons[param.name()] = button
button.toggled.connect(self.buttonToggled)
widget = QWidget()
widget.setLayout(layout)
label = None
if not is_python_wrapper:
label = wrapper.createWrappedLabel()
else:
label = wrapper.label
if label is not None:
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(label)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, label)
elif is_python_wrapper:
desc = param.description()
if isinstance(param, QgsProcessingParameterExtent):
desc += self.tr(' (xmin, xmax, ymin, ymax)')
if isinstance(param, QgsProcessingParameterPoint):
desc += self.tr(' (x, y)')
if param.flags() & QgsProcessingParameterDefinition.FlagOptional:
desc += self.tr(' [optional]')
widget.setText(desc)
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(widget)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, widget)
for output in self.alg.destinationParameterDefinitions():
if output.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if self.in_place and param.name() in ('INPUT', 'OUTPUT'):
continue
label = QLabel(output.description())
widget = DestinationSelectionPanel(output, self.alg)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (QgsProcessingParameterRasterDestination, QgsProcessingParameterFeatureSink, QgsProcessingParameterVectorDestination)):
check = QCheckBox()
check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file after running algorithm'))
def skipOutputChanged(checkbox, skipped):
checkbox.setEnabled(not skipped)
if skipped:
checkbox.setChecked(False)
check.setChecked(not widget.outputIsSkipped())
check.setEnabled(not widget.outputIsSkipped())
widget.skipOutputChanged.connect(partial(skipOutputChanged, check))
self.layoutMain.insertWidget(self.layoutMain.count() - 1, check)
self.checkBoxes[output.name()] = check
widget.setToolTip(param.toolTip())
self.outputWidgets[output.name()] = widget
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
def __init__(self, iface):
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(os.path.dirname(__file__), 'i18n',
'annotationManager_{}.qm'.format(locale))
self.translator = None
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
self.iface = iface
self.iface.projectRead.connect(self.projectOpen)
self.dock = QDockWidget(self.tr('Annotations'))
self.manager = QWidget()
toolbar = QToolBar()
self.annotationList = QListWidget()
self.annotationList.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.annotationList.itemSelectionChanged.connect(self.selectAnnotation)
self.annotationList.itemChanged.connect(self.checkItem)
action_refresh = QAction(
QIcon(':/plugins/annotationManager/resources/mActionDraw.png'),
self.tr('Refresh the annotations list'), self.manager)
action_refresh.triggered.connect(self.refreshAnnotations)
action_remove = QAction(
QIcon(
':/plugins/annotationManager/resources/mActionRemoveAnnotation.png'
), self.tr('Remove the selected annotation'), self.manager)
action_remove.triggered.connect(self.removeAnnotation)
viewMenu = QMenu()
action_showAll = QAction(
QIcon(':/plugins/annotationManager/resources/mActionShowAll.png'),
self.tr('Show all annotations'), self.manager)
action_showAll.triggered.connect(self.showAll)
action_hideAll = QAction(
QIcon(':/plugins/annotationManager/resources/mActionHideAll.png'),
self.tr('Hide all annotations'), self.manager)
action_hideAll.triggered.connect(self.hideAll)
action_showAllSelected = QAction(
QIcon(':/plugins/annotationManager/resources/mActionShowAll.png'),
self.tr('Show all selected annotations'), self.manager)
action_showAllSelected.triggered.connect(self.showAllSelected)
action_hideAllSelected = QAction(
QIcon(':/plugins/annotationManager/resources/mActionHideAll.png'),
self.tr('Hide all selected annotations'), self.manager)
action_hideAllSelected.triggered.connect(self.hideAllSelected)
viewMenu.addAction(action_showAll)
viewMenu.addAction(action_hideAll)
viewMenu.addAction(action_showAllSelected)
viewMenu.addAction(action_hideAllSelected)
viewButton = QToolButton()
viewButton.setIcon(
QIcon(':/plugins/annotationManager/resources/mActionShowAll.png'))
viewButton.setPopupMode(2)
viewButton.setMenu(viewMenu)
toolbar.addAction(action_refresh)
toolbar.addAction(action_remove)
toolbar.addWidget(viewButton)
toolbar.setIconSize(QSize(16, 16))
p1_vertical = QVBoxLayout()
p1_vertical.setContentsMargins(0, 0, 0, 0)
p1_vertical.addWidget(toolbar)
p1_vertical.addWidget(self.annotationList)
self.manager.setLayout(p1_vertical)
self.dock.setWidget(self.manager)
self.dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock)
self.rb = QgsRubberBand(self.iface.mapCanvas(),
QgsWkbTypes.PolygonGeometry)
self.project = QgsProject.instance()
self.annotationManager = self.project.annotationManager()
self.annotationManager.annotationAdded.connect(self.refreshAnnotations)
self.annotationManager.annotationRemoved.connect(
self.refreshAnnotations)
def setupUi(self):
self.checkBoxes = {}
self.showAdvanced = False
self.wrappers = {}
self.valueItems = {}
self.dependentItems = {}
self.algorithmItem = None
self.resize(650, 450)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok
| QDialogButtonBox.Help)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setSpacing(5)
self.verticalLayout.setMargin(20)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.addWidget(self.bar)
hLayout = QHBoxLayout()
hLayout.setSpacing(5)
hLayout.setMargin(0)
descriptionLabel = QLabel(self.tr("Description"))
self.descriptionBox = QLineEdit()
self.descriptionBox.setText(self._alg.displayName())
hLayout.addWidget(descriptionLabel)
hLayout.addWidget(self.descriptionBox)
self.verticalLayout.addLayout(hLayout)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.verticalLayout.addWidget(line)
self.algorithmItem = QgsGui.instance().processingGuiRegistry(
).algorithmConfigurationWidget(self._alg)
if self.configuration:
self.algorithmItem.setConfiguration(self.configuration)
self.verticalLayout.addWidget(self.algorithmItem)
for param in self._alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.advancedButton = QPushButton()
self.advancedButton.setText(
self.tr('Show advanced parameters'))
self.advancedButton.clicked.connect(
self.showAdvancedParametersClicked)
advancedButtonHLayout = QHBoxLayout()
advancedButtonHLayout.addWidget(self.advancedButton)
advancedButtonHLayout.addStretch()
self.verticalLayout.addLayout(advancedButtonHLayout)
break
for param in self._alg.parameterDefinitions():
if param.isDestination(
) or param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
wrapper = WidgetWrapperFactory.create_wrapper(param, self)
self.wrappers[param.name()] = wrapper
widget = wrapper.widget
if widget is not None:
self.valueItems[param.name()] = widget
tooltip = param.description()
widget.setToolTip(tooltip)
if param.flags(
) & QgsProcessingParameterDefinition.FlagAdvanced:
wrapper.label.setVisible(self.showAdvanced)
widget.setVisible(self.showAdvanced)
self.verticalLayout.addWidget(wrapper.label)
self.verticalLayout.addWidget(widget)
for dest in self._alg.destinationParameterDefinitions():
if dest.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if isinstance(dest, (QgsProcessingParameterRasterDestination,
QgsProcessingParameterVectorDestination,
QgsProcessingParameterFeatureSink,
QgsProcessingParameterFileDestination,
QgsProcessingParameterFolderDestination)):
label = QLabel(dest.description())
item = QgsFilterLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(
self.tr('[Enter name if this is a final result]'))
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(item)
self.valueItems[dest.name()] = item
label = QLabel(' ')
self.verticalLayout.addWidget(label)
label = QLabel(self.tr('Parent algorithms'))
self.dependenciesPanel = self.getDependenciesPanel()
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(self.dependenciesPanel)
self.verticalLayout.addStretch(1000)
self.setPreviousValues()
self.setWindowTitle(self._alg.displayName())
self.verticalLayout2 = QVBoxLayout()
self.verticalLayout2.setSpacing(2)
self.verticalLayout2.setMargin(0)
self.paramPanel = QWidget()
self.paramPanel.setLayout(self.verticalLayout)
self.scrollArea = QgsScrollArea()
self.scrollArea.setWidget(self.paramPanel)
self.scrollArea.setWidgetResizable(True)
self.verticalLayout2.addWidget(self.scrollArea)
self.verticalLayout2.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout2)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.buttonBox.helpRequested.connect(self.openHelp)
QMetaObject.connectSlotsByName(self)
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
def upload_data(self):
if self.check_login():
if self.local_data_sources.count() == 0:
return
if self.db_connections.count() == 0:
QMessageBox.warning(self, self.tr("No database available"), self.tr("Please create a database in the 'Account' tab."))
return
if not self.ui.cbUploadDatabase.currentIndex() >= 0:
QMessageBox.warning(self, self.tr("No database selected"), self.tr("Please select a database to upload data."))
return
db_name = self.ui.cbUploadDatabase.currentText()
if not self.db_connections.isPortOpen(db_name):
uri = self.db_connections.cloud_layer_uri(db_name, "", "")
host = str(uri.host())
port = uri.port()
QMessageBox.critical(self, self.tr("Network Error"),
self.tr("Could not connect to database server ({0}) on port {1}. Please contact your system administrator or internet provider to open port {1} in the firewall".format(host, port)))
return
# disable update of local data sources during upload, as there are
# temporary layers added and removed
self.do_update_local_data_sources = False
self.statusBar().showMessage(self.tr("Uploading data..."))
self.setCursor(Qt.WaitCursor)
self.ui.btnUploadData.hide()
self.ui.spinner.start()
self.ui.progressWidget.show()
# Map<data_source, {table: table, layers: layers}>
data_sources_items = {}
for row in range(0, self.ui.tblLocalLayers.rowCount()):
data_source = unicode(
self.ui.tblLocalLayers.item(
row, self.COLUMN_DATA_SOURCE).text())
layers = self.local_data_sources.layers(data_source)
if layers is not None:
table_name = unicode(
self.ui.tblLocalLayers.item(
row, self.COLUMN_TABLE_NAME).text())
data_sources_items[data_source] = {
u'table': unicode(table_name), u'layers': layers}
login_info = self.api.check_login(version_info=self._version_info())
try:
self.maxSize = login_info['max_storage']
self.maxDBs = login_info['max_dbs']
except:
self.maxSize = 50
self.maxDBs = 5
try:
self.data_upload.upload(self.db_connections.db(unicode(db_name)), data_sources_items, unicode(self.maxSize))
upload_ok = True
except Exception as e:
ErrorReportDialog(self.tr("Upload errors occurred"), self.tr("Upload errors occurred. Not all data could be uploaded."), str(e) + "\n" + traceback.format_exc(), self.user, self).exec_()
upload_ok = False
self.ui.spinner.stop()
self.ui.progressWidget.hide()
self.ui.btnUploadData.show()
self.unsetCursor()
self.statusBar().showMessage("")
# Refresh local layers
self.do_update_local_data_sources = True
self.update_local_layers()
# Refresh used space after upload
self.db_size(self.db_connections)
if upload_ok:
# Show save project dialog
save_dialog = QDialog(self)
save_dialog.setWindowTitle(self.tr("Save Project"))
save_dialog.setLayout(QVBoxLayout())
header = QWidget()
header.setLayout(QVBoxLayout())
label = QLabel(self.tr("Upload complete. The local layers in the project were replaced with the layers uploaded to the qgiscloud database."))
label.setWordWrap(True)
header.layout().addWidget(label)
label = QLabel(self.tr("Choose were to save the modified project:"))
label.setWordWrap(True)
header.layout().addWidget(label)
save_dialog.layout().setContentsMargins(0, 0, 0, 0)
save_dialog.layout().addWidget(header)
initialPath = QgsProject.instance().fileName()
if not initialPath:
initialPath = QSettings().value("/UI/lastProjectDir", ".")
fd = QFileDialog(None, self.tr("Save Project"), initialPath, "%s (*.qgz *.qgs)" % self.tr("QGIS Project Files"))
fd.setParent(save_dialog, Qt.Widget)
fd.setOption(QFileDialog.DontUseNativeDialog)
fd.setAcceptMode(QFileDialog.AcceptSave)
save_dialog.layout().addWidget(fd)
header.layout().setContentsMargins(fd.layout().contentsMargins())
fd.accepted.connect(save_dialog.accept)
fd.rejected.connect(save_dialog.reject)
if save_dialog.exec_() == QDialog.Accepted:
files = list(fd.selectedFiles())
if files:
QgsProject.instance().setFileName(files[0])
self.iface.actionSaveProject().trigger()
# Switch to map tab
self.ui.tabWidget.setCurrentWidget(self.ui.mapTab)
def setupUi(self):
type_metadata = QgsApplication.processingRegistry().parameterType(
self.param.type() if self.param else self.paramType)
self.setWindowTitle(
self.tr('{} Parameter Definition').format(type_metadata.name()))
self.mainLayout = QVBoxLayout()
self.tab = QTabWidget()
self.mainLayout.addWidget(self.tab)
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout()
self.label = QLabel(self.tr('Parameter name'))
self.verticalLayout.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.verticalLayout.addWidget(self.nameTextBox)
if isinstance(self.param, QgsProcessingParameterDefinition):
self.nameTextBox.setText(self.param.description())
if self.paramType == parameters.PARAMETER_TABLE_FIELD or \
isinstance(self.param, QgsProcessingParameterField):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
# add the datatype selector
self.verticalLayout.addWidget(QLabel(self.tr('Allowed data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Any'), -1)
self.datatypeCombo.addItem(self.tr('Number'), 0)
self.datatypeCombo.addItem(self.tr('String'), 1)
self.datatypeCombo.addItem(self.tr('Date/time'), 2)
self.verticalLayout.addWidget(self.datatypeCombo)
if self.param is not None and self.param.dataType() is not None:
# QComboBoxes indexes start at 0,
# self.param.datatype start with -1 that is why I need to do +1
datatypeIndex = self.param.dataType() + 1
self.datatypeCombo.setCurrentIndex(datatypeIndex)
self.multipleCheck = QCheckBox()
self.multipleCheck.setText(self.tr('Accept multiple fields'))
self.multipleCheck.setChecked(False)
if self.param is not None:
self.multipleCheck.setChecked(self.param.allowMultiple())
self.verticalLayout.addWidget(self.multipleCheck)
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setToolTip(
self.
tr('Default field name, or ; separated list of field names for multiple field parameters'
))
if self.param is not None:
default = self.param.defaultValue()
if default is not None:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif self.paramType == parameters.PARAMETER_BAND or \
isinstance(self.param, QgsProcessingParameterBand):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterRasterLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType
in (parameters.PARAMETER_VECTOR, parameters.PARAMETER_TABLE)
or isinstance(self.param, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer))):
self.verticalLayout.addWidget(QLabel(self.tr('Geometry type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Geometry Not Required'),
QgsProcessing.TypeVector)
self.shapetypeCombo.addItem(self.tr('Point'),
QgsProcessing.TypeVectorPoint)
self.shapetypeCombo.addItem(self.tr('Line'),
QgsProcessing.TypeVectorLine)
self.shapetypeCombo.addItem(self.tr('Polygon'),
QgsProcessing.TypeVectorPolygon)
self.shapetypeCombo.addItem(self.tr('Any Geometry Type'),
QgsProcessing.TypeVectorAnyGeometry)
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(
self.shapetypeCombo.findData(self.param.dataTypes()[0]))
self.verticalLayout.addWidget(self.shapetypeCombo)
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.verticalLayout.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Any Map Layer'),
QgsProcessing.TypeMapLayer)
self.datatypeCombo.addItem(
self.tr('Vector (No Geometry Required)'),
QgsProcessing.TypeVector)
self.datatypeCombo.addItem(self.tr('Vector (Point)'),
QgsProcessing.TypeVectorPoint)
self.datatypeCombo.addItem(self.tr('Vector (Line)'),
QgsProcessing.TypeVectorLine)
self.datatypeCombo.addItem(self.tr('Vector (Polygon)'),
QgsProcessing.TypeVectorPolygon)
self.datatypeCombo.addItem(self.tr('Vector (Any Geometry Type)'),
QgsProcessing.TypeVectorAnyGeometry)
self.datatypeCombo.addItem(self.tr('Raster'),
QgsProcessing.TypeRaster)
self.datatypeCombo.addItem(self.tr('File'), QgsProcessing.TypeFile)
if self.param is not None:
self.datatypeCombo.setCurrentIndex(
self.datatypeCombo.findData(self.param.layerType()))
self.verticalLayout.addWidget(self.datatypeCombo)
elif (self.paramType
in (parameters.PARAMETER_NUMBER, parameters.PARAMETER_DISTANCE,
parameters.PARAMETER_SCALE)
or isinstance(self.param, (QgsProcessingParameterNumber,
QgsProcessingParameterDistance,
QgsProcessingParameterScale))):
if (self.paramType == parameters.PARAMETER_DISTANCE
or isinstance(self.param, QgsProcessingParameterDistance)):
self.verticalLayout.addWidget(QLabel(self.tr('Linked input')))
self.parentCombo = QComboBox()
self.parentCombo.addItem('', '')
idx = 1
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition,
(QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer,
QgsProcessingParameterMapLayer,
QgsProcessingParameterCrs)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType != parameters.PARAMETER_SCALE
and not isinstance(self.param, QgsProcessingParameterScale)):
self.verticalLayout.addWidget(QLabel(self.tr('Number type')))
self.type_combo = QComboBox()
self.type_combo.addItem(self.tr('Float'),
QgsProcessingParameterNumber.Double)
self.type_combo.addItem(self.tr('Integer'),
QgsProcessingParameterNumber.Integer)
if self.param:
self.type_combo.setCurrentIndex(
self.type_combo.findData(self.param.dataType()))
self.verticalLayout.addWidget(self.type_combo)
if (self.paramType != parameters.PARAMETER_SCALE and
not isinstance(self.param, QgsProcessingParameterScale)):
self.verticalLayout.addWidget(QLabel(self.tr('Min value')))
self.minTextBox = QLineEdit()
self.verticalLayout.addWidget(self.minTextBox)
self.verticalLayout.addWidget(QLabel(self.tr('Max value')))
self.maxTextBox = QLineEdit()
self.verticalLayout.addWidget(self.maxTextBox)
if self.param is not None:
self.minTextBox.setText(str(self.param.minimum()))
self.maxTextBox.setText(str(self.param.maximum()))
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setText(self.tr('0'))
if self.param is not None:
default = self.param.defaultValue()
if self.param.dataType(
) == QgsProcessingParameterNumber.Integer:
default = int(math.floor(float(default)))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultEdit = QgsExpressionLineEdit()
if self.param is not None:
self.defaultEdit.setExpression(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultEdit)
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
self.parentCombo.addItem(self.tr("None"), None)
idx = 1
for param in list(self.alg.parameterComponents().values()):
definition = self.alg.parameterDefinition(
param.parameterName())
if isinstance(definition, (QgsProcessingParameterFeatureSource,
QgsProcessingParameterVectorLayer)):
self.parentCombo.addItem(definition.description(),
definition.name())
if self.param is not None:
if self.param.parentLayerParameterName(
) == definition.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType == parameters.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.defaultValue())
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == parameters.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.selector = QgsProjectionSelectionWidget()
if self.param is not None:
self.selector.setCrs(
QgsCoordinateReferenceSystem(self.param.defaultValue()))
else:
self.selector.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.verticalLayout.addWidget(self.selector)
elif self.paramType == parameters.PARAMETER_ENUM or \
isinstance(self.param, QgsProcessingParameterEnum):
self.widget = EnumModelerWidget(self)
if self.param is not None:
self.widget.setAllowMultiple(bool(self.param.allowMultiple()))
self.widget.setOptions(self.param.options())
self.widget.setDefault(self.param.defaultValue())
self.verticalLayout.addWidget(self.widget)
elif self.paramType == parameters.PARAMETER_MATRIX or \
isinstance(self.param, QgsProcessingParameterMatrix):
self.widget = MatrixModelerWidget(self)
if self.param is not None:
self.widget.setValue(self.param.headers(),
self.param.defaultValue())
self.widget.setFixedRows(self.param.hasFixedNumberRows())
self.verticalLayout.addWidget(self.widget)
elif isinstance(self.param, QgsProcessingDestinationParameter):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultWidget = DestinationSelectionPanel(
self.param, self.alg, default_selection=True)
self.verticalLayout.addWidget(self.defaultWidget)
self.verticalLayout.addSpacing(20)
self.requiredCheck = QCheckBox()
self.requiredCheck.setText(self.tr('Mandatory'))
self.requiredCheck.setChecked(True)
if self.param is not None:
self.requiredCheck.setChecked(
not self.param.flags()
& QgsProcessingParameterDefinition.FlagOptional)
self.verticalLayout.addWidget(self.requiredCheck)
self.advancedCheck = QCheckBox()
self.advancedCheck.setText(self.tr('Advanced'))
self.advancedCheck.setChecked(False)
if self.param is not None:
self.advancedCheck.setChecked(
self.param.flags()
& QgsProcessingParameterDefinition.FlagAdvanced)
self.verticalLayout.addWidget(self.advancedCheck)
# If child algorithm output is mandatory, disable checkbox
if isinstance(self.param, QgsProcessingDestinationParameter):
provider_name, child_name, output_name = self.param.name().split(
':')
child = self.alg.childAlgorithms()['{}:{}'.format(
provider_name, child_name)]
model_output = child.modelOutput(output_name)
param_def = child.algorithm().parameterDefinition(
model_output.childOutputName())
if not (param_def.flags()
& QgsProcessingParameterDefinition.FlagOptional):
self.requiredCheck.setEnabled(False)
self.requiredCheck.setChecked(True)
self.advancedCheck.setEnabled(False)
self.advancedCheck.setChecked(False)
self.verticalLayout.addStretch()
w = QWidget()
w.setLayout(self.verticalLayout)
self.tab.addTab(w, self.tr('Properties'))
self.commentLayout = QVBoxLayout()
self.commentEdit = QTextEdit()
self.commentEdit.setAcceptRichText(False)
self.commentLayout.addWidget(self.commentEdit)
w2 = QWidget()
w2.setLayout(self.commentLayout)
self.tab.addTab(w2, self.tr('Comments'))
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName('buttonBox')
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.mainLayout.addWidget(self.buttonBox)
self.setLayout(self.mainLayout)
def get_selector(self,
dialog,
selector_type,
filter=False,
widget=None,
text_filter=None,
current_tab=None):
"""
Ask to DB for selectors and make dialog
:param dialog: Is a standard dialog, from file selector.ui, where put widgets
:param selector_type: List of selectors to ask DB ['exploitation', 'state', ...]
"""
index = 0
main_tab = dialog.findChild(QTabWidget, 'main_tab')
# Set filter
if filter is not False:
main_tab = dialog.findChild(QTabWidget, 'main_tab')
text_filter = tools_qt.get_text(dialog, widget)
if text_filter in ('null', None):
text_filter = ''
# Set current_tab
index = dialog.main_tab.currentIndex()
current_tab = dialog.main_tab.widget(index).objectName()
# Profilactic control of nones
if text_filter is None:
text_filter = ''
# Built querytext
form = f'"currentTab":"{current_tab}"'
extras = f'"selectorType":{selector_type}, "filterText":"{text_filter}"'
body = tools_gw.create_body(form=form, extras=extras)
json_result = tools_gw.execute_procedure('gw_fct_getselectors', body)
if not json_result or json_result['status'] == 'Failed':
return False
# Get styles
stylesheet = json_result['body']['form'][
'style'] if 'style' in json_result['body']['form'] else None
color_rows = False
if stylesheet:
# Color selectors zebra-styled
if 'rowsColor' in stylesheet and stylesheet[
'rowsColor'] is not None:
color_rows = tools_os.set_boolean(stylesheet['rowsColor'],
False)
for form_tab in json_result['body']['form']['formTabs']:
if filter and form_tab['tabName'] != str(current_tab):
continue
selection_mode = form_tab['selectionMode']
# Create one tab for each form_tab and add to QTabWidget
tab_widget = QWidget(main_tab)
tab_widget.setObjectName(form_tab['tabName'])
tab_widget.setProperty('selector_type', form_tab['selectorType'])
if filter:
main_tab.removeTab(index)
main_tab.insertTab(index, tab_widget, form_tab['tabLabel'])
else:
main_tab.addTab(tab_widget, form_tab['tabLabel'])
if 'typeaheadForced' in form_tab and form_tab[
'typeaheadForced'] is not None:
tab_widget.setProperty('typeahead_forced',
form_tab['typeaheadForced'])
# Create a new QGridLayout and put it into tab
gridlayout = QGridLayout()
gridlayout.setObjectName("lyt" + form_tab['tabName'])
tab_widget.setLayout(gridlayout)
field = {}
i = 0
if 'typeaheadFilter' in form_tab:
label = QLabel()
label.setObjectName('lbl_filter')
label.setText('Filter:')
if tools_qt.get_widget(
dialog,
'txt_filter_' + str(form_tab['tabName'])) is None:
widget = QLineEdit()
widget.setObjectName('txt_filter_' +
str(form_tab['tabName']))
widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
widget.textChanged.connect(
partial(self.get_selector,
dialog,
selector_type,
filter=True,
widget=widget,
current_tab=current_tab))
widget.setLayoutDirection(Qt.RightToLeft)
else:
widget = tools_qt.get_widget(
dialog, 'txt_filter_' + str(form_tab['tabName']))
field['layoutname'] = gridlayout.objectName()
field['layoutorder'] = i
i = i + 1
gridlayout.addWidget(label, int(field['layoutorder']), 0)
gridlayout.addWidget(widget, int(field['layoutorder']), 2)
widget.setFocus()
if 'manageAll' in form_tab:
if (form_tab['manageAll']).lower() == 'true':
if tools_qt.get_widget(
dialog, f"chk_all_{form_tab['tabName']}") is None:
widget = QCheckBox()
widget.setObjectName('chk_all_' +
str(form_tab['tabName']))
widget.stateChanged.connect(
partial(self._manage_all, dialog, widget))
widget.setLayoutDirection(Qt.LeftToRight)
else:
widget = tools_qt.get_widget(
dialog, f"chk_all_{form_tab['tabName']}")
widget.setText('Check all')
field['layoutname'] = gridlayout.objectName()
field['layoutorder'] = i
i = i + 1
gridlayout.addWidget(widget, int(field['layoutorder']), 0,
1, -1)
for order, field in enumerate(form_tab['fields']):
try:
# Create checkbox
widget = tools_gw.add_checkbox(field)
widget.setText(field['label'])
widget.stateChanged.connect(
partial(self._set_selection_mode, dialog, widget,
selection_mode))
widget.setLayoutDirection(Qt.LeftToRight)
# Set background color every other item (if enabled)
if color_rows and order % 2 == 0:
widget.setStyleSheet(f"background-color: #E9E7E3")
# Add widget to layout
field['layoutname'] = gridlayout.objectName()
field['layoutorder'] = order + i + 1
gridlayout.addWidget(widget, int(field['layoutorder']), 0,
1, -1)
except Exception:
msg = f"key 'comboIds' or/and comboNames not found WHERE columname='{field['columnname']}' AND " \
f"widgetname='{field['widgetname']}'"
tools_qgis.show_message(msg, 2)
vertical_spacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
gridlayout.addItem(vertical_spacer1)
# Set last tab used by user as current tab
tabname = json_result['body']['form']['currentTab']
tab = main_tab.findChild(QWidget, tabname)
if tab:
main_tab.setCurrentWidget(tab)
def createWidget(self):
if self.dialogType == DIALOG_STANDARD:
widget = QWidget()
layout = QHBoxLayout()
layout.setMargin(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
self.combo = QgsMapLayerComboBox()
layout.addWidget(self.combo)
btn = QToolButton()
btn.setText('...')
btn.setToolTip(self.tr("Select file"))
btn.clicked.connect(self.selectFile)
layout.addWidget(btn)
widget.setLayout(layout)
if self.param.optional:
self.combo.setAllowEmptyLayer(True)
if ProcessingConfig.getSetting(ProcessingConfig.SHOW_CRS_DEF):
self.combo.setShowCrs(True)
self.combo.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.combo.setExcludedProviders(['grass'])
try:
if iface.activeLayer().type() == QgsMapLayer.RasterLayer:
self.combo.setLayer(iface.activeLayer())
except:
pass
self.combo.currentIndexChanged.connect(
lambda: self.widgetValueHasChanged.emit(self))
self.combo.currentTextChanged.connect(
lambda: self.widgetValueHasChanged.emit(self))
return widget
elif self.dialogType == DIALOG_BATCH:
return BatchInputSelectionPanel(self.param, self.row, self.col,
self.dialog)
else:
self.combo = QComboBox()
layers = self.dialog.getAvailableValuesOfType(
ParameterRaster, OutputRaster)
self.combo.setEditable(True)
for layer in layers:
self.combo.addItem(self.dialog.resolveValueDescription(layer),
layer)
if self.param.optional:
self.combo.setEditText("")
widget = QWidget()
layout = QHBoxLayout()
layout.setMargin(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(2)
layout.addWidget(self.combo)
btn = QToolButton()
btn.setText('...')
btn.setToolTip(self.tr("Select file"))
btn.clicked.connect(self.selectFile)
layout.addWidget(btn)
widget.setLayout(layout)
return widget
def setupUi(self):
type_metadata = QgsApplication.processingRegistry().parameterType(
self.param.type() if self.param else self.paramType)
self.setWindowTitle(
self.tr('{} Parameter Definition').format(type_metadata.name()))
self.mainLayout = QVBoxLayout()
self.tab = QTabWidget()
self.mainLayout.addWidget(self.tab)
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout()
self.label = QLabel(self.tr('Parameter name'))
self.verticalLayout.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.verticalLayout.addWidget(self.nameTextBox)
if isinstance(self.param, QgsProcessingParameterDefinition):
self.nameTextBox.setText(self.param.description())
if isinstance(self.param, QgsProcessingDestinationParameter):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultWidget = QgsProcessingLayerOutputDestinationWidget(
self.param, defaultSelection=True)
self.verticalLayout.addWidget(self.defaultWidget)
self.verticalLayout.addSpacing(20)
self.requiredCheck = QCheckBox()
self.requiredCheck.setText(self.tr('Mandatory'))
self.requiredCheck.setChecked(True)
if self.param is not None:
self.requiredCheck.setChecked(
not self.param.flags()
& QgsProcessingParameterDefinition.FlagOptional)
self.verticalLayout.addWidget(self.requiredCheck)
self.advancedCheck = QCheckBox()
self.advancedCheck.setText(self.tr('Advanced'))
self.advancedCheck.setChecked(False)
if self.param is not None:
self.advancedCheck.setChecked(
self.param.flags()
& QgsProcessingParameterDefinition.FlagAdvanced)
self.verticalLayout.addWidget(self.advancedCheck)
# If child algorithm output is mandatory, disable checkbox
if isinstance(self.param, QgsProcessingDestinationParameter):
provider_name, child_name, output_name = self.param.name().split(
':')
child = self.alg.childAlgorithms()['{}:{}'.format(
provider_name, child_name)]
model_output = child.modelOutput(output_name)
param_def = child.algorithm().parameterDefinition(
model_output.childOutputName())
if not (param_def.flags()
& QgsProcessingParameterDefinition.FlagOptional):
self.requiredCheck.setEnabled(False)
self.requiredCheck.setChecked(True)
self.advancedCheck.setEnabled(False)
self.advancedCheck.setChecked(False)
self.verticalLayout.addStretch()
w = QWidget()
w.setLayout(self.verticalLayout)
self.tab.addTab(w, self.tr('Properties'))
self.commentLayout = QVBoxLayout()
self.commentEdit = QTextEdit()
self.commentEdit.setAcceptRichText(False)
self.commentLayout.addWidget(self.commentEdit, 1)
hl = QHBoxLayout()
hl.setContentsMargins(0, 0, 0, 0)
hl.addWidget(QLabel(self.tr('Color')))
self.comment_color_button = QgsColorButton()
self.comment_color_button.setAllowOpacity(True)
self.comment_color_button.setWindowTitle(self.tr('Comment Color'))
self.comment_color_button.setShowNull(True, self.tr('Default'))
hl.addWidget(self.comment_color_button)
self.commentLayout.addLayout(hl)
w2 = QWidget()
w2.setLayout(self.commentLayout)
self.tab.addTab(w2, self.tr('Comments'))
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
self.buttonBox.setObjectName('buttonBox')
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.mainLayout.addWidget(self.buttonBox)
self.setLayout(self.mainLayout)
