QGIS API Documentation  2.9.0-Master
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
qgspallabeling.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgspallabeling.cpp
3  Smart labeling for vector layers
4  -------------------
5  begin : June 2009
6  copyright : (C) Martin Dobias
7  email : wonder dot sk at gmail dot com
8 
9  ***************************************************************************
10  * *
11  * This program is free software; you can redistribute it and/or modify *
12  * it under the terms of the GNU General Public License as published by *
13  * the Free Software Foundation; either version 2 of the License, or *
14  * (at your option) any later version. *
15  * *
16  ***************************************************************************/
17 
18 #include "qgspallabeling.h"
19 #include "qgspalgeometry.h"
20 
21 #include <list>
22 
23 #include <pal/pal.h>
24 #include <pal/feature.h>
25 #include <pal/layer.h>
26 #include <pal/palgeometry.h>
27 #include <pal/palexception.h>
28 #include <pal/problem.h>
29 #include <pal/labelposition.h>
30 
31 #include <geos_c.h>
32 
33 #include <cmath>
34 
35 #include <QApplication>
36 #include <QByteArray>
37 #include <QString>
38 #include <QFontMetrics>
39 #include <QTime>
40 #include <QPainter>
41 
42 #include "diagram/qgsdiagram.h"
43 #include "qgsdiagramrendererv2.h"
44 #include "qgsfontutils.h"
45 #include "qgslabelsearchtree.h"
46 #include "qgsexpression.h"
47 #include "qgsdatadefined.h"
48 
49 #include <qgslogger.h>
50 #include <qgsvectorlayer.h>
51 #include <qgsmaplayerregistry.h>
52 #include <qgsvectordataprovider.h>
53 #include <qgsgeometry.h>
54 #include <qgsmaprenderer.h>
55 #include <qgsmarkersymbollayerv2.h>
56 #include <qgsproject.h>
57 #include "qgssymbolv2.h"
58 #include "qgssymbollayerv2utils.h"
59 #include <QMessageBox>
60 
61 
62 Q_GUI_EXPORT extern int qt_defaultDpiX();
63 Q_GUI_EXPORT extern int qt_defaultDpiY();
64 
65 static void _fixQPictureDPI( QPainter* p )
66 {
67  // QPicture makes an assumption that we drawing to it with system DPI.
68  // Then when being drawn, it scales the painter. The following call
69  // negates the effect. There is no way of setting QPicture's DPI.
70  // See QTBUG-20361
71  p->scale(( double )qt_defaultDpiX() / p->device()->logicalDpiX(),
72  ( double )qt_defaultDpiY() / p->device()->logicalDpiY() );
73 }
74 
75 
76 using namespace pal;
77 
78 // -------------
79 
81  : upsidedownLabels( Upright )
82  , palLayer( NULL )
83  , mCurFeat( 0 )
84  , mCurFields( 0 )
85  , xform( NULL )
86  , ct( NULL )
87  , extentGeom( NULL )
88  , mFeaturesToLabel( 0 )
89  , mFeatsSendingToPal( 0 )
90  , mFeatsRegPal( 0 )
91  , expression( 0 )
92 {
93  enabled = false;
94  isExpression = false;
95  fieldIndex = 0;
96 
97  // text style
98  textFont = QApplication::font();
99  textNamedStyle = QString( "" );
100  fontSizeInMapUnits = false;
101  textColor = Qt::black;
102  textTransp = 0;
103  blendMode = QPainter::CompositionMode_SourceOver;
104  previewBkgrdColor = Qt::white;
105  // font processing info
106  mTextFontFound = true;
107  mTextFontFamily = QApplication::font().family();
108 
109  // text formatting
110  wrapChar = "";
111  multilineHeight = 1.0;
113  addDirectionSymbol = false;
114  leftDirectionSymbol = QString( "<" );
115  rightDirectionSymbol = QString( ">" );
116  reverseDirectionSymbol = false;
118  formatNumbers = false;
119  decimals = 3;
120  plusSign = false;
121 
122  // text buffer
123  bufferDraw = false;
124  bufferSize = 1.0;
125  bufferSizeInMapUnits = false;
126  bufferColor = Qt::white;
127  bufferTransp = 0;
128  bufferNoFill = false;
129  bufferJoinStyle = Qt::BevelJoin;
130  bufferBlendMode = QPainter::CompositionMode_SourceOver;
131 
132  // shape background
133  shapeDraw = false;
135  shapeSVGFile = QString();
137  shapeSize = QPointF( 0.0, 0.0 );
138  shapeSizeUnits = MM;
140  shapeRotation = 0.0;
141  shapeOffset = QPointF( 0.0, 0.0 );
143  shapeRadii = QPointF( 0.0, 0.0 );
145  shapeFillColor = Qt::white;
146  shapeBorderColor = Qt::darkGray;
147  shapeBorderWidth = 0.0;
149  shapeJoinStyle = Qt::BevelJoin;
150  shapeTransparency = 0;
151  shapeBlendMode = QPainter::CompositionMode_SourceOver;
152 
153  // drop shadow
154  shadowDraw = false;
156  shadowOffsetAngle = 135;
157  shadowOffsetDist = 1.0;
159  shadowOffsetGlobal = true;
160  shadowRadius = 1.5;
162  shadowRadiusAlphaOnly = false;
163  shadowTransparency = 30;
164  shadowScale = 100;
165  shadowColor = Qt::black;
166  shadowBlendMode = QPainter::CompositionMode_Multiply;
167 
168  // placement
170  placementFlags = 0;
171  centroidWhole = false;
172  centroidInside = false;
174  xOffset = 0;
175  yOffset = 0;
176  labelOffsetInMapUnits = true;
177  dist = 0;
178  distInMapUnits = false;
179  angleOffset = 0;
180  preserveRotation = true;
181  maxCurvedCharAngleIn = 20.0;
182  maxCurvedCharAngleOut = -20.0;
183  priority = 5;
184  repeatDistance = 0;
186 
187  // rendering
188  scaleVisibility = false;
189  scaleMin = 1;
190  scaleMax = 10000000;
191  fontLimitPixelSize = false;
192  fontMinPixelSize = 0; //trigger to turn it on by default for map unit labels
193  fontMaxPixelSize = 10000;
194  displayAll = false;
196 
197  labelPerPart = false;
198  mergeLines = false;
199  minFeatureSize = 0.0;
200  limitNumLabels = false;
201  maxNumLabels = 2000;
202  obstacle = true;
203 
204  // scale factors
205  vectorScaleFactor = 1.0;
206  rasterCompressFactor = 1.0;
207 
208  // data defined string and old-style index values
209  // NOTE: in QPair use -1 for second value (other values are for old-style layer properties migration)
210 
211  // text style
212  mDataDefinedNames.insert( Size, QPair<QString, int>( "Size", 0 ) );
213  mDataDefinedNames.insert( Bold, QPair<QString, int>( "Bold", 1 ) );
214  mDataDefinedNames.insert( Italic, QPair<QString, int>( "Italic", 2 ) );
215  mDataDefinedNames.insert( Underline, QPair<QString, int>( "Underline", 3 ) );
216  mDataDefinedNames.insert( Color, QPair<QString, int>( "Color", 4 ) );
217  mDataDefinedNames.insert( Strikeout, QPair<QString, int>( "Strikeout", 5 ) );
218  mDataDefinedNames.insert( Family, QPair<QString, int>( "Family", 6 ) );
219  mDataDefinedNames.insert( FontStyle, QPair<QString, int>( "FontStyle", -1 ) );
220  mDataDefinedNames.insert( FontSizeUnit, QPair<QString, int>( "FontSizeUnit", -1 ) );
221  mDataDefinedNames.insert( FontTransp, QPair<QString, int>( "FontTransp", 18 ) );
222  mDataDefinedNames.insert( FontCase, QPair<QString, int>( "FontCase", -1 ) );
223  mDataDefinedNames.insert( FontLetterSpacing, QPair<QString, int>( "FontLetterSpacing", -1 ) );
224  mDataDefinedNames.insert( FontWordSpacing, QPair<QString, int>( "FontWordSpacing", -1 ) );
225  mDataDefinedNames.insert( FontBlendMode, QPair<QString, int>( "FontBlendMode", -1 ) );
226 
227  // text formatting
228  mDataDefinedNames.insert( MultiLineWrapChar, QPair<QString, int>( "MultiLineWrapChar", -1 ) );
229  mDataDefinedNames.insert( MultiLineHeight, QPair<QString, int>( "MultiLineHeight", -1 ) );
230  mDataDefinedNames.insert( MultiLineAlignment, QPair<QString, int>( "MultiLineAlignment", -1 ) );
231  mDataDefinedNames.insert( DirSymbDraw, QPair<QString, int>( "DirSymbDraw", -1 ) );
232  mDataDefinedNames.insert( DirSymbLeft, QPair<QString, int>( "DirSymbLeft", -1 ) );
233  mDataDefinedNames.insert( DirSymbRight, QPair<QString, int>( "DirSymbRight", -1 ) );
234  mDataDefinedNames.insert( DirSymbPlacement, QPair<QString, int>( "DirSymbPlacement", -1 ) );
235  mDataDefinedNames.insert( DirSymbReverse, QPair<QString, int>( "DirSymbReverse", -1 ) );
236  mDataDefinedNames.insert( NumFormat, QPair<QString, int>( "NumFormat", -1 ) );
237  mDataDefinedNames.insert( NumDecimals, QPair<QString, int>( "NumDecimals", -1 ) );
238  mDataDefinedNames.insert( NumPlusSign, QPair<QString, int>( "NumPlusSign", -1 ) );
239 
240  // text buffer
241  mDataDefinedNames.insert( BufferDraw, QPair<QString, int>( "BufferDraw", -1 ) );
242  mDataDefinedNames.insert( BufferSize, QPair<QString, int>( "BufferSize", 7 ) );
243  mDataDefinedNames.insert( BufferUnit, QPair<QString, int>( "BufferUnit", -1 ) );
244  mDataDefinedNames.insert( BufferColor, QPair<QString, int>( "BufferColor", 8 ) );
245  mDataDefinedNames.insert( BufferTransp, QPair<QString, int>( "BufferTransp", 19 ) );
246  mDataDefinedNames.insert( BufferJoinStyle, QPair<QString, int>( "BufferJoinStyle", -1 ) );
247  mDataDefinedNames.insert( BufferBlendMode, QPair<QString, int>( "BufferBlendMode", -1 ) );
248 
249  // background
250  mDataDefinedNames.insert( ShapeDraw, QPair<QString, int>( "ShapeDraw", -1 ) );
251  mDataDefinedNames.insert( ShapeKind, QPair<QString, int>( "ShapeKind", -1 ) );
252  mDataDefinedNames.insert( ShapeSVGFile, QPair<QString, int>( "ShapeSVGFile", -1 ) );
253  mDataDefinedNames.insert( ShapeSizeType, QPair<QString, int>( "ShapeSizeType", -1 ) );
254  mDataDefinedNames.insert( ShapeSizeX, QPair<QString, int>( "ShapeSizeX", -1 ) );
255  mDataDefinedNames.insert( ShapeSizeY, QPair<QString, int>( "ShapeSizeY", -1 ) );
256  mDataDefinedNames.insert( ShapeSizeUnits, QPair<QString, int>( "ShapeSizeUnits", -1 ) );
257  mDataDefinedNames.insert( ShapeRotationType, QPair<QString, int>( "ShapeRotationType", -1 ) );
258  mDataDefinedNames.insert( ShapeRotation, QPair<QString, int>( "ShapeRotation", -1 ) );
259  mDataDefinedNames.insert( ShapeOffset, QPair<QString, int>( "ShapeOffset", -1 ) );
260  mDataDefinedNames.insert( ShapeOffsetUnits, QPair<QString, int>( "ShapeOffsetUnits", -1 ) );
261  mDataDefinedNames.insert( ShapeRadii, QPair<QString, int>( "ShapeRadii", -1 ) );
262  mDataDefinedNames.insert( ShapeRadiiUnits, QPair<QString, int>( "ShapeRadiiUnits", -1 ) );
263  mDataDefinedNames.insert( ShapeTransparency, QPair<QString, int>( "ShapeTransparency", -1 ) );
264  mDataDefinedNames.insert( ShapeBlendMode, QPair<QString, int>( "ShapeBlendMode", -1 ) );
265  mDataDefinedNames.insert( ShapeFillColor, QPair<QString, int>( "ShapeFillColor", -1 ) );
266  mDataDefinedNames.insert( ShapeBorderColor, QPair<QString, int>( "ShapeBorderColor", -1 ) );
267  mDataDefinedNames.insert( ShapeBorderWidth, QPair<QString, int>( "ShapeBorderWidth", -1 ) );
268  mDataDefinedNames.insert( ShapeBorderWidthUnits, QPair<QString, int>( "ShapeBorderWidthUnits", -1 ) );
269  mDataDefinedNames.insert( ShapeJoinStyle, QPair<QString, int>( "ShapeJoinStyle", -1 ) );
270 
271  // drop shadow
272  mDataDefinedNames.insert( ShadowDraw, QPair<QString, int>( "ShadowDraw", -1 ) );
273  mDataDefinedNames.insert( ShadowUnder, QPair<QString, int>( "ShadowUnder", -1 ) );
274  mDataDefinedNames.insert( ShadowOffsetAngle, QPair<QString, int>( "ShadowOffsetAngle", -1 ) );
275  mDataDefinedNames.insert( ShadowOffsetDist, QPair<QString, int>( "ShadowOffsetDist", -1 ) );
276  mDataDefinedNames.insert( ShadowOffsetUnits, QPair<QString, int>( "ShadowOffsetUnits", -1 ) );
277  mDataDefinedNames.insert( ShadowRadius, QPair<QString, int>( "ShadowRadius", -1 ) );
278  mDataDefinedNames.insert( ShadowRadiusUnits, QPair<QString, int>( "ShadowRadiusUnits", -1 ) );
279  mDataDefinedNames.insert( ShadowTransparency, QPair<QString, int>( "ShadowTransparency", -1 ) );
280  mDataDefinedNames.insert( ShadowScale, QPair<QString, int>( "ShadowScale", -1 ) );
281  mDataDefinedNames.insert( ShadowColor, QPair<QString, int>( "ShadowColor", -1 ) );
282  mDataDefinedNames.insert( ShadowBlendMode, QPair<QString, int>( "ShadowBlendMode", -1 ) );
283 
284  // placement
285  mDataDefinedNames.insert( CentroidWhole, QPair<QString, int>( "CentroidWhole", -1 ) );
286  mDataDefinedNames.insert( OffsetQuad, QPair<QString, int>( "OffsetQuad", -1 ) );
287  mDataDefinedNames.insert( OffsetXY, QPair<QString, int>( "OffsetXY", -1 ) );
288  mDataDefinedNames.insert( OffsetUnits, QPair<QString, int>( "OffsetUnits", -1 ) );
289  mDataDefinedNames.insert( LabelDistance, QPair<QString, int>( "LabelDistance", 13 ) );
290  mDataDefinedNames.insert( DistanceUnits, QPair<QString, int>( "DistanceUnits", -1 ) );
291  mDataDefinedNames.insert( OffsetRotation, QPair<QString, int>( "OffsetRotation", -1 ) );
292  mDataDefinedNames.insert( CurvedCharAngleInOut, QPair<QString, int>( "CurvedCharAngleInOut", -1 ) );
293  mDataDefinedNames.insert( RepeatDistance, QPair<QString, int>( "RepeatDistance", -1 ) );
294  mDataDefinedNames.insert( RepeatDistanceUnit, QPair<QString, int>( "RepeatDistanceUnit", -1 ) );
295  // (data defined only)
296  mDataDefinedNames.insert( PositionX, QPair<QString, int>( "PositionX", 9 ) );
297  mDataDefinedNames.insert( PositionY, QPair<QString, int>( "PositionY", 10 ) );
298  mDataDefinedNames.insert( Hali, QPair<QString, int>( "Hali", 11 ) );
299  mDataDefinedNames.insert( Vali, QPair<QString, int>( "Vali", 12 ) );
300  mDataDefinedNames.insert( Rotation, QPair<QString, int>( "Rotation", 14 ) );
301 
302  //rendering
303  mDataDefinedNames.insert( ScaleVisibility, QPair<QString, int>( "ScaleVisibility", -1 ) );
304  mDataDefinedNames.insert( MinScale, QPair<QString, int>( "MinScale", 16 ) );
305  mDataDefinedNames.insert( MaxScale, QPair<QString, int>( "MaxScale", 17 ) );
306  mDataDefinedNames.insert( FontLimitPixel, QPair<QString, int>( "FontLimitPixel", -1 ) );
307  mDataDefinedNames.insert( FontMinPixel, QPair<QString, int>( "FontMinPixel", -1 ) );
308  mDataDefinedNames.insert( FontMaxPixel, QPair<QString, int>( "FontMaxPixel", -1 ) );
309  // (data defined only)
310  mDataDefinedNames.insert( Show, QPair<QString, int>( "Show", 15 ) );
311  mDataDefinedNames.insert( AlwaysShow, QPair<QString, int>( "AlwaysShow", 20 ) );
312 
313  // temp stuff for when drawing label components (don't copy)
314  showingShadowRects = false;
315 }
316 
318  : palLayer( NULL )
319  , mCurFeat( NULL )
320  , mCurFields( NULL )
321  , fieldIndex( 0 )
322  , xform( NULL )
323  , ct( NULL )
324  , extentGeom( NULL )
325  , mFeaturesToLabel( 0 )
326  , mFeatsSendingToPal( 0 )
327  , mFeatsRegPal( 0 )
328  , showingShadowRects( false )
329  , expression( NULL )
330 {
331  // copy only permanent stuff
332 
333  enabled = s.enabled;
334 
335  // text style
336  fieldName = s.fieldName;
338  textFont = s.textFont;
342  textColor = s.textColor;
344  blendMode = s.blendMode;
346  // font processing info
349 
350  // text formatting
351  wrapChar = s.wrapChar;
360  decimals = s.decimals;
361  plusSign = s.plusSign;
362 
363  // text buffer
373 
374  // placement
375  placement = s.placement;
380  xOffset = s.xOffset;
381  yOffset = s.yOffset;
384  dist = s.dist;
391  priority = s.priority;
395 
396  // rendering
398  scaleMin = s.scaleMin;
399  scaleMax = s.scaleMax;
405 
411  obstacle = s.obstacle;
412 
413  // shape background
414  shapeDraw = s.shapeDraw;
415  shapeType = s.shapeType;
418  shapeSize = s.shapeSize;
437 
438  // drop shadow
454 
455  // data defined
457  mDataDefinedNames = s.mDataDefinedNames;
458 
459  // scale factors
462 }
463 
464 
466 {
467  // pal layer is deleted internally in PAL
468 
469  delete ct;
470  delete expression;
471  delete extentGeom;
472 
473  // clear pointers to QgsDataDefined objects
474  dataDefinedProperties.clear();
475 }
476 
477 
479 {
480  QgsPalLayerSettings settings;
481  settings.readFromLayer( layer );
482  return settings;
483 }
484 
485 
487 {
488  if ( expression == NULL )
489  {
490  expression = new QgsExpression( fieldName );
491  }
492  return expression;
493 }
494 
495 static QColor _readColor( QgsVectorLayer* layer, QString property, QColor defaultColor = Qt::black, bool withAlpha = true )
496 {
497  int r = layer->customProperty( property + "R", QVariant( defaultColor.red() ) ).toInt();
498  int g = layer->customProperty( property + "G", QVariant( defaultColor.green() ) ).toInt();
499  int b = layer->customProperty( property + "B", QVariant( defaultColor.blue() ) ).toInt();
500  int a = withAlpha ? layer->customProperty( property + "A", QVariant( defaultColor.alpha() ) ).toInt() : 255;
501  return QColor( r, g, b, a );
502 }
503 
504 static void _writeColor( QgsVectorLayer* layer, QString property, QColor color, bool withAlpha = true )
505 {
506  layer->setCustomProperty( property + "R", color.red() );
507  layer->setCustomProperty( property + "G", color.green() );
508  layer->setCustomProperty( property + "B", color.blue() );
509  if ( withAlpha )
510  layer->setCustomProperty( property + "A", color.alpha() );
511 }
512 
513 static QgsPalLayerSettings::SizeUnit _decodeUnits( const QString& str )
514 {
515  if ( str.compare( "Point", Qt::CaseInsensitive ) == 0
516  || str.compare( "Points", Qt::CaseInsensitive ) == 0 ) return QgsPalLayerSettings::Points;
517  if ( str.compare( "MapUnit", Qt::CaseInsensitive ) == 0
518  || str.compare( "MapUnits", Qt::CaseInsensitive ) == 0 ) return QgsPalLayerSettings::MapUnits;
519  if ( str.compare( "Percent", Qt::CaseInsensitive ) == 0 ) return QgsPalLayerSettings::Percent;
520  return QgsPalLayerSettings::MM; // "MM"
521 }
522 
523 static Qt::PenJoinStyle _decodePenJoinStyle( const QString& str )
524 {
525  if ( str.compare( "Miter", Qt::CaseInsensitive ) == 0 ) return Qt::MiterJoin;
526  if ( str.compare( "Round", Qt::CaseInsensitive ) == 0 ) return Qt::RoundJoin;
527  return Qt::BevelJoin; // "Bevel"
528 }
529 
530 void QgsPalLayerSettings::readDataDefinedPropertyMap( QgsVectorLayer* layer,
531  QMap < QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* > & propertyMap )
532 {
533  if ( !layer )
534  {
535  return;
536  }
537 
538  QMapIterator<QgsPalLayerSettings::DataDefinedProperties, QPair<QString, int> > i( mDataDefinedNames );
539  while ( i.hasNext() )
540  {
541  i.next();
542  readDataDefinedProperty( layer, i.key(), propertyMap );
543  }
544 }
545 
546 void QgsPalLayerSettings::writeDataDefinedPropertyMap( QgsVectorLayer* layer,
547  const QMap < QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* > & propertyMap )
548 {
549  if ( !layer )
550  {
551  return;
552  }
553 
554  QMapIterator<QgsPalLayerSettings::DataDefinedProperties, QPair<QString, int> > i( mDataDefinedNames );
555  while ( i.hasNext() )
556  {
557  i.next();
558  QString newPropertyName = "labeling/dataDefined/" + i.value().first;
559  QVariant propertyValue = QVariant();
560 
561  QMap< QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* >::const_iterator it = propertyMap.find( i.key() );
562  if ( it != propertyMap.constEnd() )
563  {
564  QgsDataDefined* dd = it.value();
565  if ( dd )
566  {
567  bool active = dd->isActive();
568  bool useExpr = dd->useExpression();
569  QString expr = dd->expressionString();
570  QString field = dd->field();
571 
572  bool defaultVals = ( !active && !useExpr && expr.isEmpty() && field.isEmpty() );
573 
574  if ( !defaultVals )
575  {
576  // TODO: update this when project settings for labeling are migrated to better XML layout
577  QStringList values;
578  values << ( active ? "1" : "0" );
579  values << ( useExpr ? "1" : "0" );
580  values << expr;
581  values << field;
582  if ( !values.isEmpty() )
583  {
584  propertyValue = QVariant( values.join( "~~" ) );
585  }
586  }
587  }
588  }
589 
590  if ( propertyValue.isValid() )
591  {
592  layer->setCustomProperty( newPropertyName, propertyValue );
593  }
594  else
595  {
596  // remove unused properties
597  layer->removeCustomProperty( newPropertyName );
598  }
599 
600  if ( layer->customProperty( newPropertyName, QVariant() ).isValid() && i.value().second > -1 )
601  {
602  // remove old-style field index-based property, if still present
603  layer->removeCustomProperty( QString( "labeling/dataDefinedProperty" ) + QString::number( i.value().second ) );
604  }
605  }
606 }
607 
608 void QgsPalLayerSettings::readDataDefinedProperty( QgsVectorLayer* layer,
610  QMap < QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* > & propertyMap )
611 {
612  QString newPropertyName = "labeling/dataDefined/" + mDataDefinedNames.value( p ).first;
613  QVariant newPropertyField = layer->customProperty( newPropertyName, QVariant() );
614 
615  QString ddString = QString();
616  if ( newPropertyField.isValid() )
617  {
618  ddString = newPropertyField.toString();
619  }
620  else // maybe working with old-style field index-based property (< QGIS 2.0)
621  {
622  int oldIndx = mDataDefinedNames.value( p ).second;
623 
624  if ( oldIndx < 0 ) // something went wrong and we are working with new-style
625  {
626  return;
627  }
628 
629  QString oldPropertyName = "labeling/dataDefinedProperty" + QString::number( oldIndx );
630  QVariant oldPropertyField = layer->customProperty( oldPropertyName, QVariant() );
631 
632  if ( !oldPropertyField.isValid() )
633  {
634  return;
635  }
636 
637  // switch from old-style field index- to name-based properties
638  bool conversionOk;
639  int indx = oldPropertyField.toInt( &conversionOk );
640 
641  if ( conversionOk )
642  {
643  // Fix to migrate from old-style vector api, where returned QMap keys possibly
644  // had 'holes' in sequence of field indices, e.g. 0,2,3
645  // QgsAttrPalIndexNameHash provides a means of access field name in sequences from
646  // providers that procuded holes (e.g. PostGIS skipped geom column), otherwise it is empty
647  QgsAttrPalIndexNameHash oldIndicesToNames = layer->dataProvider()->palAttributeIndexNames();
648 
649  if ( !oldIndicesToNames.isEmpty() )
650  {
651  ddString = oldIndicesToNames.value( indx );
652  }
653  else
654  {
655  QgsFields fields = layer->dataProvider()->fields();
656  if ( indx < fields.size() ) // in case field count has changed
657  {
658  ddString = fields.at( indx ).name();
659  }
660  }
661  }
662 
663  if ( !ddString.isEmpty() )
664  {
665  //upgrade any existing property to field name-based
666  layer->setCustomProperty( newPropertyName, QVariant( updateDataDefinedString( ddString ) ) );
667 
668  // fix for buffer drawing triggered off of just its data defined size in the past (<2.0)
669  if ( oldIndx == 7 ) // old bufferSize enum
670  {
671  bufferDraw = true;
672  layer->setCustomProperty( "labeling/bufferDraw", true );
673  }
674 
675  // fix for scale visibility limits triggered off of just its data defined values in the past (<2.0)
676  if ( oldIndx == 16 || oldIndx == 17 ) // old minScale and maxScale enums
677  {
678  scaleVisibility = true;
679  layer->setCustomProperty( "labeling/scaleVisibility", true );
680  }
681  }
682 
683  // remove old-style field index-based property
684  layer->removeCustomProperty( oldPropertyName );
685  }
686 
687  if ( !ddString.isEmpty() && ddString != QString( "0~~0~~~~" ) )
688  {
689  // TODO: update this when project settings for labeling are migrated to better XML layout
690  QString newStyleString = updateDataDefinedString( ddString );
691  QStringList ddv = newStyleString.split( "~~" );
692 
693  QgsDataDefined* dd = new QgsDataDefined( ddv.at( 0 ).toInt(), ddv.at( 1 ).toInt(), ddv.at( 2 ), ddv.at( 3 ) );
694  propertyMap.insert( p, dd );
695  }
696  else
697  {
698  // remove unused properties
699  layer->removeCustomProperty( newPropertyName );
700  }
701 }
702 
704 {
705  if ( layer->customProperty( "labeling" ).toString() != QString( "pal" ) )
706  {
707  // for polygons the "over point" (over centroid) placement is better than the default
708  // "around point" (around centroid) which is more suitable for points
709  if ( layer->geometryType() == QGis::Polygon )
711 
712  return; // there's no information available
713  }
714 
715  // NOTE: set defaults for newly added properties, for backwards compatibility
716 
717  enabled = layer->customProperty( "labeling/enabled" ).toBool();
718 
719  // text style
720  fieldName = layer->customProperty( "labeling/fieldName" ).toString();
721  isExpression = layer->customProperty( "labeling/isExpression" ).toBool();
722  QFont appFont = QApplication::font();
723  mTextFontFamily = layer->customProperty( "labeling/fontFamily", QVariant( appFont.family() ) ).toString();
724  QString fontFamily = mTextFontFamily;
726  {
727  // trigger to notify user about font family substitution (signal emitted in QgsVectorLayer::prepareLabelingAndDiagrams)
728  mTextFontFound = false;
729 
730  // TODO: update when pref for how to resolve missing family (use matching algorithm or just default font) is implemented
731  // currently only defaults to matching algorithm for resolving [foundry], if a font of similar family is found (default for QFont)
732 
733  // for now, do not use matching algorithm for substitution if family not found, substitute default instead
734  fontFamily = appFont.family();
735  }
736 
737  double fontSize = layer->customProperty( "labeling/fontSize" ).toDouble();
738  fontSizeInMapUnits = layer->customProperty( "labeling/fontSizeInMapUnits" ).toBool();
739  fontSizeMapUnitScale.minScale = layer->customProperty( "labeling/fontSizeMapUnitMinScale", 0.0 ).toDouble();
740  fontSizeMapUnitScale.maxScale = layer->customProperty( "labeling/fontSizeMapUnitMaxScale", 0.0 ).toDouble();
741  int fontWeight = layer->customProperty( "labeling/fontWeight" ).toInt();
742  bool fontItalic = layer->customProperty( "labeling/fontItalic" ).toBool();
743  textFont = QFont( fontFamily, fontSize, fontWeight, fontItalic );
744  textFont.setPointSizeF( fontSize ); //double precision needed because of map units
745  textNamedStyle = layer->customProperty( "labeling/namedStyle", QVariant( "" ) ).toString();
746  QgsFontUtils::updateFontViaStyle( textFont, textNamedStyle ); // must come after textFont.setPointSizeF()
747  textFont.setCapitalization(( QFont::Capitalization )layer->customProperty( "labeling/fontCapitals", QVariant( 0 ) ).toUInt() );
748  textFont.setUnderline( layer->customProperty( "labeling/fontUnderline" ).toBool() );
749  textFont.setStrikeOut( layer->customProperty( "labeling/fontStrikeout" ).toBool() );
750  textFont.setLetterSpacing( QFont::AbsoluteSpacing, layer->customProperty( "labeling/fontLetterSpacing", QVariant( 0.0 ) ).toDouble() );
751  textFont.setWordSpacing( layer->customProperty( "labeling/fontWordSpacing", QVariant( 0.0 ) ).toDouble() );
752  textColor = _readColor( layer, "labeling/textColor", Qt::black, false );
753  textTransp = layer->customProperty( "labeling/textTransp" ).toInt();
755  ( QgsMapRenderer::BlendMode )layer->customProperty( "labeling/blendMode", QVariant( QgsMapRenderer::BlendNormal ) ).toUInt() );
756  previewBkgrdColor = QColor( layer->customProperty( "labeling/previewBkgrdColor", QVariant( "#ffffff" ) ).toString() );
757 
758 
759  // text formatting
760  wrapChar = layer->customProperty( "labeling/wrapChar" ).toString();
761  multilineHeight = layer->customProperty( "labeling/multilineHeight", QVariant( 1.0 ) ).toDouble();
762  multilineAlign = ( MultiLineAlign )layer->customProperty( "labeling/multilineAlign", QVariant( MultiLeft ) ).toUInt();
763  addDirectionSymbol = layer->customProperty( "labeling/addDirectionSymbol" ).toBool();
764  leftDirectionSymbol = layer->customProperty( "labeling/leftDirectionSymbol", QVariant( "<" ) ).toString();
765  rightDirectionSymbol = layer->customProperty( "labeling/rightDirectionSymbol", QVariant( ">" ) ).toString();
766  reverseDirectionSymbol = layer->customProperty( "labeling/reverseDirectionSymbol" ).toBool();
767  placeDirectionSymbol = ( DirectionSymbols )layer->customProperty( "labeling/placeDirectionSymbol", QVariant( SymbolLeftRight ) ).toUInt();
768  formatNumbers = layer->customProperty( "labeling/formatNumbers" ).toBool();
769  decimals = layer->customProperty( "labeling/decimals" ).toInt();
770  plusSign = layer->customProperty( "labeling/plussign" ).toInt();
771 
772  // text buffer
773  double bufSize = layer->customProperty( "labeling/bufferSize", QVariant( 0.0 ) ).toDouble();
774 
775  // fix for buffer being keyed off of just its size in the past (<2.0)
776  QVariant drawBuffer = layer->customProperty( "labeling/bufferDraw", QVariant() );
777  if ( drawBuffer.isValid() )
778  {
779  bufferDraw = drawBuffer.toBool();
780  bufferSize = bufSize;
781  }
782  else if ( bufSize != 0.0 )
783  {
784  bufferDraw = true;
785  bufferSize = bufSize;
786  }
787  else
788  {
789  // keep bufferSize at new 1.0 default
790  bufferDraw = false;
791  }
792 
793  bufferSizeInMapUnits = layer->customProperty( "labeling/bufferSizeInMapUnits" ).toBool();
794  bufferSizeMapUnitScale.minScale = layer->customProperty( "labeling/bufferSizeMapUnitMinScale", 0.0 ).toDouble();
795  bufferSizeMapUnitScale.maxScale = layer->customProperty( "labeling/bufferSizeMapUnitMaxScale", 0.0 ).toDouble();
796  bufferColor = _readColor( layer, "labeling/bufferColor", Qt::white, false );
797  bufferTransp = layer->customProperty( "labeling/bufferTransp" ).toInt();
799  ( QgsMapRenderer::BlendMode )layer->customProperty( "labeling/bufferBlendMode", QVariant( QgsMapRenderer::BlendNormal ) ).toUInt() );
800  bufferJoinStyle = ( Qt::PenJoinStyle )layer->customProperty( "labeling/bufferJoinStyle", QVariant( Qt::BevelJoin ) ).toUInt();
801  bufferNoFill = layer->customProperty( "labeling/bufferNoFill", QVariant( false ) ).toBool();
802 
803  // background
804  shapeDraw = layer->customProperty( "labeling/shapeDraw", QVariant( false ) ).toBool();
805  shapeType = ( ShapeType )layer->customProperty( "labeling/shapeType", QVariant( ShapeRectangle ) ).toUInt();
806  shapeSVGFile = layer->customProperty( "labeling/shapeSVGFile", QVariant( "" ) ).toString();
807  shapeSizeType = ( SizeType )layer->customProperty( "labeling/shapeSizeType", QVariant( SizeBuffer ) ).toUInt();
808  shapeSize = QPointF( layer->customProperty( "labeling/shapeSizeX", QVariant( 0.0 ) ).toDouble(),
809  layer->customProperty( "labeling/shapeSizeY", QVariant( 0.0 ) ).toDouble() );
810  shapeSizeUnits = ( SizeUnit )layer->customProperty( "labeling/shapeSizeUnits", QVariant( MM ) ).toUInt();
811  shapeSizeMapUnitScale.minScale = layer->customProperty( "labeling/shapeSizeMapUnitMinScale", 0.0 ).toDouble();
812  shapeSizeMapUnitScale.maxScale = layer->customProperty( "labeling/shapeSizeMapUnitMaxScale", 0.0 ).toDouble();
813  shapeRotationType = ( RotationType )layer->customProperty( "labeling/shapeRotationType", QVariant( RotationSync ) ).toUInt();
814  shapeRotation = layer->customProperty( "labeling/shapeRotation", QVariant( 0.0 ) ).toDouble();
815  shapeOffset = QPointF( layer->customProperty( "labeling/shapeOffsetX", QVariant( 0.0 ) ).toDouble(),
816  layer->customProperty( "labeling/shapeOffsetY", QVariant( 0.0 ) ).toDouble() );
817  shapeOffsetUnits = ( SizeUnit )layer->customProperty( "labeling/shapeOffsetUnits", QVariant( MM ) ).toUInt();
818  shapeOffsetMapUnitScale.minScale = layer->customProperty( "labeling/shapeOffsetMapUnitMinScale", 0.0 ).toDouble();
819  shapeOffsetMapUnitScale.maxScale = layer->customProperty( "labeling/shapeOffsetMapUnitMaxScale", 0.0 ).toDouble();
820  shapeRadii = QPointF( layer->customProperty( "labeling/shapeRadiiX", QVariant( 0.0 ) ).toDouble(),
821  layer->customProperty( "labeling/shapeRadiiY", QVariant( 0.0 ) ).toDouble() );
822  shapeRadiiUnits = ( SizeUnit )layer->customProperty( "labeling/shapeRadiiUnits", QVariant( MM ) ).toUInt();
823  shapeRadiiMapUnitScale.minScale = layer->customProperty( "labeling/shapeRaddiMapUnitMinScale", 0.0 ).toDouble();
824  shapeRadiiMapUnitScale.maxScale = layer->customProperty( "labeling/shapeRaddiMapUnitMaxScale", 0.0 ).toDouble();
825  shapeFillColor = _readColor( layer, "labeling/shapeFillColor", Qt::white, true );
826  shapeBorderColor = _readColor( layer, "labeling/shapeBorderColor", Qt::darkGray, true );
827  shapeBorderWidth = layer->customProperty( "labeling/shapeBorderWidth", QVariant( .0 ) ).toDouble();
828  shapeBorderWidthUnits = ( SizeUnit )layer->customProperty( "labeling/shapeBorderWidthUnits", QVariant( MM ) ).toUInt();
829  shapeBorderWidthMapUnitScale.minScale = layer->customProperty( "labeling/shapeBorderWidthMapUnitMinScale", 0.0 ).toDouble();
830  shapeBorderWidthMapUnitScale.maxScale = layer->customProperty( "labeling/shapeBorderWidthMapUnitMaxScale", 0.0 ).toDouble();
831  shapeJoinStyle = ( Qt::PenJoinStyle )layer->customProperty( "labeling/shapeJoinStyle", QVariant( Qt::BevelJoin ) ).toUInt();
832  shapeTransparency = layer->customProperty( "labeling/shapeTransparency", QVariant( 0 ) ).toInt();
834  ( QgsMapRenderer::BlendMode )layer->customProperty( "labeling/shapeBlendMode", QVariant( QgsMapRenderer::BlendNormal ) ).toUInt() );
835 
836  // drop shadow
837  shadowDraw = layer->customProperty( "labeling/shadowDraw", QVariant( false ) ).toBool();
838  shadowUnder = ( ShadowType )layer->customProperty( "labeling/shadowUnder", QVariant( ShadowLowest ) ).toUInt();//ShadowLowest;
839  shadowOffsetAngle = layer->customProperty( "labeling/shadowOffsetAngle", QVariant( 135 ) ).toInt();
840  shadowOffsetDist = layer->customProperty( "labeling/shadowOffsetDist", QVariant( 1.0 ) ).toDouble();
841  shadowOffsetUnits = ( SizeUnit )layer->customProperty( "labeling/shadowOffsetUnits", QVariant( MM ) ).toUInt();
842  shadowOffsetMapUnitScale.minScale = layer->customProperty( "labeling/shadowOffsetMapUnitMinScale", 0.0 ).toDouble();
843  shadowOffsetMapUnitScale.maxScale = layer->customProperty( "labeling/shadowOffsetMapUnitMaxScale", 0.0 ).toDouble();
844  shadowOffsetGlobal = layer->customProperty( "labeling/shadowOffsetGlobal", QVariant( true ) ).toBool();
845  shadowRadius = layer->customProperty( "labeling/shadowRadius", QVariant( 1.5 ) ).toDouble();
846  shadowRadiusUnits = ( SizeUnit )layer->customProperty( "labeling/shadowRadiusUnits", QVariant( MM ) ).toUInt();
847  shadowRadiusMapUnitScale.minScale = layer->customProperty( "labeling/shadowRadiusMapUnitMinScale", 0.0 ).toDouble();
848  shadowRadiusMapUnitScale.maxScale = layer->customProperty( "labeling/shadowRadiusMapUnitMaxScale", 0.0 ).toDouble();
849  shadowRadiusAlphaOnly = layer->customProperty( "labeling/shadowRadiusAlphaOnly", QVariant( false ) ).toBool();
850  shadowTransparency = layer->customProperty( "labeling/shadowTransparency", QVariant( 30 ) ).toInt();
851  shadowScale = layer->customProperty( "labeling/shadowScale", QVariant( 100 ) ).toInt();
852  shadowColor = _readColor( layer, "labeling/shadowColor", Qt::black, false );
854  ( QgsMapRenderer::BlendMode )layer->customProperty( "labeling/shadowBlendMode", QVariant( QgsMapRenderer::BlendMultiply ) ).toUInt() );
855 
856  // placement
857  placement = ( Placement )layer->customProperty( "labeling/placement" ).toInt();
858  placementFlags = layer->customProperty( "labeling/placementFlags" ).toUInt();
859  centroidWhole = layer->customProperty( "labeling/centroidWhole", QVariant( false ) ).toBool();
860  centroidInside = layer->customProperty( "labeling/centroidInside", QVariant( false ) ).toBool();
861  dist = layer->customProperty( "labeling/dist" ).toDouble();
862  distInMapUnits = layer->customProperty( "labeling/distInMapUnits" ).toBool();
863  distMapUnitScale.minScale = layer->customProperty( "labeling/distMapUnitMinScale", 0.0 ).toDouble();
864  distMapUnitScale.maxScale = layer->customProperty( "labeling/distMapUnitMaxScale", 0.0 ).toDouble();
865  quadOffset = ( QuadrantPosition )layer->customProperty( "labeling/quadOffset", QVariant( QuadrantOver ) ).toUInt();
866  xOffset = layer->customProperty( "labeling/xOffset", QVariant( 0.0 ) ).toDouble();
867  yOffset = layer->customProperty( "labeling/yOffset", QVariant( 0.0 ) ).toDouble();
868  labelOffsetInMapUnits = layer->customProperty( "labeling/labelOffsetInMapUnits", QVariant( true ) ).toBool();
869  labelOffsetMapUnitScale.minScale = layer->customProperty( "labeling/labelOffsetMapUnitMinScale", 0.0 ).toDouble();
870  labelOffsetMapUnitScale.maxScale = layer->customProperty( "labeling/labelOffsetMapUnitMaxScale", 0.0 ).toDouble();
871  angleOffset = layer->customProperty( "labeling/angleOffset", QVariant( 0.0 ) ).toDouble();
872  preserveRotation = layer->customProperty( "labeling/preserveRotation", QVariant( true ) ).toBool();
873  maxCurvedCharAngleIn = layer->customProperty( "labeling/maxCurvedCharAngleIn", QVariant( 20.0 ) ).toDouble();
874  maxCurvedCharAngleOut = layer->customProperty( "labeling/maxCurvedCharAngleOut", QVariant( -20.0 ) ).toDouble();
875  priority = layer->customProperty( "labeling/priority" ).toInt();
876  repeatDistance = layer->customProperty( "labeling/repeatDistance", 0.0 ).toDouble();
877  repeatDistanceUnit = ( SizeUnit ) layer->customProperty( "labeling/repeatDistanceUnit", QVariant( MM ) ).toUInt();
878  repeatDistanceMapUnitScale.minScale = layer->customProperty( "labeling/repeatDistanceMapUnitMinScale", 0.0 ).toDouble();
879  repeatDistanceMapUnitScale.maxScale = layer->customProperty( "labeling/repeatDistanceMapUnitMaxScale", 0.0 ).toDouble();
880 
881  // rendering
882  int scalemn = layer->customProperty( "labeling/scaleMin", QVariant( 0 ) ).toInt();
883  int scalemx = layer->customProperty( "labeling/scaleMax", QVariant( 0 ) ).toInt();
884 
885  // fix for scale visibility limits being keyed off of just its values in the past (<2.0)
886  QVariant scalevis = layer->customProperty( "labeling/scaleVisibility", QVariant() );
887  if ( scalevis.isValid() )
888  {
889  scaleVisibility = scalevis.toBool();
890  scaleMin = scalemn;
891  scaleMax = scalemx;
892  }
893  else if ( scalemn > 0 || scalemx > 0 )
894  {
895  scaleVisibility = true;
896  scaleMin = scalemn;
897  scaleMax = scalemx;
898  }
899  else
900  {
901  // keep scaleMin and scaleMax at new 1.0 defaults (1 and 10000000, were 0 and 0)
902  scaleVisibility = false;
903  }
904 
905 
906  fontLimitPixelSize = layer->customProperty( "labeling/fontLimitPixelSize", QVariant( false ) ).toBool();
907  fontMinPixelSize = layer->customProperty( "labeling/fontMinPixelSize", QVariant( 0 ) ).toInt();
908  fontMaxPixelSize = layer->customProperty( "labeling/fontMaxPixelSize", QVariant( 10000 ) ).toInt();
909  displayAll = layer->customProperty( "labeling/displayAll", QVariant( false ) ).toBool();
910  upsidedownLabels = ( UpsideDownLabels )layer->customProperty( "labeling/upsidedownLabels", QVariant( Upright ) ).toUInt();
911 
912  labelPerPart = layer->customProperty( "labeling/labelPerPart" ).toBool();
913  mergeLines = layer->customProperty( "labeling/mergeLines" ).toBool();
914  minFeatureSize = layer->customProperty( "labeling/minFeatureSize" ).toDouble();
915  limitNumLabels = layer->customProperty( "labeling/limitNumLabels", QVariant( false ) ).toBool();
916  maxNumLabels = layer->customProperty( "labeling/maxNumLabels", QVariant( 2000 ) ).toInt();
917  obstacle = layer->customProperty( "labeling/obstacle", QVariant( true ) ).toBool();
918 
919  readDataDefinedPropertyMap( layer, dataDefinedProperties );
920 }
921 
923 {
924  // this is a mark that labeling information is present
925  layer->setCustomProperty( "labeling", "pal" );
926 
927  layer->setCustomProperty( "labeling/enabled", enabled );
928 
929  // text style
930  layer->setCustomProperty( "labeling/fieldName", fieldName );
931  layer->setCustomProperty( "labeling/isExpression", isExpression );
932  layer->setCustomProperty( "labeling/fontFamily", textFont.family() );
933  layer->setCustomProperty( "labeling/namedStyle", textNamedStyle );
934  layer->setCustomProperty( "labeling/fontSize", textFont.pointSizeF() );
935  layer->setCustomProperty( "labeling/fontSizeInMapUnits", fontSizeInMapUnits );
936  layer->setCustomProperty( "labeling/fontSizeMapUnitMinScale", fontSizeMapUnitScale.minScale );
937  layer->setCustomProperty( "labeling/fontSizeMapUnitMaxScale", fontSizeMapUnitScale.maxScale );
938  layer->setCustomProperty( "labeling/fontWeight", textFont.weight() );
939  layer->setCustomProperty( "labeling/fontItalic", textFont.italic() );
940  layer->setCustomProperty( "labeling/fontBold", textFont.bold() );
941  layer->setCustomProperty( "labeling/fontStrikeout", textFont.strikeOut() );
942  layer->setCustomProperty( "labeling/fontUnderline", textFont.underline() );
943  _writeColor( layer, "labeling/textColor", textColor );
944  layer->setCustomProperty( "labeling/fontCapitals", ( unsigned int )textFont.capitalization() );
945  layer->setCustomProperty( "labeling/fontLetterSpacing", textFont.letterSpacing() );
946  layer->setCustomProperty( "labeling/fontWordSpacing", textFont.wordSpacing() );
947  layer->setCustomProperty( "labeling/textTransp", textTransp );
948  layer->setCustomProperty( "labeling/blendMode", QgsMapRenderer::getBlendModeEnum( blendMode ) );
949  layer->setCustomProperty( "labeling/previewBkgrdColor", previewBkgrdColor.name() );
950 
951  // text formatting
952  layer->setCustomProperty( "labeling/wrapChar", wrapChar );
953  layer->setCustomProperty( "labeling/multilineHeight", multilineHeight );
954  layer->setCustomProperty( "labeling/multilineAlign", ( unsigned int )multilineAlign );
955  layer->setCustomProperty( "labeling/addDirectionSymbol", addDirectionSymbol );
956  layer->setCustomProperty( "labeling/leftDirectionSymbol", leftDirectionSymbol );
957  layer->setCustomProperty( "labeling/rightDirectionSymbol", rightDirectionSymbol );
958  layer->setCustomProperty( "labeling/reverseDirectionSymbol", reverseDirectionSymbol );
959  layer->setCustomProperty( "labeling/placeDirectionSymbol", ( unsigned int )placeDirectionSymbol );
960  layer->setCustomProperty( "labeling/formatNumbers", formatNumbers );
961  layer->setCustomProperty( "labeling/decimals", decimals );
962  layer->setCustomProperty( "labeling/plussign", plusSign );
963 
964  // text buffer
965  layer->setCustomProperty( "labeling/bufferDraw", bufferDraw );
966  layer->setCustomProperty( "labeling/bufferSize", bufferSize );
967  layer->setCustomProperty( "labeling/bufferSizeInMapUnits", bufferSizeInMapUnits );
968  layer->setCustomProperty( "labeling/bufferSizeMapUnitMinScale", bufferSizeMapUnitScale.minScale );
969  layer->setCustomProperty( "labeling/bufferSizeMapUnitMaxScale", bufferSizeMapUnitScale.maxScale );
970  _writeColor( layer, "labeling/bufferColor", bufferColor );
971  layer->setCustomProperty( "labeling/bufferNoFill", bufferNoFill );
972  layer->setCustomProperty( "labeling/bufferTransp", bufferTransp );
973  layer->setCustomProperty( "labeling/bufferJoinStyle", ( unsigned int )bufferJoinStyle );
974  layer->setCustomProperty( "labeling/bufferBlendMode", QgsMapRenderer::getBlendModeEnum( bufferBlendMode ) );
975 
976  // background
977  layer->setCustomProperty( "labeling/shapeDraw", shapeDraw );
978  layer->setCustomProperty( "labeling/shapeType", ( unsigned int )shapeType );
979  layer->setCustomProperty( "labeling/shapeSVGFile", shapeSVGFile );
980  layer->setCustomProperty( "labeling/shapeSizeType", ( unsigned int )shapeSizeType );
981  layer->setCustomProperty( "labeling/shapeSizeX", shapeSize.x() );
982  layer->setCustomProperty( "labeling/shapeSizeY", shapeSize.y() );
983  layer->setCustomProperty( "labeling/shapeSizeUnits", ( unsigned int )shapeSizeUnits );
984  layer->setCustomProperty( "labeling/shapeSizeMapUnitMinScale", shapeSizeMapUnitScale.minScale );
985  layer->setCustomProperty( "labeling/shapeSizeMapUnitMaxScale", shapeSizeMapUnitScale.maxScale );
986  layer->setCustomProperty( "labeling/shapeRotationType", ( unsigned int )shapeRotationType );
987  layer->setCustomProperty( "labeling/shapeRotation", shapeRotation );
988  layer->setCustomProperty( "labeling/shapeOffsetX", shapeOffset.x() );
989  layer->setCustomProperty( "labeling/shapeOffsetY", shapeOffset.y() );
990  layer->setCustomProperty( "labeling/shapeOffsetUnits", ( unsigned int )shapeOffsetUnits );
991  layer->setCustomProperty( "labeling/shapeOffsetMapUnitMinScale", shapeOffsetMapUnitScale.minScale );
992  layer->setCustomProperty( "labeling/shapeOffsetMapUnitMaxScale", shapeOffsetMapUnitScale.maxScale );
993  layer->setCustomProperty( "labeling/shapeRadiiX", shapeRadii.x() );
994  layer->setCustomProperty( "labeling/shapeRadiiY", shapeRadii.y() );
995  layer->setCustomProperty( "labeling/shapeRadiiUnits", ( unsigned int )shapeRadiiUnits );
996  layer->setCustomProperty( "labeling/shapeRadiiMapUnitMinScale", shapeRadiiMapUnitScale.minScale );
997  layer->setCustomProperty( "labeling/shapeRadiiMapUnitMaxScale", shapeRadiiMapUnitScale.maxScale );
998  _writeColor( layer, "labeling/shapeFillColor", shapeFillColor, true );
999  _writeColor( layer, "labeling/shapeBorderColor", shapeBorderColor, true );
1000  layer->setCustomProperty( "labeling/shapeBorderWidth", shapeBorderWidth );
1001  layer->setCustomProperty( "labeling/shapeBorderWidthUnits", ( unsigned int )shapeBorderWidthUnits );
1002  layer->setCustomProperty( "labeling/shapeBorderWidthMapUnitMinScale", shapeBorderWidthMapUnitScale.minScale );
1003  layer->setCustomProperty( "labeling/shapeBorderWidthMapUnitMaxScale", shapeBorderWidthMapUnitScale.maxScale );
1004  layer->setCustomProperty( "labeling/shapeJoinStyle", ( unsigned int )shapeJoinStyle );
1005  layer->setCustomProperty( "labeling/shapeTransparency", shapeTransparency );
1006  layer->setCustomProperty( "labeling/shapeBlendMode", QgsMapRenderer::getBlendModeEnum( shapeBlendMode ) );
1007 
1008  // drop shadow
1009  layer->setCustomProperty( "labeling/shadowDraw", shadowDraw );
1010  layer->setCustomProperty( "labeling/shadowUnder", ( unsigned int )shadowUnder );
1011  layer->setCustomProperty( "labeling/shadowOffsetAngle", shadowOffsetAngle );
1012  layer->setCustomProperty( "labeling/shadowOffsetDist", shadowOffsetDist );
1013  layer->setCustomProperty( "labeling/shadowOffsetUnits", ( unsigned int )shadowOffsetUnits );
1014  layer->setCustomProperty( "labeling/shadowOffsetMapUnitMinScale", shadowOffsetMapUnitScale.minScale );
1015  layer->setCustomProperty( "labeling/shadowOffsetMapUnitMaxScale", shadowOffsetMapUnitScale.maxScale );
1016  layer->setCustomProperty( "labeling/shadowOffsetGlobal", shadowOffsetGlobal );
1017  layer->setCustomProperty( "labeling/shadowRadius", shadowRadius );
1018  layer->setCustomProperty( "labeling/shadowRadiusUnits", ( unsigned int )shadowRadiusUnits );
1019  layer->setCustomProperty( "labeling/shadowRadiusMapUnitMinScale", shadowRadiusMapUnitScale.minScale );
1020  layer->setCustomProperty( "labeling/shadowRadiusMapUnitMaxScale", shadowRadiusMapUnitScale.maxScale );
1021  layer->setCustomProperty( "labeling/shadowRadiusAlphaOnly", shadowRadiusAlphaOnly );
1022  layer->setCustomProperty( "labeling/shadowTransparency", shadowTransparency );
1023  layer->setCustomProperty( "labeling/shadowScale", shadowScale );
1024  _writeColor( layer, "labeling/shadowColor", shadowColor, false );
1025  layer->setCustomProperty( "labeling/shadowBlendMode", QgsMapRenderer::getBlendModeEnum( shadowBlendMode ) );
1026 
1027  // placement
1028  layer->setCustomProperty( "labeling/placement", placement );
1029  layer->setCustomProperty( "labeling/placementFlags", ( unsigned int )placementFlags );
1030  layer->setCustomProperty( "labeling/centroidWhole", centroidWhole );
1031  layer->setCustomProperty( "labeling/centroidInside", centroidInside );
1032  layer->setCustomProperty( "labeling/dist", dist );
1033  layer->setCustomProperty( "labeling/distInMapUnits", distInMapUnits );
1034  layer->setCustomProperty( "labeling/distMapUnitMinScale", distMapUnitScale.minScale );
1035  layer->setCustomProperty( "labeling/distMapUnitMaxScale", distMapUnitScale.maxScale );
1036  layer->setCustomProperty( "labeling/quadOffset", ( unsigned int )quadOffset );
1037  layer->setCustomProperty( "labeling/xOffset", xOffset );
1038  layer->setCustomProperty( "labeling/yOffset", yOffset );
1039  layer->setCustomProperty( "labeling/labelOffsetInMapUnits", labelOffsetInMapUnits );
1040  layer->setCustomProperty( "labeling/labelOffsetMapUnitMinScale", labelOffsetMapUnitScale.minScale );
1041  layer->setCustomProperty( "labeling/labelOffsetMapUnitMaxScale", labelOffsetMapUnitScale.maxScale );
1042  layer->setCustomProperty( "labeling/angleOffset", angleOffset );
1043  layer->setCustomProperty( "labeling/preserveRotation", preserveRotation );
1044  layer->setCustomProperty( "labeling/maxCurvedCharAngleIn", maxCurvedCharAngleIn );
1045  layer->setCustomProperty( "labeling/maxCurvedCharAngleOut", maxCurvedCharAngleOut );
1046  layer->setCustomProperty( "labeling/priority", priority );
1047  layer->setCustomProperty( "labeling/repeatDistance", repeatDistance );
1048  layer->setCustomProperty( "labeling/repeatDistanceUnit", repeatDistanceUnit );
1049  layer->setCustomProperty( "labeling/repeatDistanceMapUnitMinScale", repeatDistanceMapUnitScale.minScale );
1050  layer->setCustomProperty( "labeling/repeatDistanceMapUnitMaxScale", repeatDistanceMapUnitScale.maxScale );
1051 
1052  // rendering
1053  layer->setCustomProperty( "labeling/scaleVisibility", scaleVisibility );
1054  layer->setCustomProperty( "labeling/scaleMin", scaleMin );
1055  layer->setCustomProperty( "labeling/scaleMax", scaleMax );
1056  layer->setCustomProperty( "labeling/fontLimitPixelSize", fontLimitPixelSize );
1057  layer->setCustomProperty( "labeling/fontMinPixelSize", fontMinPixelSize );
1058  layer->setCustomProperty( "labeling/fontMaxPixelSize", fontMaxPixelSize );
1059  layer->setCustomProperty( "labeling/displayAll", displayAll );
1060  layer->setCustomProperty( "labeling/upsidedownLabels", ( unsigned int )upsidedownLabels );
1061 
1062  layer->setCustomProperty( "labeling/labelPerPart", labelPerPart );
1063  layer->setCustomProperty( "labeling/mergeLines", mergeLines );
1064  layer->setCustomProperty( "labeling/minFeatureSize", minFeatureSize );
1065  layer->setCustomProperty( "labeling/limitNumLabels", limitNumLabels );
1066  layer->setCustomProperty( "labeling/maxNumLabels", maxNumLabels );
1067  layer->setCustomProperty( "labeling/obstacle", obstacle );
1068 
1069  writeDataDefinedPropertyMap( layer, dataDefinedProperties );
1070 }
1071 
1073  bool active, bool useExpr, const QString& expr, const QString& field )
1074 {
1075  bool defaultVals = ( !active && !useExpr && expr.isEmpty() && field.isEmpty() );
1076 
1077  if ( dataDefinedProperties.contains( p ) )
1078  {
1079  QMap< QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* >::const_iterator it = dataDefinedProperties.find( p );
1080  if ( it != dataDefinedProperties.constEnd() )
1081  {
1082  QgsDataDefined* dd = it.value();
1083  dd->setActive( active );
1084  dd->setUseExpression( useExpr );
1085  dd->setExpressionString( expr );
1086  dd->setField( field );
1087  }
1088  }
1089  else if ( !defaultVals )
1090  {
1091  QgsDataDefined* dd = new QgsDataDefined( active, useExpr, expr, field );
1092  dataDefinedProperties.insert( p, dd );
1093  }
1094 }
1095 
1097 {
1098  QMap< DataDefinedProperties, QgsDataDefined* >::iterator it = dataDefinedProperties.find( p );
1099  if ( it != dataDefinedProperties.end() )
1100  {
1101  delete( it.value() );
1102  dataDefinedProperties.erase( it );
1103  }
1104 }
1105 
1106 QString QgsPalLayerSettings::updateDataDefinedString( const QString& value )
1107 {
1108  // TODO: update or remove this when project settings for labeling are migrated to better XML layout
1109  QString newValue = value;
1110  if ( !value.isEmpty() && !value.contains( "~~" ) )
1111  {
1112  QStringList values;
1113  values << "1"; // all old-style values are active if not empty
1114  values << "0";
1115  values << "";
1116  values << value; // all old-style values are only field names
1117  newValue = values.join( "~~" );
1118  }
1119 
1120  return newValue;
1121 }
1122 
1124 {
1125  QMap< QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* >::const_iterator it = dataDefinedProperties.find( p );
1126  if ( it != dataDefinedProperties.constEnd() )
1127  {
1128  return it.value();
1129  }
1130  return 0;
1131 }
1132 
1134 {
1135  QMap<QString, QString> map;
1136  QMap< QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* >::const_iterator it = dataDefinedProperties.find( p );
1137  if ( it != dataDefinedProperties.constEnd() )
1138  {
1139  return it.value()->toMap();
1140  }
1141  return map;
1142 }
1143 
1145 {
1146  if ( !dataDefinedProperties.contains( p ) )
1147  {
1148  return QVariant();
1149  }
1150 
1151  QgsDataDefined* dd = 0;
1152  QMap< DataDefinedProperties, QgsDataDefined* >::const_iterator it = dataDefinedProperties.find( p );
1153  if ( it != dataDefinedProperties.constEnd() )
1154  {
1155  dd = it.value();
1156  }
1157 
1158  if ( !dd )
1159  {
1160  return QVariant();
1161  }
1162 
1163  if ( !dd->isActive() )
1164  {
1165  return QVariant();
1166  }
1167 
1168  QVariant result = QVariant();
1169  bool useExpression = dd->useExpression();
1170  QString field = dd->field();
1171 
1172  //QgsDebugMsgLevel( QString( "isActive:" ) + isActive ? "1" : "0", 4 );
1173  //QgsDebugMsgLevel( QString( "useExpression:" ) + useExpression ? "1" : "0", 4 );
1174  //QgsDebugMsgLevel( QString( "expression:" ) + dd->expressionString(), 4 );
1175  //QgsDebugMsgLevel( QString( "field:" ) + field, 4 );
1176 
1177  if ( useExpression && dd->expressionIsPrepared() )
1178  {
1179  QgsExpression* expr = dd->expression();
1180  //QgsDebugMsgLevel( QString( "expr columns:" ) + expr->referencedColumns().join( "," ), 4 );
1181 
1182  result = expr->evaluate( &f );
1183  if ( expr->hasEvalError() )
1184  {
1185  QgsDebugMsgLevel( QString( "Evaluate error:" ) + expr->evalErrorString(), 4 );
1186  return QVariant();
1187  }
1188  }
1189  else if ( !useExpression && !field.isEmpty() )
1190  {
1191  // use direct attribute access instead of evaluating "field" expression (much faster)
1192  int indx = fields.indexFromName( field );
1193  if ( indx != -1 )
1194  {
1195  result = f.attribute( indx );
1196  }
1197  }
1198  return result;
1199 }
1200 
1202 {
1203  // null passed-around QVariant
1204  exprVal.clear();
1205 
1206  QVariant result = dataDefinedValue( p, *mCurFeat, *mCurFields );
1207 
1208  if ( result.isValid() ) // filter NULL values? i.e. && !result.isNull()
1209  {
1210  //QgsDebugMsgLevel( QString( "result type:" ) + QString( result.typeName() ), 4 );
1211  //QgsDebugMsgLevel( QString( "result string:" ) + result.toString(), 4 );
1212  exprVal = result;
1213  return true;
1214  }
1215 
1216  return false;
1217 }
1218 
1220 {
1221  bool isActive = false;
1222  QMap< DataDefinedProperties, QgsDataDefined* >::const_iterator it = dataDefinedProperties.find( p );
1223  if ( it != dataDefinedProperties.constEnd() )
1224  {
1225  isActive = it.value()->isActive();
1226  }
1227 
1228  return isActive;
1229 }
1230 
1232 {
1233  bool useExpression = false;
1234  QMap< DataDefinedProperties, QgsDataDefined* >::const_iterator it = dataDefinedProperties.find( p );
1235  if ( it != dataDefinedProperties.constEnd() )
1236  {
1237  useExpression = it.value()->useExpression();
1238  }
1239 
1240  return useExpression;
1241 }
1242 
1243 bool QgsPalLayerSettings::checkMinimumSizeMM( const QgsRenderContext& ct, QgsGeometry* geom, double minSize ) const
1244 {
1245  if ( minSize <= 0 )
1246  {
1247  return true;
1248  }
1249 
1250  if ( !geom )
1251  {
1252  return false;
1253  }
1254 
1255  QGis::GeometryType featureType = geom->type();
1256  if ( featureType == QGis::Point ) //minimum size does not apply to point features
1257  {
1258  return true;
1259  }
1260 
1261  double mapUnitsPerMM = ct.mapToPixel().mapUnitsPerPixel() * ct.scaleFactor();
1262  if ( featureType == QGis::Line )
1263  {
1264  double length = geom->length();
1265  if ( length >= 0.0 )
1266  {
1267  return ( length >= ( minSize * mapUnitsPerMM ) );
1268  }
1269  }
1270  else if ( featureType == QGis::Polygon )
1271  {
1272  double area = geom->area();
1273  if ( area >= 0.0 )
1274  {
1275  return ( sqrt( area ) >= ( minSize * mapUnitsPerMM ) );
1276  }
1277  }
1278  return true; //should never be reached. Return true in this case to label such geometries anyway.
1279 }
1280 
1281 void QgsPalLayerSettings::calculateLabelSize( const QFontMetricsF* fm, QString text, double& labelX, double& labelY, QgsFeature* f )
1282 {
1283  if ( !fm || !f )
1284  {
1285  return;
1286  }
1287 
1288  QString wrapchr = wrapChar;
1289  double multilineH = multilineHeight;
1290 
1291  bool addDirSymb = addDirectionSymbol;
1292  QString leftDirSymb = leftDirectionSymbol;
1293  QString rightDirSymb = rightDirectionSymbol;
1295 
1296  if ( f == mCurFeat ) // called internally, use any stored data defined values
1297  {
1298  if ( dataDefinedValues.contains( QgsPalLayerSettings::MultiLineWrapChar ) )
1299  {
1300  wrapchr = dataDefinedValues.value( QgsPalLayerSettings::MultiLineWrapChar ).toString();
1301  }
1302 
1303  if ( dataDefinedValues.contains( QgsPalLayerSettings::MultiLineHeight ) )
1304  {
1305  multilineH = dataDefinedValues.value( QgsPalLayerSettings::MultiLineHeight ).toDouble();
1306  }
1307 
1308  if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbDraw ) )
1309  {
1310  addDirSymb = dataDefinedValues.value( QgsPalLayerSettings::DirSymbDraw ).toBool();
1311  }
1312 
1313  if ( addDirSymb )
1314  {
1315 
1316  if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbLeft ) )
1317  {
1318  leftDirSymb = dataDefinedValues.value( QgsPalLayerSettings::DirSymbLeft ).toString();
1319  }
1320  if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbRight ) )
1321  {
1322  rightDirSymb = dataDefinedValues.value( QgsPalLayerSettings::DirSymbRight ).toString();
1323  }
1324 
1325  if ( dataDefinedValues.contains( QgsPalLayerSettings::DirSymbPlacement ) )
1326  {
1327  placeDirSymb = ( QgsPalLayerSettings::DirectionSymbols )dataDefinedValues.value( QgsPalLayerSettings::DirSymbPlacement ).toInt();
1328  }
1329 
1330  }
1331 
1332  }
1333  else // called externally with passed-in feature, evaluate data defined
1334  {
1336  if ( exprVal.isValid() )
1337  {
1338  wrapchr = exprVal.toString();
1339  }
1340  exprVal.clear();
1342  if ( exprVal.isValid() )
1343  {
1344  bool ok;
1345  double size = exprVal.toDouble( &ok );
1346  if ( ok )
1347  {
1348  multilineH = size;
1349  }
1350  }
1351 
1352  exprVal.clear();
1354  if ( exprVal.isValid() )
1355  {
1356  addDirSymb = exprVal.toBool();
1357  }
1358 
1359  if ( addDirSymb ) // don't do extra evaluations if not adding a direction symbol
1360  {
1361  exprVal.clear();
1363  if ( exprVal.isValid() )
1364  {
1365  leftDirSymb = exprVal.toString();
1366  }
1367  exprVal.clear();
1369  if ( exprVal.isValid() )
1370  {
1371  rightDirSymb = exprVal.toString();
1372  }
1373  exprVal.clear();
1375  if ( exprVal.isValid() )
1376  {
1377  bool ok;
1378  int enmint = exprVal.toInt( &ok );
1379  if ( ok )
1380  {
1381  placeDirSymb = ( QgsPalLayerSettings::DirectionSymbols )enmint;
1382  }
1383  }
1384  }
1385 
1386  }
1387 
1388  if ( wrapchr.isEmpty() )
1389  {
1390  wrapchr = QString( "\n" ); // default to new line delimiter
1391  }
1392 
1393  //consider the space needed for the direction symbol
1394  if ( addDirSymb && placement == QgsPalLayerSettings::Line
1395  && ( !leftDirSymb.isEmpty() || !rightDirSymb.isEmpty() ) )
1396  {
1397  QString dirSym = leftDirSymb;
1398 
1399  if ( fm->width( rightDirSymb ) > fm->width( dirSym ) )
1400  dirSym = rightDirSymb;
1401 
1402  if ( placeDirSymb == QgsPalLayerSettings::SymbolLeftRight )
1403  {
1404  text.append( dirSym );
1405  }
1406  else
1407  {
1408  text.prepend( dirSym + wrapchr ); // SymbolAbove or SymbolBelow
1409  }
1410  }
1411 
1412  double w = 0.0, h = 0.0;
1413  QStringList multiLineSplit = text.split( wrapchr );
1414  int lines = multiLineSplit.size();
1415 
1416  double labelHeight = fm->ascent() + fm->descent(); // ignore +1 for baseline
1417 
1418  h += fm->height() + ( double )(( lines - 1 ) * labelHeight * multilineH );
1419  h /= rasterCompressFactor;
1420 
1421  for ( int i = 0; i < lines; ++i )
1422  {
1423  double width = fm->width( multiLineSplit.at( i ) );
1424  if ( width > w )
1425  {
1426  w = width;
1427  }
1428  }
1429  w /= rasterCompressFactor;
1430 
1431 #if 0 // XXX strk
1432  QgsPoint ptSize = xform->toMapCoordinatesF( w, h );
1433  labelX = qAbs( ptSize.x() - ptZero.x() );
1434  labelY = qAbs( ptSize.y() - ptZero.y() );
1435 #else
1436  double uPP = xform->mapUnitsPerPixel();
1437  labelX = w * uPP;
1438  labelY = h * uPP;
1439 #endif
1440 }
1441 
1442 void QgsPalLayerSettings::registerFeature( QgsFeature& f, const QgsRenderContext& context, QString dxfLayer )
1443 {
1444  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
1445  mCurFeat = &f;
1446 // mCurFields = &layer->pendingFields();
1447 
1448  // store data defined-derived values for later adding to QgsPalGeometry for use during rendering
1449  dataDefinedValues.clear();
1450 
1451  // data defined show label? defaults to show label if not 0
1453  {
1454  bool showLabel = dataDefinedEvaluate( QgsPalLayerSettings::Show, exprVal );
1455  showLabel = exprVal.toBool();
1456  QgsDebugMsgLevel( QString( "exprVal Show:%1" ).arg( showLabel ? "true" : "false" ), 4 );
1457  if ( !showLabel )
1458  {
1459  return;
1460  }
1461  }
1462 
1463  // data defined scale visibility?
1464  bool useScaleVisibility = scaleVisibility;
1466  {
1467  QgsDebugMsgLevel( QString( "exprVal ScaleVisibility:%1" ).arg( exprVal.toBool() ? "true" : "false" ), 4 );
1468  useScaleVisibility = exprVal.toBool();
1469  }
1470 
1471  if ( useScaleVisibility )
1472  {
1473  // data defined min scale?
1474  double minScale = scaleMin;
1476  {
1477  QgsDebugMsgLevel( QString( "exprVal MinScale:%1" ).arg( exprVal.toDouble() ), 4 );
1478  bool conversionOk;
1479  double mins = exprVal.toDouble( &conversionOk );
1480  if ( conversionOk )
1481  {
1482  minScale = mins;
1483  }
1484  }
1485 
1486  // scales closer than 1:1
1487  if ( minScale < 0 )
1488  {
1489  minScale = 1 / qAbs( minScale );
1490  }
1491 
1492  if ( minScale != 0 && context.rendererScale() < minScale )
1493  {
1494  return;
1495  }
1496 
1497  // data defined max scale?
1498  double maxScale = scaleMax;
1500  {
1501  QgsDebugMsgLevel( QString( "exprVal MaxScale:%1" ).arg( exprVal.toDouble() ), 4 );
1502  bool conversionOk;
1503  double maxs = exprVal.toDouble( &conversionOk );
1504  if ( conversionOk )
1505  {
1506  maxScale = maxs;
1507  }
1508  }
1509 
1510  // scales closer than 1:1
1511  if ( maxScale < 0 )
1512  {
1513  maxScale = 1 / qAbs( maxScale );
1514  }
1515 
1516  if ( maxScale != 0 && context.rendererScale() > maxScale )
1517  {
1518  return;
1519  }
1520  }
1521 
1522  QFont labelFont = textFont;
1523  // labelFont will be added to label's QgsPalGeometry for use during label painting
1524 
1525  // data defined font units?
1528  {
1529  QString units = exprVal.toString().trimmed();
1530  QgsDebugMsgLevel( QString( "exprVal Font units:%1" ).arg( units ), 4 );
1531  if ( !units.isEmpty() )
1532  {
1533  fontunits = _decodeUnits( units );
1534  }
1535  }
1536 
1537  //data defined label size?
1538  double fontSize = labelFont.pointSizeF(); // font size doesn't have its own class data member
1540  {
1541  QgsDebugMsgLevel( QString( "exprVal Size:%1" ).arg( exprVal.toDouble() ), 4 );
1542  bool ok;
1543  double size = exprVal.toDouble( &ok );
1544  if ( ok )
1545  {
1546  fontSize = size;
1547  }
1548  }
1549  if ( fontSize <= 0.0 )
1550  {
1551  return;
1552  }
1553 
1554  int fontPixelSize = sizeToPixel( fontSize, context, fontunits, true, fontSizeMapUnitScale );
1555  // don't try to show font sizes less than 1 pixel (Qt complains)
1556  if ( fontPixelSize < 1 )
1557  {
1558  return;
1559  }
1560  labelFont.setPixelSize( fontPixelSize );
1561 
1562  // NOTE: labelFont now always has pixelSize set, so pointSize or pointSizeF might return -1
1563 
1564  // defined 'minimum/maximum pixel font size'?
1565  if ( fontunits == QgsPalLayerSettings::MapUnits )
1566  {
1567  bool useFontLimitPixelSize = fontLimitPixelSize;
1569  {
1570  QgsDebugMsgLevel( QString( "exprVal FontLimitPixel:%1" ).arg( exprVal.toBool() ? "true" : "false" ), 4 );
1571  useFontLimitPixelSize = exprVal.toBool();
1572  }
1573 
1574  if ( useFontLimitPixelSize )
1575  {
1576  int fontMinPixel = fontMinPixelSize;
1578  {
1579  bool ok;
1580  int sizeInt = exprVal.toInt( &ok );
1581  QgsDebugMsgLevel( QString( "exprVal FontMinPixel:%1" ).arg( sizeInt ), 4 );
1582  if ( ok )
1583  {
1584  fontMinPixel = sizeInt;
1585  }
1586  }
1587 
1588  int fontMaxPixel = fontMaxPixelSize;
1590  {
1591  bool ok;
1592  int sizeInt = exprVal.toInt( &ok );
1593  QgsDebugMsgLevel( QString( "exprVal FontMaxPixel:%1" ).arg( sizeInt ), 4 );
1594  if ( ok )
1595  {
1596  fontMaxPixel = sizeInt;
1597  }
1598  }
1599 
1600  if ( fontMinPixel > labelFont.pixelSize() || labelFont.pixelSize() > fontMaxPixel )
1601  {
1602  return;
1603  }
1604  }
1605  }
1606 
1607  // NOTE: the following parsing functions calculate and store any data defined values for later use in QgsPalLabeling::drawLabeling
1608  // this is done to provide clarity, and because such parsing is not directly related to PAL feature registration calculations
1609 
1610  // calculate rest of font attributes and store any data defined values
1611  // this is done here for later use in making label backgrounds part of collision management (when implemented)
1612  parseTextStyle( labelFont, fontunits, context );
1613  parseTextFormatting();
1614  parseTextBuffer();
1615  parseShapeBackground();
1616  parseDropShadow();
1617 
1618  QString labelText;
1619 
1620  // Check to see if we are a expression string.
1621  if ( isExpression )
1622  {
1624  if ( exp->hasParserError() )
1625  {
1626  QgsDebugMsgLevel( QString( "Expression parser error:%1" ).arg( exp->parserErrorString() ), 4 );
1627  return;
1628  }
1629  exp->setScale( context.rendererScale() );
1630 // QVariant result = exp->evaluate( &f, layer->pendingFields() );
1631  QVariant result = exp->evaluate( &f ); // expression prepared in QgsPalLabeling::prepareLayer()
1632  if ( exp->hasEvalError() )
1633  {
1634  QgsDebugMsgLevel( QString( "Expression parser eval error:%1" ).arg( exp->evalErrorString() ), 4 );
1635  return;
1636  }
1637  labelText = result.isNull() ? "" : result.toString();
1638  }
1639  else
1640  {
1641  const QVariant &v = f.attribute( fieldIndex );
1642  labelText = v.isNull() ? "" : v.toString();
1643  }
1644 
1645  // data defined format numbers?
1646  bool formatnum = formatNumbers;
1648  {
1649  formatnum = exprVal.toBool();
1650  QgsDebugMsgLevel( QString( "exprVal NumFormat:%1" ).arg( formatnum ? "true" : "false" ), 4 );
1651  }
1652 
1653  // format number if label text is coercible to a number
1654  if ( formatnum )
1655  {
1656  // data defined decimal places?
1657  int decimalPlaces = decimals;
1659  {
1660  bool ok;
1661  int dInt = exprVal.toInt( &ok );
1662  QgsDebugMsgLevel( QString( "exprVal NumDecimals:%1" ).arg( dInt ), 4 );
1663  if ( ok && dInt > 0 ) // needs to be positive
1664  {
1665  decimalPlaces = dInt;
1666  }
1667  }
1668 
1669  // data defined plus sign?
1670  bool signPlus = plusSign;
1672  {
1673  signPlus = exprVal.toBool();
1674  QgsDebugMsgLevel( QString( "exprVal NumPlusSign:%1" ).arg( signPlus ? "true" : "false" ), 4 );
1675  }
1676 
1677  QVariant textV( labelText );
1678  bool ok;
1679  double d = textV.toDouble( &ok );
1680  if ( ok )
1681  {
1682  QString numberFormat;
1683  if ( d > 0 && signPlus )
1684  {
1685  numberFormat.append( "+" );
1686  }
1687  numberFormat.append( "%1" );
1688  labelText = numberFormat.arg( d, 0, 'f', decimalPlaces );
1689  }
1690  }
1691 
1692 
1693  // NOTE: this should come AFTER any option that affects font metrics
1694  QFontMetricsF* labelFontMetrics = new QFontMetricsF( labelFont );
1695  double labelX, labelY; // will receive label size
1696  calculateLabelSize( labelFontMetrics, labelText, labelX, labelY, mCurFeat );
1697 
1698 
1699  // maximum angle between curved label characters (hardcoded defaults used in QGIS <2.0)
1700  //
1701  double maxcharanglein = 20.0; // range 20.0-60.0
1702  double maxcharangleout = -20.0; // range 20.0-95.0
1703 
1705  {
1706  maxcharanglein = maxCurvedCharAngleIn;
1707  maxcharangleout = maxCurvedCharAngleOut;
1708 
1709  //data defined maximum angle between curved label characters?
1711  {
1712  QString ptstr = exprVal.toString().trimmed();
1713  QgsDebugMsgLevel( QString( "exprVal CurvedCharAngleInOut:%1" ).arg( ptstr ), 4 );
1714 
1715  if ( !ptstr.isEmpty() )
1716  {
1717  QPointF maxcharanglePt = QgsSymbolLayerV2Utils::decodePoint( ptstr );
1718  maxcharanglein = qBound( 20.0, ( double )maxcharanglePt.x(), 60.0 );
1719  maxcharangleout = qBound( 20.0, ( double )maxcharanglePt.y(), 95.0 );
1720  }
1721  }
1722  // make sure maxcharangleout is always negative
1723  maxcharangleout = -( qAbs( maxcharangleout ) );
1724  }
1725 
1726  QgsGeometry* geom = f.geometry();
1727  if ( !geom )
1728  {
1729  return;
1730  }
1731 
1732  // reproject the geometry if necessary (but don't modify the features
1733  // geometry so that geometry based expression keep working)
1734  QScopedPointer<QgsGeometry> clonedGeometry;
1735  if ( ct )
1736  {
1737  geom = new QgsGeometry( *geom );
1738  clonedGeometry.reset( geom );
1739 
1740  try
1741  {
1742  geom->transform( *ct );
1743  }
1744  catch ( QgsCsException &cse )
1745  {
1746  Q_UNUSED( cse );
1747  QgsDebugMsgLevel( QString( "Ignoring feature %1 due transformation exception" ).arg( f.id() ), 4 );
1748  return;
1749  }
1750  }
1751 
1752  if ( !checkMinimumSizeMM( context, geom, minFeatureSize ) )
1753  {
1754  return;
1755  }
1756 
1757  // whether we're going to create a centroid for polygon
1758  bool centroidPoly = (( placement == QgsPalLayerSettings::AroundPoint
1760  && geom->type() == QGis::Polygon );
1761 
1762  // data defined centroid whole or clipped?
1763  bool wholeCentroid = centroidWhole;
1765  {
1766  QString str = exprVal.toString().trimmed();
1767  QgsDebugMsgLevel( QString( "exprVal CentroidWhole:%1" ).arg( str ), 4 );
1768 
1769  if ( !str.isEmpty() )
1770  {
1771  if ( str.compare( "Visible", Qt::CaseInsensitive ) == 0 )
1772  {
1773  wholeCentroid = false;
1774  }
1775  else if ( str.compare( "Whole", Qt::CaseInsensitive ) == 0 )
1776  {
1777  wholeCentroid = true;
1778  }
1779  }
1780  }
1781 
1782  if ( !geom->asGeos() )
1783  return; // there is something really wrong with the geometry
1784 
1785  // fix invalid polygons
1786  if ( geom->type() == QGis::Polygon && !geom->isGeosValid() )
1787  {
1788  QgsGeometry* bufferGeom = geom->buffer( 0, 0 );
1789  if ( !bufferGeom )
1790  {
1791  return;
1792  }
1793  geom = bufferGeom;
1794  clonedGeometry.reset( geom );
1795  }
1796 
1797  // Rotate the geometry if needed, before clipping
1798  const QgsMapToPixel& m2p = context.mapToPixel();
1799  if ( m2p.mapRotation() )
1800  {
1801  if ( geom->rotate( m2p.mapRotation(), context.extent().center() ) )
1802  {
1803  QgsDebugMsg( QString( "Error rotating geometry" ).arg( geom->exportToWkt() ) );
1804  return; // really ?
1805  }
1806  }
1807 
1808  // CLIP the geometry if it is bigger than the extent
1809  // don't clip if centroid is requested for whole feature
1810  bool do_clip = false;
1811  if ( !centroidPoly || ( centroidPoly && !wholeCentroid ) )
1812  {
1813  do_clip = !extentGeom->contains( geom );
1814  if ( do_clip )
1815  {
1816  QgsGeometry* clipGeom = geom->intersection( extentGeom ); // creates new geometry
1817  if ( !clipGeom )
1818  {
1819  return;
1820  }
1821  geom = clipGeom;
1822  clonedGeometry.reset( geom );
1823  }
1824  }
1825 
1826  const GEOSGeometry* geos_geom = geom->asGeos();
1827 
1828  if ( geos_geom == NULL )
1829  return; // invalid geometry
1830 
1831  // likelihood exists label will be registered with PAL and may be drawn
1832  // check if max number of features to label (already registered with PAL) has been reached
1833  // Debug output at end of QgsPalLabeling::drawLabeling(), when deleting temp geometries
1834  if ( limitNumLabels )
1835  {
1836  if ( !maxNumLabels )
1837  {
1838  return;
1839  }
1841  if ( mFeatsRegPal >= maxNumLabels )
1842  {
1843  return;
1844  }
1845 
1846  int divNum = ( int )((( double )mFeaturesToLabel / maxNumLabels ) + 0.5 );
1847  if ( divNum && ( mFeatsRegPal == ( int )( mFeatsSendingToPal / divNum ) ) )
1848  {
1849  mFeatsSendingToPal += 1;
1850  if ( divNum && mFeatsSendingToPal % divNum )
1851  {
1852  return;
1853  }
1854  }
1855  }
1856 
1857  GEOSGeometry* geos_geom_clone;
1858  if ( GEOSGeomTypeId_r( QgsGeometry::getGEOSHandler(), geos_geom ) == GEOS_POLYGON && repeatDistance > 0 && placement == Line )
1859  {
1860  geos_geom_clone = GEOSBoundary_r( QgsGeometry::getGEOSHandler(), geos_geom );
1861  }
1862  else
1863  {
1864  geos_geom_clone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom );
1865  }
1866 
1867  //data defined position / alignment / rotation?
1868  bool dataDefinedPosition = false;
1869  bool labelIsPinned = false;
1870  bool layerDefinedRotation = false;
1871  bool dataDefinedRotation = false;
1872  double xPos = 0.0, yPos = 0.0, angle = 0.0;
1873  bool ddXPos = false, ddYPos = false;
1874  double quadOffsetX = 0.0, quadOffsetY = 0.0;
1875  double offsetX = 0.0, offsetY = 0.0;
1876 
1877  //data defined quadrant offset?
1878  QuadrantPosition quadOff = quadOffset;
1880  {
1881  bool ok;
1882  int quadInt = exprVal.toInt( &ok );
1883  QgsDebugMsgLevel( QString( "exprVal OffsetQuad:%1" ).arg( quadInt ), 4 );
1884  if ( ok && 0 <= quadInt && quadInt <= 8 )
1885  {
1886  quadOff = ( QuadrantPosition )quadInt;
1887  }
1888  }
1889 
1890  // adjust quadrant offset of labels
1891  switch ( quadOff )
1892  {
1893  case QuadrantAboveLeft:
1894  quadOffsetX = -1.0;
1895  quadOffsetY = 1.0;
1896  break;
1897  case QuadrantAbove:
1898  quadOffsetX = 0.0;
1899  quadOffsetY = 1.0;
1900  break;
1901  case QuadrantAboveRight:
1902  quadOffsetX = 1.0;
1903  quadOffsetY = 1.0;
1904  break;
1905  case QuadrantLeft:
1906  quadOffsetX = -1.0;
1907  quadOffsetY = 0.0;
1908  break;
1909  case QuadrantRight:
1910  quadOffsetX = 1.0;
1911  quadOffsetY = 0.0;
1912  break;
1913  case QuadrantBelowLeft:
1914  quadOffsetX = -1.0;
1915  quadOffsetY = -1.0;
1916  break;
1917  case QuadrantBelow:
1918  quadOffsetX = 0.0;
1919  quadOffsetY = -1.0;
1920  break;
1921  case QuadrantBelowRight:
1922  quadOffsetX = 1.0;
1923  quadOffsetY = -1.0;
1924  break;
1925  case QuadrantOver:
1926  default:
1927  break;
1928  }
1929 
1930  //data defined label offset?
1931  double xOff = xOffset;
1932  double yOff = yOffset;
1934  {
1935  QString ptstr = exprVal.toString().trimmed();
1936  QgsDebugMsgLevel( QString( "exprVal OffsetXY:%1" ).arg( ptstr ), 4 );
1937 
1938  if ( !ptstr.isEmpty() )
1939  {
1940  QPointF ddOffPt = QgsSymbolLayerV2Utils::decodePoint( ptstr );
1941  xOff = ddOffPt.x();
1942  yOff = ddOffPt.y();
1943  }
1944  }
1945 
1946  // data defined label offset units?
1947  bool offinmapunits = labelOffsetInMapUnits;
1949  {
1950  QString units = exprVal.toString().trimmed();
1951  QgsDebugMsgLevel( QString( "exprVal OffsetUnits:%1" ).arg( units ), 4 );
1952  if ( !units.isEmpty() )
1953  {
1954  offinmapunits = ( _decodeUnits( units ) == QgsPalLayerSettings::MapUnits );
1955  }
1956  }
1957 
1958  // adjust offset of labels to match chosen unit and map scale
1959  // offsets match those of symbology: -x = left, -y = up
1960  double mapUntsPerMM = labelOffsetMapUnitScale.computeMapUnitsPerPixel( context ) * context.scaleFactor();
1961  if ( xOff != 0 )
1962  {
1963  offsetX = xOff; // must be positive to match symbology offset direction
1964  if ( !offinmapunits )
1965  {
1966  offsetX *= mapUntsPerMM; //convert offset from mm to map units
1967  }
1968  }
1969  if ( yOff != 0 )
1970  {
1971  offsetY = -yOff; // must be negative to match symbology offset direction
1972  if ( !offinmapunits )
1973  {
1974  offsetY *= mapUntsPerMM; //convert offset from mm to map units
1975  }
1976  }
1977 
1978  // layer defined rotation?
1979  // only rotate non-pinned OverPoint placements until other placements are supported in pal::Feature
1980  if ( placement == QgsPalLayerSettings::OverPoint && angleOffset != 0 )
1981  {
1982  layerDefinedRotation = true;
1983  angle = angleOffset * M_PI / 180; // convert to radians
1984  }
1985 
1986  //data defined rotation?
1988  {
1989  bool ok;
1990  double rotD = exprVal.toDouble( &ok );
1991  QgsDebugMsgLevel( QString( "exprVal Rotation:%1" ).arg( rotD ), 4 );
1992  if ( ok )
1993  {
1994  dataDefinedRotation = true;
1995  // TODO: add setting to disable having data defined rotation follow
1996  // map rotation ?
1997  rotD -= m2p.mapRotation();
1998  angle = rotD * M_PI / 180.0;
1999  }
2000  }
2001 
2003  {
2004  if ( !exprVal.isNull() )
2005  xPos = exprVal.toDouble( &ddXPos );
2006  QgsDebugMsgLevel( QString( "exprVal PositionX:%1" ).arg( xPos ), 4 );
2007 
2009  {
2010  //data defined position. But field values could be NULL -> positions will be generated by PAL
2011  if ( !exprVal.isNull() )
2012  yPos = exprVal.toDouble( &ddYPos );
2013  QgsDebugMsgLevel( QString( "exprVal PositionY:%1" ).arg( yPos ), 4 );
2014 
2015  if ( ddXPos && ddYPos )
2016  {
2017  dataDefinedPosition = true;
2018  labelIsPinned = true;
2019  // layer rotation set, but don't rotate pinned labels unless data defined
2020  if ( layerDefinedRotation && !dataDefinedRotation )
2021  {
2022  angle = 0.0;
2023  }
2024 
2025  //x/y shift in case of alignment
2026  double xdiff = 0.0;
2027  double ydiff = 0.0;
2028 
2029  //horizontal alignment
2031  {
2032  QString haliString = exprVal.toString();
2033  QgsDebugMsgLevel( QString( "exprVal Hali:%1" ).arg( haliString ), 4 );
2034  if ( haliString.compare( "Center", Qt::CaseInsensitive ) == 0 )
2035  {
2036  xdiff -= labelX / 2.0;
2037  }
2038  else if ( haliString.compare( "Right", Qt::CaseInsensitive ) == 0 )
2039  {
2040  xdiff -= labelX;
2041  }
2042  }
2043 
2044  //vertical alignment
2046  {
2047  QString valiString = exprVal.toString();
2048  QgsDebugMsgLevel( QString( "exprVal Vali:%1" ).arg( valiString ), 4 );
2049 
2050  if ( valiString.compare( "Bottom", Qt::CaseInsensitive ) != 0 )
2051  {
2052  if ( valiString.compare( "Top", Qt::CaseInsensitive ) == 0 )
2053  {
2054  ydiff -= labelY;
2055  }
2056  else
2057  {
2058  double descentRatio = labelFontMetrics->descent() / labelFontMetrics->height();
2059  if ( valiString.compare( "Base", Qt::CaseInsensitive ) == 0 )
2060  {
2061  ydiff -= labelY * descentRatio;
2062  }
2063  else //'Cap' or 'Half'
2064  {
2065  double capHeightRatio = ( labelFontMetrics->boundingRect( 'H' ).height() + 1 + labelFontMetrics->descent() ) / labelFontMetrics->height();
2066  ydiff -= labelY * capHeightRatio;
2067  if ( valiString.compare( "Half", Qt::CaseInsensitive ) == 0 )
2068  {
2069  ydiff += labelY * ( capHeightRatio - descentRatio ) / 2.0;
2070  }
2071  }
2072  }
2073  }
2074  }
2075 
2076  if ( dataDefinedRotation )
2077  {
2078  //adjust xdiff and ydiff because the hali/vali point needs to be the rotation center
2079  double xd = xdiff * cos( angle ) - ydiff * sin( angle );
2080  double yd = xdiff * sin( angle ) + ydiff * cos( angle );
2081  xdiff = xd;
2082  ydiff = yd;
2083  }
2084 
2085  //project xPos and yPos from layer to map CRS
2086  double z = 0;
2087  if ( ct )
2088  {
2089  try
2090  {
2091  ct->transformInPlace( xPos, yPos, z );
2092  }
2093  catch ( QgsCsException &e )
2094  {
2095  Q_UNUSED( e );
2096  QgsDebugMsgLevel( QString( "Ignoring feature %1 due transformation exception on data-defined position" ).arg( f.id() ), 4 );
2097  return;
2098  }
2099  }
2100 
2101  //rotate position with map if data-defined
2102  if ( dataDefinedPosition && m2p.mapRotation() )
2103  {
2104  const QgsPoint& center = context.extent().center();
2105  QTransform t = QTransform::fromTranslate( center.x(), center.y() );
2106  t.rotate( -m2p.mapRotation() );
2107  t.translate( -center.x(), -center.y() );
2108  qreal xPosR, yPosR;
2109  t.map( xPos, yPos, &xPosR, &yPosR );
2110  xPos = xPosR; yPos = yPosR;
2111  }
2112 
2113  xPos += xdiff;
2114  yPos += ydiff;
2115  }
2116  else
2117  {
2118  // only rotate non-pinned OverPoint placements until other placements are supported in pal::Feature
2119  if ( dataDefinedRotation && placement != QgsPalLayerSettings::OverPoint )
2120  {
2121  angle = 0.0;
2122  }
2123  }
2124  }
2125  }
2126 
2127  // data defined always show?
2128  bool alwaysShow = false;
2130  {
2131  alwaysShow = exprVal.toBool();
2132  }
2133 
2134  QgsPalGeometry* lbl = new QgsPalGeometry(
2135  f.id(),
2136  labelText,
2137  geos_geom_clone,
2138  labelFont.letterSpacing(),
2139  labelFont.wordSpacing(),
2140  placement == QgsPalLayerSettings::Curved );
2141 
2142  lbl->setDxfLayer( dxfLayer );
2143 
2144  // record the created geometry - it will be deleted at the end.
2145  geometries.append( lbl );
2146 
2147  // store the label's calculated font for later use during painting
2148 #if QT_VERSION >= 0x040800
2149  QgsDebugMsgLevel( QString( "PAL font stored definedFont: %1, Style: %2" ).arg( labelFont.toString() ).arg( labelFont.styleName() ), 4 );
2150 #endif
2151  lbl->setDefinedFont( labelFont );
2152 
2153  // set repeat distance
2154  // data defined repeat distance?
2155  double repeatDist = repeatDistance;
2157  {
2158  bool ok;
2159  double distD = exprVal.toDouble( &ok );
2160  if ( ok )
2161  {
2162  repeatDist = distD;
2163  }
2164  }
2165 
2166  // data defined label-repeat distance units?
2167  bool repeatdistinmapunit = repeatDistanceUnit == QgsPalLayerSettings::MapUnits;
2169  {
2170  QString units = exprVal.toString().trimmed();
2171  QgsDebugMsgLevel( QString( "exprVal RepeatDistanceUnits:%1" ).arg( units ), 4 );
2172  if ( !units.isEmpty() )
2173  {
2174  repeatdistinmapunit = ( _decodeUnits( units ) == QgsPalLayerSettings::MapUnits );
2175  }
2176  }
2177 
2178  if ( repeatDist != 0 )
2179  {
2180  if ( repeatdistinmapunit ) //convert distance from mm/map units to pixels
2181  {
2182  repeatDist /= repeatDistanceMapUnitScale.computeMapUnitsPerPixel( context ) * context.scaleFactor();
2183  }
2184  else //mm
2185  {
2186  repeatDist *= vectorScaleFactor;
2187  }
2188  repeatDist *= qAbs( ptOne.x() - ptZero.x() );
2189  }
2190 
2191  // feature to the layer
2192  try
2193  {
2194  if ( !palLayer->registerFeature( lbl->strId(), lbl, labelX, labelY, labelText.toUtf8().constData(),
2195  xPos, yPos, dataDefinedPosition, angle, dataDefinedRotation,
2196  quadOffsetX, quadOffsetY, offsetX, offsetY, alwaysShow, repeatDist ) )
2197  return;
2198  }
2199  catch ( std::exception &e )
2200  {
2201  Q_UNUSED( e );
2202  QgsDebugMsgLevel( QString( "Ignoring feature %1 due PAL exception:" ).arg( f.id() ) + QString::fromLatin1( e.what() ), 4 );
2203  return;
2204  }
2205 
2206  // TODO: only for placement which needs character info
2207  pal::Feature* feat = palLayer->getFeature( lbl->strId() );
2208  // account for any data defined font metrics adjustments
2209  feat->setLabelInfo( lbl->info( labelFontMetrics, xform, rasterCompressFactor, maxcharanglein, maxcharangleout ) );
2210  delete labelFontMetrics;
2211 
2212  // TODO: allow layer-wide feature dist in PAL...?
2213 
2214  // data defined label-feature distance?
2215  double distance = dist;
2217  {
2218  bool ok;
2219  double distD = exprVal.toDouble( &ok );
2220  if ( ok )
2221  {
2222  distance = distD;
2223  }
2224  }
2225 
2226  // data defined label-feature distance units?
2227  bool distinmapunit = distInMapUnits;
2229  {
2230  QString units = exprVal.toString().trimmed();
2231  QgsDebugMsgLevel( QString( "exprVal DistanceUnits:%1" ).arg( units ), 4 );
2232  if ( !units.isEmpty() )
2233  {
2234  distinmapunit = ( _decodeUnits( units ) == QgsPalLayerSettings::MapUnits );
2235  }
2236  }
2237 
2238  if ( distance != 0 )
2239  {
2240  if ( distinmapunit ) //convert distance from mm/map units to pixels
2241  {
2242  distance /= distMapUnitScale.computeMapUnitsPerPixel( context );
2243  }
2244  else //mm
2245  {
2246  distance *= vectorScaleFactor;
2247  }
2248  feat->setDistLabel( qAbs( ptOne.x() - ptZero.x() )* distance );
2249  }
2250 
2251 
2252  //add parameters for data defined labeling to QgsPalGeometry
2253  QMap< DataDefinedProperties, QVariant >::const_iterator dIt = dataDefinedValues.constBegin();
2254  for ( ; dIt != dataDefinedValues.constEnd(); ++dIt )
2255  {
2256  lbl->addDataDefinedValue( dIt.key(), dIt.value() );
2257  }
2258 
2259  // set geometry's pinned property
2260  lbl->setIsPinned( labelIsPinned );
2261 }
2262 
2263 bool QgsPalLayerSettings::dataDefinedValEval( const QString& valType,
2265  QVariant& exprVal )
2266 {
2267  if ( dataDefinedEvaluate( p, exprVal ) )
2268  {
2269  QString dbgStr = QString( "exprVal %1:" ).arg( mDataDefinedNames.value( p ).first ) + "%1";
2270 
2271  if ( valType == QString( "bool" ) )
2272  {
2273  bool bol = exprVal.toBool();
2274  QgsDebugMsgLevel( dbgStr.arg( bol ? "true" : "false" ), 4 );
2275  dataDefinedValues.insert( p, QVariant( bol ) );
2276  return true;
2277  }
2278  if ( valType == QString( "int" ) )
2279  {
2280  bool ok;
2281  int size = exprVal.toInt( &ok );
2282  QgsDebugMsgLevel( dbgStr.arg( size ), 4 );
2283 
2284  if ( ok )
2285  {
2286  dataDefinedValues.insert( p, QVariant( size ) );
2287  return true;
2288  }
2289  }
2290  if ( valType == QString( "intpos" ) )
2291  {
2292  bool ok;
2293  int size = exprVal.toInt( &ok );
2294  QgsDebugMsgLevel( dbgStr.arg( size ), 4 );
2295 
2296  if ( ok && size > 0 )
2297  {
2298  dataDefinedValues.insert( p, QVariant( size ) );
2299  return true;
2300  }
2301  }
2302  if ( valType == QString( "double" ) )
2303  {
2304  bool ok;
2305  double size = exprVal.toDouble( &ok );
2306  QgsDebugMsgLevel( dbgStr.arg( size ), 4 );
2307 
2308  if ( ok )
2309  {
2310  dataDefinedValues.insert( p, QVariant( size ) );
2311  return true;
2312  }
2313  }
2314  if ( valType == QString( "doublepos" ) )
2315  {
2316  bool ok;
2317  double size = exprVal.toDouble( &ok );
2318  QgsDebugMsgLevel( dbgStr.arg( size ), 4 );
2319 
2320  if ( ok && size > 0.0 )
2321  {
2322  dataDefinedValues.insert( p, QVariant( size ) );
2323  return true;
2324  }
2325  }
2326  if ( valType == QString( "rotation180" ) )
2327  {
2328  bool ok;
2329  double rot = exprVal.toDouble( &ok );
2330  QgsDebugMsgLevel( dbgStr.arg( rot ), 4 );
2331  if ( ok )
2332  {
2333  if ( rot < -180.0 && rot >= -360 )
2334  {
2335  rot += 360;
2336  }
2337  if ( rot > 180.0 && rot <= 360 )
2338  {
2339  rot -= 360;
2340  }
2341  if ( rot >= -180 && rot <= 180 )
2342  {
2343  dataDefinedValues.insert( p, QVariant( rot ) );
2344  return true;
2345  }
2346  }
2347  }
2348  if ( valType == QString( "transp" ) )
2349  {
2350  bool ok;
2351  int size = exprVal.toInt( &ok );
2352  QgsDebugMsgLevel( dbgStr.arg( size ), 4 );
2353  if ( ok && size >= 0 && size <= 100 )
2354  {
2355  dataDefinedValues.insert( p, QVariant( size ) );
2356  return true;
2357  }
2358  }
2359  if ( valType == QString( "string" ) )
2360  {
2361  QString str = exprVal.toString(); // don't trim whitespace
2362  QgsDebugMsgLevel( dbgStr.arg( str ), 4 );
2363 
2364  dataDefinedValues.insert( p, QVariant( str ) ); // let it stay empty if it is
2365  return true;
2366  }
2367  if ( valType == QString( "units" ) )
2368  {
2369  QString unitstr = exprVal.toString().trimmed();
2370  QgsDebugMsgLevel( dbgStr.arg( unitstr ), 4 );
2371 
2372  if ( !unitstr.isEmpty() )
2373  {
2374  dataDefinedValues.insert( p, QVariant(( int )_decodeUnits( unitstr ) ) );
2375  return true;
2376  }
2377  }
2378  if ( valType == QString( "color" ) )
2379  {
2380  QString colorstr = exprVal.toString().trimmed();
2381  QgsDebugMsgLevel( dbgStr.arg( colorstr ), 4 );
2382  QColor color = QgsSymbolLayerV2Utils::decodeColor( colorstr );
2383 
2384  if ( color.isValid() )
2385  {
2386  dataDefinedValues.insert( p, QVariant( color ) );
2387  return true;
2388  }
2389  }
2390  if ( valType == QString( "joinstyle" ) )
2391  {
2392  QString joinstr = exprVal.toString().trimmed();
2393  QgsDebugMsgLevel( dbgStr.arg( joinstr ), 4 );
2394 
2395  if ( !joinstr.isEmpty() )
2396  {
2397  dataDefinedValues.insert( p, QVariant(( int )_decodePenJoinStyle( joinstr ) ) );
2398  return true;
2399  }
2400  }
2401  if ( valType == QString( "blendmode" ) )
2402  {
2403  QString blendstr = exprVal.toString().trimmed();
2404  QgsDebugMsgLevel( dbgStr.arg( blendstr ), 4 );
2405 
2406  if ( !blendstr.isEmpty() )
2407  {
2408  dataDefinedValues.insert( p, QVariant(( int )QgsSymbolLayerV2Utils::decodeBlendMode( blendstr ) ) );
2409  return true;
2410  }
2411  }
2412  if ( valType == QString( "pointf" ) )
2413  {
2414  QString ptstr = exprVal.toString().trimmed();
2415  QgsDebugMsgLevel( dbgStr.arg( ptstr ), 4 );
2416 
2417  if ( !ptstr.isEmpty() )
2418  {
2419  dataDefinedValues.insert( p, QVariant( QgsSymbolLayerV2Utils::decodePoint( ptstr ) ) );
2420  return true;
2421  }
2422  }
2423  }
2424  return false;
2425 }
2426 
2427 void QgsPalLayerSettings::parseTextStyle( QFont& labelFont,
2429  const QgsRenderContext& context )
2430 {
2431  // NOTE: labelFont already has pixelSize set, so pointSize or pointSizeF might return -1
2432 
2433  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
2434 
2435  // Two ways to generate new data defined font:
2436  // 1) Family + [bold] + [italic] (named style is ignored and font is built off of base family)
2437  // 2) Family + named style (bold or italic is ignored)
2438 
2439  // data defined font family?
2440  QString ddFontFamily( "" );
2442  {
2443  QString family = exprVal.toString().trimmed();
2444  QgsDebugMsgLevel( QString( "exprVal Font family:%1" ).arg( family ), 4 );
2445 
2446  if ( labelFont.family() != family )
2447  {
2448  // testing for ddFontFamily in QFontDatabase.families() may be slow to do for every feature
2449  // (i.e. don't use QgsFontUtils::fontFamilyMatchOnSystem( family ) here)
2450  if ( QgsFontUtils::fontFamilyOnSystem( family ) )
2451  {
2452  ddFontFamily = family;
2453  }
2454  }
2455  }
2456 
2457  // data defined named font style?
2458  QString ddFontStyle( "" );
2460  {
2461  QString fontstyle = exprVal.toString().trimmed();
2462  QgsDebugMsgLevel( QString( "exprVal Font style:%1" ).arg( fontstyle ), 4 );
2463  ddFontStyle = fontstyle;
2464  }
2465 
2466  // data defined bold font style?
2467  bool ddBold = false;
2469  {
2470  bool bold = exprVal.toBool();
2471  QgsDebugMsgLevel( QString( "exprVal Font bold:%1" ).arg( bold ? "true" : "false" ), 4 );
2472  ddBold = bold;
2473  }
2474 
2475  // data defined italic font style?
2476  bool ddItalic = false;
2478  {
2479  bool italic = exprVal.toBool();
2480  QgsDebugMsgLevel( QString( "exprVal Font italic:%1" ).arg( italic ? "true" : "false" ), 4 );
2481  ddItalic = italic;
2482  }
2483 
2484  // TODO: update when pref for how to resolve missing family (use matching algorithm or just default font) is implemented
2485  // (currently defaults to what has been read in from layer settings)
2486  QFont newFont;
2487  QFont appFont = QApplication::font();
2488  bool newFontBuilt = false;
2489  if ( ddBold || ddItalic )
2490  {
2491  // new font needs built, since existing style needs removed
2492  newFont = QFont( !ddFontFamily.isEmpty() ? ddFontFamily : labelFont.family() );
2493  newFontBuilt = true;
2494  newFont.setBold( ddBold );
2495  newFont.setItalic( ddItalic );
2496  }
2497  else if ( !ddFontStyle.isEmpty()
2498  && ddFontStyle.compare( "Ignore", Qt::CaseInsensitive ) != 0 )
2499  {
2500  if ( !ddFontFamily.isEmpty() )
2501  {
2502  // both family and style are different, build font from database
2503  QFont styledfont = mFontDB.font( ddFontFamily, ddFontStyle, appFont.pointSize() );
2504  if ( appFont != styledfont )
2505  {
2506  newFont = styledfont;
2507  newFontBuilt = true;
2508  }
2509  }
2510 
2511  // update the font face style
2512  QgsFontUtils::updateFontViaStyle( newFontBuilt ? newFont : labelFont, ddFontStyle );
2513  }
2514  else if ( !ddFontFamily.isEmpty() )
2515  {
2516  if ( ddFontStyle.compare( "Ignore", Qt::CaseInsensitive ) != 0 )
2517  {
2518  // just family is different, build font from database
2519  QFont styledfont = mFontDB.font( ddFontFamily, textNamedStyle, appFont.pointSize() );
2520  if ( appFont != styledfont )
2521  {
2522  newFont = styledfont;
2523  newFontBuilt = true;
2524  }
2525  }
2526  else
2527  {
2528  newFont = QFont( ddFontFamily );
2529  newFontBuilt = true;
2530  }
2531  }
2532 
2533  if ( newFontBuilt )
2534  {
2535  // copy over existing font settings
2536  //newFont = newFont.resolve( labelFont ); // should work, but let's be sure what's being copied
2537  newFont.setPixelSize( labelFont.pixelSize() );
2538  newFont.setCapitalization( labelFont.capitalization() );
2539  newFont.setUnderline( labelFont.underline() );
2540  newFont.setStrikeOut( labelFont.strikeOut() );
2541  newFont.setWordSpacing( labelFont.wordSpacing() );
2542  newFont.setLetterSpacing( QFont::AbsoluteSpacing, labelFont.letterSpacing() );
2543 
2544  labelFont = newFont;
2545  }
2546 
2547  // data defined word spacing?
2548  double wordspace = labelFont.wordSpacing();
2550  {
2551  bool ok;
2552  double wspacing = exprVal.toDouble( &ok );
2553  QgsDebugMsgLevel( QString( "exprVal FontWordSpacing:%1" ).arg( wspacing ), 4 );
2554  if ( ok )
2555  {
2556  wordspace = wspacing;
2557  }
2558  }
2559  labelFont.setWordSpacing( sizeToPixel( wordspace, context, fontunits, false, fontSizeMapUnitScale ) );
2560 
2561  // data defined letter spacing?
2562  double letterspace = labelFont.letterSpacing();
2564  {
2565  bool ok;
2566  double lspacing = exprVal.toDouble( &ok );
2567  QgsDebugMsgLevel( QString( "exprVal FontLetterSpacing:%1" ).arg( lspacing ), 4 );
2568  if ( ok )
2569  {
2570  letterspace = lspacing;
2571  }
2572  }
2573  labelFont.setLetterSpacing( QFont::AbsoluteSpacing, sizeToPixel( letterspace, context, fontunits, false, fontSizeMapUnitScale ) );
2574 
2575  // data defined font capitalization?
2576  QFont::Capitalization fontcaps = labelFont.capitalization();
2578  {
2579  QString fcase = exprVal.toString().trimmed();
2580  QgsDebugMsgLevel( QString( "exprVal FontCase:%1" ).arg( fcase ), 4 );
2581 
2582  if ( !fcase.isEmpty() )
2583  {
2584  if ( fcase.compare( "NoChange", Qt::CaseInsensitive ) == 0 )
2585  {
2586  fontcaps = QFont::MixedCase;
2587  }
2588  else if ( fcase.compare( "Upper", Qt::CaseInsensitive ) == 0 )
2589  {
2590  fontcaps = QFont::AllUppercase;
2591  }
2592  else if ( fcase.compare( "Lower", Qt::CaseInsensitive ) == 0 )
2593  {
2594  fontcaps = QFont::AllLowercase;
2595  }
2596  else if ( fcase.compare( "Capitalize", Qt::CaseInsensitive ) == 0 )
2597  {
2598  fontcaps = QFont::Capitalize;
2599  }
2600 
2601  if ( fontcaps != labelFont.capitalization() )
2602  {
2603  labelFont.setCapitalization( fontcaps );
2604  }
2605  }
2606  }
2607 
2608  // data defined strikeout font style?
2610  {
2611  bool strikeout = exprVal.toBool();
2612  QgsDebugMsgLevel( QString( "exprVal Font strikeout:%1" ).arg( strikeout ? "true" : "false" ), 4 );
2613  labelFont.setStrikeOut( strikeout );
2614  }
2615 
2616  // data defined underline font style?
2618  {
2619  bool underline = exprVal.toBool();
2620  QgsDebugMsgLevel( QString( "exprVal Font underline:%1" ).arg( underline ? "true" : "false" ), 4 );
2621  labelFont.setUnderline( underline );
2622  }
2623 
2624  // pass the rest on to QgsPalLabeling::drawLabeling
2625 
2626  // data defined font color?
2627  dataDefinedValEval( "color", QgsPalLayerSettings::Color, exprVal );
2628 
2629  // data defined font transparency?
2630  dataDefinedValEval( "transp", QgsPalLayerSettings::FontTransp, exprVal );
2631 
2632  // data defined font blend mode?
2633  dataDefinedValEval( "blendmode", QgsPalLayerSettings::FontBlendMode, exprVal );
2634 
2635 }
2636 
2637 void QgsPalLayerSettings::parseTextBuffer()
2638 {
2639  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
2640 
2641  // data defined draw buffer?
2642  bool drawBuffer = bufferDraw;
2643  if ( dataDefinedValEval( "bool", QgsPalLayerSettings::BufferDraw, exprVal ) )
2644  {
2645  drawBuffer = exprVal.toBool();
2646  }
2647 
2648  if ( !drawBuffer )
2649  {
2650  return;
2651  }
2652 
2653  // data defined buffer size?
2654  double bufrSize = bufferSize;
2655  if ( dataDefinedValEval( "doublepos", QgsPalLayerSettings::BufferSize, exprVal ) )
2656  {
2657  bufrSize = exprVal.toDouble();
2658  }
2659 
2660  // data defined buffer transparency?
2661  int bufTransp = bufferTransp;
2662  if ( dataDefinedValEval( "transp", QgsPalLayerSettings::BufferTransp, exprVal ) )
2663  {
2664  bufTransp = exprVal.toInt();
2665  }
2666 
2667  drawBuffer = ( drawBuffer && bufrSize > 0.0 && bufTransp < 100 );
2668 
2669  if ( !drawBuffer )
2670  {
2671  dataDefinedValues.insert( QgsPalLayerSettings::BufferDraw, QVariant( false ) ); // trigger value
2672  dataDefinedValues.remove( QgsPalLayerSettings::BufferSize );
2673  dataDefinedValues.remove( QgsPalLayerSettings::BufferTransp );
2674  return; // don't bother evaluating values that won't be used
2675  }
2676 
2677  // data defined buffer units?
2678  dataDefinedValEval( "units", QgsPalLayerSettings::BufferUnit, exprVal );
2679 
2680  // data defined buffer color?
2681  dataDefinedValEval( "color", QgsPalLayerSettings::BufferColor, exprVal );
2682 
2683  // data defined buffer pen join style?
2684  dataDefinedValEval( "joinstyle", QgsPalLayerSettings::BufferJoinStyle, exprVal );
2685 
2686  // data defined buffer blend mode?
2687  dataDefinedValEval( "blendmode", QgsPalLayerSettings::BufferBlendMode, exprVal );
2688 }
2689 
2690 void QgsPalLayerSettings::parseTextFormatting()
2691 {
2692  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
2693 
2694  // data defined multiline wrap character?
2695  QString wrapchr = wrapChar;
2696  if ( dataDefinedValEval( "string", QgsPalLayerSettings::MultiLineWrapChar, exprVal ) )
2697  {
2698  wrapchr = exprVal.toString();
2699  }
2700 
2701  // data defined multiline height?
2702  dataDefinedValEval( "double", QgsPalLayerSettings::MultiLineHeight, exprVal );
2703 
2704  // data defined multiline text align?
2706  {
2707  QString str = exprVal.toString().trimmed();
2708  QgsDebugMsgLevel( QString( "exprVal MultiLineAlignment:%1" ).arg( str ), 4 );
2709 
2710  if ( !str.isEmpty() )
2711  {
2712  // "Left"
2714 
2715  if ( str.compare( "Center", Qt::CaseInsensitive ) == 0 )
2716  {
2718  }
2719  else if ( str.compare( "Right", Qt::CaseInsensitive ) == 0 )
2720  {
2721  aligntype = QgsPalLayerSettings::MultiRight;
2722  }
2723  else if ( str.compare( "Follow", Qt::CaseInsensitive ) == 0 )
2724  {
2726  }
2727  dataDefinedValues.insert( QgsPalLayerSettings::MultiLineAlignment, QVariant(( int )aligntype ) );
2728  }
2729  }
2730 
2731  // data defined direction symbol?
2732  bool drawDirSymb = addDirectionSymbol;
2733  if ( dataDefinedValEval( "bool", QgsPalLayerSettings::DirSymbDraw, exprVal ) )
2734  {
2735  drawDirSymb = exprVal.toBool();
2736  }
2737 
2738  if ( drawDirSymb )
2739  {
2740  // data defined direction left symbol?
2741  dataDefinedValEval( "string", QgsPalLayerSettings::DirSymbLeft, exprVal );
2742 
2743  // data defined direction right symbol?
2744  dataDefinedValEval( "string", QgsPalLayerSettings::DirSymbRight, exprVal );
2745 
2746  // data defined direction symbol placement?
2748  {
2749  QString str = exprVal.toString().trimmed();
2750  QgsDebugMsgLevel( QString( "exprVal DirSymbPlacement:%1" ).arg( str ), 4 );
2751 
2752  if ( !str.isEmpty() )
2753  {
2754  // "LeftRight"
2756 
2757  if ( str.compare( "Above", Qt::CaseInsensitive ) == 0 )
2758  {
2760  }
2761  else if ( str.compare( "Below", Qt::CaseInsensitive ) == 0 )
2762  {
2764  }
2765  dataDefinedValues.insert( QgsPalLayerSettings::DirSymbPlacement, QVariant(( int )placetype ) );
2766  }
2767  }
2768 
2769  // data defined direction symbol reversed?
2770  dataDefinedValEval( "bool", QgsPalLayerSettings::DirSymbReverse, exprVal );
2771  }
2772 
2773  // formatting for numbers is inline with generation of base label text and not passed to label painting
2774 }
2775 
2776 void QgsPalLayerSettings::parseShapeBackground()
2777 {
2778  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
2779 
2780  // data defined draw shape?
2781  bool drawShape = shapeDraw;
2782  if ( dataDefinedValEval( "bool", QgsPalLayerSettings::ShapeDraw, exprVal ) )
2783  {
2784  drawShape = exprVal.toBool();
2785  }
2786 
2787  if ( !drawShape )
2788  {
2789  return;
2790  }
2791 
2792  // data defined shape transparency?
2793  int shapeTransp = shapeTransparency;
2794  if ( dataDefinedValEval( "transp", QgsPalLayerSettings::ShapeTransparency, exprVal ) )
2795  {
2796  shapeTransp = exprVal.toInt();
2797  }
2798 
2799  drawShape = ( drawShape && shapeTransp < 100 ); // size is not taken into account (could be)
2800 
2801  if ( !drawShape )
2802  {
2803  dataDefinedValues.insert( QgsPalLayerSettings::ShapeDraw, QVariant( false ) ); // trigger value
2804  dataDefinedValues.remove( QgsPalLayerSettings::ShapeTransparency );
2805  return; // don't bother evaluating values that won't be used
2806  }
2807 
2808  // data defined shape kind?
2811  {
2812  QString skind = exprVal.toString().trimmed();
2813  QgsDebugMsgLevel( QString( "exprVal ShapeKind:%1" ).arg( skind ), 4 );
2814 
2815  if ( !skind.isEmpty() )
2816  {
2817  // "Rectangle"
2819 
2820  if ( skind.compare( "Square", Qt::CaseInsensitive ) == 0 )
2821  {
2823  }
2824  else if ( skind.compare( "Ellipse", Qt::CaseInsensitive ) == 0 )
2825  {
2827  }
2828  else if ( skind.compare( "Circle", Qt::CaseInsensitive ) == 0 )
2829  {
2831  }
2832  else if ( skind.compare( "SVG", Qt::CaseInsensitive ) == 0 )
2833  {
2835  }
2836  shapeKind = shpkind;
2837  dataDefinedValues.insert( QgsPalLayerSettings::ShapeKind, QVariant(( int )shpkind ) );
2838  }
2839  }
2840 
2841  // data defined shape SVG path?
2842  QString svgPath = shapeSVGFile;
2844  {
2845  QString svgfile = exprVal.toString().trimmed();
2846  QgsDebugMsgLevel( QString( "exprVal ShapeSVGFile:%1" ).arg( svgfile ), 4 );
2847 
2848  // '' empty paths are allowed
2849  svgPath = svgfile;
2850  dataDefinedValues.insert( QgsPalLayerSettings::ShapeSVGFile, QVariant( svgfile ) );
2851  }
2852 
2853  // data defined shape size type?
2856  {
2857  QString stype = exprVal.toString().trimmed();
2858  QgsDebugMsgLevel( QString( "exprVal ShapeSizeType:%1" ).arg( stype ), 4 );
2859 
2860  if ( !stype.isEmpty() )
2861  {
2862  // "Buffer"
2864 
2865  if ( stype.compare( "Fixed", Qt::CaseInsensitive ) == 0 )
2866  {
2868  }
2869  shpSizeType = sizType;
2870  dataDefinedValues.insert( QgsPalLayerSettings::ShapeSizeType, QVariant(( int )sizType ) );
2871  }
2872  }
2873 
2874  // data defined shape size X? (SVGs only use X for sizing)
2875  double ddShpSizeX = shapeSize.x();
2876  if ( dataDefinedValEval( "double", QgsPalLayerSettings::ShapeSizeX, exprVal ) )
2877  {
2878  ddShpSizeX = exprVal.toDouble();
2879  }
2880 
2881  // data defined shape size Y?
2882  double ddShpSizeY = shapeSize.y();
2883  if ( dataDefinedValEval( "double", QgsPalLayerSettings::ShapeSizeY, exprVal ) )
2884  {
2885  ddShpSizeY = exprVal.toDouble();
2886  }
2887 
2888  // don't continue under certain circumstances (e.g. size is fixed)
2889  bool skip = false;
2890  if ( shapeKind == QgsPalLayerSettings::ShapeSVG
2891  && ( svgPath.isEmpty()
2892  || ( !svgPath.isEmpty()
2893  && shpSizeType == QgsPalLayerSettings::SizeFixed
2894  && ddShpSizeX == 0.0 ) ) )
2895  {
2896  skip = true;
2897  }
2898  if ( shapeKind != QgsPalLayerSettings::ShapeSVG
2899  && shpSizeType == QgsPalLayerSettings::SizeFixed
2900  && ( ddShpSizeX == 0.0 || ddShpSizeY == 0.0 ) )
2901  {
2902  skip = true;
2903  }
2904 
2905  if ( skip )
2906  {
2907  dataDefinedValues.insert( QgsPalLayerSettings::ShapeDraw, QVariant( false ) ); // trigger value
2908  dataDefinedValues.remove( QgsPalLayerSettings::ShapeTransparency );
2909  dataDefinedValues.remove( QgsPalLayerSettings::ShapeKind );
2910  dataDefinedValues.remove( QgsPalLayerSettings::ShapeSVGFile );
2911  dataDefinedValues.remove( QgsPalLayerSettings::ShapeSizeX );
2912  dataDefinedValues.remove( QgsPalLayerSettings::ShapeSizeY );
2913  return; // don't bother evaluating values that won't be used
2914  }
2915 
2916  // data defined shape size units?
2917  dataDefinedValEval( "units", QgsPalLayerSettings::ShapeSizeUnits, exprVal );
2918 
2919  // data defined shape rotation type?
2921  {
2922  QString rotstr = exprVal.toString().trimmed();
2923  QgsDebugMsgLevel( QString( "exprVal ShapeRotationType:%1" ).arg( rotstr ), 4 );
2924 
2925  if ( !rotstr.isEmpty() )
2926  {
2927  // "Sync"
2929 
2930  if ( rotstr.compare( "Offset", Qt::CaseInsensitive ) == 0 )
2931  {
2933  }
2934  else if ( rotstr.compare( "Fixed", Qt::CaseInsensitive ) == 0 )
2935  {
2937  }
2938  dataDefinedValues.insert( QgsPalLayerSettings::ShapeRotationType, QVariant(( int )rottype ) );
2939  }
2940  }
2941 
2942  // data defined shape rotation?
2943  dataDefinedValEval( "rotation180", QgsPalLayerSettings::ShapeRotation, exprVal );
2944 
2945  // data defined shape offset?
2946  dataDefinedValEval( "pointf", QgsPalLayerSettings::ShapeOffset, exprVal );
2947 
2948  // data defined shape offset units?
2949  dataDefinedValEval( "units", QgsPalLayerSettings::ShapeOffsetUnits, exprVal );
2950 
2951  // data defined shape radii?
2952  dataDefinedValEval( "pointf", QgsPalLayerSettings::ShapeRadii, exprVal );
2953 
2954  // data defined shape radii units?
2955  dataDefinedValEval( "units", QgsPalLayerSettings::ShapeRadiiUnits, exprVal );
2956 
2957  // data defined shape blend mode?
2958  dataDefinedValEval( "blendmode", QgsPalLayerSettings::ShapeBlendMode, exprVal );
2959 
2960  // data defined shape fill color?
2961  dataDefinedValEval( "color", QgsPalLayerSettings::ShapeFillColor, exprVal );
2962 
2963  // data defined shape border color?
2964  dataDefinedValEval( "color", QgsPalLayerSettings::ShapeBorderColor, exprVal );
2965 
2966  // data defined shape border width?
2967  dataDefinedValEval( "doublepos", QgsPalLayerSettings::ShapeBorderWidth, exprVal );
2968 
2969  // data defined shape border width units?
2970  dataDefinedValEval( "units", QgsPalLayerSettings::ShapeBorderWidthUnits, exprVal );
2971 
2972  // data defined shape join style?
2973  dataDefinedValEval( "joinstyle", QgsPalLayerSettings::ShapeJoinStyle, exprVal );
2974 
2975 }
2976 
2977 void QgsPalLayerSettings::parseDropShadow()
2978 {
2979  QVariant exprVal; // value() is repeatedly nulled on data defined evaluation and replaced when successful
2980 
2981  // data defined draw shadow?
2982  bool drawShadow = shadowDraw;
2983  if ( dataDefinedValEval( "bool", QgsPalLayerSettings::ShadowDraw, exprVal ) )
2984  {
2985  drawShadow = exprVal.toBool();
2986  }
2987 
2988  if ( !drawShadow )
2989  {
2990  return;
2991  }
2992 
2993  // data defined shadow transparency?
2994  int shadowTransp = shadowTransparency;
2995  if ( dataDefinedValEval( "transp", QgsPalLayerSettings::ShadowTransparency, exprVal ) )
2996  {
2997  shadowTransp = exprVal.toInt();
2998  }
2999 
3000  // data defined shadow offset distance?
3001  double shadowOffDist = shadowOffsetDist;
3002  if ( dataDefinedValEval( "doublepos", QgsPalLayerSettings::ShadowOffsetDist, exprVal ) )
3003  {
3004  shadowOffDist = exprVal.toDouble();
3005  }
3006 
3007  // data defined shadow offset distance?
3008  double shadowRad = shadowRadius;
3009  if ( dataDefinedValEval( "doublepos", QgsPalLayerSettings::ShadowRadius, exprVal ) )
3010  {
3011  shadowRad = exprVal.toDouble();
3012  }
3013 
3014  drawShadow = ( drawShadow && shadowTransp < 100 && !( shadowOffDist == 0.0 && shadowRad == 0.0 ) );
3015 
3016  if ( !drawShadow )
3017  {
3018  dataDefinedValues.insert( QgsPalLayerSettings::ShadowDraw, QVariant( false ) ); // trigger value
3019  dataDefinedValues.remove( QgsPalLayerSettings::ShadowTransparency );
3020  dataDefinedValues.remove( QgsPalLayerSettings::ShadowOffsetDist );
3021  dataDefinedValues.remove( QgsPalLayerSettings::ShadowRadius );
3022  return; // don't bother evaluating values that won't be used
3023  }
3024 
3025  // data defined shadow under type?
3027  {
3028  QString str = exprVal.toString().trimmed();
3029  QgsDebugMsgLevel( QString( "exprVal ShadowUnder:%1" ).arg( str ), 4 );
3030 
3031  if ( !str.isEmpty() )
3032  {
3033  // "Lowest"
3035 
3036  if ( str.compare( "Text", Qt::CaseInsensitive ) == 0 )
3037  {
3039  }
3040  else if ( str.compare( "Buffer", Qt::CaseInsensitive ) == 0 )
3041  {
3043  }
3044  else if ( str.compare( "Background", Qt::CaseInsensitive ) == 0 )
3045  {
3047  }
3048  dataDefinedValues.insert( QgsPalLayerSettings::ShadowUnder, QVariant(( int )shdwtype ) );
3049  }
3050  }
3051 
3052  // data defined shadow offset angle?
3053  dataDefinedValEval( "rotation180", QgsPalLayerSettings::ShadowOffsetAngle, exprVal );
3054 
3055  // data defined shadow offset units?
3056  dataDefinedValEval( "units", QgsPalLayerSettings::ShadowOffsetUnits, exprVal );
3057 
3058  // data defined shadow radius?
3059  dataDefinedValEval( "double", QgsPalLayerSettings::ShadowRadius, exprVal );
3060 
3061  // data defined shadow radius units?
3062  dataDefinedValEval( "units", QgsPalLayerSettings::ShadowRadiusUnits, exprVal );
3063 
3064  // data defined shadow scale? ( gui bounds to 0-2000, no upper bound here )
3065  dataDefinedValEval( "intpos", QgsPalLayerSettings::ShadowScale, exprVal );
3066 
3067  // data defined shadow color?
3068  dataDefinedValEval( "color", QgsPalLayerSettings::ShadowColor, exprVal );
3069 
3070  // data defined shadow blend mode?
3071  dataDefinedValEval( "blendmode", QgsPalLayerSettings::ShadowBlendMode, exprVal );
3072 }
3073 
3074 int QgsPalLayerSettings::sizeToPixel( double size, const QgsRenderContext& c, SizeUnit unit, bool rasterfactor, const QgsMapUnitScale& mapUnitScale ) const
3075 {
3076  return ( int )( scaleToPixelContext( size, c, unit, rasterfactor, mapUnitScale ) + 0.5 );
3077 }
3078 
3079 double QgsPalLayerSettings::scaleToPixelContext( double size, const QgsRenderContext& c, SizeUnit unit, bool rasterfactor, const QgsMapUnitScale& mapUnitScale ) const
3080 {
3081  // if render context is that of device (i.e. not a scaled map), just return size
3082  double mapUnitsPerPixel = mapUnitScale.computeMapUnitsPerPixel( c );
3083 
3084  if ( unit == MapUnits && mapUnitsPerPixel > 0.0 )
3085  {
3086  size = size / mapUnitsPerPixel * ( rasterfactor ? c.rasterScaleFactor() : 1 );
3087  }
3088  else // e.g. in points or mm
3089  {
3090  double ptsTomm = ( unit == Points ? 0.352778 : 1 );
3091  size *= ptsTomm * c.scaleFactor() * ( rasterfactor ? c.rasterScaleFactor() : 1 );
3092  }
3093  return size;
3094 }
3095 
3096 // -------------
3097 
3099  : mMapSettings( NULL ), mPal( NULL )
3100  , mResults( 0 )
3101 {
3102 
3103  // find out engine defaults
3104  Pal p;
3105  mCandPoint = p.getPointP();
3106  mCandLine = p.getLineP();
3107  mCandPolygon = p.getPolyP();
3108 
3109  switch ( p.getSearch() )
3110  {
3111  case CHAIN: mSearch = Chain; break;
3112  case POPMUSIC_TABU: mSearch = Popmusic_Tabu; break;
3113  case POPMUSIC_CHAIN: mSearch = Popmusic_Chain; break;
3115  case FALP: mSearch = Falp; break;
3116  }
3117 
3118  mShowingCandidates = false;
3119  mShowingShadowRects = false;
3120  mShowingAllLabels = false;
3122  mDrawOutlineLabels = true;
3123 }
3124 
3126 {
3127  // make sure we've freed everything
3128  exit();
3129 
3131 
3132  delete mResults;
3133  mResults = 0;
3134 }
3135 
3137 {
3138  return staticWillUseLayer( layer );
3139 }
3140 
3141 bool QgsPalLabeling::staticWillUseLayer( const QString& layerID )
3142 {
3143  QgsVectorLayer* layer = qobject_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( layerID ) );
3144  if ( !layer )
3145  return false;
3146  return staticWillUseLayer( layer );
3147 }
3148 
3149 
3151 {
3152  // don't do QgsPalLayerSettings::readFromLayer( layer ) if not needed
3153  bool enabled = false;
3154  if ( layer->customProperty( "labeling" ).toString() == QString( "pal" ) )
3155  enabled = layer->customProperty( "labeling/enabled", QVariant( false ) ).toBool();
3156 
3157  return enabled;
3158 }
3159 
3160 
3162 {
3163  QHash<QString, QgsPalLayerSettings>::iterator lit;
3164  for ( lit = mActiveLayers.begin(); lit != mActiveLayers.end(); ++lit )
3165  {
3166  clearActiveLayer( lit.key() );
3167  }
3168  mActiveLayers.clear();
3169 }
3170 
3171 void QgsPalLabeling::clearActiveLayer( const QString &layerID )
3172 {
3173  QgsPalLayerSettings& lyr = mActiveLayers[layerID];
3174 
3175  // delete all QgsDataDefined objects (which also deletes their QgsExpression object)
3176  QMap< QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* >::iterator it = lyr.dataDefinedProperties.begin();
3177  for ( ; it != lyr.dataDefinedProperties.constEnd(); ++it )
3178  {
3179  delete( it.value() );
3180  it.value() = 0;
3181  }
3182  lyr.dataDefinedProperties.clear();
3183 }
3184 
3185 int QgsPalLabeling::prepareLayer( QgsVectorLayer* layer, QStringList& attrNames, QgsRenderContext& ctx )
3186 {
3187  Q_ASSERT( mMapSettings != NULL );
3188 
3189  if ( !willUseLayer( layer ) )
3190  {
3191  return 0;
3192  }
3193 
3194  QgsDebugMsgLevel( "PREPARE LAYER " + layer->id(), 4 );
3195 
3196  // start with a temporary settings class, find out labeling info
3197  QgsPalLayerSettings lyrTmp;
3198  lyrTmp.readFromLayer( layer );
3199 
3200  if ( lyrTmp.fieldName.isEmpty() )
3201  {
3202  return 0;
3203  }
3204 
3205  if ( lyrTmp.isExpression )
3206  {
3207  QgsExpression exp( lyrTmp.fieldName );
3208  if ( exp.hasEvalError() )
3209  {
3210  QgsDebugMsgLevel( "Prepare error:" + exp.evalErrorString(), 4 );
3211  return 0;
3212  }
3213  }
3214  else
3215  {
3216  // If we aren't an expression, we check to see if we can find the column.
3217  if ( layer->fieldNameIndex( lyrTmp.fieldName ) == -1 )
3218  {
3219  return 0;
3220  }
3221  }
3222 
3223  // add layer settings to the pallabeling hashtable: <QgsVectorLayer*, QgsPalLayerSettings>
3224  mActiveLayers.insert( layer->id(), lyrTmp );
3225  // start using the reference to the layer in hashtable instead of local instance
3226  QgsPalLayerSettings& lyr = mActiveLayers[layer->id()];
3227 
3228  lyr.mCurFields = &( layer->pendingFields() );
3229 
3230  // add field indices for label's text, from expression or field
3231  if ( lyr.isExpression )
3232  {
3233  // prepare expression for use in QgsPalLayerSettings::registerFeature()
3234  QgsExpression* exp = lyr.getLabelExpression();
3235  exp->prepare( layer->pendingFields() );
3236  if ( exp->hasEvalError() )
3237  {
3238  QgsDebugMsgLevel( "Prepare error:" + exp->evalErrorString(), 4 );
3239  }
3240  foreach ( QString name, exp->referencedColumns() )
3241  {
3242  QgsDebugMsgLevel( "REFERENCED COLUMN = " + name, 4 );
3243  attrNames.append( name );
3244  }
3245  }
3246  else
3247  {
3248  attrNames.append( lyr.fieldName );
3249  }
3250 
3251  // add field indices of data defined expression or field
3252  QMap< QgsPalLayerSettings::DataDefinedProperties, QgsDataDefined* >::const_iterator dIt = lyr.dataDefinedProperties.constBegin();
3253  for ( ; dIt != lyr.dataDefinedProperties.constEnd(); ++dIt )
3254  {
3255  QgsDataDefined* dd = dIt.value();
3256  if ( !dd->isActive() )
3257  {
3258  continue;
3259  }
3260 
3261  // NOTE: the following also prepares any expressions for later use
3262 
3263  // store parameters for data defined expressions
3264  QMap<QString, QVariant> exprParams;
3265  exprParams.insert( "scale", ctx.rendererScale() );
3266 
3267  dd->setExpressionParams( exprParams );
3268 
3269  // this will return columns for expressions or field name, depending upon what is set to be used
3270  QStringList cols = dd->referencedColumns( layer ); // <-- prepares any expressions, too
3271 
3272  //QgsDebugMsgLevel( QString( "Data defined referenced columns:" ) + cols.join( "," ), 4 );
3273  foreach ( QString name, cols )
3274  {
3275  attrNames.append( name );
3276  }
3277  }
3278 
3279  // how to place the labels
3280  Arrangement arrangement;
3281  switch ( lyr.placement )
3282  {
3283  case QgsPalLayerSettings::AroundPoint: arrangement = P_POINT; break;
3284  case QgsPalLayerSettings::OverPoint: arrangement = P_POINT_OVER; break;
3285  case QgsPalLayerSettings::Line: arrangement = P_LINE; break;
3286  case QgsPalLayerSettings::Curved: arrangement = P_CURVED; break;
3287  case QgsPalLayerSettings::Horizontal: arrangement = P_HORIZ; break;
3288  case QgsPalLayerSettings::Free: arrangement = P_FREE; break;
3289  default: Q_ASSERT( "unsupported placement" && 0 ); return 0;
3290  }
3291 
3292  // create the pal layer
3293  double priority = 1 - lyr.priority / 10.0; // convert 0..10 --> 1..0
3294  double min_scale = -1, max_scale = -1;
3295 
3296  // handled in QgsPalLayerSettings::registerFeature now
3297  //if ( lyr.scaleVisibility && !lyr.dataDefinedIsActive( QgsPalLayerSettings::ScaleVisibility ) )
3298  //{
3299  // min_scale = lyr.scaleMin;
3300  // max_scale = lyr.scaleMax;
3301  //}
3302 
3303  Layer* l = mPal->addLayer( layer->id().toUtf8().data(),
3304  min_scale, max_scale, arrangement,
3305  METER, priority, lyr.obstacle, true, true,
3306  lyr.displayAll );
3307 
3308  if ( lyr.placementFlags )
3310 
3311  // set label mode (label per feature is the default)
3312  l->setLabelMode( lyr.labelPerPart ? Layer::LabelPerFeaturePart : Layer::LabelPerFeature );
3313 
3314  // set whether adjacent lines should be merged
3316 
3317 
3318  // set whether location of centroid must be inside of polygons
3320 
3321  // set how to show upside-down labels
3322  Layer::UpsideDownLabels upsdnlabels;
3323  switch ( lyr.upsidedownLabels )
3324  {
3325  case QgsPalLayerSettings::Upright: upsdnlabels = Layer::Upright; break;
3326  case QgsPalLayerSettings::ShowDefined: upsdnlabels = Layer::ShowDefined; break;
3327  case QgsPalLayerSettings::ShowAll: upsdnlabels = Layer::ShowAll; break;
3328  default: Q_ASSERT( "unsupported upside-down label setting" && 0 ); return 0;
3329  }
3330  l->setUpsidedownLabels( upsdnlabels );
3331 
3332 // // fix for font size in map units causing font to show pointsize at small map scales
3333 // int pixelFontSize = lyr.sizeToPixel( lyr.textFont.pointSizeF(), ctx,
3334 // lyr.fontSizeInMapUnits ? QgsPalLayerSettings::MapUnits : QgsPalLayerSettings::Points,
3335 // true );
3336 
3337 // if ( pixelFontSize < 1 )
3338 // {
3339 // lyr.textFont.setPointSize( 1 );
3340 // lyr.textFont.setPixelSize( 1 );
3341 // }
3342 // else
3343 // {
3344 // lyr.textFont.setPixelSize( pixelFontSize );
3345 // }
3346 
3347 // // scale spacing sizes if using map units
3348 // if ( lyr.fontSizeInMapUnits )
3349 // {
3350 // double spacingPixelSize;
3351 // if ( lyr.textFont.wordSpacing() != 0 )
3352 // {
3353 // spacingPixelSize = lyr.textFont.wordSpacing() / ctx.mapToPixel().mapUnitsPerPixel() * ctx.rasterScaleFactor();
3354 // lyr.textFont.setWordSpacing( spacingPixelSize );
3355 // }
3356 
3357 // if ( lyr.textFont.letterSpacing() != 0 )
3358 // {
3359 // spacingPixelSize = lyr.textFont.letterSpacing() / ctx.mapToPixel().mapUnitsPerPixel() * ctx.rasterScaleFactor();
3360 // lyr.textFont.setLetterSpacing( QFont::AbsoluteSpacing, spacingPixelSize );
3361 // }
3362 // }
3363 
3364  //raster and vector scale factors
3365  lyr.vectorScaleFactor = ctx.scaleFactor();
3367 
3368  // save the pal layer to our layer context (with some additional info)
3369  lyr.palLayer = l;
3370  lyr.fieldIndex = layer->fieldNameIndex( lyr.fieldName );
3371 
3372  lyr.xform = &mMapSettings->mapToPixel();
3373  lyr.ct = 0;
3375  lyr.ct = new QgsCoordinateTransform( layer->crs(), mMapSettings->destinationCrs() );
3376  lyr.ptZero = lyr.xform->toMapCoordinates( 0, 0 );
3377  lyr.ptOne = lyr.xform->toMapCoordinates( 1, 0 );
3378 
3379  // rect for clipping
3381 
3382  lyr.mFeatsSendingToPal = 0;
3383 
3384  return 1; // init successful
3385 }
3386 
3388 {
3389  Layer* l = mPal->addLayer( layer->id().append( "d" ).toUtf8().data(), -1, -1, pal::Arrangement( s->placement ), METER, s->priority, s->obstacle, true, true );
3391 
3392  mActiveDiagramLayers.insert( layer->id(), *s );
3393  // initialize the local copy
3395 
3396  s2.palLayer = l;
3397  s2.ct = 0;
3399  s2.ct = new QgsCoordinateTransform( layer->crs(), mMapSettings->destinationCrs() );
3400 
3401  s2.xform = &mMapSettings->mapToPixel();
3402 
3403  s2.fields = layer->pendingFields();
3404 
3405  s2.renderer = layer->diagramRenderer()->clone();
3406 
3407  return 1;
3408 }
3409 
3410 void QgsPalLabeling::registerFeature( const QString& layerID, QgsFeature& f, const QgsRenderContext& context, QString dxfLayer )
3411 {
3412  QgsPalLayerSettings& lyr = mActiveLayers[layerID];
3413  lyr.registerFeature( f, context, dxfLayer );
3414 }
3415 
3416 void QgsPalLabeling::registerDiagramFeature( const QString& layerID, QgsFeature& feat, const QgsRenderContext& context )
3417 {
3418  //get diagram layer settings, diagram renderer
3419  QHash<QString, QgsDiagramLayerSettings>::iterator layerIt = mActiveDiagramLayers.find( layerID );
3420  if ( layerIt == mActiveDiagramLayers.constEnd() )
3421  {
3422  return;
3423  }
3424 
3425  //convert geom to geos
3426  QgsGeometry* geom = feat.geometry();
3427 
3428  // reproject the geometry if necessary (but don't modify the features
3429  // geometry so that geometry based expression keep working)
3430  QScopedPointer<QgsGeometry> clonedGeometry;
3431  if ( layerIt.value().ct )
3432  {
3433  geom = new QgsGeometry( *geom );
3434  clonedGeometry.reset( geom );
3435 
3436  try
3437  {
3438  geom->transform( *( layerIt.value().ct ) );
3439  }
3440  catch ( QgsCsException &cse )
3441  {
3442  Q_UNUSED( cse );
3443  QgsDebugMsgLevel( QString( "Ignoring feature %1 due transformation exception" ).arg( feat.id() ), 4 );
3444  return;
3445  }
3446  }
3447 
3448  const GEOSGeometry* geos_geom = geom->asGeos();
3449  if ( geos_geom == 0 )
3450  {
3451  return; // invalid geometry
3452  }
3453 
3454  //create PALGeometry with diagram = true
3455  QgsPalGeometry* lbl = new QgsPalGeometry( feat.id(), "", GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom ) );
3456  lbl->setIsDiagram( true );
3457 
3458  // record the created geometry - it will be deleted at the end.
3459  layerIt.value().geometries.append( lbl );
3460 
3461  double diagramWidth = 0;
3462  double diagramHeight = 0;
3463  QgsDiagramRendererV2* dr = layerIt.value().renderer;
3464  if ( dr )
3465  {
3466  QSizeF diagSize = dr->sizeMapUnits( feat, context );
3467  if ( diagSize.isValid() )
3468  {
3469  diagramWidth = diagSize.width();
3470  diagramHeight = diagSize.height();
3471  }
3472 
3473  //append the diagram attributes to lbl
3474  lbl->setDiagramAttributes( feat.attributes() );
3475  }
3476 
3477  // feature to the layer
3478  int ddColX = layerIt.value().xPosColumn;
3479  int ddColY = layerIt.value().yPosColumn;
3480  double ddPosX = 0.0;
3481  double ddPosY = 0.0;
3482  bool ddPos = ( ddColX >= 0 && ddColY >= 0 );
3483  if ( ddPos )
3484  {
3485  bool posXOk, posYOk;
3486  //data defined diagram position is always centered
3487  ddPosX = feat.attribute( ddColX ).toDouble( &posXOk ) - diagramWidth / 2.0;
3488  ddPosY = feat.attribute( ddColY ).toDouble( &posYOk ) - diagramHeight / 2.0;
3489  if ( !posXOk || !posYOk )
3490  {
3491  ddPos = false;
3492  }
3493  else
3494  {
3495  const QgsCoordinateTransform* ct = layerIt.value().ct;
3496  if ( ct )
3497  {
3498  double z = 0;
3499  ct->transformInPlace( ddPosX, ddPosY, z );
3500  }
3501  }
3502  }
3503 
3504  try
3505  {
3506  if ( !layerIt.value().palLayer->registerFeature( lbl->strId(), lbl, diagramWidth, diagramHeight, "", ddPosX, ddPosY, ddPos ) )
3507  {
3508  return;
3509  }
3510  }
3511  catch ( std::exception &e )
3512  {
3513  Q_UNUSED( e );
3514  QgsDebugMsgLevel( QString( "Ignoring feature %1 due PAL exception:" ).arg( feat.id() ) + QString::fromLatin1( e.what() ), 4 );
3515  return;
3516  }
3517 
3518  pal::Feature* palFeat = layerIt.value().palLayer->getFeature( lbl->strId() );
3519  QgsPoint ptZero = layerIt.value().xform->toMapCoordinates( 0, 0 );
3520  QgsPoint ptOne = layerIt.value().xform->toMapCoordinates( 1, 0 );
3521  palFeat->setDistLabel( qAbs( ptOne.x() - ptZero.x() ) * layerIt.value().dist );
3522 }
3523 
3524 
3526 {
3527  init( mr->mapSettings() );
3528 }
3529 
3530 void QgsPalLabeling::init( const QgsMapSettings& mapSettings )
3531 {
3532  mMapSettings = &mapSettings;
3533 
3534  // delete if exists already
3535  if ( mPal )
3536  delete mPal;
3537 
3538  mPal = new Pal;
3539 
3540  SearchMethod s;
3541  switch ( mSearch )
3542  {
3543  default:
3544  case Chain: s = CHAIN; break;
3545  case Popmusic_Tabu: s = POPMUSIC_TABU; break;
3546  case Popmusic_Chain: s = POPMUSIC_CHAIN; break;
3547  case Popmusic_Tabu_Chain: s = POPMUSIC_TABU_CHAIN; break;
3548  case Falp: s = FALP; break;
3549  }
3550  mPal->setSearch( s );
3551 
3552  // set number of candidates generated per feature
3554  mPal->setLineP( mCandLine );
3556 
3558 
3559  clearActiveLayers(); // free any previous QgsDataDefined objects
3560  mActiveDiagramLayers.clear();
3561 }
3562 
3564 {
3565  delete mPal;
3566  mPal = NULL;
3567  mMapSettings = NULL;
3568 }
3569 
3570 QgsPalLayerSettings& QgsPalLabeling::layer( const QString& layerName )
3571 {
3572  QHash<QString, QgsPalLayerSettings>::iterator lit;
3573  for ( lit = mActiveLayers.begin(); lit != mActiveLayers.end(); ++lit )
3574  {
3575  if ( lit.key() == layerName )
3576  {
3577  return lit.value();
3578  }
3579  }
3580  return mInvalidLayerSettings;
3581 }
3582 
3584  const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant >& ddValues )
3585 {
3586  //font color
3587  if ( ddValues.contains( QgsPalLayerSettings::Color ) )
3588  {
3589  QVariant ddColor = ddValues.value( QgsPalLayerSettings::Color );
3590  tmpLyr.textColor = ddColor.value<QColor>();
3591  }
3592 
3593  //font transparency
3594  if ( ddValues.contains( QgsPalLayerSettings::FontTransp ) )
3595  {
3596  tmpLyr.textTransp = ddValues.value( QgsPalLayerSettings::FontTransp ).toInt();
3597  }
3598 
3599  tmpLyr.textColor.setAlphaF(( 100.0 - ( double )( tmpLyr.textTransp ) ) / 100.0 );
3600 
3601  //font blend mode
3602  if ( ddValues.contains( QgsPalLayerSettings::FontBlendMode ) )
3603  {
3604  tmpLyr.blendMode = ( QPainter::CompositionMode )ddValues.value( QgsPalLayerSettings::FontBlendMode ).toInt();
3605  }
3606 }
3607 
3609  const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant >& ddValues )
3610 {
3611  if ( ddValues.contains( QgsPalLayerSettings::MultiLineWrapChar ) )
3612  {
3613  tmpLyr.wrapChar = ddValues.value( QgsPalLayerSettings::MultiLineWrapChar ).toString();
3614  }
3615 
3616  if ( !tmpLyr.wrapChar.isEmpty() || tmpLyr.getLabelExpression()->expression().contains( "wordwrap" ) )
3617  {
3618 
3619  if ( ddValues.contains( QgsPalLayerSettings::MultiLineHeight ) )
3620  {
3621  tmpLyr.multilineHeight = ddValues.value( QgsPalLayerSettings::MultiLineHeight ).toDouble();
3622  }
3623 
3624  if ( ddValues.contains( QgsPalLayerSettings::MultiLineAlignment ) )
3625  {
3627  }
3628 
3629  }
3630 
3631  if ( ddValues.contains( QgsPalLayerSettings::DirSymbDraw ) )
3632  {
3633  tmpLyr.addDirectionSymbol = ddValues.value( QgsPalLayerSettings::DirSymbDraw ).toBool();
3634  }
3635 
3636  if ( tmpLyr.addDirectionSymbol )
3637  {
3638 
3639  if ( ddValues.contains( QgsPalLayerSettings::DirSymbLeft ) )
3640  {
3641  tmpLyr.leftDirectionSymbol = ddValues.value( QgsPalLayerSettings::DirSymbLeft ).toString();
3642  }
3643  if ( ddValues.contains( QgsPalLayerSettings::DirSymbRight ) )
3644  {
3645  tmpLyr.rightDirectionSymbol = ddValues.value( QgsPalLayerSettings::DirSymbRight ).toString();
3646  }
3647 
3648  if ( ddValues.contains( QgsPalLayerSettings::DirSymbPlacement ) )
3649  {
3651  }
3652 
3653  if ( ddValues.contains( QgsPalLayerSettings::DirSymbReverse ) )
3654  {
3655  tmpLyr.reverseDirectionSymbol = ddValues.value( QgsPalLayerSettings::DirSymbReverse ).toBool();
3656  }
3657 
3658  }
3659 }
3660 
3662  const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant >& ddValues )
3663 {
3664  //buffer draw
3665  if ( ddValues.contains( QgsPalLayerSettings::BufferDraw ) )
3666  {
3667  tmpLyr.bufferDraw = ddValues.value( QgsPalLayerSettings::BufferDraw ).toBool();
3668  }
3669 
3670  if ( !tmpLyr.bufferDraw )
3671  {
3672  // tmpLyr.bufferSize > 0.0 && tmpLyr.bufferTransp < 100 figured in during evaluation
3673  return; // don't continue looking for unused values
3674  }
3675 
3676  //buffer size
3677  if ( ddValues.contains( QgsPalLayerSettings::BufferSize ) )
3678  {
3679  tmpLyr.bufferSize = ddValues.value( QgsPalLayerSettings::BufferSize ).toDouble();
3680  }
3681 
3682  //buffer transparency
3683  if ( ddValues.contains( QgsPalLayerSettings::BufferTransp ) )
3684  {
3685  tmpLyr.bufferTransp = ddValues.value( QgsPalLayerSettings::BufferTransp ).toInt();
3686  }
3687 
3688  //buffer size units
3689  if ( ddValues.contains( QgsPalLayerSettings::BufferUnit ) )
3690  {
3692  tmpLyr.bufferSizeInMapUnits = ( bufunit == QgsPalLayerSettings::MapUnits );
3693  }
3694 
3695  //buffer color
3696  if ( ddValues.contains( QgsPalLayerSettings::BufferColor ) )
3697  {
3698  QVariant ddColor = ddValues.value( QgsPalLayerSettings::BufferColor );
3699  tmpLyr.bufferColor = ddColor.value<QColor>();
3700  }
3701 
3702  // apply any transparency
3703  tmpLyr.bufferColor.setAlphaF(( 100.0 - ( double )( tmpLyr.bufferTransp ) ) / 100.0 );
3704 
3705  //buffer pen join style
3706  if ( ddValues.contains( QgsPalLayerSettings::BufferJoinStyle ) )
3707  {
3708  tmpLyr.bufferJoinStyle = ( Qt::PenJoinStyle )ddValues.value( QgsPalLayerSettings::BufferJoinStyle ).toInt();
3709  }
3710 
3711  //buffer blend mode
3712  if ( ddValues.contains( QgsPalLayerSettings::BufferBlendMode ) )
3713  {
3714  tmpLyr.bufferBlendMode = ( QPainter::CompositionMode )ddValues.value( QgsPalLayerSettings::BufferBlendMode ).toInt();
3715  }
3716 }
3717 
3719  const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant >& ddValues )
3720 {
3721  //shape draw
3722  if ( ddValues.contains( QgsPalLayerSettings::ShapeDraw ) )
3723  {
3724  tmpLyr.shapeDraw = ddValues.value( QgsPalLayerSettings::ShapeDraw ).toBool();
3725  }
3726 
3727  if ( !tmpLyr.shapeDraw )
3728  {
3729  return; // don't continue looking for unused values
3730  }
3731 
3732  if ( ddValues.contains( QgsPalLayerSettings::ShapeKind ) )
3733  {
3734  tmpLyr.shapeType = ( QgsPalLayerSettings::ShapeType )ddValues.value( QgsPalLayerSettings::ShapeKind ).toInt();
3735  }
3736 
3737  if ( ddValues.contains( QgsPalLayerSettings::ShapeSVGFile ) )
3738  {
3739  tmpLyr.shapeSVGFile = ddValues.value( QgsPalLayerSettings::ShapeSVGFile ).toString();
3740  }
3741 
3742  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeType ) )
3743  {
3745  }
3746 
3747  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeX ) )
3748  {
3749  tmpLyr.shapeSize.setX( ddValues.value( QgsPalLayerSettings::ShapeSizeX ).toDouble() );
3750  }
3751  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeY ) )
3752  {
3753  tmpLyr.shapeSize.setY( ddValues.value( QgsPalLayerSettings::ShapeSizeY ).toDouble() );
3754  }
3755 
3756  if ( ddValues.contains( QgsPalLayerSettings::ShapeSizeUnits ) )
3757  {
3759  }
3760 
3761  if ( ddValues.contains( QgsPalLayerSettings::ShapeRotationType ) )
3762  {
3764  }
3765 
3766  if ( ddValues.contains( QgsPalLayerSettings::ShapeRotation ) )
3767  {
3768  tmpLyr.shapeRotation = ddValues.value( QgsPalLayerSettings::ShapeRotation ).toDouble();
3769  }
3770 
3771  if ( ddValues.contains( QgsPalLayerSettings::ShapeOffset ) )
3772  {
3773  tmpLyr.shapeOffset = ddValues.value( QgsPalLayerSettings::ShapeOffset ).toPointF();
3774  }
3775 
3776  if ( ddValues.contains( QgsPalLayerSettings::ShapeOffsetUnits ) )
3777  {
3779  }
3780 
3781  if ( ddValues.contains( QgsPalLayerSettings::ShapeRadii ) )
3782  {
3783  tmpLyr.shapeRadii = ddValues.value( QgsPalLayerSettings::ShapeRadii ).toPointF();
3784  }
3785 
3786  if ( ddValues.contains( QgsPalLayerSettings::ShapeRadiiUnits ) )
3787  {
3789  }
3790 
3791  if ( ddValues.contains( QgsPalLayerSettings::ShapeTransparency ) )
3792  {
3793  tmpLyr.shapeTransparency = ddValues.value( QgsPalLayerSettings::ShapeTransparency ).toInt();
3794  }
3795 
3796  if ( ddValues.contains( QgsPalLayerSettings::ShapeBlendMode ) )
3797  {
3798  tmpLyr.shapeBlendMode = ( QPainter::CompositionMode )ddValues.value( QgsPalLayerSettings::ShapeBlendMode ).toInt();
3799  }
3800 
3801  if ( ddValues.contains( QgsPalLayerSettings::ShapeFillColor ) )
3802  {
3803  QVariant ddColor = ddValues.value( QgsPalLayerSettings::ShapeFillColor );
3804  tmpLyr.shapeFillColor = ddColor.value<QColor>();
3805  }
3806 
3807  if ( ddValues.contains( QgsPalLayerSettings::ShapeBorderColor ) )
3808  {
3809  QVariant ddColor = ddValues.value( QgsPalLayerSettings::ShapeBorderColor );
3810  tmpLyr.shapeBorderColor = ddColor.value<QColor>();
3811  }
3812 
3813  if ( ddValues.contains( QgsPalLayerSettings::ShapeBorderWidth ) )
3814  {
3815  tmpLyr.shapeBorderWidth = ddValues.value( QgsPalLayerSettings::ShapeBorderWidth ).toDouble();
3816  }
3817 
3818  if ( ddValues.contains( QgsPalLayerSettings::ShapeBorderWidthUnits ) )
3819  {
3821  }
3822 
3823  if ( ddValues.contains( QgsPalLayerSettings::ShapeJoinStyle ) )
3824  {
3825  tmpLyr.shapeJoinStyle = ( Qt::PenJoinStyle )ddValues.value( QgsPalLayerSettings::ShapeJoinStyle ).toInt();
3826  }
3827 }
3828 
3830  const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant >& ddValues )
3831 {
3832  //shadow draw
3833  if ( ddValues.contains( QgsPalLayerSettings::ShadowDraw ) )
3834  {
3835  tmpLyr.shadowDraw = ddValues.value( QgsPalLayerSettings::ShadowDraw ).toBool();
3836  }
3837 
3838  if ( !tmpLyr.shadowDraw )
3839  {
3840  return; // don't continue looking for unused values
3841  }
3842 
3843  if ( ddValues.contains( QgsPalLayerSettings::ShadowUnder ) )
3844  {
3846  }
3847 
3848  if ( ddValues.contains( QgsPalLayerSettings::ShadowOffsetAngle ) )
3849  {
3850  tmpLyr.shadowOffsetAngle = ddValues.value( QgsPalLayerSettings::ShadowOffsetAngle ).toInt();
3851  }
3852 
3853  if ( ddValues.contains( QgsPalLayerSettings::ShadowOffsetDist ) )
3854  {
3855  tmpLyr.shadowOffsetDist = ddValues.value( QgsPalLayerSettings::ShadowOffsetDist ).toDouble();
3856  }
3857 
3858  if ( ddValues.contains( QgsPalLayerSettings::ShadowOffsetUnits ) )
3859  {
3861  }
3862 
3863  if ( ddValues.contains( QgsPalLayerSettings::ShadowRadius ) )
3864  {
3865  tmpLyr.shadowRadius = ddValues.value( QgsPalLayerSettings::ShadowRadius ).toDouble();
3866  }
3867 
3868  if ( ddValues.contains( QgsPalLayerSettings::ShadowRadiusUnits ) )
3869  {
3871  }
3872 
3873  if ( ddValues.contains( QgsPalLayerSettings::ShadowTransparency ) )
3874  {
3875  tmpLyr.shadowTransparency = ddValues.value( QgsPalLayerSettings::ShadowTransparency ).toInt();
3876  }
3877 
3878  if ( ddValues.contains( QgsPalLayerSettings::ShadowScale ) )
3879  {
3880  tmpLyr.shadowScale = ddValues.value( QgsPalLayerSettings::ShadowScale ).toInt();
3881  }
3882 
3883  if ( ddValues.contains( QgsPalLayerSettings::ShadowColor ) )
3884  {
3885  QVariant ddColor = ddValues.value( QgsPalLayerSettings::ShadowColor );
3886  tmpLyr.shadowColor = ddColor.value<QColor>();
3887  }
3888 
3889  if ( ddValues.contains( QgsPalLayerSettings::ShadowBlendMode ) )
3890  {
3891  tmpLyr.shadowBlendMode = ( QPainter::CompositionMode )ddValues.value( QgsPalLayerSettings::ShadowBlendMode ).toInt();
3892  }
3893 }
3894 
3895 
3896 // helper function for checking for job cancellation within PAL
3897 static bool _palIsCancelled( void* ctx )
3898 {
3899  return (( QgsRenderContext* ) ctx )->renderingStopped();
3900 }
3901 
3903 {
3904  Q_ASSERT( mMapSettings != NULL );
3905  QPainter* painter = context.painter();
3906  QgsRectangle extent = context.extent();
3907 
3909 
3910  delete mResults;
3912 
3913  QTime t;
3914  t.start();
3915 
3916  // do the labeling itself
3917  double scale = mMapSettings->scale(); // scale denominator
3918  QgsRectangle r = extent;
3919  double bbox[] = { r.xMinimum(), r.yMinimum(), r.xMaximum(), r.yMaximum() };
3920 
3921  std::list<LabelPosition*>* labels;
3922  pal::Problem* problem;
3923  try
3924  {
3925  problem = mPal->extractProblem( scale, bbox );
3926  }
3927  catch ( std::exception& e )
3928  {
3929  Q_UNUSED( e );
3930  QgsDebugMsgLevel( "PAL EXCEPTION :-( " + QString::fromLatin1( e.what() ), 4 );
3931  //mActiveLayers.clear(); // clean up
3932  return;
3933  }
3934 
3935  if ( context.renderingStopped() )
3936  return; // it has been cancelled
3937 
3938 #if 1 // XXX strk
3939  // features are pre-rotated but not scaled/translated,
3940  // so we only disable rotation here. Ideally, they'd be
3941  // also pre-scaled/translated, as suggested here:
3942  // http://hub.qgis.org/issues/11856
3944  xform.setMapRotation( 0, 0, 0 );
3945 #else
3946  const QgsMapToPixel& xform = mMapSettings->mapToPixel();
3947 #endif
3948 
3949  // draw rectangles with all candidates
3950  // this is done before actual solution of the problem
3951  // before number of candidates gets reduced
3952  mCandidates.clear();
3953  if ( mShowingCandidates && problem )
3954  {
3955  painter->setPen( QColor( 0, 0, 0, 64 ) );
3956  painter->setBrush( Qt::NoBrush );
3957  for ( int i = 0; i < problem->getNumFeatures(); i++ )
3958  {
3959  for ( int j = 0; j < problem->getFeatureCandidateCount( i ); j++ )
3960  {
3961  pal::LabelPosition* lp = problem->getFeatureCandidate( i, j );
3962 
3963  drawLabelCandidateRect( lp, painter, &xform );
3964  }
3965  }
3966  }
3967 
3968  // find the solution
3969  labels = mPal->solveProblem( problem, mShowingAllLabels );
3970 
3971  QgsDebugMsgLevel( QString( "LABELING work: %1 ms ... labels# %2" ).arg( t.elapsed() ).arg( labels->size() ), 4 );
3972  t.restart();
3973 
3974  if ( context.renderingStopped() )
3975  {
3976  delete problem;
3977  delete labels;
3979  return;
3980  }
3981 
3982  painter->setRenderHint( QPainter::Antialiasing );
3983 
3984  // draw the labels
3985  std::list<LabelPosition*>::iterator it = labels->begin();
3986  for ( ; it != labels->end(); ++it )
3987  {
3988  if ( context.renderingStopped() )
3989  break;
3990 
3991  QgsPalGeometry* palGeometry = dynamic_cast< QgsPalGeometry* >(( *it )->getFeaturePart()->getUserGeometry() );
3992  if ( !palGeometry )
3993  {
3994  continue;
3995  }
3996 
3997  //layer names
3998  QString layerName = QString::fromUtf8(( *it )->getLayerName() );
3999  if ( palGeometry->isDiagram() )
4000  {
4001  QgsFeature feature;
4002  //render diagram
4003  QHash<QString, QgsDiagramLayerSettings>::iterator dit = mActiveDiagramLayers.begin();
4004  for ( dit = mActiveDiagramLayers.begin(); dit != mActiveDiagramLayers.end(); ++dit )
4005  {
4006  if ( QString( dit.key() + "d" ) == layerName )
4007  {
4008  feature.setFields( &dit.value().fields );
4009  palGeometry->feature( feature );
4010  QgsPoint outPt = xform.transform(( *it )->getX(), ( *it )->getY() );
4011  dit.value().renderer->renderDiagram( feature, context, QPointF( outPt.x(), outPt.y() ) );
4012  }
4013  }
4014 
4015  //insert into label search tree to manipulate position interactively
4016  if ( mResults->mLabelSearchTree )
4017  {
4018  //for diagrams, remove the additional 'd' at the end of the layer id
4019  QString layerId = layerName;
4020  layerId.chop( 1 );
4021  mResults->mLabelSearchTree->insertLabel( *it, QString( palGeometry->strId() ).toInt(), QString( "" ), layerId, QFont(), true, false );
4022  }
4023  continue;
4024  }
4025 
4026  const QgsPalLayerSettings& lyr = layer( layerName );
4027 
4028  // Copy to temp, editable layer settings
4029  // these settings will be changed by any data defined values, then used for rendering label components
4030  // settings may be adjusted during rendering of components
4031  QgsPalLayerSettings tmpLyr( lyr );
4032 
4033  // apply any previously applied data defined settings for the label
4034  const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant >& ddValues = palGeometry->dataDefinedValues();
4035 
4036  //font
4037  QFont dFont = palGeometry->definedFont();
4038  // following debug is >= Qt 4.8 only ( because of QFont::styleName() )
4039 #if QT_VERSION >= 0x040800
4040  QgsDebugMsgLevel( QString( "PAL font tmpLyr: %1, Style: %2" ).arg( tmpLyr.textFont.toString() ).arg( QFontInfo( tmpLyr.textFont ).styleName() ), 4 );
4041  QgsDebugMsgLevel( QString( "PAL font definedFont: %1, Style: %2" ).arg( dFont.toString() ).arg( dFont.styleName() ), 4 );
4042 #endif
4043  tmpLyr.textFont = dFont;
4044 
4046  {
4047  //calculate font alignment based on label quadrant
4048  switch (( *it )->getQuadrant() )
4049  {
4050  case LabelPosition::QuadrantAboveLeft:
4051  case LabelPosition::QuadrantLeft:
4052  case LabelPosition::QuadrantBelowLeft:
4054  break;
4055  case LabelPosition::QuadrantAbove:
4056  case LabelPosition::QuadrantOver:
4057  case LabelPosition::QuadrantBelow:
4059  break;
4060  case LabelPosition::QuadrantAboveRight:
4061  case LabelPosition::QuadrantRight:
4062  case LabelPosition::QuadrantBelowRight:
4064  break;
4065  }
4066  }
4067 
4068  // update tmpLyr with any data defined text style values
4069  dataDefinedTextStyle( tmpLyr, ddValues );
4070 
4071  // update tmpLyr with any data defined text buffer values
4072  dataDefinedTextBuffer( tmpLyr, ddValues );
4073 
4074  // update tmpLyr with any data defined text formatting values
4075  dataDefinedTextFormatting( tmpLyr, ddValues );
4076 
4077  // update tmpLyr with any data defined shape background values
4078  dataDefinedShapeBackground( tmpLyr, ddValues );
4079 
4080  // update tmpLyr with any data defined drop shadow values
4081  dataDefinedDropShadow( tmpLyr, ddValues );
4082 
4083 
4085 
4086  // Render the components of a label in reverse order
4087  // (backgrounds -> text)
4088 
4089  if ( tmpLyr.shadowDraw && tmpLyr.shadowUnder == QgsPalLayerSettings::ShadowLowest )
4090  {
4091  if ( tmpLyr.shapeDraw )
4092  {
4094  }
4095  else if ( tmpLyr.bufferDraw )
4096  {
4098  }
4099  else
4100  {
4102  }
4103  }
4104 
4105  if ( tmpLyr.shapeDraw )
4106  {
4107  drawLabel( *it, context, tmpLyr, LabelShape );
4108  }
4109 
4110  if ( tmpLyr.bufferDraw )
4111  {
4112  drawLabel( *it, context, tmpLyr, LabelBuffer );
4113  }
4114 
4115  drawLabel( *it, context, tmpLyr, LabelText );
4116 
4117  if ( mResults->mLabelSearchTree )
4118  {
4119  QString labeltext = (( QgsPalGeometry* )( *it )->getFeaturePart()->getUserGeometry() )->text();
4120  mResults->mLabelSearchTree->insertLabel( *it, QString( palGeometry->strId() ).toInt(), layerName, labeltext, dFont, false, palGeometry->isPinned() );
4121  }
4122  }
4123 
4124  // Reset composition mode for further drawing operations
4125  painter->setCompositionMode( QPainter::CompositionMode_SourceOver );
4126 
4127  QgsDebugMsgLevel( QString( "LABELING draw: %1 ms" ).arg( t.elapsed() ), 4 );
4128 
4129  delete problem;
4130  delete labels;
4132 }
4133 
4135 {
4136  // delete all allocated geometries for features
4137  QHash<QString, QgsPalLayerSettings>::iterator lit;
4138  for ( lit = mActiveLayers.begin(); lit != mActiveLayers.end(); ++lit )
4139  {
4140  QgsPalLayerSettings& lyr = lit.value();
4141  for ( QList<QgsPalGeometry*>::iterator git = lyr.geometries.begin(); git != lyr.geometries.end(); ++git )
4142  delete *git;
4143  if ( lyr.limitNumLabels )
4144  {
4145  QgsDebugMsgLevel( QString( "mFeaturesToLabel: %1" ).arg( lyr.mFeaturesToLabel ), 4 );
4146  QgsDebugMsgLevel( QString( "maxNumLabels: %1" ).arg( lyr.maxNumLabels ), 4 );
4147  QgsDebugMsgLevel( QString( "mFeatsSendingToPal: %1" ).arg( lyr.mFeatsSendingToPal ), 4 );
4148  QgsDebugMsgLevel( QString( "mFeatsRegPal: %1" ).arg( lyr.geometries.count() ), 4 );
4149  }
4150  lyr.geometries.clear();
4151  }
4152 
4153  //delete all allocated geometries for diagrams
4154  QHash<QString, QgsDiagramLayerSettings>::iterator dIt = mActiveDiagramLayers.begin();
4155  for ( ; dIt != mActiveDiagramLayers.end(); ++dIt )
4156  {
4157  QgsDiagramLayerSettings& dls = dIt.value();
4158  for ( QList<QgsPalGeometry*>::iterator git = dls.geometries.begin(); git != dls.geometries.end(); ++git )
4159  {
4160  delete *git;
4161  }
4162  dls.geometries.clear();
4163  }
4164 }
4165 
4166 QList<QgsLabelPosition> QgsPalLabeling::labelsAtPosition( const QgsPoint& p )
4167 {
4168  return mResults ? mResults->labelsAtPosition( p ) : QList<QgsLabelPosition>();
4169 }
4170 
4171 QList<QgsLabelPosition> QgsPalLabeling::labelsWithinRect( const QgsRectangle& r )
4172 {
4173  return mResults ? mResults->labelsWithinRect( r ) : QList<QgsLabelPosition>();
4174 }
4175 
4177 {
4178  if ( mResults )
4179  {
4181  mResults = 0;
4182  return tmp; // ownership passed to the caller
4183  }
4184  else
4185  return 0;
4186 }
4187 
4188 void QgsPalLabeling::numCandidatePositions( int& candPoint, int& candLine, int& candPolygon )
4189 {
4190  candPoint = mCandPoint;
4191  candLine = mCandLine;
4192  candPolygon = mCandPolygon;
4193 }
4194 
4195 void QgsPalLabeling::setNumCandidatePositions( int candPoint, int candLine, int candPolygon )
4196 {
4197  mCandPoint = candPoint;
4198  mCandLine = candLine;
4199  mCandPolygon = candPolygon;
4200 }
4201 
4203 {
4204  mSearch = s;
4205 }
4206 
4208 {
4209  return mSearch;
4210 }
4211 
4213 {
4214  QgsPoint outPt = xform->transform( lp->getX(), lp->getY() );
4215 
4216  painter->save();
4217 
4218 #if 0 // TODO: generalize some of this
4219  double w = lp->getWidth();
4220  double h = lp->getHeight();
4221  double cx = lp->getX() + w / 2.0;
4222  double cy = lp->getY() + h / 2.0;
4223  double scale = 1.0 / xform->mapUnitsPerPixel();
4224  double rotation = xform->mapRotation();
4225  double sw = w * scale;
4226  double sh = h * scale;
4227  QRectF rect( -sw / 2, -sh / 2, sw, sh );
4228 
4229  painter->translate( xform->transform( QPointF( cx, cy ) ).toQPointF() );
4230  if ( rotation )
4231  {
4232  // Only if not horizontal
4233  if ( lp->getFeaturePart()->getLayer()->getArrangement() != P_POINT &&
4236  {
4237  painter->rotate( rotation );
4238  }
4239  }
4240  painter->translate( rect.bottomLeft() );
4241  painter->rotate( -lp->getAlpha() * 180 / M_PI );
4242  painter->translate( -rect.bottomLeft() );
4243 #else
4244  QgsPoint outPt2 = xform->transform( lp->getX() + lp->getWidth(), lp->getY() + lp->getHeight() );
4245  QRectF rect( 0, 0, outPt2.x() - outPt.x(), outPt2.y() - outPt.y() );
4246  painter->translate( QPointF( outPt.x(), outPt.y() ) );
4247  painter->rotate( -lp->getAlpha() * 180 / M_PI );
4248 #endif
4249 
4250  painter->drawRect( rect );
4251  painter->restore();
4252 
4253  // save the rect
4254  rect.moveTo( outPt.x(), outPt.y() );
4255  mCandidates.append( QgsLabelCandidate( rect, lp->getCost() * 1000 ) );
4256 
4257  // show all parts of the multipart label
4258  if ( lp->getNextPart() )
4259  drawLabelCandidateRect( lp->getNextPart(), painter, xform );
4260 }
4261 
4262 void QgsPalLabeling::drawLabel( pal::LabelPosition* label, QgsRenderContext& context, QgsPalLayerSettings& tmpLyr, DrawLabelType drawType, double dpiRatio )
4263 {
4264  // NOTE: this is repeatedly called for multi-part labels
4265  QPainter* painter = context.painter();
4266 #if 1 // XXX strk
4267  // features are pre-rotated but not scaled/translated,
4268  // so we only disable rotation here. Ideally, they'd be
4269  // also pre-scaled/translated, as suggested here:
4270  // http://hub.qgis.org/issues/11856
4271  QgsMapToPixel xform = context.mapToPixel();
4272  xform.setMapRotation( 0, 0, 0 );
4273 #else
4274  const QgsMapToPixel& xform = context.mapToPixel();
4275 #endif
4276 
4277  QgsLabelComponent component;
4278  component.setDpiRatio( dpiRatio );
4279 
4280  QgsPoint outPt = xform.transform( label->getX(), label->getY() );
4281 // QgsPoint outPt2 = xform->transform( label->getX() + label->getWidth(), label->getY() + label->getHeight() );
4282 // QRectF labelRect( 0, 0, outPt2.x() - outPt.x(), outPt2.y() - outPt.y() );
4283 
4284  component.setOrigin( outPt );
4285  component.setRotation( label->getAlpha() );
4286 
4287  if ( drawType == QgsPalLabeling::LabelShape )
4288  {
4289  // get rotated label's center point
4290  QgsPoint centerPt( outPt );
4291  QgsPoint outPt2 = xform.transform( label->getX() + label->getWidth() / 2,
4292  label->getY() + label->getHeight() / 2 );
4293 
4294  double xc = outPt2.x() - outPt.x();
4295  double yc = outPt2.y() - outPt.y();
4296 
4297  double angle = -label->getAlpha();
4298  double xd = xc * cos( angle ) - yc * sin( angle );
4299  double yd = xc * sin( angle ) + yc * cos( angle );
4300 
4301  centerPt.setX( centerPt.x() + xd );
4302  centerPt.setY( centerPt.y() + yd );
4303 
4304  component.setCenter( centerPt );
4305  component.setSize( QgsPoint( label->getWidth(), label->getHeight() ) );
4306 
4307  drawLabelBackground( context, component, tmpLyr );
4308  }
4309 
4310  else if ( drawType == QgsPalLabeling::LabelBuffer
4311  || drawType == QgsPalLabeling::LabelText )
4312  {
4313 
4314  // TODO: optimize access :)
4315  QString text = (( QgsPalGeometry* )label->getFeaturePart()->getUserGeometry() )->text();
4316  QString txt = ( label->getPartId() == -1 ? text : QString( text[label->getPartId()] ) );
4317  QFontMetricsF* labelfm = (( QgsPalGeometry* )label->getFeaturePart()->getUserGeometry() )->getLabelFontMetrics();
4318 
4319  QString wrapchr = !tmpLyr.wrapChar.isEmpty() ? tmpLyr.wrapChar : QString( "\n" );
4320 
4321  //add the direction symbol if needed
4322  if ( !txt.isEmpty() && tmpLyr.placement == QgsPalLayerSettings::Line &&
4323  tmpLyr.addDirectionSymbol )
4324  {
4325  bool prependSymb = false;
4326  QString symb = tmpLyr.rightDirectionSymbol;
4327 
4328  if ( label->getReversed() )
4329  {
4330  prependSymb = true;
4331  symb = tmpLyr.leftDirectionSymbol;
4332  }
4333 
4334  if ( tmpLyr.reverseDirectionSymbol )
4335  {
4336  if ( symb == tmpLyr.rightDirectionSymbol )
4337  {
4338  prependSymb = true;
4339  symb = tmpLyr.leftDirectionSymbol;
4340  }
4341  else
4342  {
4343  prependSymb = false;
4344  symb = tmpLyr.rightDirectionSymbol;
4345  }
4346  }
4347 
4349  {
4350  prependSymb = true;
4351  symb = symb + wrapchr;
4352  }
4354  {
4355  prependSymb = false;
4356  symb = wrapchr + symb;
4357  }
4358 
4359  if ( prependSymb )
4360  {
4361  txt.prepend( symb );
4362  }
4363  else
4364  {
4365  txt.append( symb );
4366  }
4367  }
4368 
4369  //QgsDebugMsgLevel( "drawLabel " + txt, 4 );
4370 
4371  QStringList multiLineList = txt.split( wrapchr );
4372  int lines = multiLineList.size();
4373 
4374  double labelWidest = 0.0;
4375  for ( int i = 0; i < lines; ++i )
4376  {
4377  double labelWidth = labelfm->width( multiLineList.at( i ) );
4378  if ( labelWidth > labelWidest )
4379  {
4380  labelWidest = labelWidth;
4381  }
4382  }
4383 
4384  double labelHeight = labelfm->ascent() + labelfm->descent(); // ignore +1 for baseline
4385  // double labelHighest = labelfm->height() + ( double )(( lines - 1 ) * labelHeight * tmpLyr.multilineHeight );
4386 
4387  // needed to move bottom of text's descender to within bottom edge of label
4388  double ascentOffset = 0.25 * labelfm->ascent(); // labelfm->descent() is not enough
4389 
4390  for ( int i = 0; i < lines; ++i )
4391  {
4392  painter->save();
4393 #if 0 // TODO: generalize some of this
4394  LabelPosition* lp = label;
4395  double w = lp->getWidth();
4396  double h = lp->getHeight();
4397  double cx = lp->getX() + w / 2.0;
4398  double cy = lp->getY() + h / 2.0;
4399  double scale = 1.0 / xform->mapUnitsPerPixel();
4400  double rotation = xform->mapRotation();
4401  double sw = w * scale;
4402  double sh = h * scale;
4403  QRectF rect( -sw / 2, -sh / 2, sw, sh );
4404  painter->translate( xform->transform( QPointF( cx, cy ) ).toQPointF() );
4405  if ( rotation )
4406  {
4407  // Only if not horizontal
4408  if ( lp->getFeaturePart()->getLayer()->getArrangement() != P_POINT &&
4411  {
4412  painter->rotate( rotation );
4413  }
4414  }
4415  painter->translate( rect.bottomLeft() );
4416  painter->rotate( -lp->getAlpha() * 180 / M_PI );
4417 #else
4418  painter->translate( QPointF( outPt.x(), outPt.y() ) );
4419  painter->rotate( -label->getAlpha() * 180 / M_PI );
4420 #endif
4421 
4422  // scale down painter: the font size has been multiplied by raster scale factor
4423  // to workaround a Qt font scaling bug with small font sizes
4424  painter->scale( 1.0 / tmpLyr.rasterCompressFactor, 1.0 / tmpLyr.rasterCompressFactor );
4425 
4426  // figure x offset for horizontal alignment of multiple lines
4427  double xMultiLineOffset = 0.0;
4428  double labelWidth = labelfm->width( multiLineList.at( i ) );
4429  if ( lines > 1 && tmpLyr.multilineAlign != QgsPalLayerSettings::MultiLeft )
4430  {
4431  double labelWidthDiff = labelWidest - labelWidth;
4433  {
4434  labelWidthDiff /= 2;
4435  }
4436  xMultiLineOffset = labelWidthDiff;
4437  //QgsDebugMsgLevel( QString( "xMultiLineOffset: %1" ).arg( xMultiLineOffset ), 4 );
4438  }
4439 
4440  double yMultiLineOffset = ( lines - 1 - i ) * labelHeight * tmpLyr.multilineHeight;
4441  painter->translate( QPointF( xMultiLineOffset, - ascentOffset - yMultiLineOffset ) );
4442 
4443  component.setText( multiLineList.at( i ) );
4444  component.setSize( QgsPoint( labelWidth, labelHeight ) );
4445  component.setOffset( QgsPoint( 0.0, -ascentOffset ) );
4446  component.setRotation( -component.rotation() * 180 / M_PI );
4447  component.setRotationOffset( 0.0 );
4448 
4449  if ( drawType == QgsPalLabeling::LabelBuffer )
4450  {
4451  // draw label's buffer
4452  drawLabelBuffer( context, component, tmpLyr );
4453  }
4454  else
4455  {
4456  // draw label's text, QPainterPath method
4457  QPainterPath path;
4458  path.addText( 0, 0, tmpLyr.textFont, component.text() );
4459 
4460  // store text's drawing in QPicture for drop shadow call
4461  QPicture textPict;
4462  QPainter textp;
4463  textp.begin( &textPict );
4464  textp.setPen( Qt::NoPen );
4465  textp.setBrush( tmpLyr.textColor );
4466  textp.drawPath( path );
4467  // TODO: why are some font settings lost on drawPicture() when using drawText() inside QPicture?
4468  // e.g. some capitalization options, but not others
4469  //textp.setFont( tmpLyr.textFont );
4470  //textp.setPen( tmpLyr.textColor );
4471  //textp.drawText( 0, 0, component.text() );
4472  textp.end();
4473 
4474  if ( tmpLyr.shadowDraw && tmpLyr.shadowUnder == QgsPalLayerSettings::ShadowText )
4475  {
4476  component.setPicture( &textPict );
4477  component.setPictureBuffer( 0.0 ); // no pen width to deal with
4478  component.setOrigin( QgsPoint( 0.0, 0.0 ) );
4479 
4480  drawLabelShadow( context, component, tmpLyr );
4481  }
4482 
4483  // paint the text
4484  if ( context.useAdvancedEffects() )
4485  {
4486  painter->setCompositionMode( tmpLyr.blendMode );
4487  }
4488 
4489  // scale for any print output or image saving @ specific dpi
4490  painter->scale( component.dpiRatio(), component.dpiRatio() );
4491 
4492  if ( mDrawOutlineLabels )
4493  {
4494  // draw outlined text
4495  _fixQPictureDPI( painter );
4496  painter->drawPicture( 0, 0, textPict );
4497  }
4498  else
4499  {
4500  // draw text as text (for SVG and PDF exports)
4501  painter->setFont( tmpLyr.textFont );
4502  painter->setPen( tmpLyr.textColor );
4503  painter->setRenderHint( QPainter::TextAntialiasing );
4504  painter->drawText( 0, 0, component.text() );
4505  }
4506  }
4507  painter->restore();
4508  }
4509  }
4510 
4511  // NOTE: this used to be within above multi-line loop block, at end. (a mistake since 2010? [LS])
4512  if ( label->getNextPart() )
4513  drawLabel( label->getNextPart(), context, tmpLyr, drawType, dpiRatio );
4514 }
4515 
4517  const QgsLabelComponent& component,
4518  const QgsPalLayerSettings& tmpLyr )
4519 {
4520  QPainter* p = context.painter();
4521 
4522  double penSize = tmpLyr.scaleToPixelContext( tmpLyr.bufferSize, context,
4524 
4525  QPainterPath path;
4526  path.addText( 0, 0, tmpLyr.textFont, component.text() );
4527  QPen pen( tmpLyr.bufferColor );
4528  pen.setWidthF( penSize );
4529  pen.setJoinStyle( tmpLyr.bufferJoinStyle );
4530  QColor tmpColor( tmpLyr.bufferColor );
4531  // honor pref for whether to fill buffer interior
4532  if ( tmpLyr.bufferNoFill )
4533  {
4534  tmpColor.setAlpha( 0 );
4535  }
4536 
4537  // store buffer's drawing in QPicture for drop shadow call
4538  QPicture buffPict;
4539  QPainter buffp;
4540  buffp.begin( &buffPict );
4541  buffp.setPen( pen );
4542  buffp.setBrush( tmpColor );
4543  buffp.drawPath( path );
4544  buffp.end();
4545 
4546  if ( tmpLyr.shadowDraw && tmpLyr.shadowUnder == QgsPalLayerSettings::ShadowBuffer )
4547  {
4548  QgsLabelComponent bufferComponent = component;
4549  bufferComponent.setOrigin( QgsPoint( 0.0, 0.0 ) );
4550  bufferComponent.setPicture( &buffPict );
4551  bufferComponent.setPictureBuffer( penSize / 2.0 );
4552  drawLabelShadow( context, bufferComponent, tmpLyr );
4553  }
4554 
4555  p->save();
4556  if ( context.useAdvancedEffects() )
4557  {
4558  p->setCompositionMode( tmpLyr.bufferBlendMode );
4559  }
4560 // p->setPen( pen );
4561 // p->setBrush( tmpColor );
4562 // p->drawPath( path );
4563 
4564  // scale for any print output or image saving @ specific dpi
4565  p->scale( component.dpiRatio(), component.dpiRatio() );
4566  _fixQPictureDPI( p );
4567  p->drawPicture( 0, 0, buffPict );
4568  p->restore();
4569 }
4570 
4572  QgsLabelComponent component,
4573  const QgsPalLayerSettings& tmpLyr )
4574 {
4575  QPainter* p = context.painter();
4576  double labelWidth = component.size().x(), labelHeight = component.size().y();
4577  //QgsDebugMsgLevel( QString( "Background label rotation: %1" ).arg( component.rotation() ), 4 );
4578 
4579  // shared calculations between shapes and SVG
4580 
4581  // configure angles, set component rotation and rotationOffset
4583  {
4584  component.setRotation( -( component.rotation() * 180 / M_PI ) ); // RotationSync
4585  component.setRotationOffset(
4587  }
4588  else // RotationFixed
4589  {
4590  component.setRotation( 0.0 ); // don't use label's rotation
4591  component.setRotationOffset( tmpLyr.shapeRotation );
4592  }
4593 
4594  // mm to map units conversion factor
4595  double mmToMapUnits = tmpLyr.shapeSizeMapUnitScale.computeMapUnitsPerPixel( context ) * context.scaleFactor();
4596 
4597  // TODO: the following label-buffered generated shapes and SVG symbols should be moved into marker symbology classes
4598 
4599  if ( tmpLyr.shapeType == QgsPalLayerSettings::ShapeSVG )
4600  {
4601  // all calculations done in shapeSizeUnits, which are then passed to symbology class for painting
4602 
4603  if ( tmpLyr.shapeSVGFile.isEmpty() )
4604  return;
4605 
4606  double sizeOut = 0.0;
4607  // only one size used for SVG sizing/scaling (no use of shapeSize.y() or Y field in gui)
4609  {
4610  sizeOut = tmpLyr.shapeSize.x();
4611  }
4612  else if ( tmpLyr.shapeSizeType == QgsPalLayerSettings::SizeBuffer )
4613  {
4614  // add buffer to greatest dimension of label
4615  if ( labelWidth >= labelHeight )
4616  sizeOut = labelWidth;
4617  else if ( labelHeight > labelWidth )
4618  sizeOut = labelHeight;
4619 
4620  // label size in map units, convert to shapeSizeUnits, if different
4621  if ( tmpLyr.shapeSizeUnits == QgsPalLayerSettings::MM )
4622  {
4623  sizeOut /= mmToMapUnits;
4624  }
4625 
4626  // add buffer
4627  sizeOut += tmpLyr.shapeSize.x() * 2;
4628  }
4629 
4630  // don't bother rendering symbols smaller than 1x1 pixels in size
4631  // TODO: add option to not show any svgs under/over a certian size
4632  if ( tmpLyr.scaleToPixelContext( sizeOut, context, tmpLyr.shapeSizeUnits, false, tmpLyr.shapeSizeMapUnitScale ) < 1.0 )
4633  return;
4634 
4635  QgsStringMap map; // for SVG symbology marker
4636  map["name"] = QgsSymbolLayerV2Utils::symbolNameToPath( tmpLyr.shapeSVGFile.trimmed() );
4637  map["size"] = QString::number( sizeOut );
4638  map["size_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit(
4640  map["angle"] = QString::number( 0.0 ); // angle is handled by this local painter
4641 
4642  // offset is handled by this local painter
4643  // TODO: see why the marker renderer doesn't seem to translate offset *after* applying rotation
4644  //map["offset"] = QgsSymbolLayerV2Utils::encodePoint( tmpLyr.shapeOffset );
4645  //map["offset_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit(
4646  // tmpLyr.shapeOffsetUnits == QgsPalLayerSettings::MapUnits ? QgsSymbolV2::MapUnit : QgsSymbolV2::MM );
4647 
4648  map["fill"] = tmpLyr.shapeFillColor.name();
4649  map["outline"] = tmpLyr.shapeBorderColor.name();
4650  map["outline-width"] = QString::number( tmpLyr.shapeBorderWidth );
4651 
4652  // TODO: fix overriding SVG symbol's border width/units in QgsSvgCache
4653  // currently broken, fall back to symbol's
4654  //map["outline_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit(
4655  // tmpLyr.shapeBorderWidthUnits == QgsPalLayerSettings::MapUnits ? QgsSymbolV2::MapUnit : QgsSymbolV2::MM );
4656 
4657  if ( tmpLyr.shadowDraw && tmpLyr.shadowUnder == QgsPalLayerSettings::ShadowShape )
4658  {
4659  // configure SVG shadow specs
4660  QgsStringMap shdwmap( map );
4661  shdwmap["fill"] = tmpLyr.shadowColor.name();
4662  shdwmap["outline"] = tmpLyr.shadowColor.name();
4663  shdwmap["size"] = QString::number( sizeOut * tmpLyr.rasterCompressFactor );
4664 
4665  // store SVG's drawing in QPicture for drop shadow call
4666  QPicture svgPict;
4667  QPainter svgp;
4668  svgp.begin( &svgPict );
4669 
4670  // draw shadow symbol
4671 
4672  // clone current render context map unit/mm conversion factors, but not
4673  // other map canvas parameters, then substitute this painter for use in symbology painting
4674  // NOTE: this is because the shadow needs to be scaled correctly for output to map canvas,
4675  // but will be created relative to the SVG's computed size, not the current map canvas
4676  QgsRenderContext shdwContext;
4677  shdwContext.setMapToPixel( context.mapToPixel() );
4678  shdwContext.setScaleFactor( context.scaleFactor() );
4679  shdwContext.setPainter( &svgp );
4680 
4681  QgsSymbolLayerV2* symShdwL = QgsSvgMarkerSymbolLayerV2::create( shdwmap );
4682  QgsSvgMarkerSymbolLayerV2* svgShdwM = static_cast<QgsSvgMarkerSymbolLayerV2*>( symShdwL );
4683  QgsSymbolV2RenderContext svgShdwContext( shdwContext, QgsSymbolV2::Mixed,
4684  ( 100.0 - ( double )( tmpLyr.shapeTransparency ) ) / 100.0 );
4685 
4686  double svgSize = tmpLyr.scaleToPixelContext( sizeOut, context, tmpLyr.shapeSizeUnits, true, tmpLyr.shapeSizeMapUnitScale );
4687  svgShdwM->renderPoint( QPointF( svgSize / 2, -svgSize / 2 ), svgShdwContext );
4688  svgp.end();
4689 
4690  component.setPicture( &svgPict );
4691  // TODO: when SVG symbol's border width/units is fixed in QgsSvgCache, adjust for it here
4692  component.setPictureBuffer( 0.0 );
4693 
4694  component.setSize( QgsPoint( svgSize, svgSize ) );
4695  component.setOffset( QgsPoint( 0.0, 0.0 ) );
4696 
4697  // rotate about origin center of SVG
4698  p->save();
4699  p->translate( component.center().x(), component.center().y() );
4700  p->rotate( component.rotation() );
4701  p->scale( 1.0 / tmpLyr.rasterCompressFactor, 1.0 / tmpLyr.rasterCompressFactor );
4702  double xoff = tmpLyr.scaleToPixelContext( tmpLyr.shapeOffset.x(), context, tmpLyr.shapeOffsetUnits, true, tmpLyr.shapeOffsetMapUnitScale );
4703  double yoff = tmpLyr.scaleToPixelContext( tmpLyr.shapeOffset.y(), context, tmpLyr.shapeOffsetUnits, true, tmpLyr.shapeOffsetMapUnitScale );
4704  p->translate( QPointF( xoff, yoff ) );
4705  p->rotate( component.rotationOffset() );
4706  p->translate( -svgSize / 2, svgSize / 2 );
4707 
4708  drawLabelShadow( context, component, tmpLyr );
4709  p->restore();
4710 
4711  delete svgShdwM;
4712  svgShdwM = 0;
4713  }
4714 
4715  // draw the actual symbol
4717  QgsSvgMarkerSymbolLayerV2* svgM = static_cast<QgsSvgMarkerSymbolLayerV2*>( symL );
4718  QgsSymbolV2RenderContext svgContext( context, QgsSymbolV2::Mixed,
4719  ( 100.0 - ( double )( tmpLyr.shapeTransparency ) ) / 100.0 );
4720 
4721  p->save();
4722  if ( context.useAdvancedEffects() )
4723  {
4724  p->setCompositionMode( tmpLyr.shapeBlendMode );
4725  }
4726  p->translate( component.center().x(), component.center().y() );
4727  p->rotate( component.rotation() );
4728  double xoff = tmpLyr.scaleToPixelContext( tmpLyr.shapeOffset.x(), context, tmpLyr.shapeOffsetUnits, false, tmpLyr.shapeOffsetMapUnitScale );
4729  double yoff = tmpLyr.scaleToPixelContext( tmpLyr.shapeOffset.y(), context, tmpLyr.shapeOffsetUnits, false, tmpLyr.shapeOffsetMapUnitScale );
4730  p->translate( QPointF( xoff, yoff ) );
4731  p->rotate( component.rotationOffset() );
4732  svgM->renderPoint( QPointF( 0, 0 ), svgContext );
4733  p->setCompositionMode( QPainter::CompositionMode_SourceOver ); // just to be sure
4734  p->restore();
4735 
4736  delete svgM;
4737  svgM = 0;
4738 
4739  }
4740  else // Generated Shapes
4741  {
4742  // all calculations done in shapeSizeUnits
4743 
4744  double w = labelWidth / ( tmpLyr.shapeSizeUnits == QgsPalLayerSettings::MM ? mmToMapUnits : 1 );
4745  double h = labelHeight / ( tmpLyr.shapeSizeUnits == QgsPalLayerSettings::MM ? mmToMapUnits : 1 );
4746 
4747  double xsize = tmpLyr.shapeSize.x();
4748  double ysize = tmpLyr.shapeSize.y();
4749 
4751  {
4752  w = xsize;
4753  h = ysize;
4754  }
4755  else if ( tmpLyr.shapeSizeType == QgsPalLayerSettings::SizeBuffer )
4756  {
4758  {
4759  if ( w > h )
4760  h = w;
4761  else if ( h > w )
4762  w = h;
4763  }
4764  else if ( tmpLyr.shapeType == QgsPalLayerSettings::ShapeCircle )
4765  {
4766  // start with label bound by circle
4767  h = sqrt( pow( w, 2 ) + pow( h, 2 ) );
4768  w = h;
4769  }
4770  else if ( tmpLyr.shapeType == QgsPalLayerSettings::ShapeEllipse )
4771  {
4772  // start with label bound by ellipse
4773  h = h / sqrt( 2.0 ) * 2;
4774  w = w / sqrt( 2.0 ) * 2;
4775  }
4776 
4777  w += xsize * 2;
4778  h += ysize * 2;
4779  }
4780 
4781  // convert everything over to map pixels from here on
4782  w = tmpLyr.scaleToPixelContext( w, context, tmpLyr.shapeSizeUnits, true, tmpLyr.shapeSizeMapUnitScale );
4783  h = tmpLyr.scaleToPixelContext( h, context, tmpLyr.shapeSizeUnits, true, tmpLyr.shapeSizeMapUnitScale );
4784 
4785  // offsets match those of symbology: -x = left, -y = up
4786  QRectF rect( -w / 2.0, - h / 2.0, w, h );
4787 
4788  if ( rect.isNull() )
4789  return;
4790 
4791  p->save();
4792  p->translate( QPointF( component.center().x(), component.center().y() ) );
4793  p->rotate( component.rotation() );
4794  double xoff = tmpLyr.scaleToPixelContext( tmpLyr.shapeOffset.x(), context, tmpLyr.shapeOffsetUnits, false, tmpLyr.shapeOffsetMapUnitScale );
4795  double yoff = tmpLyr.scaleToPixelContext( tmpLyr.shapeOffset.y(), context, tmpLyr.shapeOffsetUnits, false, tmpLyr.shapeOffsetMapUnitScale );
4796  p->translate( QPointF( xoff, yoff ) );
4797  p->rotate( component.rotationOffset() );
4798 
4799  double penSize = tmpLyr.scaleToPixelContext( tmpLyr.shapeBorderWidth, context, tmpLyr.shapeBorderWidthUnits, true, tmpLyr.shapeBorderWidthMapUnitScale );
4800 
4801  QPen pen;
4802  if ( tmpLyr.shapeBorderWidth > 0 )
4803  {
4804  pen.setColor( tmpLyr.shapeBorderColor );
4805  pen.setWidthF( penSize );
4807  pen.setJoinStyle( tmpLyr.shapeJoinStyle );
4808  }
4809  else
4810  {
4811  pen = Qt::NoPen;
4812  }
4813 
4814  // store painting in QPicture for shadow drawing
4815  QPicture shapePict;
4816  QPainter shapep;
4817  shapep.begin( &shapePict );
4818  shapep.setPen( pen );
4819  shapep.setBrush( tmpLyr.shapeFillColor );
4820 
4823  {
4825  {
4826  shapep.drawRoundedRect( rect, tmpLyr.shapeRadii.x(), tmpLyr.shapeRadii.y(), Qt::RelativeSize );
4827  }
4828  else
4829  {
4830  double xRadius = tmpLyr.scaleToPixelContext( tmpLyr.shapeRadii.x(), context, tmpLyr.shapeRadiiUnits, true, tmpLyr.shapeRadiiMapUnitScale );
4831  double yRadius = tmpLyr.scaleToPixelContext( tmpLyr.shapeRadii.y(), context, tmpLyr.shapeRadiiUnits, true, tmpLyr.shapeRadiiMapUnitScale );
4832  shapep.drawRoundedRect( rect, xRadius, yRadius );
4833  }
4834  }
4835  else if ( tmpLyr.shapeType == QgsPalLayerSettings::ShapeEllipse
4837  {
4838  shapep.drawEllipse( rect );
4839  }
4840  shapep.end();
4841 
4842  p->scale( 1.0 / tmpLyr.rasterCompressFactor, 1.0 / tmpLyr.rasterCompressFactor );
4843 
4844  if ( tmpLyr.shadowDraw && tmpLyr.shadowUnder == QgsPalLayerSettings::ShadowShape )
4845  {
4846  component.setPicture( &shapePict );
4847  component.setPictureBuffer( penSize / 2.0 );
4848 
4849  component.setSize( QgsPoint( rect.width(), rect.height() ) );
4850  component.setOffset( QgsPoint( rect.width() / 2, -rect.height() / 2 ) );
4851  drawLabelShadow( context, component, tmpLyr );
4852  }
4853 
4854  p->setOpacity(( 100.0 - ( double )( tmpLyr.shapeTransparency ) ) / 100.0 );
4855  if ( context.useAdvancedEffects() )
4856  {
4857  p->setCompositionMode( tmpLyr.shapeBlendMode );
4858  }
4859 
4860  // scale for any print output or image saving @ specific dpi
4861  p->scale( component.dpiRatio(), component.dpiRatio() );
4862  _fixQPictureDPI( p );
4863  p->drawPicture( 0, 0, shapePict );
4864  p->restore();
4865  }
4866 }
4867 
4869  const QgsLabelComponent& component,
4870  const QgsPalLayerSettings& tmpLyr )
4871 {
4872  // incoming component sizes should be multiplied by rasterCompressFactor, as
4873  // this allows shadows to be created at paint device dpi (e.g. high resolution),
4874  // then scale device painter by 1.0 / rasterCompressFactor for output
4875 
4876  QPainter* p = context.painter();
4877  double componentWidth = component.size().x(), componentHeight = component.size().y();
4878  double xOffset = component.offset().x(), yOffset = component.offset().y();
4879  double pictbuffer = component.pictureBuffer();
4880 
4881  // generate pixmap representation of label component drawing
4882  bool mapUnits = ( tmpLyr.shadowRadiusUnits == QgsPalLayerSettings::MapUnits );
4883  double radius = tmpLyr.scaleToPixelContext( tmpLyr.shadowRadius, context, tmpLyr.shadowRadiusUnits, !mapUnits, tmpLyr.shadowRadiusMapUnitScale );
4884  radius /= ( mapUnits ? tmpLyr.vectorScaleFactor / component.dpiRatio() : 1 );
4885  radius = ( int )( radius + 0.5 );
4886 
4887  // TODO: add labeling gui option to adjust blurBufferClippingScale to minimize pixels, or
4888  // to ensure shadow isn't clipped too tight. (Or, find a better method of buffering)
4889  double blurBufferClippingScale = 3.75;
4890  int blurbuffer = ( radius > 17 ? 16 : radius ) * blurBufferClippingScale;
4891 
4892  QImage blurImg( componentWidth + ( pictbuffer * 2.0 ) + ( blurbuffer * 2.0 ),
4893  componentHeight + ( pictbuffer * 2.0 ) + ( blurbuffer * 2.0 ),
4894  QImage::Format_ARGB32_Premultiplied );
4895 
4896  // TODO: add labeling gui option to not show any shadows under/over a certian size
4897  // keep very small QImages from causing paint device issues, i.e. must be at least > 1
4898  int minBlurImgSize = 1;
4899  // max limitation on QgsSvgCache is 10,000 for screen, which will probably be reasonable for future caching here, too
4900  // 4 x QgsSvgCache limit for output to print/image at higher dpi
4901  // TODO: should it be higher, scale with dpi, or have no limit? Needs testing with very large labels rendered at high dpi output
4902  int maxBlurImgSize = 40000;
4903  if ( blurImg.isNull()
4904  || ( blurImg.width() < minBlurImgSize || blurImg.height() < minBlurImgSize )
4905  || ( blurImg.width() > maxBlurImgSize || blurImg.height() > maxBlurImgSize ) )
4906  return;
4907 
4908  blurImg.fill( QColor( Qt::transparent ).rgba() );
4909  QPainter pictp;
4910  if ( !pictp.begin( &blurImg ) )
4911  return;
4912  pictp.setRenderHints( QPainter::Antialiasing | QPainter::SmoothPixmapTransform );
4913  QPointF imgOffset( blurbuffer + pictbuffer + xOffset,
4914  blurbuffer + pictbuffer + componentHeight + yOffset );
4915 
4916  pictp.drawPicture( imgOffset,
4917  *component.picture() );
4918 
4919  // overlay shadow color
4920  pictp.setCompositionMode( QPainter::CompositionMode_SourceIn );
4921  pictp.fillRect( blurImg.rect(), tmpLyr.shadowColor );
4922  pictp.end();
4923 
4924  // blur the QImage in-place
4925  if ( tmpLyr.shadowRadius > 0.0 && radius > 0 )
4926  {
4927  QgsSymbolLayerV2Utils::blurImageInPlace( blurImg, blurImg.rect(), radius, tmpLyr.shadowRadiusAlphaOnly );
4928  }
4929 
4930  if ( tmpLyr.showingShadowRects ) // engine setting, not per layer
4931  {
4932  // debug rect for QImage shadow registration and clipping visualization
4933  QPainter picti;
4934  picti.begin( &blurImg );
4935  picti.setBrush( Qt::Dense7Pattern );
4936  QPen imgPen( QColor( 0, 0, 255, 255 ) );
4937  imgPen.setWidth( 1 );
4938  picti.setPen( imgPen );
4939  picti.setOpacity( 0.1 );
4940  picti.drawRect( 0, 0, blurImg.width(), blurImg.height() );
4941  picti.end();
4942  }
4943 
4944  double offsetDist = tmpLyr.scaleToPixelContext( tmpLyr.shadowOffsetDist, context, tmpLyr.shadowOffsetUnits, true, tmpLyr.shadowOffsetMapUnitScale );
4945  double angleRad = tmpLyr.shadowOffsetAngle * M_PI / 180; // to radians
4946  if ( tmpLyr.shadowOffsetGlobal )
4947  {
4948  // TODO: check for differences in rotation origin and cw/ccw direction,
4949  // when this shadow function is used for something other than labels
4950 
4951  // it's 0-->cw-->360 for labels
4952  //QgsDebugMsgLevel( QString( "Shadow aggregated label rotation (degrees): %1" ).arg( component.rotation() + component.rotationOffset() ), 4 );
4953  angleRad -= ( component.rotation() * M_PI / 180 + component.rotationOffset() * M_PI / 180 );
4954  }
4955 
4956  QPointF transPt( -offsetDist * cos( angleRad + M_PI / 2 ),
4957  -offsetDist * sin( angleRad + M_PI / 2 ) );
4958 
4959  p->save();
4960  p->setRenderHints( QPainter::Antialiasing | QPainter::SmoothPixmapTransform );
4961  if ( context.useAdvancedEffects() )
4962  {
4963  p->setCompositionMode( tmpLyr.shadowBlendMode );
4964  }
4965  p->setOpacity(( 100.0 - ( double )( tmpLyr.shadowTransparency ) ) / 100.0 );
4966 
4967  double scale = ( double )tmpLyr.shadowScale / 100.0;
4968  // TODO: scale from center/center, left/center or left/top, instead of default left/bottom?
4969  p->scale( scale, scale );
4970  if ( component.useOrigin() )
4971  {
4972  p->translate( component.origin().x(), component.origin().y() );
4973  }
4974  p->translate( transPt );
4975  p->translate( -imgOffset.x(),
4976  -imgOffset.y() );
4977  p->drawImage( 0, 0, blurImg );
4978  p->restore();
4979 
4980  // debug rects
4981  if ( tmpLyr.showingShadowRects ) // engine setting, not per layer
4982  {
4983  // draw debug rect for QImage painting registration
4984  p->save();
4985  p->setBrush( Qt::NoBrush );
4986  QPen imgPen( QColor( 255, 0, 0, 10 ) );
4987  imgPen.setWidth( 2 );
4988  imgPen.setStyle( Qt::DashLine );
4989  p->setPen( imgPen );
4990  p->scale( scale, scale );
4991  if ( component.useOrigin() )
4992  {
4993  p->translate( component.origin().x(), component.origin().y() );
4994  }
4995  p->translate( transPt );
4996  p->translate( -imgOffset.x(),
4997  -imgOffset.y() );
4998  p->drawRect( 0, 0, blurImg.width(), blurImg.height() );
4999  p->restore();
5000 
5001  // draw debug rect for passed in component dimensions
5002  p->save();
5003  p->setBrush( Qt::NoBrush );
5004  QPen componentRectPen( QColor( 0, 255, 0, 70 ) );
5005  componentRectPen.setWidth( 1 );
5006  if ( component.useOrigin() )
5007  {
5008  p->translate( component.origin().x(), component.origin().y() );
5009  }
5010  p->setPen( componentRectPen );
5011  p->drawRect( QRect( -xOffset, -componentHeight - yOffset, componentWidth, componentHeight ) );
5012  p->restore();
5013  }
5014 }
5015 
5017 {
5018  // start with engine defaults for new project, or project that has no saved settings
5019  Pal p;
5020  bool saved = false;
5022  "PAL", "/SearchMethod", ( int )p.getSearch(), &saved ) );
5024  "PAL", "/CandidatesPoint", p.getPointP(), &saved );
5026  "PAL", "/CandidatesLine", p.getLineP(), &saved );
5028  "PAL", "/CandidatesPolygon", p.getPolyP(), &saved );
5030  "PAL", "/ShowingCandidates", false, &saved );
5032  "PAL", "/ShowingShadowRects", false, &saved );
5034  "PAL", "/ShowingAllLabels", false, &saved );
5036  "PAL", "/ShowingPartialsLabels", p.getShowPartial(), &saved );
5038  "PAL", "/DrawOutlineLabels", true, &saved );
5039 }
5040 
5042 {
5043  QgsProject::instance()->writeEntry( "PAL", "/SearchMethod", ( int )mSearch );
5044  QgsProject::instance()->writeEntry( "PAL", "/CandidatesPoint", mCandPoint );
5045  QgsProject::instance()->writeEntry( "PAL", "/CandidatesLine", mCandLine );
5046  QgsProject::instance()->writeEntry( "PAL", "/CandidatesPolygon", mCandPolygon );
5047  QgsProject::instance()->writeEntry( "PAL", "/ShowingCandidates", mShowingCandidates );
5048  QgsProject::instance()->writeEntry( "PAL", "/ShowingShadowRects", mShowingShadowRects );
5049  QgsProject::instance()->writeEntry( "PAL", "/ShowingAllLabels", mShowingAllLabels );
5050  QgsProject::instance()->writeEntry( "PAL", "/ShowingPartialsLabels", mShowingPartialsLabels );
5051  QgsProject::instance()->writeEntry( "PAL", "/DrawOutlineLabels", mDrawOutlineLabels );
5052 }
5053 
5055 {
5056  QgsProject::instance()->removeEntry( "PAL", "/SearchMethod" );
5057  QgsProject::instance()->removeEntry( "PAL", "/CandidatesPoint" );
5058  QgsProject::instance()->removeEntry( "PAL", "/CandidatesLine" );
5059  QgsProject::instance()->removeEntry( "PAL", "/CandidatesPolygon" );
5060  QgsProject::instance()->removeEntry( "PAL", "/ShowingCandidates" );
5061  QgsProject::instance()->removeEntry( "PAL", "/ShowingShadowRects" );
5062  QgsProject::instance()->removeEntry( "PAL", "/ShowingAllLabels" );
5063  QgsProject::instance()->removeEntry( "PAL", "/ShowingPartialsLabels" );
5064  QgsProject::instance()->removeEntry( "PAL", "/DrawOutlineLabels" );
5065 }
5066 
5068 {
5069  QgsPalLabeling* lbl = new QgsPalLabeling();
5075  return lbl;
5076 }
5077 
5078 
5080 {
5081  mLabelSearchTree = new QgsLabelSearchTree();
5082 }
5083 
5085 {
5086  delete mLabelSearchTree;
5087  mLabelSearchTree = NULL;
5088 }
5089 
5090 QList<QgsLabelPosition> QgsLabelingResults::labelsAtPosition( const QgsPoint& p ) const
5091 {
5092  QList<QgsLabelPosition> positions;
5093 
5094  QList<QgsLabelPosition*> positionPointers;
5095  if ( mLabelSearchTree )
5096  {
5097  mLabelSearchTree->label( p, positionPointers );
5098  QList<QgsLabelPosition*>::const_iterator pointerIt = positionPointers.constBegin();
5099  for ( ; pointerIt != positionPointers.constEnd(); ++pointerIt )
5100  {
5101  positions.push_back( QgsLabelPosition( **pointerIt ) );
5102  }
5103  }
5104 
5105  return positions;
5106 }
5107 
5108 QList<QgsLabelPosition> QgsLabelingResults::labelsWithinRect( const QgsRectangle& r ) const
5109 {
5110  QList<QgsLabelPosition> positions;
5111 
5112  QList<QgsLabelPosition*> positionPointers;
5113  if ( mLabelSearchTree )
5114  {
5115  mLabelSearchTree->labelsInRect( r, positionPointers );
5116  QList<QgsLabelPosition*>::const_iterator pointerIt = positionPointers.constBegin();
5117  for ( ; pointerIt != positionPointers.constEnd(); ++pointerIt )
5118  {
5119  positions.push_back( QgsLabelPosition( **pointerIt ) );
5120  }
5121  }
5122 
5123  return positions;
5124 }
const QgsMapSettings & mapSettings()
bridge to QgsMapSettings
QgsFeatureId id() const
Get the feature id for this feature.
Definition: qgsfeature.cpp:100
static QString encodeOutputUnit(QgsSymbolV2::OutputUnit unit)
static void _fixQPictureDPI(QPainter *p)
void calculateLabelSize(const QFontMetricsF *fm, QString text, double &labelX, double &labelY, QgsFeature *f=0)
Class for parsing and evaluation of expressions (formerly called "search strings").
Definition: qgsexpression.h:87
const QString & name() const
Gets the name of the field.
Definition: qgsfield.cpp:59
bool hasEvalError() const
Returns true if an error occurred when evaluating last input.
void setActive(bool active)
FeaturePart * getFeaturePart()
return the feature corresponding to this labelposition
A rectangle specified with double values.
Definition: qgsrectangle.h:35
double getCost() const
get the position geographical cost
void label(const QgsPoint &p, QList< QgsLabelPosition * > &posList) const
Returns label position(s) at a given point.
bool hasParserError() const
Returns true if an error occurred when parsing the input expression.
Definition: qgsexpression.h:94
void dataDefinedShapeBackground(QgsPalLayerSettings &tmpLyr, const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant > &ddValues)
std::list< LabelPosition * > * solveProblem(Problem *prob, bool displayAll)
Definition: pal.cpp:867
void setMapRotation(double degrees, double cx, double cy)
Set map rotation in degrees (clockwise)
bool dataDefinedIsActive(QgsPalLayerSettings::DataDefinedProperties p) const
Whether data definition is active.
QStringList referencedColumns() const
Get list of columns referenced by the expression.
QgsMapUnitScale shapeSizeMapUnitScale
void dataDefinedTextStyle(QgsPalLayerSettings &tmpLyr, const QMap< QgsPalLayerSettings::DataDefinedProperties, QVariant > &ddValues)
A container class for data source field mapping or expression.
QgsMapUnitScale shadowRadiusMapUnitScale
virtual void drawLabel(pal::LabelPosition *label, QgsRenderContext &context, QgsPalLayerSettings &tmpLyr, DrawLabelType drawType, double dpiRatio=1.0)
drawLabel
pal::Layer * palLayer
double scale() const
Return the calculated scale of the map.
void setOrigin(const QgsPoint &point)
double length()
get length of geometry using GEOS
virtual bool willUseLayer(QgsVectorLayer *layer) override
called to find out whether the layer is used for labeling
const QgsMapSettings * mMapSettings
pal::Pal * mPal
void addDataDefinedValue(QgsPalLayerSettings::DataDefinedProperties p, QVariant v)
int getFeatureCandidateCount(int i)
Definition: problem.h:184
void setNumCandidatePositions(int candPoint, int candLine, int candPolygon)
const QString expression() const
Alias for dump()
void registerFeature(QgsFeature &f, const QgsRenderContext &context, QString dxfLayer)
void setDxfLayer(QString dxfLayer)
QgsExpression * expression()
const QString & text() const
QVariant evaluate(const QgsFeature *f=NULL)
Evaluate the feature and return the result.
double getWidth() const
QgsLabelingResults * takeResults()
Return pointer to recently computed results (in drawLabeling()) and pass the ownership of results to ...
QString field() const
A class to query the labeling structure at a given point (small wraper around pal RTree class) ...
bool prepare(const QgsFields &fields)
Get the expression ready for evaluation - find out column indexes.
double yMaximum() const
Get the y maximum value (top side of rectangle)
Definition: qgsrectangle.h:188
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
void setSearchMethod(Search s)
void loadEngineSettings()
load/save engine settings to project file
virtual void registerFeature(const QString &layerID, QgsFeature &feat, const QgsRenderContext &context=QgsRenderContext(), QString dxfLayer=QString::null) override
hook called when drawing for every feature in a layer
QPainter::CompositionMode bufferBlendMode
A layer of spacial entites.
Definition: layer.h:65
double rendererScale() const
double rotationOffset() const
is the best but slowest
Definition: pal.h:83
QgsMapUnitScale shadowOffsetMapUnitScale
const QgsPoint & size() const
void setPointP(int point_p)
set # candidates to generate for points features Higher the value is, longer Pal::labeller will spend...
Definition: pal.cpp:885
QgsGeometry * geometry() const
Get the geometry object associated with this feature.
Definition: qgsfeature.cpp:112
double computeMapUnitsPerPixel(const QgsRenderContext &c) const
QgsPoint transform(const QgsPoint &p) const
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for layer.