api/3.0/qgsexpressioncontext_8cpp_source.html

 /***************************************************************************
      qgsexpressioncontext.cpp
      ------------------------
     Date                 : April 2015
     Copyright            : (C) 2015 by Nyall Dawson
     Email                : nyall dot dawson at gmail dot com
  ***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/

 #include "qgsexpressioncontext.h"

 #include "qgslogger.h"
 #include "qgsexpression.h"
 #include "qgsexpressionfunction.h"
 #include "qgsfields.h"
 #include "qgsvectorlayer.h"
 #include "qgsproject.h"
 #include "qgssymbollayerutils.h"
 #include "qgsgeometry.h"
 #include "qgsapplication.h"
 #include "qgsmapsettings.h"
 #include "qgsmaplayerlistutils.h"
 #include "qgsprocessingcontext.h"
 #include "qgsprocessingalgorithm.h"
 #include "qgslayoutatlas.h"
 #include "qgslayout.h"
 #include "qgslayoutpagecollection.h"
 #include "qgslayoutreportcontext.h"

 #include <QSettings>
 #include <QDir>


 const QString QgsExpressionContext::EXPR_FIELDS( QStringLiteral( "_fields_" ) );
 const QString QgsExpressionContext::EXPR_ORIGINAL_VALUE( QStringLiteral( "value" ) );
 const QString QgsExpressionContext::EXPR_SYMBOL_COLOR( QStringLiteral( "symbol_color" ) );
 const QString QgsExpressionContext::EXPR_SYMBOL_ANGLE( QStringLiteral( "symbol_angle" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_PART_COUNT( QStringLiteral( "geometry_part_count" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_PART_NUM( QStringLiteral( "geometry_part_num" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_POINT_COUNT( QStringLiteral( "geometry_point_count" ) );
 const QString QgsExpressionContext::EXPR_GEOMETRY_POINT_NUM( QStringLiteral( "geometry_point_num" ) );
 const QString QgsExpressionContext::EXPR_CLUSTER_SIZE( QStringLiteral( "cluster_size" ) );
 const QString QgsExpressionContext::EXPR_CLUSTER_COLOR( QStringLiteral( "cluster_color" ) );

 //
 // QgsExpressionContextScope
 //

 QgsExpressionContextScope::QgsExpressionContextScope( const QString &name )
   : mName( name )
 {

 }

 QgsExpressionContextScope::QgsExpressionContextScope( const QgsExpressionContextScope &other )
   : mName( other.mName )
   , mVariables( other.mVariables )
   , mHasFeature( other.mHasFeature )
   , mFeature( other.mFeature )
 {
   QHash<QString, QgsScopedExpressionFunction * >::const_iterator it = other.mFunctions.constBegin();
   for ( ; it != other.mFunctions.constEnd(); ++it )
   {
     mFunctions.insert( it.key(), it.value()->clone() );
   }
 }

 QgsExpressionContextScope &QgsExpressionContextScope::operator=( const QgsExpressionContextScope &other )
 {
   mName = other.mName;
   mVariables = other.mVariables;
   mHasFeature = other.mHasFeature;
   mFeature = other.mFeature;

   qDeleteAll( mFunctions );
   mFunctions.clear();
   QHash<QString, QgsScopedExpressionFunction * >::const_iterator it = other.mFunctions.constBegin();
   for ( ; it != other.mFunctions.constEnd(); ++it )
   {
     mFunctions.insert( it.key(), it.value()->clone() );
   }

   return *this;
 }

 QgsExpressionContextScope::~QgsExpressionContextScope()
 {
   qDeleteAll( mFunctions );
 }

 void QgsExpressionContextScope::setVariable( const QString &name, const QVariant &value, bool isStatic )
 {
   if ( mVariables.contains( name ) )
   {
     StaticVariable existing = mVariables.value( name );
     existing.value = value;
     existing.isStatic = isStatic;
     addVariable( existing );
   }
   else
   {
     addVariable( QgsExpressionContextScope::StaticVariable( name, value, false, isStatic ) );
   }
 }

 void QgsExpressionContextScope::addVariable( const QgsExpressionContextScope::StaticVariable &variable )
 {
   mVariables.insert( variable.name, variable );
 }

 bool QgsExpressionContextScope::removeVariable( const QString &name )
 {
   return mVariables.remove( name ) > 0;
 }

 bool QgsExpressionContextScope::hasVariable( const QString &name ) const
 {
   return mVariables.contains( name );
 }

 QVariant QgsExpressionContextScope::variable( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).value : QVariant();
 }

 QStringList QgsExpressionContextScope::variableNames() const
 {
   QStringList names = mVariables.keys();
   return names;
 }

 bool QgsExpressionContextScope::variableNameSort( const QString &a, const QString &b )
 {
   return QString::localeAwareCompare( a, b ) < 0;
 }

 class QgsExpressionContextVariableCompare
 {
   public:
     explicit QgsExpressionContextVariableCompare( const QgsExpressionContextScope &scope )
       : mScope( scope )
     {  }

     bool operator()( const QString &a, const QString &b ) const
     {
       bool aReadOnly = mScope.isReadOnly( a );
       bool bReadOnly = mScope.isReadOnly( b );
       if ( aReadOnly != bReadOnly )
         return aReadOnly;
       return QString::localeAwareCompare( a, b ) < 0;
     }

   private:
     const QgsExpressionContextScope &mScope;
 };

 QStringList QgsExpressionContextScope::filteredVariableNames() const
 {
   QStringList allVariables = mVariables.keys();
   QStringList filtered;
   Q_FOREACH ( const QString &variable, allVariables )
   {
     if ( variable.startsWith( '_' ) )
       continue;

     filtered << variable;
   }
   QgsExpressionContextVariableCompare cmp( *this );
   std::sort( filtered.begin(), filtered.end(), cmp );

   return filtered;
 }

 bool QgsExpressionContextScope::isReadOnly( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).readOnly : false;
 }

 bool QgsExpressionContextScope::isStatic( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).isStatic : false;
 }

 QString QgsExpressionContextScope::description( const QString &name ) const
 {
   return hasVariable( name ) ? mVariables.value( name ).description : QString();
 }

 bool QgsExpressionContextScope::hasFunction( const QString &name ) const
 {
   return mFunctions.contains( name );
 }

 QgsExpressionFunction *QgsExpressionContextScope::function( const QString &name ) const
 {
   return mFunctions.contains( name ) ? mFunctions.value( name ) : nullptr;
 }

 QStringList QgsExpressionContextScope::functionNames() const
 {
   return mFunctions.keys();
 }

 void QgsExpressionContextScope::addFunction( const QString &name, QgsScopedExpressionFunction *function )
 {
   mFunctions.insert( name, function );
 }


 void QgsExpressionContextScope::setFields( const QgsFields &fields )
 {
   addVariable( StaticVariable( QgsExpressionContext::EXPR_FIELDS, QVariant::fromValue( fields ), true ) );
 }


 //
 // QgsExpressionContext
 //

 QgsExpressionContext::QgsExpressionContext( const QList<QgsExpressionContextScope *> &scopes )
   : mStack( scopes )
 {
 }

 QgsExpressionContext::QgsExpressionContext( const QgsExpressionContext &other )
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, other.mStack )
   {
     mStack << new QgsExpressionContextScope( *scope );
   }
   mHighlightedVariables = other.mHighlightedVariables;
   mCachedValues = other.mCachedValues;
 }

 QgsExpressionContext &QgsExpressionContext::operator=( QgsExpressionContext &&other ) noexcept
 {
   if ( this != &other )
   {
     qDeleteAll( mStack );
     // move the stack over
     mStack = other.mStack;
     other.mStack.clear();

     mHighlightedVariables = other.mHighlightedVariables;
     mCachedValues = other.mCachedValues;
   }
   return *this;
 }

 QgsExpressionContext &QgsExpressionContext::operator=( const QgsExpressionContext &other )
 {
   qDeleteAll( mStack );
   mStack.clear();
   Q_FOREACH ( const QgsExpressionContextScope *scope, other.mStack )
   {
     mStack << new QgsExpressionContextScope( *scope );
   }
   mHighlightedVariables = other.mHighlightedVariables;
   mCachedValues = other.mCachedValues;
   return *this;
 }

 QgsExpressionContext::~QgsExpressionContext()
 {
   qDeleteAll( mStack );
   mStack.clear();
 }

 bool QgsExpressionContext::hasVariable( const QString &name ) const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->hasVariable( name ) )
       return true;
   }
   return false;
 }

 QVariant QgsExpressionContext::variable( const QString &name ) const
 {
   const QgsExpressionContextScope *scope = activeScopeForVariable( name );
   return scope ? scope->variable( name ) : QVariant();
 }

 QVariantMap QgsExpressionContext::variablesToMap() const
 {
   QStringList names = variableNames();
   QVariantMap m;
   Q_FOREACH ( const QString &name, names )
   {
     m.insert( name, variable( name ) );
   }
   return m;
 }

 bool QgsExpressionContext::isHighlightedVariable( const QString &name ) const
 {
   return mHighlightedVariables.contains( name );
 }

 void QgsExpressionContext::setHighlightedVariables( const QStringList &variableNames )
 {
   mHighlightedVariables = variableNames;
 }

 const QgsExpressionContextScope *QgsExpressionContext::activeScopeForVariable( const QString &name ) const
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasVariable( name ) )
       return ( *it );
   }
   return nullptr;
 }

 QgsExpressionContextScope *QgsExpressionContext::activeScopeForVariable( const QString &name )
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasVariable( name ) )
       return ( *it );
   }
   return nullptr;
 }

 QgsExpressionContextScope *QgsExpressionContext::scope( int index )
 {
   if ( index < 0 || index >= mStack.count() )
     return nullptr;

   return mStack.at( index );
 }

 QgsExpressionContextScope *QgsExpressionContext::lastScope()
 {
   if ( mStack.count() < 1 )
     return nullptr;

   return mStack.last();
 }

 int QgsExpressionContext::indexOfScope( QgsExpressionContextScope *scope ) const
 {
   if ( !scope )
     return -1;

   return mStack.indexOf( scope );
 }

 int QgsExpressionContext::indexOfScope( const QString &scopeName ) const
 {
   int index = 0;
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->name() == scopeName )
       return index;

     index++;
   }
   return -1;
 }

 QStringList QgsExpressionContext::variableNames() const
 {
   QStringList names;
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     names << scope->variableNames();
   }
   return names.toSet().toList();
 }

 QStringList QgsExpressionContext::filteredVariableNames() const
 {
   QStringList allVariables = variableNames();
   QStringList filtered;
   Q_FOREACH ( const QString &variable, allVariables )
   {
     if ( variable.startsWith( '_' ) )
       continue;

     filtered << variable;
   }

   filtered.sort();
   return filtered;
 }

 bool QgsExpressionContext::isReadOnly( const QString &name ) const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->isReadOnly( name ) )
       return true;
   }
   return false;
 }

 QString QgsExpressionContext::description( const QString &name ) const
 {
   const QgsExpressionContextScope *scope = activeScopeForVariable( name );
   return ( scope && !scope->description( name ).isEmpty() ) ? scope->description( name ) : QgsExpression::variableHelpText( name );
 }

 bool QgsExpressionContext::hasFunction( const QString &name ) const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->hasFunction( name ) )
       return true;
   }
   return false;
 }

 QStringList QgsExpressionContext::functionNames() const
 {
   QStringList result;
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     result << scope->functionNames();
   }
   result = result.toSet().toList();
   result.sort();
   return result;
 }

 QgsExpressionFunction *QgsExpressionContext::function( const QString &name ) const
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasFunction( name ) )
       return ( *it )->function( name );
   }
   return nullptr;
 }

 int QgsExpressionContext::scopeCount() const
 {
   return mStack.count();
 }

 void QgsExpressionContext::appendScope( QgsExpressionContextScope *scope )
 {
   mStack.append( scope );
 }

 void QgsExpressionContext::appendScopes( const QList<QgsExpressionContextScope *> &scopes )
 {
   mStack.append( scopes );
 }

 QgsExpressionContextScope *QgsExpressionContext::popScope()
 {
   if ( !mStack.isEmpty() )
     return mStack.takeLast();

   return nullptr;
 }

 QList<QgsExpressionContextScope *> QgsExpressionContext::takeScopes()
 {
   QList<QgsExpressionContextScope *> stack = mStack;
   mStack.clear();
   return stack;
 }

 QgsExpressionContext &QgsExpressionContext::operator<<( QgsExpressionContextScope *scope )
 {
   mStack.append( scope );
   return *this;
 }

 void QgsExpressionContext::setFeature( const QgsFeature &feature )
 {
   if ( mStack.isEmpty() )
     mStack.append( new QgsExpressionContextScope() );

   mStack.last()->setFeature( feature );
 }

 bool QgsExpressionContext::hasFeature() const
 {
   Q_FOREACH ( const QgsExpressionContextScope *scope, mStack )
   {
     if ( scope->hasFeature() )
       return true;
   }
   return false;
 }

 QgsFeature QgsExpressionContext::feature() const
 {
   //iterate through stack backwards, so that higher priority variables take precedence
   QList< QgsExpressionContextScope * >::const_iterator it = mStack.constEnd();
   while ( it != mStack.constBegin() )
   {
     --it;
     if ( ( *it )->hasFeature() )
       return ( *it )->feature();
   }
   return QgsFeature();
 }

 void QgsExpressionContext::setFields( const QgsFields &fields )
 {
   if ( mStack.isEmpty() )
     mStack.append( new QgsExpressionContextScope() );

   mStack.last()->setFields( fields );
 }

 QgsFields QgsExpressionContext::fields() const
 {
   return qvariant_cast<QgsFields>( variable( QgsExpressionContext::EXPR_FIELDS ) );
 }

 void QgsExpressionContext::setOriginalValueVariable( const QVariant &value )
 {
   if ( mStack.isEmpty() )
     mStack.append( new QgsExpressionContextScope() );

   mStack.last()->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_ORIGINAL_VALUE,
                               value, true ) );
 }

 void QgsExpressionContext::setCachedValue( const QString &key, const QVariant &value ) const
 {
   mCachedValues.insert( key, value );
 }

 bool QgsExpressionContext::hasCachedValue( const QString &key ) const
 {
   return mCachedValues.contains( key );
 }

 QVariant QgsExpressionContext::cachedValue( const QString &key ) const
 {
   return mCachedValues.value( key, QVariant() );
 }

 void QgsExpressionContext::clearCachedValues() const
 {
   mCachedValues.clear();
 }


 //
 // QgsExpressionContextUtils
 //

 QgsExpressionContextScope *QgsExpressionContextUtils::globalScope()
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Global" ) );

   QVariantMap customVariables = QgsApplication::customVariables();

   for ( QVariantMap::const_iterator it = customVariables.constBegin(); it != customVariables.constEnd(); ++it )
   {
     scope->setVariable( it.key(), it.value(), true );
   }

   //add some extra global variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_version" ), Qgis::QGIS_VERSION, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_version_no" ), Qgis::QGIS_VERSION_INT, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_short_version" ), QStringLiteral( "%1.%2" ).arg( Qgis::QGIS_VERSION_INT / 10000 ).arg( Qgis::QGIS_VERSION_INT / 100 % 100 ), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_release_name" ), Qgis::QGIS_RELEASE_NAME, true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_platform" ), QgsApplication::platform(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_os_name" ), QgsApplication::osName(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "qgis_locale" ), QgsApplication::locale(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "user_account_name" ), QgsApplication::userLoginName(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "user_full_name" ), QgsApplication::userFullName(), true, true ) );

   return scope;
 }

 void QgsExpressionContextUtils::setGlobalVariable( const QString &name, const QVariant &value )
 {
   QgsApplication::setCustomVariable( name, value );
 }

 void QgsExpressionContextUtils::setGlobalVariables( const QVariantMap &variables )
 {
   QgsApplication::setCustomVariables( variables );
 }

 void QgsExpressionContextUtils::removeGlobalVariable( const QString &name )
 {
   QVariantMap vars = QgsApplication::customVariables();
   if ( vars.remove( name ) )
     QgsApplication::setCustomVariables( vars );
 }


 class GetNamedProjectColor : public QgsScopedExpressionFunction
 {
   public:
     GetNamedProjectColor( const QgsProject *project )
       : QgsScopedExpressionFunction( QStringLiteral( "project_color" ), 1, QStringLiteral( "Color" ) )
       , mProject( project )
     {
       if ( !project )
         return;

       //build up color list from project. Do this in advance for speed
       QStringList colorStrings = project->readListEntry( QStringLiteral( "Palette" ), QStringLiteral( "/Colors" ) );
       QStringList colorLabels = project->readListEntry( QStringLiteral( "Palette" ), QStringLiteral( "/Labels" ) );

       //generate list from custom colors
       int colorIndex = 0;
       for ( QStringList::iterator it = colorStrings.begin();
             it != colorStrings.end(); ++it )
       {
         QColor color = QgsSymbolLayerUtils::decodeColor( *it );
         QString label;
         if ( colorLabels.length() > colorIndex )
         {
           label = colorLabels.at( colorIndex );
         }

         mColors.insert( label.toLower(), color );
         colorIndex++;
       }
     }

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       QString colorName = values.at( 0 ).toString().toLower();
       if ( mColors.contains( colorName ) )
       {
         return QStringLiteral( "%1,%2,%3" ).arg( mColors.value( colorName ).red() ).arg( mColors.value( colorName ).green() ).arg( mColors.value( colorName ).blue() );
       }
       else
         return QVariant();
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetNamedProjectColor( mProject );
     }

   private:

     const QgsProject *mProject = nullptr;
     QHash< QString, QColor > mColors;

 };

 class GetLayoutItemVariables : public QgsScopedExpressionFunction
 {
   public:
     GetLayoutItemVariables( const QgsLayout *c )
       : QgsScopedExpressionFunction( QStringLiteral( "item_variables" ), QgsExpressionFunction::ParameterList() << QgsExpressionFunction::Parameter( QStringLiteral( "id" ) ), QStringLiteral( "Layout" ) )
       , mLayout( c )
     {}

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       if ( !mLayout )
         return QVariant();

       QString id = values.at( 0 ).toString().toLower();

       const QgsLayoutItem *item = mLayout->itemById( id );
       if ( !item )
         return QVariant();

       QgsExpressionContext c = item->createExpressionContext();

       return c.variablesToMap();
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetLayoutItemVariables( mLayout );
     }

   private:

     const QgsLayout *mLayout = nullptr;

 };

 class GetLayerVisibility : public QgsScopedExpressionFunction
 {
   public:
     GetLayerVisibility( const QList<QgsMapLayer *> &layers )
       : QgsScopedExpressionFunction( QStringLiteral( "is_layer_visible" ), QgsExpressionFunction::ParameterList() << QgsExpressionFunction::Parameter( QStringLiteral( "id" ) ), QStringLiteral( "General" ) )
       , mLayers( layers )
     {}

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       if ( mLayers.isEmpty() )
       {
         return QVariant( false );
       }

       QgsMapLayer *layer = _qgis_findLayer( mLayers, values.at( 0 ).toString() );
       if ( layer )
       {
         return QVariant( true );
       }
       else
       {
         return QVariant( false );
       }
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetLayerVisibility( mLayers );
     }

   private:

     const QList<QgsMapLayer *> mLayers;

 };

 class GetProcessingParameterValue : public QgsScopedExpressionFunction
 {
   public:
     GetProcessingParameterValue( const QVariantMap &params )
       : QgsScopedExpressionFunction( QStringLiteral( "parameter" ), QgsExpressionFunction::ParameterList() << QgsExpressionFunction::Parameter( QStringLiteral( "name" ) ), QStringLiteral( "Processing" ) )
       , mParams( params )
     {}

     QVariant func( const QVariantList &values, const QgsExpressionContext *, QgsExpression *, const QgsExpressionNodeFunction * ) override
     {
       return mParams.value( values.at( 0 ).toString() );
     }

     QgsScopedExpressionFunction *clone() const override
     {
       return new GetProcessingParameterValue( mParams );
     }

   private:

     const QVariantMap mParams;

 };


 QgsExpressionContextScope *QgsExpressionContextUtils::projectScope( const QgsProject *project )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Project" ) );

   if ( !project )
     return scope;

   const QVariantMap vars = project->customVariables();

   QVariantMap::const_iterator it = vars.constBegin();

   for ( ; it != vars.constEnd(); ++it )
   {
     scope->setVariable( it.key(), it.value(), true );
   }

   //add other known project variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_title" ), project->title(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_path" ), QDir::toNativeSeparators( project->fileInfo().filePath() ), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_folder" ), QDir::toNativeSeparators( project->fileInfo().dir().path() ), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_filename" ), project->fileInfo().fileName(), true, true ) );
   QgsCoordinateReferenceSystem projectCrs = project->crs();
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_crs" ), projectCrs.authid(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "project_crs_definition" ), projectCrs.toProj4(), true, true ) );

   scope->addFunction( QStringLiteral( "project_color" ), new GetNamedProjectColor( project ) );
   return scope;
 }

 void QgsExpressionContextUtils::setProjectVariable( QgsProject *project, const QString &name, const QVariant &value )
 {
   if ( !project )
     return;

   QVariantMap vars = project->customVariables();

   vars.insert( name, value );

   project->setCustomVariables( vars );
 }

 void QgsExpressionContextUtils::setProjectVariables( QgsProject *project, const QVariantMap &variables )
 {
   if ( !project )
     return;

   project->setCustomVariables( variables );
 }

 void QgsExpressionContextUtils::removeProjectVariable( QgsProject *project, const QString &name )
 {
   if ( !project )
   {
     return;
   }

   QVariantMap vars = project->customVariables();
   if ( vars.remove( name ) )
     project->setCustomVariables( vars );
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::layerScope( const QgsMapLayer *layer )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Layer" ) );

   if ( !layer )
     return scope;

   //add variables defined in layer properties
   QStringList variableNames = layer->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layer->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   int varIndex = 0;
   Q_FOREACH ( const QString &variableName, variableNames )
   {
     if ( varIndex >= variableValues.length() )
     {
       break;
     }

     QVariant varValue = variableValues.at( varIndex );
     varIndex++;
     scope->setVariable( variableName, varValue, true );
   }

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layer_name" ), layer->name(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layer_id" ), layer->id(), true, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layer" ), QVariant::fromValue<QgsWeakMapLayerPointer >( QgsWeakMapLayerPointer( const_cast<QgsMapLayer *>( layer ) ) ), true, true ) );

   const QgsVectorLayer *vLayer = qobject_cast< const QgsVectorLayer * >( layer );
   if ( vLayer )
   {
     scope->setFields( vLayer->fields() );
   }

   //TODO - add functions. Possibilities include:
   //is_selected
   //field summary stats

   return scope;
 }

 QList<QgsExpressionContextScope *> QgsExpressionContextUtils::globalProjectLayerScopes( const QgsMapLayer *layer )
 {
   QList<QgsExpressionContextScope *> scopes;
   scopes << globalScope();

   QgsProject *project = QgsProject::instance();  // TODO: use project associated with layer
   if ( project )
     scopes << projectScope( project );

   if ( layer )
     scopes << layerScope( layer );
   return scopes;
 }

 void QgsExpressionContextUtils::setLayerVariable( QgsMapLayer *layer, const QString &name, const QVariant &value )
 {
   if ( !layer )
     return;

   //write variable to layer
   QStringList variableNames = layer->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layer->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   variableNames << name;
   variableValues << value.toString();

   layer->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layer->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 void QgsExpressionContextUtils::setLayerVariables( QgsMapLayer *layer, const QVariantMap &variables )
 {
   if ( !layer )
     return;

   QStringList variableNames;
   QStringList variableValues;

   QVariantMap::const_iterator it = variables.constBegin();
   for ( ; it != variables.constEnd(); ++it )
   {
     variableNames << it.key();
     variableValues << it.value().toString();
   }

   layer->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layer->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::mapSettingsScope( const QgsMapSettings &mapSettings )
 {
   // IMPORTANT: ANY CHANGES HERE ALSO NEED TO BE MADE TO QgsLayoutItemMap::createExpressionContext()
   // (rationale is described in QgsLayoutItemMap::createExpressionContext() )

   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Map Settings" ) );

   //add known map settings context variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_id" ), "canvas", true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_rotation" ), mapSettings.rotation(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_scale" ), mapSettings.scale(), true ) );
   QgsGeometry extent = QgsGeometry::fromRect( mapSettings.visibleExtent() );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent" ), QVariant::fromValue( extent ), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent_width" ), mapSettings.visibleExtent().width(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent_height" ), mapSettings.visibleExtent().height(), true ) );
   QgsGeometry centerPoint = QgsGeometry::fromPointXY( mapSettings.visibleExtent().center() );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_extent_center" ), QVariant::fromValue( centerPoint ), true ) );

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_crs" ), mapSettings.destinationCrs().authid(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_crs_definition" ), mapSettings.destinationCrs().toProj4(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "map_units" ), QgsUnitTypes::toString( mapSettings.mapUnits() ), true ) );

   scope->addFunction( QStringLiteral( "is_layer_visible" ), new GetLayerVisibility( mapSettings.layers() ) );

   return scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::mapToolCaptureScope( const QList<QgsPointLocator::Match> &matches )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Map Tool Capture" ) );

   QVariantList matchList;

   for ( const QgsPointLocator::Match &match : matches )
   {
     QVariantMap matchMap;

     matchMap.insert( QStringLiteral( "valid" ), match.isValid() );
     matchMap.insert( QStringLiteral( "layer" ), QVariant::fromValue<QgsWeakMapLayerPointer>( QgsWeakMapLayerPointer( match.layer() ) ) );
     matchMap.insert( QStringLiteral( "feature_id" ), match.featureId() );
     matchMap.insert( QStringLiteral( "vertex_index" ), match.vertexIndex() );
     matchMap.insert( QStringLiteral( "distance" ), match.distance() );

     matchList.append( matchMap );
   }

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "snapping_results" ), matchList ) );

   return scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::updateSymbolScope( const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope )
 {
   if ( !symbolScope )
     return nullptr;

   symbolScope->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_SYMBOL_COLOR, symbol ? symbol->color() : QColor(), true ) );

   double angle = 0.0;
   const QgsMarkerSymbol *markerSymbol = dynamic_cast< const QgsMarkerSymbol * >( symbol );
   if ( markerSymbol )
   {
     angle = markerSymbol->angle();
   }
   symbolScope->addVariable( QgsExpressionContextScope::StaticVariable( QgsExpressionContext::EXPR_SYMBOL_ANGLE, angle, true ) );

   return symbolScope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::layoutScope( const QgsLayout *layout )
 {
   std::unique_ptr< QgsExpressionContextScope > scope( new QgsExpressionContextScope( QObject::tr( "Layout" ) ) );
   if ( !layout )
     return scope.release();

   //add variables defined in layout properties
   QStringList variableNames = layout->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layout->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   int varIndex = 0;
   Q_FOREACH ( const QString &variableName, variableNames )
   {
     if ( varIndex >= variableValues.length() )
     {
       break;
     }

     QVariant varValue = variableValues.at( varIndex );
     varIndex++;
     scope->setVariable( variableName, varValue );
   }

   //add known layout context variables
   if ( const QgsMasterLayoutInterface *l = dynamic_cast< const QgsMasterLayoutInterface * >( layout ) )
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_name" ), l->name(), true ) );

   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_numpages" ), layout->pageCollection()->pageCount(), true ) );
   if ( layout->pageCollection()->pageCount() > 0 )
   {
     // just take first page size
     QSizeF s = layout->pageCollection()->page( 0 )->sizeWithUnits().toQSizeF();
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pageheight" ), s.height(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pagewidth" ), s.width(), true ) );
   }
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_dpi" ), layout->renderContext().dpi(), true ) );

   scope->addFunction( QStringLiteral( "item_variables" ), new GetLayoutItemVariables( layout ) );

   if ( layout->reportContext().layer() )
   {
     scope->setFields( layout->reportContext().layer()->fields() );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layerid" ), layout->reportContext().layer()->id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layername" ), layout->reportContext().layer()->name(), true ) );
   }

   if ( layout->reportContext().feature().isValid() )
   {
     QgsFeature atlasFeature = layout->reportContext().feature();
     scope->setFeature( atlasFeature );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_feature" ), QVariant::fromValue( atlasFeature ), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featureid" ), atlasFeature.id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_geometry" ), QVariant::fromValue( atlasFeature.geometry() ), true ) );
   }

   return scope.release();
 }

 void QgsExpressionContextUtils::setLayoutVariable( QgsLayout *layout, const QString &name, const QVariant &value )
 {
   if ( !layout )
     return;

   //write variable to layout
   QStringList variableNames = layout->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = layout->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   variableNames << name;
   variableValues << value.toString();

   layout->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layout->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 void QgsExpressionContextUtils::setLayoutVariables( QgsLayout *layout, const QVariantMap &variables )
 {
   if ( !layout )
     return;

   QStringList variableNames;
   QStringList variableValues;

   QVariantMap::const_iterator it = variables.constBegin();
   for ( ; it != variables.constEnd(); ++it )
   {
     variableNames << it.key();
     variableValues << it.value().toString();
   }

   layout->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   layout->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::atlasScope( QgsLayoutAtlas *atlas )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Atlas" ) );
   if ( !atlas )
   {
     //add some dummy atlas variables. This is done so that as in certain contexts we want to show
     //users that these variables are available even if they have no current value
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_pagename" ), QString(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_feature" ), QVariant::fromValue( QgsFeature() ), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featureid" ), 0, true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_geometry" ), QVariant::fromValue( QgsGeometry() ), true ) );
     return scope;
   }

   //add known atlas variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_totalfeatures" ), atlas->count(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featurenumber" ), atlas->currentFeatureNumber() + 1, true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_filename" ), atlas->currentFilename(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_pagename" ), atlas->nameForPage( atlas->currentFeatureNumber() ), true ) );

   if ( atlas->enabled() && atlas->coverageLayer() )
   {
     scope->setFields( atlas->coverageLayer()->fields() );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layerid" ), atlas->coverageLayer()->id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_layername" ), atlas->coverageLayer()->name(), true ) );
   }

   if ( atlas->enabled() )
   {
     QgsFeature atlasFeature = atlas->layout()->reportContext().feature();
     scope->setFeature( atlasFeature );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_feature" ), QVariant::fromValue( atlasFeature ), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_featureid" ), atlasFeature.id(), true ) );
     scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "atlas_geometry" ), QVariant::fromValue( atlasFeature.geometry() ), true ) );
   }

   return scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::layoutItemScope( const QgsLayoutItem *item )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope( QObject::tr( "Layout Item" ) );
   if ( !item )
     return scope;

   //add variables defined in layout item properties
   const QStringList variableNames = item->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   const QStringList variableValues = item->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   int varIndex = 0;
   for ( const QString &variableName : variableNames )
   {
     if ( varIndex >= variableValues.length() )
     {
       break;
     }

     QVariant varValue = variableValues.at( varIndex );
     varIndex++;
     scope->setVariable( variableName, varValue );
   }

   //add known layout item context variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "item_id" ), item->id(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "item_uuid" ), item->uuid(), true ) );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_page" ), item->page() + 1, true ) );

   if ( item->layout() )
   {
     const QgsLayoutItemPage *page = item->layout()->pageCollection()->page( item->page() );
     if ( page )
     {
       const QSizeF s = page->sizeWithUnits().toQSizeF();
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pageheight" ), s.height(), true ) );
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pagewidth" ), s.width(), true ) );
     }
     else
     {
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pageheight" ), QVariant(), true ) );
       scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "layout_pagewidth" ), QVariant(), true ) );
     }
   }

   return scope;
 }

 void QgsExpressionContextUtils::setLayoutItemVariable( QgsLayoutItem *item, const QString &name, const QVariant &value )
 {
   if ( !item )
     return;

   //write variable to layout item
   QStringList variableNames = item->customProperty( QStringLiteral( "variableNames" ) ).toStringList();
   QStringList variableValues = item->customProperty( QStringLiteral( "variableValues" ) ).toStringList();

   variableNames << name;
   variableValues << value.toString();

   item->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   item->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 void QgsExpressionContextUtils::setLayoutItemVariables( QgsLayoutItem *item, const QVariantMap &variables )
 {
   if ( !item )
     return;

   QStringList variableNames;
   QStringList variableValues;

   QVariantMap::const_iterator it = variables.constBegin();
   for ( ; it != variables.constEnd(); ++it )
   {
     variableNames << it.key();
     variableValues << it.value().toString();
   }

   item->setCustomProperty( QStringLiteral( "variableNames" ), variableNames );
   item->setCustomProperty( QStringLiteral( "variableValues" ), variableValues );
 }

 QgsExpressionContext QgsExpressionContextUtils::createFeatureBasedContext( const QgsFeature &feature, const QgsFields &fields )
 {
   QgsExpressionContextScope *scope = new QgsExpressionContextScope();
   scope->setFeature( feature );
   scope->setFields( fields );
   return QgsExpressionContext() << scope;
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::processingAlgorithmScope( const QgsProcessingAlgorithm *algorithm, const QVariantMap &parameters, QgsProcessingContext &context )
 {
   // set aside for future use
   Q_UNUSED( context );

   std::unique_ptr< QgsExpressionContextScope > scope( new QgsExpressionContextScope( QObject::tr( "Algorithm" ) ) );
   if ( !algorithm )
     return scope.release();

   //add standard algorithm variables
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "algorithm_id" ), algorithm->id(), true ) );

   scope->addFunction( QStringLiteral( "parameter" ), new GetProcessingParameterValue( parameters ) );

   return scope.release();
 }

 QgsExpressionContextScope *QgsExpressionContextUtils::notificationScope( const QString &message )
 {
   std::unique_ptr< QgsExpressionContextScope > scope( new QgsExpressionContextScope() );
   scope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "notification_message" ), message, true ) );
   return scope.release();
 }

 void QgsExpressionContextUtils::registerContextFunctions()
 {
   QgsExpression::registerFunction( new GetNamedProjectColor( nullptr ) );
   QgsExpression::registerFunction( new GetLayoutItemVariables( nullptr ) );
   QgsExpression::registerFunction( new GetLayerVisibility( QList<QgsMapLayer *>() ) );
   QgsExpression::registerFunction( new GetProcessingParameterValue( QVariantMap() ) );
 }

 bool QgsScopedExpressionFunction::usesGeometry( const QgsExpressionNodeFunction *node ) const
 {
   Q_UNUSED( node )
   return mUsesGeometry;
 }

 QSet<QString> QgsScopedExpressionFunction::referencedColumns( const QgsExpressionNodeFunction *node ) const
 {
   Q_UNUSED( node )
   return mReferencedColumns;
 }

 bool QgsScopedExpressionFunction::isStatic( const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context ) const
 {
   return allParamsStatic( node, parent, context );
 }
QgsPointLocator::Match
Definition: qgspointlocator.h:119

QgsFeature::isValid
bool isValid() const
Returns the validity of this feature.
Definition: qgsfeature.cpp:176

QgsExpressionContextScope::hasVariable
bool hasVariable(const QString &name) const
Tests whether a variable with the specified name exists in the scope.
Definition: qgsexpressioncontext.cpp:122

QgsExpressionContext::EXPR_ORIGINAL_VALUE
static const QString EXPR_ORIGINAL_VALUE
Inbuilt variable name for value original value variable.
Definition: qgsexpressioncontext.h:695

QgsApplication::locale
static QString locale()
Returns the QGIS locale.
Definition: qgsapplication.cpp:941

QgsFeature::id
QgsFeatureId id
Definition: qgsfeature.h:71

QgsExpressionContextUtils::updateSymbolScope
static QgsExpressionContextScope * updateSymbolScope(const QgsSymbol *symbol, QgsExpressionContextScope *symbolScope=nullptr)
Updates a symbol scope related to a QgsSymbol to an expression context.
Definition: qgsexpressioncontext.cpp:967

QgsExpressionContext::cachedValue
QVariant cachedValue(const QString &key) const
Returns the matching cached value, if set.
Definition: qgsexpressioncontext.cpp:553

QgsExpressionContextScope::description
QString description(const QString &name) const
Returns the translated description for the variable with the specified name (if set).
Definition: qgsexpressioncontext.cpp:192

QgsExpressionContextUtils::processingAlgorithmScope
static QgsExpressionContextScope * processingAlgorithmScope(const QgsProcessingAlgorithm *algorithm, const QVariantMap &parameters, QgsProcessingContext &context)
Creates a new scope which contains variables and functions relating to a processing algorithm...
Definition: qgsexpressioncontext.cpp:1207

QgsExpressionContext::EXPR_CLUSTER_COLOR
static const QString EXPR_CLUSTER_COLOR
Inbuilt variable name for cluster color variable.
Definition: qgsexpressioncontext.h:711

QgsExpressionContextUtils::setLayoutItemVariable
static void setLayoutItemVariable(QgsLayoutItem *item, const QString &name, const QVariant &value)
Sets a layout item context variable, with the given name and value.
Definition: qgsexpressioncontext.cpp:1164

QgsLayoutItem::createExpressionContext
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
Definition: qgslayoutitem.cpp:1103

QgsExpressionContextScope::StaticVariable
Single variable definition for use within a QgsExpressionContextScope.
Definition: qgsexpressioncontext.h:136

QgsExpressionContextUtils::setGlobalVariable
static void setGlobalVariable(const QString &name, const QVariant &value)
Sets a global context variable.
Definition: qgsexpressioncontext.cpp:593

QgsMapLayer
Base class for all map layer types.
Definition: qgsmaplayer.h:56

QgsExpressionContext::setCachedValue
void setCachedValue(const QString &key, const QVariant &value) const
Sets a value to cache within the expression context.
Definition: qgsexpressioncontext.cpp:543

QgsExpressionContextUtils::setLayoutItemVariables
static void setLayoutItemVariables(QgsLayoutItem *item, const QVariantMap &variables)
Sets all layout item context variables for an item.
Definition: qgsexpressioncontext.cpp:1180

Qgis::QGIS_VERSION
static const QString QGIS_VERSION
Version string.
Definition: qgis.h:63

qgsproject.h

QgsExpressionContext::scope
QgsExpressionContextScope * scope(int index)
Returns the scope at the specified index within the context.
Definition: qgsexpressioncontext.cpp:340

QgsExpressionContextUtils::setLayerVariables
static void setLayerVariables(QgsMapLayer *layer, const QVariantMap &variables)
Sets all layer context variables.
Definition: qgsexpressioncontext.cpp:897

QgsProcessingAlgorithm::id
QString id() const
Returns the unique ID for the algorithm, which is a combination of the algorithm provider&#39;s ID and th...
Definition: qgsprocessingalgorithm.cpp:44

QgsExpressionContext::isReadOnly
bool isReadOnly(const QString &name) const
Returns whether a variable is read only, and should not be modifiable by users.
Definition: qgsexpressioncontext.cpp:403

QgsLayoutItem
Base class for graphical items within a QgsLayout.
Definition: qgslayoutitem.h:112

QgsExpressionContext::EXPR_GEOMETRY_POINT_COUNT
static const QString EXPR_GEOMETRY_POINT_COUNT
Inbuilt variable name for point count variable.
Definition: qgsexpressioncontext.h:705

QgsUnitTypes::toString
static Q_INVOKABLE QString toString(QgsUnitTypes::DistanceUnit unit)
Returns a translated string representing a distance unit.
Definition: qgsunittypes.cpp:152

QgsExpressionContextUtils::setLayoutVariable
static void setLayoutVariable(QgsLayout *layout, const QString &name, const QVariant &value)
Sets a layout context variable.
Definition: qgsexpressioncontext.cpp:1043

QgsExpressionContext::filteredVariableNames
QStringList filteredVariableNames() const
Returns a filtered list of variables names set by all scopes in the context.
Definition: qgsexpressioncontext.cpp:387

QgsApplication::setCustomVariables
static void setCustomVariables(const QVariantMap &customVariables)
Custom expression variables for this application.
Definition: qgsapplication.cpp:1402

QgsSymbol
Definition: qgssymbol.h:61

QgsExpressionContext::operator=
QgsExpressionContext & operator=(const QgsExpressionContext &other)
Definition: qgsexpressioncontext.cpp:258

QgsMapSettings::rotation
double rotation() const
Returns the rotation of the resulting map image, in degrees clockwise.
Definition: qgsmapsettings.cpp:90

qgslayout.h

QgsExpressionContext::hasFunction
bool hasFunction(const QString &name) const
Checks whether a specified function is contained in the context.
Definition: qgsexpressioncontext.cpp:419

QgsLayout::customProperty
QVariant customProperty(const QString &key, const QVariant &defaultValue=QVariant()) const
Read a custom property from the layout.
Definition: qgslayout.cpp:411

QgsExpressionContextScope::addFunction
void addFunction(const QString &name, QgsScopedExpressionFunction *function)
Adds a function to the scope.
Definition: qgsexpressioncontext.cpp:212

QgsExpressionContextScope::QgsExpressionContextScope
QgsExpressionContextScope(const QString &name=QString())
Constructor for QgsExpressionContextScope.
Definition: qgsexpressioncontext.cpp:55

QgsExpressionContext::setFeature
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Definition: qgsexpressioncontext.cpp:490

QgsExpressionContextUtils::removeProjectVariable
static void removeProjectVariable(QgsProject *project, const QString &name)
Remove project context variable.
Definition: qgsexpressioncontext.cpp:814

qgslayoutatlas.h

QgsExpressionContext::activeScopeForVariable
QgsExpressionContextScope * activeScopeForVariable(const QString &name)
Returns the currently active scope from the context for a specified variable name.
Definition: qgsexpressioncontext.cpp:327

QgsExpressionContextUtils::createFeatureBasedContext
static QgsExpressionContext createFeatureBasedContext(const QgsFeature &feature, const QgsFields &fields)
Helper function for creating an expression context which contains just a feature and fields collectio...
Definition: qgsexpressioncontext.cpp:1199

QgsExpressionContextScope::variableNames
QStringList variableNames() const
Returns a list of variable names contained within the scope.
Definition: qgsexpressioncontext.cpp:132

QgsExpressionContext::hasCachedValue
bool hasCachedValue(const QString &key) const
Returns true if the expression context contains a cached value with a matching key.
Definition: qgsexpressioncontext.cpp:548

QgsLayoutItem::sizeWithUnits
QgsLayoutSize sizeWithUnits() const
Returns the item&#39;s current size, including units.
Definition: qgslayoutitem.h:549

QgsMapLayer::setCustomProperty
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for layer.
Definition: qgsmaplayer.cpp:1854

QgsLayoutObject::setCustomProperty
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for the object.
Definition: qgslayoutobject.cpp:111

QgsLayoutObject::customProperty
QVariant customProperty(const QString &key, const QVariant &defaultValue=QVariant()) const
Read a custom property from the object.
Definition: qgslayoutobject.cpp:116

QgsCoordinateReferenceSystem::toProj4
QString toProj4() const
Returns a Proj4 string representation of this CRS.
Definition: qgscoordinatereferencesystem.cpp:1018

QgsExpressionContextScope::isReadOnly
bool isReadOnly(const QString &name) const
Tests whether the specified variable is read only and should not be editable by users.
Definition: qgsexpressioncontext.cpp:182

qgsmaplayerlistutils.h

QgsFields
Container of fields for a vector layer.
Definition: qgsfields.h:42

QgsExpressionContext::hasVariable
bool hasVariable(const QString &name) const
Check whether a variable is specified by any scope within the context.
Definition: qgsexpressioncontext.cpp:277

QgsGeometry
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:111

qgsexpressioncontext.h

QgsApplication::customVariables
static QVariantMap customVariables()
Custom expression variables for this application.
Definition: qgsapplication.cpp:1383

QgsExpressionContextScope::setFields
void setFields(const QgsFields &fields)
Convenience function for setting a fields for the scope.
Definition: qgsexpressioncontext.cpp:218

QgsExpressionContext::fields
QgsFields fields() const
Convenience function for retrieving the fields for the context, if set.
Definition: qgsexpressioncontext.cpp:529

QgsExpressionContextUtils::mapToolCaptureScope
static QgsExpressionContextScope * mapToolCaptureScope(const QList< QgsPointLocator::Match > &matches)
Sets the expression context variables which are available for expressions triggered by a map tool cap...
Definition: qgsexpressioncontext.cpp:943

QgsExpressionContextUtils::projectScope
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
Definition: qgsexpressioncontext.cpp:765

QgsMapSettings::layers
QList< QgsMapLayer * > layers() const
Get list of layers for map rendering The layers are stored in the reverse order of how they are rende...
Definition: qgsmapsettings.cpp:252

QgsFeature
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:62

QgsExpressionContextScope::operator=
QgsExpressionContextScope & operator=(const QgsExpressionContextScope &other)
Definition: qgsexpressioncontext.cpp:74

QgsExpressionContext::takeScopes
QList< QgsExpressionContextScope * > takeScopes()
Return all scopes from this context and remove them, leaving this context without any context...
Definition: qgsexpressioncontext.cpp:477

QgsScopedExpressionFunction::usesGeometry
bool usesGeometry(const QgsExpressionNodeFunction *node) const override
Definition: qgsexpressioncontext.cpp:1239

QgsExpressionContextUtils::setLayoutVariables
static void setLayoutVariables(QgsLayout *layout, const QVariantMap &variables)
Sets all layout context variables.
Definition: qgsexpressioncontext.cpp:1059

qgsmapsettings.h

QgsWeakMapLayerPointer
QPointer< QgsMapLayer > QgsWeakMapLayerPointer
Weak pointer for QgsMapLayer.
Definition: qgsmaplayer.h:1349

Qgis::QGIS_VERSION_INT
static const int QGIS_VERSION_INT
Version number used for comparing versions using the "Check QGIS Version" function.
Definition: qgis.h:65

QgsProcessingAlgorithm
Abstract base class for processing algorithms.
Definition: qgsprocessingalgorithm.h:51

QgsLayout::renderContext
QgsLayoutRenderContext & renderContext()
Returns a reference to the layout&#39;s render context, which stores information relating to the current ...
Definition: qgslayout.cpp:355

QgsMapSettings::visibleExtent
QgsRectangle visibleExtent() const
Return the actual extent derived from requested extent that takes takes output image size into accoun...
Definition: qgsmapsettings.cpp:341

QgsExpressionContext::variable
QVariant variable(const QString &name) const
Fetches a matching variable from the context.
Definition: qgsexpressioncontext.cpp:287

MathUtils::angle
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Definition: MathUtils.cpp:786

QgsExpressionContextScope::addVariable
void addVariable(const QgsExpressionContextScope::StaticVariable &variable)
Adds a variable into the context scope.
Definition: qgsexpressioncontext.cpp:112

QgsExpressionContext::operator<<
QgsExpressionContext & operator<<(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Definition: qgsexpressioncontext.cpp:484

QgsMarkerSymbol
Definition: qgssymbol.h:611

QgsApplication::userFullName
static QString userFullName()
Returns the user&#39;s operating system login account full display name.
Definition: qgsapplication.cpp:887

QgsMapSettings::destinationCrs
QgsCoordinateReferenceSystem destinationCrs() const
returns CRS of destination coordinate reference system
Definition: qgsmapsettings.cpp:288

QgsExpressionContext::description
QString description(const QString &name) const
Returns a translated description string for the variable with specified name.
Definition: qgsexpressioncontext.cpp:413

QgsExpressionContext::~QgsExpressionContext
~QgsExpressionContext()
Definition: qgsexpressioncontext.cpp:271

qgsprocessingcontext.h

QgsExpressionContext::hasFeature
bool hasFeature() const
Returns true if the context has a feature associated with it.
Definition: qgsexpressioncontext.cpp:498

QgsMapSettings::mapUnits
QgsUnitTypes::DistanceUnit mapUnits() const
Get units of map&#39;s geographical coordinates - used for scale calculation.
Definition: qgsmapsettings.cpp:330

QgsLayoutAtlas::layout
QgsLayout * layout() override
Returns the layout associated with the iterator.
Definition: qgslayoutatlas.cpp:40

QgsMapSettings
The QgsMapSettings class contains configuration for rendering of the map.
Definition: qgsmapsettings.h:58

QgsExpressionContextScope::setVariable
void setVariable(const QString &name, const QVariant &value, bool isStatic=false)
Convenience method for setting a variable in the context scope by name name and value.
Definition: qgsexpressioncontext.cpp:97

QgsExpressionContextScope::~QgsExpressionContextScope
~QgsExpressionContextScope()
Definition: qgsexpressioncontext.cpp:92

QgsLayoutSize::toQSizeF
QSizeF toQSizeF() const
Converts the layout size to a QSizeF.
Definition: qgslayoutsize.cpp:47

QgsExpressionContextUtils::layoutItemScope
static QgsExpressionContextScope * layoutItemScope(const QgsLayoutItem *item)
Creates a new scope which contains variables and functions relating to a QgsLayoutItem.
Definition: qgsexpressioncontext.cpp:1117

QgsScopedExpressionFunction::isStatic
bool isStatic(const QgsExpressionNodeFunction *node, QgsExpression *parent, const QgsExpressionContext *context) const override
Definition: qgsexpressioncontext.cpp:1251

QgsGeometry::fromRect
static QgsGeometry fromRect(const QgsRectangle &rect)
Creates a new geometry from a QgsRectangle.
Definition: qgsgeometry.cpp:224

QgsExpressionContextScope::removeVariable
bool removeVariable(const QString &name)
Removes a variable from the context scope, if found.
Definition: qgsexpressioncontext.cpp:117

QgsExpressionContext::lastScope
QgsExpressionContextScope * lastScope()
Returns the last scope added to the context.
Definition: qgsexpressioncontext.cpp:348

QgsLayoutReportContext::layer
QgsVectorLayer * layer() const
Returns the vector layer associated with the layout&#39;s context.
Definition: qgslayoutreportcontext.cpp:65

QgsExpressionContextScope::hasFunction
bool hasFunction(const QString &name) const
Tests whether a function with the specified name exists in the scope.
Definition: qgsexpressioncontext.cpp:197

QgsExpressionContext::EXPR_SYMBOL_ANGLE
static const QString EXPR_SYMBOL_ANGLE
Inbuilt variable name for symbol angle variable.
Definition: qgsexpressioncontext.h:699

QgsExpressionContextUtils::globalScope
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context...
Definition: qgsexpressioncontext.cpp:568

QgsMapLayer::id
QString id() const
Returns the layer&#39;s unique ID, which is used to access this layer from QgsProject.
Definition: qgsmaplayer.cpp:143

QgsLayoutObject::layout
const QgsLayout * layout() const
Returns the layout the object is attached to.
Definition: qgslayoutobject.cpp:101

QgsLayoutPageCollection::page
QgsLayoutItemPage * page(int pageNumber)
Returns a specific page (by pageNumber) from the collection.
Definition: qgslayoutpagecollection.cpp:442

QgsVectorLayer::fields
QgsFields fields() const override
Returns the list of fields of this layer.
Definition: qgsvectorlayer.h:1320

QgsExpressionContext::scopeCount
int scopeCount() const
Returns the number of scopes contained in the context.
Definition: qgsexpressioncontext.cpp:454

qgsprocessingalgorithm.h

QgsExpressionContext::isHighlightedVariable
bool isHighlightedVariable(const QString &name) const
Returns true if the specified variable name is intended to be highlighted to the user.
Definition: qgsexpressioncontext.cpp:304

QgsLayout::pageCollection
QgsLayoutPageCollection * pageCollection()
Returns a pointer to the layout&#39;s page collection, which stores and manages page items in the layout...
Definition: qgslayout.cpp:455

QgsExpressionContextUtils::setProjectVariables
static void setProjectVariables(QgsProject *project, const QVariantMap &variables)
Sets all project context variables.
Definition: qgsexpressioncontext.cpp:806

QgsMapSettings::scale
double scale() const
Returns the calculated map scale.
Definition: qgsmapsettings.cpp:366

QgsLayoutRenderContext::dpi
double dpi() const
Returns the dpi for outputting the layout.
Definition: qgslayoutrendercontext.cpp:83

QgsRectangle::width
double width() const
Returns the width of the rectangle.
Definition: qgsrectangle.h:142

QgsExpressionContextUtils::notificationScope
static QgsExpressionContextScope * notificationScope(const QString &message=QString())
Creates a new scope which contains variables and functions relating to provider notifications.
Definition: qgsexpressioncontext.cpp:1224

QgsExpressionContext
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Definition: qgsexpressioncontext.h:375

QgsExpressionContextUtils::removeGlobalVariable
static void removeGlobalVariable(const QString &name)
Remove a global context variable.
Definition: qgsexpressioncontext.cpp:603

QgsProject::crs
QgsCoordinateReferenceSystem crs
Definition: qgsproject.h:88

QgsExpressionContext::variablesToMap
QVariantMap variablesToMap() const
Returns a map of variable name to value representing all the expression variables contained by the co...
Definition: qgsexpressioncontext.cpp:293

QgsLayoutAtlas
Class used to render an Atlas, iterating over geometry features.
Definition: qgslayoutatlas.h:37

qgsapplication.h

QgsExpressionContextScope::variable
QVariant variable(const QString &name) const
Retrieves a variable&#39;s value from the scope.
Definition: qgsexpressioncontext.cpp:127

QgsExpressionContext::EXPR_SYMBOL_COLOR
static const QString EXPR_SYMBOL_COLOR
Inbuilt variable name for symbol color variable.
Definition: qgsexpressioncontext.h:697

QgsProject::readListEntry
QStringList readListEntry(const QString &scope, const QString &key, const QStringList &def=QStringList(), bool *ok=nullptr) const
Key value accessors.
Definition: qgsproject.cpp:1600

QgsProject
Reads and writes project states.
Definition: qgsproject.h:82

QgsApplication::setCustomVariable
static void setCustomVariable(const QString &name, const QVariant &value)
Set a single custom expression variable.
Definition: qgsapplication.cpp:1417

QgsSymbol::color
QColor color() const
Definition: qgssymbol.cpp:454

QgsLayoutAtlas::currentFilename
QString currentFilename() const
Returns the current feature filename.
Definition: qgslayoutatlas.cpp:433

QgsLayoutItem::page
int page() const
Returns the page the item is currently on, with the first page returning 0.
Definition: qgslayoutitem.cpp:492

QgsLayoutItem::id
QString id() const
Returns the item&#39;s ID name.
Definition: qgslayoutitem.h:325

QgsExpressionContextUtils::globalProjectLayerScopes
static QList< QgsExpressionContextScope * > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer&#39;s project and layer.
Definition: qgsexpressioncontext.cpp:867

qgslayoutreportcontext.h

QgsExpressionContextScope::function
QgsExpressionFunction * function(const QString &name) const
Retrieves a function from the scope.
Definition: qgsexpressioncontext.cpp:202

QgsExpressionContext::EXPR_FIELDS
static const QString EXPR_FIELDS
Inbuilt variable name for fields storage.
Definition: qgsexpressioncontext.h:693

QgsExpressionContext::variableNames
QStringList variableNames() const
Returns a list of variables names set by all scopes in the context.
Definition: qgsexpressioncontext.cpp:377

QgsLayoutAtlas::count
int count() override
Returns the number of features to iterate over.
Definition: qgslayoutatlas.cpp:339

QgsExpressionContextScope
Single scope for storing variables and functions for use within a QgsExpressionContext.
Definition: qgsexpressioncontext.h:129

QgsFeature::geometry
QgsGeometry geometry() const
Returns the geometry associated with this feature.
Definition: qgsfeature.cpp:101

QgsExpressionContextScope::setFeature
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the scope.
Definition: qgsexpressioncontext.h:335

QgsExpressionContextScope::functionNames
QStringList functionNames() const
Retrieves a list of names of functions contained in the scope.
Definition: qgsexpressioncontext.cpp:207

QgsProject::setCustomVariables
void setCustomVariables(const QVariantMap &customVariables)
A map of custom project variables.
Definition: qgsproject.cpp:1131

QgsLayout
Base class for layouts, which can contain items such as maps, labels, scalebars, etc.
Definition: qgslayout.h:49

QgsExpressionContext::setFields
void setFields(const QgsFields &fields)
Convenience function for setting a fields for the context.
Definition: qgsexpressioncontext.cpp:521

QgsExpressionContextUtils::setLayerVariable
static void setLayerVariable(QgsMapLayer *layer, const QString &name, const QVariant &value)
Sets a layer context variable.
Definition: qgsexpressioncontext.cpp:881

QgsApplication::userLoginName
static QString userLoginName()
Returns the user&#39;s operating system login account name.
Definition: qgsapplication.cpp:852

QgsApplication::osName
static QString osName()
Returns a string name of the operating system QGIS is running on.
Definition: qgsapplication.cpp:921

QgsLayoutPageCollection::pageCount
int pageCount() const
Returns the number of pages in the collection.
Definition: qgslayoutpagecollection.cpp:437

qgsgeometry.h

QgsLayoutAtlas::currentFeatureNumber
int currentFeatureNumber() const
Returns the current feature number, where a value of 0 corresponds to the first feature.
Definition: qgslayoutatlas.h:250

QgsLayout::reportContext
QgsLayoutReportContext & reportContext()
Returns a reference to the layout&#39;s report context, which stores information relating to the current ...
Definition: qgslayout.cpp:365

QgsExpressionContextUtils::setProjectVariable
static void setProjectVariable(QgsProject *project, const QString &name, const QVariant &value)
Sets a project context variable.
Definition: qgsexpressioncontext.cpp:794

qgsfields.h

QgsExpressionContextUtils::registerContextFunctions
static void registerContextFunctions()
Registers all known core functions provided by QgsExpressionContextScope objects. ...
Definition: qgsexpressioncontext.cpp:1231

QgsExpressionContextUtils::atlasScope
static QgsExpressionContextScope * atlasScope(QgsLayoutAtlas *atlas)
Creates a new scope which contains variables and functions relating to a QgsLayoutAtlas.
Definition: qgsexpressioncontext.cpp:1078

QgsProject::fileInfo
QFileInfo fileInfo() const
Returns QFileInfo object for the project&#39;s associated file.
Definition: qgsproject.cpp:441

QgsExpressionContextUtils::mapSettingsScope
static QgsExpressionContextScope * mapSettingsScope(const QgsMapSettings &mapSettings)
Creates a new scope which contains variables and functions relating to a QgsMapSettings object...
Definition: qgsexpressioncontext.cpp:916

QgsExpressionContext::functionNames
QStringList functionNames() const
Retrieves a list of function names contained in the context.
Definition: qgsexpressioncontext.cpp:429

Qgis::QGIS_RELEASE_NAME
static const QString QGIS_RELEASE_NAME
Release name.
Definition: qgis.h:67

QgsExpressionContext::QgsExpressionContext
QgsExpressionContext()=default
Constructor for QgsExpressionContext.

QgsExpressionContextUtils::layoutScope
static QgsExpressionContextScope * layoutScope(const QgsLayout *layout)
Creates a new scope which contains variables and functions relating to a QgsLayout layout...
Definition: qgsexpressioncontext.cpp:985

QgsExpressionContext::clearCachedValues
void clearCachedValues() const
Clears all cached values from the context.
Definition: qgsexpressioncontext.cpp:558

QgsExpressionContext::appendScope
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Definition: qgsexpressioncontext.cpp:459

QgsProject::instance
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:383

QgsLayoutItem::uuid
virtual QString uuid() const
Returns the item identification string.
Definition: qgslayoutitem.h:317

QgsCoordinateReferenceSystem
This class represents a coordinate reference system (CRS).
Definition: qgscoordinatereferencesystem.h:189

QgsExpressionContextScope::isStatic
bool isStatic(const QString &name) const
Tests whether the variable with the specified name is static and can be cached.
Definition: qgsexpressioncontext.cpp:187

QgsLayoutAtlas::nameForPage
QString nameForPage(int page) const
Returns the calculated name for a specified atlas page number.
Definition: qgslayoutatlas.cpp:161

QgsApplication::platform
static QString platform()
Returns the QGIS platform name, e.g., "desktop" or "server".
Definition: qgsapplication.cpp:936

qgssymbollayerutils.h

qgsvectorlayer.h

QgsExpressionContext::EXPR_CLUSTER_SIZE
static const QString EXPR_CLUSTER_SIZE
Inbuilt variable name for cluster size variable.
Definition: qgsexpressioncontext.h:709

QgsLayout::setCustomProperty
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for the layout.
Definition: qgslayout.cpp:403

QgsLayoutAtlas::enabled
bool enabled() const
Returns whether the atlas generation is enabled.
Definition: qgslayoutatlas.h:63

QgsExpressionContextScope::hasFeature
bool hasFeature() const
Returns true if the scope has a feature associated with it.
Definition: qgsexpressioncontext.h:318

QgsExpressionContext::feature
QgsFeature feature() const
Convenience function for retrieving the feature for the context, if set.
Definition: qgsexpressioncontext.cpp:508

QgsExpressionContext::EXPR_GEOMETRY_POINT_NUM
static const QString EXPR_GEOMETRY_POINT_NUM
Inbuilt variable name for point number variable.
Definition: qgsexpressioncontext.h:707

QgsLayoutAtlas::coverageLayer
QgsVectorLayer * coverageLayer() const
Returns the coverage layer used for the atlas features.
Definition: qgslayoutatlas.h:112

QgsLayoutReportContext::feature
QgsFeature feature() const
Returns the current feature for evaluating the layout.
Definition: qgslayoutreportcontext.h:60

QgsExpressionContext::setHighlightedVariables
void setHighlightedVariables(const QStringList &variableNames)
Sets the list of variable names within the context intended to be highlighted to the user...
Definition: qgsexpressioncontext.cpp:309

QgsMapLayer::name
QString name
Definition: qgsmaplayer.h:60

QgsExpressionContext::appendScopes
void appendScopes(const QList< QgsExpressionContextScope *> &scopes)
Appends a list of scopes to the end of the context.
Definition: qgsexpressioncontext.cpp:464

QgsMapLayer::customProperty
QVariant customProperty(const QString &value, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer.
Definition: qgsmaplayer.cpp:1864

qgslayoutpagecollection.h

QgsProject::title
QString title() const
Returns the project&#39;s title.
Definition: qgsproject.cpp:403

QgsRectangle::center
QgsPointXY center() const
Returns the center point of the rectangle.
Definition: qgsrectangle.h:170

QgsProject::customVariables
QVariantMap customVariables() const
A map of custom project variables.
Definition: qgsproject.cpp:1126

QgsExpressionContextScope::name
QString name() const
Returns the friendly display name of the context scope.
Definition: qgsexpressioncontext.h:189

QgsExpressionContext::popScope
QgsExpressionContextScope * popScope()
Removes the last scope from the expression context and return it.
Definition: qgsexpressioncontext.cpp:469

QgsExpressionContextUtils::layerScope
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
Definition: qgsexpressioncontext.cpp:826

QgsMasterLayoutInterface
Interface for master layout type objects, such as print layouts and reports.
Definition: qgsmasterlayoutinterface.h:41

QgsExpressionContext::EXPR_GEOMETRY_PART_NUM
static const QString EXPR_GEOMETRY_PART_NUM
Inbuilt variable name for geometry part number variable.
Definition: qgsexpressioncontext.h:703

QgsExpressionContextScope::StaticVariable::isStatic
bool isStatic
A static variable can be cached for the lifetime of a context.
Definition: qgsexpressioncontext.h:165

QgsVectorLayer
Represents a vector layer which manages a vector based data sets.
Definition: qgsvectorlayer.h:353

QgsExpressionContext::indexOfScope
int indexOfScope(QgsExpressionContextScope *scope) const
Returns the index of the specified scope if it exists within the context.
Definition: qgsexpressioncontext.cpp:356

QgsExpressionContext::EXPR_GEOMETRY_PART_COUNT
static const QString EXPR_GEOMETRY_PART_COUNT
Inbuilt variable name for geometry part count variable.
Definition: qgsexpressioncontext.h:701

QgsProcessingContext
Contains information about the context in which a processing algorithm is executed.
Definition: qgsprocessingcontext.h:40

QgsExpressionContext::setOriginalValueVariable
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for the context.
Definition: qgsexpressioncontext.cpp:534

QgsExpressionContextScope::filteredVariableNames
QStringList filteredVariableNames() const
Returns a filtered and sorted list of variable names contained within the scope.
Definition: qgsexpressioncontext.cpp:165

QgsExpressionContext::scopes
QList< QgsExpressionContextScope *> scopes()
Returns a list of scopes contained within the stack.
Definition: qgsexpressioncontext.h:481

QgsExpressionContextUtils::setGlobalVariables
static void setGlobalVariables(const QVariantMap &variables)
Sets all global context variables.
Definition: qgsexpressioncontext.cpp:598

QgsExpressionContext::function
QgsExpressionFunction * function(const QString &name) const
Fetches a matching function from the context.
Definition: qgsexpressioncontext.cpp:441

QgsScopedExpressionFunction
Expression function for use within a QgsExpressionContextScope.
Definition: qgsexpressioncontext.h:55

QgsMarkerSymbol::angle
double angle() const
Returns the marker angle for the whole symbol.
Definition: qgssymbol.cpp:1146

QgsGeometry::fromPointXY
static QgsGeometry fromPointXY(const QgsPointXY &point)
Creates a new geometry from a QgsPointXY object.
Definition: qgsgeometry.cpp:159

QgsCoordinateReferenceSystem::authid
QString authid() const
Returns the authority identifier for the CRS.
Definition: qgscoordinatereferencesystem.cpp:977

QgsExpressionContextScope::StaticVariable::name
QString name
Variable name.
Definition: qgsexpressioncontext.h:156

QgsScopedExpressionFunction::referencedColumns
QSet< QString > referencedColumns(const QgsExpressionNodeFunction *node) const override
Definition: qgsexpressioncontext.cpp:1245

QgsSymbolLayerUtils::decodeColor
static QColor decodeColor(const QString &str)
Definition: qgssymbollayerutils.cpp:53

QgsRectangle::height
double height() const
Returns the height of the rectangle.
Definition: qgsrectangle.h:149

QgsLayoutItemPage
Item representing the paper in a layout.
Definition: qgslayoutitempage.h:54

qgslogger.h

QgsExpressionContextScope::StaticVariable::value
QVariant value
Variable value.
Definition: qgsexpressioncontext.h:159