qgslabelfeature.h

Go to the documentation of this file.

/***************************************************************************
    qgslabelfeature.h
    ---------------------
    begin                : December 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 QGSLABELFEATURE_H
#define QGSLABELFEATURE_H
 
#define SIP_NO_FILE
 
#include <geos_c.h>
 
#include "qgis_core.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsfeature.h"
#include "qgsgeos.h"
#include "qgslabellinesettings.h"
#include "qgslabelobstaclesettings.h"
#include "qgslabelthinningsettings.h"
#include "qgsmargins.h"
 
namespace pal
{
  class Layer;
}
 
class QgsAbstractLabelProvider;
class QgsRenderContext;
class QgsGeometry;
 

class CORE_EXPORT QgsLabelFeature
{
  public:

    QgsLabelFeature( QgsFeatureId id, geos::unique_ptr geometry, QSizeF size, int subPartId = 0 );
 
    virtual ~QgsLabelFeature();

    QgsFeatureId id() const { return mId; }

    int subPartId() const { return mSubPartId; }

    GEOSGeometry *geometry() const { return mGeometry.get(); }

    void setPermissibleZone( const QgsGeometry &geometry );

    QgsGeometry permissibleZone() const { return mPermissibleZone; }

    //TODO - remove when QgsGeometry caches GEOS preparedness
    const GEOSPreparedGeometry *permissibleZonePrepared() const { return mPermissibleZoneGeosPrepared.get(); }

    QSizeF size( double angle = 0.0 ) const;

    QRectF outerBounds() const { return mOuterBounds; }

    void setOuterBounds( const QRectF &bounds ) { mOuterBounds = bounds; }

    void setVisualMargin( const QgsMargins &margin ) { mVisualMargin = margin; }

    const QgsMargins &visualMargin() const { return mVisualMargin; }

    void setSymbolSize( QSizeF size ) { mSymbolSize = size; }

    const QSizeF &symbolSize() const { return mSymbolSize; }

    double priority() const { return mPriority; }

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

    double zIndex() const { return mZIndex; }

    void setZIndex( double zIndex ) { mZIndex = zIndex; }

    bool hasFixedPosition() const { return mHasFixedPosition; }
    void setHasFixedPosition( bool enabled ) { mHasFixedPosition = enabled; }
    QgsPointXY fixedPosition() const { return mFixedPosition; }

    void setFixedPosition( const QgsPointXY &point ) { mFixedPosition = point; }

    QgsPointXY anchorPosition() const;

    void setAnchorPosition( const QgsPointXY &anchorPosition );

    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( QPointF quadOffset ) { mQuadOffset = quadOffset; }

    QgsPointXY positionOffset() const { return mPositionOffset; }

    void setPositionOffset( const QgsPointXY &offset ) { mPositionOffset = offset; }

    Qgis::LabelOffsetType offsetType() const { return mOffsetType; }

    void setOffsetType( Qgis::LabelOffsetType type ) { mOffsetType = type; }

    double distLabel() const { return mDistLabel; }

    void setDistLabel( double dist ) { mDistLabel = dist; }

    double maximumDistance() const { return mMaximumDistance; }

    void setMaximumDistance( double distance ) { mMaximumDistance = distance; }

    QVector< Qgis::LabelPredefinedPointPosition > predefinedPositionOrder() const { return mPredefinedPositionOrder; }

    void setPredefinedPositionOrder( const QVector< Qgis::LabelPredefinedPointPosition > &order ) { mPredefinedPositionOrder = order; }

    double repeatDistance() const { return mRepeatDistance; }

    void setRepeatDistance( double dist ) { mRepeatDistance = dist; }

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

    Qgis::LabelLinePlacementFlags arrangementFlags() const { return mArrangementFlags; }

    void setArrangementFlags( Qgis::LabelLinePlacementFlags flags ) { mArrangementFlags = flags; }

    Qgis::LabelPolygonPlacementFlags polygonPlacementFlags() const { return mPolygonPlacementFlags; }

    void setPolygonPlacementFlags( Qgis::LabelPolygonPlacementFlags flags ) { mPolygonPlacementFlags = flags; }

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

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

    QgsAbstractLabelProvider *provider() const;

    QgsFeature feature() const;

    void setFeature( const QgsFeature &feature );

    const QgsSymbol *symbol() const { return mSymbol; }

    void setSymbol( const QgsSymbol *symbol ) { mSymbol = symbol; }

    double overrunDistance() const;

    void setOverrunDistance( double distance );

    double overrunSmoothDistance() const;

    void setOverrunSmoothDistance( double distance );

    double lineAnchorPercent() const { return mLineAnchorPercent; }

    void setLineAnchorPercent( double percent ) { mLineAnchorPercent = percent; }

    QgsLabelLineSettings::AnchorType lineAnchorType() const { return mLineAnchorType; }

    void setLineAnchorType( QgsLabelLineSettings::AnchorType type ) { mLineAnchorType = type; }

    QgsLabelLineSettings::AnchorTextPoint lineAnchorTextPoint() const;

    void setLineAnchorTextPoint( QgsLabelLineSettings::AnchorTextPoint point ) { mAnchorTextPoint = point; }

    Qgis::CurvedLabelMode curvedLabelMode() const { return mCurvedLabelMode; }

    void setCurvedLabelMode( Qgis::CurvedLabelMode mode ) { mCurvedLabelMode = mode; }

    Qgis::MultiPartLabelingBehavior multiPartBehavior() const { return mMultiPartBehavior; }

    void setMultiPartBehavior( Qgis::MultiPartLabelingBehavior behavior ) { mMultiPartBehavior = behavior; }

    void setRotatedSize( QSizeF size ) { mRotatedSize = size; }

    const QgsLabelObstacleSettings &obstacleSettings() const;

    void setObstacleSettings( const QgsLabelObstacleSettings &settings );

    const QgsLabelFeatureThinningSettings &thinningSettings() const { return mThinningSettings; }

    void setThinningSettings( const QgsLabelFeatureThinningSettings &settings ) { mThinningSettings = settings; }

    QgsCoordinateReferenceSystem originalFeatureCrs() const;

    void setOriginalFeatureCrs( const QgsCoordinateReferenceSystem &crs );

    double minimumSize() const { return mMinimumSize; }

    void setMinimumSize( double size ) { mMinimumSize = size; }

    Qgis::LabelOverlapHandling overlapHandling() const { return mOverlapHandling; }

    void setOverlapHandling( Qgis::LabelOverlapHandling handling ) { mOverlapHandling = handling; }

    bool allowDegradedPlacement() const { return mAllowDegradedPlacement; }

    Qgis::LabelPrioritization prioritization() const { return mPrioritization; }

    void setPrioritization( Qgis::LabelPrioritization prioritization ) { mPrioritization = prioritization; }

    void setAllowDegradedPlacement( bool allow ) { mAllowDegradedPlacement = allow; }

    Qgis::LabelWhitespaceCollisionHandling whitespaceCollisionHandling() const { return mWhitespaceCollisionHandling; }

    void setWhitespaceCollisionHandling( Qgis::LabelWhitespaceCollisionHandling handling ) { mWhitespaceCollisionHandling = handling; }
 
  protected:
    pal::Layer *mLayer = nullptr;

    QgsFeatureId mId;
    int mSubPartId = 0;
    geos::unique_ptr mGeometry;
    QgsGeometry mPermissibleZone;
    QSizeF mSize;
    QSizeF mRotatedSize;
    QRectF mOuterBounds;
    QgsMargins mVisualMargin;
    QSizeF mSymbolSize;
    double mPriority = -1;
    double mZIndex = 0;
    bool mHasFixedPosition = false;
    QgsPointXY mFixedPosition;
    bool mHasFixedAngle = false;
    double mFixedAngle = 0;
    bool mHasFixedQuadrant = false;
    QPointF mQuadOffset;
    QgsPointXY mPositionOffset;
    double mDistLabel = 0;

    double mMaximumDistance = 0;

    Qgis::LabelOffsetType mOffsetType = Qgis::LabelOffsetType::FromPoint;
    QVector< Qgis::LabelPredefinedPointPosition > mPredefinedPositionOrder;
    double mRepeatDistance = 0;
    bool mAlwaysShow = false;
    QString mLabelText;

    double mOverrunDistance = 0;
    double mOverrunSmoothDistance = 0;
 
    Qgis::LabelLinePlacementFlags mArrangementFlags = Qgis::LabelLinePlacementFlags();
    Qgis::LabelPolygonPlacementFlags mPolygonPlacementFlags = Qgis::LabelPolygonPlacementFlag::AllowPlacementInsideOfPolygon;
 
  private:

    geos::unique_ptr mPermissibleZoneGeos;
 
    // TODO - not required when QgsGeometry caches geos preparedness
    geos::prepared_unique_ptr mPermissibleZoneGeosPrepared;
 
    QgsFeature mFeature;
 
    const QgsSymbol *mSymbol = nullptr;
 
    Qgis::MultiPartLabelingBehavior mMultiPartBehavior = Qgis::MultiPartLabelingBehavior::LabelLargestPartOnly;
 
    QgsLabelObstacleSettings mObstacleSettings;
    QgsLabelFeatureThinningSettings mThinningSettings;
 
    QgsPointXY mAnchorPosition;
 
    double mLineAnchorPercent = 0.5;
    QgsLabelLineSettings::AnchorType mLineAnchorType = QgsLabelLineSettings::AnchorType::HintOnly;
    QgsLabelLineSettings::AnchorTextPoint mAnchorTextPoint = QgsLabelLineSettings::AnchorTextPoint::CenterOfText;
    Qgis::CurvedLabelMode mCurvedLabelMode = Qgis::CurvedLabelMode::Default;
 
    Qgis::LabelOverlapHandling mOverlapHandling = Qgis::LabelOverlapHandling::PreventOverlap;
    bool mAllowDegradedPlacement = false;
    Qgis::LabelPrioritization mPrioritization = Qgis::LabelPrioritization::PreferCloser;
 
    QgsCoordinateReferenceSystem mOriginalFeatureCrs;
 
    double mMinimumSize = 0.0;
 
    Qgis::LabelWhitespaceCollisionHandling mWhitespaceCollisionHandling = Qgis::LabelWhitespaceCollisionHandling::TreatWhitespaceAsCollision;
 
};
 
#endif // QGSLABELFEATURE_H