Python QgsExpressionBuilderDialog.expressionText方法代码示例

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
    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)

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
    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())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
    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())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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()))

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
    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())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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))

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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()))

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
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)

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 def buildSelection(self):
     dialog = QgsExpressionBuilderDialog(self.collection().layer('lines'))
     dialog.setExpressionText(self.collection().selection)
     if (dialog.exec_()):
         self.applySelection(dialog.expressionText())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 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())

# 需要导入模块: from qgis.gui import QgsExpressionBuilderDialog [as 别名]
# 或者: from qgis.gui.QgsExpressionBuilderDialog import expressionText [as 别名]
 def buildHighlight(self):
     dialog = QgsExpressionBuilderDialog(self.collection().layer('lines'))
     dialog.setExpressionText(self.collection().highlight)
     if (dialog.exec_()):
         self.applyHighlight(dialog.expressionText())