def opendefaultexpression(self): layer = self.form.QGISLayer dlg = QgsExpressionBuilderDialog(layer, "Create default value expression", self) text = self.defaultvalueText.text().strip('[%').strip('%]').strip() dlg.setExpressionText(text) if dlg.exec_(): self.defaultvalueText.setText('[% {} %]'.format(dlg.expressionText()))
def showExpressionsBuilder(self): context = self.param.expressionContext() dlg = QgsExpressionBuilderDialog(None, self.leText.text(), self, 'generic', context) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): self.setValue(dlg.expressionText())
def showExpressionsBuilder(self): context = self.alg.createExpressionContext({}, createContext()) dlg = QgsExpressionBuilderDialog(None, self.leText.text(), self, 'generic', context) dlg.setWindowTitle(self.tr('Expression based output')) if dlg.exec_() == QDialog.Accepted: expression = QgsExpression(dlg.expressionText()) self.leText.setText(expression.evaluate(context))
def populateByExpression(self, adding=False): """ Populates the panel using an expression """ context = dataobjects.createContext() expression_context = context.expressionContext() # use the first row parameter values as a preview during expression creation params = self.panel.parametersForRow(0, warnOnInvalid=False) alg_scope = QgsExpressionContextUtils.processingAlgorithmScope(self.panel.alg, params, context) # create explicit variables corresponding to every parameter for k, v in params.items(): alg_scope.setVariable(k, v, True) expression_context.appendScope(alg_scope) # mark the parameter variables as highlighted for discoverability highlighted_vars = expression_context.highlightedVariables() highlighted_vars.extend(list(params.keys())) expression_context.setHighlightedVariables(highlighted_vars) dlg = QgsExpressionBuilderDialog(layer=None, context=context.expressionContext()) if adding: dlg.setExpectedOutputFormat(self.tr('An array of values corresponding to each new row to add')) if not dlg.exec_(): return if adding: exp = QgsExpression(dlg.expressionText()) res = exp.evaluate(expression_context) if type(res) is not list: res = [res] first_row = self.panel.batchRowCount() if self.panel.batchRowCount() > 1 else 0 for row, value in enumerate(res): self.setRowValue(row + first_row, value, context) else: for row in range(self.panel.batchRowCount()): params = self.panel.parametersForRow(row, warnOnInvalid=False) # remove previous algorithm scope -- we need to rebuild this completely, using the # other parameter values from the current row expression_context.popScope() alg_scope = QgsExpressionContextUtils.processingAlgorithmScope(self.panel.alg, params, context) for k, v in params.items(): alg_scope.setVariable(k, v, True) expression_context.appendScope(alg_scope) # rebuild a new expression every time -- we don't want the expression compiler to replace # variables with precompiled values exp = QgsExpression(dlg.expressionText()) value = exp.evaluate(expression_context) self.setRowValue(row, value, context)
def define_filter(self): layer = self.layerCombo.currentText() if not layer: return layer = layer_by_name(layer) dlg = QgsExpressionBuilderDialog(layer, "List filter", self) text = self.filterText.toPlainText() dlg.setExpressionText(text) if dlg.exec_(): self.filterText.setPlainText(dlg.expressionText())
def opendefaultexpression(self): """ Open the default expression builder for setting default values based on QGIS Expressions. """ layer = self.form.QGISLayer dlg = QgsExpressionBuilderDialog(layer, "Create default value expression", self) text = self.defaultvalueText.text().strip('[%').strip('%]').strip() dlg.setExpressionText(text) if dlg.exec_(): self.defaultvalueText.setText('[% {} %]'.format(dlg.expressionText()))
def opendefaultexpression_advanced(self): """ Open the default expression builder for setting advanced default values based on QGIS Expressions. """ layer = self.form.QGISLayer dlg = QgsExpressionBuilderDialog(layer, "Create default value expression", self) text = self.defaultValueExpression.text() dlg.setExpressionText(text) if dlg.exec_(): self.defaultValueExpression.setText(dlg.expressionText())
def opendefaultexpression(self): layer = self.currentform.QGISLayer dlg = QgsExpressionBuilderDialog(layer, "Create default value expression", self) text = self.defaultvalueText.text().strip('[%').strip('%]').strip() dlg.setExpressionText(text) if dlg.exec_(): self.defaultvalueText.setText('[% {} %]'.format( dlg.expressionText()))
def showExpressionsBuilder(self): context = self.param.expressionContext() value = self.value() if not isinstance(value, str): value = '' dlg = QgsExpressionBuilderDialog(None, value, self.widget, 'generic', context) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): self.setValue(dlg.expressionText())
def on_advanced_search(self): # Slot raised to show the expression editor. filter_col = self.cbo_column.itemData(self.cbo_column.currentIndex()) start_txt = '"{0}" = '.format(filter_col) exp_dlg = QgsExpressionBuilderDialog(self._ds_mgr.vector_layer, start_txt, self, self._config.display_name) exp_dlg.setWindowTitle('{0} Expression Editor'.format( self._config.display_name)) if exp_dlg.exec_() == QDialog.Accepted: exp_text = exp_dlg.expressionText() self.exec_search(exp_text)
def showExpressionsBuilder(self): context = self.expressionContext() dlg = QgsExpressionBuilderDialog(None, self.spnValue.text(), self, 'generic', context) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): result = exp.evaluate(context) if not exp.hasEvalError(): try: self.spnValue.setValue(float(result)) except: pass
def showExpressionsBuilder(self): context = createExpressionContext() dlg = QgsExpressionBuilderDialog(None, str(self.spnValue.value()), self, 'generic', context) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): try: val = float(exp.evaluate(context)) self.setValue(val) except: return
def showExpressionsBuilder(self): context = self.param.expressionContext() dlg = QgsExpressionBuilderDialog(None, str(self.spnValue.value()), self, 'generic', context) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): try: val = float(exp.evaluate(context)) self.setValue(val) except: return
def showExpressionsBuilder(self): context = createExpressionContext() dlg = QgsExpressionBuilderDialog(None, str(self.leText.text()), self, 'generic', context) context.popScope() values = self.modelParametersDialog.getAvailableValuesOfType(QgsProcessingParameterNumber, QgsProcessingOutputNumber) variables = {} for value in values: if isinstance(value, QgsProcessingModelAlgorithm.ChildParameterSource): if value.source() == QgsProcessingModelAlgorithm.ChildParameterSource.ModelParameter: name = value.parameterName() element = self.modelParametersDialog.model.parameterDefinition(name) desc = element.description() elif value.source() == QgsProcessingModelAlgorithm.ChildParameterSource.ChildOutput: name = "%s_%s" % (value.outputChildId(), value.outputName()) alg = self.modelParametersDialog.model.childAlgorithm(value.outputChildId()) out = alg.algorithm().outputDefinition(value.outputName()) desc = self.tr("Output '{0}' from algorithm '{1}'").format(out.description(), alg.description()) variables[name] = desc values = self.modelParametersDialog.getAvailableValuesOfType([QgsProcessingParameterFeatureSource, QgsProcessingParameterRasterLayer], [QgsProcessingOutputVectorLayer, QgsProcessingOutputRasterLayer]) for value in values: if isinstance(value, QgsProcessingModelAlgorithm.ChildParameterSource): if value.source() == QgsProcessingModelAlgorithm.ChildParameterSource.ModelParameter: name = value.parameterName() element = self.modelParametersDialog.model.parameterDefinition(name) desc = element.description() elif value.source() == QgsProcessingModelAlgorithm.ChildParameterSource.ChildOutput: name = "%s_%s" % (value.outputChildId(), value.outputName()) alg = self.modelParametersDialog.model.childAlgorithm(value.outputChildId()) out = alg.algorithm().outputDefinition(value.outputName()) desc = self.tr("Output '{0}' from algorithm '{1}'").format(out.description(), alg.description()) variables['%s_minx' % name] = self.tr("Minimum X of {0}").format(desc) variables['%s_miny' % name] = self.tr("Minimum Y of {0}").format(desc) variables['%s_maxx' % name] = self.tr("Maximum X of {0}").format(desc) variables['%s_maxy' % name] = self.tr("Maximum Y of {0}").format(desc) if isinstance(element, (QgsProcessingParameterRasterLayer, QgsProcessingOutputRasterLayer)): variables['%s_min' % name] = self.tr("Minimum value of {0}").format(desc) variables['%s_max' % name] = self.tr("Maximum value of {0}").format(desc) variables['%s_avg' % name] = self.tr("Mean value of {0}").format(desc) variables['%s_stddev' % name] = self.tr("Standard deviation of {0}").format(desc) for variable, desc in variables.items(): dlg.expressionBuilder().registerItem("Modeler", variable, "@" + variable, desc, highlightedItem=True) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): self.setValue(dlg.expressionText())
def showExpressionsBuilder(self): context = createExpressionContext() processing_context = createContext() scope = self.modelParametersDialog.model.createExpressionContextScopeForChildAlgorithm(self.modelParametersDialog.childId, processing_context) context.appendScope(scope) highlighted = scope.variableNames() context.setHighlightedVariables(highlighted) dlg = QgsExpressionBuilderDialog(None, str(self.leText.text()), self, 'generic', context) dlg.setWindowTitle(self.tr('Expression Based Input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): self.setValue(dlg.expressionText())
def showExpressionsBuilder(self): context = self.param.expressionContext() dlg = QgsExpressionBuilderDialog(None, str(self.leText.text()), self, 'generic', context) context.popScope() values = self.modelParametersDialog.getAvailableValuesOfType(ParameterNumber, OutputNumber) variables = {} for value in values: if isinstance(value, ValueFromInput): name = value.name element = self.modelParametersDialog.model.inputs[name].param desc = element.description else: name = "%s_%s" % (value.alg, value.output) alg = self.modelParametersDialog.model.algs[value.alg] out = alg.algorithm.getOutputFromName(value.output) desc = "Output '%s' from algorithm '%s" % (out.description, alg.description) variables[name] = desc values = self.modelParametersDialog.getAvailableValuesOfType(ParameterVector, OutputVector) values.extend(self.modelParametersDialog.getAvailableValuesOfType(ParameterRaster, OutputRaster)) for value in values: if isinstance(value, ValueFromInput): name = value.name element = self.modelParametersDialog.model.inputs[name].param desc = element.description else: name = "%s_%s" % (value.alg, value.output) alg = self.modelParametersDialog.model.algs[value.alg] element = alg.algorithm.getOutputFromName(value.output) desc = "Output '%s' from algorithm '%s" % (element.description, alg.description) variables['%s_minx' % name] = "Minimum X of %s" % desc variables['%s_miny' % name] = "Maximum X of %s" % desc variables['%s_maxx' % name] = "Minimum Y of %s" % desc variables['%s_maxy' % name] = "Maximum Y of %s" % desc if isinstance(element, (ParameterRaster, OutputRaster)): variables['%s_min' % name] = "Minimum value of %s" % desc variables['%s_max' % name] = "Maximum value of %s" % desc variables['%s_avg' % name] = "Mean value of %s" % desc variables['%s_stddev' % name] = "Standard deviation of %s" % desc for variable, desc in variables.items(): dlg.expressionBuilder().registerItem("Modeler", variable, "@" + variable, desc, highlightedItem=True) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): self.setValue(dlg.expressionText())
def showExpressionsBuilder(self): context = self.param.expressionContext() dlg = QgsExpressionBuilderDialog(None, str(self.leText.text()), self, 'generic', context) context.popScope() values = self.modelParametersDialog.getAvailableValuesOfType(ParameterNumber, OutputNumber) variables = {} for value in values: if isinstance(value, ValueFromInput): name = value.name element = self.modelParametersDialog.model.inputs[name].param desc = element.description else: name = "%s_%s" % (value.alg, value.output) alg = self.modelParametersDialog.model.algs[value.alg] out = alg.algorithm.getOutputFromName(value.output) desc = self.tr("Output '{0}' from algorithm '{1}'").format(out.description, alg.description) variables[name] = desc values = self.modelParametersDialog.getAvailableValuesOfType(ParameterVector, OutputVector) values.extend(self.modelParametersDialog.getAvailableValuesOfType(ParameterRaster, OutputRaster)) for value in values: if isinstance(value, ValueFromInput): name = value.name element = self.modelParametersDialog.model.inputs[name].param desc = element.description else: name = "%s_%s" % (value.alg, value.output) alg = self.modelParametersDialog.model.algs[value.alg] element = alg.algorithm.getOutputFromName(value.output) desc = self.tr("Output '{0}' from algorithm '{1}'").format(element.description, alg.description) variables['%s_minx' % name] = self.tr("Minimum X of {0}").format(desc) variables['%s_miny' % name] = self.tr("Minimum Y of {0}").format(desc) variables['%s_maxx' % name] = self.tr("Maximum X of {0}").format(desc) variables['%s_maxy' % name] = self.tr("Maximum Y of {0}").format(desc) if isinstance(element, (ParameterRaster, OutputRaster)): variables['%s_min' % name] = self.tr("Minimum value of {0}").format(desc) variables['%s_max' % name] = self.tr("Maximum value of {0}").format(desc) variables['%s_avg' % name] = self.tr("Mean value of {0}").format(desc) variables['%s_stddev' % name] = self.tr("Standard deviation of {0}").format(desc) for variable, desc in variables.items(): dlg.expressionBuilder().registerItem("Modeler", variable, "@" + variable, desc, highlightedItem=True) dlg.setWindowTitle(self.tr('Expression based input')) if dlg.exec_() == QDialog.Accepted: exp = QgsExpression(dlg.expressionText()) if not exp.hasParserError(): self.setValue(dlg.expressionText())
def on_mAtlasFeatureFilterButton_clicked(self): atlasMap = self.mComposition.atlasComposition() vl = self.mAtlasCoverageLayerComboBox.currentLayer() if (not atlasMap or not vl): return # QScopedPointer<QgsExpressionContext> context( mComposition.createExpressionContext() ); exprDlg = QgsExpressionBuilderDialog( vl, self.mAtlasFeatureFilterEdit.text(), self, "generic") exprDlg.setWindowTitle("Expression based filter") if (exprDlg.exec_() == QtGui.QDialog.Accepted): expression = exprDlg.expressionText() if (not expression.isEmpty()): self.mAtlasFeatureFilterEdit.setText(expression) atlasMap.setFeatureFilter(self.mAtlasFeatureFilterEdit.text()) self.updateAtlasFeatures()
class ExpressionFieldCombo(FieldCombo): def __init__(self, widget, expressionWidget, vectorLayerCombo, initField="", options={}): FieldCombo.__init__(self, widget, vectorLayerCombo, initField, options) expressionWidget.clicked.connect(self.editExpression) self.windowTitle = "Expression based label" def editExpression(self): expr = "" if self.widget.currentIndex() >= self.nFields: expr = self.widget.currentText() self.exprDlg = QgsExpressionBuilderDialog(self.layer, expr) self.exprDlg.setWindowTitle(self.windowTitle) if self.exprDlg.exec_() == QDialog.Accepted: expression = self.exprDlg.expressionText() self.addExpression(expression) def getExpression(self): if self.widget.currentIndex() < 0: return None, None if self.widget.currentIndex() <= self.nFields - 1: return self.getFieldName(), False else: return self.widget.currentText(), True def setExpression(self, expr): if self.setField(expr) != -1: return self.addExpression(expr) def addExpression(self, expr): # Only add the expression if the user has entered some text. if expr != "": self.widget.addItem(expr) self.widget.setCurrentIndex(self.widget.count() - 1)
class ExpressionFieldCombo(FieldCombo): def __init__(self, widget, expressionWidget, vectorLayerCombo, initField="", options={}): FieldCombo.__init__(self, widget, vectorLayerCombo, initField, options) expressionWidget.clicked.connect(self.editExpression) self.windowTitle = "Expression based label" def editExpression(self): expr = "" if self.widget.currentIndex() >= self.nFields: expr = self.widget.currentText() self.exprDlg = QgsExpressionBuilderDialog(self.layer, expr) self.exprDlg.setWindowTitle(self.windowTitle) if self.exprDlg.exec_() == QDialog.Accepted: expression = self.exprDlg.expressionText() self.addExpression(expression) def getExpression(self): if self.widget.currentIndex() < 0: return None,None if self.widget.currentIndex() <= self.nFields-1: return self.getFieldName(), False else: return self.widget.currentText(), True def setExpression(self, expr): if self.setField(expr) != -1: return self.addExpression(expr) def addExpression(self, expr): # Only add the expression if the user has entered some text. if expr != "": self.widget.addItem(expr) self.widget.setCurrentIndex(self.widget.count() - 1)
def on_mAtlasFilenameExpressionButton_clicked(self): atlasMap = self.mComposition.atlasComposition() if (not atlasMap or not atlasMap.coverageLayer()): return # QScopedPointer<QgsExpressionContext> context( mComposition.createExpressionContext() ); exprDlg = QgsExpressionBuilderDialog( atlasMap.coverageLayer(), self.mAtlasFilenamePatternEdit.text(), self, "generic") exprDlg.setWindowTitle("Expression based filename") if (exprDlg.exec_() == QtGui.QDialog.Accepted): expression = exprDlg.expressionText() if (not expression.isEmpty()): # //set atlas filename expression self.mAtlasFilenamePatternEdit.setText(expression) if (not atlasMap.setFilenamePattern(expression)): # //expression could not be set QMessageBox.warning( self, "Could not evaluate filename pattern", QString( "Could not set filename pattern as '%1'.\nParser error:\n%2" ).arg(expression, atlasMap.filenamePatternErrorString()))
def add_expression_newvalue(self): dlg = QgsExpressionBuilderDialog(self.layer, "Set expression for new value", self) text = self.newValueText.text() dlg.setExpressionText(text) if dlg.exec_(): self.newValueText.setText(dlg.expressionText())
def show_builder(self): dlg = QgsExpressionBuilderDialog(None) if dlg.exec_(): self.namingText.setText(dlg.expressionText())
def add_expression_condition(self): dlg = QgsExpressionBuilderDialog(self.layer, "Set condition expression", self) text = self.condtionText.text() dlg.setExpressionText(text) if dlg.exec_(): self.condtionText.setText(dlg.expressionText())
def buildHighlight(self): dialog = QgsExpressionBuilderDialog(self.collection().layer('lines')) dialog.setExpressionText(self.collection().highlight) if (dialog.exec_()): self.applyHighlight(dialog.expressionText())
def populateByExpression(self, adding=False): """ Populates the panel using an expression """ context = dataobjects.createContext() expression_context = context.expressionContext() # use the first row parameter values as a preview during expression creation params, ok = self.panel.parametersForRow(0, warnOnInvalid=False) alg_scope = QgsExpressionContextUtils.processingAlgorithmScope( self.panel.alg, params, context) # create explicit variables corresponding to every parameter for k, v in params.items(): alg_scope.setVariable(k, v, True) # add batchCount in the alg scope to be used in the expressions. 0 is only an example value alg_scope.setVariable('row_number', 0, False) expression_context.appendScope(alg_scope) # mark the parameter variables as highlighted for discoverability highlighted_vars = expression_context.highlightedVariables() highlighted_vars.extend(list(params.keys())) highlighted_vars.append('row_number') expression_context.setHighlightedVariables(highlighted_vars) dlg = QgsExpressionBuilderDialog(layer=None, context=context.expressionContext()) if adding: dlg.setExpectedOutputFormat( self.tr( 'An array of values corresponding to each new row to add')) if not dlg.exec_(): return if adding: exp = QgsExpression(dlg.expressionText()) res = exp.evaluate(expression_context) if type(res) is not list: res = [res] first_row = self.panel.batchRowCount( ) if self.panel.batchRowCount() > 1 else 0 self.panel.addRow(len(res)) self.panel.tblParameters.setUpdatesEnabled(False) for row, value in enumerate(res): self.setRowValue(row + first_row, value, context) self.panel.tblParameters.setUpdatesEnabled(True) else: self.panel.tblParameters.setUpdatesEnabled(False) for row in range(self.panel.batchRowCount()): params, ok = self.panel.parametersForRow(row, warnOnInvalid=False) # remove previous algorithm scope -- we need to rebuild this completely, using the # other parameter values from the current row expression_context.popScope() alg_scope = QgsExpressionContextUtils.processingAlgorithmScope( self.panel.alg, params, context) for k, v in params.items(): alg_scope.setVariable(k, v, True) # add batch row number as evaluable variable in algorithm scope alg_scope.setVariable('row_number', row, False) expression_context.appendScope(alg_scope) # rebuild a new expression every time -- we don't want the expression compiler to replace # variables with precompiled values exp = QgsExpression(dlg.expressionText()) value = exp.evaluate(expression_context) self.setRowValue(row, value, context) self.panel.tblParameters.setUpdatesEnabled(True)
def showExpressionsBuilder(self): dlg = QgsExpressionBuilderDialog(None, self.leText.text(), self, 'generic', self.output.expressionContext(self.alg)) dlg.setWindowTitle(self.tr('Expression based output')) if dlg.exec_() == QDialog.Accepted: self.leText.setText(dlg.expressionText())
def buildSelection(self): dialog = QgsExpressionBuilderDialog(self.collection().layer('lines')) dialog.setExpressionText(self.collection().selection) if (dialog.exec_()): self.applySelection(dialog.expressionText())