QGIS API Documentation  3.21.0-Master (909859188c)
qgsrendercontext.h
Go to the documentation of this file.
1 /***************************************************************************
2  qgsrendercontext.h
3  ------------------
4  begin : March 16, 2008
5  copyright : (C) 2008 by Marco Hugentobler
6  email : marco dot hugentobler at karto dot baug dot ethz dot ch
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 
18 #ifndef QGSRENDERCONTEXT_H
19 #define QGSRENDERCONTEXT_H
20 
21 #include "qgis_core.h"
22 #include "qgis_sip.h"
23 #include <QColor>
24 #include <QPainter>
25 #include <memory>
26 
27 #include "qgscoordinatetransform.h"
28 #include "qgsexpressioncontext.h"
30 #include "qgsmaptopixel.h"
31 #include "qgsmapunitscale.h"
32 #include "qgsrectangle.h"
34 #include "qgsdistancearea.h"
36 #include "qgspathresolver.h"
37 #include "qgstemporalrangeobject.h"
38 
39 class QPainter;
41 class QgsLabelingEngine;
42 class QgsMapSettings;
44 class QgsSymbolLayer;
45 class QgsMaskIdProvider;
47 
48 
57 class CORE_EXPORT QgsRenderContext : public QgsTemporalRangeObject
58 {
59  public:
61  ~QgsRenderContext() override;
62 
64  QgsRenderContext &operator=( const QgsRenderContext &rh );
65 
70  enum Flag
71  {
72  DrawEditingInfo = 0x01,
73  ForceVectorOutput = 0x02,
74  UseAdvancedEffects = 0x04,
75  UseRenderingOptimization = 0x08,
76  DrawSelection = 0x10,
77  DrawSymbolBounds = 0x20,
78  RenderMapTile = 0x40,
79  Antialiasing = 0x80,
80  RenderPartialOutput = 0x100,
81  RenderPreviewJob = 0x200,
82  RenderBlocking = 0x400,
83  RenderSymbolPreview = 0x800,
84  LosslessImageRendering = 0x1000,
85  ApplyScalingWorkaroundForTextRendering = 0x2000,
86  Render3DMap = 0x4000,
87  ApplyClipAfterReprojection = 0x8000,
88  };
89  Q_DECLARE_FLAGS( Flags, Flag )
90 
91 
96  {
97  // refs for below dox: https://github.com/qgis/QGIS/pull/1286#issuecomment-39806854
98  // https://github.com/qgis/QGIS/pull/8573#issuecomment-445585826
99 
117 
133  };
134 
139  void setFlags( QgsRenderContext::Flags flags );
140 
145  void setFlag( Flag flag, bool on = true );
146 
151  Flags flags() const;
152 
157  bool testFlag( Flag flag ) const;
158 
163  static QgsRenderContext fromMapSettings( const QgsMapSettings &mapSettings );
164 
171  static QgsRenderContext fromQPainter( QPainter *painter );
172 
173  //getters
174 
179  QPainter *painter() {return mPainter;}
180 
181 #ifndef SIP_RUN
182 
188  const QPainter *painter() const { return mPainter; }
189 #endif
190 
200  void setPainterFlagsUsingContext( QPainter *painter = nullptr ) const;
201 
211  QPainter *maskPainter( int id = 0 ) { return mMaskPainter.value( id, nullptr ); }
212 
222  QSet<const QgsSymbolLayer *> disabledSymbolLayers() const { return mDisabledSymbolLayers; }
223 
233  bool isSymbolLayerEnabled( const QgsSymbolLayer *layer ) const { return ! mDisabledSymbolLayers.contains( layer ); }
234 
245  QgsCoordinateTransform coordinateTransform() const {return mCoordTransform;}
246 
251  const QgsDistanceArea &distanceArea() const { return mDistanceArea; }
252 
261  QgsCoordinateTransformContext transformContext() const;
262 
271  void setTransformContext( const QgsCoordinateTransformContext &context );
272 
280  const QgsPathResolver &pathResolver() const { return mPathResolver; }
281 
289  void setPathResolver( const QgsPathResolver &resolver ) { mPathResolver = resolver; }
290 
306  const QgsRectangle &extent() const { return mExtent; }
307 
318  QgsRectangle mapExtent() const { return mOriginalMapExtent; }
319 
325  const QgsMapToPixel &mapToPixel() const {return mMapToPixel;}
326 
333  double scaleFactor() const {return mScaleFactor;}
334 
341  double dpiTarget() const {return mDpiTarget;}
342 
349  bool renderingStopped() const {return mRenderingStopped;}
350 
357  bool forceVectorOutput() const;
358 
364  bool useAdvancedEffects() const;
365 
371  void setUseAdvancedEffects( bool enabled );
372 
378  bool drawEditingInformation() const;
379 
385  double rendererScale() const {return mRendererScale;}
386 
387 
403  double symbologyReferenceScale() const { return mSymbologyReferenceScale; }
404 
409  QgsLabelingEngine *labelingEngine() const { return mLabelingEngine; } SIP_SKIP
410 
416  QColor selectionColor() const { return mSelectionColor; }
417 
425  bool showSelection() const;
426 
427  //setters
428 
439  void setCoordinateTransform( const QgsCoordinateTransform &t );
440 
446  void setMapToPixel( const QgsMapToPixel &mtp ) {mMapToPixel = mtp;}
447 
460  void setExtent( const QgsRectangle &extent ) {mExtent = extent;}
461 
472  void setMapExtent( const QgsRectangle &extent ) { mOriginalMapExtent = extent; }
473 
479  void setDrawEditingInformation( bool b );
480 
487  void setRenderingStopped( bool stopped ) {mRenderingStopped = stopped;}
488 
494  void setDistanceArea( const QgsDistanceArea &distanceArea ) {mDistanceArea = distanceArea ;}
495 
502  void setScaleFactor( double factor ) {mScaleFactor = factor;}
503 
510  void setDpiTarget( double dpi ) {mDpiTarget = dpi;}
511 
517  void setRendererScale( double scale ) {mRendererScale = scale;}
518 
534  void setSymbologyReferenceScale( double scale ) { mSymbologyReferenceScale = scale; }
535 
542  void setPainter( QPainter *p ) {mPainter = p;}
543 
551  void setMaskPainter( QPainter *p, int id = 0 ) { mMaskPainter[id] = p; }
552 
562  void setDisabledSymbolLayers( const QSet<const QgsSymbolLayer *> &symbolLayers ) { mDisabledSymbolLayers = symbolLayers; }
563 
570  void setForceVectorOutput( bool force );
571 
576  void setLabelingEngine( QgsLabelingEngine *engine ) { mLabelingEngine = engine; } SIP_SKIP
577 
583  void setSelectionColor( const QColor &color ) { mSelectionColor = color; }
584 
592  void setShowSelection( bool showSelection );
593 
599  bool useRenderingOptimization() const;
600 
606  void setUseRenderingOptimization( bool enabled );
607 
616  const QgsVectorSimplifyMethod &vectorSimplifyMethod() const { return mVectorSimplifyMethod; }
617 
631  void setVectorSimplifyMethod( const QgsVectorSimplifyMethod &simplifyMethod ) { mVectorSimplifyMethod = simplifyMethod; }
632 
639  void setExpressionContext( const QgsExpressionContext &context ) { mExpressionContext = context; }
640 
647  QgsExpressionContext &expressionContext() { return mExpressionContext; }
648 
656  const QgsExpressionContext &expressionContext() const { return mExpressionContext; } SIP_SKIP
657 
659  const QgsAbstractGeometry *geometry() const { return mGeometry; }
661  void setGeometry( const QgsAbstractGeometry *geometry ) { mGeometry = geometry; }
662 
669  void setFeatureFilterProvider( const QgsFeatureFilterProvider *ffp );
670 
677  const QgsFeatureFilterProvider *featureFilterProvider() const;
678 
685  void setSegmentationTolerance( double tolerance ) { mSegmentationTolerance = tolerance; }
686 
691  double segmentationTolerance() const { return mSegmentationTolerance; }
692 
699  void setSegmentationToleranceType( QgsAbstractGeometry::SegmentationToleranceType type ) { mSegmentationToleranceType = type; }
700 
705  QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const { return mSegmentationToleranceType; }
706 
707  // Conversions
708 
715  double convertToPainterUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;
716 
723  double convertToMapUnits( double size, QgsUnitTypes::RenderUnit unit, const QgsMapUnitScale &scale = QgsMapUnitScale() ) const;
724 
730  double convertFromMapUnits( double sizeInMapUnits, QgsUnitTypes::RenderUnit outputUnit ) const;
731 
738  double convertMetersToMapUnits( double meters ) const;
739 
747  {
748  return mTextRenderFormat;
749  }
750 
758  {
759  mTextRenderFormat = format;
760  }
761 
767  QList<QgsRenderedFeatureHandlerInterface *> renderedFeatureHandlers() const;
768 
774  bool hasRenderedFeatureHandlers() const { return mHasRenderedFeatureHandlers; }
775 
784  void setMaskIdProvider( QgsMaskIdProvider *provider ) { mMaskIdProvider = provider; }
785 
791  const QgsMaskIdProvider *maskIdProvider() const { return mMaskIdProvider; }
792 
798  void setCurrentMaskId( int id ) { mCurrentMaskId = id; }
799 
806  int currentMaskId() const { return mCurrentMaskId; }
807 
817  void setIsGuiPreview( bool preview ) { mIsGuiPreview = preview; }
818 
829  bool isGuiPreview() const { return mIsGuiPreview; }
830 
837  QVariantMap customRenderingFlags() const { return mCustomRenderingFlags; }
838 
846  void setCustomRenderingFlag( const QString &flag, const QVariant &value ) { mCustomRenderingFlags[flag] = value; }
847 
854  void clearCustomRenderingFlag( const QString &flag ) { mCustomRenderingFlags.remove( flag ); }
855 
863  QList< QgsMapClippingRegion > clippingRegions() const;
864 
879  QgsGeometry featureClipGeometry() const;
880 
890  void setFeatureClipGeometry( const QgsGeometry &geometry );
891 
899  QPointF textureOrigin() const;
900 
908  void setTextureOrigin( const QPointF &origin );
909 
916  QgsDoubleRange zRange() const;
917 
924  void setZRange( const QgsDoubleRange &range );
925 
926  private:
927 
928  Flags mFlags;
929 
931  QPainter *mPainter = nullptr;
932 
939  QMap<int, QPainter *> mMaskPainter;
940 
946  QgsMaskIdProvider *mMaskIdProvider = nullptr;
947 
952  int mCurrentMaskId = -1;
953 
958  bool mIsGuiPreview = false;
959 
961  QgsCoordinateTransform mCoordTransform;
962 
968  QgsDistanceArea mDistanceArea;
969 
970  QgsRectangle mExtent;
971  QgsRectangle mOriginalMapExtent;
972 
973  QgsMapToPixel mMapToPixel;
974 
976  bool mRenderingStopped = false;
977 
979  double mScaleFactor = 1.0;
980 
982  double mDpiTarget = -1.0;
983 
985  double mRendererScale = 1.0;
986 
987  double mSymbologyReferenceScale = -1;
988 
990  QgsLabelingEngine *mLabelingEngine = nullptr;
991 
993  QColor mSelectionColor;
994 
996  QgsVectorSimplifyMethod mVectorSimplifyMethod;
997 
999  QgsExpressionContext mExpressionContext;
1000 
1002  const QgsAbstractGeometry *mGeometry = nullptr;
1003 
1005  std::unique_ptr< QgsFeatureFilterProvider > mFeatureFilterProvider;
1006 
1007  double mSegmentationTolerance = M_PI_2 / 90;
1008 
1010 
1011  QgsCoordinateTransformContext mTransformContext;
1012 
1013  QgsPathResolver mPathResolver;
1014 
1015  TextRenderFormat mTextRenderFormat = TextFormatAlwaysOutlines;
1016  QList< QgsRenderedFeatureHandlerInterface * > mRenderedFeatureHandlers;
1017  bool mHasRenderedFeatureHandlers = false;
1018  QVariantMap mCustomRenderingFlags;
1019 
1020  QSet<const QgsSymbolLayer *> mDisabledSymbolLayers;
1021 
1022  QList< QgsMapClippingRegion > mClippingRegions;
1023  QgsGeometry mFeatureClipGeometry;
1024 
1025  QPointF mTextureOrigin;
1026 
1027  QgsDoubleRange mZRange;
1028 
1029 #ifdef QGISDEBUG
1030  bool mHasTransformContext = false;
1031 #endif
1032 };
1033 
1034 Q_DECLARE_OPERATORS_FOR_FLAGS( QgsRenderContext::Flags )
1035 
1036 #ifndef SIP_RUN
1037 
1050 {
1051  public:
1052 
1059  QgsScopedRenderContextPainterSwap( QgsRenderContext &context, QPainter *temporaryPainter )
1060  : mContext( context )
1061  , mPreviousPainter( context.painter() )
1062  {
1063  mContext.setPainter( temporaryPainter );
1064  }
1065 
1069  void reset()
1070  {
1071  if ( !mReleased )
1072  {
1073  mContext.setPainter( mPreviousPainter );
1074  mReleased = true;
1075  }
1076  }
1077 
1082  {
1083  reset();
1084  }
1085 
1086  private:
1087 
1088  QgsRenderContext &mContext;
1089  QPainter *mPreviousPainter = nullptr;
1090  bool mReleased = false;
1091 };
1092 
1093 
1106 {
1107  public:
1108 
1117  : mContext( context )
1118  {
1119  if ( mContext.painter() )
1120  mContext.painter()->scale( mContext.scaleFactor(), mContext.scaleFactor() );
1121  }
1122 
1127  {
1128  if ( mContext.painter() )
1129  mContext.painter()->scale( 1.0 / mContext.scaleFactor(), 1.0 / mContext.scaleFactor() );
1130  }
1131 
1132  private:
1133 
1134  QgsRenderContext &mContext;
1135 };
1136 
1137 
1150 {
1151  public:
1152 
1161  : mContext( context )
1162  {
1163  if ( mContext.painter() )
1164  mContext.painter()->scale( 1.0 / mContext.scaleFactor(), 1.0 / mContext.scaleFactor() );
1165  }
1166 
1171  {
1172  if ( mContext.painter() )
1173  mContext.painter()->scale( mContext.scaleFactor(), mContext.scaleFactor() );
1174  }
1175 
1176  private:
1177 
1178  QgsRenderContext &mContext;
1179 };
1180 
1181 
1194 {
1195  public:
1196 
1202  QgsScopedQPainterState( QPainter *painter )
1203  : mPainter( painter )
1204  {
1205  mPainter->save();
1206  }
1207 
1212  {
1213  mPainter->restore();
1214  }
1215 
1216  private:
1217 
1218  QPainter *mPainter = nullptr;
1219 };
1220 
1221 
1233 {
1234  public:
1235 
1242  : mContext( &context )
1243  , mOriginalScale( context.symbologyReferenceScale() )
1244  {
1245  mContext->setSymbologyReferenceScale( scale );
1246  }
1247 
1252  : mContext( o.mContext )
1253  , mOriginalScale( o.mOriginalScale )
1254  {
1255  o.mContext = nullptr;
1256  }
1257 
1262  {
1263  if ( mContext )
1264  mContext->setSymbologyReferenceScale( mOriginalScale );
1265  }
1266 
1267  private:
1268 
1269  QgsRenderContext *mContext = nullptr;
1270  double mOriginalScale = 0;
1271 };
1272 
1273 
1274 #endif
1275 
1276 #endif
Abstract base class for all geometries.
SegmentationToleranceType
Segmentation tolerance as maximum angle or maximum difference between approximation and circle.
@ MaximumAngle
Maximum angle between generating radii (lines from arc center to output vertices)
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
QgsRange which stores a range of double values.
Definition: qgsrange.h:203
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Abstract interface for use by classes that filter the features or attributes of a layer.
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:124
The QgsLabelingEngine class provides map labeling functionality.
A map clipping region (in map coordinates and CRS).
The QgsMapSettings class contains configuration for rendering of the map.
Perform transforms between map coordinates and device coordinates.
Definition: qgsmaptopixel.h:39
Struct for storing maximum and minimum scales for measurements in map units.
This class allows the creation of mask ids based on the different label layers and to give a mask id ...
Resolves relative paths into absolute paths and vice versa.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
Contains information about the context of a rendering operation.
void setMapExtent(const QgsRectangle &extent)
Sets the original extent of the map being rendered.
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
void setRenderingStopped(bool stopped)
Sets whether the rendering operation has been stopped and any ongoing rendering should be canceled im...
void setDistanceArea(const QgsDistanceArea &distanceArea)
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
QPainter * maskPainter(int id=0)
Returns a mask QPainter for the render operation.
void setScaleFactor(double factor)
Sets the scaling factor for the render to convert painter units to physical sizes.
bool hasRenderedFeatureHandlers() const
Returns true if the context has any rendered feature handlers.
TextRenderFormat
Options for rendering text.
@ TextFormatAlwaysText
Always render text as text objects.
@ TextFormatAlwaysOutlines
Always render text using path objects (AKA outlines/curves).
void setSegmentationToleranceType(QgsAbstractGeometry::SegmentationToleranceType type)
Sets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
double symbologyReferenceScale() const
Returns the symbology reference scale.
void setTextRenderFormat(TextRenderFormat format)
Sets the text render format, which dictates how text is rendered (e.g.
double segmentationTolerance() const
Gets the segmentation tolerance applied when rendering curved geometries.
const QgsAbstractGeometry * geometry() const
Returns pointer to the unsegmentized geometry.
void clearCustomRenderingFlag(const QString &flag)
Clears the specified custom rendering flag.
QPainter * painter()
Returns the destination QPainter for the render operation.
double rendererScale() const
Returns the renderer map scale.
QgsExpressionContext & expressionContext()
Gets the expression context.
const QgsMapToPixel & mapToPixel() const
Returns the context's map to pixel transform, which transforms between map coordinates and device coo...
void setGeometry(const QgsAbstractGeometry *geometry)
Sets pointer to original (unsegmentized) geometry.
void setVectorSimplifyMethod(const QgsVectorSimplifyMethod &simplifyMethod)
Sets the simplification setting to use when rendering vector layers.
QVariantMap customRenderingFlags() const
Gets custom rendering flags.
bool isGuiPreview() const
Returns the Gui preview mode.
void setCurrentMaskId(int id)
Stores a mask id as the "current" one.
void setDisabledSymbolLayers(const QSet< const QgsSymbolLayer * > &symbolLayers)
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setDpiTarget(double dpi)
Sets the targeted dpi for rendering.
~QgsRenderContext() override
void setPathResolver(const QgsPathResolver &resolver)
Sets the path resolver for conversion between relative and absolute paths during rendering operations...
void setIsGuiPreview(bool preview)
Sets GUI preview mode.
QgsRectangle mapExtent() const
Returns the original extent of the map being rendered.
void setSymbologyReferenceScale(double scale)
Sets the symbology reference scale.
double dpiTarget() const
Returns the targeted DPI for rendering.
QSet< const QgsSymbolLayer * > disabledSymbolLayers() const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setMaskIdProvider(QgsMaskIdProvider *provider)
Attaches a mask id provider to the context.
const QPainter * painter() const
Returns the const destination QPainter for the render operation.
QColor selectionColor() const
Returns the color to use when rendering selected features.
const QgsExpressionContext & expressionContext() const
Gets the expression context (const version).
void setExtent(const QgsRectangle &extent)
When rendering a map layer, calling this method sets the "clipping" extent for the layer (in the laye...
QgsLabelingEngine * labelingEngine() const
Gets access to new labeling engine (may be nullptr)
void setMapToPixel(const QgsMapToPixel &mtp)
Sets the context's map to pixel transform, which transforms between map coordinates and device coordi...
Flag
Enumeration of flags that affect rendering operations.
int currentMaskId() const
Returns the current mask id, which can be used with maskPainter()
void setCustomRenderingFlag(const QString &flag, const QVariant &value)
Sets a custom rendering flag.
void setPainter(QPainter *p)
Sets the destination QPainter for the render operation.
bool isSymbolLayerEnabled(const QgsSymbolLayer *layer) const
When rendering a map layer in a second pass (for selective masking), some symbol layers may be disabl...
void setMaskPainter(QPainter *p, int id=0)
Sets a mask QPainter for the render operation.
const QgsDistanceArea & distanceArea() const
A general purpose distance and area calculator, capable of performing ellipsoid based calculations.
void setLabelingEngine(QgsLabelingEngine *engine)
Assign new labeling engine.
bool renderingStopped() const
Returns true if the rendering operation has been stopped and any ongoing rendering should be canceled...
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
void setRendererScale(double scale)
Sets the renderer map scale.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
const QgsRectangle & extent() const
When rendering a map layer, calling this method returns the "clipping" extent for the layer (in the l...
QgsAbstractGeometry::SegmentationToleranceType segmentationToleranceType() const
Gets segmentation tolerance type (maximum angle or maximum difference between curve and approximation...
const QgsVectorSimplifyMethod & vectorSimplifyMethod() const
Returns the simplification settings to use when rendering vector layers.
TextRenderFormat textRenderFormat() const
Returns the text render format, which dictates how text is rendered (e.g.
const QgsMaskIdProvider * maskIdProvider() const
Returns the mask id provider attached to the context.
const QgsPathResolver & pathResolver() const
Returns the path resolver for conversion between relative and absolute paths during rendering operati...
void setSelectionColor(const QColor &color)
Sets the color to use when rendering selected features.
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...
Scoped object for saving and restoring a QPainter object's state.
QgsScopedQPainterState(QPainter *painter)
Constructor for QgsScopedQPainterState.
~QgsScopedQPainterState()
Restores the painter back to its original state.
Scoped object for temporary replacement of a QgsRenderContext destination painter.
QgsScopedRenderContextPainterSwap(QgsRenderContext &context, QPainter *temporaryPainter)
Constructor for QgsScopedRenderContextPainterSwap.
~QgsScopedRenderContextPainterSwap()
Returns the destination painter for the context back to the original QPainter object.
void reset()
Resets the destination painter for the context back to the original QPainter object.
Scoped object for temporary override of the symbologyReferenceScale property of a QgsRenderContext.
QgsScopedRenderContextReferenceScaleOverride(QgsScopedRenderContextReferenceScaleOverride &&o) noexcept
Move constructor.
~QgsScopedRenderContextReferenceScaleOverride()
Returns the render context back to the original reference scale.
QgsScopedRenderContextReferenceScaleOverride(QgsRenderContext &context, double scale)
Constructor for QgsScopedRenderContextReferenceScaleOverride.
Scoped object for temporary scaling of a QgsRenderContext for millimeter based rendering.
~QgsScopedRenderContextScaleToMm()
Returns the destination painter back to pixel based units.
QgsScopedRenderContextScaleToMm(QgsRenderContext &context)
Constructor for QgsScopedRenderContextScaleToMm.
Scoped object for temporary scaling of a QgsRenderContext for pixel based rendering.
QgsScopedRenderContextScaleToPixels(QgsRenderContext &context)
Constructor for QgsScopedRenderContextScaleToPixels.
~QgsScopedRenderContextScaleToPixels()
Returns the destination painter back to millimeter based units.
Base class for objects with an associated (optional) temporal range.
RenderUnit
Rendering size units.
Definition: qgsunittypes.h:168
This class contains information how to simplify geometries fetched from a vector layer.
#define SIP_SKIP
Definition: qgis_sip.h:126
Q_DECLARE_OPERATORS_FOR_FLAGS(QgsField::ConfigurationFlags) CORE_EXPORT QDataStream &operator<<(QDataStream &out
Writes the field to stream out. QGIS version compatibility is not guaranteed.