QGIS API Documentation 3.37.0-Master (4ace69f83af)
Loading...
Searching...
No Matches
qgsdatadefinedsizelegend.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsdatadefinedsizelegend.cpp
3 --------------------------------------
4 Date : June 2017
5 Copyright : (C) 2017 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
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
17
18#include "qgsproperty.h"
20#include "qgssymbollayerutils.h"
21#include "qgsxmlutils.h"
22#include "qgslinesymbollayer.h"
23#include "qgstextformat.h"
24#include "qgstextrenderer.h"
25#include "qgsmarkersymbol.h"
26#include "qgslinesymbol.h"
27#include "qgsfontutils.h"
28#include "qgscolorutils.h"
29
31{
32 std::unique_ptr< QgsSimpleLineSymbolLayer > lineSymbolLayer = std::make_unique< QgsSimpleLineSymbolLayer >( QColor( 0, 0, 0 ), 0.2 );
33 mLineSymbol = std::make_unique< QgsLineSymbol >( QgsSymbolLayerList() << lineSymbolLayer.release() );
34}
35
37
39 : mType( other.mType )
40 , mTitleLabel( other.mTitleLabel )
41 , mSizeClasses( other.mSizeClasses )
42 , mSymbol( other.mSymbol.get() ? other.mSymbol->clone() : nullptr )
43 , mLineSymbol( other.mLineSymbol.get() ? other.mLineSymbol->clone() : nullptr )
44 , mSizeScaleTransformer( other.mSizeScaleTransformer.get() ? new QgsSizeScaleTransformer( *other.mSizeScaleTransformer ) : nullptr )
45 , mVAlign( other.mVAlign )
46 , mFont( other.mFont )
47 , mTextColor( other.mTextColor )
48 , mTextAlignment( other.mTextAlignment )
49{
50}
51
53{
54 if ( this != &other )
55 {
56 mType = other.mType;
57 mTitleLabel = other.mTitleLabel;
58 mSizeClasses = other.mSizeClasses;
59 mSymbol.reset( other.mSymbol.get() ? other.mSymbol->clone() : nullptr );
60 mLineSymbol.reset( other.mLineSymbol.get() ? other.mLineSymbol->clone() : nullptr );
61 mSizeScaleTransformer.reset( other.mSizeScaleTransformer.get() ? new QgsSizeScaleTransformer( *other.mSizeScaleTransformer ) : nullptr );
62 mVAlign = other.mVAlign;
63 mFont = other.mFont;
64 mTextColor = other.mTextColor;
65 mTextAlignment = other.mTextAlignment;
66 }
67 return *this;
68}
69
71{
72 mSymbol.reset( symbol );
73}
74
76{
77 return mSymbol.get();
78}
79
81{
82 mLineSymbol.reset( symbol );
83}
84
86{
87 return mLineSymbol.get();
88}
89
91{
92 mSizeScaleTransformer.reset( transformer );
93}
94
96{
97 return mSizeScaleTransformer.get();
98}
99
100
102{
103 mSymbol.reset( symbol->clone() );
104 mSymbol->setDataDefinedSize( QgsProperty() ); // original symbol may have had data-defined size associated
105
106 const QgsSizeScaleTransformer *sizeTransformer = dynamic_cast< const QgsSizeScaleTransformer * >( ddSize.transformer() );
107 mSizeScaleTransformer.reset( sizeTransformer ? sizeTransformer->clone() : nullptr );
108
109 if ( mTitleLabel.isEmpty() )
110 mTitleLabel = ddSize.propertyType() == Qgis::PropertyType::Expression ? ddSize.expressionString() : ddSize.field();
111
112 // automatically generate classes if no classes are defined
113 if ( sizeTransformer && mSizeClasses.isEmpty() )
114 {
115 mSizeClasses.clear();
116 const auto prettyBreaks { QgsSymbolLayerUtils::prettyBreaks( sizeTransformer->minValue(), sizeTransformer->maxValue(), 4 ) };
117 for ( double v : prettyBreaks )
118 {
119 mSizeClasses << SizeClass( v, QString::number( v ) );
120 }
121 }
122}
123
125{
127 if ( !mTitleLabel.isEmpty() )
128 {
129 QgsLegendSymbolItem title( nullptr, mTitleLabel, QString() );
130 lst << title;
131 }
132
133 switch ( mType )
134 {
135 case LegendCollapsed:
136 {
139 lst << i;
140 break;
141 }
142
143 case LegendSeparated:
144 {
145 lst.reserve( mSizeClasses.size() );
146 for ( const SizeClass &cl : mSizeClasses )
147 {
148 QgsLegendSymbolItem si( mSymbol.get(), cl.label, QString() );
149 QgsMarkerSymbol *s = static_cast<QgsMarkerSymbol *>( si.symbol() );
150 double size = cl.size;
151 if ( mSizeScaleTransformer )
152 {
153 size = mSizeScaleTransformer->size( size );
154 }
155
156 s->setSize( size );
157 lst << si;
158 }
159 break;
160 }
161 }
162 return lst;
163}
164
165
166void QgsDataDefinedSizeLegend::drawCollapsedLegend( QgsRenderContext &context, QSizeF *outputSize, double *labelXOffset ) const
167{
168 // this assumes the context's painter has been scaled to pixels in advance!
169
170 if ( mType != LegendCollapsed || mSizeClasses.isEmpty() || !mSymbol )
171 {
172 if ( outputSize )
173 *outputSize = QSizeF();
174 if ( labelXOffset )
175 *labelXOffset = 0;
176 return;
177 }
178
179 // parameters that could be configurable
180 double hLengthLineMM = 2; // extra horizontal space to be occupied by callout line
181 double hSpaceLineTextMM = 1; // horizontal space between end of the line and start of the text
182
183 std::unique_ptr<QgsMarkerSymbol> s( mSymbol->clone() );
184
185 QList<SizeClass> classes = mSizeClasses;
186
187 // optionally scale size values if transformer is defined
188 if ( mSizeScaleTransformer )
189 {
190 for ( SizeClass &cls : classes )
191 cls.size = mSizeScaleTransformer->size( cls.size );
192 }
193
194 // make sure we draw bigger symbols first
195 std::sort( classes.begin(), classes.end(), []( const SizeClass & a, const SizeClass & b ) { return a.size > b.size; } );
196
197 double hLengthLine = context.convertToPainterUnits( hLengthLineMM, Qgis::RenderUnit::Millimeters );
198 double hSpaceLineText = context.convertToPainterUnits( hSpaceLineTextMM, Qgis::RenderUnit::Millimeters );
199 int dpm = std::round( context.scaleFactor() * 1000 ); // scale factor = dots per millimeter
200
201 // get font metrics - we need a temporary image just to get the metrics right for the given DPI
202 QImage tmpImg( QSize( 1, 1 ), QImage::Format_ARGB32_Premultiplied );
203 tmpImg.setDotsPerMeterX( dpm );
204 tmpImg.setDotsPerMeterY( dpm );
205 QFontMetricsF fm( mFont, &tmpImg );
206 double textHeight = fm.height();
207 double leading = fm.leading();
208 double minTextDistY = textHeight + leading;
209
210 //
211 // determine layout of the rendered elements
212 //
213
214 // find out how wide the text will be
215 double maxTextWidth = 0;
216 for ( const SizeClass &c : std::as_const( classes ) )
217 {
218 maxTextWidth = std::max( maxTextWidth, fm.boundingRect( c.label ).width() );
219 }
220 // add extra width needed to handle varying rendering of font weight
221 maxTextWidth += 1;
222
223 // find out size of the largest symbol
224 double largestSize = classes.at( 0 ).size;
225 double outputLargestSize = context.convertToPainterUnits( largestSize, s->sizeUnit(), s->sizeMapUnitScale() );
226
227 // find out top Y coordinate for individual symbol sizes
228 QList<double> symbolTopY;
229 for ( const SizeClass &c : std::as_const( classes ) )
230 {
231 double outputSymbolSize = context.convertToPainterUnits( c.size, s->sizeUnit(), s->sizeMapUnitScale() );
232 switch ( mVAlign )
233 {
234 case AlignCenter:
235 symbolTopY << outputLargestSize / 2 - outputSymbolSize / 2;
236 break;
237 case AlignBottom:
238 symbolTopY << outputLargestSize - outputSymbolSize;
239 break;
240 }
241 }
242
243 // determine Y coordinate of texts: ideally they should be at the same level as symbolTopY
244 // but we need to avoid overlapping texts, so adjust the vertical positions
245 double middleIndex = 0; // classes.count() / 2; // will get the ideal position
246 QList<double> textCenterY;
247 double lastY = middleIndex < symbolTopY.size() ? symbolTopY[middleIndex] : 0;
248 textCenterY << lastY;
249 for ( int i = middleIndex + 1; i < classes.count(); ++i )
250 {
251 double symbolY = symbolTopY[i];
252 if ( symbolY - lastY < minTextDistY )
253 symbolY = lastY + minTextDistY;
254 textCenterY << symbolY;
255 lastY = symbolY;
256 }
257
258 double textTopY = textCenterY.first() - textHeight / 2;
259 double textBottomY = textCenterY.last() + textHeight / 2;
260 double totalTextHeight = textBottomY - textTopY;
261
262 double fullWidth = outputLargestSize + hLengthLine + hSpaceLineText + maxTextWidth;
263 double fullHeight = std::max( outputLargestSize - textTopY, totalTextHeight );
264
265 if ( outputSize )
266 *outputSize = QSizeF( fullWidth, fullHeight );
267 if ( labelXOffset )
268 *labelXOffset = outputLargestSize + hLengthLine + hSpaceLineText;
269
270 if ( !context.painter() )
271 return; // only layout
272
273 //
274 // drawing
275 //
276
277 QPainter *p = context.painter();
278 QgsScopedQPainterState painterState( p );
279 p->translate( 0, -textTopY );
280
281 // draw symbols first so that they do not cover
282 for ( const SizeClass &c : std::as_const( classes ) )
283 {
284 s->setSize( c.size );
285
286 double outputSymbolSize = context.convertToPainterUnits( c.size, s->sizeUnit(), s->sizeMapUnitScale() );
287 double tx = ( outputLargestSize - outputSymbolSize ) / 2;
288
289 QgsScopedQPainterState symbolPainterState( p );
290 switch ( mVAlign )
291 {
292 case AlignCenter:
293 p->translate( tx, ( outputLargestSize - outputSymbolSize ) / 2 );
294 break;
295 case AlignBottom:
296 p->translate( tx, outputLargestSize - outputSymbolSize );
297 break;
298 }
299 s->drawPreviewIcon( nullptr, QSize( outputSymbolSize, outputSymbolSize ), &context );
300 }
301
302 QgsTextFormat format = QgsTextFormat::fromQFont( mFont );
303 format.setColor( mTextColor );
304
305 if ( mLineSymbol )
306 {
307 mLineSymbol->startRender( context );
308 }
309
310 int i = 0;
311 for ( const SizeClass &c : std::as_const( classes ) )
312 {
313 // line from symbol to the text
314 if ( mLineSymbol )
315 {
316 mLineSymbol->renderPolyline( QPolygonF() << QPointF( outputLargestSize / 2, symbolTopY[i] )
317 << QPointF( outputLargestSize + hLengthLine, textCenterY[i] ), nullptr, context );
318 }
319
320 // draw label
321 QRect rect( outputLargestSize + hLengthLine + hSpaceLineText, textCenterY[i] - textHeight / 2,
322 maxTextWidth, textHeight );
323
325 QStringList() << c.label, context, format );
326 i++;
327 }
328
329 if ( mLineSymbol )
330 mLineSymbol->stopRender( context );
331}
332
333
334QImage QgsDataDefinedSizeLegend::collapsedLegendImage( QgsRenderContext &context, const QColor &backgroundColor, double paddingMM ) const
335{
336 if ( mType != LegendCollapsed || mSizeClasses.isEmpty() || !mSymbol )
337 return QImage();
338
339 // find out the size first
340 QSizeF contentSize;
341 drawCollapsedLegend( context, &contentSize );
342
343 double padding = context.convertToPainterUnits( paddingMM, Qgis::RenderUnit::Millimeters );
344 int dpm = std::round( context.scaleFactor() * 1000 ); // scale factor = dots per millimeter
345
346 QImage img( contentSize.width() + padding * 2, contentSize.height() + padding * 2, QImage::Format_ARGB32_Premultiplied );
347 img.setDotsPerMeterX( dpm );
348 img.setDotsPerMeterY( dpm );
349 img.fill( backgroundColor );
350
351 QPainter painter( &img );
352 painter.setRenderHint( QPainter::Antialiasing, true );
353
354 painter.translate( padding, padding ); // so we do not need to care about padding at all
355
356 // now do the rendering
357 QPainter *oldPainter = context.painter();
358 context.setPainter( &painter );
359 drawCollapsedLegend( context );
360 context.setPainter( oldPainter );
361
362 painter.end();
363 return img;
364}
365
367{
368 if ( elem.isNull() )
369 return nullptr;
371 ddsLegend->setLegendType( elem.attribute( QStringLiteral( "type" ) ) == QLatin1String( "collapsed" ) ? LegendCollapsed : LegendSeparated );
372 ddsLegend->setVerticalAlignment( elem.attribute( QStringLiteral( "valign" ) ) == QLatin1String( "center" ) ? AlignCenter : AlignBottom );
373 ddsLegend->setTitle( elem.attribute( QStringLiteral( "title" ) ) );
374
375 QDomElement elemSymbol = elem.firstChildElement( QStringLiteral( "symbol" ) );
376 if ( !elemSymbol.isNull() )
377 {
378 ddsLegend->setSymbol( QgsSymbolLayerUtils::loadSymbol<QgsMarkerSymbol>( elemSymbol, context ) );
379 }
380
381 const QDomElement lineSymbolElem = elem.firstChildElement( QStringLiteral( "lineSymbol" ) );
382 if ( !lineSymbolElem.isNull() )
383 {
384 ddsLegend->setLineSymbol( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( lineSymbolElem.firstChildElement(), context ) );
385 }
386
387 QgsSizeScaleTransformer *transformer = nullptr;
388 QDomElement elemTransformer = elem.firstChildElement( QStringLiteral( "transformer" ) );
389 if ( !elemTransformer.isNull() )
390 {
391 transformer = new QgsSizeScaleTransformer;
392 transformer->loadVariant( QgsXmlUtils::readVariant( elemTransformer ) );
393 }
394 ddsLegend->setSizeScaleTransformer( transformer );
395
396 QDomElement elemTextStyle = elem.firstChildElement( QStringLiteral( "text-style" ) );
397 if ( !elemTextStyle.isNull() )
398 {
399 QDomElement elemFont = elemTextStyle.firstChildElement( QStringLiteral( "font" ) );
400 if ( !elemFont.isNull() )
401 {
402 ddsLegend->setFont( QgsFontUtils::createFont( elemFont.attribute( QStringLiteral( "family" ) ), elemFont.attribute( QStringLiteral( "size" ) ).toInt(),
403 elemFont.attribute( QStringLiteral( "weight" ) ).toInt(), elemFont.attribute( QStringLiteral( "italic" ) ).toInt() ) );
404 }
405 ddsLegend->setTextColor( QgsColorUtils::colorFromString( elemTextStyle.attribute( QStringLiteral( "color" ) ) ) );
406 ddsLegend->setTextAlignment( static_cast<Qt::AlignmentFlag>( elemTextStyle.attribute( QStringLiteral( "align" ) ).toInt() ) );
407 }
408
409 QDomElement elemClasses = elem.firstChildElement( QStringLiteral( "classes" ) );
410 if ( !elemClasses.isNull() )
411 {
412 QList<SizeClass> classes;
413 QDomElement elemClass = elemClasses.firstChildElement( QStringLiteral( "class" ) );
414 while ( !elemClass.isNull() )
415 {
416 classes << SizeClass( elemClass.attribute( QStringLiteral( "size" ) ).toDouble(), elemClass.attribute( QStringLiteral( "label" ) ) );
417 elemClass = elemClass.nextSiblingElement();
418 }
419 ddsLegend->setClasses( classes );
420 }
421
422 return ddsLegend;
423}
424
425void QgsDataDefinedSizeLegend::writeXml( QDomElement &elem, const QgsReadWriteContext &context ) const
426{
427 QDomDocument doc = elem.ownerDocument();
428
429 elem.setAttribute( QStringLiteral( "type" ), mType == LegendCollapsed ? "collapsed" : "separated" );
430 elem.setAttribute( QStringLiteral( "valign" ), mVAlign == AlignCenter ? "center" : "bottom" );
431 elem.setAttribute( QStringLiteral( "title" ), mTitleLabel );
432
433 if ( mSymbol )
434 {
435 QDomElement elemSymbol = QgsSymbolLayerUtils::saveSymbol( QStringLiteral( "source" ), mSymbol.get(), doc, context );
436 elem.appendChild( elemSymbol );
437 }
438
439 if ( mLineSymbol )
440 {
441 QDomElement lineSymbolElem = doc.createElement( QStringLiteral( "lineSymbol" ) );
442 lineSymbolElem.appendChild( QgsSymbolLayerUtils::saveSymbol( QStringLiteral( "lineSymbol" ), mLineSymbol.get(), doc, context ) );
443 elem.appendChild( lineSymbolElem );
444 }
445
446 if ( mSizeScaleTransformer )
447 {
448 QDomElement elemTransformer = QgsXmlUtils::writeVariant( mSizeScaleTransformer->toVariant(), doc );
449 elemTransformer.setTagName( QStringLiteral( "transformer" ) );
450 elem.appendChild( elemTransformer );
451 }
452
453 QDomElement elemFont = doc.createElement( QStringLiteral( "font" ) );
454 elemFont.setAttribute( QStringLiteral( "family" ), mFont.family() );
455 elemFont.setAttribute( QStringLiteral( "size" ), mFont.pointSize() );
456 elemFont.setAttribute( QStringLiteral( "weight" ), mFont.weight() );
457 elemFont.setAttribute( QStringLiteral( "italic" ), mFont.italic() );
458
459 QDomElement elemTextStyle = doc.createElement( QStringLiteral( "text-style" ) );
460 elemTextStyle.setAttribute( QStringLiteral( "color" ), QgsColorUtils::colorToString( mTextColor ) );
461 elemTextStyle.setAttribute( QStringLiteral( "align" ), static_cast<int>( mTextAlignment ) );
462 elemTextStyle.appendChild( elemFont );
463 elem.appendChild( elemTextStyle );
464
465 if ( !mSizeClasses.isEmpty() )
466 {
467 QDomElement elemClasses = doc.createElement( QStringLiteral( "classes" ) );
468 for ( const SizeClass &sc : std::as_const( mSizeClasses ) )
469 {
470 QDomElement elemClass = doc.createElement( QStringLiteral( "class" ) );
471 elemClass.setAttribute( QStringLiteral( "size" ), sc.size );
472 elemClass.setAttribute( QStringLiteral( "label" ), sc.label );
473 elemClasses.appendChild( elemClass );
474 }
475 elem.appendChild( elemClasses );
476 }
477}
@ Expression
Expression based property.
@ Millimeters
Millimeters.
static QColor colorFromString(const QString &string)
Decodes a string into a color value.
static QString colorToString(const QColor &color)
Encodes a color into a string value.
Object that keeps configuration of appearance of marker symbol's data-defined size in legend.
void setTitle(const QString &title)
Sets title label for data-defined size legend.
QList< QgsDataDefinedSizeLegend::SizeClass > classes() const
Returns list of classes: each class is a pair of symbol size (in units used by the symbol) and label.
void setSymbol(QgsMarkerSymbol *symbol SIP_TRANSFER)
Sets marker symbol that will be used to draw markers in legend.
void setVerticalAlignment(VerticalAlignment vAlign)
Sets vertical alignment of symbols - only valid for collapsed legend.
void setLineSymbol(QgsLineSymbol *symbol SIP_TRANSFER)
Sets the line symbol that will be used to draw callout lines in legend.
QgsMarkerSymbol * symbol() const
Returns marker symbol that will be used to draw markers in legend.
@ AlignCenter
Symbols are aligned to the center.
@ AlignBottom
Symbols are aligned to the bottom.
void setTextAlignment(Qt::AlignmentFlag flag)
Sets horizontal text alignment for rendering of labels - only valid for collapsed legend.
QgsDataDefinedSizeLegend & operator=(const QgsDataDefinedSizeLegend &other)
void setClasses(const QList< QgsDataDefinedSizeLegend::SizeClass > &classes)
Sets list of classes: each class is a pair of symbol size (in units used by the symbol) and label.
void setLegendType(LegendType type)
Sets how the legend should be rendered.
void setFont(const QFont &font)
Sets font used for rendering of labels - only valid for collapsed legend.
void setTextColor(const QColor &color)
Sets text color for rendering of labels - only valid for collapsed legend.
QString title() const
Returns title label for data-defined size legend.
void setSizeScaleTransformer(QgsSizeScaleTransformer *transformer SIP_TRANSFER)
Sets transformer for scaling of symbol sizes. Takes ownership of the object. Accepts nullptr to set n...
QgsDataDefinedSizeLegend()
Constructor for QgsDataDefinedSizeLegend.
static QgsDataDefinedSizeLegend * readXml(const QDomElement &elem, const QgsReadWriteContext &context) SIP_FACTORY
Creates instance from given element and returns it (caller takes ownership). Returns nullptr on error...
void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const
Writes configuration to the given XML element.
@ LegendSeparated
Each class (size value) has a separate legend node.
@ LegendCollapsed
All classes are rendered within one legend node.
QgsLineSymbol * lineSymbol() const
Returns the line symbol that will be used to draw callout lines in legend.
void updateFromSymbolAndProperty(const QgsMarkerSymbol *symbol, const QgsProperty &ddSize)
Updates the list of classes, source symbol and title label from given symbol and property.
QgsSizeScaleTransformer * sizeScaleTransformer() const
Returns transformer for scaling of symbol sizes. Returns nullptr if no transformer is defined.
QImage collapsedLegendImage(QgsRenderContext &context, const QColor &backgroundColor=Qt::transparent, double paddingMM=1) const
Returns output image that would be shown in the legend. Returns invalid image if legend is not config...
QgsLegendSymbolList legendSymbolList() const
Generates legend symbol items according to the configuration.
void drawCollapsedLegend(QgsRenderContext &context, QSizeF *outputSize SIP_OUT=nullptr, double *labelXOffset SIP_OUT=nullptr) const
Draw the legend if using LegendOneNodeForAll and optionally output size of the legend and x offset of...
static QFont createFont(const QString &family, int pointSize=-1, int weight=-1, bool italic=false)
Creates a font with the specified family.
The class stores information about one class/rule of a vector layer renderer in a unified way that ca...
void setDataDefinedSizeLegendSettings(QgsDataDefinedSizeLegend *settings)
Sets extra information about data-defined size.
QgsSymbol * symbol() const
Returns associated symbol. May be nullptr.
A line symbol type, for rendering LineString and MultiLineString geometries.
A marker symbol type, for rendering Point and MultiPoint geometries.
void setSize(double size) const
Sets the size for the whole symbol.
double size() const
Returns the estimated size for the whole symbol, which is the maximum size of all marker symbol layer...
QgsMarkerSymbol * clone() const override
Returns a deep copy of this symbol.
double maxValue() const
Returns the maximum value expected by the transformer.
double minValue() const
Returns the minimum value expected by the transformer.
A store for object properties.
QString expressionString() const
Returns the expression used for the property value.
Qgis::PropertyType propertyType() const
Returns the property type.
QString field() const
Returns the current field name the property references.
const QgsPropertyTransformer * transformer() const
Returns the existing transformer used for manipulating the calculated values for the property,...
The class is used as a container of context for various read/write operations on other objects.
Contains information about the context of a rendering operation.
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
Scoped object for saving and restoring a QPainter object's state.
QgsPropertyTransformer subclass for scaling a value into a size according to various scaling methods.
bool loadVariant(const QVariant &definition) override
Loads this transformer from a QVariantMap, wrapped in a QVariant.
QgsSizeScaleTransformer * clone() const override
Returns a clone of the transformer.
static QList< double > prettyBreaks(double minimum, double maximum, int classes)
Computes a sequence of about 'classes' equally spaced round values which cover the range of values fr...
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
Container for all settings relating to text rendering.
void setColor(const QColor &color)
Sets the color that text will be rendered in.
static QgsTextFormat fromQFont(const QFont &font)
Returns a text format matching the settings from an input font.
static void drawText(const QRectF &rect, double rotation, Qgis::TextHorizontalAlignment alignment, const QStringList &textLines, QgsRenderContext &context, const QgsTextFormat &format, bool drawAsOutlines=true, Qgis::TextVerticalAlignment vAlignment=Qgis::TextVerticalAlignment::Top, Qgis::TextRendererFlags flags=Qgis::TextRendererFlags(), Qgis::TextLayoutMode mode=Qgis::TextLayoutMode::Rectangle)
Draws text within a rectangle using the specified settings.
static Qgis::TextHorizontalAlignment convertQtHAlignment(Qt::Alignment alignment)
Converts a Qt horizontal alignment flag to a Qgis::TextHorizontalAlignment value.
static QDomElement writeVariant(const QVariant &value, QDomDocument &doc)
Write a QVariant to a QDomElement.
static QVariant readVariant(const QDomElement &element)
Read a QVariant from a QDomElement.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
QList< QgsLegendSymbolItem > QgsLegendSymbolList
QList< QgsSymbolLayer * > QgsSymbolLayerList
Definition qgssymbol.h:30
Definition of one class for the legend.