class Checkbox(InputType):
'''
checkbox input
'''
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.input = QCheckBox()
self.input.stateChanged.connect(
lambda state: self.changed.emit(self.input.isChecked()))
self.registerFocusEvent(self.input)
def set_value(self, checked: bool):
'''
set the check-state of the checkbox
Parameters
----------
checked : bool
check-state
'''
self.input.setChecked(checked or False)
def get_value(self) -> bool:
'''
get current check-state of the checkbox
Returns
-------
bool
current check-state
'''
return self.input.isChecked()
def onConfigureSelectAction(self):
dlg = QDialog()
dlg.setWindowTitle(self.tr('Selection Options'))
dlg.setLayout(QGridLayout())
ww_current_checkbox = QCheckBox(self.tr('Wastewater current'))
status, _ = QgsProject.instance().readBoolEntry('Qgep', 'FollowWastewaterCurrent', True)
ww_current_checkbox.setChecked(status)
ww_planned_checkbox = QCheckBox(self.tr('Wastewater planned'))
status, _ = QgsProject.instance().readBoolEntry('Qgep', 'FollowWastewaterPlanned', True)
ww_planned_checkbox.setChecked(status)
rw_current_checkbox = QCheckBox(self.tr('Rainwater current'))
status, _ = QgsProject.instance().readBoolEntry('Qgep', 'FollowRainwaterCurrent', True)
rw_current_checkbox.setChecked(status)
rw_planned_checkbox = QCheckBox(self.tr('Rainwater planned'))
status, _ = QgsProject.instance().readBoolEntry('Qgep', 'FollowRainwaterPlanned', True)
rw_planned_checkbox.setChecked(status)
btn_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
btn_box.accepted.connect(dlg.accept)
btn_box.rejected.connect(dlg.reject)
dlg.layout().addWidget(ww_current_checkbox)
dlg.layout().addWidget(ww_planned_checkbox)
dlg.layout().addWidget(rw_current_checkbox)
dlg.layout().addWidget(rw_planned_checkbox)
dlg.layout().addWidget(btn_box)
if dlg.exec_():
QgsProject.instance().writeEntry('Qgep', 'FollowWastewaterCurrent', ww_current_checkbox.isChecked())
QgsProject.instance().writeEntry('Qgep', 'FollowWastewaterPlanned', ww_planned_checkbox.isChecked())
QgsProject.instance().writeEntry('Qgep', 'FollowRainwaterCurrent', rw_current_checkbox.isChecked())
QgsProject.instance().writeEntry('Qgep', 'FollowRainwaterPlanned', rw_planned_checkbox.isChecked())
class CreateBranchDialog(QDialog):
def __init__(self, parent=None):
super(CreateBranchDialog, self).__init__(parent)
self.ok = False
self.initGui()
def initGui(self):
self.setWindowTitle("Create branch")
layout = QVBoxLayout()
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Close)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setSpacing(2)
self.verticalLayout.setMargin(0)
horizontalLayout = QHBoxLayout()
horizontalLayout.setSpacing(30)
horizontalLayout.setMargin(0)
nameLabel = QLabel('Branch name')
self.nameBox = QLineEdit()
horizontalLayout.addWidget(nameLabel)
horizontalLayout.addWidget(self.nameBox)
horizontalLayout2 = QHBoxLayout()
horizontalLayout2.setSpacing(30)
horizontalLayout2.setMargin(20)
self.forceCheck = QCheckBox('Force')
horizontalLayout2.addWidget(self.forceCheck)
self.checkoutCheck = QCheckBox('Switch to branch after creating it')
horizontalLayout2.addWidget(self.checkoutCheck)
layout.addLayout(horizontalLayout)
layout.addLayout(horizontalLayout2)
layout.addWidget(buttonBox)
self.setLayout(layout)
buttonBox.accepted.connect(self.okPressed)
buttonBox.rejected.connect(self.cancelPressed)
self.resize(400, 150)
def getName(self):
return str(self.nameBox.text())
def isForce(self):
return self.force
def isCheckout(self):
return self.checkout
def okPressed(self):
self.force = self.forceCheck.isChecked()
self.checkout = self.checkoutCheck.isChecked()
self.ok = True
self.close()
def cancelPressed(self):
self.ok = False
self.close()
def test_should_set_config_checkedvalue_on_true():
checkbox = QCheckBox()
assert not checkbox.isChecked()
widget = CheckboxWidget(widget=checkbox)
widget.config = config
widget.setvalue('MyTrue')
assert checkbox.isChecked()
class TreeGroupItem(QTreeWidgetItem):
groupIcon = QIcon(
os.path.join(os.path.dirname(__file__), "icons", "group.gif"))
def __init__(self, name, layers, tree):
QTreeWidgetItem.__init__(self)
self.layers = layers
self.name = name
self.setText(0, name)
self.setIcon(0, self.groupIcon)
self.setCheckState(0, Qt.Checked)
self.visibleItem = QTreeWidgetItem(self)
self.visibleCheck = QCheckBox()
self.visibleCheck.setChecked(True)
self.visibleItem.setText(0, "Visibility")
self.addChild(self.visibleItem)
tree.setItemWidget(self.visibleItem, 1, self.visibleCheck)
self.interactiveItem = QTreeWidgetItem(self)
self.interactiveCheck = QCheckBox()
self.interactiveCheck.setChecked(True)
self.interactiveItem.setText(0, "Popups")
self.addChild(self.interactiveItem)
tree.setItemWidget(self.interactiveItem, 1, self.interactiveCheck)
@property
def visible(self):
return self.visibleCheck.isChecked()
@property
def interactive(self):
return self.interactiveCheck.isChecked()
def test_should_set_config_uncheckedvalue_on_false():
checkbox = QCheckBox()
checkbox.setChecked(True)
assert checkbox.isChecked()
widget = CheckboxWidget(widget=checkbox)
widget.config = config
widget.setvalue('MyFalse')
assert not checkbox.isChecked()
class LayerItemWidget(QWidget):
def __init__(self, layer, parent=None):
super(LayerItemWidget, self).__init__(parent)
self.layer = layer
self.layout = QHBoxLayout()
self.check = QCheckBox()
self.check.setText(layer.name())
self.labelMetadata = QLabel()
self.labelMetadata.setFixedWidth(50)
self.labelData = QLabel()
self.labelData.setFixedWidth(50)
self.layout.addWidget(self.check)
self.layout.addWidget(self.labelData)
self.layout.addWidget(self.labelMetadata)
self.setLayout(self.layout)
def name(self):
return self.layer.name()
def iconPath(self, server):
return os.path.join(os.path.dirname(os.path.dirname(__file__)),
"icons",
"%s.png" % server.__class__.__name__.lower()[:-6])
def setMetadataPublished(self, server):
self.labelMetadata.setPixmap(QPixmap(self.iconPath(server)))
def setDataPublished(self, server):
self.labelData.setPixmap(QPixmap(self.iconPath(server)))
def checked(self):
return self.check.isChecked()
def setCheckState(self, state):
self.check.setCheckState(state)
class QvSabiesQue(QvVisorHTML):
def __init__(self, parent=None):
if not QvMemoria().getVolHints():
return
directori = os.path.abspath('Hints/') + '/'
self.arxius = [
directori + x for x in next(os.walk('./Hints'))[2]
if x.endswith(('.htm', '.html'))
]
#afegir una ordenació aleatòria
self.ultimArxiu = directori + 'Ja esta.html'
self.arxius.remove(self.ultimArxiu)
random.shuffle(self.arxius)
super().__init__(self.arxius[0],
'Sabíeu que...',
logo=True,
parent=parent)
self.segBoto = QvPushButton('Següent', destacat=True)
self.segBoto.clicked.connect(self.seg)
self.layoutBoto.addWidget(self.segBoto)
self.cbVolMes = QCheckBox('No tornar a mostrar')
self.layoutBoto.insertWidget(0, self.cbVolMes)
self.show()
def seg(self):
self.arxius.pop(0)
if len(self.arxius) != 0:
self.carrega(self.arxius[0])
else:
self.carrega(self.ultimArxiu)
self.segBoto.setEnabled(False)
def close(self):
super().close()
QvMemoria().setVolHints(not self.cbVolMes.isChecked())
def on_import_config(self):
s = QSettings("Oslandia", "QGeoloGIS")
last_dir = s.value("config_last_dir", None)
if not last_dir:
last_dir = os.path.dirname(__file__)
dlg = QDialog(None)
file_dialog = QFileDialog(
None,
"Choose a configuration file to import",
last_dir,
"JSON files (*.json)",
options=QFileDialog.
DontUseNativeDialog # transform into an embeddable QWidget
)
# when file dialog is done, close the main dialog
file_dialog.finished.connect(dlg.done)
overwrite_checkbox = QCheckBox("Overwrite existing layers")
overwrite_checkbox.setChecked(True)
vbox = QVBoxLayout()
vbox.addWidget(file_dialog)
vbox.addWidget(overwrite_checkbox)
dlg.setLayout(vbox)
r = dlg.exec_()
print(r)
if r == QDialog.Accepted:
filename = file_dialog.selectedFiles()[0]
s.setValue("config_last_dir", os.path.dirname(filename))
self.__config = import_config(
filename, overwrite_existing=overwrite_checkbox.isChecked())
QgsProject.instance().writeEntry("QGeoloGIS", "config",
json.dumps(self.__config))
def test_should_return_uncheckedvalue_on_false():
checkbox = QCheckBox()
widget = CheckboxWidget(widget=checkbox)
widget.config = config
widget.setvalue('MyFalse')
assert checkbox.isChecked() == False
assert widget.value() == 'MyFalse'
class ConnectCredentialsWidget(QWidget):
rememberStateChanged = pyqtSignal(int)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.leLogin = IconLineEdit(self)
self.leLogin.setIcon(QIcon(os.path.join(iconsPath, "envelope.svg")))
self.leLogin.setPlaceholderText("Email")
self.lePassword = PasswordLineEdit(self)
self.chkRemember = QCheckBox(self)
self.chkRemember.setText("Remember me")
self.lblResetPassword = QLabel(self)
self.lblResetPassword.setAlignment(Qt.AlignCenter)
self.lblResetPassword.setOpenExternalLinks(True)
self.lblResetPassword.setTextInteractionFlags(Qt.LinksAccessibleByKeyboard | Qt.LinksAccessibleByMouse)
self.lblResetPassword.setText("<html><head/><body><p><a href='https://boundlessgeo.auth0.com/login?client=rmtncamSKiwRBuVYTvFYJGtTspVuplMh'><span style='text-decoration: underline; color:#0000ff;'>Don't remember your password?</span></a></p></body></html>")
self.lblRegister = QLabel(self)
self.lblRegister.setAlignment(Qt.AlignCenter)
self.lblRegister.setOpenExternalLinks(True)
self.lblRegister.setTextInteractionFlags(Qt.LinksAccessibleByKeyboard | Qt.LinksAccessibleByMouse)
self.lblRegister.setText("<html><head/><body><p><a href='https://connect.boundlessgeo.com'><span style='text-decoration: underline; color:#0000ff;'>Don't have an account?</span></a></p></body></html>")
self.layout = QVBoxLayout(self)
self.layout.addWidget(self.leLogin)
self.layout.addWidget(self.lePassword)
self.layout.addWidget(self.chkRemember)
self.layout.addWidget(self.lblResetPassword)
self.layout.addWidget(self.lblRegister)
self.setLayout(self.layout)
self.chkRemember.stateChanged.connect(self.rememberCheckChanged)
def login(self):
return self.leLogin.text()
def setLogin(self, login):
self.leLogin.setText(login)
def password(self):
return self.lePassword.text()
def setPassword(self, password):
self.lePassword.setText(password)
def remember(self):
return self.chkRemember.isChecked()
def setRemember(self, state):
self.chkRemember.setCheckState(state)
def rememberCheckChanged(self, state):
self.rememberStateChanged.emit(state)
class ImageReviewWidget(QFrame):
selectedChanged = pyqtSignal()
def __init__(self, image):
super().__init__()
self.image = image
self.checkBox = QCheckBox()
self.checkBox.setChecked(True)
self.checkBox.stateChanged.connect(self.checkStateChanged)
hlayout = QHBoxLayout()
hlayout.setMargin(0)
hlayout.addStretch()
hlayout.addWidget(self.checkBox)
vlayout = QVBoxLayout()
vlayout.setMargin(0)
vlayout.addLayout(hlayout)
self.label = QLabel()
pixmap = QPixmap(PLACEHOLDER_THUMB, "SVG")
thumb = pixmap.scaled(96, 96, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.label.setPixmap(thumb)
self.label.setFixedSize(96, 96)
url = f"{image['_links']['thumbnail']}?api_key={PlanetClient.getInstance().api_key()}"
download_thumbnail(url, self)
vlayout.addWidget(self.label)
self.setLayout(vlayout)
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
def checkStateChanged(self):
self.selectedChanged.emit()
self.label.setEnabled(self.checkBox.isChecked())
def selected(self):
return self.checkBox.isChecked()
def set_thumbnail(self, img):
self.thumbnail = QPixmap(img)
thumb = self.thumbnail.scaled(96, 96, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.label.setPixmap(thumb)
def connect_features(self, source, target):
"""
Connects the source feature with the target feature.
@param source: A QgsPointLocator.Match object. Its foreign key will be updated.
A dialog will be opened which asks the user for which foreign key(s) he wants to update.
@param target: A QgsPointLocator.Match object. This feature will be used as link target.
Its obj_id attribute will be used as primary key.
"""
dlg = QDialog(self.iface.mainWindow())
dlg.setWindowTitle(self.tr('Select properties to connect'))
dlg.setLayout(QFormLayout())
properties = list()
for prop in self.network_element_sources[source.layer()]['fields']:
if 'filter' in prop.keys():
if not prop['filter'](source, target):
continue
cbx = QCheckBox(prop['name'])
cbx.setObjectName(prop['id'])
if 'is_checked' in prop.keys():
cbx.setChecked(prop['is_checked'](source, target))
properties.append(cbx)
dlg.layout().addWidget(cbx)
btn_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
dlg.layout().addWidget(btn_box)
btn_box.accepted.connect(dlg.accept)
btn_box.rejected.connect(dlg.reject)
source_feature = self.get_feature_for_match(source)
target_feature = self.get_feature_for_match(target)
if dlg.exec_():
for cbx in properties:
if cbx.isChecked():
source_feature[cbx.objectName()] = target_feature['obj_id']
if not source.layer().isEditable():
self.iface.messageBar().pushMessage('QGEP', self.tr('Layer "{layername}" is not in edit mode').format(
layername=source.layer().name()), Qgis.Warning, 5)
elif source.layer().updateFeature(source_feature):
self.iface.messageBar().pushMessage('QGEP',
self.tr('Connected {} to {}').format(
source_feature['identifier'],
target_feature['identifier']),
Qgis.Info, 5)
else:
self.iface.messageBar().pushMessage('QGEP',
self.tr(
'Error connecting features'),
Qgis.Warning, 5)
self.reset()
def simple_dialog(parent, title, message, checkbox_text=None, yes_no=True):
"""
A simple dialog the enable you show an html message with checkbox.
:param parent: The parent of the dialog.
:type parent: QWidget
:param title: The title of the dialog
:type title: String
:param message: The message of the dialog. Use <br>
to add a new line as it is html.
:type message: String
:param checkbox_text: Add a checkbox text, if None,
the checkbox will not be shown.
:type checkbox_text: String
:param yes_no: A boolean to add the Yes No buttons.
If false, the Ok button is shown.
:type yes_no: Boolean
:return: Tuple containing the dialog exec_ result
and the checkbox result.
:rtype: Tuple
"""
simple_dialog = QDialog(parent,
Qt.WindowSystemMenuHint | Qt.WindowTitleHint)
simple_layout = QVBoxLayout(simple_dialog)
simple_label = QLabel()
simple_dialog.setWindowTitle(title)
simple_label.setTextFormat(Qt.RichText)
simple_label.setText(message)
simple_layout.addWidget(simple_label)
if checkbox_text:
confirm_checkbox = QCheckBox()
confirm_checkbox.setText(checkbox_text)
simple_layout.addWidget(confirm_checkbox)
simple_buttons = QDialogButtonBox()
if yes_no:
simple_buttons.setStandardButtons(QDialogButtonBox.Yes
| QDialogButtonBox.No)
simple_buttons.rejected.connect(simple_dialog.reject)
else:
simple_buttons.setStandardButtons(QDialogButtonBox.Ok)
simple_buttons.accepted.connect(simple_dialog.accept)
simple_layout.addWidget(simple_buttons)
simple_dialog.setModal(True)
result = simple_dialog.exec_()
if not checkbox_text is None:
return result, confirm_checkbox.isChecked()
else:
return result, False
class ImageItemWidget(QFrame):
checked_state_changed = pyqtSignal()
def __init__(self, image, sort_criteria):
QFrame.__init__(self)
self.image = image
self.properties = image['properties']
datetime = iso8601.parse_date(self.properties[sort_criteria])
self.time = datetime.strftime('%H:%M:%S')
self.date = datetime.strftime('%b %d, %Y')
text = f"""{self.date}<span style="color: rgb(100,100,100);"> {self.time} UTC</span><br>
<b>{DAILY_ITEM_TYPES_DICT[self.properties['item_type']]}</b><br>
"""
url = f"{image['_links']['thumbnail']}?api_key={PlanetClient.getInstance().api_key()}"
self.checkBox = QCheckBox("")
self.checkBox.setChecked(True)
self.checkBox.stateChanged.connect(self.checked_state_changed.emit)
self.nameLabel = QLabel(text)
self.iconLabel = QLabel()
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.checkBox)
pixmap = QPixmap(PLACEHOLDER_THUMB, 'SVG')
thumb = pixmap.scaled(48, 48, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.iconLabel.setPixmap(thumb)
self.iconLabel.setFixedSize(48, 48)
self.nam = QNetworkAccessManager()
self.nam.finished.connect(self.iconDownloaded)
self.nam.get(QNetworkRequest(QUrl(url)))
layout.addWidget(self.iconLabel)
layout.addWidget(self.nameLabel)
layout.addStretch()
self.setLayout(layout)
def iconDownloaded(self, reply):
img = QImage()
img.loadFromData(reply.readAll())
pixmap = QPixmap(img)
thumb = pixmap.scaled(48, 48, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.iconLabel.setPixmap(thumb)
def set_selected(self, checked):
self.checkBox.setChecked(checked)
def is_selected(self):
return self.checkBox.isChecked()
class QgsExampleRelationEditorConfigWidget(
QgsAbstractRelationEditorConfigWidget):
def __init__(self, relation, parent):
super().__init__(relation, parent)
self.setLayout(QGridLayout())
self.checkbox = QCheckBox('Is this checkbox checkboxin?')
self.layout().addWidget(self.checkbox)
def config(self):
return {"checkboxin": self.checkbox.isChecked()}
def setConfig(self, config):
self.checkbox.setChecked(config.get('checkboxin', False))
def on_success(r):
self.show_results()
if not self.settings.show_result_layer_info:
return
msg_box = QMessageBox(self.ui)
msg_box.setText(
'Die Ergebnislayer wurden dem QGIS-Layerbaum '
'in der Gruppe "Projektwirkung" hinzugefügt. Nur der'
' oberste Ergebnislayer ist aktiviert.\n\n'
'Um die anderen Ergebnisse anzuzeigen, '
'aktivieren Sie sie bitte manuell im Layerbaum.\n')
check = QCheckBox('nicht wieder anzeigen')
msg_box.setCheckBox(check)
msg_box.exec()
if check.isChecked():
self.settings.show_result_layer_info = False
class LayerItemWidget(QWidget):
def __init__(self, layer, parent=None):
super(LayerItemWidget, self).__init__(parent)
self.layer = layer
self.layout = QHBoxLayout()
self.check = QCheckBox()
self.check.setText(layer.name())
if layer.type() == layer.VectorLayer:
self.check.setIcon(
QgsApplication().getThemeIcon('/mIconLineLayer.svg'))
else:
self.check.setIcon(
QgsApplication().getThemeIcon('/mIconRaster.svg'))
self.labelMetadata = QLabel()
self.labelMetadata.setFixedWidth(50)
self.labelData = QLabel()
self.labelData.setFixedWidth(50)
self.layout.addWidget(self.check)
self.layout.addWidget(self.labelData)
self.layout.addWidget(self.labelMetadata)
self.setLayout(self.layout)
def name(self):
return self.layer.name()
@staticmethod
def setIcon(label, server):
pixmap = QPixmap(
files.getIconPath(server.__class__.__name__.lower()[:-6]))
label.setPixmap(pixmap)
def setMetadataPublished(self, server):
self.setIcon(self.labelMetadata, server)
def setDataPublished(self, server):
self.setIcon(self.labelData, server)
def checked(self):
return self.check.isChecked()
def setCheckState(self, state):
self.check.setCheckState(state)
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster layer'
PARAMETER_TABLE = 'Table'
PARAMETER_VECTOR = 'Vector layer'
PARAMETER_STRING = 'String'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Table field'
PARAMETER_TABLE_MULTIPLE_FIELD = 'Table multiple field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
# To add
PARAMETER_MULTIPLE = 'Multiple input'
PARAMETER_FIXED_TABLE = 'Fixed table'
paramTypes = [
PARAMETER_BOOLEAN,
PARAMETER_EXTENT,
PARAMETER_FILE,
PARAMETER_NUMBER,
PARAMETER_RASTER,
PARAMETER_STRING,
PARAMETER_TABLE,
PARAMETER_TABLE_FIELD,
PARAMETER_TABLE_MULTIPLE_FIELD,
PARAMETER_VECTOR,
PARAMETER_POINT
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
def setupUi(self):
self.setWindowTitle(self.tr('Parameter definition'))
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setSpacing(40)
self.verticalLayout.setMargin(20)
self.horizontalLayoutName = QHBoxLayout(self)
self.horizontalLayoutName.setSpacing(2)
self.horizontalLayoutName.setMargin(0)
self.label = QLabel(self.tr('Parameter name'))
self.horizontalLayoutName.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.horizontalLayoutName.addWidget(self.nameTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutName)
self.horizontalLayoutRequired = QHBoxLayout(self)
self.horizontalLayoutRequired.setSpacing(2)
self.horizontalLayoutRequired.setMargin(0)
self.horizontalLayoutParent = QHBoxLayout(self)
self.horizontalLayoutParent.setSpacing(2)
self.horizontalLayoutParent.setMargin(0)
self.horizontalLayoutDefault = QHBoxLayout(self)
self.horizontalLayoutDefault.setSpacing(2)
self.horizontalLayoutDefault.setMargin(0)
self.horizontalLayoutDatatype = QHBoxLayout(self)
self.horizontalLayoutDatatype.setSpacing(2)
self.horizontalLayoutDatatype.setMargin(0)
if isinstance(self.param, Parameter):
self.nameTextBox.setText(self.param.description)
if self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, ParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(True if self.param.value else False)
self.horizontalLayoutParent.addWidget(self.state)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType in (
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD,
ModelerParameterDefinitionDialog.PARAMETER_TABLE_MULTIPLE_FIELD)\
or isinstance(self.param, (ParameterTableField,
ParameterTableMultipleField)):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in self.alg.inputs.values():
if isinstance(param.param, (ParameterVector, ParameterTable)):
self.parentCombo.addItem(param.param.description, param.param.name)
if self.param is not None:
if self.param.parent == param.param.name:
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.horizontalLayoutParent.addWidget(self.parentCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
# add the datatype selector
self.horizontalLayoutDatatype.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.horizontalLayoutDatatype.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
datatype_index = self.param.datatype + 1
self.datatypeCombo.setCurrentIndex(datatype_index)
self.verticalLayout.addLayout(self.horizontalLayoutDatatype)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or \
isinstance(self.param, ParameterVector):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Shape type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Any'))
self.shapetypeCombo.addItem(self.tr('Point'))
self.shapetypeCombo.addItem(self.tr('Line'))
self.shapetypeCombo.addItem(self.tr('Polygon'))
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(self.param.shapetype[0] + 1)
self.horizontalLayoutParent.addWidget(self.shapetypeCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or \
isinstance(self.param, ParameterMultipleInput):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Vector (any)'))
self.datatypeCombo.addItem(self.tr('Vector (point)'))
self.datatypeCombo.addItem(self.tr('Vector (line)'))
self.datatypeCombo.addItem(self.tr('Vector (polygon)'))
self.datatypeCombo.addItem(self.tr('Raster'))
self.datatypeCombo.addItem(self.tr('Table'))
if self.param is not None:
self.datatypeCombo.setCurrentIndex(self.param.datatype + 1)
self.horizontalLayoutParent.addWidget(self.datatypeCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or \
isinstance(self.param, ParameterNumber):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Min/Max values')))
self.minTextBox = QLineEdit()
self.maxTextBox = QLineEdit()
if self.param is not None:
self.minTextBox.setText(unicode(self.param.min))
self.maxTextBox.setText(unicode(self.param.max))
self.horizontalLayoutParent.addWidget(self.minTextBox)
self.horizontalLayoutParent.addWidget(self.maxTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
self.horizontalLayoutDefault.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setText(self.tr('0'))
if self.param is not None:
default = self.param.default
if self.param.isInteger:
default = int(math.floor(default))
self.defaultTextBox.setText(unicode(default))
self.horizontalLayoutDefault.addWidget(self.defaultTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutDefault)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or \
isinstance(self.param, ParameterString):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.default)
self.horizontalLayoutParent.addWidget(self.defaultTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or \
isinstance(self.param, ParameterFile):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(
1 if self.param.isFolder else 0)
self.horizontalLayoutParent.addWidget(self.fileFolderCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or \
isinstance(self.param, ParameterPoint):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.default)
self.horizontalLayoutParent.addWidget(self.defaultTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
self.horizontalLayoutRequired.addWidget(QLabel(self.tr('Required')))
self.yesNoCombo = QComboBox()
self.yesNoCombo.addItem(self.tr('Yes'))
self.yesNoCombo.addItem(self.tr('No'))
self.horizontalLayoutRequired.addWidget(self.yesNoCombo)
if self.param is not None:
self.yesNoCombo.setCurrentIndex(
1 if self.param.optional else 0)
self.verticalLayout.addLayout(self.horizontalLayoutRequired)
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.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def okPressed(self):
description = unicode(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while name in self.alg.inputs:
name = safeName.lower() + str(i)
else:
name = self.param.name
if self.paramType \
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN \
or isinstance(self.param, ParameterBoolean):
self.param = ParameterBoolean(name, description,
self.state.isChecked())
elif self.paramType in (
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD,
ModelerParameterDefinitionDialog.PARAMETER_TABLE_MULTIPLE_FIELD)\
or isinstance(self.param, (ParameterTableField,
ParameterTableMultipleField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.itemData(self.parentCombo.currentIndex())
datatype = self.datatypeCombo.itemData(
self.datatypeCombo.currentIndex())
if (self.paramType ==
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or
isinstance(self.param, ParameterTableField)):
self.param = ParameterTableField(
name, description, parent, datatype)
else:
self.param = ParameterTableMultipleField(
name, description, parent, datatype)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_RASTER or \
isinstance(self.param, ParameterRaster):
self.param = ParameterRaster(
name, description,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE or \
isinstance(self.param, ParameterTable):
self.param = ParameterTable(
name, description,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or \
isinstance(self.param, ParameterVector):
self.param = ParameterVector(
name, description,
[self.shapetypeCombo.currentIndex() - 1],
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or \
isinstance(self.param, ParameterMultipleInput):
self.param = ParameterMultipleInput(
name, description,
self.datatypeCombo.currentIndex() - 1,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or \
isinstance(self.param, ParameterNumber):
try:
vmin = unicode(self.minTextBox.text()).strip()
if vmin == '':
vmin = None
else:
vmin = float(vmin)
vmax = unicode(self.maxTextBox.text()).strip()
if vmax == '':
vmax = None
else:
vmax = float(vmax)
self.param = ParameterNumber(name, description, vmin, vmax,
unicode(self.defaultTextBox.text()))
except:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or \
isinstance(self.param, ParameterString):
self.param = ParameterString(name, description,
unicode(self.defaultTextBox.text()))
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXTENT or \
isinstance(self.param, ParameterExtent):
self.param = ParameterExtent(name, description)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or \
isinstance(self.param, ParameterFile):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = ParameterFile(name, description, isFolder=isFolder)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or \
isinstance(self.param, ParameterPoint):
self.param = ParameterPoint(name, description,
unicode(self.defaultTextBox.text()))
self.param.optional = self.yesNoCombo.currentIndex() == 1
self.close()
def cancelPressed(self):
self.param = None
self.close()
class ModelerParameterDefinitionDialog(QDialog):
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(settings.value("/Processing/modelParametersDefinitionDialogGeometry", QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def setupUi(self):
self.setWindowTitle(self.tr('Parameter Definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
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_BOOLEAN or \
isinstance(self.param, QgsProcessingParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.defaultValue()))
self.verticalLayout.addWidget(self.state)
elif 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 == parameters.PARAMETER_NUMBER or self.paramType == parameters.PARAMETER_DISTANCE or
isinstance(self.param, (QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
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(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_STRING or
isinstance(self.param, QgsProcessingParameterString)):
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_FILE or
isinstance(self.param, QgsProcessingParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(
1 if self.param.behavior() == QgsProcessingParameterFile.Folder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
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.defaultValue())
self.widget.setHeaders(self.param.headers())
self.widget.setFixedRows(self.param.hasFixedNumberRows())
self.verticalLayout.addWidget(self.widget)
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.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.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == parameters.PARAMETER_BOOLEAN or
isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description, self.state.isChecked())
elif (self.paramType == parameters.PARAMETER_TABLE_FIELD or
isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(name, description, defaultValue=default,
parentLayerParameterName=parent, type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == parameters.PARAMETER_BAND or
isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None, parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER or
isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(
name, description)
elif (self.paramType == parameters.PARAMETER_RASTER or
isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(
name, description)
elif (self.paramType == parameters.PARAMETER_TABLE or
isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description,
[self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR or
isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description,
[self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE or
isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description,
self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_NUMBER or
isinstance(self.param, (QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
try:
self.param = QgsProcessingParameterNumber(name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION or
isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(name, description,
str(self.defaultEdit.expression()),
parent)
elif (self.paramType == parameters.PARAMETER_STRING or
isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_EXTENT or
isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == parameters.PARAMETER_FILE or
isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(name, description,
QgsProcessingParameterFile.Folder if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == parameters.PARAMETER_POINT or
isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_CRS or
isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(name, description, self.selector.crs().authid())
elif (self.paramType == parameters.PARAMETER_ENUM or
isinstance(self.param, QgsProcessingParameterEnum)):
self.param = QgsProcessingParameterEnum(name, description, self.widget.options(), self.widget.allowMultiple(), self.widget.defaultOptions())
elif (self.paramType == parameters.PARAMETER_MATRIX or
isinstance(self.param, QgsProcessingParameterMatrix)):
self.param = QgsProcessingParameterMatrix(name, description, hasFixedNumberRows=self.widget.fixedRows(), headers=self.widget.headers(), defaultValue=self.widget.value())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry().parameterType(typeId)
if not paramTypeDef:
msg = self.tr('The parameter `{}` is not registered, are you missing a required plugin?'.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(self.param.flags() | QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
QDialog.accept(self)
def reject(self):
self.param = None
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
QDialog.reject(self)
class PlanetOrderReviewWidget(QWidget):
selectedImagesChanged = pyqtSignal()
def __init__(self, item_type, bundle_type, images, add_clip,
add_harmonize):
super().__init__()
self.item_type = item_type
self.bundle_type = bundle_type
self.images = images
self.add_clip = add_clip
self.add_harmonize = add_harmonize
layout = QVBoxLayout()
layout.setMargin(0)
item_types_names = PlanetClient.getInstance().item_types_names()
labelName = IconLabel(
f"<b>{item_types_names[self.item_type]} - {bundle_type}</b>",
SATELLITE_ICON,
)
labelNumItems = IconLabel(f"{len(images)} items", NITEMS_ICON)
gridlayout = QGridLayout()
gridlayout.setMargin(0)
gridlayout.addWidget(labelNumItems, 0, 0)
self.btnDetails = QPushButton()
self.btnDetails.setFlat(True)
self.btnDetails.setIcon(EXPAND_MORE_ICON)
self.btnDetails.clicked.connect(self._btnDetailsClicked)
gridlayout.addWidget(self.btnDetails, 0, 2)
gridlayout.addWidget(labelName, 1, 0, 1, 3)
layout.addLayout(gridlayout)
self.widgetDetails = QWidget()
layout.addWidget(self.widgetDetails)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
layout.addWidget(line)
self.setLayout(layout)
self.widgetDetails.hide()
self.updateGeometry()
self.populate_details()
def populate_details(self):
self.imgWidgets = []
layout = QGridLayout()
layout.setMargin(0)
layout.setVerticalSpacing(15)
layout.setColumnStretch(0, 1)
layout.setColumnStretch(2, 1)
self.chkClip = None
self.chkHarmonize = None
if self.add_clip:
layout.addWidget(QLabel("<b>Clipping</b>"), 0, 1, Qt.AlignCenter)
layout.addWidget(
QLabel("Only get items delivered within your AOI"), 1, 1,
Qt.AlignCenter)
self.chkClip = QCheckBox("Clip items to AOI")
enabled = QSettings().value(
f"{SETTINGS_NAMESPACE}/{ENABLE_CLIP_SETTING}", False)
self.chkClip.setChecked(str(enabled).lower() == str(True).lower())
self.chkClip.stateChanged.connect(self.checkStateChanged)
layout.addWidget(self.chkClip, 2, 1, Qt.AlignCenter)
if self.add_harmonize:
layout.addWidget(QLabel("<b>Harmonization</b>"), 3, 1,
Qt.AlignCenter)
layout.addWidget(
QLabel(
"Radiometrically harmonize imagery captured by one satellite "
"instrument type to imagery capture by another"),
4,
1,
Qt.AlignCenter,
)
self.chkHarmonize = QCheckBox("Harmonize")
enabled = QSettings().value(
f"{SETTINGS_NAMESPACE}/{ENABLE_HARMONIZATION_SETTING}", False)
self.chkHarmonize.setChecked(
str(enabled).lower() == str(True).lower())
self.chkHarmonize.stateChanged.connect(self.checkStateChanged)
layout.addWidget(self.chkHarmonize, 5, 1, Qt.AlignCenter)
layout.addWidget(QLabel("<b>Review Items</b>"), 6, 1, Qt.AlignCenter)
layout.addWidget(
QLabel(
"We recommend deselecting items that appear to have no pixels"
),
7,
1,
Qt.AlignCenter,
)
sublayout = QGridLayout()
sublayout.setMargin(0)
for i, img in enumerate(self.images):
w = ImageReviewWidget(img)
w.selectedChanged.connect(self.selectedImagesChanged.emit)
row = i // 4
col = i % 4 + 1
sublayout.addWidget(w, row, col)
self.imgWidgets.append(w)
layout.addLayout(sublayout, 8, 1, Qt.AlignCenter)
self.widgetDetails.setLayout(layout)
def checkStateChanged(self):
self.selectedImagesChanged.emit()
def selected_images(self):
return [w.image for w in self.imgWidgets if w.selected()]
def clipping(self):
if self.chkClip is None:
return False
else:
return self.chkClip.isChecked()
def harmonize(self):
if self.chkHarmonize is None:
return False
else:
return self.chkHarmonize.isChecked()
def _btnDetailsClicked(self):
if self.widgetDetails.isVisible():
self.widgetDetails.hide()
self.btnDetails.setIcon(EXPAND_MORE_ICON)
else:
self.widgetDetails.show()
self.btnDetails.setIcon(EXPAND_LESS_ICON)
self.updateGeometry()
def expand(self):
self.widgetDetails.show()
self.btnDetails.setIcon(EXPAND_LESS_ICON)
self.updateGeometry()
class PlanetOrderBundleWidget(QFrame):
selectionChanged = pyqtSignal()
def __init__(self, bundleid, name, description, udm, can_harmonize,
rectified):
super().__init__()
self.bundleid = bundleid
self.name = name
self.description = description
self.udm = udm
self.can_harmonize = can_harmonize
self.rectified = rectified
layout = QVBoxLayout()
hlayout = QHBoxLayout()
hlayout.setMargin(0)
self.labelName = QLabel(f"<b>{name}</b>")
hlayout.addWidget(self.labelName)
hlayout.addStretch()
self.chkSelected = QCheckBox()
self.chkSelected.stateChanged.connect(self.checkStateChanged)
hlayout.addWidget(self.chkSelected)
layout.addLayout(hlayout)
self.labelDescription = QLabel(description)
self.labelDescription.setWordWrap(True)
layout.addWidget(self.labelDescription)
hlayouttype = QHBoxLayout()
hlayouttype.setMargin(0)
self.radioTiff = QRadioButton("GeoTIFF")
self.radioTiff.setChecked(True)
self.radioTiff.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioTiff)
self.radioNitf = QRadioButton("NITF")
self.radioNitf.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioNitf)
hlayouttype.addStretch()
layout.addLayout(hlayouttype)
if udm:
hlayoutudm = QHBoxLayout()
hlayoutudm.setMargin(0)
self.labelUdm = IconLabel("UDM2", UDM_ICON)
hlayoutudm.addWidget(self.labelUdm)
hlayoutudm.addStretch()
layout.addLayout(hlayoutudm)
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLayout(layout)
self.checkStateChanged()
def checkStateChanged(self):
self.radioTiff.setEnabled(self.chkSelected.isChecked())
self.radioNitf.setEnabled(self.chkSelected.isChecked())
self.labelName.setEnabled(self.chkSelected.isChecked())
self.labelDescription.setEnabled(self.chkSelected.isChecked())
if self.udm:
self.labelUdm.setEnabled(self.chkSelected.isChecked())
self.selectionChanged.emit()
def selected(self):
return self.chkSelected.isChecked()
def setSelected(self, selected, emit=False):
if not emit:
self.blockSignals(True)
self.chkSelected.setChecked(selected)
self.blockSignals(False)
def filetype(self):
if self.radioTiff.isChecked():
return "GeoTIFF"
else:
return "NITF"
class DialogOutputOptions(QDialog):
def __init__(self, interface, toolWindow, options):
QDialog.__init__(self, interface.mainWindow())
self.iface = interface
self.tool = toolWindow
self.options = options
self.setWindowTitle("Output Optionen")
main_widget = QWidget(self)
# Build up gui
hbox = QHBoxLayout()
saveLabel = QLabel("Speicherpfad")
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(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)
hbox.addWidget(saveLabel)
hbox.addWidget(self.pathField)
hbox.addWidget(openButton)
# Create checkboxes
questionLabel = \
QLabel(u"Welche Produkte sollen erzeugt werden?")
self.checkBoxReport = QCheckBox(u"Technischer Bericht")
self.checkBoxPlot = QCheckBox(u"Diagramm")
self.checkBoxGeodata = \
QCheckBox(u"Shape-Daten der Stützen und Seillinie")
self.checkBoxCoords = \
QCheckBox(u"Koordinaten-Tabellen der Stützen und Seillinie")
# Set tick correctly
self.checkBoxReport.setChecked(self.options['report'])
self.checkBoxPlot.setChecked(self.options['plot'])
self.checkBoxGeodata.setChecked(self.options['geodata'])
self.checkBoxCoords.setChecked(self.options['coords'])
# Create Ok/Cancel Button and connect signal
buttonBox = QDialogButtonBox(main_widget)
buttonBox.setStandardButtons(QDialogButtonBox.Ok|
QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.Apply)
buttonBox.rejected.connect(self.Reject)
# Layout
container = QVBoxLayout(main_widget)
container.addLayout(hbox)
container.addWidget(QLabel(""))
container.addWidget(questionLabel)
container.addWidget(self.checkBoxReport)
container.addWidget(self.checkBoxPlot)
container.addWidget(self.checkBoxGeodata)
container.addWidget(self.checkBoxCoords)
container.addWidget(buttonBox)
container.setAlignment(Qt.AlignLeft)
self.setLayout(container)
def fillInDropDown(self, pathList):
for i in reversed(range(self.pathField.count())):
self.pathField.removeItem(i)
for path in reversed(pathList):
self.pathField.addItem(path)
def onOpenDialog(self):
title = u"Output Pfad auswählen"
directory = QFileDialog.getExistingDirectory(self, title,
self.options['outputPath'])
self.tool.updateCommonPathList(directory)
self.fillInDropDown(self.tool.commonPaths)
def Apply(self):
# Save checkbox status
self.options['outputPath'] = self.pathField.currentText()
self.options['report'] = int(self.checkBoxReport.isChecked())
self.options['plot'] = int(self.checkBoxPlot.isChecked())
self.options['geodata'] = int(self.checkBoxGeodata.isChecked())
self.options['coords'] = int(self.checkBoxCoords.isChecked())
# Update output location with currently selected path
self.tool.updateCommonPathList(self.pathField.currentText())
self.close()
def Reject(self):
self.close()
class OutputAnalyserDialog(QDialog):
def __init__(self, iface, parent, params):
QDialog.__init__(self, parent)
self.iface = iface
self.parent = parent
self.params = params
self.output_reader = None
self.tool = None
self.element_ids_nodes = None
self.element_ids_links = None
self.nodes_lay = None
self.links_lay = None
self.setWindowTitle(Parameters.plug_in_name)
# Selection changed listeners
self.params.junctions_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.reservoirs_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.tanks_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.pipes_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.pumps_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.valves_vlay.selectionChanged.connect(self.feature_sel_changed)
# self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
fra_main_lay = QVBoxLayout(self)
self.fra_out_file = QFrame(self)
fra_out_file_lay = QHBoxLayout(self.fra_out_file)
self.lbl_out_file = QLabel('Simulation output file:')
self.txt_out_file = QLineEdit('')
self.txt_out_file.setReadOnly(True)
self.btn_out_file = QToolButton()
self.btn_out_file.setText('...')
self.btn_out_file.clicked.connect(self.btn_out_file_clicked)
fra_out_file_lay.addWidget(self.lbl_out_file)
fra_out_file_lay.addWidget(self.txt_out_file)
fra_out_file_lay.addWidget(self.btn_out_file)
self.tab_widget = QTabWidget(self)
# Graphs tab ---------------------------------------------------------------------------------------------------
self.tab_graphs = QWidget()
tab_graphs_lay = QHBoxLayout(self.tab_graphs)
# Left frame
self.fra_graphs_left = QFrame()
self.fra_graphs_left.setMaximumWidth(100)
fra_graphs_left_lay = QVBoxLayout(self.fra_graphs_left)
self.btn_sel_element = QPushButton('Pick')
self.btn_sel_element.clicked.connect(self.btn_sel_element_clicked)
fra_graphs_left_lay.addWidget(self.btn_sel_element)
# Nodes
self.grb_nodes = QGroupBox(u'Nodes')
lay_grb_nodes = QVBoxLayout(self.grb_nodes)
self.chk_node_demand = QCheckBox('Demand')
lay_grb_nodes.addWidget(self.chk_node_demand)
self.chk_node_head = QCheckBox('Head')
lay_grb_nodes.addWidget(self.chk_node_head)
self.chk_node_pressure = QCheckBox('Pressure')
lay_grb_nodes.addWidget(self.chk_node_pressure)
self.chk_node_quality = QCheckBox('Quality')
lay_grb_nodes.addWidget(self.chk_node_quality)
fra_graphs_left_lay.addWidget(self.grb_nodes)
# Links
self.grb_links = QGroupBox(u'Links')
lay_grb_links = QVBoxLayout(self.grb_links)
self.chk_link_flow = QCheckBox('Flow')
lay_grb_links.addWidget(self.chk_link_flow)
self.chk_link_velocity = QCheckBox('Velocity')
lay_grb_links.addWidget(self.chk_link_velocity)
self.chk_link_headloss = QCheckBox('Headloss')
lay_grb_links.addWidget(self.chk_link_headloss)
self.chk_link_quality = QCheckBox('Quality')
lay_grb_links.addWidget(self.chk_link_quality)
fra_graphs_left_lay.addWidget(self.grb_links)
self.btn_draw_graph = QPushButton('Draw')
self.btn_draw_graph.clicked.connect(self.draw_graphs)
fra_graphs_left_lay.addWidget(self.btn_draw_graph)
self.spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
fra_graphs_left_lay.addItem(self.spacer)
tab_graphs_lay.addWidget(self.fra_graphs_left)
# Right frame
self.fra_graphs_right = QFrame()
fra_graphs_right_lay = QVBoxLayout(self.fra_graphs_right)
fra_graphs_right_lay.setContentsMargins(0, 0, 0, 0)
self.static_canvas = StaticMplCanvas(self.fra_graphs_right, width=5, height=4, dpi=100)
fra_graphs_right_lay.addWidget(self.static_canvas)
tab_graphs_lay.addWidget(self.fra_graphs_right)
# lay.addWidget(self.button)
self.tab_widget.addTab(self.tab_graphs, 'Graphs')
# Maps tab -----------------------------------------------------------------------------------------------------
self.tab_maps = QWidget()
tab_maps_lay = QHBoxLayout(self.tab_maps)
# Left frame
self.fra_maps_left = QFrame()
self.fra_maps_left.setMaximumWidth(200)
fra_maps_left_lay = QVBoxLayout(self.fra_maps_left)
self.grb_maps = QGroupBox(u'Variable')
grb_maps_lay = QVBoxLayout(self.grb_maps)
self.rad_maps_node_demand = QRadioButton(u'Node demand')
grb_maps_lay.addWidget(self.rad_maps_node_demand)
self.rad_maps_node_head = QRadioButton(u'Node head')
grb_maps_lay.addWidget(self.rad_maps_node_head)
self.rad_maps_node_pressure = QRadioButton(u'Node pressure')
grb_maps_lay.addWidget(self.rad_maps_node_pressure)
self.rad_maps_node_quality = QRadioButton(u'Node quality')
grb_maps_lay.addWidget(self.rad_maps_node_quality)
self.rad_maps_link_flow = QRadioButton(u'Link flow')
grb_maps_lay.addWidget(self.rad_maps_link_flow)
self.rad_maps_link_velocity = QRadioButton(u'Link velocity')
grb_maps_lay.addWidget(self.rad_maps_link_velocity)
self.rad_maps_link_headloss = QRadioButton(u'Link headloss')
grb_maps_lay.addWidget(self.rad_maps_link_headloss)
self.rad_maps_link_quality = QRadioButton(u'Link quality')
grb_maps_lay.addWidget(self.rad_maps_link_quality)
fra_maps_left_lay.addWidget(self.grb_maps)
fra_maps_left_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_left)
# Right maps frame
self.fra_maps_right = QFrame()
fra_maps_right_lay = QVBoxLayout(self.fra_maps_right)
self.fra_maps_right_time = QFrame()
fra_maps_right_time_lay = QFormLayout(self.fra_maps_right_time)
self.lbl_map_times = QLabel(u'Period [h]:')
self.cbo_map_times = QComboBox()
fra_maps_right_time_lay.addRow(self.lbl_map_times, self.cbo_map_times)
fra_maps_right_lay.addWidget(self.fra_maps_right_time)
self.btn_draw_map = QPushButton(u'Draw map')
self.btn_draw_map.clicked.connect(self.draw_maps)
fra_maps_right_lay.addWidget(self.btn_draw_map)
fra_maps_right_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_right)
self.tab_widget.addTab(self.tab_maps, 'Maps')
# # Add to main
fra_main_lay.addWidget(self.fra_out_file)
fra_main_lay.addWidget(self.tab_widget)
self.setup()
self.initialize()
# self.read_outputs()
# Set size
self.setMinimumWidth(self.tab_graphs.width())
self.setMinimumHeight(self.tab_graphs.height())
def setup(self):
pass
def btn_out_file_clicked(self):
config_file = ConfigFile(Parameters.config_file_path)
out_file, __ = QFileDialog.getOpenFileName(
self,
'Select out file',
config_file.get_last_out_file(),
'Out files (*.out)')
if out_file is None or out_file == '':
return
config_file.set_last_out_file(out_file)
self.txt_out_file.setText(out_file)
self.read_outputs()
if self.output_reader is None:
return
# Fill times combo
self.cbo_map_times.clear()
for period_s in self.output_reader.period_results.keys():
text = self.seconds_to_string(
period_s,
self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
self.cbo_map_times.addItem(text, period_s)
# Activate widgets
self.btn_sel_element.setEnabled(self.output_reader is not None)
self.btn_draw_graph.setEnabled(self.output_reader is not None)
self.grb_maps.setEnabled(self.output_reader is not None)
self.btn_draw_map.setEnabled(self.output_reader is not None)
def initialize(self):
# Graphs
self.grb_nodes.setEnabled(False)
self.grb_links.setEnabled(False)
self.btn_sel_element.setEnabled(self.output_reader is not None)
self.btn_draw_graph.setEnabled(self.output_reader is not None)
# Maps
self.grb_maps.setEnabled(self.output_reader is not None)
self.rad_maps_node_demand.setChecked(True)
self.btn_draw_map.setEnabled(self.output_reader is not None)
def feature_sel_changed(self):
is_nodes = False
sel_junctions = self.params.junctions_vlay.selectedFeatureCount()
sel_reservoirs = self.params.reservoirs_vlay.selectedFeatureCount()
sel_tanks = self.params.tanks_vlay.selectedFeatureCount()
if sel_junctions > 0 or sel_reservoirs > 0 or sel_tanks > 0:
is_nodes = True
self.grb_nodes.setEnabled(is_nodes)
is_links = False
sel_pipes = self.params.pipes_vlay.selectedFeatureCount()
sel_pumps = self.params.pumps_vlay.selectedFeatureCount()
sel_valves = self.params.valves_vlay.selectedFeatureCount()
if sel_pipes > 0 or sel_pumps > 0 or sel_valves > 0:
is_links = True
self.grb_links.setEnabled(is_links)
def read_outputs(self):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
self.output_reader = BinaryOutputReader()
self.output_reader.read(self.txt_out_file.text())
QApplication.restoreOverrideCursor()
# Check if output compatible with loaded project
compatible = True
out_nodes_nr = self.output_reader.nodes_nr
out_tanks_reservs_nr = self.output_reader.tanks_reservs_nr
out_juncts_nr = out_nodes_nr - out_tanks_reservs_nr
out_links_nr = self.output_reader.links_nr
out_pumps_nr = self.output_reader.pumps_nr
out_valves_nr = self.output_reader.valves_nr
out_pipes_nr = out_links_nr - out_pumps_nr - out_valves_nr
if out_juncts_nr != self.params.junctions_vlay.featureCount():
compatible = False
if out_tanks_reservs_nr != (self.params.reservoirs_vlay.featureCount() + self.params.tanks_vlay.featureCount()):
compatible = False
if out_pipes_nr != self.params.pipes_vlay.featureCount():
compatible = False
if out_valves_nr != self.params.valves_vlay.featureCount():
compatible = False
if out_pumps_nr != self.params.pumps_vlay.featureCount():
compatible = False
if not compatible:
message = 'The out file appears to incompatible with the actual project layers.'
QMessageBox.warning(
self,
Parameters.plug_in_name,
message,
QMessageBox.Ok)
self.output_reader = None
self.txt_out_file.setText('')
else:
# Message after reading completed
message = 'Out file loaded: ' + str(out_nodes_nr) + ' nodes, ' + str(out_links_nr) + ' links found.'
# Clear refs to output layer
self.params.out_lay_node_demand = None
self.params.out_lay_node_head = None
self.params.out_lay_node_pressure = None
self.params.out_lay_node_quality = None
self.params.out_lay_link_flow = None
self.params.out_lay_link_velocity = None
self.params.out_lay_link_headloss = None
self.params.out_lay_link_quality = None
QMessageBox.information(
self,
Parameters.plug_in_name,
message,
QMessageBox.Ok)
finally:
# self.iface.messageBar().pushWarning(
# Parameters.plug_in_name,
# 'Error while reading output file.') # TODO: softcode
# self.output_reader = None
# self.txt_out_file.setText('')
QApplication.restoreOverrideCursor()
def btn_sel_element_clicked(self):
if self.output_reader is None:
self.iface.messageBar().pushMessage(
Parameters.plug_in_name,
'Please select the simulation out file.',
Qgis.Warning,
5) # TODO: softcode
return
self.tool = SelectTool(self, self.params)
self.iface.mapCanvas().setMapTool(self.tool)
cursor = QCursor()
cursor.setShape(Qt.ArrowCursor)
self.iface.mapCanvas().setCursor(cursor)
def draw_graphs(self):
# Get selected features
self.element_ids_nodes = []
for junction_feat in self.params.junctions_vlay.selectedFeatures():
self.element_ids_nodes.append(junction_feat.attribute(Junction.field_name_eid))
for reservoir_feat in self.params.reservoirs_vlay.selectedFeatures():
self.element_ids_nodes.append(reservoir_feat.attribute(Reservoir.field_name_eid))
for tank_feat in self.params.tanks_vlay.selectedFeatures():
self.element_ids_nodes.append(tank_feat.attribute(Tank.field_name_eid))
self.element_ids_links = []
for pipe_feat in self.params.pipes_vlay.selectedFeatures():
self.element_ids_links.append(pipe_feat.attribute(Pipe.field_name_eid))
for pump_feat in self.params.pumps_vlay.selectedFeatures():
self.element_ids_links.append(pump_feat.attribute(Pump.field_name_eid))
for valve_feat in self.params.valves_vlay.selectedFeatures():
self.element_ids_links.append(valve_feat.attribute(Valve.field_name_eid))
# Build values dictionaries
xs = self.output_reader.report_times
ys_d_d = {}
params_count = 0
# Nodes
if self.grb_nodes.isEnabled():
if self.chk_node_demand.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_demands_d[element_id],
self.params.options.flow_units]
ys_d_d[OutputParamCodes.NODE_DEMAND] = ys_d
if self.chk_node_head.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_heads_d[element_id],
Options.units_diameter_tanks[self.params.options.units]]
ys_d_d[OutputParamCodes.NODE_HEAD] = ys_d
if self.chk_node_pressure.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_pressures_d[element_id],
Options.units_pressure[self.params.options.units]]
ys_d_d[OutputParamCodes.NODE_PRESSURE] = ys_d
if self.chk_node_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_nodes:
ys_d[element_id] = [
self.output_reader.node_qualities_d[element_id],
Quality.quality_units_text[self.params.options.quality.mass_units]]
ys_d_d[OutputParamCodes.NODE_QUALITY] = ys_d
# Links
if self.grb_links.isEnabled():
if self.chk_link_flow.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_flows_d[element_id],
self.params.options.flow_units]
ys_d_d[OutputParamCodes.LINK_FLOW] = ys_d
if self.chk_link_velocity.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_velocities_d[element_id],
Options.units_velocity[self.params.options.units]]
ys_d_d[OutputParamCodes.LINK_VELOCITY] = ys_d
if self.chk_link_headloss.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_headlosses_d[element_id],
Options.units_diameter_tanks[self.params.options.units]]
ys_d_d[OutputParamCodes.LINK_HEADLOSS] = ys_d
if self.chk_link_quality.isChecked():
params_count += 1
ys_d = {}
for element_id in self.element_ids_links:
ys_d[element_id] = [
self.output_reader.link_qualities_d[element_id],
Quality.quality_units_text[self.params.options.quality.mass_units]]
ys_d_d[OutputParamCodes.LINK_QUALITY] = ys_d
if ys_d_d:
self.static_canvas.draw_output_line(xs, ys_d_d, params_count)
def draw_maps(self):
"""
Draws layers with all the attributes
:return:
"""
report_time = self.cbo_map_times.itemText(self.cbo_map_times.currentIndex())
if self.rad_maps_node_demand.isChecked(): # -------------------------------------------------------------------
lay_name = u'Node demand'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_demand_id, lay_name,
self.output_reader.node_demands_d, report_time)
self.params.out_lay_node_demand_id = lay_id
elif self.rad_maps_node_head.isChecked():
lay_name = u'Node head'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_head_id, lay_name,
self.output_reader.node_heads_d, report_time)
self.params.out_lay_node_head_id = lay_id
elif self.rad_maps_node_pressure.isChecked():
lay_name = u'Node pressure'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_pressure_id, lay_name,
self.output_reader.node_pressures_d, report_time)
self.params.out_lay_node_pressure_id = lay_id
elif self.rad_maps_node_quality.isChecked():
lay_name = u'Node quality'
lay_id = self.draw_map(LayerType.NODE, self.params.out_lay_node_quality_id, lay_name,
self.output_reader.node_qualities_d, report_time)
self.params.out_lay_node_quality_id = lay_id
elif self.rad_maps_link_flow.isChecked(): # -------------------------------------------------------------------
lay_name = u'Link flow'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_flow_id, lay_name,
self.output_reader.link_flows_d, report_time)
self.params.out_lay_link_flow_id = lay_id
elif self.rad_maps_link_velocity.isChecked():
lay_name = u'Link velocity'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_velocity_id, lay_name,
self.output_reader.link_velocities_d, report_time)
self.params.out_lay_link_velocity_id = lay_id
elif self.rad_maps_link_headloss.isChecked():
lay_name = u'Link headloss'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_headloss_id, lay_name,
self.output_reader.link_headlosses_d, report_time)
self.params.out_lay_link_headloss_id = lay_id
elif self.rad_maps_link_quality.isChecked():
lay_name = u'Link quality'
lay_id = self.draw_map(LayerType.LINK, self.params.out_lay_link_quality_id, lay_name,
self.output_reader.link_qualities_d, report_time)
self.params.out_lay_link_quality_id = lay_id
def draw_map(self, lay_type, lay_id, lay_name, dataset, report_time):
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
lay_name += ' ' + report_time
lay = LayerUtils.get_lay_from_id(lay_id)
if lay is None:
if lay_type == LayerType.NODE:
lay = self.create_out_node_layer(lay_name, dataset)
ns = NodeSymbology()
lay.setRenderer(ns.make_graduated_sym_renderer(lay, report_time))
elif lay_type == LayerType.LINK:
lay = self.create_out_link_layer(lay_name, dataset)
ls = LinkSymbology()
lay.setRenderer(ls.make_flow_sym_renderer(lay, report_time))
lay_id = lay.id()
QgsProject.instance().addMapLayer(lay)
self.params.out_layers.append(lay)
else:
lay.setLayerName(lay_name)
lay.triggerRepaint()
QApplication.restoreOverrideCursor()
finally:
QApplication.restoreOverrideCursor()
return lay_id
def btn_cancel_clicked(self):
self.setVisible(False)
def btn_ok_clicked(self):
pass
def create_out_node_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.NODE)
def create_out_link_layer(self, lay_name, values_d):
return self.create_out_layer(lay_name, values_d, LayerType.LINK)
def create_out_layer(self, lay_name, values_d, lay_type):
field_name_vars = []
periods = list(self.output_reader.period_results.keys())
for period_s in periods:
text = self.seconds_to_string(
period_s,
self.output_reader.sim_duration_secs,
self.output_reader.report_time_step_secs)
field_name_vars.append(text)
if lay_type == LayerType.NODE:
new_lay = MemoryDS.create_nodes_lay(self.params, field_name_vars, lay_name, self.params.crs)
elif lay_type == LayerType.LINK:
new_lay = MemoryDS.create_links_lay(self.params, field_name_vars, lay_name, self.params.crs)
with edit(new_lay):
# Update attributes
for feat in new_lay.getFeatures():
fid = feat.id()
eid = feat.attribute(Node.field_name_eid)
values = values_d[eid]
for p in range(len(periods)):
new_lay.changeAttributeValue(fid, p+1, values[p])
return new_lay
def seconds_to_string(self, period_s, duration_s, interval_s):
day = int(math.floor(period_s / 86400))
hour = period_s / 3600 - day * 24
minute = period_s / 60 - day * 24 * 60 - hour * 60
second = period_s - day * 86400 - hour * 3600 - minute * 60
text = ''
if duration_s >= 86400:
# We need days
text += str(day) + 'd'
if duration_s >= 3600:
# We need hours
text += '{:02}'.format(hour) + 'H'
text += '{:02}'.format(minute) + 'm'
if second > 0:
text += '{:02}'.format(second) + 's'
return text
class ParamBox(QDialog):
"""
Param box of the plugin
"""
def __init__(self, parent=None, tree_dock=None):
QWidget.__init__(self, parent)
self.tree_dock = tree_dock
# Init GUI
self.init_gui()
# Evaluate flags and tupdate the state of the Apply button
self.evaluate_flags()
def init_gui(self):
"""
"""
dlg_layout = QVBoxLayout()
params_layout = QVBoxLayout()
params_layout.setAlignment(Qt.AlignTop)
# Config files groupbox
self.config_files_groupbox = QgsCollapsibleGroupBox(
u"Fichier de configuration de l'arbre des ressources")
config_file_groupbox_layout = QFormLayout(self.config_files_groupbox)
# URL of the file
self.config_file_url_label = QLabel(u"URL du fichier", self)
self.config_file_url_edit = QLineEdit(self)
self.config_file_url_edit.editingFinished.connect(
self.config_file_url_changed)
config_file_groupbox_layout.addRow(self.config_file_url_label,
self.config_file_url_edit)
# Download the file at startup
self.download_cb = QCheckBox(
u"Télécharger le fichier à chaque lancement de QGIS", self)
self.download_cb.stateChanged.connect(self.download_cb_changed)
config_file_groupbox_layout.addRow(self.download_cb)
params_layout.addWidget(self.config_files_groupbox)
# Download the file now
self.download_now_label = QLabel(u"Télécharger le fichier maintenant",
self)
self.download_now_btnbox = QDialogButtonBox()
self.download_now_btnbox.setOrientation(Qt.Horizontal)
self.download_now_btnbox.setStandardButtons(QDialogButtonBox.Yes)
self.download_now_btnbox.button(QDialogButtonBox.Yes).clicked.connect(
self.download_file_now)
config_file_groupbox_layout.addRow(self.download_now_label,
self.download_now_btnbox)
# Content of the resource tree groupbox
self.resource_tree_groupbox = QgsCollapsibleGroupBox(
u"Contenu de l'arbre des ressources")
resource_tree_groupbox_layout = QFormLayout(
self.resource_tree_groupbox)
# Hide resources with a warn flag
self.hide_resources_with_warn_status_cb = QCheckBox(
u"Masquer les ressources en cours d'intégration", self)
self.hide_resources_with_warn_status_cb.stateChanged.connect(
self.hide_resources_with_warn_cb_changed)
resource_tree_groupbox_layout.addRow(
self.hide_resources_with_warn_status_cb)
# Hide empty groups in the resources tree
self.hide_empty_groups_cb = QCheckBox(
u"Masquer les groupes de ressources vides", self)
self.hide_empty_groups_cb.stateChanged.connect(
self.hide_empty_groups_cb_changed)
resource_tree_groupbox_layout.addRow(self.hide_empty_groups_cb)
params_layout.addWidget(self.resource_tree_groupbox)
dlg_layout.addLayout(params_layout)
# Set values
self.set_values_from_qsettings()
# Bottom dialog buttons
self.button_box = QDialogButtonBox()
self.button_box.setOrientation(Qt.Horizontal)
self.button_box.setStandardButtons(QDialogButtonBox.RestoreDefaults
| QDialogButtonBox.Apply
| QDialogButtonBox.Close)
self.button_box.button(
QDialogButtonBox.RestoreDefaults).clicked.connect(
self.restore_defaults_button_clicked)
self.button_box.button(QDialogButtonBox.Close).clicked.connect(
self.close_button_clicked)
self.button_box.button(QDialogButtonBox.Apply).clicked.connect(
self.apply_button_clicked)
# Dialog box title, layout, size and display
title = u"Paramétrage de l'extension GéoSAS…"
self.setWindowTitle(title)
dlg_layout.addWidget(self.button_box)
self.setLayout(dlg_layout)
self.setMinimumWidth(500)
self.resize(self.sizeHint())
self.setSizeGripEnabled(False)
self.setFixedSize(self.size())
self.show()
self.setSizeGripEnabled(False)
def set_values_from_qsettings(self):
"""
"""
# URL of the file
self.config_file_url_edit.blockSignals(True)
self.config_file_url_edit.setText(
PluginGlobals.instance().CONFIG_FILE_URLS[0])
self.config_file_url_edit.setCursorPosition(0)
self.config_file_url_edit.blockSignals(False)
# Download the file at startup
self.download_cb.blockSignals(True)
self.download_cb.setChecked(
PluginGlobals.instance().CONFIG_FILES_DOWNLOAD_AT_STARTUP)
self.download_cb.blockSignals(True)
# Hide resources with a warn flag
self.hide_resources_with_warn_status_cb.blockSignals(True)
self.hide_resources_with_warn_status_cb.setChecked(
PluginGlobals.instance().HIDE_RESOURCES_WITH_WARN_STATUS)
self.hide_resources_with_warn_status_cb.blockSignals(False)
# Hide empty groups in the resources tree
self.hide_empty_groups_cb.blockSignals(True)
self.hide_empty_groups_cb.setChecked(
PluginGlobals.instance().HIDE_EMPTY_GROUPS)
self.hide_empty_groups_cb.blockSignals(False)
def evaluate_flags(self):
"""
"""
# Detect modifications
file_url_changed = (self.config_file_url_edit.text() !=
PluginGlobals.instance().CONFIG_FILE_URLS[0])
download_at_startup_changed = \
(self.download_cb.isChecked() != PluginGlobals.instance().CONFIG_FILES_DOWNLOAD_AT_STARTUP)
hide_resources_with_warn_status_changed = \
(self.hide_resources_with_warn_status_cb.isChecked() !=
PluginGlobals.instance().HIDE_RESOURCES_WITH_WARN_STATUS)
hide_empty_groups_changed = \
(self.hide_empty_groups_cb.isChecked() != PluginGlobals.instance().HIDE_EMPTY_GROUPS)
# Init flags
self.need_update_visibility_of_tree_items = hide_empty_groups_changed or hide_resources_with_warn_status_changed
self.need_update_of_tree_content = file_url_changed
self.need_save = file_url_changed or download_at_startup_changed or \
hide_resources_with_warn_status_changed or \
hide_empty_groups_changed
# Update state of the Apply Button
self.button_box.button(QDialogButtonBox.Apply).setEnabled(
self.need_save)
def download_cb_changed(self, state):
"""
Event sent when the state of the checkbox change
"""
self.evaluate_flags()
def config_file_url_changed(self):
"""
Event sent when the text of the line edit has been edited
"""
self.evaluate_flags()
def hide_resources_with_warn_cb_changed(self, state):
"""
Event sent when the state of the checkbox change
"""
self.evaluate_flags()
def hide_empty_groups_cb_changed(self, state):
"""
Event sent when the state of the checkbox change
"""
self.evaluate_flags()
def download_file_now(self):
"""
"""
# Download, read the resources tree file and update the GUI
download_tree_config_file(self.config_file_url_edit.text())
self.ressources_tree = TreeNodeFactory(
PluginGlobals.instance().config_file_path).root_node
if self.tree_dock is not None:
self.tree_dock.set_tree_content(self.ressources_tree)
def save_settings(self):
"""
"""
# URL of the file
new_value = [self.config_file_url_edit.text()]
PluginGlobals.instance().set_qgis_settings_value(
"config_file_urls", new_value)
# Download the file at startup
new_value = self.download_cb.isChecked()
PluginGlobals.instance().set_qgis_settings_value(
"config_files_download_at_startup", new_value)
# Hide resources with a warn flag
new_value = self.hide_resources_with_warn_status_cb.isChecked()
PluginGlobals.instance().set_qgis_settings_value(
"hide_resources_with_warn_status", new_value)
# Hide empty groups in the resources tree
new_value = self.hide_empty_groups_cb.isChecked()
PluginGlobals.instance().set_qgis_settings_value(
"hide_empty_groups", new_value)
# Download, read the resources tree file and update the GUI
if self.need_update_of_tree_content:
download_tree_config_file(
PluginGlobals.instance().CONFIG_FILE_URLS[0])
self.ressources_tree = TreeNodeFactory(
PluginGlobals.instance().config_file_path).root_node
self.tree_dock.set_tree_content(self.ressources_tree)
# Update the visibility of tree items
elif self.need_update_visibility_of_tree_items and self.tree_dock is not None:
self.tree_dock.update_visibility_of_tree_items()
def apply_button_clicked(self):
"""
"""
self.save_settings()
self.evaluate_flags()
def close_button_clicked(self):
"""
"""
self.close()
def restore_defaults_button_clicked(self):
"""
"""
# URL of the file
self.config_file_url_edit.blockSignals(True)
self.config_file_url_edit.setText(
PluginGlobals.instance().get_qgis_setting_default_value(
"CONFIG_FILE_URLS")[0])
self.config_file_url_edit.setCursorPosition(0)
self.config_file_url_edit.blockSignals(False)
# Download the file at startup
self.download_cb.blockSignals(True)
self.download_cb.setChecked(
PluginGlobals.instance().get_qgis_setting_default_value(
"CONFIG_FILES_DOWNLOAD_AT_STARTUP"))
self.download_cb.blockSignals(False)
# Hide resources with a warn flag
self.hide_resources_with_warn_status_cb.blockSignals(True)
self.hide_resources_with_warn_status_cb.setChecked(
PluginGlobals.instance().get_qgis_setting_default_value(
"HIDE_RESOURCES_WITH_WARN_STATUS"))
self.hide_resources_with_warn_status_cb.blockSignals(False)
# Hide empty groups in the resources tree
self.hide_empty_groups_cb.blockSignals(True)
self.hide_empty_groups_cb.setChecked(
PluginGlobals.instance().get_qgis_setting_default_value(
"HIDE_EMPTY_GROUPS"))
self.hide_empty_groups_cb.blockSignals(False)
self.evaluate_flags()
def closeEvent(self, evnt):
"""
"""
if self.need_save:
reply = QMessageBox.question(
self, u"Sauvegarder ?",
u"Voulez-vous appliquer les changements avant de fermer la fenêtre de paramétrage de l'extension ?",
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel,
QMessageBox.Yes)
if reply == QMessageBox.No:
evnt.accept()
super(ParamBox, self).closeEvent(evnt)
elif reply == QMessageBox.Yes:
self.save_settings()
evnt.accept()
super(ParamBox, self).closeEvent(evnt)
else:
evnt.accept()
super(ParamBox, self).closeEvent(evnt)
evnt.ignore()
class PlanetOrderBundleWidget(QFrame):
selectionChanged = pyqtSignal()
def __init__(self, bundleid, bundle, item_type):
super().__init__()
self.bundleid = bundleid
self.name = bundle["name"]
self.description = bundle["description"]
self.udm = bundle.get("auxiliaryFiles", "").lower().startswith("udm2")
assets = bundle["assets"]
self.can_harmonize = ("ortho_analytic_4b_sr" in assets
or "ortho_analytic_8b_sr" in assets)
self.can_harmonize = bundle.get("canHarmonize", False)
self.can_clip = bundle.get("canClip", False)
self.rectified = bundle["rectification"] == "orthorectified"
bands = []
asset_def = PlanetClient.getInstance(
).asset_types_for_item_type_as_dict(item_type)
for asset in assets:
asset_bands = asset_def[asset].get("bands", [])
for band in asset_bands:
bands.append(band["name"])
bands = set(bands)
layout = QVBoxLayout()
hlayout = QHBoxLayout()
hlayout.setMargin(0)
self.labelName = QLabel(f"<b>{self.name}</b>")
hlayout.addWidget(self.labelName)
hlayout.addStretch()
self.chkSelected = QCheckBox()
self.chkSelected.stateChanged.connect(self.checkStateChanged)
hlayout.addWidget(self.chkSelected)
layout.addLayout(hlayout)
self.labelDescription = QLabel(self.description)
self.labelDescription.setWordWrap(True)
layout.addWidget(self.labelDescription)
self.labelBands = QLabel(
f"Bands: {', '.join([str(b) for b in bands])}")
layout.addWidget(self.labelBands)
hlayouttype = QHBoxLayout()
hlayouttype.setMargin(0)
self.radioTiff = QRadioButton("GeoTIFF")
self.radioTiff.setChecked(True)
self.radioTiff.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioTiff)
self.radioNitf = QRadioButton("NITF")
self.radioNitf.toggled.connect(self.selectionChanged.emit)
hlayouttype.addWidget(self.radioNitf)
hlayouttype.addStretch()
layout.addLayout(hlayouttype)
if self.udm:
hlayoutudm = QHBoxLayout()
hlayoutudm.setMargin(0)
self.labelUdm = IconLabel("UDM2", UDM_ICON)
hlayoutudm.addWidget(self.labelUdm)
hlayoutudm.addStretch()
layout.addLayout(hlayoutudm)
layout.addStretch()
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
self.setLayout(layout)
self.checkStateChanged()
def checkStateChanged(self):
self.radioTiff.setEnabled(self.chkSelected.isChecked())
self.radioNitf.setEnabled(self.chkSelected.isChecked())
self.labelName.setEnabled(self.chkSelected.isChecked())
self.labelDescription.setEnabled(self.chkSelected.isChecked())
self.labelBands.setEnabled(self.chkSelected.isChecked())
if self.udm:
self.labelUdm.setEnabled(self.chkSelected.isChecked())
self.selectionChanged.emit()
def selected(self):
return self.chkSelected.isChecked()
def setSelected(self, selected, emit=False):
if not emit:
self.blockSignals(True)
self.chkSelected.setChecked(selected)
self.blockSignals(False)
def filetype(self):
if self.radioTiff.isChecked():
return "GeoTIFF"
else:
return "NITF"
class TreeLayerItem(QTreeWidgetItem):
layerIcon = QIcon(
os.path.join(os.path.dirname(__file__), "icons", "layer.png"))
def __init__(self, iface, layer, tree, dlg):
QTreeWidgetItem.__init__(self)
self.iface = iface
self.layer = layer
self.setText(0, layer.name())
self.setIcon(0, self.layerIcon)
project = QgsProject.instance()
if project.layerTreeRoot().findLayer(layer.id()).isVisible():
self.setCheckState(0, Qt.Checked)
else:
self.setCheckState(0, Qt.Unchecked)
self.visibleItem = QTreeWidgetItem(self)
self.visibleCheck = QCheckBox()
vis = layer.customProperty("qgis2web/Visible", True)
if vis == 0 or str(vis).lower() == "false":
self.visibleCheck.setChecked(False)
else:
self.visibleCheck.setChecked(True)
self.visibleItem.setText(0, "Visible")
self.addChild(self.visibleItem)
tree.setItemWidget(self.visibleItem, 1, self.visibleCheck)
self.interactiveItem = QTreeWidgetItem(self)
self.interactiveCheck = QCheckBox()
int = True
if int == 0 or str(int).lower() == "false":
self.interactiveCheck.setChecked(False)
else:
self.interactiveCheck.setChecked(True)
self.interactiveItem.setText(0, "Popups")
self.addChild(self.interactiveItem)
tree.setItemWidget(self.interactiveItem, 1, self.interactiveCheck)
if layer.type() == layer.VectorLayer:
if layer.providerType() == 'WFS':
self.jsonItem = QTreeWidgetItem(self)
self.jsonCheck = QCheckBox()
if layer.customProperty("qgis2web/Encode to JSON") == 2:
self.jsonCheck.setChecked(True)
self.jsonItem.setText(0, "Encode to JSON")
self.jsonCheck.stateChanged.connect(self.changeJSON)
self.addChild(self.jsonItem)
tree.setItemWidget(self.jsonItem, 1, self.jsonCheck)
if layer.geometryType() == QgsWkbTypes.PointGeometry:
self.clusterItem = QTreeWidgetItem(self)
self.clusterCheck = QCheckBox()
if layer.customProperty("qgis2web/Cluster") == 2:
self.clusterCheck.setChecked(True)
self.clusterItem.setText(0, "Cluster")
self.clusterCheck.stateChanged.connect(self.changeCluster)
self.addChild(self.clusterItem)
tree.setItemWidget(self.clusterItem, 1, self.clusterCheck)
self.popupItem = QTreeWidgetItem(self)
self.popupItem.setText(0, "Popup fields")
options = []
fields = self.layer.fields()
for f in fields:
fieldIndex = fields.indexFromName(f.name())
editorWidget = layer.editorWidgetSetup(fieldIndex).type()
if editorWidget == 'Hidden':
continue
options.append(f.name())
for option in options:
self.attr = QTreeWidgetItem(self)
self.attrWidget = QComboBox()
self.attrWidget.addItem("no label")
self.attrWidget.addItem("inline label")
self.attrWidget.addItem("header label")
custProp = layer.customProperty("qgis2web/popup/" + option)
if (custProp != "" and custProp is not None):
self.attrWidget.setCurrentIndex(
self.attrWidget.findText(
layer.customProperty("qgis2web/popup/" + option)))
self.attr.setText(1, option)
self.popupItem.addChild(self.attr)
tree.setItemWidget(self.attr, 2, self.attrWidget)
self.addChild(self.popupItem)
else:
if layer.providerType() == 'wms':
self.getFeatureInfoItem = QTreeWidgetItem(self)
self.getFeatureInfoCheck = QCheckBox()
if layer.customProperty("qgis2web/GetFeatureInfo") == 2:
self.getFeatureInfoCheck.setChecked(True)
self.getFeatureInfoItem.setText(0, "Enable GetFeatureInfo?")
self.getFeatureInfoCheck.stateChanged.connect(
self.changeGetFeatureInfo)
self.addChild(self.getFeatureInfoItem)
tree.setItemWidget(self.getFeatureInfoItem, 1,
self.getFeatureInfoCheck)
@property
def popup(self):
popup = []
self.tree = self.treeWidget()
for p in range(self.childCount()):
item = self.child(p).text(1)
if item != "":
popupVal = self.tree.itemWidget(self.child(p), 2).currentText()
pair = (item, popupVal)
popup.append(pair)
popup = OrderedDict(popup)
return popup
@property
def visible(self):
return self.visibleCheck.isChecked()
@property
def interactive(self):
return self.interactiveCheck.isChecked()
@property
def json(self):
try:
return self.jsonCheck.isChecked()
except Exception:
return False
@property
def cluster(self):
try:
return self.clusterCheck.isChecked()
except Exception:
return False
@property
def getFeatureInfo(self):
try:
return self.getFeatureInfoCheck.isChecked()
except Exception:
return False
def changeJSON(self, isJSON):
self.layer.setCustomProperty("qgis2web/Encode to JSON", isJSON)
def changeCluster(self, isCluster):
self.layer.setCustomProperty("qgis2web/Cluster", isCluster)
def changeGetFeatureInfo(self, isGetFeatureInfo):
self.layer.setCustomProperty("qgis2web/GetFeatureInfo",
isGetFeatureInfo)
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster Layer'
PARAMETER_TABLE = 'Vector Layer'
PARAMETER_VECTOR = 'Feature Source'
PARAMETER_STRING = 'String'
PARAMETER_EXPRESSION = 'Expression'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Layer Field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
PARAMETER_CRS = 'CRS'
PARAMETER_MULTIPLE = 'Multiple Input'
PARAMETER_BAND = 'Raster Band'
PARAMETER_MAP_LAYER = 'Map Layer'
paramTypes = [
PARAMETER_BOOLEAN, PARAMETER_EXTENT, PARAMETER_FILE, PARAMETER_NUMBER,
PARAMETER_RASTER, PARAMETER_STRING, PARAMETER_EXPRESSION,
PARAMETER_MAP_LAYER, PARAMETER_TABLE, PARAMETER_TABLE_FIELD,
PARAMETER_VECTOR, PARAMETER_POINT, PARAMETER_CRS, PARAMETER_MULTIPLE,
PARAMETER_BAND
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(
settings.value(
"/Processing/modelParametersDefinitionDialogGeometry",
QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def setupUi(self):
self.setWindowTitle(self.tr('Parameter Definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
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 == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, QgsProcessingParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.defaultValue()))
self.verticalLayout.addWidget(self.state)
elif self.paramType == ModelerParameterDefinitionDialog.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 == ModelerParameterDefinitionDialog.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 (ModelerParameterDefinitionDialog.PARAMETER_VECTOR,
ModelerParameterDefinitionDialog.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
== ModelerParameterDefinitionDialog.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
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
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(default))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType
== ModelerParameterDefinitionDialog.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
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
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 == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(1 if self.param.behavior(
) == QgsProcessingParameterFile.Folder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.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 == ModelerParameterDefinitionDialog.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)
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.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.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def accept(self):
description = str(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, QgsProcessingParameterNumber)):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def reject(self):
self.param = None
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.reject(self)
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster layer'
PARAMETER_TABLE = 'Table'
PARAMETER_VECTOR = 'Vector layer'
PARAMETER_STRING = 'String'
PARAMETER_EXPRESSION = 'Expression'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Table field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
PARAMETER_CRS = 'CRS'
PARAMETER_MULTIPLE = 'Multiple input'
paramTypes = [
PARAMETER_BOOLEAN, PARAMETER_EXTENT, PARAMETER_FILE, PARAMETER_NUMBER,
PARAMETER_RASTER, PARAMETER_STRING, PARAMETER_EXPRESSION,
PARAMETER_TABLE, PARAMETER_TABLE_FIELD, PARAMETER_VECTOR,
PARAMETER_POINT, PARAMETER_CRS, PARAMETER_MULTIPLE
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
def setupUi(self):
self.setWindowTitle(self.tr('Parameter definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
self.label = QLabel(self.tr('Parameter name'))
self.verticalLayout.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.verticalLayout.addWidget(self.nameTextBox)
if isinstance(self.param, Parameter):
self.nameTextBox.setText(self.param.description)
if self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, ParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.value))
self.verticalLayout.addWidget(self.state)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or \
isinstance(self.param, ParameterTableField):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.inputs.values()):
if isinstance(param.param, (ParameterVector, ParameterTable)):
self.parentCombo.addItem(param.param.description,
param.param.name)
if self.param is not None:
if self.param.parent == param.param.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.multiple)
self.verticalLayout.addWidget(self.multipleCheck)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, ParameterVector)):
self.verticalLayout.addWidget(QLabel(self.tr('Shape type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Any'))
self.shapetypeCombo.addItem(self.tr('Point'))
self.shapetypeCombo.addItem(self.tr('Line'))
self.shapetypeCombo.addItem(self.tr('Polygon'))
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(self.param.datatype[0] + 1)
self.verticalLayout.addWidget(self.shapetypeCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, ParameterMultipleInput)):
self.verticalLayout.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Vector (any)'))
self.datatypeCombo.addItem(self.tr('Vector (point)'))
self.datatypeCombo.addItem(self.tr('Vector (line)'))
self.datatypeCombo.addItem(self.tr('Vector (polygon)'))
self.datatypeCombo.addItem(self.tr('Raster'))
self.datatypeCombo.addItem(self.tr('File'))
if self.param is not None:
self.datatypeCombo.setCurrentIndex(self.param.datatype + 1)
self.verticalLayout.addWidget(self.datatypeCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, ParameterNumber)):
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.min))
self.maxTextBox.setText(str(self.param.max))
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.default
if self.param.isInteger:
default = int(math.floor(default))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, ParameterExpression)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultEdit = QgsExpressionLineEdit()
if self.param is not None:
self.defaultEdit.setExpression(self.param.default)
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.inputs.values()):
if isinstance(param.param, (ParameterVector, ParameterTable)):
self.parentCombo.addItem(param.param.description,
param.param.name)
if self.param is not None:
if self.param.parent_layer == param.param.name:
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, ParameterString)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.default)
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, ParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(
1 if self.param.isFolder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, ParameterPoint)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.default)
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, ParameterCrs)):
self.verticalLayout.addWidget(QLabel(self.tr('Default value')))
self.selector = QgsProjectionSelectionWidget()
if self.param is not None:
self.selector.setCrs(
QgsCoordinateReferenceSystem(self.param.default))
else:
self.selector.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
self.verticalLayout.addWidget(self.selector)
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.optional)
self.verticalLayout.addWidget(self.requiredCheck)
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.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def okPressed(self):
description = str(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while name in self.alg.inputs:
name = safeName.lower() + str(i)
else:
name = self.param.name
if (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN
or isinstance(self.param, ParameterBoolean)):
self.param = ParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD
or isinstance(self.param, ParameterTableField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
self.param = ParameterTableField(
name,
description,
parent,
datatype,
multiple=self.multipleCheck.isChecked())
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_RASTER
or isinstance(self.param, ParameterRaster)):
self.param = ParameterRaster(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_TABLE
or isinstance(self.param, ParameterTable)):
self.param = ParameterTable(name, description)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_VECTOR
or isinstance(self.param, ParameterVector)):
self.param = ParameterVector(
name, description, [self.shapetypeCombo.currentIndex() - 1])
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE
or isinstance(self.param, ParameterMultipleInput)):
self.param = ParameterMultipleInput(
name, description,
self.datatypeCombo.currentIndex() - 1)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_NUMBER
or isinstance(self.param, ParameterNumber)):
try:
vmin = self.minTextBox.text().strip()
if vmin == '':
vmin = None
else:
vmin = float(vmin)
vmax = self.maxTextBox.text().strip()
if vmax == '':
vmax = None
else:
vmax = float(vmax)
self.param = ParameterNumber(name, description, vmin, vmax,
str(self.defaultTextBox.text()))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION
or isinstance(self.param, ParameterExpression)):
parent = self.parentCombo.currentData()
self.param = ParameterExpression(
name,
description,
default=str(self.defaultEdit.expression()),
parent_layer=parent)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_STRING
or isinstance(self.param, ParameterString)):
self.param = ParameterString(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_EXTENT
or isinstance(self.param, ParameterExtent)):
self.param = ParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE
or isinstance(self.param, ParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = ParameterFile(name, description, isFolder=isFolder)
elif (self.paramType
== ModelerParameterDefinitionDialog.PARAMETER_POINT
or isinstance(self.param, ParameterPoint)):
self.param = ParameterPoint(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS
or isinstance(self.param, ParameterCrs)):
self.param = ParameterCrs(name,
description,
default=self.selector.crs().authid())
self.param.optional = not self.requiredCheck.isChecked()
self.close()
def cancelPressed(self):
self.param = None
self.close()
class ModelerParameterDefinitionDialog(QDialog):
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(
settings.value(
"/Processing/modelParametersDefinitionDialogGeometry",
QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def setupUi(self):
self.setWindowTitle(self.tr('Parameter Definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
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_BOOLEAN or \
isinstance(self.param, QgsProcessingParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.defaultValue()))
self.verticalLayout.addWidget(self.state)
elif 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 == parameters.PARAMETER_NUMBER
or self.paramType == parameters.PARAMETER_DISTANCE
or isinstance(self.param, (QgsProcessingParameterNumber,
QgsProcessingParameterDistance))):
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(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_STRING
or isinstance(self.param, QgsProcessingParameterString)):
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_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(1 if self.param.behavior(
) == QgsProcessingParameterFile.Folder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
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)
# 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.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.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == parameters.PARAMETER_BOOLEAN
or isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description,
self.state.isChecked())
elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
or isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(
name,
description,
defaultValue=default,
parentLayerParameterName=parent,
type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == parameters.PARAMETER_BAND
or isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None,
parent)
elif (self.paramType == parameters.PARAMETER_MAP_LAYER
or isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(name, description)
elif (self.paramType == parameters.PARAMETER_RASTER
or isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(name, description)
elif (self.paramType == parameters.PARAMETER_TABLE
or isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_VECTOR
or isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description, [self.shapetypeCombo.currentData()])
elif (self.paramType == parameters.PARAMETER_MULTIPLE
or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description, self.datatypeCombo.currentData())
elif (self.paramType == parameters.PARAMETER_NUMBER or isinstance(
self.param,
(QgsProcessingParameterNumber, QgsProcessingParameterDistance))):
try:
self.param = QgsProcessingParameterNumber(
name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(
self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == parameters.PARAMETER_EXPRESSION
or isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(
name, description, str(self.defaultEdit.expression()), parent)
elif (self.paramType == parameters.PARAMETER_STRING
or isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_EXTENT
or isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == parameters.PARAMETER_FILE
or isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(
name, description, QgsProcessingParameterFile.Folder
if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == parameters.PARAMETER_POINT
or isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(
name, description, str(self.defaultTextBox.text()))
elif (self.paramType == parameters.PARAMETER_CRS
or isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(
name, description,
self.selector.crs().authid())
elif (self.paramType == parameters.PARAMETER_ENUM
or isinstance(self.param, QgsProcessingParameterEnum)):
self.param = QgsProcessingParameterEnum(
name, description, self.widget.options(),
self.widget.allowMultiple(), self.widget.defaultOptions())
elif (self.paramType == parameters.PARAMETER_MATRIX
or isinstance(self.param, QgsProcessingParameterMatrix)):
self.param = QgsProcessingParameterMatrix(
name,
description,
hasFixedNumberRows=self.widget.fixedRows(),
headers=self.widget.headers(),
defaultValue=self.widget.value())
# Destination parameter
elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=self.param.description(),
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=self.param.description(),
defaultValue=self.defaultWidget.getValue())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=self.param.description(),
type=self.param.dataType(),
defaultValue=self.defaultWidget.getValue())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry(
).parameterType(typeId)
if not paramTypeDef:
msg = self.tr(
'The parameter `{}` is not registered, are you missing a required plugin?'
.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def reject(self):
self.param = None
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.reject(self)
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster layer'
PARAMETER_TABLE = 'Table'
PARAMETER_VECTOR = 'Vector layer'
PARAMETER_STRING = 'String'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Table field'
PARAMETER_TABLE_MULTIPLE_FIELD = 'Table multiple field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
# To add
PARAMETER_MULTIPLE = 'Multiple input'
PARAMETER_FIXED_TABLE = 'Fixed table'
paramTypes = [
PARAMETER_BOOLEAN,
PARAMETER_EXTENT,
PARAMETER_FILE,
PARAMETER_NUMBER,
PARAMETER_RASTER,
PARAMETER_STRING,
PARAMETER_TABLE,
PARAMETER_TABLE_FIELD,
PARAMETER_TABLE_MULTIPLE_FIELD,
PARAMETER_VECTOR,
PARAMETER_POINT
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
def setupUi(self):
self.setWindowTitle(self.tr('Parameter definition'))
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setSpacing(40)
self.verticalLayout.setMargin(20)
self.horizontalLayoutName = QHBoxLayout(self)
self.horizontalLayoutName.setSpacing(2)
self.horizontalLayoutName.setMargin(0)
self.label = QLabel(self.tr('Parameter name'))
self.horizontalLayoutName.addWidget(self.label)
self.nameTextBox = QLineEdit()
self.horizontalLayoutName.addWidget(self.nameTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutName)
self.horizontalLayoutRequired = QHBoxLayout(self)
self.horizontalLayoutRequired.setSpacing(2)
self.horizontalLayoutRequired.setMargin(0)
self.horizontalLayoutParent = QHBoxLayout(self)
self.horizontalLayoutParent.setSpacing(2)
self.horizontalLayoutParent.setMargin(0)
self.horizontalLayoutDefault = QHBoxLayout(self)
self.horizontalLayoutDefault.setSpacing(2)
self.horizontalLayoutDefault.setMargin(0)
self.horizontalLayoutDatatype = QHBoxLayout(self)
self.horizontalLayoutDatatype.setSpacing(2)
self.horizontalLayoutDatatype.setMargin(0)
if isinstance(self.param, Parameter):
self.nameTextBox.setText(self.param.description)
if self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, ParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(True if self.param.value else False)
self.horizontalLayoutParent.addWidget(self.state)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType in (
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD,
ModelerParameterDefinitionDialog.PARAMETER_TABLE_MULTIPLE_FIELD)\
or isinstance(self.param, (ParameterTableField,
ParameterTableMultipleField)):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in self.alg.inputs.values():
if isinstance(param.param, (ParameterVector, ParameterTable)):
self.parentCombo.addItem(param.param.description, param.param.name)
if self.param is not None:
if self.param.parent == param.param.name:
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.horizontalLayoutParent.addWidget(self.parentCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
# add the datatype selector
self.horizontalLayoutDatatype.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.horizontalLayoutDatatype.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
datatype_index = self.param.datatype + 1
self.datatypeCombo.setCurrentIndex(datatype_index)
self.verticalLayout.addLayout(self.horizontalLayoutDatatype)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or \
isinstance(self.param, ParameterVector):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Shape type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Any'))
self.shapetypeCombo.addItem(self.tr('Point'))
self.shapetypeCombo.addItem(self.tr('Line'))
self.shapetypeCombo.addItem(self.tr('Polygon'))
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(self.param.shapetype[0] + 1)
self.horizontalLayoutParent.addWidget(self.shapetypeCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or \
isinstance(self.param, ParameterMultipleInput):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Vector (any)'))
self.datatypeCombo.addItem(self.tr('Vector (point)'))
self.datatypeCombo.addItem(self.tr('Vector (line)'))
self.datatypeCombo.addItem(self.tr('Vector (polygon)'))
self.datatypeCombo.addItem(self.tr('Raster'))
self.datatypeCombo.addItem(self.tr('Table'))
if self.param is not None:
self.datatypeCombo.setCurrentIndex(self.param.datatype + 1)
self.horizontalLayoutParent.addWidget(self.datatypeCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or \
isinstance(self.param, ParameterNumber):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Min/Max values')))
self.minTextBox = QLineEdit()
self.maxTextBox = QLineEdit()
if self.param is not None:
self.minTextBox.setText(unicode(self.param.min))
self.maxTextBox.setText(unicode(self.param.max))
self.horizontalLayoutParent.addWidget(self.minTextBox)
self.horizontalLayoutParent.addWidget(self.maxTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
self.horizontalLayoutDefault.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
self.defaultTextBox.setText(self.tr('0'))
if self.param is not None:
default = self.param.default
if self.param.isInteger:
default = int(math.floor(default))
self.defaultTextBox.setText(unicode(default))
self.horizontalLayoutDefault.addWidget(self.defaultTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutDefault)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or \
isinstance(self.param, ParameterString):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.default)
self.horizontalLayoutParent.addWidget(self.defaultTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or \
isinstance(self.param, ParameterFile):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(
1 if self.param.isFolder else 0)
self.horizontalLayoutParent.addWidget(self.fileFolderCombo)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or \
isinstance(self.param, ParameterPoint):
self.horizontalLayoutParent.addWidget(QLabel(self.tr('Default value')))
self.defaultTextBox = QLineEdit()
if self.param is not None:
self.defaultTextBox.setText(self.param.default)
self.horizontalLayoutParent.addWidget(self.defaultTextBox)
self.verticalLayout.addLayout(self.horizontalLayoutParent)
self.horizontalLayoutRequired.addWidget(QLabel(self.tr('Required')))
self.yesNoCombo = QComboBox()
self.yesNoCombo.addItem(self.tr('Yes'))
self.yesNoCombo.addItem(self.tr('No'))
self.horizontalLayoutRequired.addWidget(self.yesNoCombo)
if self.param is not None:
self.yesNoCombo.setCurrentIndex(
1 if self.param.optional else 0)
self.verticalLayout.addLayout(self.horizontalLayoutRequired)
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.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def okPressed(self):
description = unicode(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while name in self.alg.inputs:
name = safeName.lower() + str(i)
else:
name = self.param.name
if self.paramType \
== ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN \
or isinstance(self.param, ParameterBoolean):
self.param = ParameterBoolean(name, description,
self.state.isChecked())
elif self.paramType in (
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD,
ModelerParameterDefinitionDialog.PARAMETER_TABLE_MULTIPLE_FIELD)\
or isinstance(self.param, (ParameterTableField,
ParameterTableMultipleField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.itemData(self.parentCombo.currentIndex())
datatype = self.datatypeCombo.itemData(
self.datatypeCombo.currentIndex())
if (self.paramType ==
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or
isinstance(self.param, ParameterTableField)):
self.param = ParameterTableField(
name, description, parent, datatype)
else:
self.param = ParameterTableMultipleField(
name, description, parent, datatype)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_RASTER or \
isinstance(self.param, ParameterRaster):
self.param = ParameterRaster(
name, description,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE or \
isinstance(self.param, ParameterTable):
self.param = ParameterTable(
name, description,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or \
isinstance(self.param, ParameterVector):
self.param = ParameterVector(
name, description,
[self.shapetypeCombo.currentIndex() - 1],
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or \
isinstance(self.param, ParameterMultipleInput):
self.param = ParameterMultipleInput(
name, description,
self.datatypeCombo.currentIndex() - 1,
self.yesNoCombo.currentIndex() == 1)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or \
isinstance(self.param, ParameterNumber):
try:
vmin = unicode(self.minTextBox.text()).strip()
if vmin == '':
vmin = None
else:
vmin = float(vmin)
vmax = unicode(self.maxTextBox.text()).strip()
if vmax == '':
vmax = None
else:
vmax = float(vmax)
self.param = ParameterNumber(name, description, vmin, vmax,
unicode(self.defaultTextBox.text()))
except:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or \
isinstance(self.param, ParameterString):
self.param = ParameterString(name, description,
unicode(self.defaultTextBox.text()))
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXTENT or \
isinstance(self.param, ParameterExtent):
self.param = ParameterExtent(name, description)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or \
isinstance(self.param, ParameterFile):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = ParameterFile(name, description, isFolder=isFolder)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or \
isinstance(self.param, ParameterPoint):
self.param = ParameterPoint(name, description,
unicode(self.defaultTextBox.text()))
self.param.optional = self.yesNoCombo.currentIndex() == 1
self.close()
def cancelPressed(self):
self.param = None
self.close()
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster layer'
PARAMETER_TABLE = 'Table'
PARAMETER_VECTOR = 'Vector layer'
PARAMETER_STRING = 'String'
PARAMETER_EXPRESSION = 'Expression'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Table field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
PARAMETER_CRS = 'CRS'
PARAMETER_MULTIPLE = 'Multiple input'
paramTypes = [
PARAMETER_BOOLEAN,
PARAMETER_EXTENT,
PARAMETER_FILE,
PARAMETER_NUMBER,
PARAMETER_RASTER,
PARAMETER_STRING,
PARAMETER_EXPRESSION,
PARAMETER_TABLE,
PARAMETER_TABLE_FIELD,
PARAMETER_VECTOR,
PARAMETER_POINT,
PARAMETER_CRS,
PARAMETER_MULTIPLE
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
def setupUi(self):
self.setWindowTitle(self.tr('Parameter definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
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 == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, ParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.value))
self.verticalLayout.addWidget(self.state)
elif self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or \
isinstance(self.param, ParameterTableField):
self.verticalLayout.addWidget(QLabel(self.tr('Parent layer')))
self.parentCombo = QComboBox()
idx = 0
for param in list(self.alg.inputs.values()):
if isinstance(param.param, (ParameterVector, ParameterTable)):
self.parentCombo.addItem(param.param.description(), param.param.name())
if self.param is not None:
if self.param.parent == param.param.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.multiple)
self.verticalLayout.addWidget(self.multipleCheck)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or
isinstance(self.param, ParameterVector)):
self.verticalLayout.addWidget(QLabel(self.tr('Shape type')))
self.shapetypeCombo = QComboBox()
self.shapetypeCombo.addItem(self.tr('Any'))
self.shapetypeCombo.addItem(self.tr('Point'))
self.shapetypeCombo.addItem(self.tr('Line'))
self.shapetypeCombo.addItem(self.tr('Polygon'))
if self.param is not None:
self.shapetypeCombo.setCurrentIndex(self.param.datatype[0] + 1)
self.verticalLayout.addWidget(self.shapetypeCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or
isinstance(self.param, ParameterMultipleInput)):
self.verticalLayout.addWidget(QLabel(self.tr('Data type')))
self.datatypeCombo = QComboBox()
self.datatypeCombo.addItem(self.tr('Vector (any)'))
self.datatypeCombo.addItem(self.tr('Vector (point)'))
self.datatypeCombo.addItem(self.tr('Vector (line)'))
self.datatypeCombo.addItem(self.tr('Vector (polygon)'))
self.datatypeCombo.addItem(self.tr('Raster'))
self.datatypeCombo.addItem(self.tr('File'))
if self.param is not None:
self.datatypeCombo.setCurrentIndex(self.param.datatype + 1)
self.verticalLayout.addWidget(self.datatypeCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
isinstance(self.param, ParameterNumber)):
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.min))
self.maxTextBox.setText(str(self.param.max))
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.default
if self.param.isInteger:
default = int(math.floor(default))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION or
isinstance(self.param, ParameterExpression)):
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.inputs.values()):
if isinstance(param.param, (ParameterVector, ParameterTable)):
self.parentCombo.addItem(param.param.description(), param.param.name())
if self.param is not None:
if self.param.parent_layer == param.param.name():
self.parentCombo.setCurrentIndex(idx)
idx += 1
self.verticalLayout.addWidget(self.parentCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or
isinstance(self.param, ParameterString)):
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 == ModelerParameterDefinitionDialog.PARAMETER_FILE or
isinstance(self.param, ParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(
1 if self.param.isFolder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or
isinstance(self.param, ParameterPoint)):
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 == ModelerParameterDefinitionDialog.PARAMETER_CRS or
isinstance(self.param, ParameterCrs)):
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)
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.buttonBox = QDialogButtonBox(self)
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel |
QDialogButtonBox.Ok)
self.buttonBox.setObjectName('buttonBox')
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def okPressed(self):
description = str(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while name in self.alg.inputs:
name = safeName.lower() + str(i)
else:
name = self.param.name()
if (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or
isinstance(self.param, ParameterBoolean)):
self.param = ParameterBoolean(name, description, self.state.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or
isinstance(self.param, ParameterTableField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
self.param = ParameterTableField(name, description, parent, datatype, multiple=self.multipleCheck.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_RASTER or
isinstance(self.param, ParameterRaster)):
self.param = ParameterRaster(
name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE or
isinstance(self.param, ParameterTable)):
self.param = ParameterTable(
name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or
isinstance(self.param, ParameterVector)):
self.param = ParameterVector(
name, description,
[self.shapetypeCombo.currentIndex() - 1])
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or
isinstance(self.param, ParameterMultipleInput)):
self.param = ParameterMultipleInput(
name, description,
self.datatypeCombo.currentIndex() - 1)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
isinstance(self.param, ParameterNumber)):
try:
vmin = self.minTextBox.text().strip()
if vmin == '':
vmin = None
else:
vmin = float(vmin)
vmax = self.maxTextBox.text().strip()
if vmax == '':
vmax = None
else:
vmax = float(vmax)
self.param = ParameterNumber(name, description, vmin, vmax,
str(self.defaultTextBox.text()))
except:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION or
isinstance(self.param, ParameterExpression)):
parent = self.parentCombo.currentData()
self.param = ParameterExpression(name, description,
default=str(self.defaultEdit.expression()),
parent_layer=parent)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or
isinstance(self.param, ParameterString)):
self.param = ParameterString(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXTENT or
isinstance(self.param, ParameterExtent)):
self.param = ParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or
isinstance(self.param, ParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = ParameterFile(name, description, isFolder=isFolder)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or
isinstance(self.param, ParameterPoint)):
self.param = ParameterPoint(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS or
isinstance(self.param, ParameterCrs)):
self.param = ParameterCrs(name, description, default=self.selector.crs().authid())
if not self.requiredCheck.isChecked():
self.param.setFlags(self.param.flags() | QgsProcessingParameterDefinition.FlagOptional)
self.close()
def cancelPressed(self):
self.param = None
self.close()
class ModelerParameterDefinitionDialog(QDialog):
PARAMETER_NUMBER = 'Number'
PARAMETER_RASTER = 'Raster Layer'
PARAMETER_TABLE = 'Vector Layer'
PARAMETER_VECTOR = 'Vector Features'
PARAMETER_STRING = 'String'
PARAMETER_EXPRESSION = 'Expression'
PARAMETER_BOOLEAN = 'Boolean'
PARAMETER_TABLE_FIELD = 'Vector Field'
PARAMETER_EXTENT = 'Extent'
PARAMETER_FILE = 'File'
PARAMETER_POINT = 'Point'
PARAMETER_CRS = 'CRS'
PARAMETER_MULTIPLE = 'Multiple Input'
PARAMETER_BAND = 'Raster Band'
PARAMETER_MAP_LAYER = 'Map Layer'
paramTypes = [
PARAMETER_BOOLEAN,
PARAMETER_EXTENT,
PARAMETER_FILE,
PARAMETER_NUMBER,
PARAMETER_RASTER,
PARAMETER_STRING,
PARAMETER_EXPRESSION,
PARAMETER_MAP_LAYER,
PARAMETER_TABLE,
PARAMETER_TABLE_FIELD,
PARAMETER_VECTOR,
PARAMETER_POINT,
PARAMETER_CRS,
PARAMETER_MULTIPLE,
PARAMETER_BAND
]
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(settings.value("/Processing/modelParametersDefinitionDialogGeometry", QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def setupUi(self):
self.setWindowTitle(self.tr('Parameter Definition'))
self.setMinimumWidth(300)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setMargin(20)
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 == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or \
isinstance(self.param, QgsProcessingParameterBoolean):
self.state = QCheckBox()
self.state.setText(self.tr('Checked'))
self.state.setChecked(False)
if self.param is not None:
self.state.setChecked(bool(self.param.defaultValue()))
self.verticalLayout.addWidget(self.state)
elif self.paramType == ModelerParameterDefinitionDialog.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 == ModelerParameterDefinitionDialog.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 (
ModelerParameterDefinitionDialog.PARAMETER_VECTOR, ModelerParameterDefinitionDialog.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 == ModelerParameterDefinitionDialog.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 == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
isinstance(self.param, QgsProcessingParameterNumber)):
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(default))
if default:
self.defaultTextBox.setText(str(default))
self.verticalLayout.addWidget(self.defaultTextBox)
elif (self.paramType == ModelerParameterDefinitionDialog.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 == ModelerParameterDefinitionDialog.PARAMETER_STRING or
isinstance(self.param, QgsProcessingParameterString)):
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 == ModelerParameterDefinitionDialog.PARAMETER_FILE or
isinstance(self.param, QgsProcessingParameterFile)):
self.verticalLayout.addWidget(QLabel(self.tr('Type')))
self.fileFolderCombo = QComboBox()
self.fileFolderCombo.addItem(self.tr('File'))
self.fileFolderCombo.addItem(self.tr('Folder'))
if self.param is not None:
self.fileFolderCombo.setCurrentIndex(
1 if self.param.behavior() == QgsProcessingParameterFile.Folder else 0)
self.verticalLayout.addWidget(self.fileFolderCombo)
elif (self.paramType == ModelerParameterDefinitionDialog.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 == ModelerParameterDefinitionDialog.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)
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.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.verticalLayout.addStretch()
self.verticalLayout.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout)
def accept(self):
description = str(self.nameTextBox.text())
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
if self.param is None:
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
i = 2
while self.alg.parameterDefinition(name):
name = safeName.lower() + str(i)
i += 1
else:
name = self.param.name()
if (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or
isinstance(self.param, QgsProcessingParameterBoolean)):
self.param = QgsProcessingParameterBoolean(name, description, self.state.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or
isinstance(self.param, QgsProcessingParameterField)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
datatype = self.datatypeCombo.currentData()
default = self.defaultTextBox.text()
if not default:
default = None
self.param = QgsProcessingParameterField(name, description, defaultValue=default,
parentLayerParameterName=parent, type=datatype,
allowMultiple=self.multipleCheck.isChecked())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND or
isinstance(self.param, QgsProcessingParameterBand)):
if self.parentCombo.currentIndex() < 0:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterBand(name, description, None, parent)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER or
isinstance(self.param, QgsProcessingParameterMapLayer)):
self.param = QgsProcessingParameterMapLayer(
name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_RASTER or
isinstance(self.param, QgsProcessingParameterRasterLayer)):
self.param = QgsProcessingParameterRasterLayer(
name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE or
isinstance(self.param, QgsProcessingParameterVectorLayer)):
self.param = QgsProcessingParameterVectorLayer(
name, description,
[self.shapetypeCombo.currentData()])
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or
isinstance(self.param, QgsProcessingParameterFeatureSource)):
self.param = QgsProcessingParameterFeatureSource(
name, description,
[self.shapetypeCombo.currentData()])
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or
isinstance(self.param, QgsProcessingParameterMultipleLayers)):
self.param = QgsProcessingParameterMultipleLayers(
name, description,
self.datatypeCombo.currentData())
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
isinstance(self.param, QgsProcessingParameterNumber)):
try:
self.param = QgsProcessingParameterNumber(name, description, QgsProcessingParameterNumber.Double,
self.defaultTextBox.text())
vmin = self.minTextBox.text().strip()
if not vmin == '':
self.param.setMinimum(float(vmin))
vmax = self.maxTextBox.text().strip()
if not vmax == '':
self.param.setMaximum(float(vmax))
except:
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Wrong or missing parameter values'))
return
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION or
isinstance(self.param, QgsProcessingParameterExpression)):
parent = self.parentCombo.currentData()
self.param = QgsProcessingParameterExpression(name, description,
str(self.defaultEdit.expression()),
parent)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or
isinstance(self.param, QgsProcessingParameterString)):
self.param = QgsProcessingParameterString(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXTENT or
isinstance(self.param, QgsProcessingParameterExtent)):
self.param = QgsProcessingParameterExtent(name, description)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or
isinstance(self.param, QgsProcessingParameterFile)):
isFolder = self.fileFolderCombo.currentIndex() == 1
self.param = QgsProcessingParameterFile(name, description,
QgsProcessingParameterFile.Folder if isFolder else QgsProcessingParameterFile.File)
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or
isinstance(self.param, QgsProcessingParameterPoint)):
self.param = QgsProcessingParameterPoint(name, description,
str(self.defaultTextBox.text()))
elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS or
isinstance(self.param, QgsProcessingParameterCrs)):
self.param = QgsProcessingParameterCrs(name, description, self.selector.crs().authid())
if not self.requiredCheck.isChecked():
self.param.setFlags(self.param.flags() | QgsProcessingParameterDefinition.FlagOptional)
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
QDialog.accept(self)
def reject(self):
self.param = None
settings = QgsSettings()
settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())
QDialog.reject(self)
@staticmethod
def inputTooltip(input_type):
tooltips = {
ModelerParameterDefinitionDialog.PARAMETER_NUMBER: QCoreApplication.translate('Processing', 'A numeric parameter, including float or integer values.'),
ModelerParameterDefinitionDialog.PARAMETER_RASTER: QCoreApplication.translate('Processing', 'A raster layer parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_TABLE: QCoreApplication.translate('Processing', 'A vector layer parameter, e.g. for algorithms which change layer styles, edit layers in place, or other operations which affect an entire layer.'),
ModelerParameterDefinitionDialog.PARAMETER_VECTOR: QCoreApplication.translate('Processing', 'A vector feature parameter, e.g. for algorithms which operate on the features within a layer.'),
ModelerParameterDefinitionDialog.PARAMETER_STRING: QCoreApplication.translate('Processing', 'A freeform string parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION: QCoreApplication.translate('Processing', 'A QGIS expression parameter, which presents an expression builder widget to users.'),
ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN: QCoreApplication.translate('Processing', 'A boolean parameter, for true/false values.'),
ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD: QCoreApplication.translate('Processing', 'A vector field parameter, for selecting an existing field from a vector source.'),
ModelerParameterDefinitionDialog.PARAMETER_EXTENT: QCoreApplication.translate('Processing', 'A map extent parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_FILE: QCoreApplication.translate('Processing', 'A file parameter, for use with non-map layer file sources.'),
ModelerParameterDefinitionDialog.PARAMETER_POINT: QCoreApplication.translate('Processing', 'A geographic point parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_CRS: QCoreApplication.translate('Processing', 'A coordinate reference system (CRS) input parameter.'),
ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE: QCoreApplication.translate('Processing', 'An input allowing selection of multiple sources, including multiple map layers or file sources.'),
ModelerParameterDefinitionDialog.PARAMETER_BAND: QCoreApplication.translate('Processing', 'A raster band parameter, for selecting an existing band from a raster source.'),
ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER: QCoreApplication.translate('Processing', 'A generic map layer parameter, which accepts either vector or raster layers.')
}
return tooltips[input_type]
class ItemWidgetBase(QFrame):
checkedStateChanged = pyqtSignal()
thumbnailChanged = pyqtSignal()
def __init__(self, item):
QFrame.__init__(self)
self.item = item
self.is_updating_checkbox = False
self.setMouseTracking(True)
self.setStyleSheet("ItemWidgetBase{border: 2px solid transparent;}")
def _setup_ui(self, text, thumbnailurl):
self.lockLabel = QLabel()
iconSize = QSize(16, 16)
self.lockLabel.setPixmap(LOCK_ICON.pixmap(iconSize))
self.checkBox = QCheckBox("")
self.checkBox.clicked.connect(self.check_box_state_changed)
self.nameLabel = QLabel(text)
self.iconLabel = QLabel()
self.labelZoomTo = QLabel()
self.labelZoomTo.setPixmap(ZOOMTO_ICON.pixmap(QSize(18, 18)))
self.labelZoomTo.setToolTip("Zoom to extent")
self.labelZoomTo.mousePressEvent = self.zoom_to_extent
self.labelAddPreview = QLabel()
self.labelAddPreview.setPixmap(ADD_PREVIEW_ICON.pixmap(QSize(18, 18)))
self.labelAddPreview.setToolTip("Add preview layer to map")
self.labelAddPreview.mousePressEvent = self._add_preview_clicked
layout = QHBoxLayout()
layout.setMargin(0)
layout.addWidget(self.checkBox)
layout.addWidget(self.lockLabel)
pixmap = QPixmap(PLACEHOLDER_THUMB, "SVG")
self.thumbnail = None
thumb = pixmap.scaled(48, 48, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.iconLabel.setPixmap(thumb)
self.iconLabel.setFixedSize(48, 48)
layout.addWidget(self.iconLabel)
if thumbnailurl is not None:
download_thumbnail(thumbnailurl, self)
layout.addWidget(self.nameLabel)
layout.addStretch()
layout.addWidget(self.labelZoomTo)
layout.addWidget(self.labelAddPreview)
layout.addSpacing(10)
self.setLayout(layout)
self.footprint = QgsRubberBand(iface.mapCanvas(),
QgsWkbTypes.PolygonGeometry)
self.footprint.setStrokeColor(PLANET_COLOR)
self.footprint.setWidth(2)
def set_thumbnail(self, img):
self.thumbnail = QPixmap(img)
thumb = self.thumbnail.scaled(48, 48, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.iconLabel.setPixmap(thumb)
self.thumbnailChanged.emit()
def is_selected(self):
return self.checkBox.checkState() == Qt.Checked
def _geom_bbox_in_project_crs(self):
transform = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
QgsProject.instance().crs(),
QgsProject.instance(),
)
return transform.transformBoundingBox(self.geom.boundingBox())
def _geom_in_project_crs(self):
transform = QgsCoordinateTransform(
QgsCoordinateReferenceSystem("EPSG:4326"),
QgsProject.instance().crs(),
QgsProject.instance(),
)
geom = QgsGeometry(self.geom)
geom.transform(transform)
return geom
def show_footprint(self):
self.footprint.setToGeometry(self._geom_in_project_crs())
def hide_footprint(self):
self.footprint.reset(QgsWkbTypes.PolygonGeometry)
def enterEvent(self, event):
self.setStyleSheet(
"ItemWidgetBase{border: 2px solid rgb(0, 157, 165);}")
self.show_footprint()
def leaveEvent(self, event):
self.setStyleSheet("ItemWidgetBase{border: 2px solid transparent;}")
self.hide_footprint()
def zoom_to_extent(self, evt):
rect = QgsRectangle(self._geom_bbox_in_project_crs())
rect.scale(1.05)
iface.mapCanvas().setExtent(rect)
iface.mapCanvas().refresh()
def _add_preview_clicked(self, evt):
self.add_preview()
@waitcursor
def add_preview(self):
send_analytics_for_preview(self.item.images())
create_preview_group(self.name(), self.item.images())
def check_box_state_changed(self):
self.update_children_items()
self.update_parent_item()
self.checkedStateChanged.emit()
def update_parent_item(self):
parent = self.item.parent()
if parent is not None:
w = parent.treeWidget().itemWidget(parent, 0)
w.update_checkbox()
def update_children_items(self):
total = self.item.childCount()
if self.checkBox.isTristate():
self.checkBox.setTristate(False)
self.checkBox.setChecked(False)
for i in range(total):
w = self.item.treeWidget().itemWidget(self.item.child(i), 0)
w.set_checked(self.checkBox.isChecked())
def update_checkbox(self):
selected = 0
total = self.item.childCount()
for i in range(total):
w = self.item.treeWidget().itemWidget(self.item.child(i), 0)
if w.is_selected():
selected += 1
if selected == total:
self.checkBox.setTristate(False)
self.checkBox.setCheckState(Qt.Checked)
elif selected == 0:
self.checkBox.setTristate(False)
self.checkBox.setCheckState(Qt.Unchecked)
else:
self.checkBox.setTristate(True)
self.checkBox.setCheckState(Qt.PartiallyChecked)
def set_checked(self, checked):
self.checkBox.setChecked(checked)
self.update_children_items()
def update_thumbnail(self):
thumbnails = self.scene_thumbnails()
if thumbnails and None not in thumbnails:
bboxes = [img[GEOMETRY] for img in self.item.images()]
pixmap = createCompoundThumbnail(bboxes, thumbnails)
thumb = pixmap.scaled(48, 48, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.iconLabel.setPixmap(thumb)
self.thumbnailChanged.emit()
def scene_thumbnails(self):
thumbnails = []
try:
for i in range(self.item.childCount()):
w = self.item.treeWidget().itemWidget(self.item.child(i), 0)
thumbnails.extend(w.scene_thumbnails())
except RuntimeError:
# item might not exist anymore. In this case, we just return
# an empty list
pass
return thumbnails
class ModelerParameterDefinitionDialog(QDialog):
@staticmethod
def use_legacy_dialog(param=None, paramType=None):
if isinstance(param, QgsProcessingDestinationParameter):
return True
# yay, use new API!
return False
def __init__(self, alg, paramType=None, param=None):
self.alg = alg
self.paramType = paramType
self.param = param
QDialog.__init__(self)
self.setModal(True)
self.setupUi()
settings = QgsSettings()
self.restoreGeometry(
settings.value(
"/Processing/modelParametersDefinitionDialogGeometry",
QByteArray()))
def closeEvent(self, event):
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
super(ModelerParameterDefinitionDialog, self).closeEvent(event)
def switchToCommentTab(self):
self.tab.setCurrentIndex(1)
self.commentEdit.setFocus()
self.commentEdit.selectAll()
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):
child = self.alg.childAlgorithms()[self.param.metadata()
['_modelChildId']]
model_output = child.modelOutput(
self.param.metadata()['_modelChildOutputName'])
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)
def setComments(self, text):
self.commentEdit.setPlainText(text)
def comments(self):
return self.commentEdit.toPlainText()
def setCommentColor(self, color):
if color.isValid():
self.comment_color_button.setColor(color)
else:
self.comment_color_button.setToNull()
def commentColor(self):
return self.comment_color_button.color(
) if not self.comment_color_button.isNull() else QColor()
def accept(self):
description = self.nameTextBox.text()
if description.strip() == '':
QMessageBox.warning(self, self.tr('Unable to define parameter'),
self.tr('Invalid parameter name'))
return
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
safeName = ''.join(c for c in description if c in validChars)
name = safeName.lower()
# Destination parameter
if (isinstance(self.param, QgsProcessingParameterFeatureSink)):
self.param = QgsProcessingParameterFeatureSink(
name=name,
description=description,
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
self.param = QgsProcessingParameterFileDestination(
name=name,
description=description,
fileFilter=self.param.fileFilter(),
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
self.param = QgsProcessingParameterFolderDestination(
name=name,
description=description,
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
self.param = QgsProcessingParameterRasterDestination(
name=name,
description=description,
defaultValue=self.defaultWidget.value())
elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
self.param = QgsProcessingParameterVectorDestination(
name=name,
description=description,
type=self.param.dataType(),
defaultValue=self.defaultWidget.value())
else:
if self.paramType:
typeId = self.paramType
else:
typeId = self.param.type()
paramTypeDef = QgsApplication.instance().processingRegistry(
).parameterType(typeId)
if not paramTypeDef:
msg = self.tr(
'The parameter `{}` is not registered, are you missing a required plugin?'
.format(typeId))
raise UndefinedParameterException(msg)
self.param = paramTypeDef.create(name)
self.param.setDescription(description)
self.param.setMetadata(paramTypeDef.metadata())
if not self.requiredCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagOptional)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagOptional)
if self.advancedCheck.isChecked():
self.param.setFlags(
self.param.flags()
| QgsProcessingParameterDefinition.FlagAdvanced)
else:
self.param.setFlags(
self.param.flags()
& ~QgsProcessingParameterDefinition.FlagAdvanced)
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.accept(self)
def reject(self):
self.param = None
settings = QgsSettings()
settings.setValue(
"/Processing/modelParametersDefinitionDialogGeometry",
self.saveGeometry())
QDialog.reject(self)
