qgsmaplayeractionregistry.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsmaplayeractionregistry.cpp
    -----------------------------
    begin                : January 2014
    copyright            : (C) 2014 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 "qgsmaplayeractionregistry.h"


QgsMapLayerAction::QgsMapLayerAction( const QString& name, QObject* parent, const Targets& targets, const QIcon& icon )
    : QAction( icon, name, parent )
    , mSingleLayer( false )
    , mActionLayer( nullptr )
    , mSpecificLayerType( false )
    , mLayerType( QgsMapLayer::VectorLayer )
    , mTargets( targets )
{
}

QgsMapLayerAction::QgsMapLayerAction( const QString& name, QObject* parent, QgsMapLayer* layer, const Targets& targets, const QIcon& icon )
    : QAction( icon, name, parent )
    , mSingleLayer( true )
    , mActionLayer( layer )
    , mSpecificLayerType( false )
    , mLayerType( QgsMapLayer::VectorLayer )
    , mTargets( targets )
{
}

QgsMapLayerAction::QgsMapLayerAction( const QString& name, QObject* parent, QgsMapLayer::LayerType layerType, const Targets& targets, const QIcon& icon )
    : QAction( icon, name, parent )
    , mSingleLayer( false )
    , mActionLayer( nullptr )
    , mSpecificLayerType( true )
    , mLayerType( layerType )
    , mTargets( targets )
{
}

QgsMapLayerAction::~QgsMapLayerAction()
{
  //remove action from registry
  QgsMapLayerActionRegistry::instance()->removeMapLayerAction( this );
}

bool QgsMapLayerAction::canRunUsingLayer( QgsMapLayer* layer ) const
{
  //check layer details
  if ( !mSingleLayer && !mSpecificLayerType )
  {
    //action is not a single layer of specific layer type action,
    //so return true
    return true;
  }
  if ( mSingleLayer && layer == mActionLayer )
  {
    //action is a single layer type and layer matches
    return true;
  }
  else if ( mSpecificLayerType && layer->type() == mLayerType )
  {
    //action is for a layer type and layer type matches
    return true;
  }

  return false;
}

void QgsMapLayerAction::triggerForFeatures( QgsMapLayer* layer, const QList<QgsFeature>& featureList )
{
  emit triggeredForFeatures( layer, featureList );
}

void QgsMapLayerAction::triggerForFeature( QgsMapLayer* layer, const QgsFeature* feature )
{
  emit triggeredForFeature( layer, *feature );
}

void QgsMapLayerAction::triggerForLayer( QgsMapLayer* layer )
{
  emit triggeredForLayer( layer );
}

//
// Static calls to enforce singleton behaviour
//
QgsMapLayerActionRegistry *QgsMapLayerActionRegistry::mInstance = nullptr;
QgsMapLayerActionRegistry *QgsMapLayerActionRegistry::instance()
{
  if ( !mInstance )
  {
    mInstance = new QgsMapLayerActionRegistry();
  }
  return mInstance;
}

//
// Main class begins now...
//

QgsMapLayerActionRegistry::QgsMapLayerActionRegistry( QObject *parent ) : QObject( parent )
{
  // constructor does nothing
}

QgsMapLayerActionRegistry::~QgsMapLayerActionRegistry()
{

}

void QgsMapLayerActionRegistry::addMapLayerAction( QgsMapLayerAction * action )
{
  mMapLayerActionList.append( action );
  emit changed();
}

QList< QgsMapLayerAction* > QgsMapLayerActionRegistry::mapLayerActions( QgsMapLayer* layer, const QgsMapLayerAction::Targets& targets )
{
  QList< QgsMapLayerAction* > validActions;
  QList<QgsMapLayerAction*>::iterator actionIt;
  for ( actionIt = mMapLayerActionList.begin(); actionIt != mMapLayerActionList.end(); ++actionIt )
  {
    if (( *actionIt )->canRunUsingLayer( layer ) && ( targets & ( *actionIt )->targets() ) )
    {
      validActions.append(( *actionIt ) );
    }
  }
  return validActions;
}


bool QgsMapLayerActionRegistry::removeMapLayerAction( QgsMapLayerAction* action )
{
  if ( mMapLayerActionList.indexOf( action ) != -1 )
  {
    mMapLayerActionList.removeAll( action );

    //also remove this action from the default layer action map
    QMap<QgsMapLayer*, QgsMapLayerAction*>::iterator defaultIt;
    for ( defaultIt = mDefaultLayerActionMap.begin(); defaultIt != mDefaultLayerActionMap.end(); ++defaultIt )
    {
      if ( defaultIt.value() == action )
      {
        defaultIt.value() = nullptr;
      }
    }
    emit changed();
    return true;
  }
  //not found
  return false;
}

void QgsMapLayerActionRegistry::setDefaultActionForLayer( QgsMapLayer* layer, QgsMapLayerAction* action )
{
  mDefaultLayerActionMap[ layer ] = action;
}

QgsMapLayerAction * QgsMapLayerActionRegistry::defaultActionForLayer( QgsMapLayer* layer )
{
  if ( !mDefaultLayerActionMap.contains( layer ) )
  {
    return nullptr;
  }

  return mDefaultLayerActionMap[ layer ];
}