[map layer actions] action for group of features, rename availability to target (flags), only emit signal for defined target"

3nids · 3nids · commit 252dc377a43f · 2014-09-01T08:22:23.000+02:00
Conflicts:
	src/gui/qgsmaplayeractionregistry.cpp
	src/gui/qgsmaplayeractionregistry.h
diff --git a/python/gui/qgsmaplayeractionregistry.sip b/python/gui/qgsmaplayeractionregistry.sip
@@ -5,20 +5,21 @@ class QgsMapLayerAction : QAction
 %End
 
   public:
-    enum AvailabityFlag
+    enum Target
     {
-        Layer,
-        Feature,
-        LayerAndFeature
+      Layer ,
+      SingleFeature,
+      MultipleFeatures,
+      AllActions
     };
-    typedef QFlags<QgsMapLayerAction::AvailabityFlag> Availability;
+    typedef QFlags<QgsMapLayerAction::Target> Targets;
 
     /**Creates a map layer action which can run on any layer*/
-    QgsMapLayerAction( QString name, QObject *parent, Availability availability = LayerAndFeature );
+    QgsMapLayerAction( QString name, QObject *parent, Targets targets = AllActions );
     /**Creates a map layer action which can run only on a specific layer*/
-    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer* layer, Availability availability = LayerAndFeature );
+    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer* layer, Targets targets = AllActions );
     /**Creates a map layer action which can run on a specific type of layer*/
-    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer::LayerType layerType, Availability availability = LayerAndFeature );
+    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer::LayerType layerType, Targets targets = AllActions );
     ~QgsMapLayerAction();
 
     /** True if action can run using the specified layer */
@@ -31,9 +32,9 @@ class QgsMapLayerAction : QAction
     /** Triggers the action with the specified layer. This also emits the triggered() slot. */
     void triggerForLayer( QgsMapLayer* layer );
 
-    /** Define the availibility of the action */
-    void setAvailability( Availability availability );
-    Availability availability() const;
+    /** Define the targets of the action */
+    void setTargets( Targets targets );
+    Targets targets() const;
 
   signals:
     /** Triggered when action has been run for a specific feature */
@@ -60,7 +61,7 @@ class QgsMapLayerActionRegistry : QObject
     void addMapLayerAction( QgsMapLayerAction * action );
 
     /**Returns the map layer actions which can run on the specified layer*/
-    QList<QgsMapLayerAction *> mapLayerActions( QgsMapLayer* layer );
+    QList<QgsMapLayerAction *> mapLayerActions( QgsMapLayer* layer, QgsMapLayerAction::Targets targets = QgsMapLayerAction::AllActions );
 
     /**Removes a map layer action from the registry*/
     bool removeMapLayerAction( QgsMapLayerAction *action );
diff --git a/src/app/composer/qgscomposer.cpp b/src/app/composer/qgscomposer.cpp
@@ -3573,7 +3573,7 @@ void QgsComposer::updateAtlasMapLayerAction( QgsVectorLayer *coverageLayer )
 
   if ( coverageLayer )
   {
-    mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, coverageLayer, QgsMapLayerAction::Feature );
+    mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, coverageLayer, QgsMapLayerAction::SingleFeature );
     QgsMapLayerActionRegistry::instance()->addMapLayerAction( mAtlasFeatureAction );
     connect( mAtlasFeatureAction, SIGNAL( triggeredForFeature( QgsMapLayer*, QgsFeature* ) ), this, SLOT( setAtlasFeature( QgsMapLayer*, QgsFeature* ) ) );
   }
@@ -3618,7 +3618,7 @@ void QgsComposer::updateAtlasMapLayerAction( bool atlasEnabled )
   if ( atlasEnabled )
   {
     QgsAtlasComposition& atlas = mComposition->atlasComposition();
-    mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, atlas.coverageLayer() );
+    mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, atlas.coverageLayer(), QgsMapLayerAction::SingleFeature );
     QgsMapLayerActionRegistry::instance()->addMapLayerAction( mAtlasFeatureAction );
     connect( mAtlasFeatureAction, SIGNAL( triggeredForFeature( QgsMapLayer*, QgsFeature* ) ), this, SLOT( setAtlasFeature( QgsMapLayer*, QgsFeature* ) ) );
   }
diff --git a/src/gui/qgsmaplayeractionregistry.cpp b/src/gui/qgsmaplayeractionregistry.cpp
@@ -16,30 +16,30 @@
 #include "qgsmaplayeractionregistry.h"
 
 
-QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, Availability availability ) : QAction( name, parent ),
+QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, Targets targets ) : QAction( name, parent ),
     mSingleLayer( false ),
     mActionLayer( 0 ),
     mSpecificLayerType( false ),
-    mAvailability( availability )
+    mTargets( targets )
 {
 }
 
 /**Creates a map layer action which can run only on a specific layer*/
-QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer* layer , Availability availability ) : QAction( name, parent ),
+QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer* layer , Targets targets ) : QAction( name, parent ),
     mSingleLayer( true ),
     mActionLayer( layer ),
     mSpecificLayerType( false ),
-    mAvailability( availability )
+    mTargets( targets )
 {
 }
 
 /**Creates a map layer action which can run on a specific type of layer*/
-QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer::LayerType layerType, Availability availability ) : QAction( name, parent ),
+QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer::LayerType layerType, Targets targets ) : QAction( name, parent ),
     mSingleLayer( false ),
     mActionLayer( 0 ),
     mSpecificLayerType( true ),
     mLayerType( layerType ),
-    mAvailability( availability )
+    mTargets( targets )
 {
 }
 
@@ -72,18 +72,19 @@ bool QgsMapLayerAction::canRunUsingLayer( QgsMapLayer* layer ) const
   return false;
 }
 
-void QgsMapLayerAction::triggerForFeature( QgsMapLayer* layer, QgsFeature* feature )
+void QgsMapLayerAction::triggerForFeatures( QgsMapLayer* layer, QList<const QgsFeature*> featureList )
+{
+  emit triggeredForFeatures( layer, featureList );
+}
+
+void QgsMapLayerAction::triggerForFeature( QgsMapLayer* layer, const QgsFeature* feature )
 {
   emit triggeredForFeature( layer, feature );
-  //also trigger this action for the specified layer
-  triggerForLayer( layer );
 }
 
 void QgsMapLayerAction::triggerForLayer( QgsMapLayer* layer )
 {
   emit triggeredForLayer( layer );
-  //also emit triggered signal
-  emit triggered();
 }
 
 //
@@ -119,13 +120,13 @@ void QgsMapLayerActionRegistry::addMapLayerAction( QgsMapLayerAction * action )
   emit changed();
 }
 
-QList< QgsMapLayerAction* > QgsMapLayerActionRegistry::mapLayerActions( QgsMapLayer* layer )
+QList< QgsMapLayerAction* > QgsMapLayerActionRegistry::mapLayerActions( QgsMapLayer* layer, QgsMapLayerAction::Targets targets )
 {
   QList< QgsMapLayerAction* > validActions;
   QList<QgsMapLayerAction*>::iterator actionIt;
   for ( actionIt = mMapLayerActionList.begin(); actionIt != mMapLayerActionList.end(); ++actionIt )
   {
-    if (( *actionIt )->canRunUsingLayer( layer ) )
+    if (( *actionIt )->canRunUsingLayer( layer ) && ( targets & ( *actionIt )->targets() ) )
     {
       validActions.append(( *actionIt ) );
     }
diff --git a/src/gui/qgsmaplayeractionregistry.h b/src/gui/qgsmaplayeractionregistry.h
@@ -34,62 +34,71 @@ class GUI_EXPORT QgsMapLayerAction : public QAction
     Q_FLAGS( Availability )
 
   public:
-    enum AvailabityFlag
+    enum Target
     {
       Layer = 1,
-      Feature = 2,
-      LayerAndFeature = Layer | Feature
+      SingleFeature = 2,
+      MultipleFeatures = 4,
+      AllActions = Layer | SingleFeature | MultipleFeatures
     };
-    Q_DECLARE_FLAGS( Availability, AvailabityFlag )
+    Q_DECLARE_FLAGS( Targets, Target )
+
+    //! Creates a map layer action which can run on any layer
+    //! @note using AllActions as a target probably does not make a lot of sense. This default action was settled for API compatiblity reasons.
+    QgsMapLayerAction( QString name, QObject *parent, Targets targets = AllActions );
 
-    /**Creates a map layer action which can run on any layer*/
-    QgsMapLayerAction( QString name, QObject *parent, Availability availability = LayerAndFeature );
     /**Creates a map layer action which can run only on a specific layer*/
-    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer* layer, Availability availability = LayerAndFeature );
+    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer* layer, Targets targets = AllActions );
+
     /**Creates a map layer action which can run on a specific type of layer*/
-    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer::LayerType layerType, Availability availability = LayerAndFeature );
+    QgsMapLayerAction( QString name, QObject *parent, QgsMapLayer::LayerType layerType, Targets targets = AllActions );
 
     ~QgsMapLayerAction();
 
     /** True if action can run using the specified layer */
     bool canRunUsingLayer( QgsMapLayer* layer ) const;
 
-    /** Triggers the action with the specified layer and feature. This also emits the triggeredForLayer( QgsMapLayer *)
-     * and triggered() slots */
-    void triggerForFeature( QgsMapLayer* layer, QgsFeature* feature );
+    /** Triggers the action with the specified layer and list of feature. */
+    void triggerForFeatures( QgsMapLayer* layer, QList<const QgsFeature*> featureList );
 
-    /** Triggers the action with the specified layer. This also emits the triggered() slot. */
+    /** Triggers the action with the specified layer and feature.  */
+    void triggerForFeature( QgsMapLayer* layer, const QgsFeature* feature );
+
+    /** Triggers the action with the specified layer. */
     void triggerForLayer( QgsMapLayer* layer );
 
-    /** Define the availibility of the action */
-    void setAvailability( Availability availability ) {mAvailability = availability;}
+    /** Define the targets of the action */
+    void setTargets( Targets targets ) {mTargets = targets;}
     /** Return availibity of action */
-    Availability availability() const {return mAvailability;}
+    Targets targets() const {return mTargets;}
 
   signals:
+    /** Triggered when action has been run for a specific list of features */
+    void triggeredForFeatures( QgsMapLayer* layer, QList<const QgsFeature*> featureList );
+
     /** Triggered when action has been run for a specific feature */
-    void triggeredForFeature( QgsMapLayer* layer, QgsFeature* feature );
+    void triggeredForFeature( QgsMapLayer* layer, const QgsFeature* feature );
 
     /** Triggered when action has been run for a specific layer */
     void triggeredForLayer( QgsMapLayer* layer );
 
   private:
 
-    //true if action is only valid for a single layer
+    // true if action is only valid for a single layer
     bool mSingleLayer;
-    //layer if action is only valid for a single layer
+    // layer if action is only valid for a single layer
     QgsMapLayer* mActionLayer;
 
-    //true if action is only valid for a specific layer type
+    // true if action is only valid for a specific layer type
     bool mSpecificLayerType;
-    //layer type if action is only valid for a specific layer type
+    // layer type if action is only valid for a specific layer type
     QgsMapLayer::LayerType mLayerType;
 
-    // determine if the action can be run on feature and/or layer
-    Availability mAvailability;
+    // determine if the action can be run on layer and/or single feature and/or multiple features
+    Targets mTargets;
 };
 
-Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapLayerAction::Availability )
+Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapLayerAction::Targets )
 
 /**
 * This class tracks map layer actions
@@ -108,7 +117,7 @@ class GUI_EXPORT QgsMapLayerActionRegistry : public QObject
     void addMapLayerAction( QgsMapLayerAction * action );
 
     /**Returns the map layer actions which can run on the specified layer*/
-    QList<QgsMapLayerAction *> mapLayerActions( QgsMapLayer* layer );
+    QList<QgsMapLayerAction *> mapLayerActions( QgsMapLayer* layer, QgsMapLayerAction::Targets targets = QgsMapLayerAction::AllActions );
 
     /**Removes a map layer action from the registry*/
     bool removeMapLayerAction( QgsMapLayerAction *action );

Original file line number	Diff line number	Diff line change
`@@ -3573,7 +3573,7 @@ void QgsComposer::updateAtlasMapLayerAction( QgsVectorLayer *coverageLayer )`
`3573`	`3573`
`3574`	`3574`	`if ( coverageLayer )`
`3575`	`3575`	`{`
`3576`		`- mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, coverageLayer, QgsMapLayerAction::Feature );`
	`3576`	`+ mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, coverageLayer, QgsMapLayerAction::SingleFeature );`
`3577`	`3577`	`QgsMapLayerActionRegistry::instance()->addMapLayerAction( mAtlasFeatureAction );`
`3578`	`3578`	`connect( mAtlasFeatureAction, SIGNAL( triggeredForFeature( QgsMapLayer, QgsFeature ) ), this, SLOT( setAtlasFeature( QgsMapLayer, QgsFeature ) ) );`
`3579`	`3579`	`}`
`@@ -3618,7 +3618,7 @@ void QgsComposer::updateAtlasMapLayerAction( bool atlasEnabled )`
`3618`	`3618`	`if ( atlasEnabled )`
`3619`	`3619`	`{`
`3620`	`3620`	`QgsAtlasComposition& atlas = mComposition->atlasComposition();`
`3621`		`- mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, atlas.coverageLayer() );`
	`3621`	`+ mAtlasFeatureAction = new QgsMapLayerAction( QString( tr( "Set as atlas feature for %1" ) ).arg( mTitle ), this, atlas.coverageLayer(), QgsMapLayerAction::SingleFeature );`
`3622`	`3622`	`QgsMapLayerActionRegistry::instance()->addMapLayerAction( mAtlasFeatureAction );`
`3623`	`3623`	`connect( mAtlasFeatureAction, SIGNAL( triggeredForFeature( QgsMapLayer, QgsFeature ) ), this, SLOT( setAtlasFeature( QgsMapLayer, QgsFeature ) ) );`
`3624`	`3624`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,30 +16,30 @@`
`16`	`16`	`#include "qgsmaplayeractionregistry.h"`
`17`	`17`
`18`	`18`
`19`		`-QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, Availability availability ) : QAction( name, parent ),`
	`19`	`+QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, Targets targets ) : QAction( name, parent ),`
`20`	`20`	`mSingleLayer( false ),`
`21`	`21`	`mActionLayer( 0 ),`
`22`	`22`	`mSpecificLayerType( false ),`
`23`		`- mAvailability( availability )`
	`23`	`+ mTargets( targets )`
`24`	`24`	`{`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`/*Creates a map layer action which can run only on a specific layer/`
`28`		`-QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer* layer , Availability availability ) : QAction( name, parent ),`
	`28`	`+QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer* layer , Targets targets ) : QAction( name, parent ),`
`29`	`29`	`mSingleLayer( true ),`
`30`	`30`	`mActionLayer( layer ),`
`31`	`31`	`mSpecificLayerType( false ),`
`32`		`- mAvailability( availability )`
	`32`	`+ mTargets( targets )`
`33`	`33`	`{`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`/*Creates a map layer action which can run on a specific type of layer/`
`37`		`-QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer::LayerType layerType, Availability availability ) : QAction( name, parent ),`
	`37`	`+QgsMapLayerAction::QgsMapLayerAction( QString name, QObject* parent, QgsMapLayer::LayerType layerType, Targets targets ) : QAction( name, parent ),`
`38`	`38`	`mSingleLayer( false ),`
`39`	`39`	`mActionLayer( 0 ),`
`40`	`40`	`mSpecificLayerType( true ),`
`41`	`41`	`mLayerType( layerType ),`
`42`		`- mAvailability( availability )`
	`42`	`+ mTargets( targets )`
`43`	`43`	`{`
`44`	`44`	`}`
`45`	`45`
`@@ -72,18 +72,19 @@ bool QgsMapLayerAction::canRunUsingLayer( QgsMapLayer* layer ) const`
`72`	`72`	`return false;`
`73`	`73`	`}`
`74`	`74`
`75`		`-void QgsMapLayerAction::triggerForFeature( QgsMapLayer* layer, QgsFeature* feature )`
	`75`	`+void QgsMapLayerAction::triggerForFeatures( QgsMapLayer* layer, QList<const QgsFeature*> featureList )`
	`76`	`+{`
	`77`	`+ emit triggeredForFeatures( layer, featureList );`
	`78`	`+}`
	`79`	`+`
	`80`	`+void QgsMapLayerAction::triggerForFeature( QgsMapLayer* layer, const QgsFeature* feature )`
`76`	`81`	`{`
`77`	`82`	`emit triggeredForFeature( layer, feature );`
`78`		`- //also trigger this action for the specified layer`
`79`		`- triggerForLayer( layer );`
`80`	`83`	`}`
`81`	`84`
`82`	`85`	`void QgsMapLayerAction::triggerForLayer( QgsMapLayer* layer )`
`83`	`86`	`{`
`84`	`87`	`emit triggeredForLayer( layer );`
`85`		`- //also emit triggered signal`
`86`		`- emit triggered();`
`87`	`88`	`}`
`88`	`89`
`89`	`90`	`//`
`@@ -119,13 +120,13 @@ void QgsMapLayerActionRegistry::addMapLayerAction( QgsMapLayerAction * action )`
`119`	`120`	`emit changed();`
`120`	`121`	`}`
`121`	`122`
`122`		`-QList< QgsMapLayerAction* > QgsMapLayerActionRegistry::mapLayerActions( QgsMapLayer* layer )`
	`123`	`+QList< QgsMapLayerAction* > QgsMapLayerActionRegistry::mapLayerActions( QgsMapLayer* layer, QgsMapLayerAction::Targets targets )`
`123`	`124`	`{`
`124`	`125`	`QList< QgsMapLayerAction* > validActions;`
`125`	`126`	`QList<QgsMapLayerAction*>::iterator actionIt;`
`126`	`127`	`for ( actionIt = mMapLayerActionList.begin(); actionIt != mMapLayerActionList.end(); ++actionIt )`
`127`	`128`	`{`
`128`		`- if (( *actionIt )->canRunUsingLayer( layer ) )`
	`129`	`+ if (( actionIt )->canRunUsingLayer( layer ) && ( targets & ( actionIt )->targets() ) )`
`129`	`130`	`{`
`130`	`131`	`validActions.append(( *actionIt ) );`
`131`	`132`	`}`