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 "qgis_core.h"
#include "qgspallabeling.h"
#include "geos_c.h"
#include "qgsgeos.h"
#include "qgsmargins.h"
#include "qgslabelobstaclesettings.h"
#include "qgslabeling.h"
 
namespace pal
{
  class LabelInfo;
  class Layer;
}
 
class QgsAbstractLabelProvider;
class QgsRenderContext;
class QgsGeometry;
 
 
class CORE_EXPORT QgsLabelFeature
{
  public:
 
    QgsLabelFeature( QgsFeatureId id, geos::unique_ptr geometry, QSizeF size );
    virtual ~QgsLabelFeature();
 
    QgsFeatureId id() const { return mId; }
 
    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;
 
    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; }
 
    QgsPalLayerSettings::OffsetType offsetType() const { return mOffsetType; }
 
    void setOffsetType( QgsPalLayerSettings::OffsetType type ) { mOffsetType = type; }
 
    double distLabel() const { return mDistLabel; }
 
    void setDistLabel( double dist ) { mDistLabel = dist; }
 
    QVector< QgsPalLayerSettings::PredefinedPointPosition > predefinedPositionOrder() const { return mPredefinedPositionOrder; }
 
    void setPredefinedPositionOrder( const QVector< QgsPalLayerSettings::PredefinedPointPosition > &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; }
 
    QgsLabeling::LinePlacementFlags arrangementFlags() const { return mArrangementFlags; }
 
    void setArrangementFlags( QgsLabeling::LinePlacementFlags flags ) { mArrangementFlags = flags; }
 
    QgsLabeling::PolygonPlacementFlags polygonPlacementFlags() const { return mPolygonPlacementFlags; }
 
    void setPolygonPlacementFlags( QgsLabeling::PolygonPlacementFlags flags ) { mPolygonPlacementFlags = flags; }
 
    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;
 
    QgsFeature feature() const;
 
    void setFeature( const QgsFeature &feature );
 
    const QgsSymbol *symbol() { 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; }
 
    bool labelAllParts() const { return mLabelAllParts; }
 
    void setLabelAllParts( bool labelAllParts ) { mLabelAllParts = labelAllParts; }
 
    void setRotatedSize( QSizeF size ) { mRotatedSize = size; }
 
    const QgsLabelObstacleSettings &obstacleSettings() const;
 
    void setObstacleSettings( const QgsLabelObstacleSettings &settings );
 
  protected:
    pal::Layer *mLayer = nullptr;
 
    QgsFeatureId mId;
    geos::unique_ptr mGeometry;
    QgsGeometry mPermissibleZone;
    QSizeF mSize;
    QSizeF mRotatedSize;
    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;
    QgsPalLayerSettings::OffsetType mOffsetType = QgsPalLayerSettings::FromPoint;
    QVector< QgsPalLayerSettings::PredefinedPointPosition > mPredefinedPositionOrder;
    double mRepeatDistance = 0;
    bool mAlwaysShow = false;
    QString mLabelText;
    pal::LabelInfo *mInfo = nullptr;
 
    double mOverrunDistance = 0;
    double mOverrunSmoothDistance = 0;
 
    QgsLabeling::LinePlacementFlags mArrangementFlags = QgsLabeling::LinePlacementFlags();
    QgsLabeling::PolygonPlacementFlags mPolygonPlacementFlags = QgsLabeling::PolygonPlacementFlag::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;
 
    bool mLabelAllParts = false;
 
    QgsLabelObstacleSettings mObstacleSettings{};
 
    QgsPointXY mAnchorPosition;
 
    double mLineAnchorPercent = 0.5;
    QgsLabelLineSettings::AnchorType mLineAnchorType = QgsLabelLineSettings::AnchorType::HintOnly;
};
 
#endif // QGSLABELFEATURE_H