Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsmapsettings.h
3 : : --------------------------------------
4 : : Date : December 2013
5 : : Copyright : (C) 2013 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 : :
16 : : #ifndef QGSMAPSETTINGS_H
17 : : #define QGSMAPSETTINGS_H
18 : :
19 : : #include "qgis_core.h"
20 : : #include "qgis_sip.h"
21 : : #include <QColor>
22 : : #include <QImage>
23 : : #include <QPointer>
24 : : #include <QSize>
25 : : #include <QStringList>
26 : :
27 : : #include "qgscoordinatereferencesystem.h"
28 : : #include "qgslabelingenginesettings.h"
29 : : #include "qgsmaptopixel.h"
30 : : #include "qgsrectangle.h"
31 : : #include "qgsscalecalculator.h"
32 : : #include "qgsexpressioncontext.h"
33 : : #include "qgsmaplayer.h"
34 : : #include "qgsgeometry.h"
35 : : #include "qgstemporalrangeobject.h"
36 : : #include "qgsmapclippingregion.h"
37 : :
38 : : class QPainter;
39 : :
40 : : class QgsCoordinateTransform;
41 : : class QgsScaleCalculator;
42 : : class QgsMapRendererJob;
43 : : class QgsRenderedFeatureHandlerInterface;
44 : :
45 : : /**
46 : : * \class QgsLabelBlockingRegion
47 : : * \ingroup core
48 : : *
49 : : * \brief Label blocking region (in map coordinates and CRS).
50 : : *
51 : : * \since QGIS 3.6
52 : : */
53 : 0 : class CORE_EXPORT QgsLabelBlockingRegion
54 : : {
55 : : public:
56 : :
57 : : /**
58 : : * Constructor for a label blocking region
59 : : */
60 : 0 : explicit QgsLabelBlockingRegion( const QgsGeometry &geometry )
61 : 0 : : geometry( geometry )
62 : 0 : {}
63 : :
64 : : //! Geometry of region to avoid placing labels within (in destination map coordinates and CRS)
65 : : QgsGeometry geometry;
66 : :
67 : : };
68 : :
69 : :
70 : : /**
71 : : * \ingroup core
72 : : * \brief The QgsMapSettings class contains configuration for rendering of the map.
73 : : * The rendering itself is done by QgsMapRendererJob subclasses.
74 : : *
75 : : * In order to set up QgsMapSettings instance, it is necessary to set at least
76 : : * few members: extent, output size and layers.
77 : : *
78 : : * Some systems use high DPI scaling that is an alternative to the traditional
79 : : * DPI scaling. The operating system provides Qt with a scaling ratio and it
80 : : * scales window, event, and desktop geometry. The Cocoa platform plugin sets
81 : : * the scaling ratio as QWindow::devicePixelRatio().
82 : : * To properly render the map on such systems, the map settings device pixel
83 : : * ratio shall be set accordingly.
84 : : *
85 : : * \since QGIS 2.4
86 : : */
87 : 6 : class CORE_EXPORT QgsMapSettings : public QgsTemporalRangeObject
88 : : {
89 : : public:
90 : : QgsMapSettings();
91 : :
92 : : /**
93 : : * Returns geographical coordinates of the rectangle that should be rendered.
94 : : *
95 : : * \warning The actual visible extent used for rendering can be significantly different from this
96 : : * value, since the given extent may be expanded in order to fit the aspect ratio
97 : : * of the outputSize(). Use visibleExtent() to get the actual extent which will be rendered.
98 : : *
99 : : * \see visibleExtent()
100 : : * \see setExtent()
101 : : */
102 : : QgsRectangle extent() const;
103 : :
104 : : /**
105 : : * Sets the coordinates of the rectangle which should be rendered.
106 : : *
107 : : * \warning The actual visible extent used for rendering can be significantly different
108 : : * from the specified extent, since the given extent may be expanded in order to match the
109 : : * aspect ratio of outputSize(). Use visibleExtent() to retrieve the actual extent to be rendered.
110 : : *
111 : : * \see visibleExtent()
112 : : * \see extent()
113 : : */
114 : : void setExtent( const QgsRectangle &rect, bool magnified = true );
115 : :
116 : : /**
117 : : * Returns the buffer in map units to use around the visible extent for rendering
118 : : * symbols whose corresponding geometries are outside the visible extent.
119 : : * \see setExtentBuffer()
120 : : * \since QGIS 3.10
121 : : */
122 : : double extentBuffer() const;
123 : :
124 : : /**
125 : : * Sets the buffer in map units to use around the visible extent for rendering
126 : : * symbols whose corresponding geometries are outside the visible extent. This
127 : : * is useful when using tiles to avoid cut symbols at tile boundaries.
128 : : * \since QGIS 3.10
129 : : */
130 : : void setExtentBuffer( double buffer );
131 : :
132 : : /**
133 : : * Returns the size of the resulting map image, in pixels.
134 : : *
135 : : * \see deviceOutputSize()
136 : : * \see setOutputSize()
137 : : */
138 : : QSize outputSize() const;
139 : :
140 : : /**
141 : : * Sets the \a size of the resulting map image, in pixels.
142 : : *
143 : : * \see outputSize()
144 : : */
145 : : void setOutputSize( QSize size );
146 : :
147 : : /**
148 : : * Returns the device pixel ratio.
149 : : *
150 : : * Common values are 1 for normal-dpi displays and 2 for high-dpi "retina" displays.
151 : : * \since QGIS 3.4
152 : : */
153 : : float devicePixelRatio() const;
154 : :
155 : : /**
156 : : * Sets the device pixel ratio.
157 : : *
158 : : * Common values are 1 for normal-dpi displays and 2 for high-dpi "retina" displays.
159 : : * \since QGIS 3.4
160 : : */
161 : : void setDevicePixelRatio( float dpr );
162 : :
163 : : /**
164 : : * Returns the device output size of the map render.
165 : : *
166 : : * This is equivalent to the output size multiplicated
167 : : * by the device pixel ratio.
168 : : *
169 : : * \see outputSize()
170 : : * \see devicePixelRatio()
171 : : * \see setOutputSize()
172 : : *
173 : : * \since QGIS 3.4
174 : : */
175 : : QSize deviceOutputSize() const;
176 : :
177 : : /**
178 : : * Returns the rotation of the resulting map image, in degrees clockwise.
179 : : * \see setRotation()
180 : : * \since QGIS 2.8
181 : : */
182 : : double rotation() const;
183 : :
184 : : /**
185 : : * Sets the \a rotation of the resulting map image, in degrees clockwise.
186 : : * \see rotation()
187 : : * \since QGIS 2.8
188 : : */
189 : : void setRotation( double rotation );
190 : :
191 : : /**
192 : : * Returns the DPI (dots per inch) used for conversion between real world units (e.g. mm) and pixels.
193 : : *
194 : : * The default value is 96 dpi.
195 : : *
196 : : * \see setOutputDpi()
197 : : */
198 : : double outputDpi() const;
199 : :
200 : : /**
201 : : * Sets the \a dpi (dots per inch) used for conversion between real world units (e.g. mm) and pixels.
202 : : *
203 : : * \see outputDpi()
204 : : */
205 : : void setOutputDpi( double dpi );
206 : :
207 : : /**
208 : : * Set the magnification factor.
209 : : * \param factor the factor of magnification
210 : : * \param center optional point to re-center the map
211 : : * \see magnificationFactor()
212 : : * \since QGIS 2.16
213 : : */
214 : : void setMagnificationFactor( double factor, const QgsPointXY *center = nullptr );
215 : :
216 : : /**
217 : : * Returns the magnification factor.
218 : : * \see setMagnificationFactor()
219 : : * \since QGIS 2.16
220 : : */
221 : : double magnificationFactor() const;
222 : :
223 : : /**
224 : : * Returns the list of layer IDs which will be rendered in the map.
225 : : *
226 : : * The layers are stored in the reverse order of how they are rendered (layer with index 0 will be on top).
227 : : *
228 : : * \see layers()
229 : : * \see setLayers()
230 : : */
231 : : QStringList layerIds() const;
232 : :
233 : : /**
234 : : * Returns the list of layers which will be rendered in the map.
235 : : *
236 : : * The layers are stored in the reverse order of how they are rendered (layer with index 0 will be on top)
237 : : *
238 : : * \see setLayers()
239 : : * \see layerIds()
240 : : */
241 : : QList<QgsMapLayer *> layers() const;
242 : :
243 : : /**
244 : : * Sets the list of \a layers to render in the map.
245 : : *
246 : : * The layers are stored in the reverse order of how they are rendered (layer with index 0 will be on top)
247 : : *
248 : : * \note Any non-spatial layers will be automatically stripped from the list (since they cannot be rendered!).
249 : : *
250 : : * \see layers()
251 : : * \see layerIds()
252 : : */
253 : : void setLayers( const QList<QgsMapLayer *> &layers );
254 : :
255 : : /**
256 : : * Returns the map of map layer style overrides (key: layer ID, value: style name) where a different style should be used instead of the current one.
257 : : *
258 : : * \see setLayerStyleOverrides()
259 : : * \since QGIS 2.8
260 : : */
261 : : QMap<QString, QString> layerStyleOverrides() const;
262 : :
263 : : /**
264 : : * Sets the map of map layer style \a overrides (key: layer ID, value: style name) where a different style should be used instead of the current one.
265 : : *
266 : : * \see layerStyleOverrides()
267 : : * \since QGIS 2.8
268 : : */
269 : : void setLayerStyleOverrides( const QMap<QString, QString> &overrides );
270 : :
271 : : /**
272 : : * Returns custom rendering flags. Layers might honour these to alter their rendering.
273 : : * \returns custom flags strings, separated by ';'
274 : : * \see setCustomRenderFlags()
275 : : * \since QGIS 2.16
276 : : * \deprecated use \see customRenderingFlags().
277 : : */
278 : : Q_DECL_DEPRECATED QString customRenderFlags() const { return mCustomRenderFlags; }
279 : :
280 : : /**
281 : : * Sets the custom rendering flags. Layers might honour these to alter their rendering.
282 : : * \param customRenderFlags custom flags strings, separated by ';'
283 : : * \see customRenderFlags()
284 : : * \since QGIS 2.16
285 : : * \deprecated use \see setCustomRenderingFlag() instead.
286 : : */
287 : : Q_DECL_DEPRECATED void setCustomRenderFlags( const QString &customRenderFlags ) { mCustomRenderFlags = customRenderFlags; }
288 : :
289 : : /**
290 : : * Returns any custom rendering flags. Layers might honour these to alter their rendering.
291 : : * \returns a map of custom flags
292 : : * \see setCustomRenderingFlag()
293 : : * \since QGIS 3.12
294 : : */
295 : 0 : QVariantMap customRenderingFlags() const { return mCustomRenderingFlags; }
296 : :
297 : : /**
298 : : * Sets a custom rendering \a flag. Layers might honour these to alter their rendering.
299 : : * \param flag the flag name
300 : : * \param value the flag value
301 : : * \see customRenderingFlags()
302 : : * \since QGIS 3.12
303 : : */
304 : : void setCustomRenderingFlag( const QString &flag, const QVariant &value ) { mCustomRenderingFlags[flag] = value; }
305 : :
306 : : /**
307 : : * Clears the specified custom rendering \a flag.
308 : : * \param flag the flag name
309 : : * \see setCustomRenderingFlag()
310 : : * \since QGIS 3.12
311 : : */
312 : : void clearCustomRenderingFlag( const QString &flag ) { mCustomRenderingFlags.remove( flag ); }
313 : :
314 : : /**
315 : : * Sets the destination \a crs (coordinate reference system) for the map render.
316 : : *
317 : : * \see destinationCrs()
318 : : */
319 : : void setDestinationCrs( const QgsCoordinateReferenceSystem &crs );
320 : :
321 : : /**
322 : : * Returns the destination coordinate reference system for the map render.
323 : : *
324 : : * \see setDestinationCrs()
325 : : */
326 : : QgsCoordinateReferenceSystem destinationCrs() const;
327 : :
328 : : /**
329 : : * Returns the units of the map's geographical coordinates - used for scale calculation.
330 : : */
331 : : QgsUnitTypes::DistanceUnit mapUnits() const;
332 : :
333 : : /**
334 : : * Sets the \a ellipsoid by its acronym. Known ellipsoid acronyms can be
335 : : * retrieved using QgsEllipsoidUtils::acronyms().
336 : : * Calculations will only use the ellipsoid if a valid ellipsoid has been set.
337 : : * \returns TRUE if ellipsoid was successfully set
338 : : * \see ellipsoid()
339 : : * \since QGIS 3.0
340 : : */
341 : : bool setEllipsoid( const QString &ellipsoid );
342 : :
343 : : /**
344 : : * Returns ellipsoid's acronym. Calculations will only use the
345 : : * ellipsoid if a valid ellipsoid has been set.
346 : : * \see setEllipsoid()
347 : : * \since QGIS 3.0
348 : : */
349 : 0 : QString ellipsoid() const { return mEllipsoid; }
350 : :
351 : : /**
352 : : * Sets the background \a color of the map.
353 : : *
354 : : * \see backgroundColor()
355 : : */
356 : 0 : void setBackgroundColor( const QColor &color ) { mBackgroundColor = color; }
357 : :
358 : : /**
359 : : * Returns the background color of the map.
360 : : *
361 : : * \see setBackgroundColor()
362 : : */
363 : 0 : QColor backgroundColor() const { return mBackgroundColor; }
364 : :
365 : : /**
366 : : * Sets the \a color that is used for drawing of selected vector features.
367 : : *
368 : : * \see selectionColor()
369 : : */
370 : 0 : void setSelectionColor( const QColor &color ) { mSelectionColor = color; }
371 : :
372 : : /**
373 : : * Returns the color that is used for drawing of selected vector features.
374 : : *
375 : : * \see setSelectionColor()
376 : : */
377 : 0 : QColor selectionColor() const { return mSelectionColor; }
378 : :
379 : : //! Enumeration of flags that adjust the way the map is rendered
380 : : enum Flag
381 : : {
382 : : Antialiasing = 0x01, //!< Enable anti-aliasing for map rendering
383 : : DrawEditingInfo = 0x02, //!< Enable drawing of vertex markers for layers in editing mode
384 : : ForceVectorOutput = 0x04, //!< Vector graphics should not be cached and drawn as raster images
385 : : UseAdvancedEffects = 0x08, //!< Enable layer opacity and blending effects
386 : : DrawLabeling = 0x10, //!< Enable drawing of labels on top of the map
387 : : UseRenderingOptimization = 0x20, //!< Enable vector simplification and other rendering optimizations
388 : : DrawSelection = 0x40, //!< Whether vector selections should be shown in the rendered map
389 : : DrawSymbolBounds = 0x80, //!< Draw bounds of symbols (for debugging/testing)
390 : : RenderMapTile = 0x100, //!< Draw map such that there are no problems between adjacent tiles
391 : : RenderPartialOutput = 0x200, //!< Whether to make extra effort to update map image with partially rendered layers (better for interactive map canvas). Added in QGIS 3.0
392 : : RenderPreviewJob = 0x400, //!< Render is a 'canvas preview' render, and shortcuts should be taken to ensure fast rendering
393 : : RenderBlocking = 0x800, //!< Render and load remote sources in the same thread to ensure rendering remote sources (svg and images). WARNING: this flag must NEVER be used from GUI based applications (like the main QGIS application) or crashes will result. Only for use in external scripts or QGIS server.
394 : : LosslessImageRendering = 0x1000, //!< Render images losslessly whenever possible, instead of the default lossy jpeg rendering used for some destination devices (e.g. PDF). This flag only works with builds based on Qt 5.13 or later.
395 : : Render3DMap = 0x2000, //!< Render is for a 3D map
396 : : // TODO: ignore scale-based visibility (overview)
397 : : };
398 : : Q_DECLARE_FLAGS( Flags, Flag )
399 : :
400 : : //! Sets combination of flags that will be used for rendering
401 : : void setFlags( QgsMapSettings::Flags flags );
402 : : //! Enable or disable a particular flag (other flags are not affected)
403 : : void setFlag( Flag flag, bool on = true );
404 : : //! Returns combination of flags used for rendering
405 : : Flags flags() const;
406 : : //! Check whether a particular flag is enabled
407 : : bool testFlag( Flag flag ) const;
408 : :
409 : : /**
410 : : * Returns the text render format, which dictates how text is rendered (e.g. as paths or real text objects).
411 : : *
412 : : * \see setTextRenderFormat()
413 : : * \since QGIS 3.4.3
414 : : */
415 : 0 : QgsRenderContext::TextRenderFormat textRenderFormat() const
416 : : {
417 : 0 : return mTextRenderFormat;
418 : : }
419 : :
420 : : /**
421 : : * Sets the text render \a format, which dictates how text is rendered (e.g. as paths or real text objects).
422 : : *
423 : : * \warning Calling the setLabelingEngineSettings() method will reset the text render format to match the default
424 : : * text render format from the label engine settings.
425 : : *
426 : : * \see textRenderFormat()
427 : : * \since QGIS 3.4.3
428 : : */
429 : 0 : void setTextRenderFormat( QgsRenderContext::TextRenderFormat format )
430 : : {
431 : 0 : mTextRenderFormat = format;
432 : : // ensure labeling engine setting is also kept in sync, just in case anyone accesses QgsMapSettings::labelingEngineSettings().defaultTextRenderFormat()
433 : : // instead of correctly calling QgsMapSettings::textRenderFormat(). It can't hurt to be consistent!
434 : 0 : mLabelingEngineSettings.setDefaultTextRenderFormat( format );
435 : 0 : }
436 : :
437 : : //! sets format of internal QImage
438 : 0 : void setOutputImageFormat( QImage::Format format ) { mImageFormat = format; }
439 : : //! format of internal QImage, default QImage::Format_ARGB32_Premultiplied
440 : 0 : QImage::Format outputImageFormat() const { return mImageFormat; }
441 : :
442 : : //! Check whether the map settings are valid and can be used for rendering
443 : : bool hasValidSettings() const;
444 : : //! Returns the actual extent derived from requested extent that takes takes output image size into account
445 : : QgsRectangle visibleExtent() const;
446 : :
447 : : /**
448 : : * Returns the visible area as a polygon (may be rotated)
449 : : * \since QGIS 2.8
450 : : */
451 : : QPolygonF visiblePolygon() const;
452 : : //! Returns the distance in geographical coordinates that equals to one pixel in the map
453 : : double mapUnitsPerPixel() const;
454 : :
455 : : /**
456 : : * Returns the calculated map scale.
457 : : * The scale value indicates the scale denominator, e.g. 1000.0 for a 1:1000 map.
458 : : */
459 : : double scale() const;
460 : :
461 : : /**
462 : : * Sets the expression context. This context is used for all expression evaluation
463 : : * associated with this map settings.
464 : : * \see expressionContext()
465 : : * \since QGIS 2.12
466 : : */
467 : 0 : void setExpressionContext( const QgsExpressionContext &context ) { mExpressionContext = context; }
468 : :
469 : : /**
470 : : * Gets the expression context. This context should be used for all expression evaluation
471 : : * associated with this map settings.
472 : : * \see setExpressionContext()
473 : : * \since QGIS 2.12
474 : : */
475 : 0 : const QgsExpressionContext &expressionContext() const { return mExpressionContext; }
476 : :
477 : : /**
478 : : * Returns the coordinate transform context, which stores various
479 : : * information regarding which datum transforms should be used when transforming points
480 : : * from a source to destination coordinate reference system.
481 : : *
482 : : * \see setTransformContext()
483 : : * \since QGIS 3.0
484 : : */
485 : : QgsCoordinateTransformContext transformContext() const;
486 : :
487 : : /**
488 : : * Sets the coordinate transform \a context, which stores various
489 : : * information regarding which datum transforms should be used when transforming points
490 : : * from a source to destination coordinate reference system.
491 : : *
492 : : * \see transformContext()
493 : : * \since QGIS 3.0
494 : : */
495 : : void setTransformContext( const QgsCoordinateTransformContext &context );
496 : :
497 : : /**
498 : : * Returns the path resolver for conversion between relative and absolute paths
499 : : * during rendering operations, e.g. for resolving relative symbol paths.
500 : : *
501 : : * \see setPathResolver()
502 : : * \since QGIS 3.0
503 : : */
504 : 0 : const QgsPathResolver &pathResolver() const { return mPathResolver; }
505 : :
506 : : /**
507 : : * Sets the path \a resolver for conversion between relative and absolute paths
508 : : * during rendering operations, e.g. for resolving relative symbol paths.
509 : : *
510 : : * \see pathResolver()
511 : : * \since QGIS 3.0
512 : : */
513 : 0 : void setPathResolver( const QgsPathResolver &resolver ) { mPathResolver = resolver; }
514 : :
515 : 0 : const QgsMapToPixel &mapToPixel() const { return mMapToPixel; }
516 : :
517 : : /**
518 : : * Computes an *estimated* conversion factor between layer and map units: layerUnits * layerToMapUnits = mapUnits
519 : : * \param layer The layer
520 : : * \param referenceExtent A reference extent based on which to perform the computation. If not specified, the layer extent is used
521 : : * \since QGIS 2.12
522 : : */
523 : : double layerToMapUnits( const QgsMapLayer *layer, const QgsRectangle &referenceExtent = QgsRectangle() ) const;
524 : :
525 : : /**
526 : : * \brief transform bounding box from layer's CRS to output CRS
527 : : * \see layerToMapCoordinates( const QgsMapLayer *, QgsRectangle ) const if you want to transform a rectangle
528 : : * \returns a bounding box (aligned rectangle) containing the transformed extent
529 : : */
530 : : QgsRectangle layerExtentToOutputExtent( const QgsMapLayer *layer, QgsRectangle extent ) const;
531 : :
532 : : /**
533 : : * \brief transform bounding box from output CRS to layer's CRS
534 : : * \see mapToLayerCoordinates( const QgsMapLayer *, QgsRectangle ) const if you want to transform a rectangle
535 : : * \returns a bounding box (aligned rectangle) containing the transformed extent
536 : : */
537 : : QgsRectangle outputExtentToLayerExtent( const QgsMapLayer *layer, QgsRectangle extent ) const;
538 : :
539 : : /**
540 : : * \brief transform point coordinates from layer's CRS to output CRS
541 : : * \returns the transformed point
542 : : */
543 : : QgsPointXY layerToMapCoordinates( const QgsMapLayer *layer, QgsPointXY point ) const;
544 : :
545 : : /**
546 : : * \brief transform point coordinates from layer's CRS to output CRS
547 : : * \returns the transformed point
548 : : * \since QGIS 3.16
549 : : */
550 : : QgsPoint layerToMapCoordinates( const QgsMapLayer *layer, const QgsPoint &point ) const;
551 : :
552 : : /**
553 : : * \brief transform rectangle from layer's CRS to output CRS
554 : : * \see layerExtentToOutputExtent() if you want to transform a bounding box
555 : : * \returns the transformed rectangle
556 : : */
557 : : QgsRectangle layerToMapCoordinates( const QgsMapLayer *layer, QgsRectangle rect ) const;
558 : :
559 : : /**
560 : : * \brief transform point coordinates from output CRS to layer's CRS
561 : : * \returns the transformed point
562 : : */
563 : : QgsPointXY mapToLayerCoordinates( const QgsMapLayer *layer, QgsPointXY point ) const;
564 : :
565 : : /**
566 : : * \brief transform point coordinates from output CRS to layer's CRS
567 : : * \returns the transformed point
568 : : * \since QGIS 3.16
569 : : */
570 : : QgsPoint mapToLayerCoordinates( const QgsMapLayer *layer, const QgsPoint &point ) const;
571 : :
572 : : /**
573 : : * \brief transform rectangle from output CRS to layer's CRS
574 : : * \see outputExtentToLayerExtent() if you want to transform a bounding box
575 : : * \returns the transformed rectangle
576 : : */
577 : : QgsRectangle mapToLayerCoordinates( const QgsMapLayer *layer, QgsRectangle rect ) const;
578 : :
579 : : /**
580 : : * Returns the coordinate transform from layer's CRS to destination CRS
581 : : * \returns transform - may be invalid if the transform is not needed
582 : : */
583 : : QgsCoordinateTransform layerTransform( const QgsMapLayer *layer ) const;
584 : :
585 : : //! returns current extent of layer set
586 : : QgsRectangle fullExtent() const;
587 : :
588 : : /* serialization */
589 : :
590 : : void readXml( QDomNode &node );
591 : :
592 : : void writeXml( QDomNode &node, QDomDocument &doc );
593 : :
594 : : /**
595 : : * Sets the segmentation tolerance applied when rendering curved geometries
596 : : * \param tolerance the segmentation tolerance
597 : : */
598 : : void setSegmentationTolerance( double tolerance ) { mSegmentationTolerance = tolerance; }
599 : : //! Gets the segmentation tolerance applied when rendering curved geometries
600 : 0 : double segmentationTolerance() const { return mSegmentationTolerance; }
601 : :
602 : : /**
603 : : * Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation)
604 : : * \param type the segmentation tolerance typename
605 : : */
606 : : void setSegmentationToleranceType( QgsAbstractGeometry::SegmentationToleranceType type ) { mSegmentationToleranceType = type; }
607 : : //! Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation)
608 : 0 : QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const { return mSegmentationToleranceType; }
609 : :
610 : : /**
611 : : * Sets the global configuration of the labeling engine.
612 : : *
613 : : * \note Calling this method will reset the textRenderFormat() to match the default
614 : : * text render format from the label engine \a settings.
615 : : *
616 : : * \see labelingEngineSettings()
617 : : *
618 : : * \since QGIS 3.0
619 : : */
620 : 0 : void setLabelingEngineSettings( const QgsLabelingEngineSettings &settings )
621 : : {
622 : 0 : mLabelingEngineSettings = settings;
623 : 0 : mTextRenderFormat = settings.defaultTextRenderFormat();
624 : 0 : }
625 : :
626 : : /**
627 : : * Returns the global configuration of the labeling engine.
628 : : *
629 : : * \see setLabelingEngineSettings()
630 : : *
631 : : * \since QGIS 3.0
632 : : */
633 : 0 : const QgsLabelingEngineSettings &labelingEngineSettings() const { return mLabelingEngineSettings; }
634 : :
635 : : /**
636 : : * Returns the label boundary geometry, which restricts where in the rendered map labels are permitted to be
637 : : * placed. By default this is a null geometry, which indicates that labels can be placed anywhere within
638 : : * the map's visiblePolygon().
639 : : *
640 : : * The geometry is specified using the map's destinationCrs().
641 : : *
642 : : * \see setLabelBoundaryGeometry()
643 : : * \see labelBlockingRegions()
644 : : * \since QGIS 3.6
645 : : */
646 : : QgsGeometry labelBoundaryGeometry() const;
647 : :
648 : : /**
649 : : * Sets the label \a boundary geometry, which restricts where in the rendered map labels are permitted to be
650 : : * placed.
651 : : *
652 : : * A null \a boundary geometry (the default) indicates that labels can be placed anywhere within
653 : : * the map's visiblePolygon().
654 : : *
655 : : * The geometry is specified using the map's destinationCrs().
656 : : *
657 : : * \see labelBoundaryGeometry()
658 : : * \see setLabelBlockingRegions()
659 : : * \since QGIS 3.6
660 : : */
661 : : void setLabelBoundaryGeometry( const QgsGeometry &boundary );
662 : :
663 : : /**
664 : : * Sets a list of \a regions to avoid placing labels within.
665 : : * \see labelBlockingRegions()
666 : : * \see setLabelBoundaryGeometry()
667 : : * \since QGIS 3.6
668 : : */
669 : 0 : void setLabelBlockingRegions( const QList< QgsLabelBlockingRegion > ®ions ) { mLabelBlockingRegions = regions; }
670 : :
671 : : /**
672 : : * Returns the list of regions to avoid placing labels within.
673 : : * \see setLabelBlockingRegions()
674 : : * \see labelBoundaryGeometry()
675 : : * \since QGIS 3.6
676 : : */
677 : 0 : QList< QgsLabelBlockingRegion > labelBlockingRegions() const { return mLabelBlockingRegions; }
678 : :
679 : : /**
680 : : * Adds a new clipping \a region to the map settings.
681 : : *
682 : : * \see clippingRegions()
683 : : * \see setClippingRegions()
684 : : *
685 : : * \since QGIS 3.16
686 : : */
687 : : void addClippingRegion( const QgsMapClippingRegion ®ion );
688 : :
689 : : /**
690 : : * Sets the list of clipping \a regions to apply to the map.
691 : : *
692 : : * \see addClippingRegion()
693 : : * \see clippingRegions()
694 : : *
695 : : * \since QGIS 3.16
696 : : */
697 : : void setClippingRegions( const QList< QgsMapClippingRegion > ®ions );
698 : :
699 : : /**
700 : : * Returns the list of clipping regions to apply to the map.
701 : : *
702 : : * \see addClippingRegion()
703 : : * \see setClippingRegions()
704 : : *
705 : : * \since QGIS 3.16
706 : : */
707 : : QList< QgsMapClippingRegion > clippingRegions() const;
708 : :
709 : : /**
710 : : * Sets the simplification setting to use when rendering vector layers.
711 : : *
712 : : * If the simplify \a method is enabled, it will override all other layer-specific simplification
713 : : * settings and will apply to all vector layers rendered for the map.
714 : : *
715 : : * This can be used to specify global simplification methods to apply during map exports,
716 : : * e.g. to allow vector layers to be simplified to an appropriate maximum level of detail
717 : : * during PDF exports.
718 : : *
719 : : * The default is to use no global simplification, and fallback to individual layer's settings instead.
720 : : *
721 : : * \see simplifyMethod()
722 : : *
723 : : * \since QGIS 3.10
724 : : */
725 : 0 : void setSimplifyMethod( const QgsVectorSimplifyMethod &method ) { mSimplifyMethod = method; }
726 : :
727 : : /**
728 : : * Returns the simplification settings to use when rendering vector layers.
729 : : *
730 : : * If enabled, it will override all other layer-specific simplification
731 : : * settings and will apply to all vector layers rendered for the map.
732 : : *
733 : : * The default is to use no global simplification, and fallback to individual layer's settings instead.
734 : : *
735 : : * \see setSimplifyMethod()
736 : : * \since QGIS 3.10
737 : : */
738 : 0 : const QgsVectorSimplifyMethod &simplifyMethod() const { return mSimplifyMethod; }
739 : :
740 : : /**
741 : : * Adds a rendered feature \a handler to use while rendering the map settings.
742 : : *
743 : : * Ownership of \a handler is NOT transferred, and it is the caller's responsibility to ensure
744 : : * that the handler exists for the lifetime of the map render job.
745 : : *
746 : : * \see renderedFeatureHandlers()
747 : : * \since QGIS 3.10
748 : : */
749 : : void addRenderedFeatureHandler( QgsRenderedFeatureHandlerInterface *handler );
750 : :
751 : : /**
752 : : * Returns the list of rendered feature handlers to use while rendering the map settings.
753 : : * \see addRenderedFeatureHandler()
754 : : * \since QGIS 3.10
755 : : */
756 : : QList< QgsRenderedFeatureHandlerInterface * > renderedFeatureHandlers() const;
757 : :
758 : : /**
759 : : * Returns the range of z-values which will be visible in the map.
760 : : *
761 : : * \see setZRange()
762 : : * \since QGIS 3.18
763 : : */
764 : : QgsDoubleRange zRange() const;
765 : :
766 : : /**
767 : : * Sets the \a range of z-values which will be visible in the map.
768 : : *
769 : : * \see zRange()
770 : : * \since QGIS 3.18
771 : : */
772 : : void setZRange( const QgsDoubleRange &range );
773 : :
774 : : protected:
775 : :
776 : : double mDpi;
777 : :
778 : : QSize mSize;
779 : : float mDevicePixelRatio = 1.0;
780 : :
781 : : QgsRectangle mExtent;
782 : : double mExtentBuffer = 0.0;
783 : :
784 : : double mRotation = 0.0;
785 : : double mMagnificationFactor = 1.0;
786 : :
787 : : //! list of layers to be rendered (stored as weak pointers)
788 : : QgsWeakMapLayerPointerList mLayers;
789 : : QMap<QString, QString> mLayerStyleOverrides;
790 : : QString mCustomRenderFlags;
791 : : QVariantMap mCustomRenderingFlags;
792 : : QgsExpressionContext mExpressionContext;
793 : :
794 : : QgsCoordinateReferenceSystem mDestCRS;
795 : : //! ellipsoid acronym (from table tbl_ellipsoids)
796 : : QString mEllipsoid;
797 : :
798 : : QColor mBackgroundColor;
799 : : QColor mSelectionColor;
800 : :
801 : : Flags mFlags;
802 : :
803 : : QImage::Format mImageFormat = QImage::Format_ARGB32_Premultiplied;
804 : :
805 : : double mSegmentationTolerance;
806 : : QgsAbstractGeometry::SegmentationToleranceType mSegmentationToleranceType = QgsAbstractGeometry::MaximumAngle;
807 : :
808 : : QgsLabelingEngineSettings mLabelingEngineSettings;
809 : :
810 : : // derived properties
811 : : bool mValid = false; //!< Whether the actual settings are valid (set in updateDerived())
812 : : QgsRectangle mVisibleExtent; //!< Extent with some additional white space that matches the output aspect ratio
813 : : double mMapUnitsPerPixel = 1;
814 : : double mScale = 1;
815 : :
816 : : // utiity stuff
817 : : QgsScaleCalculator mScaleCalculator;
818 : : QgsMapToPixel mMapToPixel;
819 : :
820 : : QgsCoordinateTransformContext mTransformContext;
821 : :
822 : : QgsPathResolver mPathResolver;
823 : :
824 : : QgsRenderContext::TextRenderFormat mTextRenderFormat = QgsRenderContext::TextFormatAlwaysOutlines;
825 : :
826 : : QgsGeometry mLabelBoundaryGeometry;
827 : :
828 : : QgsVectorSimplifyMethod mSimplifyMethod;
829 : :
830 : : #ifdef QGISDEBUG
831 : : bool mHasTransformContext = false;
832 : : #endif
833 : :
834 : : void updateDerived();
835 : :
836 : : private:
837 : :
838 : : QList< QgsLabelBlockingRegion > mLabelBlockingRegions;
839 : : QList< QgsMapClippingRegion > mClippingRegions;
840 : : QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
841 : :
842 : : QgsDoubleRange mZRange;
843 : :
844 : : };
845 : :
846 : 6 : Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapSettings::Flags )
847 : :
848 : :
849 : : #endif // QGSMAPSETTINGS_H
|
