qgspallabeling.cpp

Go to the documentation of this file.

/***************************************************************************
  qgspallabeling.cpp
  Smart labeling for vector layers
  -------------------
   begin                : June 2009
   copyright            : (C) 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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgspallabeling.h"
#include "qgstextlabelfeature.h"
#include "qgsunittypes.h"
#include "qgsexception.h"
#include "qgsapplication.h"
#include "qgsstyle.h"
#include "qgstextrenderer.h"
 
#include <list>
 
#include "pal/labelposition.h"
 
#include <cmath>
 
#include <QApplication>
#include <QByteArray>
#include <QString>
#include <QFontMetrics>
#include <QTime>
#include <QPainter>
#include <QScreen>
#include <QWidget>
#include <QTextBoundaryFinder>
 
#include "qgsfontutils.h"
#include "qgsexpression.h"
#include "qgslabelingengine.h"
#include "qgstextrendererutils.h"
#include "qgsmultisurface.h"
#include "qgslogger.h"
#include "qgsvectorlayer.h"
#include "qgsgeometry.h"
#include "qgsreferencedgeometry.h"
#include "qgsproperty.h"
#include "qgssymbollayerutils.h"
#include "qgsmaptopixelgeometrysimplifier.h"
#include "qgscurvepolygon.h"
#include "qgsmessagelog.h"
#include "qgsgeometrycollection.h"
#include "callouts/qgscallout.h"
#include "callouts/qgscalloutsregistry.h"
#include "qgsvectortilelayer.h"
#include "qgsvectortilebasiclabeling.h"
#include "qgsfontmanager.h"
#include "qgsvariantutils.h"
 
using namespace pal;
 
// -------------
 
/* ND: Default point label position priority. These are set to match variants of the ideal placement priority described
  in "Making Maps", Krygier & Wood (2011) (p216),
  "Elements of Cartography", Robinson et al (1995)
  and "Designing Better Maps", Brewer (2005) (p76)
  Note that while they agree on positions 1-4, 5-8 are more contentious so I've selected these placements
  based on my preferences, and to follow Krygier and Wood's placements more closer. (I'm not going to disagree
  with Denis Wood on anything cartography related...!)
*/
typedef QVector< Qgis::LabelPredefinedPointPosition > PredefinedPointPositionVector;
Q_GLOBAL_STATIC_WITH_ARGS( PredefinedPointPositionVector, DEFAULT_PLACEMENT_ORDER, (
{
  Qgis::LabelPredefinedPointPosition::TopRight,
  Qgis::LabelPredefinedPointPosition::TopLeft,
  Qgis::LabelPredefinedPointPosition::BottomRight,
  Qgis::LabelPredefinedPointPosition::BottomLeft,
  Qgis::LabelPredefinedPointPosition::MiddleRight,
  Qgis::LabelPredefinedPointPosition::MiddleLeft,
  Qgis::LabelPredefinedPointPosition::TopSlightlyRight,
  Qgis::LabelPredefinedPointPosition::BottomSlightlyRight
} ) )
//debugging only - don't use these placements by default
/* << QgsPalLayerSettings::TopSlightlyLeft
<< QgsPalLayerSettings::BottomSlightlyLeft;
<< QgsPalLayerSettings::TopMiddle
<< QgsPalLayerSettings::BottomMiddle;*/
 
Q_GLOBAL_STATIC( QgsPropertiesDefinition, sPropertyDefinitions )
 
void QgsPalLayerSettings::initPropertyDefinitions()
{
  if ( !sPropertyDefinitions()->isEmpty() )
    return;
 
  const QString origin = QStringLiteral( "labeling" );
 
  *sPropertyDefinitions() = QgsPropertiesDefinition
  {
    { QgsPalLayerSettings::Size, QgsPropertyDefinition( "Size", QObject::tr( "Font size" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::Bold, QgsPropertyDefinition( "Bold", QObject::tr( "Bold style" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::Italic, QgsPropertyDefinition( "Italic", QObject::tr( "Italic style" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::Underline, QgsPropertyDefinition( "Underline", QObject::tr( "Draw underline" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::Color, QgsPropertyDefinition( "Color", QObject::tr( "Text color" ), QgsPropertyDefinition::ColorNoAlpha, origin ) },
    { QgsPalLayerSettings::Strikeout, QgsPropertyDefinition( "Strikeout", QObject::tr( "Draw strikeout" ), QgsPropertyDefinition::Boolean, origin ) },
    {
      QgsPalLayerSettings::Family, QgsPropertyDefinition( "Family", QgsPropertyDefinition::DataTypeString, QObject::tr( "Font family" ), QObject::tr( "string " ) + QObject::tr( "[<b>family</b>|<b>family[foundry]</b>],<br>"
          "e.g. Helvetica or Helvetica [Cronyx]" ), origin )
    },
    {
      QgsPalLayerSettings::FontStyle, QgsPropertyDefinition( "FontStyle", QgsPropertyDefinition::DataTypeString, QObject::tr( "Font style" ), QObject::tr( "string " ) + QObject::tr( "[<b>font style name</b>|<b>Ignore</b>],<br>"
          "e.g. Bold Condensed or Light Italic" ), origin )
    },
    { QgsPalLayerSettings::FontSizeUnit, QgsPropertyDefinition( "FontSizeUnit", QObject::tr( "Font size units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::FontTransp, QgsPropertyDefinition( "FontTransp", QObject::tr( "Text transparency" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::FontOpacity, QgsPropertyDefinition( "FontOpacity", QObject::tr( "Text opacity" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::FontStretchFactor, QgsPropertyDefinition( "FontStretchFactor", QObject::tr( "Font stretch factor" ), QgsPropertyDefinition::IntegerPositiveGreaterZero, origin ) },
    { QgsPalLayerSettings::FontCase, QgsPropertyDefinition( "FontCase", QgsPropertyDefinition::DataTypeString, QObject::tr( "Font case" ), QObject::tr( "string " ) + QStringLiteral( "[<b>NoChange</b>|<b>Upper</b>|<br><b>Lower</b>|<b>Title</b>|<b>Capitalize</b>|<b>SmallCaps</b>|<b>AllSmallCaps</b>]" ), origin ) },
    { QgsPalLayerSettings::FontLetterSpacing, QgsPropertyDefinition( "FontLetterSpacing", QObject::tr( "Letter spacing" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::FontWordSpacing, QgsPropertyDefinition( "FontWordSpacing", QObject::tr( "Word spacing" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::FontBlendMode, QgsPropertyDefinition( "FontBlendMode", QObject::tr( "Text blend mode" ), QgsPropertyDefinition::BlendMode, origin ) },
    { QgsPalLayerSettings::MultiLineWrapChar, QgsPropertyDefinition( "MultiLineWrapChar", QObject::tr( "Wrap character" ), QgsPropertyDefinition::String, origin ) },
    { QgsPalLayerSettings::AutoWrapLength, QgsPropertyDefinition( "AutoWrapLength", QObject::tr( "Automatic word wrap line length" ), QgsPropertyDefinition::IntegerPositive, origin ) },
    { QgsPalLayerSettings::MultiLineHeight, QgsPropertyDefinition( "MultiLineHeight", QObject::tr( "Line height" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::MultiLineAlignment, QgsPropertyDefinition( "MultiLineAlignment", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line alignment" ), QObject::tr( "string " ) + "[<b>Left</b>|<b>Center</b>|<b>Right</b>|<b>Follow</b>]", origin ) },
    { QgsPalLayerSettings::TextOrientation, QgsPropertyDefinition( "TextOrientation", QgsPropertyDefinition::DataTypeString, QObject::tr( "Text orientation" ), QObject::tr( "string " ) + "[<b>horizontal</b>|<b>vertical</b>]", origin ) },
    { QgsPalLayerSettings::DirSymbDraw, QgsPropertyDefinition( "DirSymbDraw", QObject::tr( "Draw direction symbol" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::DirSymbLeft, QgsPropertyDefinition( "DirSymbLeft", QObject::tr( "Left direction symbol" ), QgsPropertyDefinition::String, origin ) },
    { QgsPalLayerSettings::DirSymbRight, QgsPropertyDefinition( "DirSymbRight", QObject::tr( "Right direction symbol" ), QgsPropertyDefinition::String, origin ) },
    { QgsPalLayerSettings::DirSymbPlacement, QgsPropertyDefinition( "DirSymbPlacement", QgsPropertyDefinition::DataTypeString, QObject::tr( "Direction symbol placement" ), QObject::tr( "string " ) + "[<b>LeftRight</b>|<b>Above</b>|<b>Below</b>]", origin ) },
    { QgsPalLayerSettings::DirSymbReverse, QgsPropertyDefinition( "DirSymbReverse", QObject::tr( "Reverse direction symbol" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::NumFormat, QgsPropertyDefinition( "NumFormat", QObject::tr( "Format as number" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::NumDecimals, QgsPropertyDefinition( "NumDecimals", QObject::tr( "Number of decimal places" ), QgsPropertyDefinition::IntegerPositive, origin ) },
    { QgsPalLayerSettings::NumPlusSign, QgsPropertyDefinition( "NumPlusSign", QObject::tr( "Draw + sign" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::BufferDraw, QgsPropertyDefinition( "BufferDraw", QObject::tr( "Draw buffer" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::BufferSize, QgsPropertyDefinition( "BufferSize", QObject::tr( "Symbol size" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::BufferUnit, QgsPropertyDefinition( "BufferUnit", QObject::tr( "Buffer units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::BufferColor, QgsPropertyDefinition( "BufferColor", QObject::tr( "Buffer color" ), QgsPropertyDefinition::ColorNoAlpha, origin ) },
    { QgsPalLayerSettings::BufferTransp, QgsPropertyDefinition( "BufferTransp", QObject::tr( "Buffer transparency" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::BufferOpacity, QgsPropertyDefinition( "BufferOpacity", QObject::tr( "Buffer opacity" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::BufferJoinStyle, QgsPropertyDefinition( "BufferJoinStyle", QObject::tr( "Buffer join style" ), QgsPropertyDefinition::PenJoinStyle, origin ) },
    { QgsPalLayerSettings::BufferBlendMode, QgsPropertyDefinition( "BufferBlendMode", QObject::tr( "Buffer blend mode" ), QgsPropertyDefinition::BlendMode, origin ) },
 
    { QgsPalLayerSettings::MaskEnabled, QgsPropertyDefinition( "MaskEnabled", QObject::tr( "Enable mask" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::MaskBufferSize, QgsPropertyDefinition( "MaskBufferSize", QObject::tr( "Mask buffer size" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::MaskBufferUnit, QgsPropertyDefinition( "MaskBufferUnit", QObject::tr( "Mask buffer unit" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::MaskOpacity, QgsPropertyDefinition( "MaskOpacity", QObject::tr( "Mask opacity" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::MaskJoinStyle, QgsPropertyDefinition( "MaskJoinStyle", QObject::tr( "Mask join style" ), QgsPropertyDefinition::PenJoinStyle, origin ) },
 
    { QgsPalLayerSettings::ShapeDraw, QgsPropertyDefinition( "ShapeDraw", QObject::tr( "Draw shape" ), QgsPropertyDefinition::Boolean, origin ) },
    {
      QgsPalLayerSettings::ShapeKind, QgsPropertyDefinition( "ShapeKind", QgsPropertyDefinition::DataTypeString, QObject::tr( "Shape type" ), QObject::tr( "string " ) + QStringLiteral( "[<b>Rectangle</b>|<b>Square</b>|<br>"
          "<b>Ellipse</b>|<b>Circle</b>|<b>SVG</b>]" ), origin )
    },
    { QgsPalLayerSettings::ShapeSVGFile, QgsPropertyDefinition( "ShapeSVGFile", QObject::tr( "Shape SVG path" ), QgsPropertyDefinition::SvgPath, origin ) },
    { QgsPalLayerSettings::ShapeSizeType, QgsPropertyDefinition( "ShapeSizeType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Shape size type" ), QObject::tr( "string " ) + "[<b>Buffer</b>|<b>Fixed</b>]", origin ) },
    { QgsPalLayerSettings::ShapeSizeX, QgsPropertyDefinition( "ShapeSizeX", QObject::tr( "Shape size (X)" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::ShapeSizeY, QgsPropertyDefinition( "ShapeSizeY", QObject::tr( "Shape size (Y)" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::ShapeSizeUnits, QgsPropertyDefinition( "ShapeSizeUnits", QObject::tr( "Shape size units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::ShapeRotationType, QgsPropertyDefinition( "ShapeRotationType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Shape rotation type" ), QObject::tr( "string " ) + "[<b>Sync</b>|<b>Offset</b>|<b>Fixed</b>]", origin ) },
    { QgsPalLayerSettings::ShapeRotation, QgsPropertyDefinition( "ShapeRotation", QObject::tr( "Shape rotation" ), QgsPropertyDefinition::Rotation, origin ) },
    { QgsPalLayerSettings::ShapeOffset, QgsPropertyDefinition( "ShapeOffset", QObject::tr( "Shape offset" ), QgsPropertyDefinition::Offset, origin ) },
    { QgsPalLayerSettings::ShapeOffsetUnits, QgsPropertyDefinition( "ShapeOffsetUnits", QObject::tr( "Shape offset units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::ShapeRadii, QgsPropertyDefinition( "ShapeRadii", QObject::tr( "Shape radii" ), QgsPropertyDefinition::Size2D, origin ) },
    { QgsPalLayerSettings::ShapeRadiiUnits, QgsPropertyDefinition( "ShapeRadiiUnits", QObject::tr( "Symbol radii units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::ShapeTransparency, QgsPropertyDefinition( "ShapeTransparency", QObject::tr( "Shape transparency" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::ShapeOpacity, QgsPropertyDefinition( "ShapeOpacity", QObject::tr( "Shape opacity" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::ShapeBlendMode, QgsPropertyDefinition( "ShapeBlendMode", QObject::tr( "Shape blend mode" ), QgsPropertyDefinition::BlendMode, origin ) },
    { QgsPalLayerSettings::ShapeFillColor, QgsPropertyDefinition( "ShapeFillColor", QObject::tr( "Shape fill color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
    { QgsPalLayerSettings::ShapeStrokeColor, QgsPropertyDefinition( "ShapeBorderColor", QObject::tr( "Shape stroke color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
    { QgsPalLayerSettings::ShapeStrokeWidth, QgsPropertyDefinition( "ShapeBorderWidth", QObject::tr( "Shape stroke width" ), QgsPropertyDefinition::StrokeWidth, origin ) },
    { QgsPalLayerSettings::ShapeStrokeWidthUnits, QgsPropertyDefinition( "ShapeBorderWidthUnits", QObject::tr( "Shape stroke width units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::ShapeJoinStyle, QgsPropertyDefinition( "ShapeJoinStyle", QObject::tr( "Shape join style" ), QgsPropertyDefinition::PenJoinStyle, origin ) },
    { QgsPalLayerSettings::ShadowDraw, QgsPropertyDefinition( "ShadowDraw", QObject::tr( "Draw shadow" ), QgsPropertyDefinition::Boolean, origin ) },
    {
      QgsPalLayerSettings::ShadowUnder, QgsPropertyDefinition( "ShadowUnder", QgsPropertyDefinition::DataTypeString, QObject::tr( "Symbol size" ), QObject::tr( "string " ) + QStringLiteral( "[<b>Lowest</b>|<b>Text</b>|<br>"
          "<b>Buffer</b>|<b>Background</b>]" ), origin )
    },
    { QgsPalLayerSettings::ShadowOffsetAngle, QgsPropertyDefinition( "ShadowOffsetAngle", QObject::tr( "Shadow offset angle" ), QgsPropertyDefinition::Rotation, origin ) },
    { QgsPalLayerSettings::ShadowOffsetDist, QgsPropertyDefinition( "ShadowOffsetDist", QObject::tr( "Shadow offset distance" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::ShadowOffsetUnits, QgsPropertyDefinition( "ShadowOffsetUnits", QObject::tr( "Shadow offset units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::ShadowRadius, QgsPropertyDefinition( "ShadowRadius", QObject::tr( "Shadow blur radius" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::ShadowRadiusUnits, QgsPropertyDefinition( "ShadowRadiusUnits", QObject::tr( "Shadow blur units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::ShadowTransparency, QgsPropertyDefinition( "ShadowTransparency", QObject::tr( "Shadow transparency" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::ShadowOpacity, QgsPropertyDefinition( "ShadowOpacity", QObject::tr( "Shadow opacity" ), QgsPropertyDefinition::Opacity, origin ) },
    { QgsPalLayerSettings::ShadowScale, QgsPropertyDefinition( "ShadowScale", QObject::tr( "Shadow scale" ), QgsPropertyDefinition::IntegerPositive, origin ) },
    { QgsPalLayerSettings::ShadowColor, QgsPropertyDefinition( "ShadowColor", QObject::tr( "Shadow color" ), QgsPropertyDefinition::ColorNoAlpha, origin ) },
    { QgsPalLayerSettings::ShadowBlendMode, QgsPropertyDefinition( "ShadowBlendMode", QObject::tr( "Shadow blend mode" ), QgsPropertyDefinition::BlendMode, origin ) },
 
    { QgsPalLayerSettings::CentroidWhole, QgsPropertyDefinition( "CentroidWhole", QgsPropertyDefinition::DataTypeString, QObject::tr( "Centroid of whole shape" ), QObject::tr( "string " ) + "[<b>Visible</b>|<b>Whole</b>]", origin ) },
    {
      QgsPalLayerSettings::OffsetQuad, QgsPropertyDefinition( "OffsetQuad", QgsPropertyDefinition::DataTypeString, QObject::tr( "Offset quadrant" ), QObject::tr( "int<br>" ) + QStringLiteral( "[<b>0</b>=Above Left|<b>1</b>=Above|<b>2</b>=Above Right|<br>"
          "<b>3</b>=Left|<b>4</b>=Over|<b>5</b>=Right|<br>"
          "<b>6</b>=Below Left|<b>7</b>=Below|<b>8</b>=Below Right]" ), origin )
    },
    { QgsPalLayerSettings::OffsetXY, QgsPropertyDefinition( "OffsetXY", QObject::tr( "Offset" ), QgsPropertyDefinition::Offset, origin ) },
    { QgsPalLayerSettings::OffsetUnits, QgsPropertyDefinition( "OffsetUnits", QObject::tr( "Offset units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::LabelDistance, QgsPropertyDefinition( "LabelDistance", QObject::tr( "Label distance" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::DistanceUnits, QgsPropertyDefinition( "DistanceUnits", QObject::tr( "Label distance units" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::OffsetRotation, QgsPropertyDefinition( "OffsetRotation", QObject::tr( "Offset rotation" ), QgsPropertyDefinition::Rotation, origin ) },
    { QgsPalLayerSettings::CurvedCharAngleInOut, QgsPropertyDefinition( "CurvedCharAngleInOut", QgsPropertyDefinition::DataTypeString, QObject::tr( "Curved character angles" ), QObject::tr( "double coord [<b>in,out</b> as 20.0-60.0,20.0-95.0]" ), origin ) },
    { QgsPalLayerSettings::RepeatDistance, QgsPropertyDefinition( "RepeatDistance", QObject::tr( "Repeat distance" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::RepeatDistanceUnit, QgsPropertyDefinition( "RepeatDistanceUnit", QObject::tr( "Repeat distance unit" ), QgsPropertyDefinition::RenderUnits, origin ) },
    { QgsPalLayerSettings::OverrunDistance, QgsPropertyDefinition( "OverrunDistance", QObject::tr( "Overrun distance" ), QgsPropertyDefinition::DoublePositive, origin ) },
    { QgsPalLayerSettings::LineAnchorPercent, QgsPropertyDefinition( "LineAnchorPercent", QObject::tr( "Line anchor percentage, as fraction from 0.0 to 1.0" ), QgsPropertyDefinition::Double0To1, origin ) },
    { QgsPalLayerSettings::LineAnchorClipping, QgsPropertyDefinition( "LineAnchorClipping", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line anchor clipping mode" ), QObject::tr( "string " ) + QStringLiteral( "[<b>visible</b>|<b>entire</b>]" ), origin ) },
    { QgsPalLayerSettings::LineAnchorType, QgsPropertyDefinition( "LineAnchorType", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line anchor type" ), QObject::tr( "string " ) + QStringLiteral( "[<b>hint</b>|<b>strict</b>]" ), origin ) },
    { QgsPalLayerSettings::LineAnchorTextPoint, QgsPropertyDefinition( "LineAnchorTextPoint", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line anchor text point" ), QObject::tr( "string " ) + QStringLiteral( "[<b>follow</b>|<b>start</b>|<b>center</b>|<b>end</b>]" ), origin ) },
    { QgsPalLayerSettings::Priority, QgsPropertyDefinition( "Priority", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Label priority" ), QObject::tr( "double [0.0-10.0]" ), origin ) },
    { QgsPalLayerSettings::IsObstacle, QgsPropertyDefinition( "IsObstacle", QObject::tr( "Feature is a label obstacle" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::ObstacleFactor, QgsPropertyDefinition( "ObstacleFactor", QgsPropertyDefinition::DataTypeNumeric, QObject::tr( "Obstacle factor" ), QObject::tr( "double [0.0-10.0]" ), origin ) },
    {
      QgsPalLayerSettings::PredefinedPositionOrder, QgsPropertyDefinition( "PredefinedPositionOrder", QgsPropertyDefinition::DataTypeString, QObject::tr( "Predefined position order" ),  QObject::tr( "Comma separated list of placements in order of priority<br>" )
          + QStringLiteral( "[<b>TL</b>=Top left|<b>TSL</b>=Top, slightly left|<b>T</b>=Top middle|<br>"
                            "<b>TSR</b>=Top, slightly right|<b>TR</b>=Top right|<br>"
                            "<b>L</b>=Left|<b>R</b>=Right|<br>"
                            "<b>BL</b>=Bottom left|<b>BSL</b>=Bottom, slightly left|<b>B</b>=Bottom middle|<br>"
                            "<b>BSR</b>=Bottom, slightly right|<b>BR</b>=Bottom right]" ), origin )
    },
    {
      QgsPalLayerSettings::LinePlacementOptions, QgsPropertyDefinition( "LinePlacementFlags", QgsPropertyDefinition::DataTypeString, QObject::tr( "Line placement options" ),  QObject::tr( "Comma separated list of placement options<br>" )
          + QStringLiteral( "[<b>OL</b>=On line|<b>AL</b>=Above line|<b>BL</b>=Below line|<br>"
                            "<b>LO</b>=Respect line orientation]" ), origin )
    },
    { QgsPalLayerSettings::PolygonLabelOutside, QgsPropertyDefinition( "PolygonLabelOutside", QgsPropertyDefinition::DataTypeString, QObject::tr( "Label outside polygons" ),  QObject::tr( "string " ) + "[<b>yes</b> (allow placing outside)|<b>no</b> (never place outside)|<b>force</b> (always place outside)]", origin ) },
    { QgsPalLayerSettings::PositionX, QgsPropertyDefinition( "PositionX", QObject::tr( "Position (X)" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::PositionY, QgsPropertyDefinition( "PositionY", QObject::tr( "Position (Y)" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::PositionPoint, QgsPropertyDefinition( "PositionPoint", QgsPropertyDefinition::DataTypeString, QObject::tr( "Position (point)" ), QObject::tr( "A point geometry" ), origin ) },
    { QgsPalLayerSettings::Hali, QgsPropertyDefinition( "Hali", QgsPropertyDefinition::DataTypeString, QObject::tr( "Horizontal alignment" ), QObject::tr( "string " ) + "[<b>Left</b>|<b>Center</b>|<b>Right</b>]", origin ) },
    {
      QgsPalLayerSettings::Vali, QgsPropertyDefinition( "Vali", QgsPropertyDefinition::DataTypeString, QObject::tr( "Vertical alignment" ), QObject::tr( "string " ) + QStringLiteral( "[<b>Bottom</b>|<b>Base</b>|<br>"
          "<b>Half</b>|<b>Cap</b>|<b>Top</b>]" ), origin )
    },
    { QgsPalLayerSettings::Rotation, QgsPropertyDefinition( "Rotation", QObject::tr( "Label rotation (deprecated)" ), QgsPropertyDefinition::Rotation, origin ) },
    { QgsPalLayerSettings::LabelRotation, QgsPropertyDefinition( "LabelRotation", QObject::tr( "Label rotation" ), QgsPropertyDefinition::Rotation, origin ) },
    { QgsPalLayerSettings::ScaleVisibility, QgsPropertyDefinition( "ScaleVisibility", QObject::tr( "Scale based visibility" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::MinScale, QgsPropertyDefinition( "MinScale", QObject::tr( "Minimum scale (denominator)" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::MaxScale, QgsPropertyDefinition( "MaxScale", QObject::tr( "Maximum scale (denominator)" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::MinimumScale, QgsPropertyDefinition( "MinimumScale", QObject::tr( "Minimum scale (denominator)" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::MaximumScale, QgsPropertyDefinition( "MaximumScale", QObject::tr( "Maximum scale (denominator)" ), QgsPropertyDefinition::Double, origin ) },
 
    { QgsPalLayerSettings::FontLimitPixel, QgsPropertyDefinition( "FontLimitPixel", QObject::tr( "Limit font pixel size" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::FontMinPixel, QgsPropertyDefinition( "FontMinPixel", QObject::tr( "Minimum pixel size" ), QgsPropertyDefinition::IntegerPositive, origin ) },
    { QgsPalLayerSettings::FontMaxPixel, QgsPropertyDefinition( "FontMaxPixel", QObject::tr( "Maximum pixel size" ), QgsPropertyDefinition::IntegerPositive, origin ) },
    { QgsPalLayerSettings::ZIndex, QgsPropertyDefinition( "ZIndex", QObject::tr( "Label z-index" ), QgsPropertyDefinition::Double, origin ) },
    { QgsPalLayerSettings::Show, QgsPropertyDefinition( "Show", QObject::tr( "Show label" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::AlwaysShow, QgsPropertyDefinition( "AlwaysShow", QObject::tr( "Always show label" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::CalloutDraw, QgsPropertyDefinition( "CalloutDraw", QObject::tr( "Draw callout" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::LabelAllParts, QgsPropertyDefinition( "LabelAllParts", QObject::tr( "Label all parts" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::AllowDegradedPlacement, QgsPropertyDefinition( "AllowDegradedPlacement", QObject::tr( "Allow inferior fallback placements" ), QgsPropertyDefinition::Boolean, origin ) },
    { QgsPalLayerSettings::OverlapHandling, QgsPropertyDefinition( "OverlapHandling", QgsPropertyDefinition::DataTypeString, QObject::tr( "Overlap handing" ), QObject::tr( "string " ) + "[<b>Prevent</b>|<b>AllowIfNeeded</b>|<b>AlwaysAllow</b>]", origin ) },
  };
}
 
Q_NOWARN_DEPRECATED_PUSH // because of deprecated members
QgsPalLayerSettings::QgsPalLayerSettings()
  : predefinedPositionOrder( *DEFAULT_PLACEMENT_ORDER() )
  , mCallout( QgsCalloutRegistry::defaultCallout() )
{
  initPropertyDefinitions();
 
  mFormat = QgsStyle::defaultStyle()->defaultTextFormat( QgsStyle::TextFormatContext::Labeling );
}
Q_NOWARN_DEPRECATED_POP
 
Q_NOWARN_DEPRECATED_PUSH // because of deprecated members
QgsPalLayerSettings::QgsPalLayerSettings( const QgsPalLayerSettings &s )
  : fieldIndex( 0 )
  , mDataDefinedProperties( s.mDataDefinedProperties )
{
  *this = s;
}
Q_NOWARN_DEPRECATED_POP
 
QgsPalLayerSettings &QgsPalLayerSettings::operator=( const QgsPalLayerSettings &s )
{
  if ( this == &s )
    return *this;
 
  // copy only permanent stuff
 
  drawLabels = s.drawLabels;
 
  // text style
  fieldName = s.fieldName;
  isExpression = s.isExpression;
  Q_NOWARN_DEPRECATED_PUSH
  previewBkgrdColor = s.previewBkgrdColor;
  Q_NOWARN_DEPRECATED_POP
  substitutions = s.substitutions;
  useSubstitutions = s.useSubstitutions;
 
  // text formatting
  wrapChar = s.wrapChar;
  autoWrapLength = s.autoWrapLength;
  useMaxLineLengthForAutoWrap = s.useMaxLineLengthForAutoWrap;
  multilineAlign = s.multilineAlign;
  formatNumbers = s.formatNumbers;
  decimals = s.decimals;
  plusSign = s.plusSign;
 
  // placement
  placement = s.placement;
  mPolygonPlacementFlags = s.mPolygonPlacementFlags;
  centroidWhole = s.centroidWhole;
  centroidInside = s.centroidInside;
  predefinedPositionOrder = s.predefinedPositionOrder;
  fitInPolygonOnly = s.fitInPolygonOnly;
  quadOffset = s.quadOffset;
  xOffset = s.xOffset;
  yOffset = s.yOffset;
  offsetUnits = s.offsetUnits;
  labelOffsetMapUnitScale = s.labelOffsetMapUnitScale;
  dist = s.dist;
  offsetType = s.offsetType;
  distUnits = s.distUnits;
  distMapUnitScale = s.distMapUnitScale;
  angleOffset = s.angleOffset;
  preserveRotation = s.preserveRotation;
  mRotationUnit = s.mRotationUnit;
  maxCurvedCharAngleIn = s.maxCurvedCharAngleIn;
  maxCurvedCharAngleOut = s.maxCurvedCharAngleOut;
  priority = s.priority;
  repeatDistance = s.repeatDistance;
  repeatDistanceUnit = s.repeatDistanceUnit;
  repeatDistanceMapUnitScale = s.repeatDistanceMapUnitScale;
 
  // rendering
  scaleVisibility = s.scaleVisibility;
  maximumScale = s.maximumScale;
  minimumScale = s.minimumScale;
  fontLimitPixelSize = s.fontLimitPixelSize;
  fontMinPixelSize = s.fontMinPixelSize;
  fontMaxPixelSize = s.fontMaxPixelSize;
  upsidedownLabels = s.upsidedownLabels;
 
  labelPerPart = s.labelPerPart;
  zIndex = s.zIndex;
 
  mFormat = s.mFormat;
  mDataDefinedProperties = s.mDataDefinedProperties;
 
  mCallout.reset( s.mCallout ? s.mCallout->clone() : nullptr );
 
  mPlacementSettings = s.mPlacementSettings;
  mLineSettings = s.mLineSettings;
  mObstacleSettings = s.mObstacleSettings;
  mThinningSettings = s.mThinningSettings;
 
  geometryGenerator = s.geometryGenerator;
  geometryGeneratorEnabled = s.geometryGeneratorEnabled;
  geometryGeneratorType = s.geometryGeneratorType;
  layerType = s.layerType;
 
  mLegendString = s.mLegendString;
 
  mUnplacedVisibility = s.mUnplacedVisibility;
 
  return *this;
}
 
bool QgsPalLayerSettings::prepare( QgsRenderContext &context, QSet<QString> &attributeNames, const QgsFields &fields, const QgsMapSettings &mapSettings, const QgsCoordinateReferenceSystem &crs )
{
  if ( drawLabels )
  {
    if ( fieldName.isEmpty() )
    {
      return false;
    }
 
    if ( isExpression )
    {
      QgsExpression exp( fieldName );
      if ( exp.hasEvalError() )
      {
        QgsDebugMsgLevel( "Prepare error:" + exp.evalErrorString(), 4 );
        return false;
      }
    }
    else
    {
      // If we aren't an expression, we check to see if we can find the column.
      if ( fields.lookupField( fieldName ) == -1 )
      {
        return false;
      }
    }
  }
 
  mCurFields = fields;
 
  if ( drawLabels || mObstacleSettings.isObstacle() )
  {
    if ( drawLabels )
    {
      // add field indices for label's text, from expression or field
      if ( isExpression )
      {
        // prepare expression for use in QgsPalLayerSettings::registerFeature()
        QgsExpression *exp = getLabelExpression();
        exp->prepare( &context.expressionContext() );
        if ( exp->hasEvalError() )
        {
          QgsDebugMsgLevel( "Prepare error:" + exp->evalErrorString(), 4 );
        }
        const auto referencedColumns = exp->referencedColumns();
        for ( const QString &name : referencedColumns )
        {
          attributeNames.insert( name );
        }
      }
      else
      {
        attributeNames.insert( fieldName );
      }
    }
 
    mDataDefinedProperties.prepare( context.expressionContext() );
    // add field indices of data defined expression or field
    attributeNames.unite( dataDefinedProperties().referencedFields( context.expressionContext() ) );
  }
 
  // NOW INITIALIZE QgsPalLayerSettings
 
  // TODO: ideally these (non-configuration) members should get out of QgsPalLayerSettings to QgsVectorLayerLabelProvider::prepare
  // (together with registerFeature() & related methods) and QgsPalLayerSettings just stores config
 
  // save the pal layer to our layer context (with some additional info)
  fieldIndex = fields.lookupField( fieldName );
 
  xform = &mapSettings.mapToPixel();
  ct = QgsCoordinateTransform();
  if ( context.coordinateTransform().isValid() )
    // this is context for layer rendering
    ct = context.coordinateTransform();
  else
  {
    // otherwise fall back to creating our own CT
    ct = QgsCoordinateTransform( crs, mapSettings.destinationCrs(), mapSettings.transformContext() );
  }
  ptZero = xform->toMapCoordinates( 0, 0 );
  ptOne = xform->toMapCoordinates( 1, 0 );
 
  // rect for clipping
  QgsRectangle r1 = mapSettings.visibleExtent();
  QgsDebugMsgLevel( QStringLiteral( "Visible extent: %1" ).arg( r1.toString() ), 2 );
  QgsDebugMsgLevel( QStringLiteral( "mapSetting extentBuffer: %1" ).arg( mapSettings.extentBuffer() ), 2 );
  r1.grow( mapSettings.extentBuffer() );
  QgsDebugMsgLevel( QStringLiteral( "Grown visible extent: %1" ).arg( r1.toString() ), 2 );
  extentGeom = QgsGeometry::fromRect( r1 );
  QgsDebugMsgLevel( QStringLiteral( "Extent geom  %1" ).arg( extentGeom.asWkt() ), 2 );
 
  if ( !qgsDoubleNear( mapSettings.rotation(), 0.0 ) )
  {
    //PAL features are prerotated, so extent also needs to be unrotated
    extentGeom.rotate( -mapSettings.rotation(), mapSettings.visibleExtent().center() );
    QgsDebugMsgLevel( QStringLiteral( "Rotated extent geom  %1" ).arg( extentGeom.asWkt() ), 2 );
  }
 
  mFeatsSendingToPal = 0;
 
  if ( geometryGeneratorEnabled )
  {
    mGeometryGeneratorExpression = QgsExpression( geometryGenerator );
    mGeometryGeneratorExpression.prepare( &context.expressionContext() );
    if ( mGeometryGeneratorExpression.hasParserError() )
    {
      QgsMessageLog::logMessage( mGeometryGeneratorExpression.parserErrorString(), QObject::tr( "Labeling" ) );
      return false;
    }
 
    const auto referencedColumns = mGeometryGeneratorExpression.referencedColumns();
    for ( const QString &name : referencedColumns )
    {
      attributeNames.insert( name );
    }
  }
  attributeNames.unite( mFormat.referencedFields( context ) );
 
  if ( mCallout )
  {
    const auto referencedColumns = mCallout->referencedFields( context );
    for ( const QString &name : referencedColumns )
    {
      attributeNames.insert( name );
    }
  }
 
  return true;
}
 
QSet<QString> QgsPalLayerSettings::referencedFields( const QgsRenderContext &context ) const
{
  QSet<QString> referenced;
  if ( drawLabels )
  {
    if ( isExpression )
    {
      referenced.unite( QgsExpression( fieldName ).referencedColumns() );
    }
    else
    {
      referenced.insert( fieldName );
    }
  }
 
  referenced.unite( mFormat.referencedFields( context ) );
 
  // calling referencedFields() with ignoreContext=true because in our expression context
  // we do not have valid QgsFields yet - because of that the field names from expressions
  // wouldn't get reported
  referenced.unite( mDataDefinedProperties.referencedFields( context.expressionContext(), true ) );
 
  if ( geometryGeneratorEnabled )
  {
    QgsExpression geomGeneratorExpr( geometryGenerator );
    referenced.unite( geomGeneratorExpr.referencedColumns() );
  }
 
  if ( mCallout )
  {
    referenced.unite( mCallout->referencedFields( context ) );
  }
 
  return referenced;
}
 
void QgsPalLayerSettings::startRender( QgsRenderContext &context )
{
  if ( mRenderStarted )
  {
    qWarning( "Start render called for when a previous render was already underway!!" );
    return;
  }
 
  switch ( placement )
  {
    case Qgis::LabelPlacement::PerimeterCurved:
    case Qgis::LabelPlacement::Curved:
    {
      // force horizontal orientation, other orientation modes aren't unsupported for curved placement
      mFormat.setOrientation( Qgis::TextOrientation::Horizontal );
      mDataDefinedProperties.property( QgsPalLayerSettings::TextOrientation ).setActive( false );
      break;
    }
 
    case Qgis::LabelPlacement::AroundPoint:
    case Qgis::LabelPlacement::OverPoint:
    case Qgis::LabelPlacement::Line:
    case Qgis::LabelPlacement::Horizontal:
    case Qgis::LabelPlacement::Free:
    case Qgis::LabelPlacement::OrderedPositionsAroundPoint:
    case Qgis::LabelPlacement::OutsidePolygons:
      break;
  }
 
  if ( mCallout )
  {
    mCallout->startRender( context );
  }
 
  mRenderStarted = true;
}
 
void QgsPalLayerSettings::stopRender( QgsRenderContext &context )
{
  if ( !mRenderStarted )
  {
    qWarning( "Stop render called for QgsPalLayerSettings without a startRender call!" );
    return;
  }
 
  if ( mCallout )
  {
    mCallout->stopRender( context );
  }
 
  mRenderStarted = false;
}
 
bool QgsPalLayerSettings::containsAdvancedEffects() const
{
  return mFormat.containsAdvancedEffects() || mCallout->containsAdvancedEffects();
}
 
QgsPalLayerSettings::~QgsPalLayerSettings()
{
  if ( mRenderStarted )
  {
    qWarning( "stopRender was not called on QgsPalLayerSettings object!" );
  }
 
  // pal layer is deleted internally in PAL
 
  delete expression;
}
 
 
const QgsPropertiesDefinition &QgsPalLayerSettings::propertyDefinitions()
{
  initPropertyDefinitions();
  return *sPropertyDefinitions();
}
 
QgsExpression *QgsPalLayerSettings::getLabelExpression()
{
  if ( !expression )
  {
    expression = new QgsExpression( fieldName );
  }
  return expression;
}
 
Qgis::AngleUnit QgsPalLayerSettings::rotationUnit() const
{
  return mRotationUnit;
}
 
void QgsPalLayerSettings::setRotationUnit( Qgis::AngleUnit angleUnit )
{
  mRotationUnit = angleUnit;
}
 
QString updateDataDefinedString( const QString &value )
{
  // TODO: update or remove this when project settings for labeling are migrated to better XML layout
  QString newValue = value;
  if ( !value.isEmpty() && !value.contains( QLatin1String( "~~" ) ) )
  {
    QStringList values;
    values << QStringLiteral( "1" ); // all old-style values are active if not empty
    values << QStringLiteral( "0" );
    values << QString();
    values << value; // all old-style values are only field names
    newValue = values.join( QLatin1String( "~~" ) );
  }
 
  return newValue;
}
 
void QgsPalLayerSettings::readOldDataDefinedProperty( QgsVectorLayer *layer, QgsPalLayerSettings::Property p )
{
  QString newPropertyName = "labeling/dataDefined/" + sPropertyDefinitions()->value( p ).name();
  QVariant newPropertyField = layer->customProperty( newPropertyName, QVariant() );
 
  if ( !newPropertyField.isValid() )
    return;
 
  QString ddString = newPropertyField.toString();
 
  if ( !ddString.isEmpty() && ddString != QLatin1String( "0~~0~~~~" ) )
  {
    // TODO: update this when project settings for labeling are migrated to better XML layout
    QString newStyleString = updateDataDefinedString( ddString );
    QStringList ddv = newStyleString.split( QStringLiteral( "~~" ) );
 
    bool active = ddv.at( 0 ).toInt();
    if ( ddv.at( 1 ).toInt() )
    {
      mDataDefinedProperties.setProperty( p, QgsProperty::fromExpression( ddv.at( 2 ), active ) );
    }
    else
    {
      mDataDefinedProperties.setProperty( p, QgsProperty::fromField( ddv.at( 3 ), active ) );
    }
  }
  else
  {
    // remove unused properties
    layer->removeCustomProperty( newPropertyName );
  }
}
 
void QgsPalLayerSettings::readOldDataDefinedPropertyMap( QgsVectorLayer *layer, QDomElement *parentElem )
{
  if ( !layer && !parentElem )
  {
    return;
  }
 
  QgsPropertiesDefinition::const_iterator i = sPropertyDefinitions()->constBegin();
  for ( ; i != sPropertyDefinitions()->constEnd(); ++i )
  {
    if ( layer )
    {
      // reading from layer's custom properties
      readOldDataDefinedProperty( layer, static_cast< Property >( i.key() ) );
    }
    else if ( parentElem )
    {
      // reading from XML
      QDomElement e = parentElem->firstChildElement( i.value().name() );
      if ( !e.isNull() )
      {
        bool active = e.attribute( QStringLiteral( "active" ) ).compare( QLatin1String( "true" ), Qt::CaseInsensitive ) == 0;
        bool isExpression = e.attribute( QStringLiteral( "useExpr" ) ).compare( QLatin1String( "true" ), Qt::CaseInsensitive ) == 0;
        if ( isExpression )
        {
          mDataDefinedProperties.setProperty( i.key(), QgsProperty::fromExpression( e.attribute( QStringLiteral( "expr" ) ), active ) );
        }
        else
        {
          mDataDefinedProperties.setProperty( i.key(), QgsProperty::fromField( e.attribute( QStringLiteral( "field" ) ), active ) );
        }
      }
    }
  }
}
 
void QgsPalLayerSettings::readFromLayerCustomProperties( QgsVectorLayer *layer )
{
  if ( layer->customProperty( QStringLiteral( "labeling" ) ).toString() != QLatin1String( "pal" ) )
  {
    if ( layer->geometryType() == Qgis::GeometryType::Point )
      placement = Qgis::LabelPlacement::OrderedPositionsAroundPoint;
 
    // for polygons the "over point" (over centroid) placement is better than the default
    // "around point" (around centroid) which is more suitable for points
    if ( layer->geometryType() == Qgis::GeometryType::Polygon )
      placement = Qgis::LabelPlacement::OverPoint;
 
    return; // there's no information available
  }
 
  // NOTE: set defaults for newly added properties, for backwards compatibility
 
  drawLabels = layer->customProperty( QStringLiteral( "labeling/drawLabels" ), true ).toBool();
 
  mFormat.readFromLayer( layer );
 
  // text style
  fieldName = layer->customProperty( QStringLiteral( "labeling/fieldName" ) ).toString();
  isExpression = layer->customProperty( QStringLiteral( "labeling/isExpression" ) ).toBool();
  Q_NOWARN_DEPRECATED_PUSH
  previewBkgrdColor = QColor( layer->customProperty( QStringLiteral( "labeling/previewBkgrdColor" ), QVariant( "#ffffff" ) ).toString() );
  Q_NOWARN_DEPRECATED_POP
  QDomDocument doc( QStringLiteral( "substitutions" ) );
  doc.setContent( layer->customProperty( QStringLiteral( "labeling/substitutions" ) ).toString() );
  QDomElement replacementElem = doc.firstChildElement( QStringLiteral( "substitutions" ) );
  substitutions.readXml( replacementElem );
  useSubstitutions = layer->customProperty( QStringLiteral( "labeling/useSubstitutions" ) ).toBool();
 
  // text formatting
  wrapChar = layer->customProperty( QStringLiteral( "labeling/wrapChar" ) ).toString();
  autoWrapLength = layer->customProperty( QStringLiteral( "labeling/autoWrapLength" ) ).toInt();
  useMaxLineLengthForAutoWrap = layer->customProperty( QStringLiteral( "labeling/useMaxLineLengthForAutoWrap" ), QStringLiteral( "1" ) ).toBool();
 
  multilineAlign = static_cast< Qgis::LabelMultiLineAlignment >( layer->customProperty( QStringLiteral( "labeling/multilineAlign" ), QVariant( static_cast< int >( Qgis::LabelMultiLineAlignment::FollowPlacement ) ) ).toUInt() );
  mLineSettings.setAddDirectionSymbol( layer->customProperty( QStringLiteral( "labeling/addDirectionSymbol" ) ).toBool() );
  mLineSettings.setLeftDirectionSymbol( layer->customProperty( QStringLiteral( "labeling/leftDirectionSymbol" ), QVariant( "<" ) ).toString() );
  mLineSettings.setRightDirectionSymbol( layer->customProperty( QStringLiteral( "labeling/rightDirectionSymbol" ), QVariant( ">" ) ).toString() );
  mLineSettings.setReverseDirectionSymbol( layer->customProperty( QStringLiteral( "labeling/reverseDirectionSymbol" ) ).toBool() );
  mLineSettings.setDirectionSymbolPlacement( static_cast< QgsLabelLineSettings::DirectionSymbolPlacement >( layer->customProperty( QStringLiteral( "labeling/placeDirectionSymbol" ), QVariant( static_cast< int >( QgsLabelLineSettings::DirectionSymbolPlacement::SymbolLeftRight ) ) ).toUInt() ) );
  formatNumbers = layer->customProperty( QStringLiteral( "labeling/formatNumbers" ) ).toBool();
  decimals = layer->customProperty( QStringLiteral( "labeling/decimals" ) ).toInt();
  plusSign = layer->customProperty( QStringLiteral( "labeling/plussign" ) ).toBool();
 
  // placement
  placement = static_cast< Qgis::LabelPlacement >( layer->customProperty( QStringLiteral( "labeling/placement" ) ).toInt() );
  mLineSettings.setPlacementFlags( static_cast< Qgis::LabelLinePlacementFlags >( layer->customProperty( QStringLiteral( "labeling/placementFlags" ) ).toUInt() ) );
  centroidWhole = layer->customProperty( QStringLiteral( "labeling/centroidWhole" ), QVariant( false ) ).toBool();
  centroidInside = layer->customProperty( QStringLiteral( "labeling/centroidInside" ), QVariant( false ) ).toBool();
  predefinedPositionOrder = QgsLabelingUtils::decodePredefinedPositionOrder( layer->customProperty( QStringLiteral( "labeling/predefinedPositionOrder" ) ).toString() );
  if ( predefinedPositionOrder.isEmpty() )
    predefinedPositionOrder = *DEFAULT_PLACEMENT_ORDER();
  fitInPolygonOnly = layer->customProperty( QStringLiteral( "labeling/fitInPolygonOnly" ), QVariant( false ) ).toBool();
  dist = layer->customProperty( QStringLiteral( "labeling/dist" ) ).toDouble();
  distUnits = layer->customProperty( QStringLiteral( "labeling/distInMapUnits" ) ).toBool() ? Qgis::RenderUnit::MapUnits : Qgis::RenderUnit::Millimeters;
  if ( layer->customProperty( QStringLiteral( "labeling/distMapUnitScale" ) ).toString().isEmpty() )
  {
    //fallback to older property
    double oldMin = layer->customProperty( QStringLiteral( "labeling/distMapUnitMinScale" ), 0.0 ).toDouble();
    distMapUnitScale.minScale = !qgsDoubleNear( oldMin, 0.0 ) ? 1.0 / oldMin : 0;
    double oldMax = layer->customProperty( QStringLiteral( "labeling/distMapUnitMaxScale" ), 0.0 ).toDouble();
    distMapUnitScale.maxScale = !qgsDoubleNear( oldMax, 0.0 ) ? 1.0 / oldMax : 0;
  }
  else
  {
    distMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( layer->customProperty( QStringLiteral( "labeling/distMapUnitScale" ) ).toString() );
  }
  offsetType = static_cast< Qgis::LabelOffsetType >( layer->customProperty( QStringLiteral( "labeling/offsetType" ), QVariant( static_cast< int >( Qgis::LabelOffsetType::FromPoint ) ) ).toUInt() );
  quadOffset = static_cast< Qgis::LabelQuadrantPosition >( layer->customProperty( QStringLiteral( "labeling/quadOffset" ), QVariant( static_cast< int >( Qgis::LabelQuadrantPosition::Over ) ) ).toUInt() );
  xOffset = layer->customProperty( QStringLiteral( "labeling/xOffset" ), QVariant( 0.0 ) ).toDouble();
  yOffset = layer->customProperty( QStringLiteral( "labeling/yOffset" ), QVariant( 0.0 ) ).toDouble();
  if ( layer->customProperty( QStringLiteral( "labeling/labelOffsetInMapUnits" ), QVariant( true ) ).toBool() )
    offsetUnits = Qgis::RenderUnit::MapUnits;
  else
    offsetUnits = Qgis::RenderUnit::Millimeters;
 
  if ( layer->customProperty( QStringLiteral( "labeling/labelOffsetMapUnitScale" ) ).toString().isEmpty() )
  {
    //fallback to older property
    double oldMin = layer->customProperty( QStringLiteral( "labeling/labelOffsetMapUnitMinScale" ), 0.0 ).toDouble();
    labelOffsetMapUnitScale.minScale = !qgsDoubleNear( oldMin, 0.0 ) ? 1.0 / oldMin : 0;
    double oldMax = layer->customProperty( QStringLiteral( "labeling/labelOffsetMapUnitMaxScale" ), 0.0 ).toDouble();
    labelOffsetMapUnitScale.maxScale = !qgsDoubleNear( oldMax, 0 ) ? 1.0 / oldMax : 0;
  }
  else
  {
    labelOffsetMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( layer->customProperty( QStringLiteral( "labeling/labelOffsetMapUnitScale" ) ).toString() );
  }
 
  QVariant tempAngle = layer->customProperty( QStringLiteral( "labeling/angleOffset" ), QVariant() );
  if ( tempAngle.isValid() )
  {
    double oldAngle = layer->customProperty( QStringLiteral( "labeling/angleOffset" ), QVariant( 0.0 ) ).toDouble();
    angleOffset = std::fmod( 360 - oldAngle, 360.0 );
  }
  else
  {
    angleOffset = layer->customProperty( QStringLiteral( "labeling/rotationAngle" ), QVariant( 0.0 ) ).toDouble();
  }
 
  preserveRotation = layer->customProperty( QStringLiteral( "labeling/preserveRotation" ), QVariant( true ) ).toBool();
  mRotationUnit = layer->customEnumProperty( QStringLiteral( "labeling/rotationUnit" ), Qgis::AngleUnit::Degrees );
  maxCurvedCharAngleIn = layer->customProperty( QStringLiteral( "labeling/maxCurvedCharAngleIn" ), QVariant( 25.0 ) ).toDouble();
  maxCurvedCharAngleOut = layer->customProperty( QStringLiteral( "labeling/maxCurvedCharAngleOut" ), QVariant( -25.0 ) ).toDouble();
  priority = layer->customProperty( QStringLiteral( "labeling/priority" ) ).toInt();
  repeatDistance = layer->customProperty( QStringLiteral( "labeling/repeatDistance" ), 0.0 ).toDouble();
  switch ( layer->customProperty( QStringLiteral( "labeling/repeatDistanceUnit" ), QVariant( 1 ) ).toUInt() )
  {
    case 0:
      repeatDistanceUnit = Qgis::RenderUnit::Points;
      break;
    case 1:
      repeatDistanceUnit = Qgis::RenderUnit::Millimeters;
      break;
    case 2:
      repeatDistanceUnit = Qgis::RenderUnit::MapUnits;
      break;
    case 3:
      repeatDistanceUnit = Qgis::RenderUnit::Percentage;
      break;
  }
  if ( layer->customProperty( QStringLiteral( "labeling/repeatDistanceMapUnitScale" ) ).toString().isEmpty() )
  {
    //fallback to older property
    double oldMin = layer->customProperty( QStringLiteral( "labeling/repeatDistanceMapUnitMinScale" ), 0.0 ).toDouble();
    repeatDistanceMapUnitScale.minScale = !qgsDoubleNear( oldMin, 0 ) ? 1.0 / oldMin : 0;
    double oldMax = layer->customProperty( QStringLiteral( "labeling/repeatDistanceMapUnitMaxScale" ), 0.0 ).toDouble();
    repeatDistanceMapUnitScale.maxScale = !qgsDoubleNear( oldMax, 0 ) ? 1.0 / oldMax : 0;
  }
  else
  {
    repeatDistanceMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( layer->customProperty( QStringLiteral( "labeling/repeatDistanceMapUnitScale" ) ).toString() );
  }
 
  // rendering
  double scalemn = layer->customProperty( QStringLiteral( "labeling/scaleMin" ), QVariant( 0 ) ).toDouble();
  double scalemx = layer->customProperty( QStringLiteral( "labeling/scaleMax" ), QVariant( 0 ) ).toDouble();
 
  // fix for scale visibility limits being keyed off of just its values in the past (<2.0)
  QVariant scalevis = layer->customProperty( QStringLiteral( "labeling/scaleVisibility" ), QVariant() );
  if ( scalevis.isValid() )
  {
    scaleVisibility = scalevis.toBool();
    maximumScale = scalemn;
    minimumScale = scalemx;
  }
  else if ( scalemn > 0 || scalemx > 0 )
  {
    scaleVisibility = true;
    maximumScale = scalemn;
    minimumScale = scalemx;
  }
  else
  {
    // keep scaleMin and scaleMax at new 1.0 defaults (1 and 10000000, were 0 and 0)
    scaleVisibility = false;
  }
 
 
  fontLimitPixelSize = layer->customProperty( QStringLiteral( "labeling/fontLimitPixelSize" ), QVariant( false ) ).toBool();
  fontMinPixelSize = layer->customProperty( QStringLiteral( "labeling/fontMinPixelSize" ), QVariant( 0 ) ).toInt();
  fontMaxPixelSize = layer->customProperty( QStringLiteral( "labeling/fontMaxPixelSize" ), QVariant( 10000 ) ).toInt();
  if ( layer->customProperty( QStringLiteral( "labeling/displayAll" ), QVariant( false ) ).toBool() )
  {
    mPlacementSettings.setOverlapHandling( Qgis::LabelOverlapHandling::AllowOverlapIfRequired );
    mPlacementSettings.setAllowDegradedPlacement( true );
  }
  else
  {
    mPlacementSettings.setOverlapHandling( Qgis::LabelOverlapHandling::PreventOverlap );
    mPlacementSettings.setAllowDegradedPlacement( false );
  }
  upsidedownLabels = static_cast< Qgis::UpsideDownLabelHandling >( layer->customProperty( QStringLiteral( "labeling/upsidedownLabels" ), QVariant( static_cast< int >( Qgis::UpsideDownLabelHandling::FlipUpsideDownLabels ) ) ).toUInt() );
 
  labelPerPart = layer->customProperty( QStringLiteral( "labeling/labelPerPart" ) ).toBool();
  mLineSettings.setMergeLines( layer->customProperty( QStringLiteral( "labeling/mergeLines" ) ).toBool() );
  mThinningSettings.setMinimumFeatureSize( layer->customProperty( QStringLiteral( "labeling/minFeatureSize" ) ).toDouble() );
  mThinningSettings.setLimitNumberLabelsEnabled( layer->customProperty( QStringLiteral( "labeling/limitNumLabels" ), QVariant( false ) ).toBool() );
  mThinningSettings.setMaximumNumberLabels( layer->customProperty( QStringLiteral( "labeling/maxNumLabels" ), QVariant( 2000 ) ).toInt() );
  mObstacleSettings.setIsObstacle( layer->customProperty( QStringLiteral( "labeling/obstacle" ), QVariant( true ) ).toBool() );
  mObstacleSettings.setFactor( layer->customProperty( QStringLiteral( "labeling/obstacleFactor" ), QVariant( 1.0 ) ).toDouble() );
  mObstacleSettings.setType( static_cast< QgsLabelObstacleSettings::ObstacleType >( layer->customProperty( QStringLiteral( "labeling/obstacleType" ), QVariant( PolygonInterior ) ).toUInt() ) );
  zIndex = layer->customProperty( QStringLiteral( "labeling/zIndex" ), QVariant( 0.0 ) ).toDouble();
 
  mDataDefinedProperties.clear();
  if ( layer->customProperty( QStringLiteral( "labeling/ddProperties" ) ).isValid() )
  {
    QDomDocument doc( QStringLiteral( "dd" ) );
    doc.setContent( layer->customProperty( QStringLiteral( "labeling/ddProperties" ) ).toString() );
    QDomElement elem = doc.firstChildElement( QStringLiteral( "properties" ) );
    mDataDefinedProperties.readXml( elem, *sPropertyDefinitions() );
  }
  else
  {
    // read QGIS 2.x style data defined properties
    readOldDataDefinedPropertyMap( layer, nullptr );
  }
  // upgrade older data defined settings
  if ( mDataDefinedProperties.isActive( FontTransp ) )
  {
    mDataDefinedProperties.setProperty( FontOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( FontTransp ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( FontTransp, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( BufferTransp ) )
  {
    mDataDefinedProperties.setProperty( BufferOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( BufferTransp ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( BufferTransp, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( ShapeTransparency ) )
  {
    mDataDefinedProperties.setProperty( ShapeOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( ShapeTransparency ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( ShapeTransparency, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( ShadowTransparency ) )
  {
    mDataDefinedProperties.setProperty( ShadowOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( ShadowTransparency ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( ShadowTransparency, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( Rotation ) )
  {
    mDataDefinedProperties.setProperty( LabelRotation, QgsProperty::fromExpression( QStringLiteral( "360 - (%1)" ).arg( mDataDefinedProperties.property( Rotation ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( Rotation, QgsProperty() );
  }
  // older 2.x projects had min/max scale flipped - so change them here.
  if ( mDataDefinedProperties.isActive( MinScale ) )
  {
    mDataDefinedProperties.setProperty( MaximumScale, mDataDefinedProperties.property( MinScale ) );
    mDataDefinedProperties.setProperty( MinScale, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( MaxScale ) )
  {
    mDataDefinedProperties.setProperty( MinimumScale, mDataDefinedProperties.property( MaxScale ) );
    mDataDefinedProperties.setProperty( MaxScale, QgsProperty() );
  }
}
 
void QgsPalLayerSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
{
  // text style
  QDomElement textStyleElem = elem.firstChildElement( QStringLiteral( "text-style" ) );
  fieldName = textStyleElem.attribute( QStringLiteral( "fieldName" ) );
  isExpression = textStyleElem.attribute( QStringLiteral( "isExpression" ) ).toInt();
 
  mFormat.readXml( elem, context );
  Q_NOWARN_DEPRECATED_PUSH
  previewBkgrdColor = QColor( textStyleElem.attribute( QStringLiteral( "previewBkgrdColor" ), QStringLiteral( "#ffffff" ) ) );
  Q_NOWARN_DEPRECATED_POP
  substitutions.readXml( textStyleElem.firstChildElement( QStringLiteral( "substitutions" ) ) );
  useSubstitutions = textStyleElem.attribute( QStringLiteral( "useSubstitutions" ) ).toInt();
  mLegendString = textStyleElem.attribute( QStringLiteral( "legendString" ), QObject::tr( "Aa" ) );
 
  // text formatting
  QDomElement textFormatElem = elem.firstChildElement( QStringLiteral( "text-format" ) );
  wrapChar = textFormatElem.attribute( QStringLiteral( "wrapChar" ) );
  autoWrapLength = textFormatElem.attribute( QStringLiteral( "autoWrapLength" ), QStringLiteral( "0" ) ).toInt();
  useMaxLineLengthForAutoWrap = textFormatElem.attribute( QStringLiteral( "useMaxLineLengthForAutoWrap" ), QStringLiteral( "1" ) ).toInt();
  multilineAlign = static_cast< Qgis::LabelMultiLineAlignment >( textFormatElem.attribute( QStringLiteral( "multilineAlign" ), QString::number( static_cast< int >( Qgis::LabelMultiLineAlignment::FollowPlacement ) ) ).toUInt() );
  mLineSettings.setAddDirectionSymbol( textFormatElem.attribute( QStringLiteral( "addDirectionSymbol" ) ).toInt() );
  mLineSettings.setLeftDirectionSymbol( textFormatElem.attribute( QStringLiteral( "leftDirectionSymbol" ), QStringLiteral( "<" ) ) );
  mLineSettings.setRightDirectionSymbol( textFormatElem.attribute( QStringLiteral( "rightDirectionSymbol" ), QStringLiteral( ">" ) ) );
  mLineSettings.setReverseDirectionSymbol( textFormatElem.attribute( QStringLiteral( "reverseDirectionSymbol" ) ).toInt() );
  mLineSettings.setDirectionSymbolPlacement( static_cast< QgsLabelLineSettings::DirectionSymbolPlacement >( textFormatElem.attribute( QStringLiteral( "placeDirectionSymbol" ), QString::number( static_cast< int >( QgsLabelLineSettings::DirectionSymbolPlacement::SymbolLeftRight ) ) ).toUInt() ) );
  formatNumbers = textFormatElem.attribute( QStringLiteral( "formatNumbers" ) ).toInt();
  decimals = textFormatElem.attribute( QStringLiteral( "decimals" ) ).toInt();
  plusSign = textFormatElem.attribute( QStringLiteral( "plussign" ) ).toInt();
 
  // placement
  QDomElement placementElem = elem.firstChildElement( QStringLiteral( "placement" ) );
  placement = static_cast< Qgis::LabelPlacement >( placementElem.attribute( QStringLiteral( "placement" ) ).toInt() );
  mLineSettings.setPlacementFlags( static_cast< Qgis::LabelLinePlacementFlags >( placementElem.attribute( QStringLiteral( "placementFlags" ) ).toUInt() ) );
  mPolygonPlacementFlags = static_cast< Qgis::LabelPolygonPlacementFlags >( placementElem.attribute( QStringLiteral( "polygonPlacementFlags" ), QString::number( static_cast< int >( Qgis::LabelPolygonPlacementFlag::AllowPlacementInsideOfPolygon ) ) ).toInt() );
 
  centroidWhole = placementElem.attribute( QStringLiteral( "centroidWhole" ), QStringLiteral( "0" ) ).toInt();
  centroidInside = placementElem.attribute( QStringLiteral( "centroidInside" ), QStringLiteral( "0" ) ).toInt();
  predefinedPositionOrder = QgsLabelingUtils::decodePredefinedPositionOrder( placementElem.attribute( QStringLiteral( "predefinedPositionOrder" ) ) );
  if ( predefinedPositionOrder.isEmpty() )
    predefinedPositionOrder = *DEFAULT_PLACEMENT_ORDER();
  fitInPolygonOnly = placementElem.attribute( QStringLiteral( "fitInPolygonOnly" ), QStringLiteral( "0" ) ).toInt();
  dist = placementElem.attribute( QStringLiteral( "dist" ) ).toDouble();
  if ( !placementElem.hasAttribute( QStringLiteral( "distUnits" ) ) )
  {
    if ( placementElem.attribute( QStringLiteral( "distInMapUnits" ) ).toInt() )
      distUnits = Qgis::RenderUnit::MapUnits;
    else
      distUnits = Qgis::RenderUnit::Millimeters;
  }
  else
  {
    distUnits = QgsUnitTypes::decodeRenderUnit( placementElem.attribute( QStringLiteral( "distUnits" ) ) );
  }
  if ( !placementElem.hasAttribute( QStringLiteral( "distMapUnitScale" ) ) )
  {
    //fallback to older property
    double oldMin = placementElem.attribute( QStringLiteral( "distMapUnitMinScale" ), QStringLiteral( "0" ) ).toDouble();
    distMapUnitScale.minScale = !qgsDoubleNear( oldMin, 0 ) ? 1.0 / oldMin : 0;
    double oldMax = placementElem.attribute( QStringLiteral( "distMapUnitMaxScale" ), QStringLiteral( "0" ) ).toDouble();
    distMapUnitScale.maxScale = !qgsDoubleNear( oldMax, 0 ) ? 1.0 / oldMax : 0;
  }
  else
  {
    distMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( placementElem.attribute( QStringLiteral( "distMapUnitScale" ) ) );
  }
  offsetType = static_cast< Qgis::LabelOffsetType >( placementElem.attribute( QStringLiteral( "offsetType" ), QString::number( static_cast< int >( Qgis::LabelOffsetType::FromPoint ) ) ).toUInt() );
  quadOffset = static_cast< Qgis::LabelQuadrantPosition >( placementElem.attribute( QStringLiteral( "quadOffset" ), QString::number( static_cast< int >( Qgis::LabelQuadrantPosition::Over ) ) ).toUInt() );
  xOffset = placementElem.attribute( QStringLiteral( "xOffset" ), QStringLiteral( "0" ) ).toDouble();
  yOffset = placementElem.attribute( QStringLiteral( "yOffset" ), QStringLiteral( "0" ) ).toDouble();
  if ( !placementElem.hasAttribute( QStringLiteral( "offsetUnits" ) ) )
  {
    offsetUnits = placementElem.attribute( QStringLiteral( "labelOffsetInMapUnits" ), QStringLiteral( "1" ) ).toInt() ? Qgis::RenderUnit::MapUnits : Qgis::RenderUnit::Millimeters;
  }
  else
  {
    offsetUnits = QgsUnitTypes::decodeRenderUnit( placementElem.attribute( QStringLiteral( "offsetUnits" ) ) );
  }
  if ( !placementElem.hasAttribute( QStringLiteral( "labelOffsetMapUnitScale" ) ) )
  {
    //fallback to older property
    double oldMin = placementElem.attribute( QStringLiteral( "labelOffsetMapUnitMinScale" ), QStringLiteral( "0" ) ).toDouble();
    labelOffsetMapUnitScale.minScale = !qgsDoubleNear( oldMin, 0.0 ) ? 1.0 / oldMin : 0;
    double oldMax = placementElem.attribute( QStringLiteral( "labelOffsetMapUnitMaxScale" ), QStringLiteral( "0" ) ).toDouble();
    labelOffsetMapUnitScale.maxScale = !qgsDoubleNear( oldMax, 0.0 ) ? 1.0 / oldMax : 0;
  }
  else
  {
    labelOffsetMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( placementElem.attribute( QStringLiteral( "labelOffsetMapUnitScale" ) ) );
  }
 
  if ( placementElem.hasAttribute( QStringLiteral( "angleOffset" ) ) )
  {
    double oldAngle = placementElem.attribute( QStringLiteral( "angleOffset" ), QStringLiteral( "0" ) ).toDouble();
    angleOffset = std::fmod( 360 - oldAngle, 360.0 );
  }
  else
  {
    angleOffset = placementElem.attribute( QStringLiteral( "rotationAngle" ), QStringLiteral( "0" ) ).toDouble();
  }
 
  preserveRotation = placementElem.attribute( QStringLiteral( "preserveRotation" ), QStringLiteral( "1" ) ).toInt();
  {
    QString rotationUnitString = placementElem.attribute( QStringLiteral( "rotationUnit" ), qgsEnumValueToKey( Qgis::AngleUnit::Degrees ) );
    if ( rotationUnitString.startsWith( QLatin1String( "Angle" ) ) )
    {
      // compatibility with QGIS < 3.30
      rotationUnitString = rotationUnitString.mid( 5 );
    }
 
    mRotationUnit = qgsEnumKeyToValue( rotationUnitString, Qgis::AngleUnit::Degrees );
  }
  maxCurvedCharAngleIn = placementElem.attribute( QStringLiteral( "maxCurvedCharAngleIn" ), QStringLiteral( "25" ) ).toDouble();
  maxCurvedCharAngleOut = placementElem.attribute( QStringLiteral( "maxCurvedCharAngleOut" ), QStringLiteral( "-25" ) ).toDouble();
  priority = placementElem.attribute( QStringLiteral( "priority" ) ).toInt();
  repeatDistance = placementElem.attribute( QStringLiteral( "repeatDistance" ), QStringLiteral( "0" ) ).toDouble();
  if ( !placementElem.hasAttribute( QStringLiteral( "repeatDistanceUnits" ) ) )
  {
    // upgrade old setting
    switch ( placementElem.attribute( QStringLiteral( "repeatDistanceUnit" ), QString::number( 1 ) ).toUInt() )
    {
      case 0:
        repeatDistanceUnit = Qgis::RenderUnit::Points;
        break;
      case 1:
        repeatDistanceUnit = Qgis::RenderUnit::Millimeters;
        break;
      case 2:
        repeatDistanceUnit = Qgis::RenderUnit::MapUnits;
        break;
      case 3:
        repeatDistanceUnit = Qgis::RenderUnit::Percentage;
        break;
    }
  }
  else
  {
    repeatDistanceUnit = QgsUnitTypes::decodeRenderUnit( placementElem.attribute( QStringLiteral( "repeatDistanceUnits" ) ) );
  }
  if ( !placementElem.hasAttribute( QStringLiteral( "repeatDistanceMapUnitScale" ) ) )
  {
    //fallback to older property
    double oldMin = placementElem.attribute( QStringLiteral( "repeatDistanceMapUnitMinScale" ), QStringLiteral( "0" ) ).toDouble();
    repeatDistanceMapUnitScale.minScale = !qgsDoubleNear( oldMin, 0.0 ) ? 1.0 / oldMin : 0;
    double oldMax = placementElem.attribute( QStringLiteral( "repeatDistanceMapUnitMaxScale" ), QStringLiteral( "0" ) ).toDouble();
    repeatDistanceMapUnitScale.maxScale = !qgsDoubleNear( oldMax, 0.0 ) ? 1.0 / oldMax : 0;
  }
  else
  {
    repeatDistanceMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( placementElem.attribute( QStringLiteral( "repeatDistanceMapUnitScale" ) ) );
  }
 
  mLineSettings.setOverrunDistance( placementElem.attribute( QStringLiteral( "overrunDistance" ), QStringLiteral( "0" ) ).toDouble() );
  mLineSettings.setOverrunDistanceUnit( QgsUnitTypes::decodeRenderUnit( placementElem.attribute( QStringLiteral( "overrunDistanceUnit" ) ) ) );
  mLineSettings.setOverrunDistanceMapUnitScale( QgsSymbolLayerUtils::decodeMapUnitScale( placementElem.attribute( QStringLiteral( "overrunDistanceMapUnitScale" ) ) ) );
  mLineSettings.setLineAnchorPercent( placementElem.attribute( QStringLiteral( "lineAnchorPercent" ), QStringLiteral( "0.5" ) ).toDouble() );
  mLineSettings.setAnchorType( static_cast< QgsLabelLineSettings::AnchorType >( placementElem.attribute( QStringLiteral( "lineAnchorType" ), QStringLiteral( "0" ) ).toInt() ) );
  mLineSettings.setAnchorClipping( static_cast< QgsLabelLineSettings::AnchorClipping >( placementElem.attribute( QStringLiteral( "lineAnchorClipping" ), QStringLiteral( "0" ) ).toInt() ) );
  // when reading the anchor text point we default to center mode, to keep same result as for proejcts created in < 3.26
  mLineSettings.setAnchorTextPoint( qgsEnumKeyToValue( placementElem.attribute( QStringLiteral( "lineAnchorTextPoint" ) ), QgsLabelLineSettings::AnchorTextPoint::CenterOfText ) );
 
  geometryGenerator = placementElem.attribute( QStringLiteral( "geometryGenerator" ) );
  geometryGeneratorEnabled = placementElem.attribute( QStringLiteral( "geometryGeneratorEnabled" ) ).toInt();
  {
    QString geometryTypeKey = placementElem.attribute( QStringLiteral( "geometryGeneratorType" ) );
    // maintain compatibility with < 3.3.0
    if ( geometryTypeKey.endsWith( QLatin1String( "Geometry" ) ) )
      geometryTypeKey.chop( 8 );
 
    geometryGeneratorType = qgsEnumKeyToValue( geometryTypeKey, Qgis::GeometryType::Point );
  }
  {
    QString layerTypeKey = placementElem.attribute( QStringLiteral( "layerType" ) );
    // maintain compatibility with < 3.3.0
    if ( layerTypeKey.endsWith( QLatin1String( "Geometry" ) ) )
      layerTypeKey.chop( 8 );
 
    layerType = qgsEnumKeyToValue( layerTypeKey, Qgis::GeometryType::Unknown );
  }
 
  mPlacementSettings.setAllowDegradedPlacement( placementElem.attribute( QStringLiteral( "allowDegraded" ), QStringLiteral( "0" ) ).toInt() );
 
  // rendering
  QDomElement renderingElem = elem.firstChildElement( QStringLiteral( "rendering" ) );
 
  drawLabels = renderingElem.attribute( QStringLiteral( "drawLabels" ), QStringLiteral( "1" ) ).toInt();
 
  maximumScale = renderingElem.attribute( QStringLiteral( "scaleMin" ), QStringLiteral( "0" ) ).toDouble();
  minimumScale = renderingElem.attribute( QStringLiteral( "scaleMax" ), QStringLiteral( "0" ) ).toDouble();
  scaleVisibility = renderingElem.attribute( QStringLiteral( "scaleVisibility" ) ).toInt();
 
  fontLimitPixelSize = renderingElem.attribute( QStringLiteral( "fontLimitPixelSize" ), QStringLiteral( "0" ) ).toInt();
  fontMinPixelSize = renderingElem.attribute( QStringLiteral( "fontMinPixelSize" ), QStringLiteral( "0" ) ).toInt();
  fontMaxPixelSize = renderingElem.attribute( QStringLiteral( "fontMaxPixelSize" ), QStringLiteral( "10000" ) ).toInt();
 
  if ( placementElem.hasAttribute( QStringLiteral( "overlapHandling" ) ) )
  {
    mPlacementSettings.setOverlapHandling( qgsEnumKeyToValue( placementElem.attribute( QStringLiteral( "overlapHandling" ) ), Qgis::LabelOverlapHandling::PreventOverlap ) );
  }
  else
  {
    // legacy setting
    if ( renderingElem.attribute( QStringLiteral( "displayAll" ), QStringLiteral( "0" ) ).toInt() )
    {
      mPlacementSettings.setOverlapHandling( Qgis::LabelOverlapHandling::AllowOverlapIfRequired );
      mPlacementSettings.setAllowDegradedPlacement( true );
    }
    else
    {
      mPlacementSettings.setOverlapHandling( Qgis::LabelOverlapHandling::PreventOverlap );
      mPlacementSettings.setAllowDegradedPlacement( false );
    }
  }
  upsidedownLabels = static_cast< Qgis::UpsideDownLabelHandling >( renderingElem.attribute( QStringLiteral( "upsidedownLabels" ), QString::number( static_cast< int >( Qgis::UpsideDownLabelHandling::FlipUpsideDownLabels ) ) ).toUInt() );
 
  labelPerPart = renderingElem.attribute( QStringLiteral( "labelPerPart" ) ).toInt();
  mLineSettings.setMergeLines( renderingElem.attribute( QStringLiteral( "mergeLines" ) ).toInt() );
  mThinningSettings.setMinimumFeatureSize( renderingElem.attribute( QStringLiteral( "minFeatureSize" ) ).toDouble() );
  mThinningSettings.setLimitNumberLabelsEnabled( renderingElem.attribute( QStringLiteral( "limitNumLabels" ), QStringLiteral( "0" ) ).toInt() );
  mThinningSettings.setMaximumNumberLabels( renderingElem.attribute( QStringLiteral( "maxNumLabels" ), QStringLiteral( "2000" ) ).toInt() );
  mObstacleSettings.setIsObstacle( renderingElem.attribute( QStringLiteral( "obstacle" ), QStringLiteral( "1" ) ).toInt() );
  mObstacleSettings.setFactor( renderingElem.attribute( QStringLiteral( "obstacleFactor" ), QStringLiteral( "1" ) ).toDouble() );
  mObstacleSettings.setType( static_cast< QgsLabelObstacleSettings::ObstacleType >( renderingElem.attribute( QStringLiteral( "obstacleType" ), QString::number( PolygonInterior ) ).toUInt() ) );
  zIndex = renderingElem.attribute( QStringLiteral( "zIndex" ), QStringLiteral( "0.0" ) ).toDouble();
  mUnplacedVisibility = static_cast< Qgis::UnplacedLabelVisibility >( renderingElem.attribute( QStringLiteral( "unplacedVisibility" ), QString::number( static_cast< int >( Qgis::UnplacedLabelVisibility::FollowEngineSetting ) ) ).toInt() );
 
  QDomElement ddElem = elem.firstChildElement( QStringLiteral( "dd_properties" ) );
  if ( !ddElem.isNull() )
  {
    mDataDefinedProperties.readXml( ddElem, *sPropertyDefinitions() );
  }
  else
  {
    // upgrade 2.x style dd project
    mDataDefinedProperties.clear();
    QDomElement ddElem = elem.firstChildElement( QStringLiteral( "data-defined" ) );
    readOldDataDefinedPropertyMap( nullptr, &ddElem );
  }
  // upgrade older data defined settings
  if ( mDataDefinedProperties.isActive( FontTransp ) )
  {
    mDataDefinedProperties.setProperty( FontOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( FontTransp ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( FontTransp, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( BufferTransp ) )
  {
    mDataDefinedProperties.setProperty( BufferOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( BufferTransp ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( BufferTransp, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( ShapeTransparency ) )
  {
    mDataDefinedProperties.setProperty( ShapeOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( ShapeTransparency ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( ShapeTransparency, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( ShadowTransparency ) )
  {
    mDataDefinedProperties.setProperty( ShadowOpacity, QgsProperty::fromExpression( QStringLiteral( "100 - (%1)" ).arg( mDataDefinedProperties.property( ShadowTransparency ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( ShadowTransparency, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( Rotation ) )
  {
    mDataDefinedProperties.setProperty( LabelRotation, QgsProperty::fromExpression( QStringLiteral( "360 - (%1)" ).arg( mDataDefinedProperties.property( Rotation ).asExpression() ) ) );
    mDataDefinedProperties.setProperty( Rotation, QgsProperty() );
  }
  // older 2.x projects had min/max scale flipped - so change them here.
  if ( mDataDefinedProperties.isActive( MinScale ) )
  {
    mDataDefinedProperties.setProperty( MaximumScale, mDataDefinedProperties.property( MinScale ) );
    mDataDefinedProperties.setProperty( MinScale, QgsProperty() );
  }
  if ( mDataDefinedProperties.isActive( MaxScale ) )
  {
    mDataDefinedProperties.setProperty( MinimumScale, mDataDefinedProperties.property( MaxScale ) );
    mDataDefinedProperties.setProperty( MaxScale, QgsProperty() );
  }
 
  // TODO - replace with registry when multiple callout styles exist
  const QString calloutType = elem.attribute( QStringLiteral( "calloutType" ) );
  if ( calloutType.isEmpty() )
    mCallout.reset( QgsCalloutRegistry::defaultCallout() );
  else
  {
    mCallout.reset( QgsApplication::calloutRegistry()->createCallout( calloutType, elem.firstChildElement( QStringLiteral( "callout" ) ), context ) );
    if ( !mCallout )
      mCallout.reset( QgsCalloutRegistry::defaultCallout() );
  }
}
 
QDomElement QgsPalLayerSettings::writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const
{
  QDomElement textStyleElem = mFormat.writeXml( doc, context );
 
  // text style
  textStyleElem.setAttribute( QStringLiteral( "fieldName" ), fieldName );
  textStyleElem.setAttribute( QStringLiteral( "isExpression" ), isExpression );
  QDomElement replacementElem = doc.createElement( QStringLiteral( "substitutions" ) );
  substitutions.writeXml( replacementElem, doc );
  textStyleElem.appendChild( replacementElem );
  textStyleElem.setAttribute( QStringLiteral( "useSubstitutions" ), useSubstitutions );
  textStyleElem.setAttribute( QStringLiteral( "legendString" ), mLegendString );
 
  // text formatting
  QDomElement textFormatElem = doc.createElement( QStringLiteral( "text-format" ) );
  textFormatElem.setAttribute( QStringLiteral( "wrapChar" ), wrapChar );
  textFormatElem.setAttribute( QStringLiteral( "autoWrapLength" ), autoWrapLength );
  textFormatElem.setAttribute( QStringLiteral( "useMaxLineLengthForAutoWrap" ), useMaxLineLengthForAutoWrap );
  textFormatElem.setAttribute( QStringLiteral( "multilineAlign" ), static_cast< unsigned int >( multilineAlign ) );
  textFormatElem.setAttribute( QStringLiteral( "addDirectionSymbol" ), mLineSettings.addDirectionSymbol() );
  textFormatElem.setAttribute( QStringLiteral( "leftDirectionSymbol" ), mLineSettings.leftDirectionSymbol() );
  textFormatElem.setAttribute( QStringLiteral( "rightDirectionSymbol" ), mLineSettings.rightDirectionSymbol() );
  textFormatElem.setAttribute( QStringLiteral( "reverseDirectionSymbol" ), mLineSettings.reverseDirectionSymbol() );
  textFormatElem.setAttribute( QStringLiteral( "placeDirectionSymbol" ), static_cast< unsigned int >( mLineSettings.directionSymbolPlacement() ) );
  textFormatElem.setAttribute( QStringLiteral( "formatNumbers" ), formatNumbers );
  textFormatElem.setAttribute( QStringLiteral( "decimals" ), decimals );
  textFormatElem.setAttribute( QStringLiteral( "plussign" ), plusSign );
 
  // placement
  QDomElement placementElem = doc.createElement( QStringLiteral( "placement" ) );
  placementElem.setAttribute( QStringLiteral( "placement" ), static_cast< int >( placement ) );
  placementElem.setAttribute( QStringLiteral( "polygonPlacementFlags" ), static_cast< int >( mPolygonPlacementFlags ) );
  placementElem.setAttribute( QStringLiteral( "placementFlags" ), static_cast< unsigned int >( mLineSettings.placementFlags() ) );
  placementElem.setAttribute( QStringLiteral( "centroidWhole" ), centroidWhole );
  placementElem.setAttribute( QStringLiteral( "centroidInside" ), centroidInside );
  placementElem.setAttribute( QStringLiteral( "predefinedPositionOrder" ), QgsLabelingUtils::encodePredefinedPositionOrder( predefinedPositionOrder ) );
  placementElem.setAttribute( QStringLiteral( "fitInPolygonOnly" ), fitInPolygonOnly );
  placementElem.setAttribute( QStringLiteral( "dist" ), dist );
  placementElem.setAttribute( QStringLiteral( "distUnits" ), QgsUnitTypes::encodeUnit( distUnits ) );
  placementElem.setAttribute( QStringLiteral( "distMapUnitScale" ), QgsSymbolLayerUtils::encodeMapUnitScale( distMapUnitScale ) );
  placementElem.setAttribute( QStringLiteral( "offsetType" ), static_cast< unsigned int >( offsetType ) );
  placementElem.setAttribute( QStringLiteral( "quadOffset" ), static_cast< unsigned int >( quadOffset ) );
  placementElem.setAttribute( QStringLiteral( "xOffset" ), xOffset );
  placementElem.setAttribute( QStringLiteral( "yOffset" ), yOffset );
  placementElem.setAttribute( QStringLiteral( "offsetUnits" ), QgsUnitTypes::encodeUnit( offsetUnits ) );
  placementElem.setAttribute( QStringLiteral( "labelOffsetMapUnitScale" ), QgsSymbolLayerUtils::encodeMapUnitScale( labelOffsetMapUnitScale ) );
  placementElem.setAttribute( QStringLiteral( "rotationAngle" ), angleOffset );
  placementElem.setAttribute( QStringLiteral( "preserveRotation" ), preserveRotation );
  {
    // append Angle prefix to maintain compatibility with QGIS < 3.30
    const QString rotationUnitString = QStringLiteral( "Angle" ) + qgsEnumValueToKey( mRotationUnit );
    placementElem.setAttribute( QStringLiteral( "rotationUnit" ), rotationUnitString );
  }
  placementElem.setAttribute( QStringLiteral( "maxCurvedCharAngleIn" ), maxCurvedCharAngleIn );
  placementElem.setAttribute( QStringLiteral( "maxCurvedCharAngleOut" ), maxCurvedCharAngleOut );
  placementElem.setAttribute( QStringLiteral( "priority" ), priority );
  placementElem.setAttribute( QStringLiteral( "repeatDistance" ), repeatDistance );
  placementElem.setAttribute( QStringLiteral( "repeatDistanceUnits" ), QgsUnitTypes::encodeUnit( repeatDistanceUnit ) );
  placementElem.setAttribute( QStringLiteral( "repeatDistanceMapUnitScale" ), QgsSymbolLayerUtils::encodeMapUnitScale( repeatDistanceMapUnitScale ) );
  placementElem.setAttribute( QStringLiteral( "overrunDistance" ), mLineSettings.overrunDistance() );
  placementElem.setAttribute( QStringLiteral( "overrunDistanceUnit" ), QgsUnitTypes::encodeUnit( mLineSettings.overrunDistanceUnit() ) );
  placementElem.setAttribute( QStringLiteral( "overrunDistanceMapUnitScale" ), QgsSymbolLayerUtils::encodeMapUnitScale( mLineSettings.overrunDistanceMapUnitScale() ) );
  placementElem.setAttribute( QStringLiteral( "lineAnchorPercent" ), mLineSettings.lineAnchorPercent() );
  placementElem.setAttribute( QStringLiteral( "lineAnchorType" ), static_cast< int >( mLineSettings.anchorType() ) );
  placementElem.setAttribute( QStringLiteral( "lineAnchorClipping" ), static_cast< int >( mLineSettings.anchorClipping() ) );
  placementElem.setAttribute( QStringLiteral( "lineAnchorTextPoint" ), qgsEnumValueToKey( mLineSettings.anchorTextPoint() ) );
 
  placementElem.setAttribute( QStringLiteral( "geometryGenerator" ), geometryGenerator );
  placementElem.setAttribute( QStringLiteral( "geometryGeneratorEnabled" ), geometryGeneratorEnabled );
  placementElem.setAttribute( QStringLiteral( "geometryGeneratorType" ), qgsEnumValueToKey( geometryGeneratorType ) + QStringLiteral( "Geometry" ) );
 
  placementElem.setAttribute( QStringLiteral( "layerType" ), qgsEnumValueToKey( layerType ) + QStringLiteral( "Geometry" ) );
 
  placementElem.setAttribute( QStringLiteral( "overlapHandling" ), qgsEnumValueToKey( mPlacementSettings.overlapHandling() ) );
  placementElem.setAttribute( QStringLiteral( "allowDegraded" ), mPlacementSettings.allowDegradedPlacement() ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
 
  // rendering
  QDomElement renderingElem = doc.createElement( QStringLiteral( "rendering" ) );
  renderingElem.setAttribute( QStringLiteral( "drawLabels" ), drawLabels );
  renderingElem.setAttribute( QStringLiteral( "scaleVisibility" ), scaleVisibility );
  renderingElem.setAttribute( QStringLiteral( "scaleMin" ), maximumScale );
  renderingElem.setAttribute( QStringLiteral( "scaleMax" ), minimumScale );
  renderingElem.setAttribute( QStringLiteral( "fontLimitPixelSize" ), fontLimitPixelSize );
  renderingElem.setAttribute( QStringLiteral( "fontMinPixelSize" ), fontMinPixelSize );
  renderingElem.setAttribute( QStringLiteral( "fontMaxPixelSize" ), fontMaxPixelSize );
  renderingElem.setAttribute( QStringLiteral( "upsidedownLabels" ), static_cast< unsigned int >( upsidedownLabels ) );
 
  renderingElem.setAttribute( QStringLiteral( "labelPerPart" ), labelPerPart );
  renderingElem.setAttribute( QStringLiteral( "mergeLines" ), mLineSettings.mergeLines() );
  renderingElem.setAttribute( QStringLiteral( "minFeatureSize" ), mThinningSettings.minimumFeatureSize() );
  renderingElem.setAttribute( QStringLiteral( "limitNumLabels" ), mThinningSettings.limitNumberOfLabelsEnabled() );
  renderingElem.setAttribute( QStringLiteral( "maxNumLabels" ), mThinningSettings.maximumNumberLabels() );
  renderingElem.setAttribute( QStringLiteral( "obstacle" ), mObstacleSettings.isObstacle() );
  renderingElem.setAttribute( QStringLiteral( "obstacleFactor" ), mObstacleSettings.factor() );
  renderingElem.setAttribute( QStringLiteral( "obstacleType" ), static_cast< unsigned int >( mObstacleSettings.type() ) );
  renderingElem.setAttribute( QStringLiteral( "zIndex" ), zIndex );
  renderingElem.setAttribute( QStringLiteral( "unplacedVisibility" ), static_cast< int >( mUnplacedVisibility ) );
 
  QDomElement ddElem = doc.createElement( QStringLiteral( "dd_properties" ) );
  mDataDefinedProperties.writeXml( ddElem, *sPropertyDefinitions() );
 
  QDomElement elem = doc.createElement( QStringLiteral( "settings" ) );
  elem.appendChild( textStyleElem );
  elem.appendChild( textFormatElem );
  elem.appendChild( placementElem );
  elem.appendChild( renderingElem );
  elem.appendChild( ddElem );
 
  if ( mCallout )
  {
    elem.setAttribute( QStringLiteral( "calloutType" ), mCallout->type() );
    mCallout->saveProperties( doc, elem, context );
  }
 
  return elem;
}
 
void QgsPalLayerSettings::setCallout( QgsCallout *callout )
{
  mCallout.reset( callout );
}
 
QPixmap QgsPalLayerSettings::labelSettingsPreviewPixmap( const QgsPalLayerSettings &settings, QSize size, const QString &previewText, int padding, const QgsScreenProperties &screen )
{
  const double devicePixelRatio = screen.isValid() ? screen.devicePixelRatio() : 1;
 
  // for now, just use format
  QgsTextFormat tempFormat = settings.format();
  QPixmap pixmap( size * devicePixelRatio );
  pixmap.fill( Qt::transparent );
  pixmap.setDevicePixelRatio( devicePixelRatio );
  QPainter painter;
  painter.begin( &pixmap );
 
  painter.setRenderHint( QPainter::Antialiasing );
 
  const QRectF rect( 0, 0, size.width(), size.height() );
 
  // shameless eye candy - use a subtle gradient when drawing background
  painter.setPen( Qt::NoPen );
  QColor background1 = tempFormat.previewBackgroundColor();
  if ( ( background1.lightnessF() < 0.7 ) )
  {
    background1 = background1.darker( 125 );
  }
  else
  {
    background1 = background1.lighter( 125 );
  }
  QColor background2 = tempFormat.previewBackgroundColor();
  QLinearGradient linearGrad( QPointF( 0, 0 ), QPointF( 0, rect.height() ) );
  linearGrad.setColorAt( 0, background1 );
  linearGrad.setColorAt( 1, background2 );
  painter.setBrush( QBrush( linearGrad ) );
  if ( size.width() > 30 )
  {
    painter.drawRoundedRect( rect, 6, 6 );
  }
  else
  {
    // don't use rounded rect for small previews
    painter.drawRect( rect );
  }
  painter.setBrush( Qt::NoBrush );
  painter.setPen( Qt::NoPen );
  padding += 1; // move text away from background border
 
  QgsRenderContext context;
  QgsMapToPixel newCoordXForm;
  newCoordXForm.setParameters( 1, 0, 0, 0, 0, 0 );
  context.setMapToPixel( newCoordXForm );
  context.setFlag( Qgis::RenderContextFlag::Antialiasing, true );
 
  if ( screen.isValid() )
  {
    screen.updateRenderContextForScreen( context );
  }
  else
  {
    QWidget *activeWindow = QApplication::activeWindow();
    if ( QScreen *screen = activeWindow ? activeWindow->screen() : nullptr )
    {
      context.setScaleFactor( screen->physicalDotsPerInch() / 25.4 );
      context.setDevicePixelRatio( screen->devicePixelRatio() );
    }
    else
    {
      context.setScaleFactor( 96.0 / 25.4 );
      context.setDevicePixelRatio( 1.0 );
    }
  }
 
  context.setUseAdvancedEffects( true );
  context.setPainter( &painter );
 
  // slightly inset text to account for buffer/background
  const double fontSize = context.convertToPainterUnits( tempFormat.size(), tempFormat.sizeUnit(), tempFormat.sizeMapUnitScale() );
  double xtrans = 0;
  if ( tempFormat.buffer().enabled() )
    xtrans = tempFormat.buffer().sizeUnit() == Qgis::RenderUnit::Percentage
             ? fontSize * tempFormat.buffer().size() / 100
             : context.convertToPainterUnits( tempFormat.buffer().size(), tempFormat.buffer().sizeUnit(), tempFormat.buffer().sizeMapUnitScale() );
  if ( tempFormat.background().enabled() && tempFormat.background().sizeType() != QgsTextBackgroundSettings::SizeFixed )
    xtrans = std::max( xtrans, context.convertToPainterUnits( tempFormat.background().size().width(), tempFormat.background().sizeUnit(), tempFormat.background().sizeMapUnitScale() ) );
 
  double ytrans = 0.0;
  if ( tempFormat.buffer().enabled() )
    ytrans = std::max( ytrans, tempFormat.buffer().sizeUnit() == Qgis::RenderUnit::Percentage
                       ? fontSize * tempFormat.buffer().size() / 100
                       : context.convertToPainterUnits( tempFormat.buffer().size(), tempFormat.buffer().sizeUnit(), tempFormat.buffer().sizeMapUnitScale() ) );
  if ( tempFormat.background().enabled() )
    ytrans = std::max( ytrans, context.convertToPainterUnits( tempFormat.background().size().height(), tempFormat.background().sizeUnit(), tempFormat.background().sizeMapUnitScale() ) );
 
  const QStringList text = QStringList() << ( previewText.isEmpty() ? settings.legendString() : previewText );
  const double textHeight = QgsTextRenderer::textHeight( context, tempFormat, text, Qgis::TextLayoutMode::Rectangle );
  QRectF textRect = rect;
  textRect.setLeft( xtrans + padding );
  textRect.setWidth( rect.width() - xtrans - 2 * padding );
 
  if ( textRect.width() > 2000 )
    textRect.setWidth( 2000 - 2 * padding );
 
  const double bottom = textRect.height() / 2 + textHeight / 2;
  textRect.setTop( bottom - textHeight );
  textRect.setBottom( bottom );
 
  const double iconWidth = QFontMetricsF( QFont() ).horizontalAdvance( 'X' ) * Qgis::UI_SCALE_FACTOR;
 
  if ( settings.callout() && settings.callout()->enabled() )
  {
    // draw callout preview
    const double textWidth = QgsTextRenderer::textWidth( context, tempFormat, text );
    QgsCallout *callout = settings.callout();
    callout->startRender( context );
    QgsCallout::QgsCalloutContext calloutContext;
    QRectF labelRect( textRect.left() + ( textRect.width() - textWidth ) / 2.0, textRect.top(), textWidth, textRect.height() );
    callout->render( context, labelRect, 0, QgsGeometry::fromPointXY( QgsPointXY( labelRect.left() - iconWidth * 1.5, labelRect.bottom() + iconWidth ) ), calloutContext );
    callout->stopRender( context );
  }
 
  QgsTextRenderer::drawText( textRect, 0, Qgis::TextHorizontalAlignment::Center, text, context, tempFormat );
 
  if ( size.width() > 30 )
  {
    // draw a label icon
 
    QgsApplication::getThemeIcon( QStringLiteral( "labelingSingle.svg" ) ).paint( &painter, QRect(
          rect.width() - iconWidth * 3, rect.height() - iconWidth * 3,
          iconWidth * 2, iconWidth * 2 ), Qt::AlignRight | Qt::AlignBottom );
  }
 
  // draw border on top of text
  painter.setBrush( Qt::NoBrush );
  painter.setPen( QPen( tempFormat.previewBackgroundColor().darker( 150 ), 0 ) );
  if ( size.width() > 30 )
  {
    painter.drawRoundedRect( rect, 6, 6 );
  }
  else
  {
    // don't use rounded rect for small previews
    painter.drawRect( rect );
  }
 
  painter.end();
  return pixmap;
}
 
Qgis::UnplacedLabelVisibility QgsPalLayerSettings::unplacedVisibility() const
{
  return mUnplacedVisibility;
}
 
void QgsPalLayerSettings::setUnplacedVisibility( Qgis::UnplacedLabelVisibility visibility )
{
  mUnplacedVisibility = visibility;
}
 
bool QgsPalLayerSettings::checkMinimumSizeMM( const QgsRenderContext &ct, const QgsGeometry &geom, double minSize ) const
{
  return QgsPalLabeling::checkMinimumSizeMM( ct, geom, minSize );
}
 
void QgsPalLayerSettings::calculateLabelSize( const QFontMetricsF *fm, const QString &text, double &labelX, double &labelY, const QgsFeature *f, QgsRenderContext *context, double *rotatedLabelX, double *rotatedLabelY, QgsTextDocument *document, QgsTextDocumentMetrics *documentMetrics, QRectF *outerBounds )
{
  if ( !fm || !f )
  {
    return;
  }
 
  QString textCopy( text );
 
  //try to keep < 2.12 API - handle no passed render context
  std::unique_ptr< QgsRenderContext > scopedRc;
  if ( !context )
  {
    scopedRc.reset( new QgsRenderContext() );
    if ( f )
      scopedRc->expressionContext().setFeature( *f );
  }
  QgsRenderContext *rc = context ? context : scopedRc.get();
 
  QString wrapchr = wrapChar;
  int evalAutoWrapLength = autoWrapLength;
  double multilineH = mFormat.lineHeight();
  Qgis::TextOrientation orientation = mFormat.orientation();
 
  bool addDirSymb = mLineSettings.addDirectionSymbol();
  QString leftDirSymb = mLineSettings.leftDirectionSymbol();
  QString rightDirSymb = mLineSettings.rightDirectionSymbol();
  QgsLabelLineSettings::DirectionSymbolPlacement placeDirSymb = mLineSettings.directionSymbolPlacement();
 
  if ( f == mCurFeat ) // called internally, use any stored data defined values
  {
    if ( dataDefinedValues.contains( QgsPalLayerSettings::MultiLineWrapChar ) )
    {
      wrapchr = dataDefinedValues.value( QgsPalLayerSettings::MultiLineWrapChar ).toString();
    }
 
    if ( dataDefinedValues.contains( QgsPalLayerSettings::AutoWrapLength ) )
    {
      evalAutoWrapLength = dataDefinedValues.value( QgsPalLayerSettings::AutoWrapLength, evalAutoWrapLength ).toInt();
    }
 
    if ( dataDefinedValues.contains( QgsPalLayerSettings::MultiLineHeight ) )
    {
      multilineH = dataDefinedValues.value( QgsPalLayerSettings::MultiLineHeight ).toDouble();
    }
 
    if ( dataDefinedValues.contains( QgsPalLayerSettings::TextOrientation ) )
    {
      orientation = QgsTextRendererUtils::decodeTextOrientation( dataDefinedValues.value( QgsPalLayerSettings::TextOrientation ).toString() );
    }
 
    if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbDraw ) )
    {
      addDirSymb = dataDefinedValues.value( QgsPalLayerSettings::DirSymbDraw ).toBool();
    }
 
    if ( addDirSymb )
    {
 
      if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbLeft ) )
      {
        leftDirSymb = dataDefinedValues.value( QgsPalLayerSettings::DirSymbLeft ).toString();
      }
      if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbRight ) )
      {
        rightDirSymb = dataDefinedValues.value( QgsPalLayerSettings::DirSymbRight ).toString();
      }
 
      if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbPlacement ) )
      {
        placeDirSymb = static_cast< QgsLabelLineSettings::DirectionSymbolPlacement >( dataDefinedValues.value( QgsPalLayerSettings::DirSymbPlacement ).toInt() );
      }
 
    }
 
  }
  else // called externally with passed-in feature, evaluate data defined
  {
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::MultiLineWrapChar ) )
    {
      rc->expressionContext().setOriginalValueVariable( wrapChar );
      wrapchr = mDataDefinedProperties.value( QgsPalLayerSettings::MultiLineWrapChar, rc->expressionContext(), wrapchr ).toString();
    }
 
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::AutoWrapLength ) )
    {
      rc->expressionContext().setOriginalValueVariable( evalAutoWrapLength );
      evalAutoWrapLength = mDataDefinedProperties.value( QgsPalLayerSettings::AutoWrapLength, rc->expressionContext(), evalAutoWrapLength ).toInt();
    }
 
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::MultiLineHeight ) )
    {
      rc->expressionContext().setOriginalValueVariable( multilineH );
      multilineH = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::MultiLineHeight, rc->expressionContext(), multilineH );
    }
 
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::TextOrientation ) )
    {
      QString encoded = QgsTextRendererUtils::encodeTextOrientation( orientation );
      rc->expressionContext().setOriginalValueVariable( encoded );
      orientation = QgsTextRendererUtils::decodeTextOrientation( mDataDefinedProperties.valueAsString( QgsPalLayerSettings::TextOrientation, rc->expressionContext(), encoded ) );
    }
 
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::DirSymbDraw ) )
    {
      rc->expressionContext().setOriginalValueVariable( addDirSymb );
      addDirSymb = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::DirSymbDraw, rc->expressionContext(), addDirSymb );
    }
 
    if ( addDirSymb ) // don't do extra evaluations if not adding a direction symbol
    {
      if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::DirSymbLeft ) )
      {
        rc->expressionContext().setOriginalValueVariable( leftDirSymb );
        leftDirSymb = mDataDefinedProperties.value( QgsPalLayerSettings::DirSymbLeft, rc->expressionContext(), leftDirSymb ).toString();
      }
 
      if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::DirSymbRight ) )
      {
        rc->expressionContext().setOriginalValueVariable( rightDirSymb );
        rightDirSymb = mDataDefinedProperties.value( QgsPalLayerSettings::DirSymbRight, rc->expressionContext(), rightDirSymb ).toString();
      }
 
      if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::DirSymbPlacement ) )
      {
        rc->expressionContext().setOriginalValueVariable( static_cast< int >( placeDirSymb ) );
        placeDirSymb = static_cast< QgsLabelLineSettings::DirectionSymbolPlacement >( mDataDefinedProperties.valueAsInt( QgsPalLayerSettings::DirSymbPlacement, rc->expressionContext(), static_cast< int >( placeDirSymb ) ) );
      }
    }
  }
 
  if ( wrapchr.isEmpty() )
  {
    wrapchr = QStringLiteral( "\n" ); // default to new line delimiter
  }
 
  //consider the space needed for the direction symbol
  if ( addDirSymb && placement == Qgis::LabelPlacement::Line
       && ( !leftDirSymb.isEmpty() || !rightDirSymb.isEmpty() ) )
  {
    QString dirSym = leftDirSymb;
 
    if ( fm->horizontalAdvance( rightDirSymb ) > fm->horizontalAdvance( dirSym ) )
      dirSym = rightDirSymb;
 
    switch ( placeDirSymb )
    {
      case QgsLabelLineSettings::DirectionSymbolPlacement::SymbolLeftRight:
        textCopy.append( dirSym );
        break;
 
      case QgsLabelLineSettings::DirectionSymbolPlacement::SymbolAbove:
      case QgsLabelLineSettings::DirectionSymbolPlacement::SymbolBelow:
        textCopy.prepend( dirSym + QStringLiteral( "\n" ) );
        break;
    }
  }
 
  double w = 0.0, h = 0.0, rw = 0.0, rh = 0.0;
  double labelHeight = fm->ascent() + fm->descent(); // ignore +1 for baseline
 
  if ( document )
  {
    document->splitLines( wrapchr, evalAutoWrapLength, useMaxLineLengthForAutoWrap );
 
    *documentMetrics = QgsTextDocumentMetrics::calculateMetrics( *document, mFormat, *rc );
    const QSizeF size = documentMetrics->documentSize( Qgis::TextLayoutMode::Labeling, orientation );
    w = size.width();
    h = size.height();
  }
  else
  {
    const QStringList multiLineSplit = QgsPalLabeling::splitToLines( textCopy, wrapchr, evalAutoWrapLength, useMaxLineLengthForAutoWrap );
    const int lines = multiLineSplit.size();
 
    const double lineHeightPainterUnits = rc->convertToPainterUnits( mFormat.lineHeight(), mFormat.lineHeightUnit() );
 
    switch ( orientation )
    {
      case Qgis::TextOrientation::Horizontal:
      {
        h += fm->height() + static_cast< double >( ( lines - 1 ) * ( mFormat.lineHeightUnit() == Qgis::RenderUnit::Percentage ? ( labelHeight * multilineH ) : lineHeightPainterUnits ) );
 
        for ( const QString &line : std::as_const( multiLineSplit ) )
        {
          w = std::max( w, fm->horizontalAdvance( line ) );
        }
        break;
      }
 
      case Qgis::TextOrientation::Vertical:
      {
        double letterSpacing = mFormat.scaledFont( *context ).letterSpacing();
        double labelWidth = fm->maxWidth();
        w = labelWidth + ( lines - 1 ) * ( mFormat.lineHeightUnit() == Qgis::RenderUnit::Percentage ? ( labelWidth * multilineH ) : lineHeightPainterUnits );
 
        int maxLineLength = 0;
        for ( const QString &line : std::as_const( multiLineSplit ) )
        {
          maxLineLength = std::max( maxLineLength, static_cast<int>( line.length() ) );
        }
        h = fm->ascent() * maxLineLength + ( maxLineLength - 1 ) * letterSpacing;
        break;
      }
 
      case Qgis::TextOrientation::RotationBased:
      {
        double widthHorizontal = 0.0;
        for ( const QString &line : std::as_const( multiLineSplit ) )
        {
          widthHorizontal = std::max( w, fm->horizontalAdvance( line ) );
        }
 
        double widthVertical = 0.0;
        double letterSpacing = mFormat.scaledFont( *context ).letterSpacing();
        double labelWidth = fm->maxWidth();
        widthVertical = labelWidth + ( lines - 1 ) * ( mFormat.lineHeightUnit() == Qgis::RenderUnit::Percentage ? ( labelWidth * multilineH ) : lineHeightPainterUnits );
 
        double heightHorizontal = 0.0;
        heightHorizontal += fm->height() + static_cast< double >( ( lines - 1 ) * ( mFormat.lineHeightUnit() == Qgis::RenderUnit::Percentage ? ( labelHeight * multilineH ) : lineHeightPainterUnits ) );
 
        double heightVertical = 0.0;
        int maxLineLength = 0;
        for ( const QString &line : std::as_const( multiLineSplit ) )
        {
          maxLineLength = std::max( maxLineLength, static_cast<int>( line.length() ) );
        }
        heightVertical = fm->ascent() * maxLineLength + ( maxLineLength - 1 ) * letterSpacing;
 
        w = widthHorizontal;
        rw = heightVertical;
        h = heightHorizontal;
        rh = widthVertical;
        break;
      }
    }
  }
 
#if 0 // XXX strk
  QgsPointXY ptSize = xform->toMapCoordinatesF( w, h );
  labelX = std::fabs( ptSize.x() - ptZero.x() );
  labelY = std::fabs( ptSize.y() - ptZero.y() );
#else
  double uPP = xform->mapUnitsPerPixel();
  labelX = w * uPP;
  labelY = h * uPP;
  if ( rotatedLabelX && rotatedLabelY )
  {
    *rotatedLabelX = rw * uPP;
    *rotatedLabelY = rh * uPP;
  }
#endif
 
  if ( outerBounds && documentMetrics )
  {
    const QRectF outerBoundsPixels = documentMetrics->outerBounds( Qgis::TextLayoutMode::Labeling, orientation );
 
    *outerBounds = QRectF( outerBoundsPixels.left() * uPP,
                           outerBoundsPixels.top() * uPP,
                           outerBoundsPixels.width() * uPP,
                           outerBoundsPixels.height() * uPP );
  }
}
 
void QgsPalLayerSettings::registerFeature( const QgsFeature &f, QgsRenderContext &context )
{
  registerFeatureWithDetails( f, context, QgsGeometry(), nullptr );
}
 
std::unique_ptr<QgsLabelFeature> QgsPalLayerSettings::registerFeatureWithDetails( const QgsFeature &f, QgsRenderContext &context, QgsGeometry obstacleGeometry, const QgsSymbol *symbol )
{
  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
  mCurFeat = &f;
 
  // data defined is obstacle? calculate this first, to avoid wasting time working with obstacles we don't require
  bool isObstacle = mObstacleSettings.isObstacle();
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::IsObstacle ) )
    isObstacle = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::IsObstacle, context.expressionContext(), isObstacle ); // default to layer default
 
  if ( !drawLabels )
  {
    if ( isObstacle )
    {
      return registerObstacleFeature( f, context, obstacleGeometry );
    }
    else
    {
      return nullptr;
    }
  }
 
  QgsFeature feature = f;
  if ( geometryGeneratorEnabled )
  {
    const QgsGeometry geometry = mGeometryGeneratorExpression.evaluate( &context.expressionContext() ).value<QgsGeometry>();
    if ( mGeometryGeneratorExpression.hasEvalError() )
      QgsMessageLog::logMessage( mGeometryGeneratorExpression.evalErrorString(), QObject::tr( "Labeling" ) );
 
    if ( obstacleGeometry.isNull() )
    {
      // if an explicit obstacle geometry hasn't been set, we must always use the original feature geometry
      // as the obstacle -- because we want to use the geometry which was used to render the symbology
      // for the feature as the obstacle for other layers' labels, NOT the generated geometry which is used
      // only to place labels for this layer.
      obstacleGeometry = f.geometry();
    }
 
    feature.setGeometry( geometry );
  }
 
  // store data defined-derived values for later adding to label feature for use during rendering
  dataDefinedValues.clear();
 
  // data defined show label? defaults to show label if not set
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Show ) )
  {
    context.expressionContext().setOriginalValueVariable( true );
    if ( !mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::Show, context.expressionContext(), true ) )
    {
      return nullptr;
    }
  }
 
  // data defined scale visibility?
  bool useScaleVisibility = scaleVisibility;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::ScaleVisibility ) )
    useScaleVisibility = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::ScaleVisibility, context.expressionContext(), scaleVisibility );
 
  if ( useScaleVisibility )
  {
    // data defined min scale?
    double maxScale = maximumScale;
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::MaximumScale ) )
    {
      context.expressionContext().setOriginalValueVariable( maximumScale );
      maxScale = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::MaximumScale, context.expressionContext(), maxScale );
    }
 
    // scales closer than 1:1
    if ( maxScale < 0 )
    {
      maxScale = 1 / std::fabs( maxScale );
    }
 
    if ( !qgsDoubleNear( maxScale, 0.0 ) && context.rendererScale() < maxScale )
    {
      return nullptr;
    }
 
    // data defined min scale?
    double minScale = minimumScale;
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::MinimumScale ) )
    {
      context.expressionContext().setOriginalValueVariable( minimumScale );
      minScale = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::MinimumScale, context.expressionContext(), minScale );
    }
 
    // scales closer than 1:1
    if ( minScale < 0 )
    {
      minScale = 1 / std::fabs( minScale );
    }
 
    if ( !qgsDoubleNear( minScale, 0.0 ) && context.rendererScale() > minScale )
    {
      return nullptr;
    }
  }
 
  QFont labelFont = mFormat.font();
  // labelFont will be added to label feature for use during label painting
 
  // data defined font units?
  Qgis::RenderUnit fontunits = mFormat.sizeUnit();
  exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::FontSizeUnit, context.expressionContext() );
  if ( !QgsVariantUtils::isNull( exprVal ) )
  {
    QString units = exprVal.toString();
    if ( !units.isEmpty() )
    {
      bool ok;
      Qgis::RenderUnit res = QgsUnitTypes::decodeRenderUnit( units, &ok );
      if ( ok )
        fontunits = res;
    }
  }
 
  //data defined label size?
  double fontSize = mFormat.size();
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Size ) )
  {
    context.expressionContext().setOriginalValueVariable( fontSize );
    fontSize = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::Size, context.expressionContext(), fontSize );
  }
  if ( fontSize <= 0.0 )
  {
    return nullptr;
  }
 
  int fontPixelSize = QgsTextRenderer::sizeToPixel( fontSize, context, fontunits, mFormat.sizeMapUnitScale() );
  // don't try to show font sizes less than 1 pixel (Qt complains)
  if ( fontPixelSize < 1 )
  {
    return nullptr;
  }
  labelFont.setPixelSize( fontPixelSize );
 
  // NOTE: labelFont now always has pixelSize set, so pointSize or pointSizeF might return -1
 
  // defined 'minimum/maximum pixel font size'?
  if ( fontunits == Qgis::RenderUnit::MapUnits )
  {
    if ( mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::FontLimitPixel, context.expressionContext(), fontLimitPixelSize ) )
    {
      int fontMinPixel = mDataDefinedProperties.valueAsInt( QgsPalLayerSettings::FontMinPixel, context.expressionContext(), fontMinPixelSize );
      int fontMaxPixel = mDataDefinedProperties.valueAsInt( QgsPalLayerSettings::FontMaxPixel, context.expressionContext(), fontMaxPixelSize );
 
      if ( fontMinPixel > labelFont.pixelSize() || labelFont.pixelSize() > fontMaxPixel )
      {
        return nullptr;
      }
    }
  }
 
  // NOTE: the following parsing functions calculate and store any data defined values for later use in QgsPalLabeling::drawLabeling
  // this is done to provide clarity, and because such parsing is not directly related to PAL feature registration calculations
 
  // calculate rest of font attributes and store any data defined values
  // this is done here for later use in making label backgrounds part of collision management (when implemented)
  labelFont.setCapitalization( QFont::MixedCase ); // reset this - we don't use QFont's handling as it breaks with curved labels
 
  parseTextStyle( labelFont, fontunits, context );
  if ( mDataDefinedProperties.hasActiveProperties() )
  {
    parseTextFormatting( context );
    parseTextBuffer( context );
    parseTextMask( context );
    parseShapeBackground( context );
    parseDropShadow( context );
  }
 
  QString labelText;
 
  // Check to see if we are a expression string.
  if ( isExpression )
  {
    QgsExpression *exp = getLabelExpression();
    if ( exp->hasParserError() )
    {
      QgsDebugMsgLevel( QStringLiteral( "Expression parser error:%1" ).arg( exp->parserErrorString() ), 4 );
      return nullptr;
    }
 
    QVariant result = exp->evaluate( &context.expressionContext() ); // expression prepared in QgsPalLabeling::prepareLayer()
    if ( exp->hasEvalError() )
    {
      QgsDebugMsgLevel( QStringLiteral( "Expression parser eval error:%1" ).arg( exp->evalErrorString() ), 4 );
      return nullptr;
    }
    labelText = QgsVariantUtils::isNull( result ) ? QString() : result.toString();
  }
  else
  {
    const QVariant &v = feature.attribute( fieldIndex );
    labelText = QgsVariantUtils::isNull( v ) ? QString() : v.toString();
  }
 
  // apply text replacements
  if ( useSubstitutions )
  {
    labelText = substitutions.process( labelText );
  }
 
  // apply capitalization
  Qgis::Capitalization capitalization = mFormat.capitalization();
  // maintain API - capitalization may have been set in textFont
  if ( capitalization == Qgis::Capitalization::MixedCase && mFormat.font().capitalization() != QFont::MixedCase )
  {
    capitalization = static_cast< Qgis::Capitalization >( mFormat.font().capitalization() );
  }
  // data defined font capitalization?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::FontCase ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::FontCase, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString fcase = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal FontCase:%1" ).arg( fcase ), 4 );
 
      if ( !fcase.isEmpty() )
      {
        if ( fcase.compare( QLatin1String( "NoChange" ), Qt::CaseInsensitive ) == 0 )
        {
          capitalization = Qgis::Capitalization::MixedCase;
        }
        else if ( fcase.compare( QLatin1String( "Upper" ), Qt::CaseInsensitive ) == 0 )
        {
          capitalization = Qgis::Capitalization::AllUppercase;
        }
        else if ( fcase.compare( QLatin1String( "Lower" ), Qt::CaseInsensitive ) == 0 )
        {
          capitalization = Qgis::Capitalization::AllLowercase;
        }
        else if ( fcase.compare( QLatin1String( "Capitalize" ), Qt::CaseInsensitive ) == 0 )
        {
          capitalization = Qgis::Capitalization::ForceFirstLetterToCapital;
        }
        else if ( fcase.compare( QLatin1String( "Title" ), Qt::CaseInsensitive ) == 0 )
        {
          capitalization = Qgis::Capitalization::TitleCase;
        }
#if defined(HAS_KDE_QT5_SMALL_CAPS_FIX) || QT_VERSION >= QT_VERSION_CHECK(6, 3, 0)
        else if ( fcase.compare( QLatin1String( "SmallCaps" ), Qt::CaseInsensitive ) == 0 )
        {
          capitalization = Qgis::Capitalization::SmallCaps;
        }
        else if ( fcase.compare( QLatin1String( "AllSmallCaps" ), Qt::CaseInsensitive ) == 0 )
        {
          capitalization = Qgis::Capitalization::AllSmallCaps;
        }
#endif
      }
    }
  }
  labelText = QgsStringUtils::capitalize( labelText, capitalization );
 
  // format number if label text is coercible to a number
  bool evalFormatNumbers = formatNumbers;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::NumFormat ) )
  {
    evalFormatNumbers = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::NumFormat, context.expressionContext(), evalFormatNumbers );
  }
  if ( evalFormatNumbers )
  {
    // data defined decimal places?
    int decimalPlaces = mDataDefinedProperties.valueAsInt( QgsPalLayerSettings::NumDecimals, context.expressionContext(), decimals );
    if ( decimalPlaces <= 0 ) // needs to be positive
      decimalPlaces = decimals;
 
    // data defined plus sign?
    bool signPlus = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::NumPlusSign, context.expressionContext(), plusSign );
 
    QVariant textV( labelText );
    bool ok;
    double d = textV.toDouble( &ok );
    if ( ok )
    {
      QString numberFormat;
      if ( d > 0 && signPlus )
      {
        numberFormat.append( '+' );
      }
      numberFormat.append( "%1" );
      labelText = numberFormat.arg( QLocale().toString( d, 'f', decimalPlaces ) );
    }
  }
 
  // NOTE: this should come AFTER any option that affects font metrics
  std::unique_ptr<QFontMetricsF> labelFontMetrics( new QFontMetricsF( labelFont ) );
  double labelWidth;
  double labelHeight;
  double rotatedLabelX;
  double rotatedLabelY;
 
  QgsTextDocument doc;
  QgsTextDocumentMetrics documentMetrics;
  QRectF outerBounds;
  if ( format().allowHtmlFormatting() && !labelText.isEmpty() )
  {
    doc = QgsTextDocument::fromHtml( QStringList() << labelText );
    // also applies the line split to doc and calculates document metrics!
    calculateLabelSize( labelFontMetrics.get(), labelText, labelWidth, labelHeight, mCurFeat, &context, &rotatedLabelX, &rotatedLabelY, &doc, &documentMetrics, &outerBounds );
  }
  else
  {
    calculateLabelSize( labelFontMetrics.get(), labelText, labelWidth, labelHeight, mCurFeat, &context, &rotatedLabelX, &rotatedLabelY, nullptr, nullptr, &outerBounds );
  }
 
  // maximum angle between curved label characters (hardcoded defaults used in QGIS <2.0)
  //
  double maxcharanglein = 20.0; // range 20.0-60.0
  double maxcharangleout = -20.0; // range 20.0-95.0
 
  switch ( placement )
  {
    case Qgis::LabelPlacement::PerimeterCurved:
    case Qgis::LabelPlacement::Curved:
    {
      maxcharanglein = maxCurvedCharAngleIn;
      maxcharangleout = maxCurvedCharAngleOut;
 
      //data defined maximum angle between curved label characters?
      if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::CurvedCharAngleInOut ) )
      {
        exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::CurvedCharAngleInOut, context.expressionContext() );
        bool ok = false;
        const QPointF maxcharanglePt = QgsSymbolLayerUtils::toPoint( exprVal, &ok );
        if ( ok )
        {
          maxcharanglein = std::clamp( static_cast< double >( maxcharanglePt.x() ), 20.0, 60.0 );
          maxcharangleout = std::clamp( static_cast< double >( maxcharanglePt.y() ), 20.0, 95.0 );
        }
      }
      // make sure maxcharangleout is always negative
      maxcharangleout = -( std::fabs( maxcharangleout ) );
      break;
    }
 
    case Qgis::LabelPlacement::AroundPoint:
    case Qgis::LabelPlacement::OverPoint:
    case Qgis::LabelPlacement::Line:
    case Qgis::LabelPlacement::Horizontal:
    case Qgis::LabelPlacement::Free:
    case Qgis::LabelPlacement::OrderedPositionsAroundPoint:
    case Qgis::LabelPlacement::OutsidePolygons:
      break;
  }
 
  // data defined centroid whole or clipped?
  bool wholeCentroid = centroidWhole;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::CentroidWhole ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::CentroidWhole, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString str = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal CentroidWhole:%1" ).arg( str ), 4 );
 
      if ( !str.isEmpty() )
      {
        if ( str.compare( QLatin1String( "Visible" ), Qt::CaseInsensitive ) == 0 )
        {
          wholeCentroid = false;
        }
        else if ( str.compare( QLatin1String( "Whole" ), Qt::CaseInsensitive ) == 0 )
        {
          wholeCentroid = true;
        }
      }
    }
  }
 
  QgsGeometry geom = feature.geometry();
  if ( geom.isNull() )
  {
    return nullptr;
  }
 
  // simplify?
  const QgsVectorSimplifyMethod &simplifyMethod = context.vectorSimplifyMethod();
  std::unique_ptr<QgsGeometry> scopedClonedGeom;
  if ( simplifyMethod.simplifyHints() != QgsVectorSimplifyMethod::NoSimplification && simplifyMethod.forceLocalOptimization() )
  {
    unsigned int simplifyHints = simplifyMethod.simplifyHints() | QgsMapToPixelSimplifier::SimplifyEnvelope;
    QgsMapToPixelSimplifier::SimplifyAlgorithm simplifyAlgorithm = static_cast< QgsMapToPixelSimplifier::SimplifyAlgorithm >( simplifyMethod.simplifyAlgorithm() );
    QgsMapToPixelSimplifier simplifier( simplifyHints, simplifyMethod.tolerance(), simplifyAlgorithm );
    geom = simplifier.simplify( geom );
  }
 
  if ( !context.featureClipGeometry().isEmpty() )
  {
    const Qgis::GeometryType expectedType = geom.type();
    geom = geom.intersection( context.featureClipGeometry() );
    geom.convertGeometryCollectionToSubclass( expectedType );
  }
 
  // whether we're going to create a centroid for polygon
  bool centroidPoly = ( ( placement == Qgis::LabelPlacement::AroundPoint
                          || placement == Qgis::LabelPlacement::OverPoint )
                        && geom.type() == Qgis::GeometryType::Polygon );
 
  // CLIP the geometry if it is bigger than the extent
  // don't clip if centroid is requested for whole feature
  bool doClip = false;
  if ( !centroidPoly || !wholeCentroid )
  {
    doClip = true;
  }
 
 
  Qgis::LabelPolygonPlacementFlags polygonPlacement = mPolygonPlacementFlags;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::PolygonLabelOutside ) )
  {
    const QVariant dataDefinedOutside = mDataDefinedProperties.value( QgsPalLayerSettings::PolygonLabelOutside, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( dataDefinedOutside ) )
    {
      if ( dataDefinedOutside.type() == QVariant::String )
      {
        const QString value = dataDefinedOutside.toString().trimmed();
        if ( value.compare( QLatin1String( "force" ), Qt::CaseInsensitive ) == 0 )
        {
          // forced outside placement -- remove inside flag, add outside flag
          polygonPlacement &= ~static_cast< int >( Qgis::LabelPolygonPlacementFlag::AllowPlacementInsideOfPolygon );
          polygonPlacement |= Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon;
        }
        else if ( value.compare( QLatin1String( "yes" ), Qt::CaseInsensitive ) == 0 )
        {
          // permit outside placement
          polygonPlacement |= Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon;
        }
        else if ( value.compare( QLatin1String( "no" ), Qt::CaseInsensitive ) == 0 )
        {
          // block outside placement
          polygonPlacement &= ~static_cast< int >( Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon );
        }
      }
      else
      {
        if ( dataDefinedOutside.toBool() )
        {
          // permit outside placement
          polygonPlacement |= Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon;
        }
        else
        {
          // block outside placement
          polygonPlacement &= ~static_cast< int >( Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon );
        }
      }
    }
  }
 
  QgsLabelLineSettings lineSettings = mLineSettings;
  lineSettings.updateDataDefinedProperties( mDataDefinedProperties, context.expressionContext() );
 
  if ( geom.type() == Qgis::GeometryType::Line || placement == Qgis::LabelPlacement::Line || placement == Qgis::LabelPlacement::PerimeterCurved )
  {
    switch ( lineSettings.anchorClipping() )
    {
      case QgsLabelLineSettings::AnchorClipping::UseVisiblePartsOfLine:
        break;
 
      case QgsLabelLineSettings::AnchorClipping::UseEntireLine:
        doClip = false;
        break;
    }
  }
 
  // if using fitInPolygonOnly option, generate the permissible zone (must happen before geometry is modified - e.g.,
  // as a result of using perimeter based labeling and the geometry is converted to a boundary)
  // note that we also force this if we are permitting labels to be placed outside of polygons too!
  QgsGeometry permissibleZone;
  if ( geom.type() == Qgis::GeometryType::Polygon && ( fitInPolygonOnly || polygonPlacement & Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon ) )
  {
    permissibleZone = geom;
    if ( QgsPalLabeling::geometryRequiresPreparation( permissibleZone, context, ct, doClip ? extentGeom : QgsGeometry(), lineSettings.mergeLines() ) )
    {
      permissibleZone = QgsPalLabeling::prepareGeometry( permissibleZone, context, ct, doClip ? extentGeom : QgsGeometry(), lineSettings.mergeLines() );
    }
  }
 
  // if using perimeter based labeling for polygons, get the polygon's
  // linear boundary and use that for the label geometry
  if ( ( geom.type() == Qgis::GeometryType::Polygon )
       && ( placement == Qgis::LabelPlacement::Line || placement == Qgis::LabelPlacement::PerimeterCurved ) )
  {
    geom = QgsGeometry( geom.constGet()->boundary() );
  }
 
  geos::unique_ptr geos_geom_clone;
  if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, ct, doClip ? extentGeom : QgsGeometry(), lineSettings.mergeLines() ) )
  {
    geom = QgsPalLabeling::prepareGeometry( geom, context, ct, doClip ? extentGeom : QgsGeometry(), lineSettings.mergeLines() );
 
    if ( geom.isEmpty() )
      return nullptr;
  }
  geos_geom_clone = QgsGeos::asGeos( geom );
 
  if ( isObstacle || ( geom.type() == Qgis::GeometryType::Point && offsetType == Qgis::LabelOffsetType::FromSymbolBounds ) )
  {
    if ( !obstacleGeometry.isNull() && QgsPalLabeling::geometryRequiresPreparation( obstacleGeometry, context, ct, doClip ? extentGeom : QgsGeometry(), lineSettings.mergeLines() ) )
    {
      obstacleGeometry = QgsGeometry( QgsPalLabeling::prepareGeometry( obstacleGeometry, context, ct, doClip ? extentGeom : QgsGeometry(), lineSettings.mergeLines() ) );
    }
  }
 
  QgsLabelThinningSettings featureThinningSettings = mThinningSettings;
  featureThinningSettings.updateDataDefinedProperties( mDataDefinedProperties, context.expressionContext() );
 
  double minimumSize = 0.0;
  if ( featureThinningSettings.minimumFeatureSize() > 0 )
  {
    // for minimum feature size on merged lines, we need to delay the filtering after the merging occurred in PAL
    if ( geom.type() == Qgis::GeometryType::Line && mLineSettings.mergeLines() )
    {
      minimumSize = context.convertToMapUnits( featureThinningSettings.minimumFeatureSize(), Qgis::RenderUnit::Millimeters );
    }
    else
    {
      if ( !checkMinimumSizeMM( context, geom, featureThinningSettings.minimumFeatureSize() ) )
        return nullptr;
    }
  }
 
  if ( !geos_geom_clone )
    return nullptr; // invalid geometry
 
  // likelihood exists label will be registered with PAL and may be drawn
  // check if max number of features to label (already registered with PAL) has been reached
  // Debug output at end of QgsPalLabeling::drawLabeling(), when deleting temp geometries
  if ( featureThinningSettings.limitNumberOfLabelsEnabled() )
  {
    if ( !featureThinningSettings.maximumNumberLabels() )
    {
      return nullptr;
    }
    if ( mFeatsRegPal >= featureThinningSettings.maximumNumberLabels() )
    {
      return nullptr;
    }
 
    int divNum = static_cast< int >( ( static_cast< double >( mFeaturesToLabel ) / featureThinningSettings.maximumNumberLabels() ) + 0.5 ); // NOLINT
    if ( divNum && ( mFeatsRegPal == static_cast< int >( mFeatsSendingToPal / divNum ) ) )
    {
      mFeatsSendingToPal += 1;
      if ( divNum &&  mFeatsSendingToPal % divNum )
      {
        return nullptr;
      }
    }
  }
 
  //data defined position / alignment / rotation?
  bool layerDefinedRotation = false;
  bool dataDefinedRotation = false;
  double xPos = 0.0, yPos = 0.0;
  double angleInRadians = 0.0;
  double quadOffsetX = 0.0, quadOffsetY = 0.0;
  double offsetX = 0.0, offsetY = 0.0;
  QgsPointXY anchorPosition;
 
  if ( placement == Qgis::LabelPlacement::OverPoint )
  {
    anchorPosition = geom.centroid().asPoint();
  }
  //x/y shift in case of alignment
  double xdiff = 0.0;
  double ydiff = 0.0;
 
  //data defined quadrant offset?
  bool ddFixedQuad = false;
  Qgis::LabelQuadrantPosition quadOff = quadOffset;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::OffsetQuad ) )
  {
    context.expressionContext().setOriginalValueVariable( static_cast< int >( quadOff ) );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::OffsetQuad, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      bool ok;
      int quadInt = exprVal.toInt( &ok );
      if ( ok && 0 <= quadInt && quadInt <= 8 )
      {
        quadOff = static_cast< Qgis::LabelQuadrantPosition >( quadInt );
        ddFixedQuad = true;
      }
    }
  }
 
  // adjust quadrant offset of labels
  switch ( quadOff )
  {
    case Qgis::LabelQuadrantPosition::AboveLeft:
      quadOffsetX = -1.0;
      quadOffsetY = 1.0;
      break;
    case Qgis::LabelQuadrantPosition::Above:
      quadOffsetX = 0.0;
      quadOffsetY = 1.0;
      break;
    case Qgis::LabelQuadrantPosition::AboveRight:
      quadOffsetX = 1.0;
      quadOffsetY = 1.0;
      break;
    case Qgis::LabelQuadrantPosition::Left:
      quadOffsetX = -1.0;
      quadOffsetY = 0.0;
      break;
    case Qgis::LabelQuadrantPosition::Right:
      quadOffsetX = 1.0;
      quadOffsetY = 0.0;
      break;
    case Qgis::LabelQuadrantPosition::BelowLeft:
      quadOffsetX = -1.0;
      quadOffsetY = -1.0;
      break;
    case Qgis::LabelQuadrantPosition::Below:
      quadOffsetX = 0.0;
      quadOffsetY = -1.0;
      break;
    case Qgis::LabelQuadrantPosition::BelowRight:
      quadOffsetX = 1.0;
      quadOffsetY = -1.0;
      break;
    case Qgis::LabelQuadrantPosition::Over:
      break;
  }
 
  //data defined label offset?
  double xOff = xOffset;
  double yOff = yOffset;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::OffsetXY ) )
  {
    context.expressionContext().setOriginalValueVariable( QgsSymbolLayerUtils::encodePoint( QPointF( xOffset, yOffset ) ) );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::OffsetXY, context.expressionContext() );
    bool ok = false;
    const QPointF ddOffPt = QgsSymbolLayerUtils::toPoint( exprVal, &ok );
    if ( ok )
    {
      xOff = ddOffPt.x();
      yOff = ddOffPt.y();
    }
  }
 
  // data defined label offset units?
  Qgis::RenderUnit offUnit = offsetUnits;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::OffsetUnits ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::OffsetUnits, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString units = exprVal.toString().trimmed();
      if ( !units.isEmpty() )
      {
        bool ok = false;
        Qgis::RenderUnit decodedUnits = QgsUnitTypes::decodeRenderUnit( units, &ok );
        if ( ok )
        {
          offUnit = decodedUnits;
        }
      }
    }
  }
 
  // adjust offset of labels to match chosen unit and map scale
  // offsets match those of symbology: -x = left, -y = up
  offsetX = context.convertToMapUnits( xOff, offUnit, labelOffsetMapUnitScale );
  // must be negative to match symbology offset direction
  offsetY = context.convertToMapUnits( -yOff, offUnit, labelOffsetMapUnitScale );
 
  // layer defined rotation?
  if ( !qgsDoubleNear( angleOffset, 0.0 ) )
  {
    layerDefinedRotation = true;
    angleInRadians = ( 360 - angleOffset ) * M_PI / 180; // convert to radians counterclockwise
  }
 
  const QgsMapToPixel &m2p = context.mapToPixel();
  //data defined rotation?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::LabelRotation ) )
  {
    context.expressionContext().setOriginalValueVariable( angleOffset );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::LabelRotation, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      bool ok;
      const double rotation = exprVal.toDouble( &ok );
      if ( ok )
      {
        dataDefinedRotation = true;
 
        double rotationDegrees = rotation * QgsUnitTypes::fromUnitToUnitFactor( mRotationUnit,
                                 Qgis::AngleUnit::Degrees );
 
        // TODO: add setting to disable having data defined rotation follow
        //       map rotation ?
        rotationDegrees += m2p.mapRotation();
        angleInRadians = ( 360 - rotationDegrees ) * M_PI / 180.0;
      }
    }
  }
 
  bool hasDataDefinedPosition = false;
  {
    bool ddPosition = false;
 
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::PositionX )
         && mDataDefinedProperties.isActive( QgsPalLayerSettings::PositionY ) )
    {
      const QVariant xPosProperty = mDataDefinedProperties.value( QgsPalLayerSettings::PositionX, context.expressionContext() );
      const QVariant yPosProperty = mDataDefinedProperties.value( QgsPalLayerSettings::PositionY, context.expressionContext() );
      if ( !QgsVariantUtils::isNull( xPosProperty )
           && !QgsVariantUtils::isNull( yPosProperty ) )
      {
        ddPosition = true;
 
        bool ddXPos = false, ddYPos = false;
        xPos = xPosProperty.toDouble( &ddXPos );
        yPos = yPosProperty.toDouble( &ddYPos );
        if ( ddXPos && ddYPos )
          hasDataDefinedPosition = true;
      }
    }
    else if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::PositionPoint ) )
    {
      const QVariant pointPosProperty = mDataDefinedProperties.value( QgsPalLayerSettings::PositionPoint, context.expressionContext() );
      if ( !QgsVariantUtils::isNull( pointPosProperty ) )
      {
        ddPosition = true;
 
        QgsPoint point;
        if ( pointPosProperty.userType() == QMetaType::type( "QgsReferencedGeometry" ) )
        {
          QgsReferencedGeometry referencedGeometryPoint = pointPosProperty.value<QgsReferencedGeometry>();
          point = QgsPoint( referencedGeometryPoint.asPoint() );
 
          if ( !referencedGeometryPoint.isNull()
               && ct.sourceCrs() != referencedGeometryPoint.crs() )
            QgsMessageLog::logMessage( QObject::tr( "Label position geometry is not in layer coordinates reference system. Layer CRS: '%1', Geometry CRS: '%2'" ).arg( ct.sourceCrs().userFriendlyIdentifier(), referencedGeometryPoint.crs().userFriendlyIdentifier() ), QObject::tr( "Labeling" ), Qgis::Warning );
        }
        else if ( pointPosProperty.userType() == QMetaType::type( "QgsGeometry" ) )
        {
          point = QgsPoint( pointPosProperty.value<QgsGeometry>().asPoint() );
        }
 
        if ( !point.isEmpty() )
        {
          hasDataDefinedPosition = true;
 
          xPos = point.x();
          yPos = point.y();
        }
      }
    }
 
    if ( ddPosition )
    {
      //data defined position. But field values could be NULL -> positions will be generated by PAL
      if ( hasDataDefinedPosition )
      {
        // layer rotation set, but don't rotate pinned labels unless data defined
        if ( layerDefinedRotation && !dataDefinedRotation )
        {
          angleInRadians = 0.0;
        }
 
        //horizontal alignment
        if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Hali ) )
        {
          exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::Hali, context.expressionContext() );
          if ( !QgsVariantUtils::isNull( exprVal ) )
          {
            QString haliString = exprVal.toString();
            if ( haliString.compare( QLatin1String( "Center" ), Qt::CaseInsensitive ) == 0 )
            {
              xdiff -= labelWidth / 2.0;
            }
            else if ( haliString.compare( QLatin1String( "Right" ), Qt::CaseInsensitive ) == 0 )
            {
              xdiff -= labelWidth;
            }
          }
        }
 
        //vertical alignment
        if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Vali ) )
        {
          exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::Vali, context.expressionContext() );
          if ( !QgsVariantUtils::isNull( exprVal ) )
          {
            QString valiString = exprVal.toString();
            if ( valiString.compare( QLatin1String( "Bottom" ), Qt::CaseInsensitive ) != 0 )
            {
              if ( valiString.compare( QLatin1String( "Top" ), Qt::CaseInsensitive ) == 0 )
              {
                ydiff -= labelHeight;;
              }
              else
              {
                double descentRatio = labelFontMetrics->descent() / labelFontMetrics->height();
                if ( valiString.compare( QLatin1String( "Base" ), Qt::CaseInsensitive ) == 0 )
                {
                  ydiff -= labelHeight * descentRatio;
                }
                else //'Cap' or 'Half'
                {
                  double capHeightRatio = ( labelFontMetrics->boundingRect( 'H' ).height() + 1 + labelFontMetrics->descent() ) / labelFontMetrics->height();
                  ydiff -= labelHeight * capHeightRatio;
                  if ( valiString.compare( QLatin1String( "Half" ), Qt::CaseInsensitive ) == 0 )
                  {
                    ydiff += labelHeight * ( capHeightRatio - descentRatio ) / 2.0;
                  }
                }
              }
            }
          }
        }
 
        if ( dataDefinedRotation )
        {
          //adjust xdiff and ydiff because the hali/vali point needs to be the rotation center
          double xd = xdiff * std::cos( angleInRadians ) - ydiff * std::sin( angleInRadians );
          double yd = xdiff * std::sin( angleInRadians ) + ydiff * std::cos( angleInRadians );
          xdiff = xd;
          ydiff = yd;
        }
 
        //project xPos and yPos from layer to map CRS, handle rotation
        QgsGeometry ddPoint( new QgsPoint( xPos, yPos ) );
        if ( QgsPalLabeling::geometryRequiresPreparation( ddPoint, context, ct ) )
        {
          ddPoint = QgsPalLabeling::prepareGeometry( ddPoint, context, ct );
          if ( const QgsPoint *point = qgsgeometry_cast< const QgsPoint * >( ddPoint.constGet() ) )
          {
            xPos = point->x();
            yPos = point->y();
            anchorPosition = QgsPointXY( xPos, yPos );
          }
          else
          {
            QgsMessageLog::logMessage( QObject::tr( "Invalid data defined label position (%1, %2)" ).arg( xPos ).arg( yPos ), QObject::tr( "Labeling" ) );
            hasDataDefinedPosition = false;
          }
        }
        else
        {
          anchorPosition = QgsPointXY( xPos, yPos );
        }
 
        xPos += xdiff;
        yPos += ydiff;
      }
      else
      {
        anchorPosition = QgsPointXY( xPos, yPos );
      }
    }
  }
 
  // data defined always show?
  bool alwaysShow = false;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::AlwaysShow ) )
  {
    alwaysShow = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::AlwaysShow, context.expressionContext(), false );
  }
 
  // set repeat distance
  // data defined repeat distance?
  double repeatDist = repeatDistance;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::RepeatDistance ) )
  {
    context.expressionContext().setOriginalValueVariable( repeatDist );
    repeatDist = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::RepeatDistance, context.expressionContext(), repeatDist );
  }
 
  // data defined label-repeat distance units?
  Qgis::RenderUnit repeatUnits = repeatDistanceUnit;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::RepeatDistanceUnit ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::RepeatDistanceUnit, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString units = exprVal.toString().trimmed();
      if ( !units.isEmpty() )
      {
        bool ok = false;
        Qgis::RenderUnit decodedUnits = QgsUnitTypes::decodeRenderUnit( units, &ok );
        if ( ok )
        {
          repeatUnits = decodedUnits;
        }
      }
    }
  }
 
  if ( !qgsDoubleNear( repeatDist, 0.0 ) )
  {
    if ( repeatUnits != Qgis::RenderUnit::MapUnits )
    {
      repeatDist = context.convertToMapUnits( repeatDist, repeatUnits, repeatDistanceMapUnitScale );
    }
  }
 
  //  overrun distance
  double overrunDistanceEval = lineSettings.overrunDistance();
  if ( !qgsDoubleNear( overrunDistanceEval, 0.0 ) )
  {
    overrunDistanceEval = context.convertToMapUnits( overrunDistanceEval, lineSettings.overrunDistanceUnit(), lineSettings.overrunDistanceMapUnitScale() );
  }
 
  // we smooth out the overrun label extensions by 1 mm, to avoid little jaggies right at the start or end of the lines
  // causing the overrun extension to extend out in an undesirable direction. This is hard coded, we don't want to overload
  // users with options they likely don't need to see...
  const double overrunSmoothDist = context.convertToMapUnits( 1, Qgis::RenderUnit::Millimeters );
 
  bool labelAll = labelPerPart && !hasDataDefinedPosition;
  if ( !hasDataDefinedPosition )
  {
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::LabelAllParts ) )
    {
      context.expressionContext().setOriginalValueVariable( labelPerPart );
      labelAll = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::LabelAllParts, context.expressionContext(), labelPerPart );
    }
  }
 
  //  feature to the layer
  std::unique_ptr< QgsTextLabelFeature > labelFeature = std::make_unique< QgsTextLabelFeature>( feature.id(), std::move( geos_geom_clone ), QSizeF( labelWidth, labelHeight ) );
  labelFeature->setAnchorPosition( anchorPosition );
  labelFeature->setFeature( feature );
  labelFeature->setSymbol( symbol );
  labelFeature->setDocument( doc, documentMetrics );
  if ( !qgsDoubleNear( rotatedLabelX, 0.0 ) && !qgsDoubleNear( rotatedLabelY, 0.0 ) )
    labelFeature->setRotatedSize( QSizeF( rotatedLabelX, rotatedLabelY ) );
  mFeatsRegPal++;
 
  labelFeature->setHasFixedPosition( hasDataDefinedPosition );
  labelFeature->setFixedPosition( QgsPointXY( xPos, yPos ) );
  // use layer-level defined rotation, but not if position fixed
  labelFeature->setHasFixedAngle( dataDefinedRotation || ( !hasDataDefinedPosition && !qgsDoubleNear( angleInRadians, 0.0 ) ) );
  labelFeature->setFixedAngle( angleInRadians );
  labelFeature->setQuadOffset( QPointF( quadOffsetX, quadOffsetY ) );
  labelFeature->setPositionOffset( QgsPointXY( offsetX, offsetY ) );
  labelFeature->setOffsetType( offsetType );
  labelFeature->setAlwaysShow( alwaysShow );
  labelFeature->setRepeatDistance( repeatDist );
  labelFeature->setLabelText( labelText );
  labelFeature->setPermissibleZone( permissibleZone );
  labelFeature->setOverrunDistance( overrunDistanceEval );
  labelFeature->setOverrunSmoothDistance( overrunSmoothDist );
  labelFeature->setLineAnchorPercent( lineSettings.lineAnchorPercent() );
  labelFeature->setLineAnchorType( lineSettings.anchorType() );
  labelFeature->setLineAnchorTextPoint( lineSettings.anchorTextPoint() );
  labelFeature->setLabelAllParts( labelAll );
  labelFeature->setOriginalFeatureCrs( context.coordinateTransform().sourceCrs() );
  labelFeature->setMinimumSize( minimumSize );
  if ( geom.type() == Qgis::GeometryType::Point && !obstacleGeometry.isNull() )
  {
    //register symbol size
    labelFeature->setSymbolSize( QSizeF( obstacleGeometry.boundingBox().width(),
                                         obstacleGeometry.boundingBox().height() ) );
  }
 
  if ( outerBounds.left() != 0 || outerBounds.top() != 0 || !qgsDoubleNear( outerBounds.width(), labelWidth ) || !qgsDoubleNear( outerBounds.height(), labelHeight ) )
  {
    labelFeature->setOuterBounds( outerBounds );
  }
 
  //set label's visual margin so that top visual margin is the leading, and bottom margin is the font's descent
  //this makes labels align to the font's baseline or highest character
  double topMargin = std::max( 0.25 * labelFontMetrics->ascent(), 0.0 );
  double bottomMargin = 1.0 + labelFontMetrics->descent();
  QgsMargins vm( 0.0, topMargin, 0.0, bottomMargin );
  vm *= xform->mapUnitsPerPixel();
  labelFeature->setVisualMargin( vm );
 
  // store the label's calculated font for later use during painting
  QgsDebugMsgLevel( QStringLiteral( "PAL font stored definedFont: %1, Style: %2" ).arg( labelFont.toString(), labelFont.styleName() ), 4 );
  labelFeature->setDefinedFont( labelFont );
 
  labelFeature->setMaximumCharacterAngleInside( std::clamp( maxcharanglein, 20.0, 60.0 ) * M_PI / 180 );
  labelFeature->setMaximumCharacterAngleOutside( std::clamp( maxcharangleout, -95.0, -20.0 ) * M_PI / 180 );
  switch ( placement )
  {
    case Qgis::LabelPlacement::AroundPoint:
    case Qgis::LabelPlacement::OverPoint:
    case Qgis::LabelPlacement::Line:
    case Qgis::LabelPlacement::Horizontal:
    case Qgis::LabelPlacement::Free:
    case Qgis::LabelPlacement::OrderedPositionsAroundPoint:
    case Qgis::LabelPlacement::OutsidePolygons:
      // these placements don't require text metrics
      break;
 
    case Qgis::LabelPlacement::Curved:
    case Qgis::LabelPlacement::PerimeterCurved:
      labelFeature->setTextMetrics( QgsTextLabelFeature::calculateTextMetrics( xform, context, labelFont, *labelFontMetrics, labelFont.letterSpacing(), labelFont.wordSpacing(), labelText, format().allowHtmlFormatting() ? &doc : nullptr, format().allowHtmlFormatting() ? &documentMetrics : nullptr ) );
      break;
  }
 
  // for labelFeature the LabelInfo is passed to feat when it is registered
 
  // TODO: allow layer-wide feature dist in PAL...?
 
  // data defined label-feature distance?
  double distance = dist;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::LabelDistance ) )
  {
    context.expressionContext().setOriginalValueVariable( distance );
    distance = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::LabelDistance, context.expressionContext(), distance );
  }
 
  // data defined label-feature distance units?
  Qgis::RenderUnit distUnit = distUnits;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::DistanceUnits ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::DistanceUnits, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString units = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal DistanceUnits:%1" ).arg( units ), 4 );
      if ( !units.isEmpty() )
      {
        bool ok = false;
        Qgis::RenderUnit decodedUnits = QgsUnitTypes::decodeRenderUnit( units, &ok );
        if ( ok )
        {
          distUnit = decodedUnits;
        }
      }
    }
  }
  distance = context.convertToPainterUnits( distance, distUnit, distMapUnitScale );
 
  // when using certain placement modes, we force a tiny minimum distance. This ensures that
  // candidates are created just offset from a border and avoids candidates being incorrectly flagged as colliding with neighbours
  switch ( placement )
  {
    case Qgis::LabelPlacement::Line:
    case Qgis::LabelPlacement::Curved:
    case Qgis::LabelPlacement::PerimeterCurved:
      distance = ( distance < 0 ? -1 : 1 ) * std::max( std::fabs( distance ), 1.0 );
      break;
 
    case Qgis::LabelPlacement::OrderedPositionsAroundPoint:
      break;
 
    case Qgis::LabelPlacement::AroundPoint:
    case Qgis::LabelPlacement::OverPoint:
    case Qgis::LabelPlacement::Horizontal:
    case Qgis::LabelPlacement::Free:
      if ( polygonPlacement & Qgis::LabelPolygonPlacementFlag::AllowPlacementOutsideOfPolygon )
      {
        distance = std::max( distance, 2.0 );
      }
      break;
 
    case Qgis::LabelPlacement::OutsidePolygons:
      distance = std::max( distance, 2.0 );
      break;
  }
 
  if ( !qgsDoubleNear( distance, 0.0 ) )
  {
    double d = ptOne.distance( ptZero ) * distance;
    labelFeature->setDistLabel( d );
  }
 
  if ( ddFixedQuad )
  {
    labelFeature->setHasFixedQuadrant( true );
  }
 
  labelFeature->setArrangementFlags( lineSettings.placementFlags() );
 
  labelFeature->setPolygonPlacementFlags( polygonPlacement );
 
  // data defined z-index?
  double z = zIndex;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::ZIndex ) )
  {
    context.expressionContext().setOriginalValueVariable( z );
    z = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::ZIndex, context.expressionContext(), z );
  }
  labelFeature->setZIndex( z );
 
  // data defined priority?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Priority ) )
  {
    context.expressionContext().setOriginalValueVariable( priority );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::Priority, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      bool ok;
      double priorityD = exprVal.toDouble( &ok );
      if ( ok )
      {
        priorityD = std::clamp( priorityD, 0.0, 10.0 );
        priorityD = 1 - priorityD / 10.0; // convert 0..10 --> 1..0
        labelFeature->setPriority( priorityD );
      }
    }
  }
 
  // data defined allow degraded placement
  {
    double allowDegradedPlacement = mPlacementSettings.allowDegradedPlacement();
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::AllowDegradedPlacement ) )
    {
      context.expressionContext().setOriginalValueVariable( allowDegradedPlacement );
      allowDegradedPlacement = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::AllowDegradedPlacement, context.expressionContext(), allowDegradedPlacement );
    }
    labelFeature->setAllowDegradedPlacement( allowDegradedPlacement );
  }
 
  // data defined overlap handling
  {
    Qgis::LabelOverlapHandling overlapHandling = mPlacementSettings.overlapHandling();
    if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::OverlapHandling ) )
    {
      const QString handlingString = mDataDefinedProperties.valueAsString( QgsPalLayerSettings::OverlapHandling, context.expressionContext() );
      const QString cleanedString = handlingString.trimmed();
      if ( cleanedString.compare( QLatin1String( "prevent" ), Qt::CaseInsensitive ) == 0 )
        overlapHandling = Qgis::LabelOverlapHandling::PreventOverlap;
      else if ( cleanedString.compare( QLatin1String( "allowifneeded" ), Qt::CaseInsensitive ) == 0 )
        overlapHandling = Qgis::LabelOverlapHandling::AllowOverlapIfRequired;
      else if ( cleanedString.compare( QLatin1String( "alwaysallow" ), Qt::CaseInsensitive ) == 0 )
        overlapHandling = Qgis::LabelOverlapHandling::AllowOverlapAtNoCost;
    }
    labelFeature->setOverlapHandling( overlapHandling );
  }
 
  QgsLabelObstacleSettings os = mObstacleSettings;
  os.setIsObstacle( isObstacle );
  os.updateDataDefinedProperties( mDataDefinedProperties, context.expressionContext() );
  os.setObstacleGeometry( obstacleGeometry );
  labelFeature->setObstacleSettings( os );
 
  QVector< Qgis::LabelPredefinedPointPosition > positionOrder = predefinedPositionOrder;
  if ( positionOrder.isEmpty() )
    positionOrder = *DEFAULT_PLACEMENT_ORDER();
 
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::PredefinedPositionOrder ) )
  {
    context.expressionContext().setOriginalValueVariable( QgsLabelingUtils::encodePredefinedPositionOrder( predefinedPositionOrder ) );
    QString dataDefinedOrder = mDataDefinedProperties.valueAsString( QgsPalLayerSettings::PredefinedPositionOrder, context.expressionContext() );
    if ( !dataDefinedOrder.isEmpty() )
    {
      positionOrder = QgsLabelingUtils::decodePredefinedPositionOrder( dataDefinedOrder );
    }
  }
  labelFeature->setPredefinedPositionOrder( positionOrder );
 
  // add parameters for data defined labeling to label feature
  labelFeature->setDataDefinedValues( dataDefinedValues );
 
  return labelFeature;
}
 
std::unique_ptr<QgsLabelFeature> QgsPalLayerSettings::registerObstacleFeature( const QgsFeature &f, QgsRenderContext &context, const QgsGeometry &obstacleGeometry )
{
  mCurFeat = &f;
 
  QgsGeometry geom;
  if ( !obstacleGeometry.isNull() )
  {
    geom = obstacleGeometry;
  }
  else
  {
    geom = f.geometry();
  }
 
  if ( geom.isNull() )
  {
    return nullptr;
  }
 
  // don't even try to register linestrings with only one vertex as an obstacle
  if ( const QgsLineString *ls = qgsgeometry_cast< const QgsLineString * >( geom.constGet() ) )
  {
    if ( ls->numPoints() < 2 )
      return nullptr;
  }
 
  // simplify?
  const QgsVectorSimplifyMethod &simplifyMethod = context.vectorSimplifyMethod();
  std::unique_ptr<QgsGeometry> scopedClonedGeom;
  if ( simplifyMethod.simplifyHints() != QgsVectorSimplifyMethod::NoSimplification && simplifyMethod.forceLocalOptimization() )
  {
    int simplifyHints = simplifyMethod.simplifyHints() | QgsMapToPixelSimplifier::SimplifyEnvelope;
    QgsMapToPixelSimplifier::SimplifyAlgorithm simplifyAlgorithm = static_cast< QgsMapToPixelSimplifier::SimplifyAlgorithm >( simplifyMethod.simplifyAlgorithm() );
    QgsMapToPixelSimplifier simplifier( simplifyHints, simplifyMethod.tolerance(), simplifyAlgorithm );
    geom = simplifier.simplify( geom );
  }
 
  geos::unique_ptr geos_geom_clone;
  std::unique_ptr<QgsGeometry> scopedPreparedGeom;
 
  if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, ct, extentGeom, mLineSettings.mergeLines() ) )
  {
    geom = QgsPalLabeling::prepareGeometry( geom, context, ct, extentGeom, mLineSettings.mergeLines() );
  }
  geos_geom_clone = QgsGeos::asGeos( geom );
 
  if ( !geos_geom_clone )
    return nullptr; // invalid geometry
 
  //  feature to the layer
  std::unique_ptr< QgsLabelFeature > obstacleFeature = std::make_unique< QgsLabelFeature >( f.id(), std::move( geos_geom_clone ), QSizeF( 0, 0 ) );
  obstacleFeature->setFeature( f );
 
  QgsLabelObstacleSettings os = mObstacleSettings;
  os.setIsObstacle( true );
  os.updateDataDefinedProperties( mDataDefinedProperties, context.expressionContext() );
  obstacleFeature->setObstacleSettings( os );
 
  mFeatsRegPal++;
  return obstacleFeature;
}
 
bool QgsPalLayerSettings::dataDefinedValEval( DataDefinedValueType valType,
    QgsPalLayerSettings::Property p,
    QVariant &exprVal, QgsExpressionContext &context, const QVariant &originalValue )
{
  if ( !mDataDefinedProperties.isActive( p ) )
    return false;
 
  context.setOriginalValueVariable( originalValue );
  exprVal = mDataDefinedProperties.value( p, context );
  if ( !QgsVariantUtils::isNull( exprVal ) )
  {
    switch ( valType )
    {
      case DDBool:
      {
        bool bol = exprVal.toBool();
        dataDefinedValues.insert( p, QVariant( bol ) );
        return true;
      }
      case DDInt:
      {
        bool ok;
        int size = exprVal.toInt( &ok );
 
        if ( ok )
        {
          dataDefinedValues.insert( p, QVariant( size ) );
          return true;
        }
        return false;
      }
      case DDIntPos:
      {
        bool ok;
        int size = exprVal.toInt( &ok );
 
        if ( ok && size > 0 )
        {
          dataDefinedValues.insert( p, QVariant( size ) );
          return true;
        }
        return false;
      }
      case DDDouble:
      {
        bool ok;
        double size = exprVal.toDouble( &ok );
 
        if ( ok )
        {
          dataDefinedValues.insert( p, QVariant( size ) );
          return true;
        }
        return false;
      }
      case DDDoublePos:
      {
        bool ok;
        double size = exprVal.toDouble( &ok );
 
        if ( ok && size > 0.0 )
        {
          dataDefinedValues.insert( p, QVariant( size ) );
          return true;
        }
        return false;
      }
      case DDRotation180:
      {
        bool ok;
        double rot = exprVal.toDouble( &ok );
        if ( ok )
        {
          if ( rot < -180.0 && rot >= -360 )
          {
            rot += 360;
          }
          if ( rot > 180.0 && rot <= 360 )
          {
            rot -= 360;
          }
          if ( rot >= -180 && rot <= 180 )
          {
            dataDefinedValues.insert( p, QVariant( rot ) );
            return true;
          }
        }
        return false;
      }
      case DDOpacity:
      {
        bool ok;
        int size = exprVal.toInt( &ok );
        if ( ok && size >= 0 && size <= 100 )
        {
          dataDefinedValues.insert( p, QVariant( size ) );
          return true;
        }
        return false;
      }
      case DDString:
      {
        QString str = exprVal.toString(); // don't trim whitespace
 
        dataDefinedValues.insert( p, QVariant( str ) ); // let it stay empty if it is
        return true;
      }
      case DDUnits:
      {
        QString unitstr = exprVal.toString().trimmed();
 
        if ( !unitstr.isEmpty() )
        {
          dataDefinedValues.insert( p, QVariant( static_cast< int >( QgsUnitTypes::decodeRenderUnit( unitstr ) ) ) );
          return true;
        }
        return false;
      }
      case DDColor:
      {
        QString colorstr = exprVal.toString().trimmed();
        QColor color = QgsSymbolLayerUtils::decodeColor( colorstr );
 
        if ( color.isValid() )
        {
          dataDefinedValues.insert( p, QVariant( color ) );
          return true;
        }
        return false;
      }
      case DDJoinStyle:
      {
        QString joinstr = exprVal.toString().trimmed();
 
        if ( !joinstr.isEmpty() )
        {
          dataDefinedValues.insert( p, QVariant( static_cast< int >( QgsSymbolLayerUtils::decodePenJoinStyle( joinstr ) ) ) );
          return true;
        }
        return false;
      }
      case DDBlendMode:
      {
        QString blendstr = exprVal.toString().trimmed();
 
        if ( !blendstr.isEmpty() )
        {
          dataDefinedValues.insert( p, QVariant( static_cast< int >( QgsSymbolLayerUtils::decodeBlendMode( blendstr ) ) ) );
          return true;
        }
        return false;
      }
      case DDPointF:
      {
        bool ok = false;
        const QPointF res = QgsSymbolLayerUtils::toPoint( exprVal, &ok );
        if ( ok )
        {
          dataDefinedValues.insert( p, res );
          return true;
        }
        return false;
      }
      case DDSizeF:
      {
        bool ok = false;
        const QSizeF res = QgsSymbolLayerUtils::toSize( exprVal, &ok );
        if ( ok )
        {
          dataDefinedValues.insert( p, res );
          return true;
        }
        return false;
      }
    }
  }
  return false;
}
 
void QgsPalLayerSettings::parseTextStyle( QFont &labelFont,
    Qgis::RenderUnit fontunits,
    QgsRenderContext &context )
{
  // NOTE: labelFont already has pixelSize set, so pointSize or pointSizeF might return -1
 
  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
 
  // Two ways to generate new data defined font:
  // 1) Family + [bold] + [italic] (named style is ignored and font is built off of base family)
  // 2) Family + named style  (bold or italic is ignored)
 
  // data defined font family?
  QString ddFontFamily;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Family ) )
  {
    context.expressionContext().setOriginalValueVariable( labelFont.family() );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::Family, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString family = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal Font family:%1" ).arg( family ), 4 );
 
      family = QgsApplication::fontManager()->processFontFamilyName( family );
      if ( labelFont.family() != family )
      {
        // testing for ddFontFamily in QFontDatabase.families() may be slow to do for every feature
        // (i.e. don't use QgsFontUtils::fontFamilyMatchOnSystem( family ) here)
        if ( QgsFontUtils::fontFamilyOnSystem( family ) )
        {
          ddFontFamily = family;
        }
      }
    }
  }
 
  // data defined named font style?
  QString ddFontStyle;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::FontStyle ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::FontStyle, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString fontstyle = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal Font style:%1" ).arg( fontstyle ), 4 );
      ddFontStyle = fontstyle;
    }
  }
 
  // data defined bold font style?
  bool ddBold = false;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Bold ) )
  {
    context.expressionContext().setOriginalValueVariable( labelFont.bold() );
    ddBold = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::Bold, context.expressionContext(), false );
  }
 
  // data defined italic font style?
  bool ddItalic = false;
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Italic ) )
  {
    context.expressionContext().setOriginalValueVariable( labelFont.italic() );
    ddItalic = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::Italic, context.expressionContext(), false );
  }
 
  // TODO: update when pref for how to resolve missing family (use matching algorithm or just default font) is implemented
  //       (currently defaults to what has been read in from layer settings)
  QFont newFont;
  QFont appFont = QApplication::font();
  bool newFontBuilt = false;
  if ( ddBold || ddItalic )
  {
    // new font needs built, since existing style needs removed
    newFont = QgsFontUtils::createFont( !ddFontFamily.isEmpty() ? ddFontFamily : labelFont.family() );
    newFontBuilt = true;
    newFont.setBold( ddBold );
    newFont.setItalic( ddItalic );
  }
  else if ( !ddFontStyle.isEmpty()
            && ddFontStyle.compare( QLatin1String( "Ignore" ), Qt::CaseInsensitive ) != 0 )
  {
    if ( !ddFontFamily.isEmpty() )
    {
      // both family and style are different, build font from database
      if ( !mFontDB )
        mFontDB = std::make_unique< QFontDatabase >();
 
      QFont styledfont = mFontDB->font( ddFontFamily, ddFontStyle, appFont.pointSize() );
      if ( appFont != styledfont )
      {
        newFont = styledfont;
        newFontBuilt = true;
      }
    }
 
    // update the font face style
    QgsFontUtils::updateFontViaStyle( newFontBuilt ? newFont : labelFont, ddFontStyle );
  }
  else if ( !ddFontFamily.isEmpty() )
  {
    if ( ddFontStyle.compare( QLatin1String( "Ignore" ), Qt::CaseInsensitive ) != 0 )
    {
      // just family is different, build font from database
      if ( !mFontDB )
        mFontDB = std::make_unique< QFontDatabase >();
      QFont styledfont = mFontDB->font( ddFontFamily, mFormat.namedStyle(), appFont.pointSize() );
      if ( appFont != styledfont )
      {
        newFont = styledfont;
        newFontBuilt = true;
      }
    }
    else
    {
      newFont = QgsFontUtils::createFont( ddFontFamily );
      newFontBuilt = true;
    }
  }
 
  if ( newFontBuilt )
  {
    // copy over existing font settings
    //newFont = newFont.resolve( labelFont ); // should work, but let's be sure what's being copied
    newFont.setPixelSize( labelFont.pixelSize() );
    newFont.setUnderline( labelFont.underline() );
    newFont.setStrikeOut( labelFont.strikeOut() );
    newFont.setWordSpacing( labelFont.wordSpacing() );
    newFont.setLetterSpacing( QFont::AbsoluteSpacing, labelFont.letterSpacing() );
 
    labelFont = newFont;
  }
 
  // data defined word spacing?
  double wordspace = labelFont.wordSpacing();
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::FontWordSpacing ) )
  {
    context.expressionContext().setOriginalValueVariable( wordspace );
    wordspace = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::FontWordSpacing, context.expressionContext(), wordspace );
  }
  labelFont.setWordSpacing( context.convertToPainterUnits( wordspace, fontunits, mFormat.sizeMapUnitScale() ) );
 
  // data defined letter spacing?
  double letterspace = labelFont.letterSpacing();
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::FontLetterSpacing ) )
  {
    context.expressionContext().setOriginalValueVariable( letterspace );
    letterspace = mDataDefinedProperties.valueAsDouble( QgsPalLayerSettings::FontLetterSpacing, context.expressionContext(), letterspace );
  }
  labelFont.setLetterSpacing( QFont::AbsoluteSpacing, context.convertToPainterUnits( letterspace, fontunits, mFormat.sizeMapUnitScale() ) );
 
  // data defined strikeout font style?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Strikeout ) )
  {
    context.expressionContext().setOriginalValueVariable( labelFont.strikeOut() );
    bool strikeout = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::Strikeout, context.expressionContext(), false );
    labelFont.setStrikeOut( strikeout );
  }
 
  // data defined stretch
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::FontStretchFactor ) )
  {
    context.expressionContext().setOriginalValueVariable( mFormat.stretchFactor() );
    labelFont.setStretch( mDataDefinedProperties.valueAsInt( QgsPalLayerSettings::FontStretchFactor, context.expressionContext(),  mFormat.stretchFactor() ) );
  }
 
  // data defined underline font style?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::Underline ) )
  {
    context.expressionContext().setOriginalValueVariable( labelFont.underline() );
    bool underline = mDataDefinedProperties.valueAsBool( QgsPalLayerSettings::Underline, context.expressionContext(), false );
    labelFont.setUnderline( underline );
  }
 
  // pass the rest on to QgsPalLabeling::drawLabeling
 
  // data defined font color?
  dataDefinedValEval( DDColor, QgsPalLayerSettings::Color, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodeColor( mFormat.color() ) );
 
  // data defined font opacity?
  dataDefinedValEval( DDOpacity, QgsPalLayerSettings::FontOpacity, exprVal, context.expressionContext(), mFormat.opacity() * 100 );
 
  // data defined font blend mode?
  dataDefinedValEval( DDBlendMode, QgsPalLayerSettings::FontBlendMode, exprVal, context.expressionContext() );
 
}
 
void QgsPalLayerSettings::parseTextBuffer( QgsRenderContext &context )
{
  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
 
  QgsTextBufferSettings buffer = mFormat.buffer();
 
  // data defined draw buffer?
  bool drawBuffer = mFormat.buffer().enabled();
  if ( dataDefinedValEval( DDBool, QgsPalLayerSettings::BufferDraw, exprVal, context.expressionContext(), buffer.enabled() ) )
  {
    drawBuffer = exprVal.toBool();
  }
  else if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::BufferDraw ) && QgsVariantUtils::isNull( exprVal ) )
  {
    dataDefinedValues.insert( QgsPalLayerSettings::BufferDraw, QVariant( drawBuffer ) );
  }
 
  if ( !drawBuffer )
  {
    return;
  }
 
  // data defined buffer size?
  double bufrSize = buffer.size();
  if ( dataDefinedValEval( DDDoublePos, QgsPalLayerSettings::BufferSize, exprVal, context.expressionContext(), buffer.size() ) )
  {
    bufrSize = exprVal.toDouble();
  }
 
  // data defined buffer transparency?
  double bufferOpacity = buffer.opacity() * 100;
  if ( dataDefinedValEval( DDOpacity, QgsPalLayerSettings::BufferOpacity, exprVal, context.expressionContext(), bufferOpacity ) )
  {
    bufferOpacity = exprVal.toDouble();
  }
 
  drawBuffer = ( drawBuffer && bufrSize > 0.0 && bufferOpacity > 0 );
 
  if ( !drawBuffer )
  {
    dataDefinedValues.insert( QgsPalLayerSettings::BufferDraw, QVariant( false ) ); // trigger value
    dataDefinedValues.remove( QgsPalLayerSettings::BufferSize );
    dataDefinedValues.remove( QgsPalLayerSettings::BufferOpacity );
    return; // don't bother evaluating values that won't be used
  }
 
  // data defined buffer units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::BufferUnit, exprVal, context.expressionContext() );
 
  // data defined buffer color?
  dataDefinedValEval( DDColor, QgsPalLayerSettings::BufferColor, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodeColor( buffer.color() ) );
 
  // data defined buffer pen join style?
  dataDefinedValEval( DDJoinStyle, QgsPalLayerSettings::BufferJoinStyle, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodePenJoinStyle( buffer.joinStyle() ) );
 
  // data defined buffer blend mode?
  dataDefinedValEval( DDBlendMode, QgsPalLayerSettings::BufferBlendMode, exprVal, context.expressionContext() );
}
 
void QgsPalLayerSettings::parseTextMask( QgsRenderContext &context )
{
  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
 
  QgsTextMaskSettings mask = mFormat.mask();
 
  // data defined enabled mask?
  bool maskEnabled = mask.enabled();
  if ( dataDefinedValEval( DDBool, QgsPalLayerSettings::MaskEnabled, exprVal, context.expressionContext(), mask.enabled() ) )
  {
    maskEnabled = exprVal.toBool();
  }
 
  if ( !maskEnabled )
  {
    return;
  }
 
  // data defined buffer size?
  double bufrSize = mask.size();
  if ( dataDefinedValEval( DDDoublePos, QgsPalLayerSettings::MaskBufferSize, exprVal, context.expressionContext(), mask.size() ) )
  {
    bufrSize = exprVal.toDouble();
  }
 
  // data defined opacity?
  double opacity = mask.opacity() * 100;
  if ( dataDefinedValEval( DDOpacity, QgsPalLayerSettings::MaskOpacity, exprVal, context.expressionContext(), opacity ) )
  {
    opacity = exprVal.toDouble();
  }
 
  maskEnabled = ( maskEnabled && bufrSize > 0.0 && opacity > 0 );
 
  if ( !maskEnabled )
  {
    dataDefinedValues.insert( QgsPalLayerSettings::MaskEnabled, QVariant( false ) ); // trigger value
    dataDefinedValues.remove( QgsPalLayerSettings::MaskBufferSize );
    dataDefinedValues.remove( QgsPalLayerSettings::MaskOpacity );
    return; // don't bother evaluating values that won't be used
  }
 
  // data defined buffer units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::MaskBufferUnit, exprVal, context.expressionContext() );
 
  // data defined buffer pen join style?
  dataDefinedValEval( DDJoinStyle, QgsPalLayerSettings::MaskJoinStyle, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodePenJoinStyle( mask.joinStyle() ) );
}
 
void QgsPalLayerSettings::parseTextFormatting( QgsRenderContext &context )
{
  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
 
  // data defined multiline wrap character?
  QString wrapchr = wrapChar;
  if ( dataDefinedValEval( DDString, QgsPalLayerSettings::MultiLineWrapChar, exprVal, context.expressionContext(), wrapChar ) )
  {
    wrapchr = exprVal.toString();
  }
 
  int evalAutoWrapLength = autoWrapLength;
  if ( dataDefinedValEval( DDInt, QgsPalLayerSettings::AutoWrapLength, exprVal, context.expressionContext(), evalAutoWrapLength ) )
  {
    evalAutoWrapLength = exprVal.toInt();
  }
 
  // data defined multiline height?
  dataDefinedValEval( DDDouble, QgsPalLayerSettings::MultiLineHeight, exprVal, context.expressionContext() );
 
  // data defined multiline text align?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::MultiLineAlignment ) )
  {
    context.expressionContext().setOriginalValueVariable( mFormat.lineHeight() );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::MultiLineAlignment, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString str = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal MultiLineAlignment:%1" ).arg( str ), 4 );
 
      if ( !str.isEmpty() )
      {
        // "Left"
        Qgis::LabelMultiLineAlignment aligntype = Qgis::LabelMultiLineAlignment::Left;
 
        if ( str.compare( QLatin1String( "Center" ), Qt::CaseInsensitive ) == 0 )
        {
          aligntype = Qgis::LabelMultiLineAlignment::Center;
        }
        else if ( str.compare( QLatin1String( "Right" ), Qt::CaseInsensitive ) == 0 )
        {
          aligntype = Qgis::LabelMultiLineAlignment::Right;
        }
        else if ( str.compare( QLatin1String( "Follow" ), Qt::CaseInsensitive ) == 0 )
        {
          aligntype = Qgis::LabelMultiLineAlignment::FollowPlacement;
        }
        else if ( str.compare( QLatin1String( "Justify" ), Qt::CaseInsensitive ) == 0 )
        {
          aligntype = Qgis::LabelMultiLineAlignment::Justify;
        }
        dataDefinedValues.insert( QgsPalLayerSettings::MultiLineAlignment, QVariant( static_cast< int >( aligntype ) ) );
      }
    }
  }
 
  // text orientation
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::TextOrientation ) )
  {
    const QString encoded = QgsTextRendererUtils::encodeTextOrientation( mFormat.orientation() );
    context.expressionContext().setOriginalValueVariable( encoded );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::TextOrientation, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString str = exprVal.toString().trimmed();
      if ( !str.isEmpty() )
        dataDefinedValues.insert( QgsPalLayerSettings::TextOrientation, str );
    }
  }
 
  // data defined direction symbol?
  bool drawDirSymb = mLineSettings.addDirectionSymbol();
  if ( dataDefinedValEval( DDBool, QgsPalLayerSettings::DirSymbDraw, exprVal, context.expressionContext(), drawDirSymb ) )
  {
    drawDirSymb = exprVal.toBool();
  }
 
  if ( drawDirSymb )
  {
    // data defined direction left symbol?
    dataDefinedValEval( DDString, QgsPalLayerSettings::DirSymbLeft, exprVal, context.expressionContext(), mLineSettings.leftDirectionSymbol() );
 
    // data defined direction right symbol?
    dataDefinedValEval( DDString, QgsPalLayerSettings::DirSymbRight, exprVal, context.expressionContext(), mLineSettings.rightDirectionSymbol() );
 
    // data defined direction symbol placement?
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::DirSymbPlacement, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString str = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal DirSymbPlacement:%1" ).arg( str ), 4 );
 
      if ( !str.isEmpty() )
      {
        // "LeftRight"
        QgsLabelLineSettings::DirectionSymbolPlacement placetype = QgsLabelLineSettings::DirectionSymbolPlacement::SymbolLeftRight;
 
        if ( str.compare( QLatin1String( "Above" ), Qt::CaseInsensitive ) == 0 )
        {
          placetype = QgsLabelLineSettings::DirectionSymbolPlacement::SymbolAbove;
        }
        else if ( str.compare( QLatin1String( "Below" ), Qt::CaseInsensitive ) == 0 )
        {
          placetype = QgsLabelLineSettings::DirectionSymbolPlacement::SymbolBelow;
        }
        dataDefinedValues.insert( QgsPalLayerSettings::DirSymbPlacement, QVariant( static_cast< int >( placetype ) ) );
      }
    }
 
    // data defined direction symbol reversed?
    dataDefinedValEval( DDBool, QgsPalLayerSettings::DirSymbReverse, exprVal, context.expressionContext(), mLineSettings.reverseDirectionSymbol() );
  }
 
  // formatting for numbers is inline with generation of base label text and not passed to label painting
}
 
void QgsPalLayerSettings::parseShapeBackground( QgsRenderContext &context )
{
  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
 
  QgsTextBackgroundSettings background = mFormat.background();
 
  // data defined draw shape?
  bool drawShape = background.enabled();
  if ( dataDefinedValEval( DDBool, QgsPalLayerSettings::ShapeDraw, exprVal, context.expressionContext(), drawShape ) )
  {
    drawShape = exprVal.toBool();
  }
 
  if ( !drawShape )
  {
    return;
  }
 
  // data defined shape transparency?
  double shapeOpacity = background.opacity() * 100;
  if ( dataDefinedValEval( DDOpacity, QgsPalLayerSettings::ShapeOpacity, exprVal, context.expressionContext(), shapeOpacity ) )
  {
    shapeOpacity = 100.0 * exprVal.toDouble();
  }
 
  drawShape = ( drawShape && shapeOpacity > 0 ); // size is not taken into account (could be)
 
  if ( !drawShape )
  {
    dataDefinedValues.insert( QgsPalLayerSettings::ShapeDraw, QVariant( false ) ); // trigger value
    dataDefinedValues.remove( QgsPalLayerSettings::ShapeOpacity );
    return; // don't bother evaluating values that won't be used
  }
 
  // data defined shape kind?
  QgsTextBackgroundSettings::ShapeType shapeKind = background.type();
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::ShapeKind ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::ShapeKind, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString skind = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal ShapeKind:%1" ).arg( skind ), 4 );
 
      if ( !skind.isEmpty() )
      {
        shapeKind = QgsTextRendererUtils::decodeShapeType( skind );
        dataDefinedValues.insert( QgsPalLayerSettings::ShapeKind, QVariant( static_cast< int >( shapeKind ) ) );
      }
    }
  }
 
  // data defined shape SVG path?
  QString svgPath = background.svgFile();
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::ShapeSVGFile ) )
  {
    context.expressionContext().setOriginalValueVariable( svgPath );
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::ShapeSVGFile, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString svgfile = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal ShapeSVGFile:%1" ).arg( svgfile ), 4 );
 
      // '' empty paths are allowed
      svgPath = QgsSymbolLayerUtils::svgSymbolNameToPath( svgfile, context.pathResolver() );
      dataDefinedValues.insert( QgsPalLayerSettings::ShapeSVGFile, QVariant( svgPath ) );
    }
  }
 
  // data defined shape size type?
  QgsTextBackgroundSettings::SizeType shpSizeType = background.sizeType();
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::ShapeSizeType ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::ShapeSizeType, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString stype = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal ShapeSizeType:%1" ).arg( stype ), 4 );
 
      if ( !stype.isEmpty() )
      {
        shpSizeType = QgsTextRendererUtils::decodeBackgroundSizeType( stype );
        dataDefinedValues.insert( QgsPalLayerSettings::ShapeSizeType, QVariant( static_cast< int >( shpSizeType ) ) );
      }
    }
  }
 
  // data defined shape size X? (SVGs only use X for sizing)
  double ddShpSizeX = background.size().width();
  if ( dataDefinedValEval( DDDouble, QgsPalLayerSettings::ShapeSizeX, exprVal, context.expressionContext(), ddShpSizeX ) )
  {
    ddShpSizeX = exprVal.toDouble();
  }
 
  // data defined shape size Y?
  double ddShpSizeY = background.size().height();
  if ( dataDefinedValEval( DDDouble, QgsPalLayerSettings::ShapeSizeY, exprVal, context.expressionContext(), ddShpSizeY ) )
  {
    ddShpSizeY = exprVal.toDouble();
  }
 
  // don't continue under certain circumstances (e.g. size is fixed)
  bool skip = false;
  if ( shapeKind == QgsTextBackgroundSettings::ShapeSVG
       && ( svgPath.isEmpty()
            || ( !svgPath.isEmpty()
                 && shpSizeType == QgsTextBackgroundSettings::SizeFixed
                 && ddShpSizeX == 0.0 ) ) )
  {
    skip = true;
  }
  if ( shapeKind == QgsTextBackgroundSettings::ShapeMarkerSymbol
       && ( !background.markerSymbol()
            || ( background.markerSymbol()
                 && shpSizeType == QgsTextBackgroundSettings::SizeFixed
                 && ddShpSizeX == 0.0 ) ) )
  {
    skip = true;
  }
  if ( shapeKind != QgsTextBackgroundSettings::ShapeSVG
       && shapeKind != QgsTextBackgroundSettings::ShapeMarkerSymbol
       && shpSizeType == QgsTextBackgroundSettings::SizeFixed
       && ( ddShpSizeX == 0.0 || ddShpSizeY == 0.0 ) )
  {
    skip = true;
  }
 
  if ( skip )
  {
    dataDefinedValues.insert( QgsPalLayerSettings::ShapeDraw, QVariant( false ) ); // trigger value
    dataDefinedValues.remove( QgsPalLayerSettings::ShapeOpacity );
    dataDefinedValues.remove( QgsPalLayerSettings::ShapeKind );
    dataDefinedValues.remove( QgsPalLayerSettings::ShapeSVGFile );
    dataDefinedValues.remove( QgsPalLayerSettings::ShapeSizeX );
    dataDefinedValues.remove( QgsPalLayerSettings::ShapeSizeY );
    return; // don't bother evaluating values that won't be used
  }
 
  // data defined shape size units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::ShapeSizeUnits, exprVal, context.expressionContext() );
 
  // data defined shape rotation type?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::ShapeRotationType ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::ShapeRotationType, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString rotstr = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal ShapeRotationType:%1" ).arg( rotstr ), 4 );
 
      if ( !rotstr.isEmpty() )
      {
        // "Sync"
        QgsTextBackgroundSettings::RotationType rottype = QgsTextRendererUtils::decodeBackgroundRotationType( rotstr );
        dataDefinedValues.insert( QgsPalLayerSettings::ShapeRotationType, QVariant( static_cast< int >( rottype ) ) );
      }
    }
  }
 
  // data defined shape rotation?
  dataDefinedValEval( DDRotation180, QgsPalLayerSettings::ShapeRotation, exprVal, context.expressionContext(), background.rotation() );
 
  // data defined shape offset?
  dataDefinedValEval( DDPointF, QgsPalLayerSettings::ShapeOffset, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodePoint( background.offset() ) );
 
  // data defined shape offset units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::ShapeOffsetUnits, exprVal, context.expressionContext() );
 
  // data defined shape radii?
  dataDefinedValEval( DDSizeF, QgsPalLayerSettings::ShapeRadii, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodeSize( background.radii() ) );
 
  // data defined shape radii units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::ShapeRadiiUnits, exprVal, context.expressionContext() );
 
  // data defined shape blend mode?
  dataDefinedValEval( DDBlendMode, QgsPalLayerSettings::ShapeBlendMode, exprVal, context.expressionContext() );
 
  // data defined shape fill color?
  dataDefinedValEval( DDColor, QgsPalLayerSettings::ShapeFillColor, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodeColor( background.fillColor() ) );
 
  // data defined shape stroke color?
  dataDefinedValEval( DDColor, QgsPalLayerSettings::ShapeStrokeColor, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodeColor( background.strokeColor() ) );
 
  // data defined shape stroke width?
  dataDefinedValEval( DDDoublePos, QgsPalLayerSettings::ShapeStrokeWidth, exprVal, context.expressionContext(), background.strokeWidth() );
 
  // data defined shape stroke width units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::ShapeStrokeWidthUnits, exprVal, context.expressionContext() );
 
  // data defined shape join style?
  dataDefinedValEval( DDJoinStyle, QgsPalLayerSettings::ShapeJoinStyle, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodePenJoinStyle( background.joinStyle() ) );
 
}
 
void QgsPalLayerSettings::parseDropShadow( QgsRenderContext &context )
{
  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
 
  QgsTextShadowSettings shadow = mFormat.shadow();
 
  // data defined draw shadow?
  bool drawShadow = shadow.enabled();
  if ( dataDefinedValEval( DDBool, QgsPalLayerSettings::ShadowDraw, exprVal, context.expressionContext(), drawShadow ) )
  {
    drawShadow = exprVal.toBool();
  }
 
  if ( !drawShadow )
  {
    return;
  }
 
  // data defined shadow transparency?
  double shadowOpacity = shadow.opacity() * 100;
  if ( dataDefinedValEval( DDOpacity, QgsPalLayerSettings::ShadowOpacity, exprVal, context.expressionContext(), shadowOpacity ) )
  {
    shadowOpacity = exprVal.toDouble();
  }
 
  // data defined shadow offset distance?
  double shadowOffDist = shadow.offsetDistance();
  if ( dataDefinedValEval( DDDoublePos, QgsPalLayerSettings::ShadowOffsetDist, exprVal, context.expressionContext(), shadowOffDist ) )
  {
    shadowOffDist = exprVal.toDouble();
  }
 
  // data defined shadow offset distance?
  double shadowRad = shadow.blurRadius();
  if ( dataDefinedValEval( DDDoublePos, QgsPalLayerSettings::ShadowRadius, exprVal, context.expressionContext(), shadowRad ) )
  {
    shadowRad = exprVal.toDouble();
  }
 
  drawShadow = ( drawShadow && shadowOpacity > 0 && !( shadowOffDist == 0.0 && shadowRad == 0.0 ) );
 
  if ( !drawShadow )
  {
    dataDefinedValues.insert( QgsPalLayerSettings::ShadowDraw, QVariant( false ) ); // trigger value
    dataDefinedValues.remove( QgsPalLayerSettings::ShadowOpacity );
    dataDefinedValues.remove( QgsPalLayerSettings::ShadowOffsetDist );
    dataDefinedValues.remove( QgsPalLayerSettings::ShadowRadius );
    return; // don't bother evaluating values that won't be used
  }
 
  // data defined shadow under type?
  if ( mDataDefinedProperties.isActive( QgsPalLayerSettings::ShadowUnder ) )
  {
    exprVal = mDataDefinedProperties.value( QgsPalLayerSettings::ShadowUnder, context.expressionContext() );
    if ( !QgsVariantUtils::isNull( exprVal ) )
    {
      QString str = exprVal.toString().trimmed();
      QgsDebugMsgLevel( QStringLiteral( "exprVal ShadowUnder:%1" ).arg( str ), 4 );
 
      if ( !str.isEmpty() )
      {
        QgsTextShadowSettings::ShadowPlacement shdwtype = QgsTextRendererUtils::decodeShadowPlacementType( str );
        dataDefinedValues.insert( QgsPalLayerSettings::ShadowUnder, QVariant( static_cast< int >( shdwtype ) ) );
      }
    }
  }
 
  // data defined shadow offset angle?
  dataDefinedValEval( DDRotation180, QgsPalLayerSettings::ShadowOffsetAngle, exprVal, context.expressionContext(), shadow.offsetAngle() );
 
  // data defined shadow offset units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::ShadowOffsetUnits, exprVal, context.expressionContext() );
 
  // data defined shadow radius?
  dataDefinedValEval( DDDouble, QgsPalLayerSettings::ShadowRadius, exprVal, context.expressionContext(), shadow.blurRadius() );
 
  // data defined shadow radius units?
  dataDefinedValEval( DDUnits, QgsPalLayerSettings::ShadowRadiusUnits, exprVal, context.expressionContext() );
 
  // data defined shadow scale?  ( gui bounds to 0-2000, no upper bound here )
  dataDefinedValEval( DDIntPos, QgsPalLayerSettings::ShadowScale, exprVal, context.expressionContext(), shadow.scale() );
 
  // data defined shadow color?
  dataDefinedValEval( DDColor, QgsPalLayerSettings::ShadowColor, exprVal, context.expressionContext(), QgsSymbolLayerUtils::encodeColor( shadow.color() ) );
 
  // data defined shadow blend mode?
  dataDefinedValEval( DDBlendMode, QgsPalLayerSettings::ShadowBlendMode, exprVal, context.expressionContext() );
}
 
// -------------
 
 
bool QgsPalLabeling::staticWillUseLayer( const QgsMapLayer *layer )
{
  switch ( layer->type() )
  {
    case Qgis::LayerType::Vector:
    {
      const QgsVectorLayer *vl = qobject_cast< const QgsVectorLayer * >( layer );
      return vl->labelsEnabled() || vl->diagramsEnabled();
    }
 
    case Qgis::LayerType::VectorTile:
    {
      const QgsVectorTileLayer *vl = qobject_cast< const QgsVectorTileLayer * >( layer );
      if ( !vl->labeling() )
        return false;
 
      if ( const QgsVectorTileBasicLabeling *labeling = dynamic_cast< const QgsVectorTileBasicLabeling *>( vl->labeling() ) )
        return !labeling->styles().empty();
 
      return false;
    }
 
    case Qgis::LayerType::Raster:
    case Qgis::LayerType::Plugin:
    case Qgis::LayerType::Mesh:
    case Qgis::LayerType::PointCloud:
    case Qgis::LayerType::Annotation:
    case Qgis::LayerType::Group:
    case Qgis::LayerType::TiledScene:
      return false;
  }
  return false;
}
 
 
bool QgsPalLabeling::geometryRequiresPreparation( const QgsGeometry &geometry, QgsRenderContext &context, const QgsCoordinateTransform &ct, const QgsGeometry &clipGeometry, bool mergeLines )
{
  if ( geometry.isNull() )
  {
    return false;
  }
 
  if ( geometry.type() == Qgis::GeometryType::Line && geometry.isMultipart() && mergeLines )
  {
    return true;
  }
 
  //requires reprojection
  if ( ct.isValid() && !ct.isShortCircuited() )
    return true;
 
  //requires rotation
  const QgsMapToPixel &m2p = context.mapToPixel();
  if ( !qgsDoubleNear( m2p.mapRotation(), 0 ) )
    return true;
 
  //requires clip
  if ( !clipGeometry.isNull() && !clipGeometry.boundingBox().contains( geometry.boundingBox() ) )
    return true;
 
  //requires fixing
  if ( geometry.type() == Qgis::GeometryType::Polygon && !geometry.isGeosValid() )
    return true;
 
  return false;
}
 
QStringList QgsPalLabeling::splitToLines( const QString &text, const QString &wrapCharacter, const int autoWrapLength, const bool useMaxLineLengthWhenAutoWrapping )
{
  QStringList multiLineSplit;
  if ( !wrapCharacter.isEmpty() && wrapCharacter != QLatin1String( "\n" ) )
  {
    //wrap on both the wrapchr and new line characters
    const QStringList lines = text.split( wrapCharacter );
    for ( const QString &line : lines )
    {
      multiLineSplit.append( line.split( '\n' ) );
    }
  }
  else
  {
    multiLineSplit = text.split( '\n' );
  }
 
  // apply auto wrapping to each manually created line
  if ( autoWrapLength != 0 )
  {
    QStringList autoWrappedLines;
    autoWrappedLines.reserve( multiLineSplit.count() );
    for ( const QString &line : std::as_const( multiLineSplit ) )
    {
      autoWrappedLines.append( QgsStringUtils::wordWrap( line, autoWrapLength, useMaxLineLengthWhenAutoWrapping ).split( '\n' ) );
    }
    multiLineSplit = autoWrappedLines;
  }
  return multiLineSplit;
}
 
QStringList QgsPalLabeling::splitToGraphemes( const QString &text )
{
  QStringList graphemes;
  QTextBoundaryFinder boundaryFinder( QTextBoundaryFinder::Grapheme, text );
  int currentBoundary = -1;
  int previousBoundary = 0;
  while ( ( currentBoundary = boundaryFinder.toNextBoundary() ) > 0 )
  {
    graphemes << text.mid( previousBoundary, currentBoundary - previousBoundary );
    previousBoundary = currentBoundary;
  }
  return graphemes;
}
 
QgsGeometry QgsPalLabeling::prepareGeometry( const QgsGeometry &geometry, QgsRenderContext &context, const QgsCoordinateTransform &ct, const QgsGeometry &clipGeometry, bool mergeLines )
{
  if ( geometry.isNull() )
  {
    return QgsGeometry();
  }
 
  //don't modify the feature's geometry so that geometry based expressions keep working
  QgsGeometry geom = geometry;
 
  if ( geom.type() == Qgis::GeometryType::Line && geom.isMultipart() && mergeLines )
  {
    geom = geom.mergeLines();
  }
 
  //reproject the geometry if necessary
  if ( ct.isValid() && !ct.isShortCircuited() )
  {
    try
    {
      geom.transform( ct );
    }
    catch ( QgsCsException &cse )
    {
      Q_UNUSED( cse )
      QgsDebugMsgLevel( QStringLiteral( "Ignoring feature due to transformation exception" ), 4 );
      return QgsGeometry();
    }
    // geometry transforms may result in nan points, remove these
    geom.filterVertices( []( const QgsPoint & point )->bool
    {
      return std::isfinite( point.x() ) && std::isfinite( point.y() );
    } );
    if ( QgsCurvePolygon *cp = qgsgeometry_cast< QgsCurvePolygon * >( geom.get() ) )
    {
      cp->removeInvalidRings();
    }
    else if ( QgsMultiSurface *ms = qgsgeometry_cast< QgsMultiSurface * >( geom.get() ) )
    {
      for ( int i = 0; i < ms->numGeometries(); ++i )
      {
        if ( QgsCurvePolygon *cp = qgsgeometry_cast< QgsCurvePolygon * >( ms->geometryN( i ) ) )
          cp->removeInvalidRings();
      }
    }
  }
 
  // Rotate the geometry if needed, before clipping
  const QgsMapToPixel &m2p = context.mapToPixel();
  if ( !qgsDoubleNear( m2p.mapRotation(), 0 ) )
  {
    QgsPointXY center = context.mapExtent().center();
    if ( geom.rotate( m2p.mapRotation(), center ) != Qgis::GeometryOperationResult::Success )
    {
      QgsDebugError( QStringLiteral( "Error rotating geometry" ).arg( geom.asWkt() ) );
      return QgsGeometry();
    }
  }
 
  const bool mustClip = ( !clipGeometry.isNull() &&
                          ( ( qgsDoubleNear( m2p.mapRotation(), 0 ) && !clipGeometry.boundingBox().contains( geom.boundingBox() ) )
                            || ( !qgsDoubleNear( m2p.mapRotation(), 0 ) && !clipGeometry.contains( geom ) ) ) );
 
  bool mustClipExact = false;
  if ( mustClip )
  {
    // nice and fast, but can result in invalid geometries. At least it will potentially strip out a bunch of unwanted vertices upfront!
    QgsGeometry clipGeom = geom.clipped( clipGeometry.boundingBox() );
    if ( clipGeom.isEmpty() )
      return QgsGeometry();
 
    geom = clipGeom;
 
    // we've now clipped against the BOUNDING BOX of clipGeometry. But if clipGeometry is an axis parallel rectangle, then there's no
    // need to do an exact (potentially costly) intersection clip as well!
    mustClipExact = !clipGeometry.isAxisParallelRectangle( 0.001 );
  }
 
  // fix invalid polygons
  if ( geom.type() == Qgis::GeometryType::Polygon )
  {
    if ( geom.isMultipart() )
    {
      // important -- we need to treat ever part in isolation here. We can't test the validity of the whole geometry
      // at once, because touching parts would result in an invalid geometry, and buffering this "dissolves" the parts.
      // because the actual label engine treats parts as separate entities, we aren't bound by the usual "touching parts are invalid" rule
      // see https://github.com/qgis/QGIS/issues/26763
      QVector< QgsGeometry> parts;
      parts.reserve( qgsgeometry_cast< const QgsGeometryCollection * >( geom.constGet() )->numGeometries() );
      for ( auto it = geom.const_parts_begin(); it != geom.const_parts_end(); ++it )
      {
        QgsGeometry partGeom( ( *it )->clone() );
        if ( !partGeom.isGeosValid() )
        {
 
          partGeom = partGeom.makeValid();
        }
        parts.append( partGeom );
      }
      geom = QgsGeometry::collectGeometry( parts );
    }
    else if ( !geom.isGeosValid() )
    {
 
      QgsGeometry bufferGeom = geom.makeValid();
      if ( bufferGeom.isNull() )
      {
        QgsDebugError( QStringLiteral( "Could not repair geometry: %1" ).arg( bufferGeom.lastError() ) );
        return QgsGeometry();
      }
      geom = bufferGeom;
    }
  }
 
  if ( mustClipExact )
  {
    // now do the real intersection against the actual clip geometry
    QgsGeometry clipGeom = geom.intersection( clipGeometry );
    if ( clipGeom.isEmpty() )
    {
      return QgsGeometry();
    }
    geom = clipGeom;
  }
 
  return geom;
}
 
bool QgsPalLabeling::checkMinimumSizeMM( const QgsRenderContext &context, const QgsGeometry &geom, double minSize )
{
  if ( minSize <= 0 )
  {
    return true;
  }
 
  if ( geom.isNull() )
  {
    return false;
  }
 
  Qgis::GeometryType featureType = geom.type();
  if ( featureType == Qgis::GeometryType::Point ) //minimum size does not apply to point features
  {
    return true;
  }
 
  double mapUnitsPerMM = context.mapToPixel().mapUnitsPerPixel() * context.scaleFactor();
  if ( featureType == Qgis::GeometryType::Line )
  {
    double length = geom.length();
    if ( length >= 0.0 )
    {
      return ( length >= ( minSize * mapUnitsPerMM ) );
    }
  }
  else if ( featureType == Qgis::GeometryType::Polygon )
  {
    double area = geom.area();
    if ( area >= 0.0 )
    {
      return ( std::sqrt( area ) >= ( minSize * mapUnitsPerMM ) );
    }
  }
  return true; //should never be reached. Return true in this case to label such geometries anyway.
}
 
 
void QgsPalLabeling::dataDefinedTextStyle( QgsPalLayerSettings &tmpLyr,
    const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues )
{
  QgsTextFormat format = tmpLyr.format();
  bool changed = false;
 
  //font color
  if ( ddValues.contains( QgsPalLayerSettings::Color ) )
  {
    QVariant ddColor = ddValues.value( QgsPalLayerSettings::Color );
    format.setColor( ddColor.value<QColor>() );
    changed = true;
  }
 
  //font transparency
  if ( ddValues.contains( QgsPalLayerSettings::FontOpacity ) )
  {
    format.setOpacity( ddValues.value( QgsPalLayerSettings::FontOpacity ).toDouble() / 100.0 );
    changed = true;
  }
 
  //font blend mode
  if ( ddValues.contains( QgsPalLayerSettings::FontBlendMode ) )
  {
    format.setBlendMode( static_cast< QPainter::CompositionMode >( ddValues.value( QgsPalLayerSettings::FontBlendMode ).toInt() ) );
    changed = true;
  }
 
  if ( changed )
  {
    tmpLyr.setFormat( format );
  }
}
 
void QgsPalLabeling::dataDefinedTextFormatting( QgsPalLayerSettings &tmpLyr,
    const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues )
{
  if ( ddValues.contains( QgsPalLayerSettings::MultiLineWrapChar ) )
  {
    tmpLyr.wrapChar = ddValues.value( QgsPalLayerSettings::MultiLineWrapChar ).toString();
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::AutoWrapLength ) )
  {
    tmpLyr.autoWrapLength = ddValues.value( QgsPalLayerSettings::AutoWrapLength ).toInt();
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::MultiLineHeight ) )
  {
    QgsTextFormat format = tmpLyr.format();
    format.setLineHeight( ddValues.value( QgsPalLayerSettings::MultiLineHeight ).toDouble() );
    tmpLyr.setFormat( format );
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::MultiLineAlignment ) )
  {
    tmpLyr.multilineAlign = static_cast< Qgis::LabelMultiLineAlignment >( ddValues.value( QgsPalLayerSettings::MultiLineAlignment ).toInt() );
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::TextOrientation ) )
  {
    QgsTextFormat format = tmpLyr.format();
    format.setOrientation( QgsTextRendererUtils::decodeTextOrientation( ddValues.value( QgsPalLayerSettings::TextOrientation ).toString() ) );
    tmpLyr.setFormat( format );
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::DirSymbDraw ) )
  {
    tmpLyr.lineSettings().setAddDirectionSymbol( ddValues.value( QgsPalLayerSettings::DirSymbDraw ).toBool() );
  }
 
  if ( tmpLyr.lineSettings().addDirectionSymbol() )
  {
 
    if ( ddValues.contains( QgsPalLayerSettings::DirSymbLeft ) )
    {
      tmpLyr.lineSettings().setLeftDirectionSymbol( ddValues.value( QgsPalLayerSettings::DirSymbLeft ).toString() );
    }
    if ( ddValues.contains( QgsPalLayerSettings::DirSymbRight ) )
    {
      tmpLyr.lineSettings().setRightDirectionSymbol( ddValues.value( QgsPalLayerSettings::DirSymbRight ).toString() );
    }
 
    if ( ddValues.contains( QgsPalLayerSettings::DirSymbPlacement ) )
    {
      tmpLyr.lineSettings().setDirectionSymbolPlacement( static_cast< QgsLabelLineSettings::DirectionSymbolPlacement >( ddValues.value( QgsPalLayerSettings::DirSymbPlacement ).toInt() ) );
    }
 
    if ( ddValues.contains( QgsPalLayerSettings::DirSymbReverse ) )
    {
      tmpLyr.lineSettings().setReverseDirectionSymbol( ddValues.value( QgsPalLayerSettings::DirSymbReverse ).toBool() );
    }
 
  }
}
 
void QgsPalLabeling::dataDefinedTextBuffer( QgsPalLayerSettings &tmpLyr,
    const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues )
{
  QgsTextBufferSettings buffer = tmpLyr.format().buffer();
  bool changed = false;
 
  //buffer draw
  if ( ddValues.contains( QgsPalLayerSettings::BufferDraw ) )
  {
    buffer.setEnabled( ddValues.value( QgsPalLayerSettings::BufferDraw ).toBool() );
    changed = true;
  }
 
  if ( !buffer.enabled() )
  {
    if ( changed )
    {
      QgsTextFormat format = tmpLyr.format();
      format.setBuffer( buffer );
      tmpLyr.setFormat( format );
    }
 
    // tmpLyr.bufferSize > 0.0 && tmpLyr.bufferTransp < 100 figured in during evaluation
    return; // don't continue looking for unused values
  }
 
  //buffer size
  if ( ddValues.contains( QgsPalLayerSettings::BufferSize ) )
  {
    buffer.setSize( ddValues.value( QgsPalLayerSettings::BufferSize ).toDouble() );
    changed = true;
  }
 
  //buffer opacity
  if ( ddValues.contains( QgsPalLayerSettings::BufferOpacity ) )
  {
    buffer.setOpacity( ddValues.value( QgsPalLayerSettings::BufferOpacity ).toDouble() / 100.0 );
    changed = true;
  }
 
  //buffer size units
  if ( ddValues.contains( QgsPalLayerSettings::BufferUnit ) )
  {
    Qgis::RenderUnit bufunit = static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::BufferUnit ).toInt() );
    buffer.setSizeUnit( bufunit );
    changed = true;
  }
 
  //buffer color
  if ( ddValues.contains( QgsPalLayerSettings::BufferColor ) )
  {
    QVariant ddColor = ddValues.value( QgsPalLayerSettings::BufferColor );
    buffer.setColor( ddColor.value<QColor>() );
    changed = true;
  }
 
  //buffer pen join style
  if ( ddValues.contains( QgsPalLayerSettings::BufferJoinStyle ) )
  {
    buffer.setJoinStyle( static_cast< Qt::PenJoinStyle >( ddValues.value( QgsPalLayerSettings::BufferJoinStyle ).toInt() ) );
    changed = true;
  }
 
  //buffer blend mode
  if ( ddValues.contains( QgsPalLayerSettings::BufferBlendMode ) )
  {
    buffer.setBlendMode( static_cast< QPainter::CompositionMode >( ddValues.value( QgsPalLayerSettings::BufferBlendMode ).toInt() ) );
    changed = true;
  }
 
  if ( changed )
  {
    QgsTextFormat format = tmpLyr.format();
    format.setBuffer( buffer );
    tmpLyr.setFormat( format );
  }
}
 
void QgsPalLabeling::dataDefinedTextMask( QgsPalLayerSettings &tmpLyr,
    const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues )
{
  if ( ddValues.isEmpty() )
    return;
 
  QgsTextMaskSettings mask = tmpLyr.format().mask();
  bool changed = false;
 
  // enabled ?
  if ( ddValues.contains( QgsPalLayerSettings::MaskEnabled ) )
  {
    mask.setEnabled( ddValues.value( QgsPalLayerSettings::MaskEnabled ).toBool() );
    changed = true;
  }
 
  if ( !mask.enabled() )
  {
    if ( changed )
    {
      QgsTextFormat format = tmpLyr.format();
      format.setMask( mask );
      tmpLyr.setFormat( format );
    }
 
    // tmpLyr.bufferSize > 0.0 && tmpLyr.bufferTransp < 100 figured in during evaluation
    return; // don't continue looking for unused values
  }
 
  // buffer size
  if ( ddValues.contains( QgsPalLayerSettings::MaskBufferSize ) )
  {
    mask.setSize( ddValues.value( QgsPalLayerSettings::MaskBufferSize ).toDouble() );
    changed = true;
  }
 
  // opacity
  if ( ddValues.contains( QgsPalLayerSettings::MaskOpacity ) )
  {
    mask.setOpacity( ddValues.value( QgsPalLayerSettings::MaskOpacity ).toDouble() / 100.0 );
    changed = true;
  }
 
  // buffer size units
  if ( ddValues.contains( QgsPalLayerSettings::MaskBufferUnit ) )
  {
    Qgis::RenderUnit bufunit = static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::MaskBufferUnit ).toInt() );
    mask.setSizeUnit( bufunit );
    changed = true;
  }
 
  // pen join style
  if ( ddValues.contains( QgsPalLayerSettings::MaskJoinStyle ) )
  {
    mask.setJoinStyle( static_cast< Qt::PenJoinStyle >( ddValues.value( QgsPalLayerSettings::MaskJoinStyle ).toInt() ) );
    changed = true;
  }
 
  if ( changed )
  {
    QgsTextFormat format = tmpLyr.format();
    format.setMask( mask );
    tmpLyr.setFormat( format );
  }
}
 
void QgsPalLabeling::dataDefinedShapeBackground( QgsPalLayerSettings &tmpLyr,
    const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues )
{
  QgsTextBackgroundSettings background = tmpLyr.format().background();
  bool changed = false;
 
  //shape draw
  if ( ddValues.contains( QgsPalLayerSettings::ShapeDraw ) )
  {
    background.setEnabled( ddValues.value( QgsPalLayerSettings::ShapeDraw ).toBool() );
    changed = true;
  }
 
  if ( !background.enabled() )
  {
    if ( changed )
    {
      QgsTextFormat format = tmpLyr.format();
      format.setBackground( background );
      tmpLyr.setFormat( format );
    }
    return; // don't continue looking for unused values
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeKind ) )
  {
    background.setType( static_cast< QgsTextBackgroundSettings::ShapeType >( ddValues.value( QgsPalLayerSettings::ShapeKind ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeSVGFile ) )
  {
    background.setSvgFile( ddValues.value( QgsPalLayerSettings::ShapeSVGFile ).toString() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeType ) )
  {
    background.setSizeType( static_cast< QgsTextBackgroundSettings::SizeType >( ddValues.value( QgsPalLayerSettings::ShapeSizeType ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeX ) )
  {
    QSizeF size = background.size();
    size.setWidth( ddValues.value( QgsPalLayerSettings::ShapeSizeX ).toDouble() );
    background.setSize( size );
    changed = true;
  }
  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeY ) )
  {
    QSizeF size = background.size();
    size.setHeight( ddValues.value( QgsPalLayerSettings::ShapeSizeY ).toDouble() );
    background.setSize( size );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeUnits ) )
  {
    background.setSizeUnit( static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::ShapeSizeUnits ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeRotationType ) )
  {
    background.setRotationType( static_cast< QgsTextBackgroundSettings::RotationType >( ddValues.value( QgsPalLayerSettings::ShapeRotationType ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeRotation ) )
  {
    background.setRotation( ddValues.value( QgsPalLayerSettings::ShapeRotation ).toDouble() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeOffset ) )
  {
    background.setOffset( ddValues.value( QgsPalLayerSettings::ShapeOffset ).toPointF() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeOffsetUnits ) )
  {
    background.setOffsetUnit( static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::ShapeOffsetUnits ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeRadii ) )
  {
    background.setRadii( ddValues.value( QgsPalLayerSettings::ShapeRadii ).toSizeF() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeRadiiUnits ) )
  {
    background.setRadiiUnit( static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::ShapeRadiiUnits ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeBlendMode ) )
  {
    background.setBlendMode( static_cast< QPainter::CompositionMode >( ddValues.value( QgsPalLayerSettings::ShapeBlendMode ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeFillColor ) )
  {
    QVariant ddColor = ddValues.value( QgsPalLayerSettings::ShapeFillColor );
    background.setFillColor( ddColor.value<QColor>() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeStrokeColor ) )
  {
    QVariant ddColor = ddValues.value( QgsPalLayerSettings::ShapeStrokeColor );
    background.setStrokeColor( ddColor.value<QColor>() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeOpacity ) )
  {
    background.setOpacity( ddValues.value( QgsPalLayerSettings::ShapeOpacity ).toDouble() / 100.0 );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeStrokeWidth ) )
  {
    background.setStrokeWidth( ddValues.value( QgsPalLayerSettings::ShapeStrokeWidth ).toDouble() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeStrokeWidthUnits ) )
  {
    background.setStrokeWidthUnit( static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::ShapeStrokeWidthUnits ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShapeJoinStyle ) )
  {
    background.setJoinStyle( static_cast< Qt::PenJoinStyle >( ddValues.value( QgsPalLayerSettings::ShapeJoinStyle ).toInt() ) );
    changed = true;
  }
 
  if ( changed )
  {
    QgsTextFormat format = tmpLyr.format();
    format.setBackground( background );
    tmpLyr.setFormat( format );
  }
}
 
void QgsPalLabeling::dataDefinedDropShadow( QgsPalLayerSettings &tmpLyr,
    const QMap< QgsPalLayerSettings::Property, QVariant > &ddValues )
{
  QgsTextShadowSettings shadow = tmpLyr.format().shadow();
  bool changed = false;
 
  //shadow draw
  if ( ddValues.contains( QgsPalLayerSettings::ShadowDraw ) )
  {
    shadow.setEnabled( ddValues.value( QgsPalLayerSettings::ShadowDraw ).toBool() );
    changed = true;
  }
 
  if ( !shadow.enabled() )
  {
    if ( changed )
    {
      QgsTextFormat format = tmpLyr.format();
      format.setShadow( shadow );
      tmpLyr.setFormat( format );
    }
    return; // don't continue looking for unused values
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowUnder ) )
  {
    shadow.setShadowPlacement( static_cast< QgsTextShadowSettings::ShadowPlacement >( ddValues.value( QgsPalLayerSettings::ShadowUnder ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowOffsetAngle ) )
  {
    shadow.setOffsetAngle( ddValues.value( QgsPalLayerSettings::ShadowOffsetAngle ).toInt() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowOffsetDist ) )
  {
    shadow.setOffsetDistance( ddValues.value( QgsPalLayerSettings::ShadowOffsetDist ).toDouble() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowOffsetUnits ) )
  {
    shadow.setOffsetUnit( static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::ShadowOffsetUnits ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowRadius ) )
  {
    shadow.setBlurRadius( ddValues.value( QgsPalLayerSettings::ShadowRadius ).toDouble() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowRadiusUnits ) )
  {
    shadow.setBlurRadiusUnit( static_cast< Qgis::RenderUnit >( ddValues.value( QgsPalLayerSettings::ShadowRadiusUnits ).toInt() ) );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowColor ) )
  {
    QVariant ddColor = ddValues.value( QgsPalLayerSettings::ShadowColor );
    shadow.setColor( ddColor.value<QColor>() );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowOpacity ) )
  {
    shadow.setOpacity( ddValues.value( QgsPalLayerSettings::ShadowOpacity ).toDouble() / 100.0 );
    changed = true;
  }
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowScale ) )
  {
    shadow.setScale( ddValues.value( QgsPalLayerSettings::ShadowScale ).toInt() );
    changed = true;
  }
 
 
  if ( ddValues.contains( QgsPalLayerSettings::ShadowBlendMode ) )
  {
    shadow.setBlendMode( static_cast< QPainter::CompositionMode >( ddValues.value( QgsPalLayerSettings::ShadowBlendMode ).toInt() ) );
    changed = true;
  }
 
  if ( changed )
  {
    QgsTextFormat format = tmpLyr.format();
    format.setShadow( shadow );
    tmpLyr.setFormat( format );
  }
}
 
void QgsPalLabeling::drawLabelCandidateRect( pal::LabelPosition *lp, QPainter *painter, const QgsMapToPixel *xform, QList<QgsLabelCandidate> *candidates )
{
  QgsPointXY outPt = xform->transform( lp->getX(), lp->getY() );
 
  painter->save();
 
#if 0 // TODO: generalize some of this
  double w = lp->getWidth();
  double h = lp->getHeight();
  double cx = lp->getX() + w / 2.0;
  double cy = lp->getY() + h / 2.0;
  double scale = 1.0 / xform->mapUnitsPerPixel();
  double rotation = xform->mapRotation();
  double sw = w * scale;
  double sh = h * scale;
  QRectF rect( -sw / 2, -sh / 2, sw, sh );
 
  painter->translate( xform->transform( QPointF( cx, cy ) ).toQPointF() );
  if ( rotation )
  {
    // Only if not horizontal
    if ( lp->getFeaturePart()->getLayer()->getArrangement() != P_POINT &&
         lp->getFeaturePart()->getLayer()->getArrangement() != P_POINT_OVER &&
         lp->getFeaturePart()->getLayer()->getArrangement() != P_HORIZ )
    {
      painter->rotate( rotation );
    }
  }
  painter->translate( rect.bottomLeft() );
  painter->rotate( -lp->getAlpha() * 180 / M_PI );
  painter->translate( -rect.bottomLeft() );
#else
  QgsPointXY outPt2 = xform->transform( lp->getX() + lp->getWidth(), lp->getY() + lp->getHeight() );
  QRectF rect( 0, 0, outPt2.x() - outPt.x(), outPt2.y() - outPt.y() );
  painter->translate( QPointF( outPt.x(), outPt.y() ) );
  painter->rotate( -lp->getAlpha() * 180 / M_PI );
#endif
 
  if ( lp->conflictsWithObstacle() )
  {
    painter->setPen( QColor( 255, 0, 0, 64 ) );
  }
  else
  {
    painter->setPen( QColor( 0, 0, 0, 64 ) );
  }
  painter->drawRect( rect );
  painter->restore();
 
  // save the rect
  rect.moveTo( outPt.x(), outPt.y() );
  if ( candidates )
    candidates->append( QgsLabelCandidate( rect, lp->cost() * 1000 ) );
 
  // show all parts of the multipart label
  if ( lp->nextPart() )
    drawLabelCandidateRect( lp->nextPart(), painter, xform, candidates );
}