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"

namespace pal
{
  class LabelInfo;
}

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 setObstacleGeometry( geos::unique_ptr obstacleGeom );

    GEOSGeometry *obstacleGeometry() const { return mObstacleGeometry.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() const { return mSize; }

    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; }

    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; }

    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 = nullptr;

    QgsFeatureId mId;
    geos::unique_ptr mGeometry;
    geos::unique_ptr mObstacleGeometry;
    QgsGeometry mPermissibleZone;
    QSizeF mSize;
    QgsMargins mVisualMargin;
    QSizeF mSymbolSize;
    double mPriority;
    double mZIndex;
    bool mHasFixedPosition;
    QgsPointXY mFixedPosition;
    bool mHasFixedAngle;
    double mFixedAngle;
    bool mHasFixedQuadrant;
    QPointF mQuadOffset;
    QgsPointXY mPositionOffset;
    double mDistLabel;
    QgsPalLayerSettings::OffsetType mOffsetType;
    QVector< QgsPalLayerSettings::PredefinedPointPosition > mPredefinedPositionOrder;
    double mRepeatDistance;
    bool mAlwaysShow;
    bool mIsObstacle;
    double mObstacleFactor;
    QString mLabelText;
    pal::LabelInfo *mInfo = nullptr;

  private:

    geos::unique_ptr mPermissibleZoneGeos;

    // TODO - not required when QgsGeometry caches geos preparedness
    geos::prepared_unique_ptr mPermissibleZoneGeosPrepared;

};

#endif // QGSLABELFEATURE_H