-
-
Notifications
You must be signed in to change notification settings - Fork 3k
/
qgsexpressioncontext.sip
956 lines (820 loc) · 30.7 KB
/
qgsexpressioncontext.sip
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
/************************************************************************
* 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, const QString &description = QString() );
%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.
\param description optional translated description of variable, for use in expression builder widgets
%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
QString description;
%Docstring
Translated description of variable, for use within expression builder widgets.
%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
QString description( const QString &name ) const;
%Docstring
Returns the translated description for the variable with the specified ``name``
(if set).
.. versionadded:: 3.0
:rtype: str
%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
QString description( const QString &name ) const;
%Docstring
Returns a translated description string for the variable with specified ``name``.
If no specific description has been provided for the variable, the value from
QgsExpression.variableHelpText() will be returned.
.. versionadded:: 3.0
:rtype: str
%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 *mapToolCaptureScope( const QList<QgsPointLocator::Match> &matches ) /Factory/;
%Docstring
Sets the expression context variables which are available for expressions triggered by
a map tool capture like add feature.
.. versionadded:: 3.0
: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 *layoutScope( const QgsLayout *layout ) /Factory/;
%Docstring
Creates a new scope which contains variables and functions relating to a QgsLayout ``layout``.
For instance, number of pages and page sizes.
.. versionadded:: 3.0
:rtype: QgsExpressionContextScope
%End
static void setLayoutVariable( QgsLayout *layout, const QString &name, const QVariant &value );
%Docstring
Sets a layout context variable. This variable will be contained within scopes retrieved via
layoutScope().
\param layout target layout
\param name variable name
\param value variable value
.. seealso:: setLayoutVariables()
.. seealso:: layoutScope()
.. versionadded:: 3.0
%End
static void setLayoutVariables( QgsLayout *layout, const QVariantMap &variables );
%Docstring
Sets all layout context variables. Existing layout variables will be removed and replaced
with the variables specified.
\param layout target layout
\param variables new set of layer variables
.. seealso:: setLayoutVariable()
.. seealso:: layoutScope()
.. versionadded:: 3.0
%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 QgsExpressionContextScope *processingAlgorithmScope( const QgsProcessingAlgorithm *algorithm, const QVariantMap ¶meters, QgsProcessingContext &context ) /Factory/;
%Docstring
Creates a new scope which contains variables and functions relating to a processing ``algorithm``,
when used with the specified ``parameters`` and ``context``.
For instance, algorithm name and parameter functions.
:rtype: QgsExpressionContextScope
%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 *
************************************************************************/