qgslabelingenginev2.h

Go to the documentation of this file.

/***************************************************************************
  qgslabelingenginev2.h
  --------------------------------------
  Date                 : September 2015
  Copyright            : (C) 2015 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 QGSLABELINGENGINEV2_H
#define QGSLABELINGENGINEV2_H

#include "qgsgeometry.h"

#include "qgsmapsettings.h"

#include "qgspallabeling.h"

#include <QFlags>

class QgsAbstractLabelProvider;
class QgsRenderContext;
class QgsGeometry;

namespace pal
{
  class LabelInfo;
}

class CORE_EXPORT QgsLabelFeature
{
  public:
    QgsLabelFeature( QgsFeatureId id, GEOSGeometry* geometry, const QSizeF& size );
    virtual ~QgsLabelFeature();

    QgsFeatureId id() const { return mId; }

    GEOSGeometry* geometry() const { return mGeometry; }

    QSizeF size() const { return mSize; }

    double priority() const { return mPriority; }
    void setPriority( double priority ) { mPriority = priority; }

    bool hasFixedPosition() const { return mHasFixedPosition; }
    void setHasFixedPosition( bool enabled ) { mHasFixedPosition = enabled; }
    QgsPoint fixedPosition() const { return mFixedPosition; }
    void setFixedPosition( const QgsPoint& point ) { mFixedPosition = point; }

    bool hasFixedAngle() const { return mHasFixedAngle; }
    void setHasFixedAngle( bool enabled ) { mHasFixedAngle = enabled; }
    double fixedAngle() const { return mFixedAngle; }
    void setFixedAngle( double angle ) { mFixedAngle = angle; }

    bool hasFixedQuadrant() const { return mHasFixedQuadrant; }
    void setHasFixedQuadrant( bool enabled ) { mHasFixedQuadrant = enabled; }
    QPointF quadOffset() const { return mQuadOffset; }
    void setQuadOffset( const QPointF& quadOffset ) { mQuadOffset = quadOffset; }
    QgsPoint positionOffset() const { return mPositionOffset; }
    void setPositionOffset( const QgsPoint& offset ) { mPositionOffset = offset; }
    double distLabel() const { return mDistLabel; }
    void setDistLabel( double dist ) { mDistLabel = dist; }

    double repeatDistance() const { return mRepeatDistance; }
    void setRepeatDistance( double dist ) { mRepeatDistance = dist; }

    bool alwaysShow() const { return mAlwaysShow; }
    void setAlwaysShow( bool enabled ) { mAlwaysShow = enabled; }

    bool isObstacle() const { return mIsObstacle; }
    void setIsObstacle( bool enabled ) { mIsObstacle = enabled; }
    double obstacleFactor() const { return mObstacleFactor; }
    void setObstacleFactor( double factor ) { mObstacleFactor = factor; }

    QString labelText() const { return mLabelText; }
    void setLabelText( const QString& text ) { mLabelText = text; }

    pal::LabelInfo* curvedLabelInfo() const { return mInfo; }
    void setCurvedLabelInfo( pal::LabelInfo* info ) { mInfo = info; }

    pal::Layer* layer() const { return mLayer; }
    void setLayer( pal::Layer* layer ) { mLayer = layer; }

    QgsAbstractLabelProvider* provider() const;

  protected:
    pal::Layer* mLayer;

    QgsFeatureId mId;
    GEOSGeometry* mGeometry;
    QSizeF mSize;
    double mPriority;
    bool mHasFixedPosition;
    QgsPoint mFixedPosition;
    bool mHasFixedAngle;
    double mFixedAngle;
    bool mHasFixedQuadrant;
    QPointF mQuadOffset;
    QgsPoint mPositionOffset;
    double mDistLabel;
    double mRepeatDistance;
    bool mAlwaysShow;
    bool mIsObstacle;
    double mObstacleFactor;
    QString mLabelText;
    pal::LabelInfo* mInfo;
};



class QgsLabelingEngineV2;


class CORE_EXPORT QgsAbstractLabelProvider
{

  public:
    QgsAbstractLabelProvider();
    virtual ~QgsAbstractLabelProvider() {}

    void setEngine( const QgsLabelingEngineV2* engine ) { mEngine = engine; }

    enum Flag
    {
      DrawLabels              = 1 << 1,  
      DrawAllLabels           = 1 << 2,  
      MergeConnectedLines     = 1 << 3,  
      CentroidMustBeInside    = 1 << 4,  
      FitInPolygonOnly        = 1 << 5,  
      LabelPerFeaturePart     = 1 << 6,  
    };
    Q_DECLARE_FLAGS( Flags, Flag )

    
    virtual QList<QgsLabelFeature*> labelFeatures( QgsRenderContext& context ) = 0;

    virtual void drawLabel( QgsRenderContext& context, pal::LabelPosition* label ) const = 0;

    virtual QList<QgsAbstractLabelProvider*> subProviders() { return QList<QgsAbstractLabelProvider*>(); }

    QString name() const { return mName; }

    Flags flags() const { return mFlags; }

    QgsPalLayerSettings::Placement placement() const { return mPlacement; }

    unsigned int linePlacementFlags() const { return mLinePlacementFlags; }

    double priority() const { return mPriority; }

    QgsPalLayerSettings::ObstacleType obstacleType() const { return mObstacleType; }

    QgsPalLayerSettings::UpsideDownLabels upsidedownLabels() const { return mUpsidedownLabels; }

  protected:
    const QgsLabelingEngineV2* mEngine;

    QString mName;
    Flags mFlags;
    QgsPalLayerSettings::Placement mPlacement;
    unsigned int mLinePlacementFlags;
    double mPriority;
    QgsPalLayerSettings::ObstacleType mObstacleType;
    QgsPalLayerSettings::UpsideDownLabels mUpsidedownLabels;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAbstractLabelProvider::Flags )




class CORE_EXPORT QgsLabelingEngineV2
{
  public:
    QgsLabelingEngineV2();
    ~QgsLabelingEngineV2();

    enum Flag
    {
      UseAllLabels          = 1 << 1,  
      UsePartialCandidates  = 1 << 2,  
      RenderOutlineLabels   = 1 << 3,  
      DrawLabelRectOnly     = 1 << 4,  
      DrawCandidates        = 1 << 5,  
      DrawShadowRects       = 1 << 6,  
    };
    Q_DECLARE_FLAGS( Flags, Flag )

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

    void addProvider( QgsAbstractLabelProvider* provider );

    void removeProvider( QgsAbstractLabelProvider* provider );

    void run( QgsRenderContext& context );

    QgsLabelingResults* takeResults();

    QgsLabelingResults* results() const { return mResults; }

    void setFlags( const Flags& flags ) { mFlags = flags; }
    Flags flags() const { return mFlags; }
    bool testFlag( Flag f ) const { return mFlags.testFlag( f ); }
    void setFlag( Flag f, bool enabled = true ) { if ( enabled ) mFlags |= f; else mFlags &= ~f; }

    void numCandidatePositions( int& candPoint, int& candLine, int& candPolygon ) { candPoint = mCandPoint; candLine = mCandLine; candPolygon = mCandPolygon; }
    void setNumCandidatePositions( int candPoint, int candLine, int candPolygon ) { mCandPoint = candPoint; mCandLine = candLine; mCandPolygon = candPolygon; }

    void setSearchMethod( QgsPalLabeling::Search s ) { mSearchMethod = s; }
    QgsPalLabeling::Search searchMethod() const { return mSearchMethod; }

    void readSettingsFromProject();
    void writeSettingsToProject();

  protected:
    void processProvider( QgsAbstractLabelProvider* provider, QgsRenderContext& context, pal::Pal& p );

  protected:
    QgsMapSettings mMapSettings;
    QList<QgsAbstractLabelProvider*> mProviders;
    QList<QgsAbstractLabelProvider*> mSubProviders;
    Flags mFlags;
    QgsPalLabeling::Search mSearchMethod;
    int mCandPoint, mCandLine, mCandPolygon;

    QgsLabelingResults* mResults;
};

Q_DECLARE_OPERATORS_FOR_FLAGS( QgsLabelingEngineV2::Flags )

#endif // QGSLABELINGENGINEV2_H