QGIS/python/core/auto_generated/qgspallabeling.sip.in

/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/qgspallabeling.h                                            *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.pl again   *
 ************************************************************************/






class QgsLabelPosition
{

%TypeHeaderCode
#include "qgspallabeling.h"
%End
  public:

    QgsLabelPosition( QgsFeatureId id, double r, const QVector< QgsPointXY > &corners, const QgsRectangle &rect, double w, double h, const QString &layer, const QString &labeltext, const QFont &labelfont, bool upside_down, bool diagram = false, bool pinned = false, const QString &providerId = QString(),
                      const QgsGeometry &labelGeometry = QgsGeometry(), bool isUnplaced = false );
%Docstring
Constructor for QgsLabelPosition.

:param id: associated feature ID
:param r: label rotation in degrees clockwise
:param corners: corner points of label bounding box, in map units
:param rect: label bounding box, in map units
:param w: width of label, in map units
:param h: height of label, in map units
:param layer: ID of associated map layer
:param labeltext: text rendered for label
:param labelfont: font used to render label
:param upside_down: ``True`` if label is upside down
:param diagram: ``True`` if label is a diagram
:param pinned: ``True`` if label has pinned placement
:param providerId: ID of associated label provider
:param labelGeometry: polygon geometry of label boundary
:param isUnplaced: set to ``True`` if label was unplaced (e.g. due to collisions with other labels)
%End

    QgsLabelPosition();
%Docstring
Constructor for QgsLabelPosition
%End

    QgsFeatureId featureId;

    double rotation;

    QVector< QgsPointXY > cornerPoints;
    QgsRectangle labelRect;

    QgsGeometry labelGeometry;

    double width;

    double height;

    QString layerID;

    QString labelText;

    QFont labelFont;

    bool upsideDown;

    bool isDiagram;

    bool isPinned;

    QString providerID;

    bool isUnplaced;
};


class QgsPalLayerSettings
{

%TypeHeaderCode
#include "qgspallabeling.h"
%End
  public:
    QgsPalLayerSettings();
    QgsPalLayerSettings( const QgsPalLayerSettings &s );
    ~QgsPalLayerSettings();



    enum Placement
    {
      AroundPoint,
      OverPoint,
      Line,
      Curved,
      Horizontal,
      Free,
      OrderedPositionsAroundPoint,
      PerimeterCurved,
    };

    enum PredefinedPointPosition
    {
      TopLeft,
      TopSlightlyLeft,
      TopMiddle,
      TopSlightlyRight,
      TopRight,
      MiddleLeft,
      MiddleRight,
      BottomLeft,
      BottomSlightlyLeft,
      BottomMiddle,
      BottomSlightlyRight,
      BottomRight,
    };


    enum OffsetType
    {
      FromPoint,
      FromSymbolBounds,
    };


    enum LinePlacementFlags
    {
      OnLine,
      AboveLine,
      BelowLine,
      MapOrientation,
    };

    enum QuadrantPosition
    {
      QuadrantAboveLeft,
      QuadrantAbove,
      QuadrantAboveRight,
      QuadrantLeft,
      QuadrantOver,
      QuadrantRight,
      QuadrantBelowLeft,
      QuadrantBelow,
      QuadrantBelowRight,
    };

    enum UpsideDownLabels
    {
      Upright,
      ShowDefined,
      ShowAll
    };

    enum DirectionSymbols
    {
      SymbolLeftRight,
      SymbolAbove,
      SymbolBelow
    };

    enum MultiLineAlign
    {
      MultiLeft,
      MultiCenter,
      MultiRight,
      MultiFollowPlacement
    };


    enum ObstacleType
    {
      PolygonInterior,
      PolygonBoundary,
      PolygonWhole
    };

    enum Property
    {
      // text style
      Size,
      Bold,
      Italic,
      Underline,
      Color,
      Strikeout,
      Family,
      FontStyle,
      FontSizeUnit,
      FontTransp,
      FontOpacity,
      FontCase,
      FontLetterSpacing,
      FontWordSpacing,
      FontBlendMode,

      // text formatting
      MultiLineWrapChar,
      AutoWrapLength,
      MultiLineHeight,
      MultiLineAlignment,
      TextOrientation,
      DirSymbDraw,
      DirSymbLeft,
      DirSymbRight,
      DirSymbPlacement,
      DirSymbReverse,
      NumFormat,
      NumDecimals,
      NumPlusSign,

      // text buffer
      BufferDraw,
      BufferSize,
      BufferUnit,
      BufferColor,
      BufferTransp,
      BufferOpacity,
      BufferJoinStyle,
      BufferBlendMode,

      // background
      ShapeDraw,
      ShapeKind,
      ShapeSVGFile,
      ShapeSizeType,
      ShapeSizeX,
      ShapeSizeY,
      ShapeSizeUnits,
      ShapeRotationType,
      ShapeRotation,
      ShapeOffset,
      ShapeOffsetUnits,
      ShapeRadii,
      ShapeRadiiUnits,
      ShapeTransparency,
      ShapeOpacity,
      ShapeBlendMode,
      ShapeFillColor,
      ShapeStrokeColor,
      ShapeStrokeWidth,
      ShapeStrokeWidthUnits,
      ShapeJoinStyle,

      // drop shadow
      ShadowDraw,
      ShadowUnder,
      ShadowOffsetAngle,
      ShadowOffsetDist,
      ShadowOffsetUnits,
      ShadowRadius,
      ShadowRadiusUnits,
      ShadowTransparency,
      ShadowOpacity,
      ShadowScale,
      ShadowColor,
      ShadowBlendMode,

      // placement
      CentroidWhole,
      OffsetQuad,
      OffsetXY,
      OffsetUnits,
      LabelDistance,
      DistanceUnits,
      OffsetRotation,
      CurvedCharAngleInOut,
      // (data defined only)
      PositionX,
      PositionY,
      Hali,
      Vali,
      Rotation,
      LabelRotation,
      RepeatDistance,
      RepeatDistanceUnit,
      Priority,
      PredefinedPositionOrder,
      LinePlacementOptions,
      OverrunDistance,
      LabelAllParts,

      // rendering
      ScaleVisibility,
      MinScale,
      MinimumScale,
      MaxScale,
      MaximumScale,
      FontLimitPixel,
      FontMinPixel,
      FontMaxPixel,
      IsObstacle,
      ObstacleFactor,
      ZIndex,
      CalloutDraw,

      // (data defined only)
      Show,
      AlwaysShow
    };


    bool prepare( QgsRenderContext &context, QSet<QString> &attributeNames /In,Out/, const QgsFields &fields, const QgsMapSettings &mapSettings, const QgsCoordinateReferenceSystem &crs );
%Docstring
Prepare for registration of features.
The ``context``, ``mapSettings`` and ``fields`` parameters give more
information about the rendering environment.
If target ``crs`` is not specified, the targetCrs from ``mapSettings``
will be taken.
The parameter ``attributeNames`` should be updated to contain all the field
names which the labeling requires for the rendering.

.. versionadded:: 3.8
%End

    void startRender( QgsRenderContext &context );
%Docstring
Prepares the label settings for rendering.

This should be called before rendering any labels, and must be
followed by a call to stopRender() in order to gracefully clean up symbols.

.. versionadded:: 3.10
%End

    void stopRender( QgsRenderContext &context );
%Docstring
Finalises the label settings after use.

This must be called after a call to startRender(), in order to gracefully clean up symbols.

.. versionadded:: 3.10
%End

    static const QgsPropertiesDefinition &propertyDefinitions();
%Docstring
Returns the labeling property definitions.

.. versionadded:: 3.0
%End

    bool drawLabels;


    QString fieldName;

    bool isExpression;

    QgsExpression *getLabelExpression();
%Docstring
Returns the QgsExpression for this label settings. May be ``None`` if isExpression is ``False``.
%End

 QColor previewBkgrdColor;

    QgsStringReplacementCollection substitutions;
    bool useSubstitutions;


    QString wrapChar;

    int autoWrapLength;

    bool useMaxLineLengthForAutoWrap;

    MultiLineAlign multilineAlign;

    bool addDirectionSymbol;

    QString leftDirectionSymbol;

    QString rightDirectionSymbol;

    DirectionSymbols placeDirectionSymbol;

    bool reverseDirectionSymbol;

    bool formatNumbers;

    int decimals;

    bool plusSign;


    Placement placement;
    unsigned int placementFlags;

    bool centroidWhole;

    bool centroidInside;


    bool fitInPolygonOnly;

    double dist;

    QgsUnitTypes::RenderUnit distUnits;

    QgsMapUnitScale distMapUnitScale;

    OffsetType offsetType;

    double repeatDistance;

    QgsUnitTypes::RenderUnit repeatDistanceUnit;

    QgsMapUnitScale repeatDistanceMapUnitScale;

    double overrunDistance;

    QgsUnitTypes::RenderUnit overrunDistanceUnit;

    QgsMapUnitScale overrunDistanceMapUnitScale;

    QuadrantPosition quadOffset;

    double xOffset;

    double yOffset;

    QgsUnitTypes::RenderUnit offsetUnits;

    QgsMapUnitScale labelOffsetMapUnitScale;

    double angleOffset;

    bool preserveRotation;

    double maxCurvedCharAngleIn;

    double maxCurvedCharAngleOut;

    int priority;


    bool scaleVisibility;

    double maximumScale;

    double minimumScale;

    bool fontLimitPixelSize;

    int fontMinPixelSize;

    int fontMaxPixelSize;

    bool displayAll;

    UpsideDownLabels upsidedownLabels;

    bool labelPerPart;

    bool mergeLines;

    bool limitNumLabels;

    int maxNumLabels;

    double minFeatureSize;

    bool obstacle;

    double obstacleFactor;

    ObstacleType obstacleType;

    double zIndex;

    QString geometryGenerator;

    QgsWkbTypes::GeometryType geometryGeneratorType;

    bool geometryGeneratorEnabled;

    QgsWkbTypes::GeometryType layerType;

    void calculateLabelSize( const QFontMetricsF *fm, const QString &text, double &labelX, double &labelY, const QgsFeature *f = 0, QgsRenderContext *context = 0, double *rotatedLabelX /Out/ = 0, double *rotatedLabelY /Out/ = 0 );
%Docstring
Calculates the space required to render the provided ``text`` in map units.
Results will be written to ``labelX`` and ``labelY``.
If the text orientation is set to rotation-based, the spaced taken to render
vertically oriented text will be written to ``rotatedLabelX`` and ``rotatedLabelY`` .
%End

    void registerFeature( const QgsFeature &f, QgsRenderContext &context  );

%Docstring
Register a feature for labeling.

:param f: feature to label
:param context: render context. The QgsExpressionContext contained within the render context
                must have already had the feature and fields sets prior to calling this method.
:param labelFeature: if using :py:class:`QgsLabelingEngine`, this will receive the label feature. Not available
                     in Python bindings.
:param symbol: feature symbol to label (ownership is not transferred, and ``symbol`` must exist until the labeling is complete)
%End

    void readXml( const QDomElement &elem, const QgsReadWriteContext &context );
%Docstring
Read settings from a DOM element

.. versionadded:: 2.12
%End

    QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const;
%Docstring
Write settings into a DOM element

.. versionadded:: 2.12
%End

    QgsPropertyCollection &dataDefinedProperties();
%Docstring
Returns a reference to the label's property collection, used for data defined overrides.

.. seealso:: :py:func:`setDataDefinedProperties`

.. versionadded:: 3.0
%End


    void setDataDefinedProperties( const QgsPropertyCollection &collection );
%Docstring
Sets the label's property collection, used for data defined overrides.

:param collection: property collection. Existing properties will be replaced.

.. seealso:: :py:func:`dataDefinedProperties`

.. seealso:: Property

.. versionadded:: 3.0
%End

    const QgsTextFormat &format() const;
%Docstring
Returns the label text formatting settings, e.g., font settings, buffer settings, etc.

.. seealso:: :py:func:`setFormat`

.. versionadded:: 3.0
%End

    void setFormat( const QgsTextFormat &format );
%Docstring
Sets the label text formatting settings, e.g., font settings, buffer settings, etc.

:param format: label text format

.. seealso:: :py:func:`format`

.. versionadded:: 3.0
%End

    QgsCallout *callout() const;
%Docstring
Returns the label callout renderer, responsible for drawing label callouts.

Ownership is not transferred.

.. seealso:: :py:func:`setCallout`

.. versionadded:: 3.10
%End

    void setCallout( QgsCallout *callout /Transfer/ );
%Docstring
Sets the label ``callout`` renderer, responsible for drawing label callouts.

Ownership of ``callout`` is transferred to the settings.

.. seealso:: :py:func:`callout`

.. versionadded:: 3.10
%End

    static QPixmap labelSettingsPreviewPixmap( const QgsPalLayerSettings &settings, QSize size, const QString &previewText = QString(), int padding = 0 );
%Docstring
Returns a pixmap preview for label ``settings``.

:param settings: label settings
:param size: target pixmap size
:param previewText: text to render in preview, or empty for default text
:param padding: space between icon edge and color ramp

.. versionadded:: 3.10
%End

    const QgsFeature *mCurFeat;
    QgsFields mCurFields;
    int fieldIndex;
    const QgsMapToPixel *xform;
    QgsCoordinateTransform ct;

    QgsPointXY ptZero;
    QgsPointXY ptOne;
    QgsGeometry extentGeom;
    int mFeaturesToLabel;
    int mFeatsSendingToPal;
    int mFeatsRegPal;
};

class QgsLabelCandidate
{

%TypeHeaderCode
#include "qgspallabeling.h"
%End
  public:
    QgsLabelCandidate( const QRectF &r, double c );

    QRectF rect;
    double cost;
};




class QgsLabelingResults
{
%Docstring
Class that stores computed placement from labeling engine.

.. versionadded:: 2.4
%End

%TypeHeaderCode
#include "qgspallabeling.h"
%End
  public:
    QgsLabelingResults();
    ~QgsLabelingResults();


    QList<QgsLabelPosition> labelsAtPosition( const QgsPointXY &p ) const;
%Docstring
Returns infos about labels at a given (map) position
%End
    QList<QgsLabelPosition> labelsWithinRect( const QgsRectangle &r ) const;
%Docstring
Returns infos about labels within a given (map) rectangle
%End

    void setMapSettings( const QgsMapSettings &settings );
%Docstring
Sets the map ``settings`` associated with the labeling run.

.. versionadded:: 3.4.8
%End

  private:
    QgsLabelingResults( const QgsLabelingResults & );
};

class QgsPalLabeling
{

%TypeHeaderCode
#include "qgspallabeling.h"
%End
  public:

    static bool staticWillUseLayer( QgsVectorLayer *layer );
%Docstring
called to find out whether the layer is used for labeling

.. versionadded:: 2.4
%End


    static QgsGeometry prepareGeometry( const QgsGeometry &geometry, QgsRenderContext &context, const QgsCoordinateTransform &ct, const QgsGeometry &clipGeometry = QgsGeometry(), bool mergeLines = false ) /Factory/;
%Docstring
Prepares a geometry for registration with PAL. Handles reprojection, rotation, clipping, etc.

:param geometry: geometry to prepare
:param context: render context
:param ct: coordinate transform, or invalid transform if no transformation required
:param clipGeometry: geometry to clip features to, if applicable
:param mergeLines: ``True`` if touching lines from this layer will be merged and treated as single features during labeling

:return: prepared geometry

.. versionadded:: 2.9
%End

    static bool geometryRequiresPreparation( const QgsGeometry &geometry, QgsRenderContext &context, const QgsCoordinateTransform &ct, const QgsGeometry &clipGeometry = QgsGeometry(), bool mergeLines = false );
%Docstring
Checks whether a geometry requires preparation before registration with PAL

:param geometry: geometry to prepare
:param context: render context
:param ct: coordinate transform, or invalid transform if no transformation required
:param clipGeometry: geometry to clip features to, if applicable
:param mergeLines: ``True`` if touching lines from this layer will be merged and treated as single features during labeling

:return: ``True`` if geometry requires preparation

.. versionadded:: 2.9
%End

    static QStringList splitToLines( const QString &text, const QString &wrapCharacter, int autoWrapLength = 0, bool useMaxLineLengthWhenAutoWrapping = true );
%Docstring
Splits a ``text`` string to a list of separate lines, using a specified wrap character (``wrapCharacter``).
The text string will be split on either newline characters or the wrap character.

Since QGIS 3.4 the ``autoWrapLength`` argument can be used to specify an ideal length of line to automatically
wrap text to (automatic wrapping is disabled if ``autoWrapLength`` is 0). This automatic wrapping is performed
after processing wrapping using ``wrapCharacter``. When auto wrapping is enabled, the ``useMaxLineLengthWhenAutoWrapping``
argument controls whether the lines should be wrapped to an ideal maximum of ``autoWrapLength`` characters, or
if ``False`` then the lines are wrapped to an ideal minimum length of ``autoWrapLength`` characters.

.. versionadded:: 2.9
%End

    static QStringList splitToGraphemes( const QString &text );
%Docstring
Splits a text string to a list of graphemes, which are the smallest allowable character
divisions in the string. This accounts for scripts were individual characters are not
allowed to be split apart (e.g., Arabic and Indic based scripts)

:param text: string to split

:return: list of graphemes

.. versionadded:: 2.10
%End

};

/************************************************************************
 * This file has been generated automatically from                      *
 *                                                                      *
 * src/core/qgspallabeling.h                                            *
 *                                                                      *
 * Do not edit manually ! Edit header and run scripts/sipify.pl again   *
 ************************************************************************/