QGIS API Documentation  3.17.0-Master (a035f434f4)
qgsproperty.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsproperty.cpp
3  ---------------
4  Date : January 2017
5  Copyright : (C) 2017 by Nyall Dawson
6  Email : nyall dot dawson at gmail dot com
7  ***************************************************************************
8  * *
9  * This program is free software; you can redistribute it and/or modify *
10  * it under the terms of the GNU General Public License as published by *
11  * the Free Software Foundation; either version 2 of the License, or *
12  * (at your option) any later version. *
13  * *
14  ***************************************************************************/
15 
16 #include "qgsproperty.h"
17 #include "qgsproperty_p.h"
18 
19 #include "qgslogger.h"
20 #include "qgsexpression.h"
21 #include "qgsfeature.h"
22 #include "qgssymbollayerutils.h"
23 #include "qgscolorramp.h"
24 
25 QgsPropertyDefinition::QgsPropertyDefinition( const QString &name, const QString &description, QgsPropertyDefinition::StandardPropertyTemplate type, const QString &origin, const QString &comment )
26  : mName( name )
27  , mDescription( description )
28  , mStandardType( type )
29  , mOrigin( origin )
30  , mComment( comment )
31 {
32  switch ( mStandardType )
33  {
34  case Boolean:
35  mTypes = DataTypeBoolean;
36  mHelpText = QObject::tr( "bool [<b>1</b>=True|<b>0</b>=False]" );
37  break;
38 
39  case Integer:
40  mTypes = DataTypeNumeric;
41  mHelpText = QObject::tr( "int [≤ 0 ≥]" );
42  break;
43 
44  case IntegerPositive:
45  mTypes = DataTypeNumeric;
46  mHelpText = QObject::tr( "int [≥ 0]" );
47  break;
48 
50  mTypes = DataTypeNumeric;
51  mHelpText = QObject::tr( "int [≥ 1]" );
52  break;
53 
54  case Double:
55  mTypes = DataTypeNumeric;
56  mHelpText = QObject::tr( "double [≤ 0.0 ≥]" );
57  break;
58 
59  case DoublePositive:
60  mTypes = DataTypeNumeric;
61  mHelpText = QObject::tr( "double [≥ 0.0]" );
62  break;
63 
64  case Double0To1:
65  mTypes = DataTypeNumeric;
66  mHelpText = QObject::tr( "double [0.0-1.0]" );
67  break;
68 
69  case Rotation:
70  mTypes = DataTypeNumeric;
71  mHelpText = QObject::tr( "double [0.0-360.0]" );
72  break;
73 
74  case String:
75  mTypes = DataTypeString;
76  mHelpText = QObject::tr( "string of variable length" );
77  break;
78 
79  case Opacity:
80  mTypes = DataTypeNumeric;
81  mHelpText = QObject::tr( "int [0-100]" );
82  break;
83 
84  case RenderUnits:
85  mTypes = DataTypeString;
86  mHelpText = trString() + QStringLiteral( "[<b>MM</b>|<b>MapUnit</b>|<b>Pixel</b>|<b>Point</b>]" );
87  break;
88 
89  case ColorWithAlpha:
90  mTypes = DataTypeString;
91  mHelpText = QObject::tr( "string [<b>r,g,b,a</b>] as int 0-255 or #<b>RRGGBBAA</b> as hex or <b>color</b> as color's name" );
92  break;
93 
94  case ColorNoAlpha:
95  mTypes = DataTypeString;
96  mHelpText = QObject::tr( "string [<b>r,g,b</b>] as int 0-255 or #<b>RRGGBB</b> as hex or <b>color</b> as color's name" );
97  break;
98 
99  case PenJoinStyle:
100  mTypes = DataTypeString;
101  mHelpText = trString() + QStringLiteral( "[<b>bevel</b>|<b>miter</b>|<b>round</b>]" );
102  break;
103 
104  case BlendMode:
105  mTypes = DataTypeString;
106  mHelpText = trString() + QStringLiteral( "[<b>Normal</b>|<b>Lighten</b>|<b>Screen</b>|<b>Dodge</b>|<br>"
107  "<b>Addition</b>|<b>Darken</b>|<b>Multiply</b>|<b>Burn</b>|<b>Overlay</b>|<br>"
108  "<b>SoftLight</b>|<b>HardLight</b>|<b>Difference</b>|<b>Subtract</b>]" );
109  break;
110 
111  case Point:
112  mTypes = DataTypeString;
113  mHelpText = QObject::tr( "double coord [<b>X,Y</b>]" );
114  break;
115 
116  case Size:
117  mTypes = DataTypeNumeric;
118  mHelpText = QObject::tr( "double [≥ 0.0]" );
119  break;
120 
121  case Size2D:
122  mTypes = DataTypeString;
123  mHelpText = QObject::tr( "string of doubles '<b>width,height</b>' or array of doubles <b>[width, height]</b>" );
124  break;
125 
126  case LineStyle:
127  mTypes = DataTypeString;
128  mHelpText = trString() + QStringLiteral( "[<b>no</b>|<b>solid</b>|<b>dash</b>|<b>dot</b>|<b>dash dot</b>|<b>dash dot dot</b>]" );
129  break;
130 
131  case StrokeWidth:
132  mTypes = DataTypeNumeric;
133  mHelpText = QObject::tr( "double [≥ 0.0]" );
134  break;
135 
136  case FillStyle:
137  mTypes = DataTypeString;
138  mHelpText = trString() + QStringLiteral( "[<b>solid</b>|<b>horizontal</b>|<b>vertical</b>|<b>cross</b>|<b>b_diagonal</b>|<b>f_diagonal"
139  "</b>|<b>diagonal_x</b>|<b>dense1</b>|<b>dense2</b>|<b>dense3</b>|<b>dense4</b>|<b>dense5"
140  "</b>|<b>dense6</b>|<b>dense7</b>|<b>no]" );
141  break;
142 
143  case CapStyle:
144  mTypes = DataTypeString;
145  mHelpText = trString() + QStringLiteral( "[<b>square</b>|<b>flat</b>|<b>round</b>]" );
146  break;
147 
148  case HorizontalAnchor:
149  mTypes = DataTypeString;
150  mHelpText = trString() + QStringLiteral( "[<b>left</b>|<b>center</b>|<b>right</b>]" );
151  break;
152 
153  case VerticalAnchor:
154  mTypes = DataTypeString;
155  mHelpText = trString() + QStringLiteral( "[<b>top</b>|<b>center</b>|<b>bottom</b>]" );
156  break;
157 
158  case SvgPath:
159  mTypes = DataTypeString;
160  mHelpText = trString() + QStringLiteral( "[<b>filepath</b>] as<br>"
161  "<b>''</b>=empty|absolute|search-paths-relative|<br>"
162  "project-relative|URL" );
163  break;
164 
165  case Offset:
166  mTypes = DataTypeString;
167  mHelpText = QObject::tr( "string of doubles '<b>x,y</b>' or array of doubles <b>[x, y]</b>" );
168  break;
169 
170  case DateTime:
171  mTypes = DataTypeString;
172  mHelpText = QObject::tr( "DateTime or string representation of a DateTime" );
173  break;
174 
175  case Custom:
176  mTypes = DataTypeString;
177  }
178 }
179 
180 QgsPropertyDefinition::QgsPropertyDefinition( const QString &name, DataType dataType, const QString &description, const QString &helpText, const QString &origin, const QString &comment )
181  : mName( name )
182  , mDescription( description )
183  , mTypes( dataType )
184  , mHelpText( helpText )
185  , mOrigin( origin )
186  , mComment( comment )
187 {}
188 
190 {
191  return mTypes == DataTypeNumeric || mStandardType == Size || mStandardType == StrokeWidth || mStandardType == ColorNoAlpha || mStandardType == ColorWithAlpha
192  || mStandardType == Rotation;
193 }
194 
195 QString QgsPropertyDefinition::trString()
196 {
197  // just something to reduce translation redundancy
198  return QObject::tr( "string " );
199 }
200 
201 //
202 // QgsProperty
203 //
204 
206 {
207  d = new QgsPropertyPrivate();
208 }
209 
210 QgsProperty::~QgsProperty() = default;
211 
212 QgsProperty QgsProperty::fromExpression( const QString &expression, bool isActive )
213 {
214  QgsProperty p;
215  p.setExpressionString( expression );
216  p.setActive( isActive );
217  return p;
218 }
219 
220 QgsProperty QgsProperty::fromField( const QString &fieldName, bool isActive )
221 {
222  QgsProperty p;
223  p.setField( fieldName );
224  p.setActive( isActive );
225  return p;
226 }
227 
228 QgsProperty QgsProperty::fromValue( const QVariant &value, bool isActive )
229 {
230  QgsProperty p;
231  p.setStaticValue( value );
232  p.setActive( isActive );
233  return p;
234 }
235 
236 QgsProperty::QgsProperty( const QgsProperty &other ) //NOLINT
237  : d( other.d )
238 {}
239 
241 {
242  d = other.d;
243  return *this;
244 }
245 
246 bool QgsProperty::operator==( const QgsProperty &other ) const
247 {
248  return d->active == other.d->active
249  && d->type == other.d->type
250  && ( d->type != StaticProperty || d->staticValue == other.d->staticValue )
251  && ( d->type != FieldBasedProperty || d->fieldName == other.d->fieldName )
252  && ( d->type != ExpressionBasedProperty || d->expressionString == other.d->expressionString )
253  && ( ( !d->transformer && !other.d->transformer ) || ( d->transformer && other.d->transformer && d->transformer->toExpression( QString() ) == other.d->transformer->toExpression( QString() ) ) );
254 }
255 
256 bool QgsProperty::operator!=( const QgsProperty &other ) const
257 {
258  return ( !( ( *this ) == other ) );
259 }
260 
262 {
263  return static_cast< Type >( d->type );
264 }
265 
267 {
268  return d->type != InvalidProperty && d->active;
269 }
270 
271 void QgsProperty::setActive( bool active )
272 {
273  d.detach();
274  d->active = active;
275 }
276 
277 void QgsProperty::setStaticValue( const QVariant &value )
278 {
279  d.detach();
280  d->type = StaticProperty;
281  d->staticValue = value;
282 }
283 
284 QVariant QgsProperty::staticValue() const
285 {
286  if ( d->type != StaticProperty )
287  return QVariant();
288 
289  return d->staticValue;
290 }
291 
292 void QgsProperty::setField( const QString &field )
293 {
294  d.detach();
295  d->type = FieldBasedProperty;
296  d->fieldName = field;
297  d->cachedFieldIdx = -1;
298 }
299 
300 QString QgsProperty::field() const
301 {
302  if ( d->type != FieldBasedProperty )
303  return QString();
304 
305  return d->fieldName;
306 }
307 
308 QgsProperty::operator bool() const
309 {
310  return d->type != InvalidProperty;
311 }
312 
313 void QgsProperty::setExpressionString( const QString &expression )
314 {
315  d.detach();
316  d->type = ExpressionBasedProperty;
317  d->expressionString = expression;
318  d->expression = QgsExpression( expression );
319  d->expressionPrepared = false;
320  d->expressionIsInvalid = false;
321 }
322 
324 {
325  if ( d->type != ExpressionBasedProperty )
326  return QString();
327 
328  return d->expressionString;
329 }
330 
331 
333 {
334  QString exp;
335  switch ( d->type )
336  {
337  case StaticProperty:
338  exp = QgsExpression::quotedValue( d->staticValue );
339  break;
340 
341  case FieldBasedProperty:
342  exp = QgsExpression::quotedColumnRef( d->fieldName );
343  break;
344 
346  exp = d->expressionString;
347  break;
348 
349  case InvalidProperty:
350  exp = QString();
351  break;
352  }
353  return d->transformer ? d->transformer->toExpression( exp ) : exp;
354 }
355 
356 bool QgsProperty::prepare( const QgsExpressionContext &context ) const
357 {
358  if ( !d->active )
359  return true;
360 
361  switch ( d->type )
362  {
363  case StaticProperty:
364  return true;
365 
366  case FieldBasedProperty:
367  {
368  d.detach();
369  // cache field index to avoid subsequent lookups
370  QgsFields f = context.fields();
371  d->cachedFieldIdx = f.lookupField( d->fieldName );
372  return true;
373  }
374 
376  {
377  d.detach();
378  if ( !d->expression.prepare( &context ) )
379  {
380  d->expressionReferencedCols.clear();
381  d->expressionPrepared = false;
382  d->expressionIsInvalid = true;
383  return false;
384  }
385 
386  d->expressionPrepared = true;
387  d->expressionIsInvalid = false;
388  d->expressionReferencedCols = d->expression.referencedColumns();
389  return true;
390  }
391 
392  case InvalidProperty:
393  return true;
394 
395  }
396 
397  return false;
398 }
399 
400 QSet<QString> QgsProperty::referencedFields( const QgsExpressionContext &context, bool ignoreContext ) const
401 {
402  if ( !d->active )
403  return QSet<QString>();
404 
405  switch ( d->type )
406  {
407  case StaticProperty:
408  case InvalidProperty:
409  return QSet<QString>();
410 
411  case FieldBasedProperty:
412  {
413  QSet< QString > fields;
414  if ( !d->fieldName.isEmpty() )
415  fields.insert( d->fieldName );
416  return fields;
417  }
418 
420  {
421  if ( ignoreContext )
422  {
423  return d->expression.referencedColumns();
424  }
425 
426  if ( d->expressionIsInvalid )
427  return QSet< QString >();
428 
429  d.detach();
430  if ( !d->expressionPrepared && !prepare( context ) )
431  {
432  d->expressionIsInvalid = true;
433  return QSet< QString >();
434  }
435 
436  return d->expressionReferencedCols;
437  }
438 
439  }
440  return QSet<QString>();
441 }
442 
444 {
445  QRegularExpression rx( QStringLiteral( "^project_color\\('.*'\\)$" ) );
446  return d->type == QgsProperty::ExpressionBasedProperty && !d->expressionString.isEmpty()
447  && rx.match( d->expressionString ).hasMatch();
448 }
449 
450 QVariant QgsProperty::propertyValue( const QgsExpressionContext &context, const QVariant &defaultValue, bool *ok ) const
451 {
452  if ( ok )
453  *ok = false;
454 
455  if ( !d->active )
456  return defaultValue;
457 
458  switch ( d->type )
459  {
460  case StaticProperty:
461  {
462  if ( ok )
463  *ok = true;
464  return d->staticValue;
465  }
466 
467  case FieldBasedProperty:
468  {
469  QgsFeature f = context.feature();
470  if ( !f.isValid() )
471  return defaultValue;
472 
473  //shortcut the field lookup
474  if ( d->cachedFieldIdx >= 0 )
475  {
476  if ( ok )
477  *ok = true;
478  return f.attribute( d->cachedFieldIdx );
479  }
480  prepare( context );
481  if ( d->cachedFieldIdx < 0 )
482  return defaultValue;
483 
484  if ( ok )
485  *ok = true;
486  return f.attribute( d->cachedFieldIdx );
487  }
488 
490  {
491  if ( d->expressionIsInvalid )
492  return defaultValue;
493 
494  if ( !d->expressionPrepared && !prepare( context ) )
495  return defaultValue;
496 
497  QVariant result = d->expression.evaluate( &context );
498  if ( result.isValid() )
499  {
500  if ( ok )
501  *ok = true;
502  return result;
503  }
504  else
505  {
506  return defaultValue;
507  }
508  }
509 
510  case InvalidProperty:
511  return defaultValue;
512 
513  }
514 
515  return QVariant();
516 }
517 
518 
519 QVariant QgsProperty::value( const QgsExpressionContext &context, const QVariant &defaultValue, bool *ok ) const
520 {
521  if ( ok )
522  *ok = false;
523 
524  bool valOk = false;
525  QVariant val = propertyValue( context, defaultValue, &valOk );
526  if ( !d->transformer && !valOk ) // if transformer present, let it handle null values
527  return defaultValue;
528 
529  if ( d->transformer )
530  {
531  if ( !valOk )
532  val = QVariant();
533  val = d->transformer->transform( context, val );
534  }
535 
536  if ( ok )
537  *ok = true;
538 
539  return val;
540 }
541 
542 QDateTime QgsProperty::valueAsDateTime( const QgsExpressionContext &context, const QDateTime &defaultDateTime, bool *ok ) const
543 {
544  bool valOk = false;
545  QVariant val = value( context, defaultDateTime, &valOk );
546 
547  if ( !valOk || !val.isValid() )
548  return defaultDateTime;
549 
550  QDateTime dateTime;
551  if ( val.type() == QVariant::DateTime )
552  {
553  dateTime = val.value<QDateTime>();
554  }
555  else
556  {
557  dateTime = val.toDateTime();
558  }
559 
560  if ( !dateTime.isValid() )
561  return defaultDateTime;
562  else
563  {
564  if ( ok )
565  *ok = true;
566  return dateTime;
567  }
568 }
569 
570 QString QgsProperty::valueAsString( const QgsExpressionContext &context, const QString &defaultString, bool *ok ) const
571 {
572  bool valOk = false;
573  QVariant val = value( context, defaultString, &valOk );
574 
575  if ( !valOk || !val.isValid() )
576  {
577  if ( ok )
578  *ok = false;
579  return defaultString;
580  }
581  else
582  {
583  if ( ok )
584  *ok = true;
585  return val.toString();
586  }
587 }
588 
589 QColor QgsProperty::valueAsColor( const QgsExpressionContext &context, const QColor &defaultColor, bool *ok ) const
590 {
591  if ( ok )
592  *ok = false;
593 
594  bool valOk = false;
595  QVariant val = value( context, defaultColor, &valOk );
596 
597  if ( !valOk || !val.isValid() )
598  return defaultColor;
599 
600  QColor color;
601  if ( val.type() == QVariant::Color )
602  {
603  color = val.value<QColor>();
604  }
605  else
606  {
607  color = QgsSymbolLayerUtils::decodeColor( val.toString() );
608  }
609 
610  if ( !color.isValid() )
611  return defaultColor;
612  else
613  {
614  if ( ok )
615  *ok = true;
616  return color;
617  }
618 }
619 
620 double QgsProperty::valueAsDouble( const QgsExpressionContext &context, double defaultValue, bool *ok ) const
621 {
622  if ( ok )
623  *ok = false;
624 
625  bool valOk = false;
626  QVariant val = value( context, defaultValue, &valOk );
627 
628  if ( !valOk || !val.isValid() )
629  return defaultValue;
630 
631  bool convertOk = false;
632  double dbl = val.toDouble( &convertOk );
633  if ( !convertOk )
634  return defaultValue;
635  else
636  {
637  if ( ok )
638  *ok = true;
639  return dbl;
640  }
641 }
642 
643 int QgsProperty::valueAsInt( const QgsExpressionContext &context, int defaultValue, bool *ok ) const
644 {
645  if ( ok )
646  *ok = false;
647 
648  bool valOk = false;
649  QVariant val = value( context, defaultValue, &valOk );
650 
651  if ( !valOk || !val.isValid() )
652  return defaultValue;
653 
654  bool convertOk = false;
655  int integer = val.toInt( &convertOk );
656  if ( !convertOk )
657  {
658  //one more option to try
659  double dbl = val.toDouble( &convertOk );
660  if ( convertOk )
661  {
662  if ( ok )
663  *ok = true;
664  return std::round( dbl );
665  }
666  else
667  {
668  return defaultValue;
669  }
670  }
671  else
672  {
673  if ( ok )
674  *ok = true;
675  return integer;
676  }
677 }
678 
679 bool QgsProperty::valueAsBool( const QgsExpressionContext &context, bool defaultValue, bool *ok ) const
680 {
681  if ( ok )
682  *ok = false;
683 
684  bool valOk = false;
685  QVariant val = value( context, defaultValue, &valOk );
686 
687  if ( !valOk || !val.isValid() || val.isNull() )
688  return defaultValue;
689 
690  if ( ok )
691  *ok = true;
692  return val.toBool();
693 }
694 
695 QVariant QgsProperty::toVariant() const
696 {
697  QVariantMap propertyMap;
698 
699  propertyMap.insert( QStringLiteral( "active" ), d->active );
700  propertyMap.insert( QStringLiteral( "type" ), d->type );
701 
702  switch ( d->type )
703  {
704  case StaticProperty:
705  // propertyMap.insert( QStringLiteral( "valType" ), d->staticValue.typeName() );
706  propertyMap.insert( QStringLiteral( "val" ), d->staticValue.toString() );
707  break;
708 
709  case FieldBasedProperty:
710  propertyMap.insert( QStringLiteral( "field" ), d->fieldName );
711  break;
712 
714  propertyMap.insert( QStringLiteral( "expression" ), d->expressionString );
715  break;
716 
717  case InvalidProperty:
718  break;
719  }
720 
721  if ( d->transformer )
722  {
723  QVariantMap transformer;
724  transformer.insert( QStringLiteral( "t" ), d->transformer->transformerType() );
725  transformer.insert( QStringLiteral( "d" ), d->transformer->toVariant() );
726 
727  propertyMap.insert( QStringLiteral( "transformer" ), transformer );
728  }
729 
730  return propertyMap;
731 }
732 
733 bool QgsProperty::loadVariant( const QVariant &property )
734 {
735  QVariantMap propertyMap = property.toMap();
736 
737  d.detach();
738  d->active = propertyMap.value( QStringLiteral( "active" ) ).toBool();
739  d->type = static_cast< Type >( propertyMap.value( QStringLiteral( "type" ), InvalidProperty ).toInt() );
740 
741  switch ( d->type )
742  {
743  case StaticProperty:
744  d->staticValue = propertyMap.value( QStringLiteral( "val" ) );
745  // d->staticValue.convert( QVariant::nameToType( propertyElem.attribute( "valType", "QString" ).toLocal8Bit().constData() ) );
746  break;
747 
748  case FieldBasedProperty:
749  d->fieldName = propertyMap.value( QStringLiteral( "field" ) ).toString();
750  if ( d->fieldName.isEmpty() )
751  d->active = false;
752  break;
753 
755  d->expressionString = propertyMap.value( QStringLiteral( "expression" ) ).toString();
756  if ( d->expressionString.isEmpty() )
757  d->active = false;
758 
759  d->expression = QgsExpression( d->expressionString );
760  d->expressionPrepared = false;
761  d->expressionIsInvalid = false;
762  d->expressionReferencedCols.clear();
763  break;
764 
765  case InvalidProperty:
766  break;
767 
768  }
769 
770  //restore transformer if present
771  delete d->transformer;
772  d->transformer = nullptr;
773 
774 
775  QVariant transform = propertyMap.value( QStringLiteral( "transformer" ) );
776 
777  if ( transform.isValid() )
778  {
779  QVariantMap transformerMap = transform.toMap();
780 
781  QgsPropertyTransformer::Type type = static_cast< QgsPropertyTransformer::Type >( transformerMap.value( QStringLiteral( "t" ), QgsPropertyTransformer::GenericNumericTransformer ).toInt() );
782  std::unique_ptr< QgsPropertyTransformer > transformer( QgsPropertyTransformer::create( type ) );
783 
784  if ( transformer )
785  {
786  if ( transformer->loadVariant( transformerMap.value( QStringLiteral( "d" ) ) ) )
787  d->transformer = transformer.release();
788  }
789  }
790 
791  return true;
792 }
793 
794 
796 {
797  d.detach();
798  d->transformer = transformer;
799 }
800 
802 {
803  return d->transformer;
804 }
805 
807 {
808  if ( d->type != ExpressionBasedProperty )
809  return false;
810 
811  if ( d->transformer )
812  return false; // already a transformer
813 
814  QString baseExpression;
815  QString fieldName;
816  std::unique_ptr< QgsPropertyTransformer > transformer( QgsPropertyTransformer::fromExpression( d->expressionString, baseExpression, fieldName ) );
817  if ( !transformer )
818  return false;
819 
820  d.detach();
821  d->transformer = transformer.release();
822  if ( !fieldName.isEmpty() )
823  setField( fieldName );
824  else
825  setExpressionString( baseExpression );
826  return true;
827 }
828 
829 
830 
int lookupField(const QString &fieldName) const
Looks up field&#39;s index from the field name.
Definition: qgsfields.cpp:344
bool operator==(const QgsProperty &other) const
Render units (eg mm/pixels/map units)
Definition: qgsproperty.h:64
bool isValid() const
Returns the validity of this feature.
Definition: qgsfeature.cpp:185
Class for parsing and evaluation of expressions (formerly called "search strings").
bool supportsAssistant() const
Returns true if the property is of a type which is compatible with property override assistants...
QString asExpression() const
Returns an expression string representing the state of the property, or an empty string if the proper...
Field based property (QgsFieldBasedProperty)
Definition: qgsproperty.h:240
Positive integer values (including 0)
Definition: qgsproperty.h:56
QgsProperty & operator=(const QgsProperty &other)
QgsPropertyDefinition()=default
Constructs an empty property.
static QString quotedColumnRef(QString name)
Returns a quoted column reference (in double quotes)
1D size (eg marker radius, or square marker height/width)
Definition: qgsproperty.h:70
Invalid (not set) property.
Definition: qgsproperty.h:238
Expression based property (QgsExpressionBasedProperty)
Definition: qgsproperty.h:241
Abstract base class for objects which transform the calculated value of a property.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
Non-zero positive integer values.
Definition: qgsproperty.h:57
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
Container of fields for a vector layer.
Definition: qgsfields.h:44
Color with alpha channel.
Definition: qgsproperty.h:65
QgsFields fields() const
Convenience function for retrieving the fields for the context, if set.
QVariant value(const QgsExpressionContext &context, const QVariant &defaultValue=QVariant(), bool *ok=nullptr) const
Calculates the current value of the property, including any transforms which are set for the property...
QSet< QString > referencedFields(const QgsExpressionContext &context=QgsExpressionContext(), bool ignoreContext=false) const
Returns the set of any fields referenced by the property for a specified expression context...
static QgsPropertyTransformer * create(Type type)
Factory method for creating a new property transformer of the specified type.
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:55
Positive double value (including 0)
Definition: qgsproperty.h:59
Rotation (value between 0-360 degrees)
Definition: qgsproperty.h:61
QgsProperty()
Constructor for a QgsAbstractProperty.
QColor valueAsColor(const QgsExpressionContext &context, const QColor &defaultColor=QColor(), bool *ok=nullptr) const
Calculates the current value of the property and interprets it as a color.
static QgsPropertyTransformer * fromExpression(const QString &expression, QString &baseExpression, QString &fieldName)
Attempts to parse an expression into a corresponding property transformer.
Any string value.
Definition: qgsproperty.h:62
const QgsPropertyTransformer * transformer() const
Returns the existing transformer used for manipulating the calculated values for the property...
Type
Property types.
Definition: qgsproperty.h:236
QVariant toVariant() const
Saves this property to a QVariantMap, wrapped in a QVariant.
QString expressionString() const
Returns the expression used for the property value.
void setField(const QString &field)
Sets the field name the property references.
bool isProjectColor() const
Returns true if the property is set to a linked project color.
QString valueAsString(const QgsExpressionContext &context, const QString &defaultString=QString(), bool *ok=nullptr) const
Calculates the current value of the property and interprets it as a string.
static QgsProperty fromValue(const QVariant &value, bool isActive=true)
Returns a new StaticProperty created from the specified value.
DataType dataType() const
Returns the allowable field/value data type for the property.
Definition: qgsproperty.h:189
Integer value (including negative values)
Definition: qgsproperty.h:55
Type propertyType() const
Returns the property type.
bool loadVariant(const QVariant &property)
Loads this property from a QVariantMap, wrapped in a QVariant.
Property requires a boolean value.
Definition: qgsproperty.h:107
bool convertToTransformer()
Attempts to convert an existing expression based property to a base expression with corresponding tra...
QString description() const
Descriptive name of the property.
Definition: qgsproperty.h:164
void setActive(bool active)
Sets whether the property is currently active.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
bool valueAsBool(const QgsExpressionContext &context, bool defaultValue=false, bool *ok=nullptr) const
Calculates the current value of the property and interprets it as an boolean.
Property requires a numeric value.
Definition: qgsproperty.h:100
bool operator!=(const QgsProperty &other) const
A store for object properties.
Definition: qgsproperty.h:231
Fill style (eg solid, lines)
Definition: qgsproperty.h:74
Double value (including negative values)
Definition: qgsproperty.h:58
void setExpressionString(const QString &expression)
Sets the expression to use for the property value.
QString field() const
Returns the current field name the property references.
QString helpText() const
Helper text for using the property, including a description of the valid values for the property...
Definition: qgsproperty.h:179
DataType
Valid data types required by property.
Definition: qgsproperty.h:85
double valueAsDouble(const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property and interprets it as a double.
QDateTime valueAsDateTime(const QgsExpressionContext &context, const QDateTime &defaultDateTime=QDateTime(), bool *ok=nullptr) const
Calculates the current value of the property and interprets it as a datetime.
QString comment() const
Returns the comment of the property.
Definition: qgsproperty.h:169
Generic transformer for numeric values (QgsGenericNumericTransformer)
virtual ~QgsProperty()
Property requires a string value.
Definition: qgsproperty.h:93
int valueAsInt(const QgsExpressionContext &context, int defaultValue=0, bool *ok=nullptr) const
Calculates the current value of the property and interprets it as an integer.
Line style (eg solid/dashed)
Definition: qgsproperty.h:72
QVariant staticValue() const
Returns the current static value for the property.
Horizontal anchor point.
Definition: qgsproperty.h:76
QgsFeature feature() const
Convenience function for retrieving the feature for the context, if set.
StandardPropertyTemplate
Predefined standard property templates.
Definition: qgsproperty.h:52
static QString quotedValue(const QVariant &value)
Returns a string representation of a literal value, including appropriate quotations where required...
Path to an SVG file.
Definition: qgsproperty.h:78
Line cap style (eg round)
Definition: qgsproperty.h:75
QString name() const
Returns the name of the property.
Definition: qgsproperty.h:140
QVariant attribute(const QString &name) const
Lookup attribute value from attribute name.
Definition: qgsfeature.cpp:264
Static property (QgsStaticProperty)
Definition: qgsproperty.h:239
void setStaticValue(const QVariant &value)
Sets the static value for the property.
QString origin() const
Returns the origin of the property.
Definition: qgsproperty.h:152
void setTransformer(QgsPropertyTransformer *transformer)
Sets an optional transformer to use for manipulating the calculated values for the property...
bool isActive() const
Returns whether the property is currently active.
2D size (width/height different)
Definition: qgsproperty.h:71
static QColor decodeColor(const QString &str)
Custom property types.
Definition: qgsproperty.h:81
Color with no alpha channel.
Definition: qgsproperty.h:66
Double value between 0-1 (inclusive)
Definition: qgsproperty.h:60
bool prepare(const QgsExpressionContext &context=QgsExpressionContext()) const
Prepares the property against a specified expression context.