mirror of
https://github.com/qgis/QGIS.git
synced 2025-02-27 00:33:48 -05:00
ec40199862
The file qgsexpressions.h has grown to one monolithic piece over the years. This makes it hard to maintain and slows down compilation because even small changes at one end will result in recompiling big parts of the source tree. It also requires the compiler to keep track of all these implementation details for said big parts of the source tree. This splits this implementation into smaller pieces. There are soe API changes connected to this, but since these can be considered implementation details, on which not many plugins rely, this shouldn't have a big impact on the ecosystem outside the source tree.
883 lines
28 KiB
Plaintext
883 lines
28 KiB
Plaintext
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsexpressioncontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|
|
|
|
|
|
|
|
|
|
class QgsScopedExpressionFunction : QgsExpressionFunction
|
|
{
|
|
%Docstring
|
|
Expression function for use within a QgsExpressionContextScope. This differs from a
|
|
standard QgsExpression.Function in that it requires an implemented
|
|
clone() method.
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressioncontext.h"
|
|
%End
|
|
public:
|
|
|
|
QgsScopedExpressionFunction( const QString &fnname,
|
|
int params,
|
|
const QString &group,
|
|
const QString &helpText = QString(),
|
|
bool usesGeometry = false,
|
|
const QSet<QString> &referencedColumns = QSet<QString>(),
|
|
bool lazyEval = false,
|
|
bool handlesNull = false,
|
|
bool isContextual = true );
|
|
%Docstring
|
|
Create a new QgsScopedExpressionFunction
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
QgsScopedExpressionFunction( const QString &fnname,
|
|
const QgsExpressionFunction::ParameterList ¶ms,
|
|
const QString &group,
|
|
const QString &helpText = QString(),
|
|
bool usesGeometry = false,
|
|
const QSet<QString> &referencedColumns = QSet<QString>(),
|
|
bool lazyEval = false,
|
|
bool handlesNull = false,
|
|
bool isContextual = true );
|
|
%Docstring
|
|
Create a new QgsScopedExpressionFunction using named parameters.
|
|
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
virtual QVariant func( const QVariantList &values, const QgsExpressionContext *context, QgsExpression *parent ) = 0;
|
|
|
|
virtual QgsScopedExpressionFunction *clone() const = 0 /Factory/;
|
|
%Docstring
|
|
Returns a clone of the function.
|
|
:rtype: QgsScopedExpressionFunction
|
|
%End
|
|
|
|
virtual bool usesGeometry( const QgsExpressionNodeFunction *node ) const;
|
|
|
|
virtual QSet<QString> referencedColumns( const QgsExpressionNodeFunction *node ) const;
|
|
|
|
virtual bool isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
class QgsExpressionContextScope
|
|
{
|
|
%Docstring
|
|
Single scope for storing variables and functions for use within a QgsExpressionContext.
|
|
Examples include a project's scope, which could contain information about the current project such as
|
|
the project file's location. QgsExpressionContextScope can encapsulate both variables (static values)
|
|
and functions(which are calculated only when an expression is evaluated).
|
|
|
|
See QgsExpressionContextUtils for helper methods for working with QgsExpressionContextScope objects.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressioncontext.h"
|
|
%End
|
|
public:
|
|
|
|
struct StaticVariable
|
|
{
|
|
|
|
StaticVariable( const QString &name = QString(), const QVariant &value = QVariant(), bool readOnly = false, bool isStatic = false );
|
|
%Docstring
|
|
Constructor for StaticVariable.
|
|
\param name variable name (should be unique within the QgsExpressionContextScope)
|
|
\param value initial variable value
|
|
\param readOnly true if variable should not be editable by users
|
|
\param isStatic true if the variable will not change during the lifteime of an iterator.
|
|
%End
|
|
|
|
QString name;
|
|
%Docstring
|
|
Variable name
|
|
%End
|
|
|
|
QVariant value;
|
|
%Docstring
|
|
Variable value
|
|
%End
|
|
|
|
bool readOnly;
|
|
%Docstring
|
|
True if variable should not be editable by users
|
|
%End
|
|
|
|
bool isStatic;
|
|
%Docstring
|
|
A static variable can be cached for the lifetime of a context
|
|
%End
|
|
};
|
|
|
|
QgsExpressionContextScope( const QString &name = QString() );
|
|
%Docstring
|
|
Constructor for QgsExpressionContextScope
|
|
\param name friendly display name for the context scope
|
|
%End
|
|
|
|
QgsExpressionContextScope( const QgsExpressionContextScope &other );
|
|
%Docstring
|
|
Copy constructor
|
|
%End
|
|
|
|
|
|
~QgsExpressionContextScope();
|
|
|
|
QString name() const;
|
|
%Docstring
|
|
Returns the friendly display name of the context scope.
|
|
:rtype: str
|
|
%End
|
|
|
|
void setVariable( const QString &name, const QVariant &value, bool isStatic = false );
|
|
%Docstring
|
|
Convenience method for setting a variable in the context scope by ``name`` name and ``value``. If a variable
|
|
with the same name is already set then its value is overwritten, otherwise a new variable is added to the scope.
|
|
If the ``isStatic`` parameter is set to true, this variable can be cached during the execution
|
|
of QgsExpression.prepare().
|
|
.. seealso:: addVariable()
|
|
%End
|
|
|
|
void addVariable( const QgsExpressionContextScope::StaticVariable &variable );
|
|
%Docstring
|
|
Adds a variable into the context scope. If a variable with the same name is already set then its
|
|
value is overwritten, otherwise a new variable is added to the scope.
|
|
\param variable definition of variable to insert
|
|
.. seealso:: setVariable()
|
|
.. seealso:: addFunction()
|
|
%End
|
|
|
|
bool removeVariable( const QString &name );
|
|
%Docstring
|
|
Removes a variable from the context scope, if found.
|
|
\param name name of variable to remove
|
|
:return: true if variable was removed from the scope, false if matching variable was not
|
|
found within the scope
|
|
:rtype: bool
|
|
%End
|
|
|
|
bool hasVariable( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether a variable with the specified name exists in the scope.
|
|
\param name variable name
|
|
:return: true if matching variable was found in the scope
|
|
.. seealso:: variable()
|
|
.. seealso:: hasFunction()
|
|
:rtype: bool
|
|
%End
|
|
|
|
QVariant variable( const QString &name ) const;
|
|
%Docstring
|
|
Retrieves a variable's value from the scope.
|
|
\param name variable name
|
|
:return: variable value, or invalid QVariant if matching variable could not be found
|
|
.. seealso:: hasVariable()
|
|
.. seealso:: function()
|
|
:rtype: QVariant
|
|
%End
|
|
|
|
QStringList variableNames() const;
|
|
%Docstring
|
|
Returns a list of variable names contained within the scope.
|
|
.. seealso:: functionNames()
|
|
.. seealso:: filteredVariableNames()
|
|
:rtype: list of str
|
|
%End
|
|
|
|
QStringList filteredVariableNames() const;
|
|
%Docstring
|
|
Returns a filtered and sorted list of variable names contained within the scope.
|
|
Hidden variable names will be excluded, and the list will be sorted so that
|
|
read only variables are listed first.
|
|
.. seealso:: variableNames()
|
|
:rtype: list of str
|
|
%End
|
|
|
|
bool isReadOnly( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether the specified variable is read only and should not be editable
|
|
by users.
|
|
\param name variable name
|
|
:return: true if variable is read only
|
|
:rtype: bool
|
|
%End
|
|
|
|
bool isStatic( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether the variable with the specified ``name`` is static and can
|
|
be cached.
|
|
|
|
.. versionadded:: 3.0
|
|
:rtype: bool
|
|
%End
|
|
|
|
int variableCount() const;
|
|
%Docstring
|
|
Returns the count of variables contained within the scope.
|
|
:rtype: int
|
|
%End
|
|
|
|
bool hasFunction( const QString &name ) const;
|
|
%Docstring
|
|
Tests whether a function with the specified name exists in the scope.
|
|
\param name function name
|
|
:return: true if matching function was found in the scope
|
|
.. seealso:: function()
|
|
.. seealso:: hasFunction()
|
|
:rtype: bool
|
|
%End
|
|
|
|
QgsExpressionFunction *function( const QString &name ) const;
|
|
%Docstring
|
|
Retrieves a function from the scope.
|
|
\param name function name
|
|
:return: function, or null if matching function could not be found
|
|
.. seealso:: hasFunction()
|
|
.. seealso:: functionNames()
|
|
.. seealso:: variable()
|
|
:rtype: QgsExpressionFunction
|
|
%End
|
|
|
|
QStringList functionNames() const;
|
|
%Docstring
|
|
Retrieves a list of names of functions contained in the scope.
|
|
.. seealso:: function()
|
|
.. seealso:: variableNames()
|
|
:rtype: list of str
|
|
%End
|
|
|
|
void addFunction( const QString &name, QgsScopedExpressionFunction *function /Transfer/ );
|
|
%Docstring
|
|
Adds a function to the scope.
|
|
\param name function name
|
|
\param function function to insert. Ownership is transferred to the scope.
|
|
.. seealso:: addVariable()
|
|
%End
|
|
|
|
bool hasFeature() const;
|
|
%Docstring
|
|
Returns true if the scope has a feature associated with it.
|
|
.. versionadded:: 3.0
|
|
.. seealso:: feature()
|
|
:rtype: bool
|
|
%End
|
|
|
|
QgsFeature feature() const;
|
|
%Docstring
|
|
Sets the feature associated with the scope.
|
|
.. seealso:: setFeature()
|
|
.. seealso:: hasFeature()
|
|
.. versionadded:: 3.0
|
|
:rtype: QgsFeature
|
|
%End
|
|
|
|
void setFeature( const QgsFeature &feature );
|
|
%Docstring
|
|
Convenience function for setting a feature for the scope. Any existing
|
|
feature set by the scope will be overwritten.
|
|
\param feature feature for scope
|
|
.. seealso:: removeFeature()
|
|
.. seealso:: feature()
|
|
%End
|
|
|
|
void removeFeature();
|
|
%Docstring
|
|
Removes any feature associated with the scope.
|
|
.. versionadded:: 3.0
|
|
.. seealso:: setFeature()
|
|
.. seealso:: hasFeature()
|
|
%End
|
|
|
|
void setFields( const QgsFields &fields );
|
|
%Docstring
|
|
Convenience function for setting a fields for the scope. Any existing
|
|
fields set by the scope will be overwritten.
|
|
\param fields fields for scope
|
|
%End
|
|
|
|
};
|
|
|
|
class QgsExpressionContext
|
|
{
|
|
%Docstring
|
|
Expression contexts are used to encapsulate the parameters around which a QgsExpression should
|
|
be evaluated. QgsExpressions can then utilize the information stored within a context to contextualise
|
|
their evaluated result. A QgsExpressionContext consists of a stack of QgsExpressionContextScope objects,
|
|
where scopes added later to the stack will override conflicting variables and functions from scopes
|
|
lower in the stack.
|
|
|
|
See QgsExpressionContextUtils for helper methods for working with QgsExpressionContext objects.
|
|
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressioncontext.h"
|
|
%End
|
|
public:
|
|
|
|
QgsExpressionContext();
|
|
|
|
explicit QgsExpressionContext( const QList<QgsExpressionContextScope *> &scopes /Transfer/ );
|
|
%Docstring
|
|
Initializes the context with given list of scopes.
|
|
Ownership of the scopes is transferred to the stack.
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsExpressionContext( const QgsExpressionContext &other );
|
|
%Docstring
|
|
Copy constructor
|
|
%End
|
|
|
|
|
|
|
|
~QgsExpressionContext();
|
|
|
|
bool hasVariable( const QString &name ) const;
|
|
%Docstring
|
|
Check whether a variable is specified by any scope within the context.
|
|
\param name variable name
|
|
:return: true if variable is set
|
|
.. seealso:: variable()
|
|
.. seealso:: variableNames()
|
|
:rtype: bool
|
|
%End
|
|
|
|
QVariant variable( const QString &name ) const;
|
|
%Docstring
|
|
Fetches a matching variable from the context. The variable will be fetched
|
|
from the last scope contained within the context which has a matching
|
|
variable set.
|
|
\param name variable name
|
|
:return: variable value if matching variable exists in the context, otherwise an invalid QVariant
|
|
.. seealso:: hasVariable()
|
|
.. seealso:: variableNames()
|
|
:rtype: QVariant
|
|
%End
|
|
|
|
QVariantMap variablesToMap() const;
|
|
%Docstring
|
|
Returns a map of variable name to value representing all the expression variables
|
|
contained by the context.
|
|
.. versionadded:: 3.0
|
|
:rtype: QVariantMap
|
|
%End
|
|
|
|
bool isHighlightedVariable( const QString &name ) const;
|
|
%Docstring
|
|
Returns true if the specified variable name is intended to be highlighted to the
|
|
user. This is used by the expression builder to more prominently display the
|
|
variable.
|
|
\param name variable name
|
|
.. seealso:: setHighlightedVariables()
|
|
:rtype: bool
|
|
%End
|
|
|
|
void setHighlightedVariables( const QStringList &variableNames );
|
|
%Docstring
|
|
Sets the list of variable names within the context intended to be highlighted to the user. This
|
|
is used by the expression builder to more prominently display these variables.
|
|
\param variableNames variable names to highlight
|
|
.. seealso:: isHighlightedVariable()
|
|
%End
|
|
|
|
QgsExpressionContextScope *activeScopeForVariable( const QString &name );
|
|
%Docstring
|
|
Returns the currently active scope from the context for a specified variable name.
|
|
As scopes later in the stack override earlier contexts, this will be the last matching
|
|
scope which contains a matching variable.
|
|
\param name variable name
|
|
:return: matching scope containing variable, or null if none found
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
|
|
QgsExpressionContextScope *scope( int index );
|
|
%Docstring
|
|
Returns the scope at the specified index within the context.
|
|
\param index index of scope
|
|
:return: matching scope, or null if none found
|
|
.. seealso:: lastScope()
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
QgsExpressionContextScope *lastScope();
|
|
%Docstring
|
|
Returns the last scope added to the context.
|
|
.. seealso:: scope()
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
QList< QgsExpressionContextScope * > scopes();
|
|
%Docstring
|
|
Returns a list of scopes contained within the stack.
|
|
:return: list of pointers to scopes
|
|
:rtype: list of QgsExpressionContextScope
|
|
%End
|
|
|
|
int indexOfScope( QgsExpressionContextScope *scope ) const;
|
|
%Docstring
|
|
Returns the index of the specified scope if it exists within the context.
|
|
\param scope scope to find
|
|
:return: index of scope, or -1 if scope was not found within the context.
|
|
:rtype: int
|
|
%End
|
|
|
|
int indexOfScope( const QString &scopeName ) const;
|
|
%Docstring
|
|
Returns the index of the first scope with a matching name within the context.
|
|
\param scopeName name of scope to find
|
|
:return: index of scope, or -1 if scope was not found within the context.
|
|
.. versionadded:: 3.0
|
|
:rtype: int
|
|
%End
|
|
|
|
QStringList variableNames() const;
|
|
%Docstring
|
|
Returns a list of variables names set by all scopes in the context.
|
|
:return: list of unique variable names
|
|
.. seealso:: filteredVariableNames
|
|
.. seealso:: functionNames
|
|
.. seealso:: hasVariable
|
|
.. seealso:: variable
|
|
:rtype: list of str
|
|
%End
|
|
|
|
QStringList filteredVariableNames() const;
|
|
%Docstring
|
|
Returns a filtered list of variables names set by all scopes in the context. The included
|
|
variables are those which should be seen by users.
|
|
:return: filtered list of unique variable names
|
|
.. seealso:: variableNames
|
|
:rtype: list of str
|
|
%End
|
|
|
|
bool isReadOnly( const QString &name ) const;
|
|
%Docstring
|
|
Returns whether a variable is read only, and should not be modifiable by users.
|
|
\param name variable name
|
|
:return: true if variable is read only. Read only status will be taken from last
|
|
matching scope which contains a matching variable.
|
|
:rtype: bool
|
|
%End
|
|
|
|
bool hasFunction( const QString &name ) const;
|
|
%Docstring
|
|
Checks whether a specified function is contained in the context.
|
|
\param name function name
|
|
:return: true if context provides a matching function
|
|
.. seealso:: function
|
|
:rtype: bool
|
|
%End
|
|
|
|
QStringList functionNames() const;
|
|
%Docstring
|
|
Retrieves a list of function names contained in the context.
|
|
.. seealso:: function()
|
|
.. seealso:: variableNames()
|
|
:rtype: list of str
|
|
%End
|
|
|
|
QgsExpressionFunction *function( const QString &name ) const;
|
|
%Docstring
|
|
Fetches a matching function from the context. The function will be fetched
|
|
from the last scope contained within the context which has a matching
|
|
function set.
|
|
\param name function name
|
|
:return: function if contained by the context, otherwise null.
|
|
.. seealso:: hasFunction
|
|
:rtype: QgsExpressionFunction
|
|
%End
|
|
|
|
int scopeCount() const;
|
|
%Docstring
|
|
Returns the number of scopes contained in the context.
|
|
:rtype: int
|
|
%End
|
|
|
|
void appendScope( QgsExpressionContextScope *scope /Transfer/ );
|
|
%Docstring
|
|
Appends a scope to the end of the context. This scope will override
|
|
any matching variables or functions provided by existing scopes within the
|
|
context. Ownership of the scope is transferred to the stack.
|
|
\param scope expression context to append to context
|
|
%End
|
|
|
|
void appendScopes( const QList<QgsExpressionContextScope *> &scopes /Transfer/ );
|
|
%Docstring
|
|
Appends a list of scopes to the end of the context. This scopes will override
|
|
any matching variables or functions provided by existing scopes within the
|
|
context. Ownership of the scopes is transferred to the stack.
|
|
\param scopes scopes to append to context
|
|
.. versionadded:: 3.0
|
|
%End
|
|
|
|
QgsExpressionContextScope *popScope();
|
|
%Docstring
|
|
Removes the last scope from the expression context and return it.
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
|
|
void setFeature( const QgsFeature &feature );
|
|
%Docstring
|
|
Convenience function for setting a feature for the context. The feature
|
|
will be set within the last scope of the context, so will override any
|
|
existing features within the context.
|
|
\param feature feature for context
|
|
.. seealso:: feature()
|
|
%End
|
|
|
|
bool hasFeature() const;
|
|
%Docstring
|
|
Returns true if the context has a feature associated with it.
|
|
.. versionadded:: 3.0
|
|
.. seealso:: feature()
|
|
:rtype: bool
|
|
%End
|
|
|
|
QgsFeature feature() const;
|
|
%Docstring
|
|
Convenience function for retrieving the feature for the context, if set.
|
|
.. seealso:: setFeature
|
|
:rtype: QgsFeature
|
|
%End
|
|
|
|
void setFields( const QgsFields &fields );
|
|
%Docstring
|
|
Convenience function for setting a fields for the context. The fields
|
|
will be set within the last scope of the context, so will override any
|
|
existing fields within the context.
|
|
\param fields fields for context
|
|
.. seealso:: fields()
|
|
%End
|
|
|
|
QgsFields fields() const;
|
|
%Docstring
|
|
Convenience function for retrieving the fields for the context, if set.
|
|
.. seealso:: setFields
|
|
:rtype: QgsFields
|
|
%End
|
|
|
|
void setOriginalValueVariable( const QVariant &value );
|
|
%Docstring
|
|
Sets the original value variable value for the context.
|
|
\param value value for original value variable. This usually represents the an original widget
|
|
value before any data defined overrides have been applied.
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
void setCachedValue( const QString &key, const QVariant &value ) const;
|
|
%Docstring
|
|
Sets a value to cache within the expression context. This can be used to cache the results
|
|
of expensive expression sub-calculations, to speed up future evaluations using the same
|
|
expression context.
|
|
\param key unique key for retrieving cached value
|
|
\param value value to cache
|
|
.. seealso:: hasCachedValue()
|
|
.. seealso:: cachedValue()
|
|
.. seealso:: clearCachedValues()
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
bool hasCachedValue( const QString &key ) const;
|
|
%Docstring
|
|
Returns true if the expression context contains a cached value with a matching key.
|
|
\param key unique key used to store cached value
|
|
.. seealso:: setCachedValue()
|
|
.. seealso:: cachedValue()
|
|
.. seealso:: clearCachedValues()
|
|
.. versionadded:: 2.16
|
|
:rtype: bool
|
|
%End
|
|
|
|
QVariant cachedValue( const QString &key ) const;
|
|
%Docstring
|
|
Returns the matching cached value, if set. This can be used to retrieve the previously stored results
|
|
of an expensive expression sub-calculation.
|
|
\param key unique key used to store cached value
|
|
:return: matching cached value, or invalid QVariant if not set
|
|
.. seealso:: setCachedValue()
|
|
.. seealso:: hasCachedValue()
|
|
.. seealso:: clearCachedValues()
|
|
.. versionadded:: 2.16
|
|
:rtype: QVariant
|
|
%End
|
|
|
|
void clearCachedValues() const;
|
|
%Docstring
|
|
Clears all cached values from the context.
|
|
.. seealso:: setCachedValue()
|
|
.. seealso:: hasCachedValue()
|
|
.. seealso:: cachedValue()
|
|
.. versionadded:: 2.16
|
|
%End
|
|
|
|
static const QString EXPR_FIELDS;
|
|
%Docstring
|
|
Inbuilt variable name for fields storage
|
|
%End
|
|
static const QString EXPR_ORIGINAL_VALUE;
|
|
%Docstring
|
|
Inbuilt variable name for value original value variable
|
|
%End
|
|
static const QString EXPR_SYMBOL_COLOR;
|
|
%Docstring
|
|
Inbuilt variable name for symbol color variable
|
|
%End
|
|
static const QString EXPR_SYMBOL_ANGLE;
|
|
%Docstring
|
|
Inbuilt variable name for symbol angle variable
|
|
%End
|
|
static const QString EXPR_GEOMETRY_PART_COUNT;
|
|
%Docstring
|
|
Inbuilt variable name for geometry part count variable
|
|
%End
|
|
static const QString EXPR_GEOMETRY_PART_NUM;
|
|
%Docstring
|
|
Inbuilt variable name for geometry part number variable
|
|
%End
|
|
static const QString EXPR_GEOMETRY_POINT_COUNT;
|
|
%Docstring
|
|
Inbuilt variable name for point count variable
|
|
%End
|
|
static const QString EXPR_GEOMETRY_POINT_NUM;
|
|
%Docstring
|
|
Inbuilt variable name for point number variable
|
|
%End
|
|
static const QString EXPR_CLUSTER_SIZE;
|
|
%Docstring
|
|
Inbuilt variable name for cluster size variable
|
|
%End
|
|
static const QString EXPR_CLUSTER_COLOR;
|
|
%Docstring
|
|
Inbuilt variable name for cluster color variable
|
|
%End
|
|
|
|
};
|
|
|
|
|
|
class QgsExpressionContextUtils
|
|
{
|
|
%Docstring
|
|
Contains utilities for working with QgsExpressionContext objects, including methods
|
|
for creating scopes for specific uses (e.g., project scopes, layer scopes).
|
|
.. versionadded:: 2.12
|
|
%End
|
|
|
|
%TypeHeaderCode
|
|
#include "qgsexpressioncontext.h"
|
|
%End
|
|
public:
|
|
|
|
static QgsExpressionContextScope *globalScope() /Factory/;
|
|
%Docstring
|
|
Creates a new scope which contains variables and functions relating to the global QGIS context.
|
|
For instance, QGIS version numbers and variables specified through QGIS options.
|
|
.. seealso:: setGlobalVariable()
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static void setGlobalVariable( const QString &name, const QVariant &value );
|
|
%Docstring
|
|
Sets a global context variable. This variable will be contained within scopes retrieved via
|
|
globalScope().
|
|
\param name variable name
|
|
\param value variable value
|
|
.. seealso:: setGlobalVariable()
|
|
.. seealso:: globalScope()
|
|
%End
|
|
|
|
static void setGlobalVariables( const QVariantMap &variables );
|
|
%Docstring
|
|
Sets all global context variables. Existing global variables will be removed and replaced
|
|
with the variables specified.
|
|
\param variables new set of global variables
|
|
.. seealso:: setGlobalVariable()
|
|
.. seealso:: globalScope()
|
|
%End
|
|
|
|
static QgsExpressionContextScope *projectScope( const QgsProject *project ) /Factory/;
|
|
%Docstring
|
|
Creates a new scope which contains variables and functions relating to a QGIS project.
|
|
For instance, project path and title, and variables specified through the project properties.
|
|
\param project What project to use
|
|
.. seealso:: setProjectVariable()
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static void setProjectVariable( QgsProject *project, const QString &name, const QVariant &value );
|
|
%Docstring
|
|
Sets a project context variable. This variable will be contained within scopes retrieved via
|
|
projectScope().
|
|
\param project Project to apply changes to
|
|
\param name variable name
|
|
\param value variable value
|
|
.. seealso:: setProjectVariables()
|
|
.. seealso:: projectScope()
|
|
%End
|
|
|
|
static void setProjectVariables( QgsProject *project, const QVariantMap &variables );
|
|
%Docstring
|
|
Sets all project context variables. Existing project variables will be removed and replaced
|
|
with the variables specified.
|
|
\param project Project to apply changes to
|
|
\param variables new set of project variables
|
|
.. seealso:: setProjectVariable()
|
|
.. seealso:: projectScope()
|
|
%End
|
|
|
|
static QgsExpressionContextScope *layerScope( const QgsMapLayer *layer ) /Factory/;
|
|
%Docstring
|
|
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
|
|
For instance, layer name, id and fields.
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static QList<QgsExpressionContextScope *> globalProjectLayerScopes( const QgsMapLayer *layer ) /Factory/;
|
|
%Docstring
|
|
Creates a list of three scopes: global, layer's project and layer.
|
|
.. versionadded:: 3.0
|
|
:rtype: list of QgsExpressionContextScope
|
|
%End
|
|
|
|
static void setLayerVariable( QgsMapLayer *layer, const QString &name, const QVariant &value );
|
|
%Docstring
|
|
Sets a layer context variable. This variable will be contained within scopes retrieved via
|
|
layerScope().
|
|
\param layer map layer
|
|
\param name variable name
|
|
\param value variable value
|
|
.. seealso:: setLayerVariables()
|
|
.. seealso:: layerScope()
|
|
%End
|
|
|
|
static void setLayerVariables( QgsMapLayer *layer, const QVariantMap &variables );
|
|
%Docstring
|
|
Sets all layer context variables. Existing layer variables will be removed and replaced
|
|
with the variables specified.
|
|
\param layer map layer
|
|
\param variables new set of layer variables
|
|
.. seealso:: setLayerVariable()
|
|
.. seealso:: layerScope()
|
|
%End
|
|
|
|
static QgsExpressionContextScope *mapSettingsScope( const QgsMapSettings &mapSettings ) /Factory/;
|
|
%Docstring
|
|
Creates a new scope which contains variables and functions relating to a QgsMapSettings object.
|
|
For instance, map scale and rotation.
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static QgsExpressionContextScope *updateSymbolScope( const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope = 0 );
|
|
%Docstring
|
|
Updates a symbol scope related to a QgsSymbol to an expression context.
|
|
\param symbol symbol to extract properties from
|
|
\param symbolScope pointer to an existing scope to update
|
|
.. versionadded:: 2.14
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static QgsExpressionContextScope *compositionScope( const QgsComposition *composition ) /Factory/;
|
|
%Docstring
|
|
Creates a new scope which contains variables and functions relating to a QgsComposition.
|
|
For instance, number of pages and page sizes.
|
|
\param composition source composition
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static void setCompositionVariable( QgsComposition *composition, const QString &name, const QVariant &value );
|
|
%Docstring
|
|
Sets a composition context variable. This variable will be contained within scopes retrieved via
|
|
compositionScope().
|
|
\param composition target composition
|
|
\param name variable name
|
|
\param value variable value
|
|
.. seealso:: setCompositionVariables()
|
|
.. seealso:: compositionScope()
|
|
%End
|
|
|
|
static void setCompositionVariables( QgsComposition *composition, const QVariantMap &variables );
|
|
%Docstring
|
|
Sets all composition context variables. Existing composition variables will be removed and replaced
|
|
with the variables specified.
|
|
\param composition target composition
|
|
\param variables new set of layer variables
|
|
.. seealso:: setCompositionVariable()
|
|
.. seealso:: compositionScope()
|
|
%End
|
|
|
|
static QgsExpressionContextScope *atlasScope( const QgsAtlasComposition *atlas ) /Factory/;
|
|
%Docstring
|
|
Creates a new scope which contains variables and functions relating to a QgsAtlasComposition.
|
|
For instance, current page name and number.
|
|
\param atlas source atlas. If null, a set of default atlas variables will be added to the scope.
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static QgsExpressionContextScope *composerItemScope( const QgsComposerItem *composerItem ) /Factory/;
|
|
%Docstring
|
|
Creates a new scope which contains variables and functions relating to a QgsComposerItem.
|
|
For instance, item size and position.
|
|
\param composerItem source composer item
|
|
:rtype: QgsExpressionContextScope
|
|
%End
|
|
|
|
static void setComposerItemVariable( QgsComposerItem *composerItem, const QString &name, const QVariant &value );
|
|
%Docstring
|
|
Sets a composer item context variable. This variable will be contained within scopes retrieved via
|
|
composerItemScope().
|
|
\param composerItem target composer item
|
|
\param name variable name
|
|
\param value variable value
|
|
.. seealso:: setComposerItemVariables()
|
|
.. seealso:: composerItemScope()
|
|
%End
|
|
|
|
static void setComposerItemVariables( QgsComposerItem *composerItem, const QVariantMap &variables );
|
|
%Docstring
|
|
Sets all composition context variables. Existing compositoin variables will be removed and replaced
|
|
with the variables specified.
|
|
\param composerItem target composer item
|
|
\param variables new set of layer variables
|
|
.. seealso:: setComposerItemVariable()
|
|
.. seealso:: composerItemScope()
|
|
%End
|
|
|
|
static QgsExpressionContext createFeatureBasedContext( const QgsFeature &feature, const QgsFields &fields );
|
|
%Docstring
|
|
Helper function for creating an expression context which contains just a feature and fields
|
|
collection. Generally this method should not be used as the created context does not include
|
|
standard scopes such as the global and project scopes.
|
|
:rtype: QgsExpressionContext
|
|
%End
|
|
|
|
static void registerContextFunctions();
|
|
%Docstring
|
|
Registers all known core functions provided by QgsExpressionContextScope objects.
|
|
%End
|
|
|
|
};
|
|
|
|
/************************************************************************
|
|
* This file has been generated automatically from *
|
|
* *
|
|
* src/core/qgsexpressioncontext.h *
|
|
* *
|
|
* Do not edit manually ! Edit header and run scripts/sipify.pl again *
|
|
************************************************************************/
|