QGIS API Documentation 3.31.0-Master (d3d0431685)
qgslayoutitemmapoverview.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgslayoutitemmapoverview.cpp
3 --------------------
4 begin : October 2017
5 copyright : (C) 2017 by Nyall Dawson
6 email : nyall dot dawson at gmail dot com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
19#include "qgslayoutitemmap.h"
20#include "qgslayout.h"
21#include "qgssymbollayerutils.h"
22#include "qgssymbol.h"
23#include "qgspainting.h"
24#include "qgsreadwritecontext.h"
25#include "qgslayoututils.h"
26#include "qgsexception.h"
27#include "qgsvectorlayer.h"
30#include "qgsfillsymbol.h"
31
32#include <QPainter>
33
35 : QgsLayoutItemMapItem( name, map )
36 , mExtentLayer( std::make_unique< QgsVectorLayer >( QStringLiteral( "Polygon?crs=EPSG:4326" ), tr( "Overview" ), QStringLiteral( "memory" ), QgsVectorLayer::LayerOptions( map && map->layout() && map->layout()->project() ? map->layout()->project()->transformContext() : QgsCoordinateTransformContext() ) ) )
37{
38 createDefaultFrameSymbol();
39}
40
42
43void QgsLayoutItemMapOverview::createDefaultFrameSymbol()
44{
45 QVariantMap properties;
46 properties.insert( QStringLiteral( "color" ), QStringLiteral( "255,0,0,75" ) );
47 properties.insert( QStringLiteral( "style" ), QStringLiteral( "solid" ) );
48 properties.insert( QStringLiteral( "style_border" ), QStringLiteral( "no" ) );
49 mFrameSymbol.reset( QgsFillSymbol::createSimple( properties ) );
50
51 mExtentLayer->setRenderer( new QgsSingleSymbolRenderer( mFrameSymbol->clone() ) );
52}
53
54void QgsLayoutItemMapOverview::draw( QPainter *painter )
55{
56 if ( !mEnabled || !mFrameMap || !mMap || !mMap->layout() )
57 {
58 return;
59 }
60 if ( !painter )
61 {
62 return;
63 }
64
65 const QgsLayoutItemMap *overviewFrameMap = linkedMap();
66 if ( !overviewFrameMap )
67 {
68 return;
69 }
70
71 //get polygon for other overview frame map's extent (use visibleExtentPolygon as it accounts for map rotation)
72 QPolygonF otherExtent = overviewFrameMap->visibleExtentPolygon();
73 if ( overviewFrameMap->crs() !=
74 mMap->crs() )
75 {
76 QgsGeometry g = QgsGeometry::fromQPolygonF( otherExtent );
77
78 // reproject extent
79 QgsCoordinateTransform ct( overviewFrameMap->crs(),
80 mMap->crs(), mLayout->project() );
81 g = g.densifyByCount( 20 );
82 try
83 {
84 g.transform( ct );
85 }
86 catch ( QgsCsException & )
87 {
88 }
89
90 otherExtent = g.asQPolygonF();
91 }
92
93 //get current map's extent as a QPolygonF
94 QPolygonF thisExtent = mMap->visibleExtentPolygon();
95 //intersect the two
96 QPolygonF intersectExtent = thisExtent.intersected( otherExtent );
97
98 //setup painter scaling to dots so that raster symbology is drawn to scale
99 double dotsPerMM = painter->device()->logicalDpiX() / 25.4;
100
101 //setup render context
103 context.setForceVectorOutput( true );
104 QgsExpressionContext expressionContext = createExpressionContext();
105 context.setExpressionContext( expressionContext );
106
107 QgsScopedQPainterState painterState( painter );
108 context.setPainterFlagsUsingContext( painter );
109
110 painter->setCompositionMode( mBlendMode );
111 painter->translate( mMap->mXOffset, mMap->mYOffset );
112 painter->scale( 1 / dotsPerMM, 1 / dotsPerMM ); // scale painter from mm to dots
113
114 mFrameSymbol->startRender( context );
115
116 //construct a polygon corresponding to the intersecting map extent
117 //need to scale line to dots, rather then mm, since the painter has been scaled to dots
118 QTransform mapTransform;
119 QPolygonF thisRectPoly = QPolygonF( QRectF( 0, 0, dotsPerMM * mMap->rect().width(), dotsPerMM * mMap->rect().height() ) );
120
121 //workaround QT Bug #21329
122 thisRectPoly.pop_back();
123 thisExtent.pop_back();
124
125 //create transform from map coordinates to painter coordinates
126 QTransform::quadToQuad( thisExtent, thisRectPoly, mapTransform );
127 QPolygonF intersectPolygon;
128 intersectPolygon = mapTransform.map( intersectExtent );
129
130 QVector<QPolygonF> rings; //empty list
131 if ( !mInverted )
132 {
133 //Render the intersecting map extent
134 mFrameSymbol->renderPolygon( intersectPolygon, &rings, nullptr, context );
135 }
136 else
137 {
138 //We are inverting the overview frame (ie, shading outside the intersecting extent)
139 //Construct a polygon corresponding to the overview map extent
140 QPolygonF outerPolygon;
141 outerPolygon << QPointF( 0, 0 )
142 << QPointF( mMap->rect().width() * dotsPerMM, 0 )
143 << QPointF( mMap->rect().width() * dotsPerMM, mMap->rect().height() * dotsPerMM )
144 << QPointF( 0, mMap->rect().height() * dotsPerMM )
145 << QPointF( 0, 0 );
146
147 //Intersecting extent is an inner ring for the shaded area
148 rings.append( intersectPolygon );
149 mFrameSymbol->renderPolygon( outerPolygon, &rings, nullptr, context );
150 }
151
152 mFrameSymbol->stopRender( context );
153}
154
155bool QgsLayoutItemMapOverview::writeXml( QDomElement &elem, QDomDocument &doc, const QgsReadWriteContext &context ) const
156{
157 if ( elem.isNull() )
158 {
159 return false;
160 }
161
162 //overview map frame
163 QDomElement overviewFrameElem = doc.createElement( QStringLiteral( "ComposerMapOverview" ) );
164
165 overviewFrameElem.setAttribute( QStringLiteral( "frameMap" ), mFrameMap ? mFrameMap ->uuid() : QString() );
166 overviewFrameElem.setAttribute( QStringLiteral( "blendMode" ), static_cast< int >( QgsPainting::getBlendModeEnum( mBlendMode ) ) );
167 overviewFrameElem.setAttribute( QStringLiteral( "inverted" ), mInverted );
168 overviewFrameElem.setAttribute( QStringLiteral( "centered" ), mCentered );
169
170 QDomElement frameStyleElem = QgsSymbolLayerUtils::saveSymbol( QString(), mFrameSymbol.get(), doc, context );
171 overviewFrameElem.appendChild( frameStyleElem );
172
173 bool ok = QgsLayoutItemMapItem::writeXml( overviewFrameElem, doc, context );
174 elem.appendChild( overviewFrameElem );
175 return ok;
176}
177
178bool QgsLayoutItemMapOverview::readXml( const QDomElement &itemElem, const QDomDocument &doc, const QgsReadWriteContext &context )
179{
180 Q_UNUSED( doc )
181 if ( itemElem.isNull() )
182 {
183 return false;
184 }
185
186 bool ok = QgsLayoutItemMapItem::readXml( itemElem, doc, context );
187
188 mFrameMapUuid = itemElem.attribute( QStringLiteral( "frameMap" ) );
189 setLinkedMap( nullptr );
190
191 mBlendMode = QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( itemElem.attribute( QStringLiteral( "blendMode" ), QStringLiteral( "0" ) ).toUInt() ) );
192 mInverted = ( itemElem.attribute( QStringLiteral( "inverted" ), QStringLiteral( "0" ) ) != QLatin1String( "0" ) );
193 mCentered = ( itemElem.attribute( QStringLiteral( "centered" ), QStringLiteral( "0" ) ) != QLatin1String( "0" ) );
194
195 QDomElement frameStyleElem = itemElem.firstChildElement( QStringLiteral( "symbol" ) );
196 if ( !frameStyleElem.isNull() )
197 {
198 mFrameSymbol.reset( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( frameStyleElem, context ) );
199 }
200 return ok;
201}
202
204{
205 if ( !mFrameMapUuid.isEmpty() )
206 {
207 setLinkedMap( qobject_cast< QgsLayoutItemMap * >( mLayout->itemByUuid( mFrameMapUuid, true ) ) );
208 }
209}
210
212{
213 return mBlendMode != QPainter::CompositionMode_SourceOver;
214}
215
217{
218 if ( mFrameMap == map )
219 {
220 //no change
221 return;
222 }
223
224 //disconnect old map
225 if ( mFrameMap )
226 {
229 }
230 mFrameMap = map;
231 //connect to new map signals
234}
235
237{
238 return mFrameMap;
239}
240
242{
243 if ( !mMap )
244 {
245 return;
246 }
247
248 if ( mFrameMap )
249 {
252 }
253}
254
256{
257 if ( !mEnabled || !mFrameMap || !mMap || !mMap->layout() )
258 {
259 return nullptr;
260 }
261
262 const QgsLayoutItemMap *overviewFrameMap = linkedMap();
263 if ( !overviewFrameMap )
264 {
265 return nullptr;
266 }
267
268 //get polygon for other overview frame map's extent (use visibleExtentPolygon as it accounts for map rotation)
269 QPolygonF otherExtent = overviewFrameMap->visibleExtentPolygon();
270 QgsGeometry g = QgsGeometry::fromQPolygonF( otherExtent );
271
272 if ( overviewFrameMap->crs() != mMap->crs() )
273 {
274 // reproject extent
275 QgsCoordinateTransform ct( overviewFrameMap->crs(),
276 mMap->crs(), mLayout->project() );
277 g = g.densifyByCount( 20 );
278 try
279 {
280 g.transform( ct );
281 }
282 catch ( QgsCsException & )
283 {
284 }
285 }
286
287 //get current map's extent as a QPolygonF
288 QPolygonF thisExtent = mMap->visibleExtentPolygon();
289 QgsGeometry thisGeom = QgsGeometry::fromQPolygonF( thisExtent );
290 //intersect the two
291 QgsGeometry intersectExtent = thisGeom.intersection( g );
292
293 mExtentLayer->setBlendMode( mBlendMode );
294
295 static_cast< QgsSingleSymbolRenderer * >( mExtentLayer->renderer() )->setSymbol( mFrameSymbol->clone() );
296 mExtentLayer->dataProvider()->truncate();
297 mExtentLayer->setCrs( mMap->crs() );
298
299 if ( mInverted )
300 {
301 intersectExtent = thisGeom.difference( intersectExtent );
302 }
303
304 QgsFeature f;
305 f.setGeometry( intersectExtent );
306 mExtentLayer->dataProvider()->addFeature( f );
307
308 return mExtentLayer.get();
309}
310
312{
313 return mExtentLayer.get();
314}
315
317{
318 if ( mFrameSymbol )
319 {
320 QgsStyleSymbolEntity entity( mFrameSymbol.get() );
321 if ( !visitor->visit( QgsStyleEntityVisitorInterface::StyleLeaf( &entity, QStringLiteral( "overview" ), QObject::tr( "Overview" ) ) ) )
322 return false;
323 }
324
325 return true;
326}
327
329{
330 mFrameSymbol.reset( symbol );
331}
332
334{
335 return mFrameSymbol.get();
336}
337
339{
340 return mFrameSymbol.get();
341}
342
343void QgsLayoutItemMapOverview::setBlendMode( const QPainter::CompositionMode blendMode )
344{
345 mBlendMode = blendMode;
346}
347
348void QgsLayoutItemMapOverview::setInverted( const bool inverted )
349{
350 mInverted = inverted;
351}
352
353void QgsLayoutItemMapOverview::setCentered( const bool centered )
354{
355 mCentered = centered;
357}
358
360{
361 if ( !mMap )
362 {
363 return;
364 }
365
366 //if using overview centering, update the map's extent
367 if ( mMap->layout() && mCentered && mFrameMap )
368 {
369 QgsRectangle extent = mMap->extent();
370 QgsRectangle otherExtent = mFrameMap->extent();
371
372 QgsPointXY center = otherExtent.center();
373 QgsRectangle movedExtent( center.x() - extent.width() / 2,
374 center.y() - extent.height() / 2,
375 center.x() - extent.width() / 2 + extent.width(),
376 center.y() - extent.height() / 2 + extent.height() );
377 mMap->setExtent( movedExtent );
378 }
379
380 //repaint map so that overview gets updated
382}
383
384
385//
386// QgsLayoutItemMapOverviewStack
387//
388
391{
392
393}
394
396{
398}
399
400void QgsLayoutItemMapOverviewStack::removeOverview( const QString &overviewId )
401{
403}
404
405void QgsLayoutItemMapOverviewStack::moveOverviewUp( const QString &overviewId )
406{
408}
409
410void QgsLayoutItemMapOverviewStack::moveOverviewDown( const QString &overviewId )
411{
413}
414
416{
418 return qobject_cast<QgsLayoutItemMapOverview *>( item );
419}
420
422{
424 return qobject_cast<QgsLayoutItemMapOverview *>( item );
425}
426
428{
429 QgsLayoutItemMapItem *item = mItems.at( idx );
430 QgsLayoutItemMapOverview *overview = qobject_cast<QgsLayoutItemMapOverview *>( item );
431 return *overview;
432}
433
434QList<QgsLayoutItemMapOverview *> QgsLayoutItemMapOverviewStack::asList() const
435{
436 QList< QgsLayoutItemMapOverview * > list;
437 QList< QgsLayoutItemMapItem * >::const_iterator it = mItems.begin();
438 for ( ; it != mItems.end(); ++it )
439 {
440 QgsLayoutItemMapOverview *overview = qobject_cast<QgsLayoutItemMapOverview *>( *it );
441 if ( overview )
442 {
443 list.append( overview );
444 }
445 }
446 return list;
447}
448
449bool QgsLayoutItemMapOverviewStack::readXml( const QDomElement &elem, const QDomDocument &doc, const QgsReadWriteContext &context )
450{
451 removeItems();
452
453 //read overview stack
454 QDomNodeList mapOverviewNodeList = elem.elementsByTagName( QStringLiteral( "ComposerMapOverview" ) );
455 for ( int i = 0; i < mapOverviewNodeList.size(); ++i )
456 {
457 QDomElement mapOverviewElem = mapOverviewNodeList.at( i ).toElement();
458 QgsLayoutItemMapOverview *mapOverview = new QgsLayoutItemMapOverview( mapOverviewElem.attribute( QStringLiteral( "name" ) ), mMap );
459 mapOverview->readXml( mapOverviewElem, doc, context );
460 mItems.append( mapOverview );
461 }
462
463 return true;
464}
465
466QList<QgsMapLayer *> QgsLayoutItemMapOverviewStack::modifyMapLayerList( const QList<QgsMapLayer *> &layers )
467{
468 QList<QgsMapLayer *> res = layers;
469 res.reserve( layers.count() + mItems.count() );
470 for ( QgsLayoutItemMapItem *item : std::as_const( mItems ) )
471 {
472 if ( !item )
473 continue;
474
475 QgsVectorLayer *l = static_cast< QgsLayoutItemMapOverview * >( item )->asMapLayer();
476 if ( !l )
477 continue;
478
479 l->setCustomProperty( QStringLiteral( "_noset_layer_expression_context" ), true );
480
481 switch ( item->stackingPosition() )
482 {
484 continue;
485
488 {
489 QgsMapLayer *stackLayer = item->stackingLayer();
490 if ( !stackLayer )
491 continue;
492
493 auto pos = std::find( res.begin(), res.end(), stackLayer );
494 if ( pos == res.end() )
495 continue;
496
498 {
499 pos++;
500 if ( pos == res.end() )
501 {
502 res.push_back( l );
503 break;
504 }
505 }
506 res.insert( pos, l );
507 break;
508 }
509
511 res.push_back( l );
512 break;
513
515 res.push_front( l );
516 break;
517 }
518 }
519
520 return res;
521}
BlendMode
Blending modes defining the available composition modes that can be used when painting.
Definition: qgis.h:3196
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:67
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition: qgsfeature.h:56
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Definition: qgsfeature.cpp:167
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgsfillsymbol.h:30
static QgsFillSymbol * createSimple(const QVariantMap &properties)
Create a fill symbol with one symbol layer: SimpleFill with specified properties.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:164
QgsGeometry densifyByCount(int extraNodesPerSegment) const
Returns a copy of the geometry which has been densified by adding the specified number of extra nodes...
QgsGeometry difference(const QgsGeometry &geometry, const QgsGeometryParameters &parameters=QgsGeometryParameters()) const
Returns a geometry representing the points making up this geometry that do not make up other.
Qgis::GeometryOperationResult transform(const QgsCoordinateTransform &ct, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool transformZ=false) SIP_THROW(QgsCsException)
Transforms this geometry as described by the coordinate transform ct.
static QgsGeometry fromQPolygonF(const QPolygonF &polygon)
Construct geometry from a QPolygonF.
QPolygonF asQPolygonF() const SIP_HOLDGIL
Returns contents of the geometry as a QPolygonF.
QgsGeometry intersection(const QgsGeometry &geometry, const QgsGeometryParameters &parameters=QgsGeometryParameters()) const
Returns a geometry representing the points shared by this geometry and other.
A collection of map items which are drawn above the map content in a QgsLayoutItemMap.
void addItem(QgsLayoutItemMapItem *item)
Adds a new map item to the stack and takes ownership of the item.
void removeItem(const QString &itemId)
Removes an item which matching itemId from the stack and deletes the corresponding QgsLayoutItemMapIt...
QgsLayoutItemMapItem * item(int index) const
Returns a reference to the item at the specified index within the stack.
void moveItemUp(const QString &itemId)
Moves an item which matching itemId up the stack, causing it to be rendered above other items.
void removeItems()
Clears the item stack and deletes all QgsLayoutItemMapItems contained by the stack.
QList< QgsLayoutItemMapItem * > mItems
void moveItemDown(const QString &itemId)
Moves an item which matching itemId up the stack, causing it to be rendered above other items.
An item which is drawn inside a QgsLayoutItemMap, e.g., a grid or map overview.
@ StackBelowMapLabels
Render above all map layers, but below map labels.
@ StackAboveMapLabels
Render above all map layers and labels.
@ StackBelowMapLayer
Render below a specific map layer (see stackingLayer())
@ StackAboveMapLayer
Render above a specific map layer (see stackingLayer())
@ StackBelowMap
Render below all map layers.
QgsLayoutItemMap * mMap
Associated map.
virtual bool readXml(const QDomElement &element, const QDomDocument &doc, const QgsReadWriteContext &context)
Sets the map item state from a DOM document, where element is the DOM node corresponding to a 'Layout...
virtual bool writeXml(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Stores map item state in a DOM element, where element is the DOM element corresponding to a 'LayoutMa...
bool mEnabled
True if item is to be displayed on map.
StackingPosition stackingPosition() const
Returns the item's stacking position, which specifies where the in the map's stack the item should be...
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
const QgsLayoutItemMap * map() const
Returns the layout item map for the item.
QgsMapLayer * stackingLayer() const
Returns the item's stacking layer, which specifies where the in the map's stack the item should be re...
void moveOverviewUp(const QString &overviewId)
Moves an overview with matching overviewId up the stack, causing it to be rendered above other overvi...
QgsLayoutItemMapOverviewStack(QgsLayoutItemMap *map)
Constructor for QgsLayoutItemMapOverviewStack, attached to the specified map.
QgsLayoutItemMapOverview & operator[](int index)
Returns a reference to an overview at the specified index within the stack.
void addOverview(QgsLayoutItemMapOverview *overview)
Adds a new map overview to the stack and takes ownership of the overview.
bool readXml(const QDomElement &elem, const QDomDocument &doc, const QgsReadWriteContext &context) override
Sets the item stack's state from a DOM document, where element is a DOM node corresponding to a 'Layo...
QList< QgsMapLayer * > modifyMapLayerList(const QList< QgsMapLayer * > &layers)
Alters the list of map layers which will be rendered for the link map item, inserting temporary layer...
void moveOverviewDown(const QString &overviewId)
Moves an overview with matching overviewId down the stack, causing it to be rendered below other over...
void removeOverview(const QString &overviewId)
Removes an overview with matching overviewId from the stack and deletes the corresponding QgsLayoutIt...
QList< QgsLayoutItemMapOverview * > asList() const
Returns a list of QgsLayoutItemMapOverviews contained by the stack.
QgsLayoutItemMapOverview * overview(const QString &overviewId) const
Returns a reference to an overview with matching overviewId within the stack.
An individual overview which is drawn above the map content in a QgsLayoutItemMap,...
QgsFillSymbol * frameSymbol()
Returns the fill symbol used for drawing the overview extent.
QPainter::CompositionMode blendMode() const
Retrieves the blending mode used for drawing the overview.
bool usesAdvancedEffects() const override
Returns true if the item is drawn using advanced effects, such as blend modes.
void connectSignals()
Reconnects signals for overview map, so that overview correctly follows changes to source map's exten...
void setBlendMode(QPainter::CompositionMode mode)
Sets the blending mode used for drawing the overview.
QgsMapLayer * mapLayer() override
Returns the internal map layer used by this item, if available.
QgsVectorLayer * asMapLayer()
Returns a vector layer to render as part of the QgsLayoutItemMap render, containing a feature represe...
void draw(QPainter *painter) override
Draws the item on to a destination painter.
void overviewExtentChanged()
Handles recentering of the map and redrawing of the map's overview.
bool writeXml(QDomElement &elem, QDomDocument &doc, const QgsReadWriteContext &context) const override
Stores map item state in a DOM element, where element is the DOM element corresponding to a 'LayoutMa...
bool centered() const
Returns whether the extent of the map is forced to center on the overview.
~QgsLayoutItemMapOverview() override
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map to show the overview extent of.
void finalizeRestoreFromXml() override
Called after all pending items have been restored from XML.
void setFrameSymbol(QgsFillSymbol *symbol)
Sets the fill symbol used for drawing the overview extent.
bool inverted() const
Returns whether the overview frame is inverted, ie, whether the shaded area is drawn outside the exte...
void setInverted(bool inverted)
Sets whether the overview frame is inverted, ie, whether the shaded area is drawn outside the extent ...
bool accept(QgsStyleEntityVisitorInterface *visitor) const override
Accepts the specified style entity visitor, causing it to visit all style entities associated with th...
QgsLayoutItemMapOverview(const QString &name, QgsLayoutItemMap *map)
Constructor for QgsLayoutItemMapOverview.
bool readXml(const QDomElement &itemElem, const QDomDocument &doc, const QgsReadWriteContext &context) override
Sets the map item state from a DOM document, where element is the DOM node corresponding to a 'Layout...
void setCentered(bool centered)
Sets whether the extent of the map is forced to center on the overview.
QgsLayoutItemMap * linkedMap()
Returns the source map to show the overview extent of.
Layout graphical items for displaying a map.
void extentChanged()
Emitted when the map's extent changes.
void mapRotationChanged(double newRotation)
Emitted when the map's rotation changes.
void setExtent(const QgsRectangle &extent)
Sets a new extent for the map.
QPolygonF visibleExtentPolygon() const
Returns a polygon representing the current visible map extent, considering map extents and rotation.
void invalidateCache() override
QgsRectangle extent() const
Returns the current map extent.
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used for rendering the map.
const QgsLayout * layout() const
Returns the layout the object is attached to.
QPointer< QgsLayout > mLayout
static QgsRenderContext createRenderContextForLayout(QgsLayout *layout, QPainter *painter, double dpi=-1)
Creates a render context suitable for the specified layout and painter destination.
Base class for all map layer types.
Definition: qgsmaplayer.h:73
Q_INVOKABLE void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for layer.
static Qgis::BlendMode getBlendModeEnum(QPainter::CompositionMode blendMode)
Returns a BlendMode corresponding to a QPainter::CompositionMode.
Definition: qgspainting.cpp:80
static QPainter::CompositionMode getCompositionMode(Qgis::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a BlendMode.
Definition: qgspainting.cpp:20
A class to represent a 2D point.
Definition: qgspointxy.h:59
double y
Definition: qgspointxy.h:63
Q_GADGET double x
Definition: qgspointxy.h:62
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
double height() const SIP_HOLDGIL
Returns the height of the rectangle.
Definition: qgsrectangle.h:230
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
Definition: qgsrectangle.h:223
QgsPointXY center() const SIP_HOLDGIL
Returns the center point of the rectangle.
Definition: qgsrectangle.h:251
Contains information about the context of a rendering operation.
void setForceVectorOutput(bool force)
Sets whether rendering operations should use vector operations instead of any faster raster shortcuts...
void setPainterFlagsUsingContext(QPainter *painter=nullptr) const
Sets relevant flags on a destination painter, using the flags and settings currently defined for the ...
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
Scoped object for saving and restoring a QPainter object's state.
An interface for classes which can visit style entity (e.g.
virtual bool visit(const QgsStyleEntityVisitorInterface::StyleLeaf &entity)
Called when the visitor will visit a style entity.
A symbol entity for QgsStyle databases.
Definition: qgsstyle.h:1341
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
Represents a vector layer which manages a vector based data sets.
Contains information relating to the style entity currently being visited.