def toggle_select_features_widget(title, text, button_text, layer,
new_feature_ids, old_feature_ids):
"""
Create a widget for QgsMessageBar to switch between two sets.
:param title: The title
:type title: str
:param text: The text message
:type text: str
:param button_text: The text on the toggle button
:type button_text: str
:param layer: The QgsVectorLayer where the selection is applied
:type layer: QgsVectorLayer
:param new_feature_ids: The list to select if use_new is true
:type new_feature_ids: QgsFeatureIds
:param old_feature_ids: The list to select if use_new is false
:type old_feature_ids: QgsFeatureIds
:returns: the widget
"""
widget = QgsMessageBar.createMessage(title, text)
button = QToolButton(widget)
button.setCheckable(True)
button.setText(button_text)
button.toggled.connect(
lambda on,
layer=layer,
new_feature_ids=new_feature_ids,
old_feature_ids=old_feature_ids:
toggle_select_features(layer,
on,
new_feature_ids,
old_feature_ids))
widget.layout().addWidget(button)
return widget
class PasswordLineEdit(QLineEdit):
def __init__(self, parent=None):
QLineEdit.__init__(self, parent)
self.setPlaceholderText(self.tr("Password"))
self.setEchoMode(QLineEdit.Password)
self.btnIcon = QToolButton(self)
self.btnIcon.setIcon(QIcon(os.path.join(iconsPath, "lock.svg")))
self.btnIcon.setEnabled(False)
self.btnIcon.setStyleSheet(
"QToolButton { border: none; padding: 0px; }")
self.btnToggle = QToolButton(self)
self.btnToggle.setIcon(QIcon(os.path.join(iconsPath, "eye-slash.svg")))
self.btnToggle.setCheckable(True)
self.btnToggle.setToolTip(self.tr("Toggle password visibility"))
self.btnToggle.setCursor(Qt.ArrowCursor)
self.btnToggle.setStyleSheet(
"QToolButton { border: none; padding: 0px; }")
self.btnToggle.toggled.connect(self.togglePassword)
frameWidth = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
self.setStyleSheet(
"QLineEdit {{ padding-right: {}px; padding-left: {}px }} ".format(
self.btnToggle.sizeHint().width() + frameWidth + 1,
self.btnIcon.sizeHint().width() + frameWidth + 1))
msz = self.minimumSizeHint()
self.setMinimumSize(
max(msz.width(),
self.btnToggle.sizeHint().height() + frameWidth * 2 + 2),
max(msz.height(),
self.btnToggle.sizeHint().height() + frameWidth * 2 + 2))
def resizeEvent(self, event):
frameWidth = self.style().pixelMetric(QStyle.PM_DefaultFrameWidth)
sz = self.btnIcon.sizeHint()
self.btnIcon.move(frameWidth + 1,
(self.rect().bottom() + 1 - sz.height()) / 2)
sz = self.btnToggle.sizeHint()
self.btnToggle.move(self.rect().right() - frameWidth - sz.width(),
(self.rect().bottom() + 1 - sz.height()) / 2)
def togglePassword(self, toggled):
if toggled:
self.setEchoMode(QLineEdit.Normal)
self.btnToggle.setIcon(QIcon(os.path.join(iconsPath, "eye.svg")))
else:
self.setEchoMode(QLineEdit.Password)
self.btnToggle.setIcon(
QIcon(os.path.join(iconsPath, "eye-slash.svg")))
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 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 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()
widget_context.setProject(QgsProject.instance())
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
if isinstance(self.alg, QgsProcessingModelAlgorithm):
widget_context.setModel(self.alg)
# 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)
wrapper.setWidgetContext(widget_context)
wrapper.registerProcessingContextGenerator(
self.context_generator)
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:
widget = wrapper.createWrappedWidget(
self.processing_context)
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()))
class FeatureSelectorWidget(QWidget):
feature_identified = pyqtSignal(QgsFeature)
def __init__(self, parent):
QWidget.__init__(self, parent)
edit_layout = QHBoxLayout()
edit_layout.setContentsMargins(0, 0, 0, 0)
edit_layout.setSpacing(2)
self.setLayout(edit_layout)
self.line_edit = QLineEdit(self)
self.line_edit.setReadOnly(True)
edit_layout.addWidget(self.line_edit)
self.highlight_feature_button = QToolButton(self)
self.highlight_feature_button.setPopupMode(QToolButton.MenuButtonPopup)
self.highlight_feature_action = QAction(
QgsApplication.getThemeIcon("/mActionHighlightFeature.svg"),
"Highlight feature", self)
self.scale_highlight_feature_action = QAction(
QgsApplication.getThemeIcon("/mActionScaleHighlightFeature.svg"),
"Scale and highlight feature", self)
self.pan_highlight_feature_action = QAction(
QgsApplication.getThemeIcon("/mActionPanHighlightFeature.svg"),
"Pan and highlight feature", self)
self.highlight_feature_button.addAction(self.highlight_feature_action)
self.highlight_feature_button.addAction(
self.scale_highlight_feature_action)
self.highlight_feature_button.addAction(
self.pan_highlight_feature_action)
self.highlight_feature_button.setDefaultAction(
self.highlight_feature_action)
edit_layout.addWidget(self.highlight_feature_button)
self.map_identification_button = QToolButton(self)
self.map_identification_button.setIcon(
QgsApplication.getThemeIcon("/mActionMapIdentification.svg"))
self.map_identification_button.setText("Select on map")
self.map_identification_button.setCheckable(True)
edit_layout.addWidget(self.map_identification_button)
self.map_identification_button.clicked.connect(self.map_identification)
self.highlight_feature_button.triggered.connect(
self.highlight_action_triggered)
self.layer = None
self.map_tool = None
self.canvas = None
self.window_widget = None
self.highlight = None
self.feature = QgsFeature()
def set_canvas(self, map_canvas):
self.map_tool = QgsMapToolIdentifyFeature(map_canvas)
self.map_tool.setButton(self.map_identification_button)
self.canvas = map_canvas
def set_layer(self, layer):
self.layer = layer
def set_feature(self, feature, canvas_extent=CanvasExtent.Fixed):
self.line_edit.clear()
self.feature = feature
if self.feature is None or not self.feature.isValid(
) or self.layer is None:
return
expression = QgsExpression(self.layer.displayExpression())
context = QgsExpressionContext()
scope = QgsExpressionContextScope()
context.appendScope(scope)
scope.setFeature(feature)
feature_title = expression.evaluate(context)
if feature_title == "":
feature_title = feature.id()
self.line_edit.setText(str(feature_title))
self.highlight_feature(canvas_extent)
def clear(self):
self.feature = QgsFeature()
self.line_edit.clear()
@pyqtSlot()
def map_identification(self):
if self.layer is None or self.map_tool is None or self.canvas is None:
return
self.map_tool.setLayer(self.layer)
self.canvas.setMapTool(self.map_tool)
self.window_widget = QWidget.window(self)
self.canvas.window().raise_()
self.canvas.activateWindow()
self.canvas.setFocus()
self.map_tool.featureIdentified.connect(
self.map_tool_feature_identified)
self.map_tool.deactivated.connect(self.map_tool_deactivated)
def map_tool_feature_identified(self, feature):
feature = QgsFeature(feature)
self.feature_identified.emit(feature)
self.unset_map_tool()
self.set_feature(feature)
def map_tool_deactivated(self):
if self.window_widget is not None:
self.window_widget.raise_()
self.window_widget.activateWindow()
def highlight_feature(self, canvas_extent=CanvasExtent.Fixed):
if self.canvas is None or not self.feature.isValid():
return
geom = self.feature.geometry()
if geom is None:
return
if canvas_extent == CanvasExtent.Scale:
feature_bounding_box = geom.boundingBox()
feature_bounding_box = self.canvas.mapSettings(
).layerToMapCoordinates(self.layer, feature_bounding_box)
extent = self.canvas.extent()
if not extent.contains(feature_bounding_box):
extent.combineExtentWith(feature_bounding_box)
extent.scale(1.1)
self.canvas.setExtent(extent)
self.canvas.refresh()
elif canvas_extent == CanvasExtent.Pan:
centroid = geom.centroid()
center = centroid.asPoint()
center = self.canvas.mapSettings().layerToMapCoordinates(
self.layer, center)
self.canvas.zoomByFactor(1.0,
center) # refresh is done in this method
# highlight
self.delete_highlight()
self.highlight = QgsHighlight(self.canvas, geom, self.layer)
settings = QSettings()
color = QColor(
settings.value("/Map/highlight/color",
Qgis.DEFAULT_HIGHLIGHT_COLOR.name()))
alpha = int(
settings.value("/Map/highlight/colorAlpha",
Qgis.DEFAULT_HIGHLIGHT_COLOR.alpha()))
buffer = 2 * float(
settings.value("/Map/highlight/buffer",
Qgis.DEFAULT_HIGHLIGHT_BUFFER_MM))
min_width = 2 * float(
settings.value("/Map/highlight/min_width",
Qgis.DEFAULT_HIGHLIGHT_MIN_WIDTH_MM))
self.highlight.setColor(color) # sets also fill with default alpha
color.setAlpha(alpha)
self.highlight.setFillColor(color) # sets fill with alpha
self.highlight.setBuffer(buffer)
self.highlight.setMinWidth(min_width)
self.highlight.setWidth(4.0)
self.highlight.show()
self.timer = QTimer(self)
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.delete_highlight)
self.timer.start(3000)
def delete_highlight(self):
if self.highlight is not None:
self.highlight.hide()
del self.highlight
self.highlight = None
def unset_map_tool(self):
if self.canvas is not None and self.map_tool is not None:
# this will call mapTool.deactivated
self.canvas.unsetMapTool(self.map_tool)
def highlight_action_triggered(self, action):
self.highlight_feature_button.setDefaultAction(action)
if action == self.highlight_feature_action:
self.highlight_feature()
elif action == self.scale_highlight_feature_action:
self.highlight_feature(CanvasExtent.Scale)
elif action == self.pan_highlight_feature_action:
self.highlight_feature(CanvasExtent.Pan)
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 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:
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]')
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(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, 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 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.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.layoutAdvanced.addWidget(label)
else:
self.layoutMain.insertWidget(
self.layoutMain.count() - 2, label)
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(self.tr('Open output file after running algorithm'))
check.setChecked(True)
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 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 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]
class CoordinateCaptureDockWidget(QDockWidget):
closingPlugin = pyqtSignal()
def __init__(self, parent=None):
"""Constructor."""
super(CoordinateCaptureDockWidget, self).__init__(parent)
self.setWindowTitle(self.tr("Coordinate Capture"))
self.setGeometry(0, 0, 300, 228)
self.dockWidgetContents = QWidget(self)
self.setWidget(self.dockWidgetContents)
self.gridLayout = QGridLayout()
self.dockWidgetContents.setLayout(self.gridLayout)
self.dockWidgetContents.layout().setColumnMinimumWidth(0, 36)
self.userCrsToolButton = QToolButton(self.dockWidgetContents)
self.userCrsToolButton.setIcon(
QIcon(":/plugins/coordinate_capture/mIconProjectionEnabled.svg"))
self.userCrsToolButton.setToolTip(
self.tr("Click to select the CRS to use for coordinate display"))
self.userCrsLabel = QLabel(self.dockWidgetContents)
self.userCrsLabel.setPixmap(
QPixmap(":/plugins/coordinate_capture/transformed.svg"))
self.userCrsLabel.setGeometry(self.userCrsToolButton.geometry())
self.userCrsEdit = QLineEdit(self.dockWidgetContents)
self.userCrsEdit.setReadOnly(True)
self.userCrsEdit.setToolTip(
self.tr("Coordinate in your selected CRS (lat,lon or east,north)"))
self.copyUserCrsCoordinatesAction = self.userCrsEdit.addAction(
QIcon(":/plugins/coordinate_capture/mActionEditCopy.svg"),
QLineEdit.TrailingPosition)
self.copyUserCrsCoordinatesAction.triggered.connect(
self.copyUserCrsCoordinates)
self.canvasCrsEdit = QLineEdit(self.dockWidgetContents)
self.canvasCrsEdit.setReadOnly(True)
self.canvasCrsEdit.setToolTip(
self.
tr("Coordinate in map canvas coordinate reference system (lat,lon or east,north)"
))
self.copyCanvasCrsCoordinatesAction = self.canvasCrsEdit.addAction(
QIcon(":/plugins/coordinate_capture/mActionEditCopy.svg"),
QLineEdit.TrailingPosition)
self.copyCanvasCrsCoordinatesAction.triggered.connect(
self.copyCanvasCrsCoordinates)
self.trackMouseButton = QToolButton(self.dockWidgetContents)
self.trackMouseButton.setIcon(
QIcon(":/plugins/coordinate_capture/tracking.svg"))
self.trackMouseButton.setCheckable(True)
self.trackMouseButton.setToolTip(
self.tr(
"Click to enable mouse tracking. Click the canvas to stop"))
self.trackMouseButton.setChecked(False)
# Create the action for tool
self.captureButton = QPushButton(self.dockWidgetContents)
self.captureButton.setText(self.tr("Start Capture"))
self.captureButton.setToolTip(
self.tr("Click to enable coordinate capture"))
self.captureButton.setIcon(
QIcon(":/plugins/coordinate_capture/coordinate_capture.png"))
self.captureButton.setWhatsThis(
self.
tr("Click on the map to view coordinates and capture to clipboard."
))
# // Set the icons
# setCurrentTheme(QString());
self.dockWidgetContents.layout().addWidget(self.userCrsToolButton, 0,
0)
self.dockWidgetContents.layout().addWidget(self.userCrsEdit, 0, 1)
self.dockWidgetContents.layout().addWidget(self.userCrsLabel, 1, 0)
self.dockWidgetContents.layout().addWidget(self.canvasCrsEdit, 1, 1)
self.dockWidgetContents.layout().addWidget(self.trackMouseButton, 2, 0)
self.dockWidgetContents.layout().addWidget(self.captureButton, 2, 1)
def copyUserCrsCoordinates(self):
self.userCrsEdit.selectAll()
self.userCrsEdit.copy()
def copyCanvasCrsCoordinates(self):
self.canvasCrsEdit.selectAll()
self.canvasCrsEdit.copy()
def closeEvent(self, event):
self.closingPlugin.emit()
event.accept()
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.datatype)
else:
layers = dataobjects.getTables()
if len(layers) > 0:
output.base_layer = layers[0]
class searchBar():
def __init__(self, iface, TOMsSearchBar, proposalsManager):
TOMsMessageLog.logMessage("In searchBar", level=Qgis.Info)
# Save reference to the QGIS interface
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.TOMsSearchBar = TOMsSearchBar
self.proposalsManager = proposalsManager
self.tool = TOMsInstantPrintTool(self.iface, self.proposalsManager)
self.initSearchBar()
# https: // gis.stackexchange.com / questions / 244584 / adding - textbox - to - qgis - plugin - toolbar
def initSearchBar(self):
TOMsMessageLog.logMessage("In initSearchBox:", level=Qgis.Info)
self.initialPass = True
self.gazetteerStringList = []
# Create & add a textbox
self.searchTextbox = QLineEdit(self.iface.mainWindow())
# Set width
self.searchTextbox.setFixedWidth(250)
# Add textbox to toolbar
self.txtEntry = self.TOMsSearchBar.addWidget(self.searchTextbox)
#self.txtEntry.setToolTip(self.tr(u'Enter Street Name'))
self.searchTextbox.textChanged.connect(self.doLookupItem)
self.actionGoToItem = QAction(QIcon(":/plugins/TOMs/resources/magnifyingGlass.png"),
QCoreApplication.translate("MyPlugin", "Start TOMs"), self.iface.mainWindow())
self.TOMsSearchBar.addAction(self.actionGoToItem)
self.actionGoToItem.triggered.connect(self.doGoToItem)
self.actionGoToItem.setCheckable(True)
# Add in details of the Instant Print plugin
self.toolButton = QToolButton(self.iface.mainWindow())
self.toolButton.setIcon(QIcon(":/plugins/TOMs/InstantPrint/icons/icon.png"))
#self.toolButton.setToolTip(self.tr("Instant Print"))
self.toolButton.setCheckable(True)
self.printButtonAction = self.TOMsSearchBar.addWidget(self.toolButton)
"""self.actionInstantPrint = QAction(QIcon(":/plugins/TOMs/InstantPrint/icons/icon.png"),
QCoreApplication.translate("Print", "Print"), self.iface.mainWindow())"""
self.toolButton.toggled.connect(self.__enablePrintTool)
self.iface.mapCanvas().mapToolSet.connect(self.__onPrintToolSet)
def enableSearchBar(self):
TOMsMessageLog.logMessage("In enableSearchBar", level=Qgis.Info)
self.actionGoToItem.setEnabled(True)
self.toolButton.setEnabled(True)
self.searchTextbox.textChanged.connect(self.doLookupItem)
def disableSearchBar(self):
TOMsMessageLog.logMessage("In disableSearchBar", level=Qgis.Info)
self.initialPass = True
self.actionGoToItem.setEnabled(False)
self.toolButton.setEnabled(False)
self.searchTextbox.textChanged.disconnect(self.doLookupItem)
def doLookupItem(self):
TOMsMessageLog.logMessage("In doLookupItem:", level=Qgis.Info)
# TODO: Check whether or not a project has been opened
#https: // gis.stackexchange.com / questions / 246339 / drop - down - list - qgis - plugin - based - on - keyword - search / 246347
if self.initialPass:
self.setupCompleter()
self.initialPass = False
searchText = self.searchTextbox.text()
TOMsMessageLog.logMessage("In doLookupItem: searchText " + str(searchText), level=Qgis.Info)
#search_in = txt
#query = "SELECT myfield1, myfield2 FROM my_table WHERE '%s' LIKE '%' || search_field || '%';" % (search_in)
# access your db and run the query
# run the query with while query.next() and store values in a list
# feed list to resiver (combox.addItems(myList)
def setupCompleter(self):
# set up string list for completer
TOMsMessageLog.logMessage("In setupCompleter:", level=Qgis.Info)
lookupStringSet = set()
# https://gis.stackexchange.com/questions/155805/qstringlist-error-in-plugin-of-qgis-2-10
self.GazetteerLayer = QgsProject.instance().mapLayersByName("StreetGazetteerRecords")[0]
for row in self.GazetteerLayer.getFeatures():
streetName = row.attribute("Descriptor_")
locality = row.attribute("Locality")
nameString = streetName
if locality:
nameString = nameString + ", " + locality
if nameString:
TOMsMessageLog.logMessage("In setupCompleter: nameString: " + nameString, level=Qgis.Info)
lookupStringSet.add(nameString)
# self.gazetteerStringList.append((nameString))
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
self.searchTextbox.setCompleter(completer)
model = QStringListModel()
completer.setModel(model)
model.setStringList(self.gazetteerStringList)
model.setStringList(sorted(lookupStringSet))
def doGoToItem(self):
TOMsMessageLog.logMessage("In doGoToItem:", level=Qgis.Info)
searchText = self.searchTextbox.text()
TOMsMessageLog.logMessage("In doGoToItem: searchText " + str(searchText), level=Qgis.Info)
# Split out the components of the text
streetName, localityName = searchText.split(',')
#amendedStreetName = streetName.replace("'", "\'\'")
#amendedLocalityName = localityName.replace("'", "\'\'")
TOMsMessageLog.logMessage("In doGoToItem: streetName: " + str(streetName.replace("'", "\'\'")) + " locality: + " + str(localityName.replace("'", "\'\'")), level=Qgis.Info)
# Now search for the street
queryString = "\"Descriptor_\" = \'" + streetName.replace("'", "\'\'") + "\'"
if localityName:
queryString = queryString + " AND \"Locality\" = \'" + localityName.replace("'", "\'\'").lstrip() + "\'"
TOMsMessageLog.logMessage("In doGoToItem: queryString: " + str(queryString), level=Qgis.Info)
it = self.GazetteerLayer.selectByExpression(queryString, QgsVectorLayer.SetSelection)
self.canvas.zoomToSelected(self.GazetteerLayer)
"""box = layer.boundingBoxOfSelected()
iface.mapCanvas().setExtent(box)
iface.mapCanvas().refresh()"""
def unload(self):
self.tool.setEnabled(False)
self.tool = None
self.iface.TOMsSearchBar().removeAction(self.printButtonAction)
self.iface.TOMsSearchBar().removeAction(self.actionGoToItem)
def __enablePrintTool(self, active):
self.tool.setEnabled(active)
def __onPrintToolSet(self, tool):
if tool != self.tool:
self.toolButton.setChecked(False)
def initWidgets(self): # Heavy overload
# 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
print('initWidgets - param.name(): {}'.format(param.name()))
if param.isDestination(): # and param.name() != 'OUTPUT_ASC':
continue
else:
wrapper = WidgetWrapperFactory.create_wrapper(param, self.parent)
self.wrappers[param.name()] = wrapper
#widget = wrapper.widget
# 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:
from qgis.gui import (QgsProcessingContextGenerator, QgsProcessingParameterWidgetContext)
widget_context = QgsProcessingParameterWidgetContext()
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
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())
#print('initWidgets 2 - param.name(): {}'.format(param.name()))
widget = DestinationSelectionPanel(output, self.alg) # TODO, overload
self.layoutMain.insertWidget(self.layoutMain.count() - 1, label)
self.layoutMain.insertWidget(self.layoutMain.count() - 1, widget)
if isinstance(output, (QgsProcessingParameterRasterDestination,
QgsProcessingParameterFeatureSink,
QgsProcessingParameterVectorDestination
# alk: checkboxes for Chloe handling
,ChloeCSVParameterFileDestination,
ChloeASCParameterFileDestination,
ChloeParameterFolderDestination)
):
check = QCheckBox()
check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file(s) 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
# initial state
if hasattr(output,'addToMapDefaultState'):
check.setChecked(output.addToMapDefaultState)
widget.setToolTip(param.toolTip())
self.outputWidgets[output.name()] = widget
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
# # alk: checkboxes for Chloe handling
# for output in self.alg.destinationParameterDefinitions():
# if output.flags() & QgsProcessingParameterDefinition.FlagHidden:
# continue
# if isinstance(output, (ChloeCSVParameterFileDestination)) or isinstance(output, (ChloeASCParameterFileDestination)):
# check = QCheckBox()
# check.setText(QCoreApplication.translate('ParametersPanel', 'Open output file(s) 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))
# print(str(self.layoutMain)+1)
# self.layoutMain.insertWidget(self.layoutMain.count() - 1, check)
# self.checkBoxes[output.name()] = check
# # connecting alg outputLoading info with checkbox state
# self.alg.outputLoading[output.name()] = check.isChecked()
# def updateOutputLoadingState(alg, outputName, checkbox, state):
# self.alg.outputLoading[outputName] = checkbox.isChecked()
# print( outputName + " " + str(checkbox.isChecked()) + " " + str(self.alg.outputLoading) + " " + str(self.alg))
# #print(str(self.alg.parameters))
# check.stateChanged.connect(partial(updateOutputLoadingState, self, output.name(), check))
# alk: addition of wrapper special config handling
# for dependancy between wrapper, i.e. changing the value
# of a FileSelectionPanel entails the update of another widget
for k in self.wrappers:
w = self.wrappers[k]
if hasattr(w,'getParentWidgetConfig'):
print(str(w) + " " + "getParentWidgetConfig")
config = w.getParentWidgetConfig()
if config != None:
p = self.wrappers[config['paramName']]
m = getattr(w, config['refreshMethod'])
if m!=None:
print(str(p) + " " + str(p.widget))
# todo generalize valueChanged handling
# to any type of widget componant
if isinstance(p.widget, FileSelectionPanel):
p.widget.leText.textChanged.connect(m)
elif isinstance(p, RasterWidgetWrapper):
try:
p.combo.valueChanged.connect(m) # QGIS 3.8 version
except:
p.combo.currentIndexChanged.connect(m) # QGIS LTR 3.4
