QGIS API Documentation  3.12.1-BucureČ™ti (121cc00ff0)
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 "qgsmapsettings.h"
24 #include "qgspainting.h"
25 #include "qgspathresolver.h"
26 #include "qgsreadwritecontext.h"
27 #include "qgslayoututils.h"
28 #include "qgsexception.h"
29 #include "qgsvectorlayer.h"
31 #include "qgsstyleentityvisitor.h"
32 
33 #include <QPainter>
34 
36  : QgsLayoutItemMapItem( name, map )
37  , mExtentLayer( qgis::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() ) ) )
38 {
39  createDefaultFrameSymbol();
40 }
41 
43 
44 void QgsLayoutItemMapOverview::createDefaultFrameSymbol()
45 {
46  QgsStringMap properties;
47  properties.insert( QStringLiteral( "color" ), QStringLiteral( "255,0,0,75" ) );
48  properties.insert( QStringLiteral( "style" ), QStringLiteral( "solid" ) );
49  properties.insert( QStringLiteral( "style_border" ), QStringLiteral( "no" ) );
50  mFrameSymbol.reset( QgsFillSymbol::createSimple( properties ) );
51 
52  mExtentLayer->setRenderer( new QgsSingleSymbolRenderer( mFrameSymbol->clone() ) );
53 }
54 
55 void QgsLayoutItemMapOverview::draw( QPainter *painter )
56 {
57  if ( !mEnabled || !mFrameMap || !mMap || !mMap->layout() )
58  {
59  return;
60  }
61  if ( !painter )
62  {
63  return;
64  }
65 
66  const QgsLayoutItemMap *overviewFrameMap = linkedMap();
67  if ( !overviewFrameMap )
68  {
69  return;
70  }
71 
72  //get polygon for other overview frame map's extent (use visibleExtentPolygon as it accounts for map rotation)
73  QPolygonF otherExtent = overviewFrameMap->visibleExtentPolygon();
74  if ( overviewFrameMap->crs() !=
75  mMap->crs() )
76  {
77  QgsGeometry g = QgsGeometry::fromQPolygonF( otherExtent );
78 
79  // reproject extent
80  QgsCoordinateTransform ct( overviewFrameMap->crs(),
81  mMap->crs(), mLayout->project() );
82  g = g.densifyByCount( 20 );
83  try
84  {
85  g.transform( ct );
86  }
87  catch ( QgsCsException & )
88  {
89  }
90 
91  otherExtent = g.asQPolygonF();
92  }
93 
94  //get current map's extent as a QPolygonF
95  QPolygonF thisExtent = mMap->visibleExtentPolygon();
96  //intersect the two
97  QPolygonF intersectExtent = thisExtent.intersected( otherExtent );
98 
99  //setup painter scaling to dots so that raster symbology is drawn to scale
100  double dotsPerMM = painter->device()->logicalDpiX() / 25.4;
101 
102  //setup render context
104  context.setForceVectorOutput( true );
105  QgsExpressionContext expressionContext = createExpressionContext();
106  context.setExpressionContext( expressionContext );
107 
108  painter->save();
109  painter->setCompositionMode( mBlendMode );
110  painter->translate( mMap->mXOffset, mMap->mYOffset );
111  painter->scale( 1 / dotsPerMM, 1 / dotsPerMM ); // scale painter from mm to dots
112  painter->setRenderHint( QPainter::Antialiasing );
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  QList<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  painter->restore();
154 }
155 
156 bool QgsLayoutItemMapOverview::writeXml( QDomElement &elem, QDomDocument &doc, const QgsReadWriteContext &context ) const
157 {
158  if ( elem.isNull() )
159  {
160  return false;
161  }
162 
163  //overview map frame
164  QDomElement overviewFrameElem = doc.createElement( QStringLiteral( "ComposerMapOverview" ) );
165 
166  overviewFrameElem.setAttribute( QStringLiteral( "frameMap" ), mFrameMap ? mFrameMap ->uuid() : QString() );
167  overviewFrameElem.setAttribute( QStringLiteral( "blendMode" ), QgsPainting::getBlendModeEnum( mBlendMode ) );
168  overviewFrameElem.setAttribute( QStringLiteral( "inverted" ), mInverted );
169  overviewFrameElem.setAttribute( QStringLiteral( "centered" ), mCentered );
170 
171  QDomElement frameStyleElem = QgsSymbolLayerUtils::saveSymbol( QString(), mFrameSymbol.get(), doc, context );
172  overviewFrameElem.appendChild( frameStyleElem );
173 
174  bool ok = QgsLayoutItemMapItem::writeXml( overviewFrameElem, doc, context );
175  elem.appendChild( overviewFrameElem );
176  return ok;
177 }
178 
179 bool QgsLayoutItemMapOverview::readXml( const QDomElement &itemElem, const QDomDocument &doc, const QgsReadWriteContext &context )
180 {
181  Q_UNUSED( doc )
182  if ( itemElem.isNull() )
183  {
184  return false;
185  }
186 
187  bool ok = QgsLayoutItemMapItem::readXml( itemElem, doc, context );
188 
189  mFrameMapUuid = itemElem.attribute( QStringLiteral( "frameMap" ) );
190  setLinkedMap( nullptr );
191 
192  mBlendMode = QgsPainting::getCompositionMode( static_cast< QgsPainting::BlendMode >( itemElem.attribute( QStringLiteral( "blendMode" ), QStringLiteral( "0" ) ).toUInt() ) );
193  mInverted = ( itemElem.attribute( QStringLiteral( "inverted" ), QStringLiteral( "0" ) ) != QLatin1String( "0" ) );
194  mCentered = ( itemElem.attribute( QStringLiteral( "centered" ), QStringLiteral( "0" ) ) != QLatin1String( "0" ) );
195 
196  QDomElement frameStyleElem = itemElem.firstChildElement( QStringLiteral( "symbol" ) );
197  if ( !frameStyleElem.isNull() )
198  {
199  mFrameSymbol.reset( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( frameStyleElem, context ) );
200  }
201  return ok;
202 }
203 
205 {
206  if ( !mFrameMapUuid.isEmpty() )
207  {
208  setLinkedMap( qobject_cast< QgsLayoutItemMap * >( mLayout->itemByUuid( mFrameMapUuid, true ) ) );
209  }
210 }
211 
213 {
214  return mBlendMode != QPainter::CompositionMode_SourceOver;
215 }
216 
218 {
219  if ( mFrameMap == map )
220  {
221  //no change
222  return;
223  }
224 
225  //disconnect old map
226  if ( mFrameMap )
227  {
230  }
231  mFrameMap = map;
232  //connect to new map signals
233  connectSignals();
235 }
236 
238 {
239  return mFrameMap;
240 }
241 
243 {
244  if ( !mMap )
245  {
246  return;
247  }
248 
249  if ( mFrameMap )
250  {
253  }
254 }
255 
257 {
258  if ( !mEnabled || !mFrameMap || !mMap || !mMap->layout() )
259  {
260  return nullptr;
261  }
262 
263  const QgsLayoutItemMap *overviewFrameMap = linkedMap();
264  if ( !overviewFrameMap )
265  {
266  return nullptr;
267  }
268 
269  //get polygon for other overview frame map's extent (use visibleExtentPolygon as it accounts for map rotation)
270  QPolygonF otherExtent = overviewFrameMap->visibleExtentPolygon();
271  QgsGeometry g = QgsGeometry::fromQPolygonF( otherExtent );
272 
273  if ( overviewFrameMap->crs() != mMap->crs() )
274  {
275  // reproject extent
276  QgsCoordinateTransform ct( overviewFrameMap->crs(),
277  mMap->crs(), mLayout->project() );
278  g = g.densifyByCount( 20 );
279  try
280  {
281  g.transform( ct );
282  }
283  catch ( QgsCsException & )
284  {
285  }
286  }
287 
288  //get current map's extent as a QPolygonF
289  QPolygonF thisExtent = mMap->visibleExtentPolygon();
290  QgsGeometry thisGeom = QgsGeometry::fromQPolygonF( thisExtent );
291  //intersect the two
292  QgsGeometry intersectExtent = thisGeom.intersection( g );
293 
294  mExtentLayer->setBlendMode( mBlendMode );
295 
296  static_cast< QgsSingleSymbolRenderer * >( mExtentLayer->renderer() )->setSymbol( mFrameSymbol->clone() );
297  mExtentLayer->dataProvider()->truncate();
298  mExtentLayer->setCrs( mMap->crs() );
299 
300  if ( mInverted )
301  {
302  intersectExtent = thisGeom.difference( intersectExtent );
303  }
304 
305  QgsFeature f;
306  f.setGeometry( intersectExtent );
307  mExtentLayer->dataProvider()->addFeature( f );
308 
309  return mExtentLayer.get();
310 }
311 
313 {
314  return mExtentLayer.get();
315 }
316 
318 {
319  if ( mFrameSymbol )
320  {
321  QgsStyleSymbolEntity entity( mFrameSymbol.get() );
322  if ( !visitor->visit( QgsStyleEntityVisitorInterface::StyleLeaf( &entity, QStringLiteral( "overview" ), QObject::tr( "Overview" ) ) ) )
323  return false;
324  }
325 
326  return true;
327 }
328 
330 {
331  mFrameSymbol.reset( symbol );
332 }
333 
335 {
336  return mFrameSymbol.get();
337 }
338 
340 {
341  return mFrameSymbol.get();
342 }
343 
344 void QgsLayoutItemMapOverview::setBlendMode( const QPainter::CompositionMode blendMode )
345 {
346  mBlendMode = blendMode;
347 }
348 
350 {
351  mInverted = inverted;
352 }
353 
355 {
356  mCentered = centered;
358 }
359 
361 {
362  if ( !mMap )
363  {
364  return;
365  }
366 
367  //if using overview centering, update the map's extent
368  if ( mMap->layout() && mCentered && mFrameMap )
369  {
370  QgsRectangle extent = mMap->extent();
371  QgsRectangle otherExtent = mFrameMap->extent();
372 
373  QgsPointXY center = otherExtent.center();
374  QgsRectangle movedExtent( center.x() - extent.width() / 2,
375  center.y() - extent.height() / 2,
376  center.x() - extent.width() / 2 + extent.width(),
377  center.y() - extent.height() / 2 + extent.height() );
378  mMap->setExtent( movedExtent );
379  }
380 
381  //repaint map so that overview gets updated
383 }
384 
385 
386 //
387 // QgsLayoutItemMapOverviewStack
388 //
389 
392 {
393 
394 }
395 
397 {
399 }
400 
401 void QgsLayoutItemMapOverviewStack::removeOverview( const QString &overviewId )
402 {
404 }
405 
406 void QgsLayoutItemMapOverviewStack::moveOverviewUp( const QString &overviewId )
407 {
409 }
410 
411 void QgsLayoutItemMapOverviewStack::moveOverviewDown( const QString &overviewId )
412 {
414 }
415 
417 {
419  return qobject_cast<QgsLayoutItemMapOverview *>( item );
420 }
421 
423 {
425  return qobject_cast<QgsLayoutItemMapOverview *>( item );
426 }
427 
429 {
430  QgsLayoutItemMapItem *item = mItems.at( idx );
432  return *overview;
433 }
434 
435 QList<QgsLayoutItemMapOverview *> QgsLayoutItemMapOverviewStack::asList() const
436 {
437  QList< QgsLayoutItemMapOverview * > list;
438  QList< QgsLayoutItemMapItem * >::const_iterator it = mItems.begin();
439  for ( ; it != mItems.end(); ++it )
440  {
442  if ( overview )
443  {
444  list.append( overview );
445  }
446  }
447  return list;
448 }
449 
450 bool QgsLayoutItemMapOverviewStack::readXml( const QDomElement &elem, const QDomDocument &doc, const QgsReadWriteContext &context )
451 {
452  removeItems();
453 
454  //read overview stack
455  QDomNodeList mapOverviewNodeList = elem.elementsByTagName( QStringLiteral( "ComposerMapOverview" ) );
456  for ( int i = 0; i < mapOverviewNodeList.size(); ++i )
457  {
458  QDomElement mapOverviewElem = mapOverviewNodeList.at( i ).toElement();
459  QgsLayoutItemMapOverview *mapOverview = new QgsLayoutItemMapOverview( mapOverviewElem.attribute( QStringLiteral( "name" ) ), mMap );
460  mapOverview->readXml( mapOverviewElem, doc, context );
461  mItems.append( mapOverview );
462  }
463 
464  return true;
465 }
466 
467 QList<QgsMapLayer *> QgsLayoutItemMapOverviewStack::modifyMapLayerList( const QList<QgsMapLayer *> &layers )
468 {
469  QList<QgsMapLayer *> res = layers;
470  res.reserve( layers.count() + mItems.count() );
471  for ( QgsLayoutItemMapItem *item : qgis::as_const( mItems ) )
472  {
473  if ( !item )
474  continue;
475 
476  QgsVectorLayer *l = static_cast< QgsLayoutItemMapOverview * >( item )->asMapLayer();
477  if ( !l )
478  continue;
479 
480  switch ( item->stackingPosition() )
481  {
483  continue;
484 
487  {
488  QgsMapLayer *stackLayer = item->stackingLayer();
489  if ( !stackLayer )
490  continue;
491 
492  auto pos = std::find( res.begin(), res.end(), stackLayer );
493  if ( pos == res.end() )
494  continue;
495 
497  {
498  pos++;
499  if ( pos == res.end() )
500  {
501  res.push_back( l );
502  break;
503  }
504  }
505  res.insert( pos, l );
506  break;
507  }
508 
510  res.push_back( l );
511  break;
512 
514  res.push_front( l );
515  break;
516  }
517  }
518 
519  return res;
520 }
void setForceVectorOutput(bool force)
Sets whether rendering operations should use vector operations instead of any faster raster shortcuts...
The class is used as a container of context for various read/write operations on other objects...
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map to show the overview extent of.
A rectangle specified with double values.
Definition: qgsrectangle.h:41
Base class for all map layer types.
Definition: qgsmaplayer.h:79
A symbol entity for QgsStyle databases.
Definition: qgsstyle.h:971
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 moveOverviewUp(const QString &overviewId)
Moves an overview with matching overviewId up the stack, causing it to be rendered above other overvi...
void setFrameSymbol(QgsFillSymbol *symbol)
Sets the fill symbol used for drawing the overview extent.
An individual overview which is drawn above the map content in a QgsLayoutItemMap, and shows the extent of another QgsLayoutItemMap.
OperationResult transform(const QgsCoordinateTransform &ct, QgsCoordinateTransform::TransformDirection direction=QgsCoordinateTransform::ForwardTransform, bool transformZ=false) SIP_THROW(QgsCsException)
Transforms this geometry as described by the coordinate transform ct.
void setInverted(bool inverted)
Sets whether the overview frame is inverted, ie, whether the shaded area is drawn outside the extent ...
void setExtent(const QgsRectangle &extent)
Sets a new extent for the map.
QgsLayoutItemMapOverview(const QString &name, QgsLayoutItemMap *map)
Constructor for QgsLayoutItemMapOverview.
double y
Definition: qgspointxy.h:48
An item which is drawn inside a QgsLayoutItemMap, e.g., a grid or map overview.
static QgsFillSymbol * createSimple(const QgsStringMap &properties)
Create a fill symbol with one symbol layer: SimpleFill with specified properties. ...
Definition: qgssymbol.cpp:1310
A class to represent a 2D point.
Definition: qgspointxy.h:43
void extentChanged()
Emitted when the map&#39;s extent changes.
void draw(QPainter *painter) override
Draws the item on to a destination painter.
static QgsPainting::BlendMode getBlendModeEnum(QPainter::CompositionMode blendMode)
Returns a BlendMode corresponding to a QPainter::CompositionMode.
Definition: qgspainting.cpp:80
Render above a specific map layer (see stackingLayer())
A collection of map items which are drawn above the map content in a QgsLayoutItemMap.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:122
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 &#39;Layout...
static QPainter::CompositionMode getCompositionMode(QgsPainting::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a BlendMode.
Definition: qgspainting.cpp:20
QList< QgsLayoutItemMapOverview *> asList() const
Returns a list of QgsLayoutItemMapOverviews contained by the stack.
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
void invalidateCache() override
void finalizeRestoreFromXml() override
Called after all pending items have been restored from XML.
QgsFillSymbol * frameSymbol()
Returns the fill symbol used for drawing the overview extent.
QgsGeometry intersection(const QgsGeometry &geometry) const
Returns a geometry representing the points shared by this geometry and other.
The feature class encapsulates a single feature including its id, geometry and a list of field/values...
Definition: qgsfeature.h:55
An interface for classes which can visit style entity (e.g.
bool accept(QgsStyleEntityVisitorInterface *visitor) const override
Accepts the specified style entity visitor, causing it to visit all style entities associated with th...
void setBlendMode(QPainter::CompositionMode mode)
Sets the blending mode used for drawing the overview.
QMap< QString, QString > QgsStringMap
Definition: qgis.h:694
void connectSignals()
Reconnects signals for overview map, so that overview correctly follows changes to source map&#39;s exten...
Render below a specific map layer (see stackingLayer())
void removeItems()
Clears the item stack and deletes all QgsLayoutItemMapItems contained by the stack.
QgsLayoutItemMapOverview * overview(const QString &overviewId) const
Returns a reference to an overview with matching overviewId within the stack.
Render above all map layers, but below map labels.
QgsLayoutItemMapOverview & operator[](int index)
Returns a reference to an overview at the specified index within the stack.
virtual bool visit(const QgsStyleEntityVisitorInterface::StyleLeaf &entity)
Called when the visitor will visit a style entity.
void addOverview(QgsLayoutItemMapOverview *overview)
Adds a new map overview to the stack and takes ownership of the overview.
QgsLayoutItemMap * mMap
Associated map.
bool inverted() const
Returns whether the overview frame is inverted, ie, whether the shaded area is drawn outside the exte...
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
bool mEnabled
True if item is to be displayed on map.
QgsRectangle extent() const
Returns the current map extent.
Layout graphical items for displaying a map.
const QgsLayout * layout() const
Returns the layout the object is attached to.
double width() const
Returns the width of the rectangle.
Definition: qgsrectangle.h:202
QgsGeometry densifyByCount(int extraNodesPerSegment) const
Returns a copy of the geometry which has been densified by adding the specified number of extra nodes...
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void addItem(QgsLayoutItemMapItem *item)
Adds a new map item to the stack and takes ownership of the item.
~QgsLayoutItemMapOverview() override
QPainter::CompositionMode blendMode() const
Retrieves the blending mode used for drawing the overview.
StackingPosition stackingPosition() const
Returns the item&#39;s stacking position, which specifies where the in the map&#39;s stack the item should be...
static QgsRenderContext createRenderContextForLayout(QgsLayout *layout, QPainter *painter, double dpi=-1)
Creates a render context suitable for the specified layout and painter destination.
QPointer< QgsLayout > mLayout
void moveOverviewDown(const QString &overviewId)
Moves an overview with matching overviewId down the stack, causing it to be rendered below other over...
QgsMapLayer * stackingLayer() const
Returns the item&#39;s stacking layer, which specifies where the in the map&#39;s stack the item should be re...
bool readXml(const QDomElement &elem, const QDomDocument &doc, const QgsReadWriteContext &context) override
Sets the item stack&#39;s state from a DOM document, where element is a DOM node corresponding to a &#39;Layo...
Contains information about the context in which a coordinate transform is executed.
void moveItemUp(const QString &itemId)
Moves an item which matching itemId up the stack, causing it to be rendered above other items...
QgsLayoutItemMapItem * item(int index) const
Returns a reference to the item at the specified index within the stack.
void setCentered(bool centered)
Sets whether the extent of the map is forced to center on the overview.
double x
Definition: qgspointxy.h:47
QPolygonF visibleExtentPolygon() const
Returns a polygon representing the current visible map extent, considering map extents and rotation...
void mapRotationChanged(double newRotation)
Emitted when the map&#39;s rotation changes.
const QgsLayoutItemMap * map() const
Returns the layout item map for the item.
QgsLayoutItemMapOverviewStack(QgsLayoutItemMap *map)
Constructor for QgsLayoutItemMapOverviewStack, attached to the specified 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 &#39;Layout...
QgsMapLayer * mapLayer() override
Returns the internal map layer used by this item, if available.
void removeOverview(const QString &overviewId)
Removes an overview with matching overviewId from the stack and deletes the corresponding QgsLayoutIt...
Contains information about the context of a rendering operation.
void overviewExtentChanged()
Handles recentering of the map and redrawing of the map&#39;s overview.
bool usesAdvancedEffects() const override
Returns true if the item is drawn using advanced effects, such as blend modes.
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used for rendering the map.
void setGeometry(const QgsGeometry &geometry)
Set the feature&#39;s geometry.
Definition: qgsfeature.cpp:137
static QgsGeometry fromQPolygonF(const QPolygonF &polygon)
Construct geometry from a QPolygonF.
Class for doing transforms between two map coordinate systems.
bool centered() const
Returns whether the extent of the map is forced to center on the overview.
A fill symbol type, for rendering Polygon and MultiPolygon geometries.
Definition: qgssymbol.h:1190
void removeItem(const QString &itemId)
Removes an item which matching itemId from the stack and deletes the corresponding QgsLayoutItemMapIt...
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:65
QgsVectorLayer * asMapLayer()
Returns a vector layer to render as part of the QgsLayoutItemMap render, containing a feature represe...
QgsPointXY center() const
Returns the center point of the rectangle.
Definition: qgsrectangle.h:230
void moveItemDown(const QString &itemId)
Moves an item which matching itemId up the stack, causing it to be rendered above other items...
QList< QgsLayoutItemMapItem *> mItems
Represents a vector layer which manages a vector based data sets.
Contains information relating to the style entity currently being visited.
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 &#39;LayoutMa...
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
Render above all map layers and labels.
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 &#39;LayoutMa...
double height() const
Returns the height of the rectangle.
Definition: qgsrectangle.h:209
QgsLayoutItemMap * linkedMap()
Returns the source map to show the overview extent of.
Render below all map layers.
QgsGeometry difference(const QgsGeometry &geometry) const
Returns a geometry representing the points making up this geometry that do not make up other...