QGIS API Documentation  2.17.0-Master (00653d2)
qgsellipsesymbollayerv2.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsellipsesymbollayerv2.cpp
3  ---------------------
4  begin : June 2011
5  copyright : (C) 2011 by Marco Hugentobler
6  email : marco dot hugentobler at sourcepole dot ch
7  ***************************************************************************
8  * *
9  * This program is free software; you can redistribute it and/or modify *
10  * it under the terms of the GNU General Public License as published by *
11  * the Free Software Foundation; either version 2 of the License, or *
12  * (at your option) any later version. *
13  * *
14  ***************************************************************************/
16 #include "qgsdxfexport.h"
17 #include "qgsexpression.h"
18 #include "qgsfeature.h"
19 #include "qgsrendercontext.h"
20 #include "qgsvectorlayer.h"
21 #include "qgsdatadefined.h"
22 #include "qgslogger.h"
23 #include "qgsunittypes.h"
24 
25 #include <QPainter>
26 #include <QSet>
27 #include <QDomDocument>
28 #include <QDomElement>
29 
32  , mSymbolName( "circle" )
33  , mSymbolWidth( 4 )
34  , mSymbolWidthUnit( QgsSymbolV2::MM )
35  , mSymbolHeight( 3 )
36  , mSymbolHeightUnit( QgsSymbolV2::MM )
37  , mOutlineColor( Qt::black )
38  , mOutlineStyle( Qt::SolidLine )
39  , mPenJoinStyle( DEFAULT_ELLIPSE_JOINSTYLE )
40  , mOutlineWidth( 0 )
41  , mOutlineWidthUnit( QgsSymbolV2::MM )
42 {
43  mColor = Qt::white;
44  mPen.setColor( mOutlineColor );
45  mPen.setStyle( mOutlineStyle );
46  mPen.setJoinStyle( mPenJoinStyle );
47  mPen.setWidth( 1.0 );
48  mBrush.setColor( mColor );
49  mBrush.setStyle( Qt::SolidPattern );
50  mOffset = QPointF( 0, 0 );
51  mAngle = 0;
52 }
53 
55 {
56 }
57 
59 {
61  if ( properties.contains( "symbol_name" ) )
62  {
63  layer->setSymbolName( properties[ "symbol_name" ] );
64  }
65  if ( properties.contains( "symbol_width" ) )
66  {
67  layer->setSymbolWidth( properties["symbol_width"].toDouble() );
68  }
69  if ( properties.contains( "symbol_width_unit" ) )
70  {
71  layer->setSymbolWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["symbol_width_unit"] ) );
72  }
73  if ( properties.contains( "symbol_width_map_unit_scale" ) )
74  {
75  layer->setSymbolWidthMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( properties["symbol_width_map_unit_scale"] ) );
76  }
77  if ( properties.contains( "symbol_height" ) )
78  {
79  layer->setSymbolHeight( properties["symbol_height"].toDouble() );
80  }
81  if ( properties.contains( "symbol_height_unit" ) )
82  {
83  layer->setSymbolHeightUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["symbol_height_unit"] ) );
84  }
85  if ( properties.contains( "symbol_height_map_unit_scale" ) )
86  {
87  layer->setSymbolHeightMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( properties["symbol_height_map_unit_scale"] ) );
88  }
89  if ( properties.contains( "angle" ) )
90  {
91  layer->setAngle( properties["angle"].toDouble() );
92  }
93  if ( properties.contains( "outline_style" ) )
94  {
95  layer->setOutlineStyle( QgsSymbolLayerV2Utils::decodePenStyle( properties["outline_style"] ) );
96  }
97  else if ( properties.contains( "line_style" ) )
98  {
99  layer->setOutlineStyle( QgsSymbolLayerV2Utils::decodePenStyle( properties["line_style"] ) );
100  }
101  if ( properties.contains( "joinstyle" ) )
102  {
103  layer->setPenJoinStyle( QgsSymbolLayerV2Utils::decodePenJoinStyle( properties["joinstyle"] ) );
104  }
105  if ( properties.contains( "outline_width" ) )
106  {
107  layer->setOutlineWidth( properties["outline_width"].toDouble() );
108  }
109  else if ( properties.contains( "line_width" ) )
110  {
111  layer->setOutlineWidth( properties["line_width"].toDouble() );
112  }
113  if ( properties.contains( "outline_width_unit" ) )
114  {
115  layer->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["outline_width_unit"] ) );
116  }
117  else if ( properties.contains( "line_width_unit" ) )
118  {
119  layer->setOutlineWidthUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["line_width_unit"] ) );
120  }
121  if ( properties.contains( "outline_width_map_unit_scale" ) )
122  {
123  layer->setOutlineWidthMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( properties["outline_width_map_unit_scale"] ) );
124  }
125  if ( properties.contains( "fill_color" ) )
126  {
127  //pre 2.5 projects used "fill_color"
128  layer->setFillColor( QgsSymbolLayerV2Utils::decodeColor( properties["fill_color"] ) );
129  }
130  else if ( properties.contains( "color" ) )
131  {
132  layer->setFillColor( QgsSymbolLayerV2Utils::decodeColor( properties["color"] ) );
133  }
134  if ( properties.contains( "outline_color" ) )
135  {
136  layer->setOutlineColor( QgsSymbolLayerV2Utils::decodeColor( properties["outline_color"] ) );
137  }
138  else if ( properties.contains( "line_color" ) )
139  {
140  layer->setOutlineColor( QgsSymbolLayerV2Utils::decodeColor( properties["line_color"] ) );
141  }
142  if ( properties.contains( "size" ) )
143  {
144  layer->setSize( properties["size"].toDouble() );
145  }
146  if ( properties.contains( "size_unit" ) )
147  {
148  layer->setSizeUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["size_unit"] ) );
149  }
150  if ( properties.contains( "size_map_unit_scale" ) )
151  {
152  layer->setSizeMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( properties["size_map_unit_scale"] ) );
153  }
154  if ( properties.contains( "offset" ) )
155  {
156  layer->setOffset( QgsSymbolLayerV2Utils::decodePoint( properties["offset"] ) );
157  }
158  if ( properties.contains( "offset_unit" ) )
159  {
160  layer->setOffsetUnit( QgsSymbolLayerV2Utils::decodeOutputUnit( properties["offset_unit"] ) );
161  }
162  if ( properties.contains( "offset_map_unit_scale" ) )
163  {
164  layer->setOffsetMapUnitScale( QgsSymbolLayerV2Utils::decodeMapUnitScale( properties["offset_map_unit_scale"] ) );
165  }
166  if ( properties.contains( "horizontal_anchor_point" ) )
167  {
168  layer->setHorizontalAnchorPoint( QgsMarkerSymbolLayerV2::HorizontalAnchorPoint( properties[ "horizontal_anchor_point" ].toInt() ) );
169  }
170  if ( properties.contains( "vertical_anchor_point" ) )
171  {
172  layer->setVerticalAnchorPoint( QgsMarkerSymbolLayerV2::VerticalAnchorPoint( properties[ "vertical_anchor_point" ].toInt() ) );
173  }
174 
175  //data defined properties
176  layer->restoreDataDefinedProperties( properties );
177 
178  //compatibility with old project file format
179  if ( !properties["width_field"].isEmpty() )
180  {
181  layer->setDataDefinedProperty( QgsSymbolLayerV2::EXPR_WIDTH, new QgsDataDefined( properties["width_field"] ) );
182  }
183  if ( !properties["height_field"].isEmpty() )
184  {
185  layer->setDataDefinedProperty( QgsSymbolLayerV2::EXPR_HEIGHT, new QgsDataDefined( properties["height_field"] ) );
186  }
187  if ( !properties["rotation_field"].isEmpty() )
188  {
189  layer->setDataDefinedProperty( QgsSymbolLayerV2::EXPR_ROTATION, new QgsDataDefined( properties["rotation_field"] ) );
190  }
191  if ( !properties["outline_width_field"].isEmpty() )
192  {
193  layer->setDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_WIDTH, new QgsDataDefined( properties[ "outline_width_field" ] ) );
194  }
195  if ( !properties["fill_color_field"].isEmpty() )
196  {
197  layer->setDataDefinedProperty( QgsSymbolLayerV2::EXPR_FILL_COLOR, new QgsDataDefined( properties["fill_color_field"] ) );
198  }
199  if ( !properties["outline_color_field"].isEmpty() )
200  {
201  layer->setDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_COLOR, new QgsDataDefined( properties["outline_color_field"] ) );
202  }
203  if ( !properties["symbol_name_field"].isEmpty() )
204  {
205  layer->setDataDefinedProperty( QgsSymbolLayerV2::EXPR_SYMBOL_NAME, new QgsDataDefined( properties["symbol_name_field"] ) );
206  }
207 
208  return layer;
209 }
210 
212 {
213  bool ok;
215  {
216  context.setOriginalValueVariable( mOutlineWidth );
217  double width = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_WIDTH, context, mOutlineWidth ).toDouble();
218  width = QgsSymbolLayerV2Utils::convertToPainterUnits( context.renderContext(), width, mOutlineWidthUnit, mOutlineWidthMapUnitScale );
219  mPen.setWidthF( width );
220  }
222  {
225  if ( ok )
226  {
227  Qt::PenStyle style = QgsSymbolLayerV2Utils::decodePenStyle( styleString );
228  mPen.setStyle( style );
229  }
230  }
232  {
235  if ( ok )
236  {
238  }
239  }
241  {
244  if ( ok )
245  mBrush.setColor( QgsSymbolLayerV2Utils::decodeColor( colorString ) );
246  }
248  {
251  if ( ok )
252  mPen.setColor( QgsSymbolLayerV2Utils::decodeColor( colorString ) );
253  }
254  double scaledWidth = mSymbolWidth;
255  double scaledHeight = mSymbolHeight;
257  {
258  QString symbolName = mSymbolName;
260  {
261  context.setOriginalValueVariable( mSymbolName );
262  symbolName = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_SYMBOL_NAME, context, mSymbolName ).toString();
263  }
264  preparePath( symbolName, context, &scaledWidth, &scaledHeight, context.feature() );
265  }
266 
267  //offset and rotation
268  bool hasDataDefinedRotation = false;
269  QPointF offset;
270  double angle = 0;
271  calculateOffsetAndRotation( context, scaledWidth, scaledHeight, hasDataDefinedRotation, offset, angle );
272 
273  QPainter* p = context.renderContext().painter();
274  if ( !p )
275  {
276  return;
277  }
278 
279  QMatrix transform;
280  transform.translate( point.x() + offset.x(), point.y() + offset.y() );
281  if ( !qgsDoubleNear( angle, 0.0 ) )
282  {
283  transform.rotate( angle );
284  }
285 
286  p->setPen( mPen );
287  p->setBrush( mBrush );
288  p->drawPath( transform.map( mPainterPath ) );
289 }
290 
291 
292 void QgsEllipseSymbolLayerV2::calculateOffsetAndRotation( QgsSymbolV2RenderContext& context,
293  double scaledWidth,
294  double scaledHeight,
295  bool& hasDataDefinedRotation,
296  QPointF& offset,
297  double& angle ) const
298 {
299  double offsetX = 0;
300  double offsetY = 0;
301  markerOffset( context, scaledWidth, scaledHeight, mSymbolWidthUnit, mSymbolHeightUnit, offsetX, offsetY, mSymbolWidthMapUnitScale, mSymbolHeightMapUnitScale );
302  offset = QPointF( offsetX, offsetY );
303 
304 //priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle)
305  bool ok = true;
306  angle = mAngle + mLineAngle;
307  bool usingDataDefinedRotation = false;
309  {
310  context.setOriginalValueVariable( angle );
312  usingDataDefinedRotation = ok;
313  }
314 
315  hasDataDefinedRotation = context.renderHints() & QgsSymbolV2::DataDefinedRotation || usingDataDefinedRotation;
316  if ( hasDataDefinedRotation )
317  {
318  // For non-point markers, "dataDefinedRotation" means following the
319  // shape (shape-data defined). For them, "field-data defined" does
320  // not work at all. TODO: if "field-data defined" ever gets implemented
321  // we'll need a way to distinguish here between the two, possibly
322  // using another flag in renderHints()
323  const QgsFeature* f = context.feature();
324  if ( f )
325  {
326  const QgsGeometry *g = f->constGeometry();
327  if ( g && g->type() == QGis::Point )
328  {
329  const QgsMapToPixel& m2p = context.renderContext().mapToPixel();
330  angle += m2p.mapRotation();
331  }
332  }
333  }
334 
335  if ( angle )
336  offset = _rotatedOffset( offset, angle );
337 }
338 
340 {
341  return "EllipseMarker";
342 }
343 
345 {
346  QgsMarkerSymbolLayerV2::startRender( context ); // get anchor point expressions
347  if ( !context.feature() || !hasDataDefinedProperties() )
348  {
349  preparePath( mSymbolName, context );
350  }
351  mPen.setColor( mOutlineColor );
352  mPen.setStyle( mOutlineStyle );
353  mPen.setJoinStyle( mPenJoinStyle );
354  mPen.setWidthF( QgsSymbolLayerV2Utils::convertToPainterUnits( context.renderContext(), mOutlineWidth, mOutlineWidthUnit, mOutlineWidthMapUnitScale ) );
355  mBrush.setColor( mColor );
356  prepareExpressions( context );
357 }
358 
360 {
361 }
362 
364 {
366  m->setSymbolName( mSymbolName );
367  m->setSymbolWidth( mSymbolWidth );
368  m->setSymbolHeight( mSymbolHeight );
369  m->setOutlineStyle( mOutlineStyle );
370  m->setOffset( mOffset );
373  m->setOutlineStyle( mOutlineStyle );
374  m->setPenJoinStyle( mPenJoinStyle );
375  m->setOutlineWidth( mOutlineWidth );
376  m->setColor( color() );
377  m->setOutlineColor( mOutlineColor );
378  m->setSymbolWidthUnit( mSymbolWidthUnit );
379  m->setSymbolWidthMapUnitScale( mSymbolWidthMapUnitScale );
380  m->setSymbolHeightUnit( mSymbolHeightUnit );
381  m->setSymbolHeightMapUnitScale( mSymbolHeightMapUnitScale );
382  m->setOutlineWidthUnit( mOutlineWidthUnit );
383  m->setOutlineWidthMapUnitScale( mOutlineWidthMapUnitScale );
384  m->setAngle( mAngle );
387 
389  copyPaintEffect( m );
390  return m;
391 }
392 
393 void QgsEllipseSymbolLayerV2::toSld( QDomDocument &doc, QDomElement &element, const QgsStringMap& props ) const
394 {
395  QDomElement symbolizerElem = doc.createElement( "se:PointSymbolizer" );
396  if ( !props.value( "uom", "" ).isEmpty() )
397  symbolizerElem.setAttribute( "uom", props.value( "uom", "" ) );
398  element.appendChild( symbolizerElem );
399 
400  // <Geometry>
401  QgsSymbolLayerV2Utils::createGeometryElement( doc, symbolizerElem, props.value( "geom", "" ) );
402 
403  writeSldMarker( doc, symbolizerElem, props );
404 }
405 
407 {
408  // <Graphic>
409  QDomElement graphicElem = doc.createElement( "se:Graphic" );
410  element.appendChild( graphicElem );
411 
412  double outlineWidth = QgsSymbolLayerV2Utils::rescaleUom( mOutlineWidth, mOutlineWidthUnit, props );
413  double symbolWidth = QgsSymbolLayerV2Utils::rescaleUom( mSymbolWidth, mSymbolWidthUnit, props );
414  QgsSymbolLayerV2Utils::wellKnownMarkerToSld( doc, graphicElem, mSymbolName, mColor, mOutlineColor, mOutlineStyle, outlineWidth, symbolWidth );
415 
416  // <Rotation>
418 
419  QString angleFunc = props.value( "angle", "" );
420  if ( angleFunc.isEmpty() ) // symbol has no angle set
421  {
422  if ( ddRotation && ddRotation->isActive() )
423  {
424  angleFunc = ddRotation->useExpression() ? ddRotation->expressionString() : ddRotation->field();
425  }
426  else if ( !qgsDoubleNear( mAngle, 0.0 ) )
427  angleFunc = QString::number( mAngle );
428  }
429  else if ( ddRotation && ddRotation->isActive() )
430  {
431  // the symbol has an angle and the symbol layer have a rotation
432  // property set
433  angleFunc = QString( "%1 + %2" ).arg( angleFunc, ddRotation->useExpression() ? ddRotation->expressionString() : ddRotation->field() );
434  }
435  else if ( !qgsDoubleNear( mAngle, 0.0 ) )
436  {
437  // both the symbol and the symbol layer have angle value set
438  bool ok;
439  double angle = angleFunc.toDouble( &ok );
440  if ( !ok )
441  {
442  // its a string (probably a property name or a function)
443  angleFunc = QString( "%1 + %2" ).arg( angleFunc ).arg( mAngle );
444  }
445  else if ( !qgsDoubleNear( angle + mAngle, 0.0 ) )
446  {
447  // it's a double value
448  angleFunc = QString::number( angle + mAngle );
449  }
450  }
451  QgsSymbolLayerV2Utils::createRotationElement( doc, graphicElem, angleFunc );
452  QgsSymbolLayerV2Utils::createRotationElement( doc, graphicElem, angleFunc );
453 
454  // <Displacement>
456  QgsSymbolLayerV2Utils::createDisplacementElement( doc, graphicElem, offset );
457 
458  // store w/h factor in a <VendorOption>
459  double widthHeightFactor = mSymbolWidth / mSymbolHeight;
460  QDomElement factorElem = QgsSymbolLayerV2Utils::createVendorOptionElement( doc, "widthHeightFactor", QString::number( widthHeightFactor ) );
461  graphicElem.appendChild( factorElem );
462 }
463 
465 {
466  QgsDebugMsg( "Entered." );
467 
468  QDomElement graphicElem = element.firstChildElement( "Graphic" );
469  if ( graphicElem.isNull() )
470  return nullptr;
471 
472  QString name = "circle";
473  QColor fillColor, borderColor;
474  double borderWidth, size;
475  double widthHeightFactor = 1.0;
476  Qt::PenStyle borderStyle;
477 
478  QgsStringMap vendorOptions = QgsSymbolLayerV2Utils::getVendorOptionList( graphicElem );
479  for ( QgsStringMap::iterator it = vendorOptions.begin(); it != vendorOptions.end(); ++it )
480  {
481  if ( it.key() == "widthHeightFactor" )
482  {
483  bool ok;
484  double v = it.value().toDouble( &ok );
485  if ( ok && !qgsDoubleNear( v, 0.0 ) && v > 0 )
486  widthHeightFactor = v;
487  }
488  }
489 
490  if ( !QgsSymbolLayerV2Utils::wellKnownMarkerFromSld( graphicElem, name, fillColor, borderColor, borderStyle, borderWidth, size ) )
491  return nullptr;
492 
493  double angle = 0.0;
494  QString angleFunc;
495  if ( QgsSymbolLayerV2Utils::rotationFromSldElement( graphicElem, angleFunc ) )
496  {
497  bool ok;
498  double d = angleFunc.toDouble( &ok );
499  if ( ok )
500  angle = d;
501  }
502 
504  m->setSymbolName( name );
505  m->setFillColor( fillColor );
506  m->setOutlineColor( borderColor );
507  m->setOutlineStyle( borderStyle );
508  m->setOutlineWidth( borderWidth );
509  m->setSymbolWidth( size );
510  m->setSymbolHeight( size / widthHeightFactor );
511  m->setAngle( angle );
512  return m;
513 }
514 
516 {
517  QgsStringMap map;
518  map["symbol_name"] = mSymbolName;
519  map["symbol_width"] = QString::number( mSymbolWidth );
520  map["symbol_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSymbolWidthUnit );
521  map["symbol_width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSymbolWidthMapUnitScale );
522  map["symbol_height"] = QString::number( mSymbolHeight );
523  map["symbol_height_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mSymbolHeightUnit );
524  map["symbol_height_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSymbolHeightMapUnitScale );
525  map["angle"] = QString::number( mAngle );
526  map["outline_style"] = QgsSymbolLayerV2Utils::encodePenStyle( mOutlineStyle );
527  map["outline_width"] = QString::number( mOutlineWidth );
528  map["outline_width_unit"] = QgsSymbolLayerV2Utils::encodeOutputUnit( mOutlineWidthUnit );
529  map["outline_width_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOutlineWidthMapUnitScale );
530  map["joinstyle"] = QgsSymbolLayerV2Utils::encodePenJoinStyle( mPenJoinStyle );
531  map["color"] = QgsSymbolLayerV2Utils::encodeColor( mColor );
532  map["outline_color"] = QgsSymbolLayerV2Utils::encodeColor( mOutlineColor );
533  map["offset"] = QgsSymbolLayerV2Utils::encodePoint( mOffset );
535  map["offset_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mOffsetMapUnitScale );
536  map["size"] = QString::number( mSize );
538  map["size_map_unit_scale"] = QgsSymbolLayerV2Utils::encodeMapUnitScale( mSizeMapUnitScale );
539  map["horizontal_anchor_point"] = QString::number( mHorizontalAnchorPoint );
540  map["vertical_anchor_point"] = QString::number( mVerticalAnchorPoint );
542  return map;
543 }
544 
545 QSizeF QgsEllipseSymbolLayerV2::calculateSize( QgsSymbolV2RenderContext& context, double* scaledWidth, double* scaledHeight )
546 {
547  double width = 0;
548 
549  if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_WIDTH ) ) //1. priority: data defined setting on symbol layer le
550  {
551  context.setOriginalValueVariable( mSymbolWidth );
552  width = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_WIDTH, context, mSymbolWidth ).toDouble();
553  }
554  else if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
555  {
556  width = mSize;
557  }
558  else //3. priority: global width setting
559  {
560  width = mSymbolWidth;
561  }
562  if ( scaledWidth )
563  {
564  *scaledWidth = width;
565  }
566  width = QgsSymbolLayerV2Utils::convertToPainterUnits( context.renderContext(), width, mSymbolWidthUnit, mSymbolHeightMapUnitScale );
567 
568  double height = 0;
569  if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_HEIGHT ) ) //1. priority: data defined setting on symbol layer level
570  {
571  context.setOriginalValueVariable( mSymbolHeight );
572  height = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_HEIGHT, context, mSymbolHeight ).toDouble();
573  }
574  else if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
575  {
576  height = mSize;
577  }
578  else //3. priority: global height setting
579  {
580  height = mSymbolHeight;
581  }
582  if ( scaledHeight )
583  {
584  *scaledHeight = height;
585  }
586  height = QgsSymbolLayerV2Utils::convertToPainterUnits( context.renderContext(), height, mSymbolHeightUnit, mSymbolHeightMapUnitScale );
587  return QSizeF( width, height );
588 }
589 
590 void QgsEllipseSymbolLayerV2::preparePath( const QString& symbolName, QgsSymbolV2RenderContext& context, double* scaledWidth, double* scaledHeight, const QgsFeature* )
591 {
592  mPainterPath = QPainterPath();
593 
594  QSizeF size = calculateSize( context, scaledWidth, scaledHeight );
595 
596  if ( symbolName == "circle" )
597  {
598  mPainterPath.addEllipse( QRectF( -size.width() / 2.0, -size.height() / 2.0, size.width(), size.height() ) );
599  }
600  else if ( symbolName == "semi_circle" )
601  {
602  mPainterPath.arcTo( -size.width() / 2.0, -size.height() / 2.0, size.width(), size.height(), 0, 180 );
603  mPainterPath.lineTo( 0, 0 );
604  }
605  else if ( symbolName == "rectangle" )
606  {
607  mPainterPath.addRect( QRectF( -size.width() / 2.0, -size.height() / 2.0, size.width(), size.height() ) );
608  }
609  else if ( symbolName == "diamond" )
610  {
611  mPainterPath.moveTo( -size.width() / 2.0, 0 );
612  mPainterPath.lineTo( 0, size.height() / 2.0 );
613  mPainterPath.lineTo( size.width() / 2.0, 0 );
614  mPainterPath.lineTo( 0, -size.height() / 2.0 );
615  mPainterPath.lineTo( -size.width() / 2.0, 0 );
616  }
617  else if ( symbolName == "cross" )
618  {
619  mPainterPath.moveTo( 0, -size.height() / 2.0 );
620  mPainterPath.lineTo( 0, size.height() / 2.0 );
621  mPainterPath.moveTo( -size.width() / 2.0, 0 );
622  mPainterPath.lineTo( size.width() / 2.0, 0 );
623  }
624  else if ( symbolName == "triangle" )
625  {
626  mPainterPath.moveTo( 0, -size.height() / 2.0 );
627  mPainterPath.lineTo( -size.width() / 2.0, size.height() / 2.0 );
628  mPainterPath.lineTo( size.width() / 2.0, size.height() / 2.0 );
629  mPainterPath.lineTo( 0, -size.height() / 2.0 );
630  }
631  else if ( symbolName == "left_half_triangle" )
632  {
633  mPainterPath.moveTo( 0, size.height() / 2.0 );
634  mPainterPath.lineTo( size.width() / 2.0, size.height() / 2.0 );
635  mPainterPath.lineTo( 0, -size.height() / 2.0 );
636  mPainterPath.lineTo( 0, size.height() / 2.0 );
637  }
638  else if ( symbolName == "right_half_triangle" )
639  {
640  mPainterPath.moveTo( -size.width() / 2.0, size.height() / 2.0 );
641  mPainterPath.lineTo( 0, size.height() / 2.0 );
642  mPainterPath.lineTo( 0, -size.height() / 2.0 );
643  mPainterPath.lineTo( -size.width() / 2.0, size.height() / 2.0 );
644  }
645 }
646 
648 {
650  mSymbolWidthUnit = unit;
651  mSymbolHeightUnit = unit;
652  mOutlineWidthUnit = unit;
653 }
654 
656 {
658  if ( mSymbolWidthUnit != unit || mSymbolHeightUnit != unit || mOutlineWidthUnit != unit )
659  {
660  return QgsSymbolV2::Mixed;
661  }
662  return unit;
663 }
664 
666 {
668  mSymbolWidthMapUnitScale = scale;
669  mSymbolHeightMapUnitScale = scale;
670  mOutlineWidthMapUnitScale = scale;
671 }
672 
674 {
675  if ( QgsMarkerSymbolLayerV2::mapUnitScale() == mSymbolWidthMapUnitScale &&
676  mSymbolWidthMapUnitScale == mSymbolHeightMapUnitScale &&
677  mSymbolHeightMapUnitScale == mOutlineWidthMapUnitScale )
678  {
679  return mSymbolWidthMapUnitScale;
680  }
681  return QgsMapUnitScale();
682 }
683 
685 {
686  QSizeF size = calculateSize( context );
687 
688  bool hasDataDefinedRotation = false;
689  QPointF offset;
690  double angle = 0;
691  calculateOffsetAndRotation( context, size.width(), size.height(), hasDataDefinedRotation, offset, angle );
692 
693  double pixelSize = 1.0 / context.renderContext().rasterScaleFactor();
694 
695  QMatrix transform;
696 
697  // move to the desired position
698  transform.translate( point.x() + offset.x(), point.y() + offset.y() );
699 
700  if ( !qgsDoubleNear( angle, 0.0 ) )
701  transform.rotate( angle );
702 
703  double penWidth = 0.0;
704  bool ok = true;
706  {
707  context.setOriginalValueVariable( mOutlineWidth );
709  if ( ok )
710  {
711  penWidth = QgsSymbolLayerV2Utils::convertToPainterUnits( context.renderContext(), outlineWidth, mOutlineWidthUnit, mOutlineWidthMapUnitScale );
712  }
713  }
715  {
718  if ( ok && outlineStyle == "no" )
719  {
720  penWidth = 0.0;
721  }
722  }
723 
724  //antialiasing
725  penWidth += pixelSize;
726 
727  QRectF symbolBounds = transform.mapRect( QRectF( -size.width() / 2.0,
728  -size.height() / 2.0,
729  size.width(),
730  size.height() ) );
731 
732  //extend bounds by pen width / 2.0
733  symbolBounds.adjust( -penWidth / 2.0, -penWidth / 2.0,
734  penWidth / 2.0, penWidth / 2.0 );
735 
736  return symbolBounds;
737 }
738 
739 bool QgsEllipseSymbolLayerV2::writeDxf( QgsDxfExport& e, double mmMapUnitScaleFactor, const QString& layerName, QgsSymbolV2RenderContext &context, QPointF shift ) const
740 {
741  //width
742  double symbolWidth = mSymbolWidth;
743 
744  if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_WIDTH ) ) //1. priority: data defined setting on symbol layer le
745  {
746  context.setOriginalValueVariable( mSymbolWidth );
747  symbolWidth = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_WIDTH, context, mSymbolWidth ).toDouble();
748  }
749  else if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
750  {
751  symbolWidth = mSize;
752  }
753  if ( mSymbolWidthUnit == QgsSymbolV2::MM )
754  {
755  symbolWidth *= mmMapUnitScaleFactor;
756  }
757 
758  //height
759  double symbolHeight = mSymbolHeight;
760  if ( hasDataDefinedProperty( QgsSymbolLayerV2::EXPR_HEIGHT ) ) //1. priority: data defined setting on symbol layer level
761  {
762  context.setOriginalValueVariable( mSymbolHeight );
763  symbolHeight = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_HEIGHT, context, mSymbolHeight ).toDouble();
764  }
765  else if ( context.renderHints() & QgsSymbolV2::DataDefinedSizeScale ) //2. priority: is data defined size on symbol level
766  {
767  symbolHeight = mSize;
768  }
769  if ( mSymbolHeightUnit == QgsSymbolV2::MM )
770  {
771  symbolHeight *= mmMapUnitScaleFactor;
772  }
773 
774  //outline width
775  double outlineWidth = mOutlineWidth;
776 
778  {
779  context.setOriginalValueVariable( mOutlineWidth );
780  outlineWidth = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_OUTLINE_WIDTH, context, mOutlineWidth ).toDouble();
781  }
782  if ( mOutlineWidthUnit == QgsSymbolV2::MM )
783  {
784  outlineWidth *= outlineWidth;
785  }
786 
787  //fill color
788  bool ok;
789  QColor fc = mColor;
791  {
794  if ( ok )
795  fc = QgsSymbolLayerV2Utils::decodeColor( colorString );
796  }
797 
798  //outline color
799  QColor oc = mOutlineColor;
801  {
804  if ( ok )
805  oc = QgsSymbolLayerV2Utils::decodeColor( colorString );
806  }
807 
808  //symbol name
809  QString symbolName = mSymbolName;
811  {
812  context.setOriginalValueVariable( mSymbolName );
813  symbolName = evaluateDataDefinedProperty( QgsSymbolLayerV2::EXPR_SYMBOL_NAME, context, mSymbolName ).toString();
814  }
815 
816  //offset
817  double offsetX = 0;
818  double offsetY = 0;
819  markerOffset( context, offsetX, offsetY );
820  QPointF off( offsetX, offsetY );
821 
822  //priority for rotation: 1. data defined symbol level, 2. symbol layer rotation (mAngle)
823  double rotation = 0.0;
825  {
826  context.setOriginalValueVariable( mAngle );
828  }
829  else if ( !qgsDoubleNear( mAngle + mLineAngle, 0.0 ) )
830  {
831  rotation = mAngle + mLineAngle;
832  }
833  rotation = -rotation; //rotation in Qt is counterclockwise
834  if ( rotation )
835  off = _rotatedOffset( off, rotation );
836 
837  QTransform t;
838  t.translate( shift.x() + offsetX, shift.y() + offsetY );
839 
840  if ( !qgsDoubleNear( rotation, 0.0 ) )
841  t.rotate( rotation );
842 
843  double halfWidth = symbolWidth / 2.0;
844  double halfHeight = symbolHeight / 2.0;
845 
846  if ( symbolName == "circle" )
847  {
848  if ( qgsDoubleNear( halfWidth, halfHeight ) )
849  {
850  QgsPointV2 pt( t.map( QPointF( 0, 0 ) ) );
851  e.writeFilledCircle( layerName, oc, pt, halfWidth );
852  }
853  else
854  {
855  QgsPointSequenceV2 line;
856 
857  double stepsize = 2 * M_PI / 40;
858  for ( int i = 0; i < 39; ++i )
859  {
860  double angle = stepsize * i;
861  double x = halfWidth * cos( angle );
862  double y = halfHeight * sin( angle );
863  line << QgsPointV2( t.map( QPointF( x, y ) ) );
864  }
865  //close ellipse with first point
866  line << line.at( 0 );
867 
868  if ( mBrush.style() != Qt::NoBrush )
869  e.writePolygon( QgsRingSequenceV2() << line, layerName, "SOLID", fc );
870  if ( mPen.style() != Qt::NoPen )
871  e.writePolyline( line, layerName, "CONTINUOUS", oc, outlineWidth );
872  }
873  }
874  else if ( symbolName == "rectangle" )
875  {
877  p << QgsPointV2( t.map( QPointF( -halfWidth, -halfHeight ) ) )
878  << QgsPointV2( t.map( QPointF( halfWidth, -halfHeight ) ) )
879  << QgsPointV2( t.map( QPointF( halfWidth, halfHeight ) ) )
880  << QgsPointV2( t.map( QPointF( -halfWidth, halfHeight ) ) );
881  p << p[0];
882 
883  if ( mBrush.style() != Qt::NoBrush )
884  e.writePolygon( QgsRingSequenceV2() << p, layerName, "SOLID", fc );
885  if ( mPen.style() != Qt::NoPen )
886  e.writePolyline( p, layerName, "CONTINUOUS", oc, outlineWidth );
887  return true;
888  }
889  else if ( symbolName == "cross" && mPen.style() != Qt::NoPen )
890  {
892  << QgsPointV2( t.map( QPointF( -halfWidth, 0 ) ) )
893  << QgsPointV2( t.map( QPointF( halfWidth, 0 ) ) ),
894  layerName, "CONTINUOUS", oc, outlineWidth );
896  << QgsPointV2( t.map( QPointF( 0, halfHeight ) ) )
897  << QgsPointV2( t.map( QPointF( 0, -halfHeight ) ) ),
898  layerName, "CONTINUOUS", oc, outlineWidth );
899  return true;
900  }
901  else if ( symbolName == "triangle" )
902  {
904  p << QgsPointV2( t.map( QPointF( -halfWidth, -halfHeight ) ) )
905  << QgsPointV2( t.map( QPointF( halfWidth, -halfHeight ) ) )
906  << QgsPointV2( t.map( QPointF( 0, halfHeight ) ) );
907  p << p[0];
908  if ( mBrush.style() != Qt::NoBrush )
909  e.writePolygon( QgsRingSequenceV2() << p, layerName, "SOLID", fc );
910  if ( mPen.style() != Qt::NoPen )
911  e.writePolyline( p, layerName, "CONTINUOUS", oc, outlineWidth );
912  return true;
913  }
914 
915  return false; //soon...
916 }
917 
918 
void addEllipse(const QRectF &boundingRectangle)
static QString encodeOutputUnit(QgsSymbolV2::OutputUnit unit)
static const QString EXPR_OUTLINE_COLOR
void writeSldMarker(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const override
Writes the symbol layer definition as a SLD XML element.
static void createRotationElement(QDomDocument &doc, QDomElement &element, const QString &rotationFunc)
void markerOffset(QgsSymbolV2RenderContext &context, double &offsetX, double &offsetY) const
Calculates the required marker offset, including both the symbol offset and any displacement required...
Qt::PenStyle style() const
void setSymbolWidthUnit(QgsSymbolV2::OutputUnit unit)
QColor fillColor() const override
Get fill color.
QgsSymbolV2::OutputUnit outputUnit() const override
void setStyle(Qt::PenStyle style)
static QPointF _rotatedOffset(QPointF offset, double angle)
Adjusts a marker offset to account for rotation.
QPointF offset() const
Returns the marker&#39;s offset, which is the horizontal and vertical displacement which the rendered mar...
void renderPoint(QPointF point, QgsSymbolV2RenderContext &context) override
Renders a marker at the specified point.
OutputUnit
The unit of the output.
Definition: qgssymbolv2.h:65
QgsMapUnitScale mSizeMapUnitScale
Marker size map unit scale.
A container class for data source field mapping or expression.
bool contains(const Key &key) const
static Q_DECL_DEPRECATED bool wellKnownMarkerFromSld(QDomElement &element, QString &name, QColor &color, QColor &borderColor, double &borderWidth, double &size)
void startRender(QgsSymbolV2RenderContext &context) override
QDomNode appendChild(const QDomNode &newChild)
static double rescaleUom(double size, QgsSymbolV2::OutputUnit unit, const QgsStringMap &props)
Rescales the given size based on the uomScale found in the props, if any is found, otherwise returns the value un-modified.
static QDomElement createVendorOptionElement(QDomDocument &doc, const QString &name, const QString &value)
Qt::BrushStyle style() const
static void createGeometryElement(QDomDocument &doc, QDomElement &element, const QString &geomFunc)
#define QgsDebugMsg(str)
Definition: qgslogger.h:33
double size() const
Returns the symbol size.
QPoint map(const QPoint &point) const
static QString encodeColor(const QColor &color)
static const QString EXPR_WIDTH
static QgsStringMap getVendorOptionList(QDomElement &element)
const T & at(int i) const
void setOffset(QPointF offset)
Sets the marker&#39;s offset, which is the horizontal and vertical displacement which the rendered marker...
void setOutlineWidthUnit(QgsSymbolV2::OutputUnit unit)
void setHorizontalAnchorPoint(HorizontalAnchorPoint h)
Sets the horizontal anchor point for positioning the symbol.
virtual bool hasDataDefinedProperties() const
Checks whether the layer has any associated data defined properties.
void setOriginalValueVariable(const QVariant &value)
Sets the original value variable value for data defined symbology.
void setVerticalAnchorPoint(VerticalAnchorPoint v)
Sets the vertical anchor point for positioning the symbol.
QgsEllipseSymbolLayerV2 * clone() const override
Shall be reimplemented by subclasses to create a deep copy of the instance.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:76
void setJoinStyle(Qt::PenJoinStyle style)
void moveTo(const QPointF &point)
static QPointF decodePoint(const QString &str)
static Qt::PenJoinStyle decodePenJoinStyle(const QString &str)
const QgsGeometry * constGeometry() const
Gets a const pointer to the geometry object associated with this feature.
Definition: qgsfeature.cpp:82
const QgsFeature * feature() const
Current feature being rendered - may be null.
Definition: qgssymbolv2.h:385
static QString encodeMapUnitScale(const QgsMapUnitScale &mapUnitScale)
QRectF bounds(QPointF point, QgsSymbolV2RenderContext &context) override
Returns the approximate bounding box of the marker symbol layer, taking into account any data defined...
QgsSymbolV2::OutputUnit outputUnit() const override
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:187
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the symbol&#39;s offset.
virtual QgsDataDefined * getDataDefinedProperty(const QString &property) const
Returns the data defined property corresponding to the specified property key.
static void createDisplacementElement(QDomDocument &doc, QDomElement &element, QPointF offset)
double toDouble(bool *ok) const
void setStyle(Qt::BrushStyle style)
A symbol layer for rendering objects with major and minor axis (e.g.
QgsStringMap properties() const override
Should be reimplemented by subclasses to return a string map that contains the configuration informat...
void adjust(qreal dx1, qreal dy1, qreal dx2, qreal dy2)
bool qgsDoubleNear(double a, double b, double epsilon=4 *DBL_EPSILON)
Compare two doubles (but allow some difference)
Definition: qgis.h:353
void setMapUnitScale(const QgsMapUnitScale &scale) override
virtual Q_DECL_DEPRECATED QVariant evaluateDataDefinedProperty(const QString &property, const QgsFeature *feature, const QVariant &defaultVal=QVariant(), bool *ok=nullptr) const
Evaluates the matching data defined property and returns the calculated value.
double mapRotation() const
Return current map rotation in degrees.
void setOffsetUnit(QgsSymbolV2::OutputUnit unit)
Sets the units for the symbol&#39;s offset.
bool useExpression() const
Returns if the field or the expression part is active.
void setMapUnitScale(const QgsMapUnitScale &scale) override
static const QString EXPR_JOIN_STYLE
static QgsSymbolV2::OutputUnit decodeOutputUnit(const QString &str)
static QString encodePenStyle(Qt::PenStyle style)
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:34
Mixed units in symbol layers.
Definition: qgssymbolv2.h:69
void setSymbolHeightMapUnitScale(const QgsMapUnitScale &scale)
QTransform & translate(qreal dx, qreal dy)
The output shall be in millimeters.
Definition: qgssymbolv2.h:67
QString number(int n, int base)
static const QString EXPR_FILL_COLOR
qreal x() const
qreal y() const
void setOutputUnit(QgsSymbolV2::OutputUnit unit) override
void toSld(QDomDocument &doc, QDomElement &element, const QgsStringMap &props) const override
Writes the SLD element following the SLD v1.1 specs.
static QString encodePoint(QPointF point)
static double convertToPainterUnits(const QgsRenderContext &c, double size, QgsSymbolV2::OutputUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale())
Converts a size from the specied units to painter units.
void setPen(const QColor &color)
void lineTo(const QPointF &endPoint)
void setAttribute(const QString &name, const QString &value)
QMatrix & translate(qreal dx, qreal dy)
QString expressionString() const
Returns the expression string of this QgsDataDefined.
Point geometry type, with support for z-dimension and m-values.
Definition: qgspointv2.h:34
bool isEmpty() const
static QString encodePenJoinStyle(Qt::PenJoinStyle style)
void addRect(const QRectF &rectangle)
#define M_PI
void setSizeUnit(QgsSymbolV2::OutputUnit unit)
Sets the units for the symbol&#39;s size.
bool writeDxf(QgsDxfExport &e, double mmMapUnitScaleFactor, const QString &layerName, QgsSymbolV2RenderContext &context, QPointF shift=QPointF(0.0, 0.0)) const override
write as DXF
void setWidthF(qreal width)
void setBrush(const QBrush &brush)
Q_DECL_DEPRECATED void writeFilledCircle(const QString &layer, const QColor &color, const QgsPoint &pt, double radius)
Write filled circle (as hatch)
Qt::PenStyle outlineStyle() const
HorizontalAnchorPoint mHorizontalAnchorPoint
Horizontal anchor point.
iterator end()
void setOutlineStyle(Qt::PenStyle outlineStyle)
void setColor(const QColor &color)
void setSymbolName(const QString &name)
virtual Q_DECL_DEPRECATED void prepareExpressions(const QgsFields *fields, double scale=-1.0)
Prepares all data defined property expressions for evaluation.
QGis::GeometryType type() const
Returns type of the geometry as a QGis::GeometryType.
virtual QColor color() const
The fill color.
double mAngle
Marker rotation angle, in degrees clockwise from north.
iterator begin()
static Qt::PenStyle decodePenStyle(const QString &str)
double mLineAngle
Line rotation angle (see setLineAngle() for details)
static const QString EXPR_OUTLINE_STYLE
Q_DECL_DEPRECATED void writePolyline(const QgsPolyline &line, const QString &layer, const QString &lineStyleName, const QColor &color, double width=-1)
Draw dxf primitives (LWPOLYLINE)
static QgsSymbolLayerV2 * create(const QgsStringMap &properties=QgsStringMap())
void copyDataDefinedProperties(QgsSymbolLayerV2 *destLayer) const
Copies all data defined properties of this layer to another symbol layer.
void saveDataDefinedProperties(QgsStringMap &stringMap) const
Saves all data defined properties to a string map.
QRect mapRect(const QRect &rectangle) const
QString field() const
Get the field which this QgsDataDefined represents.
bool isNull() const
void startRender(QgsSymbolV2RenderContext &context) override
static const QString EXPR_OUTLINE_WIDTH
QTransform & rotate(qreal angle, Qt::Axis axis)
void copyPaintEffect(QgsSymbolLayerV2 *destLayer) const
Copies paint effect of this layer to another symbol layer.
QMatrix & rotate(qreal degrees)
VerticalAnchorPoint
Symbol vertical anchor points.
QPainter * painter()
const QgsMapToPixel & mapToPixel() const
void drawPath(const QPainterPath &path)
static QgsSymbolLayerV2 * createFromSld(QDomElement &element)
void setWidth(int width)
Struct for storing maximum and minimum scales for measurements in map units.
QgsMapUnitScale mapUnitScale() const override
virtual bool hasDataDefinedProperty(const QString &property) const
Checks whether the layer has a matching data defined property and if that property is currently activ...
void setSymbolWidthMapUnitScale(const QgsMapUnitScale &scale)
QgsRenderContext & renderContext()
Definition: qgssymbolv2.h:356
QDomElement firstChildElement(const QString &tagName) const
void setOutlineColor(const QColor &c) override
Set outline color.
Q_DECL_DEPRECATED void writePolygon(const QgsPolygon &polygon, const QString &layer, const QString &hatchPattern, const QColor &color)
Draw dxf filled polygon (HATCH)
static const QString EXPR_ROTATION
double angle() const
Returns the rotation angle for the marker, in degrees clockwise from north.
QgsSymbolV2::OutputUnit mOffsetUnit
Offset units.
virtual void setColor(const QColor &color)
The fill color.
static bool rotationFromSldElement(QDomElement &element, QString &rotationFunc)
double toDouble(bool *ok) const
static QColor decodeColor(const QString &str)
Abstract base class for marker symbol layers.
VerticalAnchorPoint mVerticalAnchorPoint
Vertical anchor point.
void stopRender(QgsSymbolV2RenderContext &context) override
QgsSymbolV2::OutputUnit mSizeUnit
Marker size unit.
QgsMapUnitScale mOffsetMapUnitScale
Offset map unit scale.
HorizontalAnchorPoint
Symbol horizontal anchor points.
void setPenJoinStyle(Qt::PenJoinStyle style)
Set outline join style.
void restoreDataDefinedProperties(const QgsStringMap &stringMap)
Restores all data defined properties from string map.
static QgsMapUnitScale decodeMapUnitScale(const QString &str)
QString layerType() const override
Returns a string that represents this layer type.
double rasterScaleFactor() const
double mSize
Marker size.
QDomElement createElement(const QString &tagName)
static const QString EXPR_SYMBOL_NAME
qreal height() const
QgsMapUnitScale mapUnitScale() const override
void setSize(double size)
Sets the symbol size.
void map(int x, int y, int *tx, int *ty) const
void setAngle(double angle)
Sets the rotation angle for the marker.
void arcTo(const QRectF &rectangle, qreal startAngle, qreal sweepLength)
void setColor(const QColor &color)
QString arg(qlonglong a, int fieldWidth, int base, const QChar &fillChar) const
QString toString() const
QPointF mOffset
Marker offset.
void setSizeMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale for the symbol&#39;s size.
void setFillColor(const QColor &c) override
Set fill color.
void setSymbolHeightUnit(QgsSymbolV2::OutputUnit unit)
void setOutputUnit(QgsSymbolV2::OutputUnit unit) override
bool isActive() const
qreal width() const
void setOutlineWidthMapUnitScale(const QgsMapUnitScale &scale)
#define DEFAULT_ELLIPSE_JOINSTYLE
QList< QgsPointV2 > QgsPointSequenceV2
static const QString EXPR_HEIGHT
const T value(const Key &key) const
static Q_DECL_DEPRECATED void wellKnownMarkerToSld(QDomDocument &doc, QDomElement &element, const QString &name, const QColor &color, const QColor &borderColor=QColor(), double borderWidth=-1, double size=-1)
virtual Q_DECL_DEPRECATED void setDataDefinedProperty(const QString &property, const QString &expressionString)
Sets a data defined expression for a property.