QGIS API Documentation  3.9.0-Master (224899f119)
qgsmapsettings.h
Go to the documentation of this file.
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 
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 
36 class QPainter;
37 
39 class QgsScaleCalculator;
40 class QgsMapRendererJob;
42 
51 class CORE_EXPORT QgsLabelBlockingRegion
52 {
53  public:
54 
58  explicit QgsLabelBlockingRegion( const QgsGeometry &geometry )
59  : geometry( geometry )
60  {}
61 
64 
65 };
66 
67 
85 class CORE_EXPORT QgsMapSettings
86 {
87  public:
89 
96  QgsRectangle extent() const;
97 
104  void setExtent( const QgsRectangle &rect, bool magnified = true );
105 
112  double extentBuffer() const;
113 
120  void setExtentBuffer( double buffer );
121 
123  QSize outputSize() const;
125  void setOutputSize( QSize size );
126 
132  float devicePixelRatio() const;
133 
139  void setDevicePixelRatio( float dpr );
140 
147  QSize deviceOutputSize() const;
148 
154  double rotation() const;
155 
161  void setRotation( double rotation );
162 
167  double outputDpi() const;
169  void setOutputDpi( double dpi );
170 
177  void setMagnificationFactor( double factor );
178 
184  double magnificationFactor() const;
185 
190  QStringList layerIds() const;
191 
196  QList<QgsMapLayer *> layers() const;
197 
204  void setLayers( const QList<QgsMapLayer *> &layers );
205 
210  QMap<QString, QString> layerStyleOverrides() const;
211 
216  void setLayerStyleOverrides( const QMap<QString, QString> &overrides );
217 
224  QString customRenderFlags() const { return mCustomRenderFlags; }
225 
232  void setCustomRenderFlags( const QString &customRenderFlags ) { mCustomRenderFlags = customRenderFlags; }
233 
235  void setDestinationCrs( const QgsCoordinateReferenceSystem &crs );
237  QgsCoordinateReferenceSystem destinationCrs() const;
238 
240  QgsUnitTypes::DistanceUnit mapUnits() const;
241 
250  bool setEllipsoid( const QString &ellipsoid );
251 
258  QString ellipsoid() const { return mEllipsoid; }
259 
261  void setBackgroundColor( const QColor &color ) { mBackgroundColor = color; }
263  QColor backgroundColor() const { return mBackgroundColor; }
264 
266  void setSelectionColor( const QColor &color ) { mSelectionColor = color; }
268  QColor selectionColor() const { return mSelectionColor; }
269 
271  enum Flag
272  {
273  Antialiasing = 0x01,
274  DrawEditingInfo = 0x02,
275  ForceVectorOutput = 0x04,
276  UseAdvancedEffects = 0x08,
277  DrawLabeling = 0x10,
278  UseRenderingOptimization = 0x20,
279  DrawSelection = 0x40,
280  DrawSymbolBounds = 0x80,
281  RenderMapTile = 0x100,
282  RenderPartialOutput = 0x200,
283  RenderPreviewJob = 0x400,
284  // TODO: ignore scale-based visibility (overview)
285  };
286  Q_DECLARE_FLAGS( Flags, Flag )
287 
288 
289  void setFlags( QgsMapSettings::Flags flags );
291  void setFlag( Flag flag, bool on = true );
293  Flags flags() const;
295  bool testFlag( Flag flag ) const;
296 
304  {
305  return mTextRenderFormat;
306  }
307 
318  {
319  mTextRenderFormat = format;
320  // ensure labeling engine setting is also kept in sync, just in case anyone accesses QgsMapSettings::labelingEngineSettings().defaultTextRenderFormat()
321  // instead of correctly calling QgsMapSettings::textRenderFormat(). It can't hurt to be consistent!
322  mLabelingEngineSettings.setDefaultTextRenderFormat( format );
323  }
324 
326  void setOutputImageFormat( QImage::Format format ) { mImageFormat = format; }
328  QImage::Format outputImageFormat() const { return mImageFormat; }
329 
331  bool hasValidSettings() const;
333  QgsRectangle visibleExtent() const;
334 
339  QPolygonF visiblePolygon() const;
341  double mapUnitsPerPixel() const;
342 
347  double scale() const;
348 
355  void setExpressionContext( const QgsExpressionContext &context ) { mExpressionContext = context; }
356 
363  const QgsExpressionContext &expressionContext() const { return mExpressionContext; }
364 
373  QgsCoordinateTransformContext transformContext() const;
374 
383  void setTransformContext( const QgsCoordinateTransformContext &context );
384 
392  const QgsPathResolver &pathResolver() const { return mPathResolver; }
393 
401  void setPathResolver( const QgsPathResolver &resolver ) { mPathResolver = resolver; }
402 
403  const QgsMapToPixel &mapToPixel() const { return mMapToPixel; }
404 
411  double layerToMapUnits( const QgsMapLayer *layer, const QgsRectangle &referenceExtent = QgsRectangle() ) const;
412 
418  QgsRectangle layerExtentToOutputExtent( const QgsMapLayer *layer, QgsRectangle extent ) const;
419 
425  QgsRectangle outputExtentToLayerExtent( const QgsMapLayer *layer, QgsRectangle extent ) const;
426 
431  QgsPointXY layerToMapCoordinates( const QgsMapLayer *layer, QgsPointXY point ) const;
432 
438  QgsRectangle layerToMapCoordinates( const QgsMapLayer *layer, QgsRectangle rect ) const;
439 
444  QgsPointXY mapToLayerCoordinates( const QgsMapLayer *layer, QgsPointXY point ) const;
445 
451  QgsRectangle mapToLayerCoordinates( const QgsMapLayer *layer, QgsRectangle rect ) const;
452 
457  QgsCoordinateTransform layerTransform( const QgsMapLayer *layer ) const;
458 
460  QgsRectangle fullExtent() const;
461 
462  /* serialization */
463 
464  void readXml( QDomNode &node );
465 
466  void writeXml( QDomNode &node, QDomDocument &doc );
467 
471  void setSegmentationTolerance( double tolerance ) { mSegmentationTolerance = tolerance; }
473  double segmentationTolerance() const { return mSegmentationTolerance; }
474 
478  void setSegmentationToleranceType( QgsAbstractGeometry::SegmentationToleranceType type ) { mSegmentationToleranceType = type; }
480  QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const { return mSegmentationToleranceType; }
481 
493  {
494  mLabelingEngineSettings = settings;
495  mTextRenderFormat = settings.defaultTextRenderFormat();
496  }
497 
505  const QgsLabelingEngineSettings &labelingEngineSettings() const { return mLabelingEngineSettings; }
506 
518  QgsGeometry labelBoundaryGeometry() const;
519 
533  void setLabelBoundaryGeometry( const QgsGeometry &boundary );
534 
541  void setLabelBlockingRegions( const QList< QgsLabelBlockingRegion > &regions ) { mLabelBlockingRegions = regions; }
542 
549  QList< QgsLabelBlockingRegion > labelBlockingRegions() const { return mLabelBlockingRegions; }
550 
567  void setSimplifyMethod( const QgsVectorSimplifyMethod &method ) { mSimplifyMethod = method; }
568 
580  const QgsVectorSimplifyMethod &simplifyMethod() const { return mSimplifyMethod; }
581 
591  void addRenderedFeatureHandler( QgsRenderedFeatureHandlerInterface *handler );
592 
598  QList< QgsRenderedFeatureHandlerInterface * > renderedFeatureHandlers() const;
599 
600  protected:
601 
602  double mDpi;
603 
604  QSize mSize;
605  float mDevicePixelRatio = 1.0;
606 
608  double mExtentBuffer = 0.0;
609 
610  double mRotation = 0.0;
611  double mMagnificationFactor = 1.0;
612 
615  QMap<QString, QString> mLayerStyleOverrides;
618 
621  QString mEllipsoid;
622 
625 
626  Flags mFlags;
627 
628  QImage::Format mImageFormat = QImage::Format_ARGB32_Premultiplied;
629 
632 
634 
635  // derived properties
636  bool mValid = false;
638  double mMapUnitsPerPixel = 1;
639  double mScale = 1;
640 
641  // utiity stuff
644 
646 
648 
650 
652 
654 
655 #ifdef QGISDEBUG
656  bool mHasTransformContext = false;
657 #endif
658 
659  void updateDerived();
660 
661  private:
662 
663  QList< QgsLabelBlockingRegion > mLabelBlockingRegions;
664  QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
665 };
666 
667 Q_DECLARE_OPERATORS_FOR_FLAGS( QgsMapSettings::Flags )
668 
669 
670 #endif // QGSMAPSETTINGS_H
A rectangle specified with double values.
Definition: qgsrectangle.h:41
Base class for all map layer types.
Definition: qgsmaplayer.h:79
QgsRectangle mVisibleExtent
Extent with some additional white space that matches the output aspect ratio.
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
QgsMapToPixel mMapToPixel
Abstract base class for map rendering implementations.
const QgsExpressionContext & expressionContext() const
Gets the expression context.
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
Maximum angle between generating radii (lines from arc center to output vertices) ...
QgsRenderContext::TextRenderFormat defaultTextRenderFormat() const
Returns the default text rendering format for the labels.
QgsCoordinateReferenceSystem mDestCRS
QgsCoordinateTransformContext mTransformContext
A class to represent a 2D point.
Definition: qgspointxy.h:43
QMap< QString, QString > mLayerStyleOverrides
QColor backgroundColor() const
Gets the background color of the map.
void setCustomRenderFlags(const QString &customRenderFlags)
Sets the custom rendering flags.
QgsGeometry mLabelBoundaryGeometry
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:121
SegmentationToleranceType
Segmentation tolerance as maximum angle or maximum difference between approximation and circle...
const QgsCoordinateReferenceSystem & crs
QgsLabelingEngineSettings mLabelingEngineSettings
The QgsMapSettings class contains configuration for rendering of the map.
QString customRenderFlags() const
Gets custom rendering flags.
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:37
const QgsVectorSimplifyMethod & simplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
QgsRectangle mExtent
void setTextRenderFormat(QgsRenderContext::TextRenderFormat format)
Sets the text render format, which dictates how text is rendered (e.g.
Flag
Enumeration of flags that adjust the way the map is rendered.
Always render text using path objects (AKA outlines/curves).
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void setSegmentationTolerance(double tolerance)
Sets the segmentation tolerance applied when rendering curved geometries.
An interface for classes which provider custom handlers for features rendered as part of a map render...
QgsPathResolver mPathResolver
QgsVectorSimplifyMethod mSimplifyMethod
QImage::Format outputImageFormat() const
format of internal QImage, default QImage::Format_ARGB32_Premultiplied
void setSimplifyMethod(const QgsVectorSimplifyMethod &method)
Sets the simplification setting to use when rendering vector layers.
void setOutputImageFormat(QImage::Format format)
sets format of internal QImage
Label blocking region (in map coordinates and CRS).
Contains information about the context in which a coordinate transform is executed.
QgsExpressionContext mExpressionContext
TextRenderFormat
Options for rendering text.
QgsScaleCalculator mScaleCalculator
const QgsMapToPixel & mapToPixel() const
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
Calculates scale for a given combination of canvas size, map extent, and monitor dpi.
DistanceUnit
Units of distance.
Definition: qgsunittypes.h:54
QString mEllipsoid
ellipsoid acronym (from table tbl_ellipsoids)
void setBackgroundColor(const QColor &color)
Sets the background color of the map.
void setLabelingEngineSettings(const QgsLabelingEngineSettings &settings)
Sets the global configuration of the labeling engine.
This class contains information how to simplify geometries fetched from a vector layer.
QString ellipsoid() const
Returns ellipsoid&#39;s acronym.
double segmentationTolerance() const
Gets the segmentation tolerance applied when rendering curved geometries.
double mSegmentationTolerance
void setSelectionColor(const QColor &color)
Sets color that is used for drawing of selected vector features.
QList< QgsWeakMapLayerPointer > QgsWeakMapLayerPointerList
A list of weak pointers to QgsMapLayers.
Definition: qgsmaplayer.h:1624
QgsWeakMapLayerPointerList mLayers
list of layers to be rendered (stored as weak pointers)
Stores global configuration for labeling engine.
This class represents a coordinate reference system (CRS).
QColor mBackgroundColor
Class for doing transforms between two map coordinate systems.
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
QgsLabelBlockingRegion(const QgsGeometry &geometry)
Constructor for a label blocking region.
QgsGeometry geometry
Geometry of region to avoid placing labels within (in destination map coordinates and CRS) ...
QgsRenderContext::TextRenderFormat textRenderFormat() const
Returns the text render format, which dictates how text is rendered (e.g.
QColor selectionColor() const
Gets color that is used for drawing of selected vector features.
QColor mSelectionColor
Resolves relative paths into absolute paths and vice versa.
QList< QgsLabelBlockingRegion > labelBlockingRegions() const
Returns the list of regions to avoid placing labels within.
QString mCustomRenderFlags
const QgsLabelingEngineSettings & labelingEngineSettings() const
Returns the global configuration of the labeling engine.
void setLabelBlockingRegions(const QList< QgsLabelBlockingRegion > &regions)
Sets a list of regions to avoid placing labels within.