Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsdiagramrenderer.cpp
3 : : ---------------------
4 : : begin : March 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 : : ***************************************************************************/
15 : : #include "qgsdiagramrenderer.h"
16 : :
17 : : #include "qgsdatadefinedsizelegend.h"
18 : : #include "qgsvectorlayer.h"
19 : : #include "diagram/qgstextdiagram.h"
20 : : #include "diagram/qgspiediagram.h"
21 : : #include "diagram/qgshistogramdiagram.h"
22 : : #include "diagram/qgsstackedbardiagram.h"
23 : : #include "qgsrendercontext.h"
24 : : #include "qgslayertreemodellegendnode.h"
25 : : #include "qgsfontutils.h"
26 : : #include "qgssymbollayerutils.h"
27 : : #include "qgspainteffectregistry.h"
28 : : #include "qgspainteffect.h"
29 : : #include "qgsapplication.h"
30 : :
31 : : #include <QDomElement>
32 : : #include <QPainter>
33 : :
34 : 5 : QgsPropertiesDefinition QgsDiagramLayerSettings::sPropertyDefinitions;
35 : :
36 : 0 : void QgsDiagramLayerSettings::initPropertyDefinitions()
37 : : {
38 : 0 : if ( !sPropertyDefinitions.isEmpty() )
39 : 0 : return;
40 : :
41 : 0 : const QString origin = QStringLiteral( "diagram" );
42 : :
43 : 0 : sPropertyDefinitions = QgsPropertiesDefinition
44 : 0 : {
45 : 0 : { QgsDiagramLayerSettings::BackgroundColor, QgsPropertyDefinition( "backgroundColor", QObject::tr( "Background color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
46 : 0 : { QgsDiagramLayerSettings::StrokeColor, QgsPropertyDefinition( "strokeColor", QObject::tr( "Stroke color" ), QgsPropertyDefinition::ColorWithAlpha, origin ) },
47 : 0 : { QgsDiagramLayerSettings::StrokeWidth, QgsPropertyDefinition( "strokeWidth", QObject::tr( "Stroke width" ), QgsPropertyDefinition::StrokeWidth, origin ) },
48 : 0 : { QgsDiagramLayerSettings::PositionX, QgsPropertyDefinition( "positionX", QObject::tr( "Position (X)" ), QgsPropertyDefinition::Double, origin ) },
49 : 0 : { QgsDiagramLayerSettings::PositionY, QgsPropertyDefinition( "positionY", QObject::tr( "Position (Y)" ), QgsPropertyDefinition::Double, origin ) },
50 : 0 : { QgsDiagramLayerSettings::Distance, QgsPropertyDefinition( "distance", QObject::tr( "Placement distance" ), QgsPropertyDefinition::DoublePositive, origin ) },
51 : 0 : { QgsDiagramLayerSettings::Priority, QgsPropertyDefinition( "priority", QObject::tr( "Placement priority" ), QgsPropertyDefinition::DoublePositive, origin ) },
52 : 0 : { QgsDiagramLayerSettings::ZIndex, QgsPropertyDefinition( "zIndex", QObject::tr( "Placement z-index" ), QgsPropertyDefinition::Double, origin ) },
53 : 0 : { QgsDiagramLayerSettings::IsObstacle, QgsPropertyDefinition( "isObstacle", QObject::tr( "Diagram is an obstacle" ), QgsPropertyDefinition::Boolean, origin ) },
54 : 0 : { QgsDiagramLayerSettings::Show, QgsPropertyDefinition( "show", QObject::tr( "Show diagram" ), QgsPropertyDefinition::Boolean, origin ) },
55 : 0 : { QgsDiagramLayerSettings::AlwaysShow, QgsPropertyDefinition( "alwaysShow", QObject::tr( "Always show diagram" ), QgsPropertyDefinition::Boolean, origin ) },
56 : 0 : { QgsDiagramLayerSettings::StartAngle, QgsPropertyDefinition( "startAngle", QObject::tr( "Pie chart start angle" ), QgsPropertyDefinition::Rotation, origin ) },
57 : : };
58 : 0 : }
59 : :
60 : 0 : const QgsPropertiesDefinition &QgsDiagramLayerSettings::propertyDefinitions()
61 : : {
62 : 0 : initPropertyDefinitions();
63 : 0 : return sPropertyDefinitions;
64 : : }
65 : :
66 : 0 : QgsDiagramLayerSettings::QgsDiagramLayerSettings()
67 : : {
68 : 0 : initPropertyDefinitions();
69 : 0 : }
70 : :
71 : 0 : QgsDiagramLayerSettings::QgsDiagramLayerSettings( const QgsDiagramLayerSettings &rh )
72 : 0 : : mCt( rh.mCt )
73 : 0 : , mPlacement( rh.mPlacement )
74 : 0 : , mPlacementFlags( rh.mPlacementFlags )
75 : 0 : , mPriority( rh.mPriority )
76 : 0 : , mZIndex( rh.mZIndex )
77 : 0 : , mObstacle( rh.mObstacle )
78 : 0 : , mDistance( rh.mDistance )
79 : 0 : , mRenderer( rh.mRenderer ? rh.mRenderer->clone() : nullptr )
80 : 0 : , mShowAll( rh.mShowAll )
81 : 0 : , mDataDefinedProperties( rh.mDataDefinedProperties )
82 : : {
83 : 0 : initPropertyDefinitions();
84 : 0 : }
85 : :
86 : 0 : QgsDiagramLayerSettings &QgsDiagramLayerSettings::operator=( const QgsDiagramLayerSettings &rh )
87 : : {
88 : 0 : mPlacement = rh.mPlacement;
89 : 0 : mPlacementFlags = rh.mPlacementFlags;
90 : 0 : mPriority = rh.mPriority;
91 : 0 : mZIndex = rh.mZIndex;
92 : 0 : mObstacle = rh.mObstacle;
93 : 0 : mDistance = rh.mDistance;
94 : 0 : mRenderer = rh.mRenderer ? rh.mRenderer->clone() : nullptr;
95 : 0 : mCt = rh.mCt;
96 : 0 : mShowAll = rh.mShowAll;
97 : 0 : mDataDefinedProperties = rh.mDataDefinedProperties;
98 : 0 : return *this;
99 : : }
100 : :
101 : 0 : QgsDiagramLayerSettings::~QgsDiagramLayerSettings()
102 : : {
103 : 0 : delete mRenderer;
104 : 0 : }
105 : :
106 : 0 : void QgsDiagramLayerSettings::setRenderer( QgsDiagramRenderer *diagramRenderer )
107 : : {
108 : 0 : if ( diagramRenderer == mRenderer )
109 : 0 : return;
110 : :
111 : 0 : delete mRenderer;
112 : 0 : mRenderer = diagramRenderer;
113 : 0 : }
114 : :
115 : 0 : void QgsDiagramLayerSettings::setCoordinateTransform( const QgsCoordinateTransform &transform )
116 : : {
117 : 0 : mCt = transform;
118 : 0 : }
119 : :
120 : 0 : void QgsDiagramLayerSettings::readXml( const QDomElement &elem )
121 : : {
122 : 0 : QDomNodeList propertyElems = elem.elementsByTagName( QStringLiteral( "properties" ) );
123 : 0 : if ( !propertyElems.isEmpty() )
124 : : {
125 : 0 : ( void )mDataDefinedProperties.readXml( propertyElems.at( 0 ).toElement(), sPropertyDefinitions );
126 : 0 : }
127 : : else
128 : : {
129 : 0 : mDataDefinedProperties.clear();
130 : : }
131 : :
132 : 0 : mPlacement = static_cast< Placement >( elem.attribute( QStringLiteral( "placement" ) ).toInt() );
133 : 0 : mPlacementFlags = static_cast< LinePlacementFlag >( elem.attribute( QStringLiteral( "linePlacementFlags" ) ).toInt() );
134 : 0 : mPriority = elem.attribute( QStringLiteral( "priority" ) ).toInt();
135 : 0 : mZIndex = elem.attribute( QStringLiteral( "zIndex" ) ).toDouble();
136 : 0 : mObstacle = elem.attribute( QStringLiteral( "obstacle" ) ).toInt();
137 : 0 : mDistance = elem.attribute( QStringLiteral( "dist" ) ).toDouble();
138 : 0 : mShowAll = ( elem.attribute( QStringLiteral( "showAll" ), QStringLiteral( "0" ) ) != QLatin1String( "0" ) );
139 : 0 : }
140 : :
141 : 0 : void QgsDiagramLayerSettings::writeXml( QDomElement &layerElem, QDomDocument &doc ) const
142 : : {
143 : 0 : QDomElement diagramLayerElem = doc.createElement( QStringLiteral( "DiagramLayerSettings" ) );
144 : 0 : QDomElement propertiesElem = doc.createElement( QStringLiteral( "properties" ) );
145 : 0 : ( void )mDataDefinedProperties.writeXml( propertiesElem, sPropertyDefinitions );
146 : 0 : diagramLayerElem.appendChild( propertiesElem );
147 : 0 : diagramLayerElem.setAttribute( QStringLiteral( "placement" ), mPlacement );
148 : 0 : diagramLayerElem.setAttribute( QStringLiteral( "linePlacementFlags" ), mPlacementFlags );
149 : 0 : diagramLayerElem.setAttribute( QStringLiteral( "priority" ), mPriority );
150 : 0 : diagramLayerElem.setAttribute( QStringLiteral( "zIndex" ), mZIndex );
151 : 0 : diagramLayerElem.setAttribute( QStringLiteral( "obstacle" ), mObstacle );
152 : 0 : diagramLayerElem.setAttribute( QStringLiteral( "dist" ), QString::number( mDistance ) );
153 : 0 : diagramLayerElem.setAttribute( QStringLiteral( "showAll" ), mShowAll );
154 : 0 : layerElem.appendChild( diagramLayerElem );
155 : 0 : }
156 : :
157 : 0 : bool QgsDiagramLayerSettings::prepare( const QgsExpressionContext &context ) const
158 : : {
159 : 0 : return mDataDefinedProperties.prepare( context );
160 : : }
161 : :
162 : 0 : QSet<QString> QgsDiagramLayerSettings::referencedFields( const QgsExpressionContext &context ) const
163 : : {
164 : 0 : QSet< QString > referenced;
165 : 0 : if ( mRenderer )
166 : 0 : referenced = mRenderer->referencedFields( context );
167 : :
168 : : //add the ones needed for data defined settings
169 : 0 : referenced.unite( mDataDefinedProperties.referencedFields( context ) );
170 : :
171 : 0 : return referenced;
172 : 0 : }
173 : :
174 : 0 : void QgsDiagramSettings::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
175 : : {
176 : 0 : enabled = ( elem.attribute( QStringLiteral( "enabled" ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
177 : 0 : if ( !QgsFontUtils::setFromXmlChildNode( font, elem, QStringLiteral( "fontProperties" ) ) )
178 : : {
179 : 0 : font.fromString( elem.attribute( QStringLiteral( "font" ) ) );
180 : 0 : }
181 : 0 : backgroundColor.setNamedColor( elem.attribute( QStringLiteral( "backgroundColor" ) ) );
182 : 0 : backgroundColor.setAlpha( elem.attribute( QStringLiteral( "backgroundAlpha" ) ).toInt() );
183 : 0 : size.setWidth( elem.attribute( QStringLiteral( "width" ) ).toDouble() );
184 : 0 : size.setHeight( elem.attribute( QStringLiteral( "height" ) ).toDouble() );
185 : 0 : if ( elem.hasAttribute( QStringLiteral( "transparency" ) ) )
186 : : {
187 : 0 : opacity = 1 - elem.attribute( QStringLiteral( "transparency" ), QStringLiteral( "0" ) ).toInt() / 255.0;
188 : 0 : }
189 : : else
190 : : {
191 : 0 : opacity = elem.attribute( QStringLiteral( "opacity" ), QStringLiteral( "1.00" ) ).toDouble();
192 : : }
193 : :
194 : 0 : penColor.setNamedColor( elem.attribute( QStringLiteral( "penColor" ) ) );
195 : 0 : int penAlpha = elem.attribute( QStringLiteral( "penAlpha" ), QStringLiteral( "255" ) ).toInt();
196 : 0 : penColor.setAlpha( penAlpha );
197 : 0 : penWidth = elem.attribute( QStringLiteral( "penWidth" ) ).toDouble();
198 : :
199 : 0 : mDirection = static_cast< Direction >( elem.attribute( QStringLiteral( "direction" ), QStringLiteral( "1" ) ).toInt() );
200 : :
201 : 0 : maximumScale = elem.attribute( QStringLiteral( "minScaleDenominator" ), QStringLiteral( "-1" ) ).toDouble();
202 : 0 : minimumScale = elem.attribute( QStringLiteral( "maxScaleDenominator" ), QStringLiteral( "-1" ) ).toDouble();
203 : 0 : if ( elem.hasAttribute( QStringLiteral( "scaleBasedVisibility" ) ) )
204 : : {
205 : 0 : scaleBasedVisibility = ( elem.attribute( QStringLiteral( "scaleBasedVisibility" ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
206 : 0 : }
207 : : else
208 : : {
209 : 0 : scaleBasedVisibility = maximumScale >= 0 && minimumScale >= 0;
210 : : }
211 : :
212 : : //diagram size unit type and scale
213 : 0 : if ( elem.attribute( QStringLiteral( "sizeType" ) ) == QLatin1String( "MapUnits" ) )
214 : : {
215 : : //compatibility with pre-2.16 project files
216 : 0 : sizeType = QgsUnitTypes::RenderMapUnits;
217 : 0 : }
218 : : else
219 : : {
220 : 0 : sizeType = QgsUnitTypes::decodeRenderUnit( elem.attribute( QStringLiteral( "sizeType" ) ) );
221 : : }
222 : 0 : sizeScale = QgsSymbolLayerUtils::decodeMapUnitScale( elem.attribute( QStringLiteral( "sizeScale" ) ) );
223 : :
224 : : //line width unit type and scale
225 : 0 : lineSizeUnit = QgsUnitTypes::decodeRenderUnit( elem.attribute( QStringLiteral( "lineSizeType" ) ) );
226 : 0 : lineSizeScale = QgsSymbolLayerUtils::decodeMapUnitScale( elem.attribute( QStringLiteral( "lineSizeScale" ) ) );
227 : :
228 : 0 : mSpacing = elem.attribute( QStringLiteral( "spacing" ) ).toDouble();
229 : 0 : mSpacingUnit = QgsUnitTypes::decodeRenderUnit( elem.attribute( QStringLiteral( "spacingUnit" ) ) );
230 : 0 : mSpacingMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( elem.attribute( QStringLiteral( "spacingUnitScale" ) ) );
231 : :
232 : : //label placement method
233 : 0 : if ( elem.attribute( QStringLiteral( "labelPlacementMethod" ) ) == QLatin1String( "Height" ) )
234 : : {
235 : 0 : labelPlacementMethod = Height;
236 : 0 : }
237 : : else
238 : : {
239 : 0 : labelPlacementMethod = XHeight;
240 : : }
241 : :
242 : : // orientation
243 : 0 : if ( elem.attribute( QStringLiteral( "diagramOrientation" ) ) == QLatin1String( "Left" ) )
244 : : {
245 : 0 : diagramOrientation = Left;
246 : 0 : }
247 : 0 : else if ( elem.attribute( QStringLiteral( "diagramOrientation" ) ) == QLatin1String( "Right" ) )
248 : : {
249 : 0 : diagramOrientation = Right;
250 : 0 : }
251 : 0 : else if ( elem.attribute( QStringLiteral( "diagramOrientation" ) ) == QLatin1String( "Down" ) )
252 : : {
253 : 0 : diagramOrientation = Down;
254 : 0 : }
255 : : else
256 : : {
257 : 0 : diagramOrientation = Up;
258 : : }
259 : :
260 : : // scale dependency
261 : 0 : if ( elem.attribute( QStringLiteral( "scaleDependency" ) ) == QLatin1String( "Diameter" ) )
262 : : {
263 : 0 : scaleByArea = false;
264 : 0 : }
265 : : else
266 : : {
267 : 0 : scaleByArea = true;
268 : : }
269 : :
270 : 0 : barWidth = elem.attribute( QStringLiteral( "barWidth" ) ).toDouble();
271 : :
272 : 0 : if ( elem.hasAttribute( QStringLiteral( "angleOffset" ) ) )
273 : 0 : rotationOffset = std::fmod( 360.0 - elem.attribute( QStringLiteral( "angleOffset" ) ).toInt() / 16.0, 360.0 );
274 : : else
275 : 0 : rotationOffset = elem.attribute( QStringLiteral( "rotationOffset" ) ).toDouble();
276 : :
277 : 0 : minimumSize = elem.attribute( QStringLiteral( "minimumSize" ) ).toDouble();
278 : :
279 : 0 : QDomNodeList axisSymbolNodes = elem.elementsByTagName( QStringLiteral( "axisSymbol" ) );
280 : 0 : if ( axisSymbolNodes.count() > 0 )
281 : : {
282 : 0 : QDomElement axisSymbolElem = axisSymbolNodes.at( 0 ).toElement().firstChildElement();
283 : 0 : mAxisLineSymbol.reset( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( axisSymbolElem, context ) );
284 : 0 : }
285 : : else
286 : : {
287 : 0 : mAxisLineSymbol = std::make_unique< QgsLineSymbol >();
288 : : }
289 : :
290 : 0 : mShowAxis = elem.attribute( QStringLiteral( "showAxis" ), QStringLiteral( "0" ) ).toInt();
291 : :
292 : : //colors
293 : 0 : categoryColors.clear();
294 : 0 : QDomNodeList attributes = elem.elementsByTagName( QStringLiteral( "attribute" ) );
295 : :
296 : :
297 : 0 : if ( attributes.length() > 0 )
298 : : {
299 : 0 : for ( int i = 0; i < attributes.size(); i++ )
300 : : {
301 : 0 : QDomElement attrElem = attributes.at( i ).toElement();
302 : 0 : QColor newColor( attrElem.attribute( QStringLiteral( "color" ) ) );
303 : 0 : newColor.setAlphaF( opacity );
304 : 0 : categoryColors.append( newColor );
305 : 0 : categoryAttributes.append( attrElem.attribute( QStringLiteral( "field" ) ) );
306 : 0 : categoryLabels.append( attrElem.attribute( QStringLiteral( "label" ) ) );
307 : 0 : if ( categoryLabels.constLast().isEmpty() )
308 : : {
309 : 0 : categoryLabels.back() = categoryAttributes.back();
310 : 0 : }
311 : 0 : }
312 : 0 : }
313 : : else
314 : : {
315 : : // Restore old format attributes and colors
316 : :
317 : 0 : QStringList colorList = elem.attribute( QStringLiteral( "colors" ) ).split( '/' );
318 : 0 : QStringList::const_iterator colorIt = colorList.constBegin();
319 : 0 : for ( ; colorIt != colorList.constEnd(); ++colorIt )
320 : : {
321 : 0 : QColor newColor( *colorIt );
322 : 0 : newColor.setAlphaF( opacity );
323 : 0 : categoryColors.append( QColor( newColor ) );
324 : 0 : }
325 : :
326 : : //attribute indices
327 : 0 : categoryAttributes.clear();
328 : 0 : QStringList catList = elem.attribute( QStringLiteral( "categories" ) ).split( '/' );
329 : 0 : QStringList::const_iterator catIt = catList.constBegin();
330 : 0 : for ( ; catIt != catList.constEnd(); ++catIt )
331 : : {
332 : 0 : categoryAttributes.append( *catIt );
333 : 0 : categoryLabels.append( *catIt );
334 : 0 : }
335 : 0 : }
336 : :
337 : 0 : QDomElement effectElem = elem.firstChildElement( QStringLiteral( "effect" ) );
338 : 0 : if ( !effectElem.isNull() )
339 : 0 : setPaintEffect( QgsApplication::paintEffectRegistry()->createEffect( effectElem ) );
340 : : else
341 : 0 : setPaintEffect( QgsApplication::paintEffectRegistry()->defaultStack() );
342 : 0 : }
343 : :
344 : 0 : void QgsDiagramSettings::writeXml( QDomElement &rendererElem, QDomDocument &doc, const QgsReadWriteContext &context ) const
345 : : {
346 : 0 : QDomElement categoryElem = doc.createElement( QStringLiteral( "DiagramCategory" ) );
347 : 0 : categoryElem.setAttribute( QStringLiteral( "enabled" ), enabled );
348 : 0 : categoryElem.appendChild( QgsFontUtils::toXmlElement( font, doc, QStringLiteral( "fontProperties" ) ) );
349 : 0 : categoryElem.setAttribute( QStringLiteral( "backgroundColor" ), backgroundColor.name() );
350 : 0 : categoryElem.setAttribute( QStringLiteral( "backgroundAlpha" ), backgroundColor.alpha() );
351 : 0 : categoryElem.setAttribute( QStringLiteral( "width" ), QString::number( size.width() ) );
352 : 0 : categoryElem.setAttribute( QStringLiteral( "height" ), QString::number( size.height() ) );
353 : 0 : categoryElem.setAttribute( QStringLiteral( "penColor" ), penColor.name() );
354 : 0 : categoryElem.setAttribute( QStringLiteral( "penAlpha" ), penColor.alpha() );
355 : 0 : categoryElem.setAttribute( QStringLiteral( "penWidth" ), QString::number( penWidth ) );
356 : 0 : categoryElem.setAttribute( QStringLiteral( "scaleBasedVisibility" ), scaleBasedVisibility );
357 : 0 : categoryElem.setAttribute( QStringLiteral( "minScaleDenominator" ), QString::number( maximumScale ) );
358 : 0 : categoryElem.setAttribute( QStringLiteral( "maxScaleDenominator" ), QString::number( minimumScale ) );
359 : 0 : categoryElem.setAttribute( QStringLiteral( "opacity" ), QString::number( opacity ) );
360 : 0 : categoryElem.setAttribute( QStringLiteral( "spacing" ), QString::number( mSpacing ) );
361 : 0 : categoryElem.setAttribute( QStringLiteral( "spacingUnit" ), QgsUnitTypes::encodeUnit( mSpacingUnit ) );
362 : 0 : categoryElem.setAttribute( QStringLiteral( "spacingUnitScale" ), QgsSymbolLayerUtils::encodeMapUnitScale( mSpacingMapUnitScale ) );
363 : 0 : categoryElem.setAttribute( QStringLiteral( "direction" ), QString::number( mDirection ) );
364 : :
365 : : //diagram size unit type and scale
366 : 0 : categoryElem.setAttribute( QStringLiteral( "sizeType" ), QgsUnitTypes::encodeUnit( sizeType ) );
367 : 0 : categoryElem.setAttribute( QStringLiteral( "sizeScale" ), QgsSymbolLayerUtils::encodeMapUnitScale( sizeScale ) );
368 : :
369 : : //line width unit type and scale
370 : 0 : categoryElem.setAttribute( QStringLiteral( "lineSizeType" ), QgsUnitTypes::encodeUnit( lineSizeUnit ) );
371 : 0 : categoryElem.setAttribute( QStringLiteral( "lineSizeScale" ), QgsSymbolLayerUtils::encodeMapUnitScale( lineSizeScale ) );
372 : :
373 : : // label placement method (text diagram)
374 : 0 : if ( labelPlacementMethod == Height )
375 : : {
376 : 0 : categoryElem.setAttribute( QStringLiteral( "labelPlacementMethod" ), QStringLiteral( "Height" ) );
377 : 0 : }
378 : : else
379 : : {
380 : 0 : categoryElem.setAttribute( QStringLiteral( "labelPlacementMethod" ), QStringLiteral( "XHeight" ) );
381 : : }
382 : :
383 : 0 : if ( scaleByArea )
384 : : {
385 : 0 : categoryElem.setAttribute( QStringLiteral( "scaleDependency" ), QStringLiteral( "Area" ) );
386 : 0 : }
387 : : else
388 : : {
389 : 0 : categoryElem.setAttribute( QStringLiteral( "scaleDependency" ), QStringLiteral( "Diameter" ) );
390 : : }
391 : :
392 : : // orientation (histogram)
393 : 0 : switch ( diagramOrientation )
394 : : {
395 : : case Left:
396 : 0 : categoryElem.setAttribute( QStringLiteral( "diagramOrientation" ), QStringLiteral( "Left" ) );
397 : 0 : break;
398 : :
399 : : case Right:
400 : 0 : categoryElem.setAttribute( QStringLiteral( "diagramOrientation" ), QStringLiteral( "Right" ) );
401 : 0 : break;
402 : :
403 : : case Down:
404 : 0 : categoryElem.setAttribute( QStringLiteral( "diagramOrientation" ), QStringLiteral( "Down" ) );
405 : 0 : break;
406 : :
407 : : case Up:
408 : 0 : categoryElem.setAttribute( QStringLiteral( "diagramOrientation" ), QStringLiteral( "Up" ) );
409 : 0 : break;
410 : : }
411 : :
412 : 0 : categoryElem.setAttribute( QStringLiteral( "barWidth" ), QString::number( barWidth ) );
413 : 0 : categoryElem.setAttribute( QStringLiteral( "minimumSize" ), QString::number( minimumSize ) );
414 : 0 : categoryElem.setAttribute( QStringLiteral( "rotationOffset" ), QString::number( rotationOffset ) );
415 : :
416 : 0 : int nCats = std::min( categoryColors.size(), categoryAttributes.size() );
417 : 0 : for ( int i = 0; i < nCats; ++i )
418 : 0 : {
419 : 0 : QDomElement attributeElem = doc.createElement( QStringLiteral( "attribute" ) );
420 : :
421 : 0 : attributeElem.setAttribute( QStringLiteral( "field" ), categoryAttributes.at( i ) );
422 : 0 : attributeElem.setAttribute( QStringLiteral( "color" ), categoryColors.at( i ).name() );
423 : 0 : attributeElem.setAttribute( QStringLiteral( "label" ), categoryLabels.at( i ) );
424 : 0 : categoryElem.appendChild( attributeElem );
425 : 0 : }
426 : :
427 : 0 : categoryElem.setAttribute( QStringLiteral( "showAxis" ), mShowAxis ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
428 : 0 : QDomElement axisSymbolElem = doc.createElement( QStringLiteral( "axisSymbol" ) );
429 : 0 : QDomElement symbolElem = QgsSymbolLayerUtils::saveSymbol( QString(), mAxisLineSymbol.get(), doc, context );
430 : 0 : axisSymbolElem.appendChild( symbolElem );
431 : 0 : categoryElem.appendChild( axisSymbolElem );
432 : :
433 : 0 : if ( mPaintEffect && !QgsPaintEffectRegistry::isDefaultStack( mPaintEffect.get() ) )
434 : 0 : mPaintEffect->saveProperties( doc, categoryElem );
435 : :
436 : 0 : rendererElem.appendChild( categoryElem );
437 : 0 : }
438 : :
439 : 0 : void QgsDiagramRenderer::setDiagram( QgsDiagram *d )
440 : : {
441 : 0 : if ( mDiagram.get() == d )
442 : 0 : return;
443 : :
444 : 0 : mDiagram.reset( d );
445 : 0 : }
446 : :
447 : 0 : QgsDiagramRenderer::QgsDiagramRenderer( const QgsDiagramRenderer &other )
448 : 0 : : mDiagram( other.mDiagram ? other.mDiagram->clone() : nullptr )
449 : 0 : , mShowAttributeLegend( other.mShowAttributeLegend )
450 : 0 : {
451 : 0 : }
452 : 0 :
453 : 0 : QgsDiagramRenderer &QgsDiagramRenderer::operator=( const QgsDiagramRenderer &other )
454 : 0 : {
455 : 0 : mDiagram.reset( other.mDiagram ? other.mDiagram->clone() : nullptr );
456 : 0 : mShowAttributeLegend = other.mShowAttributeLegend;
457 : 0 : return *this;
458 : : }
459 : 0 :
460 : 0 : void QgsDiagramRenderer::renderDiagram( const QgsFeature &feature, QgsRenderContext &c, QPointF pos, const QgsPropertyCollection &properties ) const
461 : : {
462 : 0 : if ( !mDiagram )
463 : : {
464 : 0 : return;
465 : 0 : }
466 : :
467 : 0 : QgsDiagramSettings s;
468 : 0 : if ( !diagramSettings( feature, c, s ) )
469 : : {
470 : 0 : return;
471 : : }
472 : :
473 : 0 : if ( properties.hasActiveProperties() )
474 : : {
475 : 0 : c.expressionContext().setOriginalValueVariable( QgsSymbolLayerUtils::encodeColor( s.backgroundColor ) );
476 : 0 : s.backgroundColor = properties.valueAsColor( QgsDiagramLayerSettings::BackgroundColor, c.expressionContext(), s.backgroundColor );
477 : 0 : c.expressionContext().setOriginalValueVariable( QgsSymbolLayerUtils::encodeColor( s.penColor ) );
478 : 0 : s.penColor = properties.valueAsColor( QgsDiagramLayerSettings::StrokeColor, c.expressionContext(), s.penColor );
479 : 0 : c.expressionContext().setOriginalValueVariable( s.penWidth );
480 : 0 : s.penWidth = properties.valueAsDouble( QgsDiagramLayerSettings::StrokeWidth, c.expressionContext(), s.penWidth );
481 : 0 : c.expressionContext().setOriginalValueVariable( s.rotationOffset );
482 : 0 : s.rotationOffset = properties.valueAsDouble( QgsDiagramLayerSettings::StartAngle, c.expressionContext(), s.rotationOffset );
483 : 0 : }
484 : :
485 : 0 : QgsPaintEffect *effect = s.paintEffect();
486 : 0 : std::unique_ptr< QgsEffectPainter > effectPainter;
487 : 0 : if ( effect && effect->enabled() )
488 : : {
489 : 0 : effectPainter = std::make_unique< QgsEffectPainter >( c, effect );
490 : 0 : }
491 : :
492 : 0 : mDiagram->renderDiagram( feature, c, s, pos );
493 : 0 : }
494 : :
495 : 0 : QSizeF QgsDiagramRenderer::sizeMapUnits( const QgsFeature &feature, const QgsRenderContext &c ) const
496 : : {
497 : 0 : QgsDiagramSettings s;
498 : 0 : if ( !diagramSettings( feature, c, s ) )
499 : : {
500 : 0 : return QSizeF();
501 : : }
502 : :
503 : 0 : QSizeF size = diagramSize( feature, c );
504 : 0 : if ( size.isValid() )
505 : : {
506 : 0 : double width = c.convertToMapUnits( size.width(), s.sizeType, s.sizeScale );
507 : 0 : size.rheight() *= width / size.width();
508 : 0 : size.setWidth( width );
509 : 0 : }
510 : 0 : return size;
511 : 0 : }
512 : :
513 : 0 : QSet<QString> QgsDiagramRenderer::referencedFields( const QgsExpressionContext &context ) const
514 : : {
515 : 0 : QSet< QString > referenced;
516 : :
517 : 0 : if ( !mDiagram )
518 : 0 : return referenced;
519 : :
520 : 0 : const auto constDiagramAttributes = diagramAttributes();
521 : 0 : for ( const QString &att : constDiagramAttributes )
522 : : {
523 : 0 : QgsExpression *expression = mDiagram->getExpression( att, context );
524 : 0 : const auto constReferencedColumns = expression->referencedColumns();
525 : 0 : for ( const QString &field : constReferencedColumns )
526 : : {
527 : 0 : referenced << field;
528 : : }
529 : 0 : }
530 : 0 : return referenced;
531 : 0 : }
532 : :
533 : 0 : void QgsDiagramRenderer::convertSizeToMapUnits( QSizeF &size, const QgsRenderContext &context ) const
534 : : {
535 : 0 : if ( !size.isValid() )
536 : : {
537 : 0 : return;
538 : : }
539 : :
540 : 0 : double pixelToMap = context.scaleFactor() * context.mapToPixel().mapUnitsPerPixel();
541 : 0 : size.rwidth() *= pixelToMap;
542 : 0 : size.rheight() *= pixelToMap;
543 : 0 : }
544 : :
545 : 0 : int QgsDiagramRenderer::dpiPaintDevice( const QPainter *painter )
546 : : {
547 : 0 : if ( painter )
548 : : {
549 : 0 : QPaintDevice *device = painter->device();
550 : 0 : if ( device )
551 : : {
552 : 0 : return device->logicalDpiX();
553 : : }
554 : 0 : }
555 : 0 : return -1;
556 : 0 : }
557 : :
558 : 0 : void QgsDiagramRenderer::_readXml( const QDomElement &elem, const QgsReadWriteContext &context )
559 : : {
560 : 0 : Q_UNUSED( context )
561 : 0 : mDiagram.reset();
562 : 0 : QString diagramType = elem.attribute( QStringLiteral( "diagramType" ) );
563 : 0 : if ( diagramType == QLatin1String( "Pie" ) )
564 : : {
565 : 0 : mDiagram.reset( new QgsPieDiagram() );
566 : 0 : }
567 : 0 : else if ( diagramType == QLatin1String( "Text" ) )
568 : : {
569 : 0 : mDiagram.reset( new QgsTextDiagram() );
570 : 0 : }
571 : 0 : else if ( diagramType == QLatin1String( "Histogram" ) )
572 : : {
573 : 0 : mDiagram.reset( new QgsHistogramDiagram() );
574 : 0 : }
575 : 0 : else if ( diagramType == QLatin1String( "Stacked" ) )
576 : : {
577 : 0 : mDiagram.reset( new QgsStackedBarDiagram() );
578 : 0 : }
579 : : else
580 : : {
581 : : // unknown diagram type -- default to histograms
582 : 0 : mDiagram.reset( new QgsHistogramDiagram() );
583 : : }
584 : 0 : mShowAttributeLegend = ( elem.attribute( QStringLiteral( "attributeLegend" ), QStringLiteral( "1" ) ) != QLatin1String( "0" ) );
585 : 0 : }
586 : :
587 : 0 : void QgsDiagramRenderer::_writeXml( QDomElement &rendererElem, QDomDocument &doc, const QgsReadWriteContext &context ) const
588 : : {
589 : 0 : Q_UNUSED( doc )
590 : 0 : Q_UNUSED( context )
591 : :
592 : 0 : if ( mDiagram )
593 : : {
594 : 0 : rendererElem.setAttribute( QStringLiteral( "diagramType" ), mDiagram->diagramName() );
595 : 0 : }
596 : 0 : rendererElem.setAttribute( QStringLiteral( "attributeLegend" ), mShowAttributeLegend );
597 : 0 : }
598 : :
599 : 0 : QgsSingleCategoryDiagramRenderer *QgsSingleCategoryDiagramRenderer::clone() const
600 : : {
601 : 0 : return new QgsSingleCategoryDiagramRenderer( *this );
602 : 0 : }
603 : :
604 : 0 : bool QgsSingleCategoryDiagramRenderer::diagramSettings( const QgsFeature &, const QgsRenderContext &c, QgsDiagramSettings &s ) const
605 : : {
606 : 0 : Q_UNUSED( c )
607 : 0 : s = mSettings;
608 : 0 : return true;
609 : : }
610 : :
611 : 0 : QSizeF QgsSingleCategoryDiagramRenderer::diagramSize( const QgsFeature &feature, const QgsRenderContext &c ) const
612 : : {
613 : 0 : return mDiagram->diagramSize( feature.attributes(), c, mSettings );
614 : 0 : }
615 : :
616 : 0 : QList<QgsDiagramSettings> QgsSingleCategoryDiagramRenderer::diagramSettings() const
617 : : {
618 : 0 : QList<QgsDiagramSettings> settingsList;
619 : 0 : settingsList.push_back( mSettings );
620 : 0 : return settingsList;
621 : 0 : }
622 : :
623 : 0 : void QgsSingleCategoryDiagramRenderer::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
624 : : {
625 : 0 : QDomElement categoryElem = elem.firstChildElement( QStringLiteral( "DiagramCategory" ) );
626 : 0 : if ( categoryElem.isNull() )
627 : : {
628 : 0 : return;
629 : : }
630 : :
631 : 0 : mSettings.readXml( categoryElem, context );
632 : 0 : _readXml( elem, context );
633 : 0 : }
634 : :
635 : 0 : void QgsSingleCategoryDiagramRenderer::writeXml( QDomElement &layerElem, QDomDocument &doc, const QgsReadWriteContext &context ) const
636 : : {
637 : 0 : QDomElement rendererElem = doc.createElement( QStringLiteral( "SingleCategoryDiagramRenderer" ) );
638 : 0 : mSettings.writeXml( rendererElem, doc, context );
639 : 0 : _writeXml( rendererElem, doc, context );
640 : 0 : layerElem.appendChild( rendererElem );
641 : 0 : }
642 : :
643 : :
644 : 0 : QgsLinearlyInterpolatedDiagramRenderer::QgsLinearlyInterpolatedDiagramRenderer()
645 : 0 : {
646 : 0 : mInterpolationSettings.classificationAttributeIsExpression = false;
647 : 0 : }
648 : 0 :
649 : 0 : QgsLinearlyInterpolatedDiagramRenderer::QgsLinearlyInterpolatedDiagramRenderer( const QgsLinearlyInterpolatedDiagramRenderer &other )
650 : 0 : : QgsDiagramRenderer( other )
651 : 0 : , mSettings( other.mSettings )
652 : 0 : , mInterpolationSettings( other.mInterpolationSettings )
653 : 0 : , mDataDefinedSizeLegend( other.mDataDefinedSizeLegend ? new QgsDataDefinedSizeLegend( *other.mDataDefinedSizeLegend ) : nullptr )
654 : 0 : {
655 : 0 : }
656 : :
657 : 0 : QgsLinearlyInterpolatedDiagramRenderer::~QgsLinearlyInterpolatedDiagramRenderer()
658 : 0 : {
659 : 0 : delete mDataDefinedSizeLegend;
660 : 0 : }
661 : :
662 : 0 : QgsLinearlyInterpolatedDiagramRenderer *QgsLinearlyInterpolatedDiagramRenderer::clone() const
663 : : {
664 : 0 : return new QgsLinearlyInterpolatedDiagramRenderer( *this );
665 : 0 : }
666 : :
667 : 0 : QList<QgsDiagramSettings> QgsLinearlyInterpolatedDiagramRenderer::diagramSettings() const
668 : : {
669 : 0 : QList<QgsDiagramSettings> settingsList;
670 : 0 : settingsList.push_back( mSettings );
671 : 0 : return settingsList;
672 : 0 : }
673 : :
674 : 0 : bool QgsLinearlyInterpolatedDiagramRenderer::diagramSettings( const QgsFeature &feature, const QgsRenderContext &c, QgsDiagramSettings &s ) const
675 : : {
676 : 0 : s = mSettings;
677 : 0 : s.size = diagramSize( feature, c );
678 : 0 : return true;
679 : : }
680 : :
681 : 0 : QList<QString> QgsLinearlyInterpolatedDiagramRenderer::diagramAttributes() const
682 : : {
683 : 0 : return mSettings.categoryAttributes;
684 : : }
685 : :
686 : 0 : QSet<QString> QgsLinearlyInterpolatedDiagramRenderer::referencedFields( const QgsExpressionContext &context ) const
687 : : {
688 : 0 : QSet< QString > referenced = QgsDiagramRenderer::referencedFields( context );
689 : 0 : if ( mInterpolationSettings.classificationAttributeIsExpression )
690 : : {
691 : 0 : QgsExpression *expression = mDiagram->getExpression( mInterpolationSettings.classificationAttributeExpression, context );
692 : 0 : const auto constReferencedColumns = expression->referencedColumns();
693 : 0 : for ( const QString &field : constReferencedColumns )
694 : : {
695 : 0 : referenced << field;
696 : : }
697 : 0 : }
698 : : else
699 : : {
700 : 0 : referenced << mInterpolationSettings.classificationField;
701 : : }
702 : 0 : return referenced;
703 : 0 : }
704 : :
705 : 0 : QSizeF QgsLinearlyInterpolatedDiagramRenderer::diagramSize( const QgsFeature &feature, const QgsRenderContext &c ) const
706 : : {
707 : 0 : return mDiagram->diagramSize( feature, c, mSettings, mInterpolationSettings );
708 : : }
709 : :
710 : 0 : void QgsLinearlyInterpolatedDiagramRenderer::readXml( const QDomElement &elem, const QgsReadWriteContext &context )
711 : : {
712 : 0 : mInterpolationSettings.lowerValue = elem.attribute( QStringLiteral( "lowerValue" ) ).toDouble();
713 : 0 : mInterpolationSettings.upperValue = elem.attribute( QStringLiteral( "upperValue" ) ).toDouble();
714 : 0 : mInterpolationSettings.lowerSize.setWidth( elem.attribute( QStringLiteral( "lowerWidth" ) ).toDouble() );
715 : 0 : mInterpolationSettings.lowerSize.setHeight( elem.attribute( QStringLiteral( "lowerHeight" ) ).toDouble() );
716 : 0 : mInterpolationSettings.upperSize.setWidth( elem.attribute( QStringLiteral( "upperWidth" ) ).toDouble() );
717 : 0 : mInterpolationSettings.upperSize.setHeight( elem.attribute( QStringLiteral( "upperHeight" ) ).toDouble() );
718 : 0 : mInterpolationSettings.classificationAttributeIsExpression = elem.hasAttribute( QStringLiteral( "classificationAttributeExpression" ) );
719 : 0 : if ( mInterpolationSettings.classificationAttributeIsExpression )
720 : : {
721 : 0 : mInterpolationSettings.classificationAttributeExpression = elem.attribute( QStringLiteral( "classificationAttributeExpression" ) );
722 : 0 : }
723 : : else
724 : : {
725 : 0 : mInterpolationSettings.classificationField = elem.attribute( QStringLiteral( "classificationField" ) );
726 : : }
727 : 0 : QDomElement settingsElem = elem.firstChildElement( QStringLiteral( "DiagramCategory" ) );
728 : 0 : if ( !settingsElem.isNull() )
729 : : {
730 : 0 : mSettings.readXml( settingsElem );
731 : 0 : }
732 : :
733 : 0 : delete mDataDefinedSizeLegend;
734 : :
735 : 0 : QDomElement ddsLegendSizeElem = elem.firstChildElement( QStringLiteral( "data-defined-size-legend" ) );
736 : 0 : if ( !ddsLegendSizeElem.isNull() )
737 : : {
738 : 0 : mDataDefinedSizeLegend = QgsDataDefinedSizeLegend::readXml( ddsLegendSizeElem, context );
739 : 0 : }
740 : : else
741 : : {
742 : : // pre-3.0 projects
743 : 0 : if ( elem.attribute( QStringLiteral( "sizeLegend" ), QStringLiteral( "0" ) ) != QLatin1String( "0" ) )
744 : : {
745 : 0 : mDataDefinedSizeLegend = new QgsDataDefinedSizeLegend();
746 : 0 : QDomElement sizeLegendSymbolElem = elem.firstChildElement( QStringLiteral( "symbol" ) );
747 : 0 : if ( !sizeLegendSymbolElem.isNull() && sizeLegendSymbolElem.attribute( QStringLiteral( "name" ) ) == QLatin1String( "sizeSymbol" ) )
748 : : {
749 : 0 : mDataDefinedSizeLegend->setSymbol( QgsSymbolLayerUtils::loadSymbol<QgsMarkerSymbol>( sizeLegendSymbolElem, context ) );
750 : 0 : }
751 : 0 : }
752 : : else
753 : : {
754 : 0 : mDataDefinedSizeLegend = nullptr;
755 : : }
756 : : }
757 : :
758 : 0 : _readXml( elem, context );
759 : 0 : }
760 : :
761 : 0 : void QgsLinearlyInterpolatedDiagramRenderer::writeXml( QDomElement &layerElem, QDomDocument &doc, const QgsReadWriteContext &context ) const
762 : : {
763 : 0 : QDomElement rendererElem = doc.createElement( QStringLiteral( "LinearlyInterpolatedDiagramRenderer" ) );
764 : 0 : rendererElem.setAttribute( QStringLiteral( "lowerValue" ), QString::number( mInterpolationSettings.lowerValue ) );
765 : 0 : rendererElem.setAttribute( QStringLiteral( "upperValue" ), QString::number( mInterpolationSettings.upperValue ) );
766 : 0 : rendererElem.setAttribute( QStringLiteral( "lowerWidth" ), QString::number( mInterpolationSettings.lowerSize.width() ) );
767 : 0 : rendererElem.setAttribute( QStringLiteral( "lowerHeight" ), QString::number( mInterpolationSettings.lowerSize.height() ) );
768 : 0 : rendererElem.setAttribute( QStringLiteral( "upperWidth" ), QString::number( mInterpolationSettings.upperSize.width() ) );
769 : 0 : rendererElem.setAttribute( QStringLiteral( "upperHeight" ), QString::number( mInterpolationSettings.upperSize.height() ) );
770 : 0 : if ( mInterpolationSettings.classificationAttributeIsExpression )
771 : : {
772 : 0 : rendererElem.setAttribute( QStringLiteral( "classificationAttributeExpression" ), mInterpolationSettings.classificationAttributeExpression );
773 : 0 : }
774 : : else
775 : : {
776 : 0 : rendererElem.setAttribute( QStringLiteral( "classificationField" ), mInterpolationSettings.classificationField );
777 : : }
778 : 0 : mSettings.writeXml( rendererElem, doc );
779 : :
780 : 0 : if ( mDataDefinedSizeLegend )
781 : : {
782 : 0 : QDomElement ddsLegendElem = doc.createElement( QStringLiteral( "data-defined-size-legend" ) );
783 : 0 : mDataDefinedSizeLegend->writeXml( ddsLegendElem, context );
784 : 0 : rendererElem.appendChild( ddsLegendElem );
785 : 0 : }
786 : :
787 : 0 : _writeXml( rendererElem, doc, context );
788 : 0 : layerElem.appendChild( rendererElem );
789 : 0 : }
790 : :
791 : 0 : QList< QgsLayerTreeModelLegendNode * > QgsDiagramSettings::legendItems( QgsLayerTreeLayer *nodeLayer ) const
792 : : {
793 : 0 : QList< QgsLayerTreeModelLegendNode * > list;
794 : 0 : list.reserve( categoryLabels.size() );
795 : 0 : for ( int i = 0; i < categoryLabels.size(); ++i )
796 : : {
797 : 0 : QPixmap pix( 16, 16 );
798 : 0 : pix.fill( categoryColors[i] );
799 : 0 : list << new QgsSimpleLegendNode( nodeLayer, categoryLabels[i], QIcon( pix ), nullptr, QStringLiteral( "diagram_%1" ).arg( QString::number( i ) ) );
800 : 0 : }
801 : 0 : return list;
802 : 0 : }
803 : :
804 : 0 : QgsLineSymbol *QgsDiagramSettings::axisLineSymbol() const
805 : : {
806 : 0 : return mAxisLineSymbol.get();
807 : : }
808 : :
809 : 0 : void QgsDiagramSettings::setAxisLineSymbol( QgsLineSymbol *axisLineSymbol )
810 : : {
811 : 0 : if ( axisLineSymbol != mAxisLineSymbol.get() )
812 : 0 : mAxisLineSymbol.reset( axisLineSymbol );
813 : 0 : }
814 : :
815 : 0 : bool QgsDiagramSettings::showAxis() const
816 : : {
817 : 0 : return mShowAxis;
818 : : }
819 : :
820 : 0 : void QgsDiagramSettings::setShowAxis( bool showAxis )
821 : : {
822 : 0 : mShowAxis = showAxis;
823 : 0 : }
824 : :
825 : 0 : QgsPaintEffect *QgsDiagramSettings::paintEffect() const
826 : : {
827 : 0 : return mPaintEffect.get();
828 : : }
829 : :
830 : 0 : void QgsDiagramSettings::setPaintEffect( QgsPaintEffect *effect )
831 : : {
832 : 0 : if ( effect != mPaintEffect.get() )
833 : 0 : mPaintEffect.reset( effect );
834 : 0 : }
835 : :
836 : 0 : QgsDiagramSettings::QgsDiagramSettings()
837 : 0 : : mAxisLineSymbol( std::make_unique< QgsLineSymbol >() )
838 : : {
839 : 0 : }
840 : :
841 : 0 : QgsDiagramSettings::~QgsDiagramSettings() = default;
842 : :
843 : 0 : QgsDiagramSettings::QgsDiagramSettings( const QgsDiagramSettings &other )
844 : 0 : : enabled( other.enabled )
845 : 0 : , font( other.font )
846 : 0 : , categoryColors( other.categoryColors )
847 : 0 : , categoryAttributes( other.categoryAttributes )
848 : 0 : , categoryLabels( other.categoryLabels )
849 : 0 : , size( other.size )
850 : 0 : , sizeType( other.sizeType )
851 : 0 : , sizeScale( other.sizeScale )
852 : 0 : , lineSizeUnit( other.lineSizeUnit )
853 : 0 : , lineSizeScale( other.lineSizeScale )
854 : 0 : , backgroundColor( other.backgroundColor )
855 : 0 : , penColor( other.penColor )
856 : 0 : , penWidth( other.penWidth )
857 : 0 : , labelPlacementMethod( other.labelPlacementMethod )
858 : 0 : , diagramOrientation( other.diagramOrientation )
859 : 0 : , barWidth( other.barWidth )
860 : 0 : , opacity( other.opacity )
861 : 0 : , scaleByArea( other.scaleByArea )
862 : 0 : , rotationOffset( other.rotationOffset )
863 : 0 : , scaleBasedVisibility( other.scaleBasedVisibility )
864 : 0 : , maximumScale( other.maximumScale )
865 : 0 : , minimumScale( other.minimumScale )
866 : 0 : , minimumSize( other.minimumSize )
867 : 0 : , mSpacing( other.mSpacing )
868 : 0 : , mSpacingUnit( other.mSpacingUnit )
869 : 0 : , mSpacingMapUnitScale( other.mSpacingMapUnitScale )
870 : 0 : , mDirection( other.mDirection )
871 : 0 : , mShowAxis( other.mShowAxis )
872 : 0 : , mAxisLineSymbol( other.mAxisLineSymbol ? other.mAxisLineSymbol->clone() : nullptr )
873 : 0 : , mPaintEffect( other.mPaintEffect ? other.mPaintEffect->clone() : nullptr )
874 : : {
875 : :
876 : 0 : }
877 : :
878 : 0 : QgsDiagramSettings &QgsDiagramSettings::operator=( const QgsDiagramSettings &other )
879 : : {
880 : 0 : enabled = other.enabled;
881 : 0 : font = other.font;
882 : 0 : categoryColors = other.categoryColors;
883 : 0 : categoryAttributes = other.categoryAttributes;
884 : 0 : categoryLabels = other.categoryLabels;
885 : 0 : size = other.size;
886 : 0 : sizeType = other.sizeType;
887 : 0 : sizeScale = other.sizeScale;
888 : 0 : lineSizeUnit = other.lineSizeUnit;
889 : 0 : lineSizeScale = other.lineSizeScale;
890 : 0 : backgroundColor = other.backgroundColor;
891 : 0 : penColor = other.penColor;
892 : 0 : penWidth = other.penWidth;
893 : 0 : labelPlacementMethod = other.labelPlacementMethod;
894 : 0 : diagramOrientation = other.diagramOrientation;
895 : 0 : barWidth = other.barWidth;
896 : 0 : opacity = other.opacity;
897 : 0 : scaleByArea = other.scaleByArea;
898 : 0 : rotationOffset = other.rotationOffset;
899 : 0 : scaleBasedVisibility = other.scaleBasedVisibility;
900 : 0 : maximumScale = other.maximumScale;
901 : 0 : minimumScale = other.minimumScale;
902 : 0 : minimumSize = other.minimumSize;
903 : 0 : mSpacing = other.mSpacing;
904 : 0 : mSpacingUnit = other.mSpacingUnit;
905 : 0 : mSpacingMapUnitScale = other.mSpacingMapUnitScale;
906 : 0 : mDirection = other.mDirection;
907 : 0 : mAxisLineSymbol.reset( other.mAxisLineSymbol ? other.mAxisLineSymbol->clone() : nullptr );
908 : 0 : mShowAxis = other.mShowAxis;
909 : 0 : mPaintEffect.reset( other.mPaintEffect ? other.mPaintEffect->clone() : nullptr );
910 : 0 : return *this;
911 : : }
912 : :
913 : 0 : QgsDiagramSettings::Direction QgsDiagramSettings::direction() const
914 : : {
915 : 0 : return mDirection;
916 : : }
917 : :
918 : 0 : void QgsDiagramSettings::setDirection( Direction direction )
919 : : {
920 : 0 : mDirection = direction;
921 : 0 : }
922 : :
923 : 0 : QList< QgsLayerTreeModelLegendNode * > QgsDiagramRenderer::legendItems( QgsLayerTreeLayer * ) const
924 : : {
925 : 0 : return QList< QgsLayerTreeModelLegendNode * >();
926 : : }
927 : :
928 : 0 : QList< QgsLayerTreeModelLegendNode * > QgsSingleCategoryDiagramRenderer::legendItems( QgsLayerTreeLayer *nodeLayer ) const
929 : : {
930 : 0 : QList< QgsLayerTreeModelLegendNode * > nodes;
931 : 0 : if ( mShowAttributeLegend )
932 : 0 : nodes = mSettings.legendItems( nodeLayer );
933 : :
934 : 0 : return nodes;
935 : 0 : }
936 : :
937 : 0 : QList< QgsLayerTreeModelLegendNode * > QgsLinearlyInterpolatedDiagramRenderer::legendItems( QgsLayerTreeLayer *nodeLayer ) const
938 : : {
939 : 0 : QList< QgsLayerTreeModelLegendNode * > nodes;
940 : 0 : if ( mShowAttributeLegend )
941 : 0 : nodes = mSettings.legendItems( nodeLayer );
942 : :
943 : 0 : if ( mDataDefinedSizeLegend && mDiagram )
944 : : {
945 : : // add size legend
946 : 0 : QgsMarkerSymbol *legendSymbol = mDataDefinedSizeLegend->symbol() ? mDataDefinedSizeLegend->symbol()->clone() : QgsMarkerSymbol::createSimple( QVariantMap() );
947 : 0 : legendSymbol->setSizeUnit( mSettings.sizeType );
948 : 0 : legendSymbol->setSizeMapUnitScale( mSettings.sizeScale );
949 : :
950 : 0 : QgsDataDefinedSizeLegend ddSizeLegend( *mDataDefinedSizeLegend );
951 : 0 : ddSizeLegend.setSymbol( legendSymbol ); // transfers ownership
952 : :
953 : 0 : QList<QgsDataDefinedSizeLegend::SizeClass> sizeClasses;
954 : 0 : if ( ddSizeLegend.classes().isEmpty() )
955 : : {
956 : : // automatic class creation if the classes are not defined manually
957 : 0 : const auto prettyBreaks { QgsSymbolLayerUtils::prettyBreaks( mInterpolationSettings.lowerValue, mInterpolationSettings.upperValue, 4 ) };
958 : 0 : for ( double v : prettyBreaks )
959 : : {
960 : 0 : double size = mDiagram->legendSize( v, mSettings, mInterpolationSettings );
961 : 0 : sizeClasses << QgsDataDefinedSizeLegend::SizeClass( size, QString::number( v ) );
962 : : }
963 : 0 : }
964 : : else
965 : : {
966 : : // manual classes need to get size scaled because the QgsSizeScaleTransformer is not used in diagrams :-(
967 : 0 : const auto constClasses = ddSizeLegend.classes();
968 : 0 : for ( const QgsDataDefinedSizeLegend::SizeClass &sc : constClasses )
969 : : {
970 : 0 : double size = mDiagram->legendSize( sc.size, mSettings, mInterpolationSettings );
971 : 0 : sizeClasses << QgsDataDefinedSizeLegend::SizeClass( size, sc.label );
972 : : }
973 : 0 : }
974 : 0 : ddSizeLegend.setClasses( sizeClasses );
975 : :
976 : 0 : const auto constLegendSymbolList = ddSizeLegend.legendSymbolList();
977 : 0 : for ( const QgsLegendSymbolItem &si : constLegendSymbolList )
978 : : {
979 : 0 : if ( auto *lDataDefinedSizeLegendSettings = si.dataDefinedSizeLegendSettings() )
980 : 0 : nodes << new QgsDataDefinedSizeLegendNode( nodeLayer, *lDataDefinedSizeLegendSettings );
981 : : else
982 : 0 : nodes << new QgsSymbolLegendNode( nodeLayer, si );
983 : : }
984 : 0 : }
985 : :
986 : 0 : return nodes;
987 : 0 : }
988 : :
989 : 0 : void QgsLinearlyInterpolatedDiagramRenderer::setDataDefinedSizeLegend( QgsDataDefinedSizeLegend *settings )
990 : : {
991 : 0 : delete mDataDefinedSizeLegend;
992 : 0 : mDataDefinedSizeLegend = settings;
993 : 0 : }
994 : :
995 : 0 : QgsDataDefinedSizeLegend *QgsLinearlyInterpolatedDiagramRenderer::dataDefinedSizeLegend() const
996 : : {
997 : 0 : return mDataDefinedSizeLegend;
998 : : }
|
