qgslabelingengine.h

Go to the documentation of this file.

/***************************************************************************
  qgslabelingengine.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 QGSLABELINGENGINE_H
#define QGSLABELINGENGINE_H
 
#define SIP_NO_FILE
 
#include "qgis_core.h"
#include "qgsmapsettings.h"
 
#include "qgspallabeling.h"
#include "qgslabelingenginesettings.h"
#include "qgslabeling.h"
#include "qgsfeedback.h"
 
class QgsLabelingEngine;
class QgsLabelingResults;
 
namespace pal
{
  class Problem;
}
 
class CORE_EXPORT QgsAbstractLabelProvider
{
 
  public:
    QgsAbstractLabelProvider( QgsMapLayer *layer, const QString &providerId = QString() );
 
    virtual ~QgsAbstractLabelProvider() = default;
 
    void setEngine( const QgsLabelingEngine *engine ) { mEngine = engine; }
 
    enum Flag
    {
      DrawLabels              = 1 << 1,  
      DrawAllLabels           = 1 << 2,  
      MergeConnectedLines     = 1 << 3,  
      CentroidMustBeInside    = 1 << 4,  
    };
    Q_DECLARE_FLAGS( Flags, Flag )
 
    
    virtual QList<QgsLabelFeature *> labelFeatures( QgsRenderContext &context ) = 0;
 
    virtual void drawLabel( QgsRenderContext &context, pal::LabelPosition *label ) const = 0;
 
    virtual void drawUnplacedLabel( QgsRenderContext &context, pal::LabelPosition *label ) const;
 
    virtual void drawLabelBackground( QgsRenderContext &context, pal::LabelPosition *label ) const;
 
    virtual void startRender( QgsRenderContext &context );
 
    virtual void stopRender( QgsRenderContext &context );
 
    virtual QList<QgsAbstractLabelProvider *> subProviders() { return QList<QgsAbstractLabelProvider *>(); }
 
    QString name() const { return mName; }
 
    QString layerId() const { return mLayerId; }
 
    QgsMapLayer *layer() const { return mLayer.data(); }
 
    QString providerId() const { return mProviderId; }
 
    Flags flags() const { return mFlags; }
 
    QgsPalLayerSettings::Placement placement() const { return mPlacement; }
 
    double priority() const { return mPriority; }
 
    QgsLabelObstacleSettings::ObstacleType obstacleType() const { return mObstacleType; }
 
    QgsPalLayerSettings::UpsideDownLabels upsidedownLabels() const { return mUpsidedownLabels; }
 
    QgsExpressionContextScope *layerExpressionContextScope() const;
 
    double layerReferenceScale() const { return mLayerReferenceScale; }
 
  protected:
    const QgsLabelingEngine *mEngine = nullptr;
 
    QString mName;
    QString mLayerId;
    QgsWeakMapLayerPointer mLayer;
    QString mProviderId;
    Flags mFlags;
    QgsPalLayerSettings::Placement mPlacement;
    double mPriority;
    QgsLabelObstacleSettings::ObstacleType mObstacleType = QgsLabelObstacleSettings::PolygonBoundary;
    QgsPalLayerSettings::UpsideDownLabels mUpsidedownLabels;
 
  private:
 
    std::unique_ptr< QgsExpressionContextScope > mLayerExpressionContextScope;
    double mLayerReferenceScale = -1;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsAbstractLabelProvider::Flags )
 
 
 
class CORE_EXPORT QgsLabelingEngineFeedback : public QgsFeedback
{
    Q_OBJECT
 
  public:
 
    QgsLabelingEngineFeedback( QObject *parent SIP_TRANSFERTHIS = nullptr )
      : QgsFeedback( parent )
    {}
 
  signals:
 
    void labelRegistrationAboutToBegin();
 
    void labelRegistrationFinished();
 
    void providerRegistrationAboutToBegin( QgsAbstractLabelProvider *provider );
 
    void providerRegistrationFinished( QgsAbstractLabelProvider *provider );
 
    void candidateCreationAboutToBegin( QgsAbstractLabelProvider *provider );
 
    void candidateCreationFinished( QgsAbstractLabelProvider *provider );
 
    void obstacleCostingAboutToBegin();
 
    void obstacleCostingFinished();
 
    void calculatingConflictsAboutToBegin();
 
    void calculatingConflictsFinished();
 
    void finalizingCandidatesAboutToBegin();
 
    void finalizingCandidatesFinished();
 
    void reductionAboutToBegin();
 
    void reductionFinished();
 
    void solvingPlacementAboutToBegin();
 
    void solvingPlacementFinished();
};
 
class CORE_EXPORT QgsLabelingEngine
{
  public:
    QgsLabelingEngine();
    virtual ~QgsLabelingEngine();
 
    QgsLabelingEngine( const QgsLabelingEngine &rh ) = delete;
    QgsLabelingEngine &operator=( const QgsLabelingEngine &rh ) = delete;
 
    void setMapSettings( const QgsMapSettings &mapSettings );
    const QgsMapSettings &mapSettings() const { return mMapSettings; }
 
    const QgsLabelingEngineSettings &engineSettings() const { return mMapSettings.labelingEngineSettings(); }
 
    QList< QgsMapLayer * > participatingLayers() const;
 
    QStringList participatingLayerIds() const;
 
    void addProvider( QgsAbstractLabelProvider *provider );
 
    void removeProvider( QgsAbstractLabelProvider *provider );
 
    virtual void run( QgsRenderContext &context ) = 0;
 
    QgsLabelingResults *takeResults();
 
    QgsLabelingResults *results() const { return mResults.get(); }
 
  protected:
    void processProvider( QgsAbstractLabelProvider *provider, QgsRenderContext &context, pal::Pal &p );
 
  protected:
 
    void registerLabels( QgsRenderContext &context );
 
    void solve( QgsRenderContext &context );
 
    void drawLabels( QgsRenderContext &context, const QString &layerId = QString() );
 
    void cleanup();
 
    QgsMapSettings mMapSettings;
 
    QList<QgsAbstractLabelProvider *> mProviders;
    QList<QgsAbstractLabelProvider *> mSubProviders;
 
    std::unique_ptr< QgsLabelingResults > mResults;
 
    std::unique_ptr< pal::Pal > mPal;
    std::unique_ptr< pal::Problem > mProblem;
    QList<pal::LabelPosition *> mUnlabeled;
    QList<pal::LabelPosition *> mLabels;
 
};
 
class CORE_EXPORT QgsDefaultLabelingEngine : public QgsLabelingEngine
{
  public:
    QgsDefaultLabelingEngine();
 
    QgsDefaultLabelingEngine( const QgsDefaultLabelingEngine &rh ) = delete;
    QgsDefaultLabelingEngine &operator=( const QgsDefaultLabelingEngine &rh ) = delete;
 
    void run( QgsRenderContext &context ) override;
 
};
 
class CORE_EXPORT QgsStagedRenderLabelingEngine : public QgsLabelingEngine
{
  public:
    QgsStagedRenderLabelingEngine();
 
    QgsStagedRenderLabelingEngine( const QgsStagedRenderLabelingEngine &rh ) = delete;
    QgsStagedRenderLabelingEngine &operator=( const QgsStagedRenderLabelingEngine &rh ) = delete;
 
    void run( QgsRenderContext &context ) override;
 
    void renderLabelsForLayer( QgsRenderContext &context, const QString &layerId );
 
    void finalize();
};
 
 
class CORE_EXPORT QgsLabelingUtils
{
  public:
 
    static QString encodePredefinedPositionOrder( const QVector< QgsPalLayerSettings::PredefinedPointPosition > &positions );
 
    static QVector< QgsPalLayerSettings::PredefinedPointPosition > decodePredefinedPositionOrder( const QString &positionString );
 
    static QString encodeLinePlacementFlags( QgsLabeling::LinePlacementFlags flags );
 
    static QgsLabeling::LinePlacementFlags decodeLinePlacementFlags( const QString &string );
 
};
 
#endif // QGSLABELINGENGINE_H