qgssnappingutils.h

Go to the documentation of this file.

/***************************************************************************
  qgssnappingutils.h
  --------------------------------------
  Date                 : November 2014
  Copyright            : (C) 2014 by Martin Dobias
  Email                : wonder dot sk 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.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef QGSSNAPPINGUTILS_H
#define QGSSNAPPINGUTILS_H


#include "qgsmapsettings.h"
#include "qgstolerance.h"
#include "qgspointlocator.h"

class CORE_EXPORT QgsSnappingUtils : public QObject
{
    Q_OBJECT
  public:
    QgsSnappingUtils( QObject* parent = nullptr );
    ~QgsSnappingUtils();

    // main actions

    QgsPointLocator* locatorForLayer( QgsVectorLayer* vl );

    QgsPointLocator::Match snapToMap( QPoint point, QgsPointLocator::MatchFilter* filter = nullptr );
    QgsPointLocator::Match snapToMap( const QgsPoint& pointMap, QgsPointLocator::MatchFilter* filter = nullptr );

    QgsPointLocator::Match snapToCurrentLayer( QPoint point, int type, QgsPointLocator::MatchFilter* filter = nullptr );

    // environment setup

    void setMapSettings( const QgsMapSettings& settings );
    const QgsMapSettings& mapSettings() const { return mMapSettings; }

    void setCurrentLayer( QgsVectorLayer* layer );
    QgsVectorLayer* currentLayer() const { return mCurrentLayer; }


    // configuration

    enum SnapToMapMode
    {
      SnapCurrentLayer,    
      SnapAllLayers,       
      SnapAdvanced,        
    };

    void setSnapToMapMode( SnapToMapMode mode );
    SnapToMapMode snapToMapMode() const { return mSnapToMapMode; }

    enum IndexingStrategy
    {
      IndexAlwaysFull,    
      IndexNeverFull,     
      IndexHybrid,        
      IndexExtent         
    };

    void setIndexingStrategy( IndexingStrategy strategy ) { mStrategy = strategy; }
    IndexingStrategy indexingStrategy() const { return mStrategy; }

    void setDefaultSettings( int type, double tolerance, QgsTolerance::UnitType unit );
    void defaultSettings( int& type, double& tolerance, QgsTolerance::UnitType& unit );

    struct LayerConfig
    {
      LayerConfig( QgsVectorLayer* l, QgsPointLocator::Types t, double tol, QgsTolerance::UnitType u )
          : layer( l )
          , type( t )
          , tolerance( tol )
          , unit( u )
      {}

      bool operator==( const LayerConfig& other ) const
      {
        return layer == other.layer && type == other.type && tolerance == other.tolerance && unit == other.unit;
      }
      bool operator!=( const LayerConfig& other ) const
      {
        return !operator==( other );
      }

      QgsVectorLayer* layer;
      QgsPointLocator::Types type;
      double tolerance;
      QgsTolerance::UnitType unit;
    };

    void setLayers( const QList<LayerConfig>& layers );
    QList<LayerConfig> layers() const { return mLayers; }

    void setSnapOnIntersections( bool enabled );
    bool snapOnIntersections() const { return mSnapOnIntersection; }

    QString dump();

  public slots:
    void readConfigFromProject();

  signals:
    void configChanged();

  protected:
    virtual void prepareIndexStarting( int count ) { Q_UNUSED( count ); }
    virtual void prepareIndexProgress( int index ) { Q_UNUSED( index ); }

  private slots:
    void onLayersWillBeRemoved( const QStringList& layerIds );

  private:
    const QgsCoordinateReferenceSystem* destCRS();

    void clearAllLocators();

    QgsPointLocator* locatorForLayerUsingStrategy( QgsVectorLayer* vl, const QgsPoint& pointMap, double tolerance );
    QgsPointLocator* temporaryLocatorForLayer( QgsVectorLayer* vl, const QgsPoint& pointMap, double tolerance );

    typedef QPair< QgsVectorLayer*, QgsRectangle > LayerAndAreaOfInterest;

    bool isIndexPrepared( QgsVectorLayer* vl, const QgsRectangle& areaOfInterest );
    void prepareIndex( const QList<LayerAndAreaOfInterest>& layers );

  private:
    // environment
    QgsMapSettings mMapSettings;
    QgsVectorLayer* mCurrentLayer;

    // configuration
    SnapToMapMode mSnapToMapMode;
    IndexingStrategy mStrategy;
    int mDefaultType;
    double mDefaultTolerance;
    QgsTolerance::UnitType mDefaultUnit;
    QList<LayerConfig> mLayers;
    bool mSnapOnIntersection;

    // internal data
    typedef QMap<QgsVectorLayer*, QgsPointLocator*> LocatorsMap;
    LocatorsMap mLocators;
    LocatorsMap mTemporaryLocators;
    QSet<QString> mHybridNonindexableLayers;
    QHash<QString, double> mHybridMaxAreaPerLayer;
    int mHybridPerLayerFeatureLimit;

    bool mIsIndexing;
};


#endif // QGSSNAPPINGUTILS_H