/************************************************************************ * This file has been generated automatically from * * * * src/core/qgis.h * * * * Do not edit manually ! Edit header and run scripts/sipify.py again * ************************************************************************/ %ModuleHeaderCode #include %End %ModuleCode int QgisEvent = QEvent::User + 1; %End class Qgis { %Docstring(signature="appended") Provides global constants and enumerations for use throughout the application. %End %TypeHeaderCode #include "qgis.h" %End public: static const QMetaObject staticMetaObject; public: static QString version(); %Docstring Version string. .. versionadded:: 3.12 %End static int versionInt(); %Docstring Version number used for comparing versions using the "Check QGIS Version" function .. versionadded:: 3.12 %End static QString releaseName(); %Docstring Release name .. versionadded:: 3.12 %End static const char *QGIS_DEV_VERSION; static QString devVersion(); %Docstring The development version .. versionadded:: 3.12 %End enum class AuthConfigurationStorageCapability { ClearStorage, ReadConfiguration, UpdateConfiguration, DeleteConfiguration, CreateConfiguration, ReadCertificateIdentity, UpdateCertificateIdentity, DeleteCertificateIdentity, CreateCertificateIdentity, ReadSslCertificateCustomConfig, UpdateSslCertificateCustomConfig, DeleteSslCertificateCustomConfig, CreateSslCertificateCustomConfig, ReadCertificateAuthority, UpdateCertificateAuthority, DeleteCertificateAuthority, CreateCertificateAuthority, ReadCertificateTrustPolicy, UpdateCertificateTrustPolicy, DeleteCertificateTrustPolicy, CreateCertificateTrustPolicy, ReadMasterPassword, UpdateMasterPassword, DeleteMasterPassword, CreateMasterPassword, ReadSetting, UpdateSetting, DeleteSetting, CreateSetting, }; typedef QFlags AuthConfigurationStorageCapabilities; enum MessageLevel { Info, Warning, Critical, Success, NoLevel, }; enum class LayerType { Vector, Raster, Plugin, Mesh, VectorTile, Annotation, PointCloud, Group, TiledScene, }; enum class LayerFilter { RasterLayer, NoGeometry, PointLayer, LineLayer, PolygonLayer, HasGeometry, VectorLayer, PluginLayer, WritableLayer, MeshLayer, VectorTileLayer, PointCloudLayer, AnnotationLayer, TiledSceneLayer, All, SpatialLayer }; typedef QFlags LayerFilters; enum class LoadStyleFlag { IgnoreMissingStyleErrors, }; typedef QFlags LoadStyleFlags; enum class WkbType { Unknown, Point, LineString, Polygon, Triangle, MultiPoint, MultiLineString, MultiPolygon, GeometryCollection, CircularString, CompoundCurve, CurvePolygon, MultiCurve, MultiSurface, PolyhedralSurface, TIN, NoGeometry, PointZ, LineStringZ, PolygonZ, TriangleZ, MultiPointZ, MultiLineStringZ, MultiPolygonZ, GeometryCollectionZ, CircularStringZ, CompoundCurveZ, CurvePolygonZ, MultiCurveZ, MultiSurfaceZ, PolyhedralSurfaceZ, TINZ, PointM, LineStringM, PolygonM, TriangleM, MultiPointM, MultiLineStringM, MultiPolygonM, GeometryCollectionM, CircularStringM, CompoundCurveM, CurvePolygonM, MultiCurveM, MultiSurfaceM, PolyhedralSurfaceM, TINM, PointZM, LineStringZM, PolygonZM, MultiPointZM, MultiLineStringZM, MultiPolygonZM, GeometryCollectionZM, CircularStringZM, CompoundCurveZM, CurvePolygonZM, MultiCurveZM, MultiSurfaceZM, PolyhedralSurfaceZM, TINZM, TriangleZM, Point25D, LineString25D, Polygon25D, MultiPoint25D, MultiLineString25D, MultiPolygon25D }; enum class GeometryType { Point, Line, Polygon, Unknown, Null, }; enum class DataType { UnknownDataType, Byte, Int8, UInt16, Int16, UInt32, Int32, Float32, Float64, CInt16, CInt32, CFloat32, CFloat64, ARGB32, ARGB32_Premultiplied }; enum class CaptureTechnique { StraightSegments, CircularString, Streaming, Shape, }; enum class VectorLayerTypeFlag { SqlQuery }; typedef QFlags VectorLayerTypeFlags; enum class PythonEmbeddedMode { Never, Ask, SessionOnly, Always, NotForThisSession, }; enum class PythonEmbeddedType { Macro, ExpressionFunction, }; enum class DataProviderReadFlag { TrustDataSource, SkipFeatureCount, LoadDefaultStyle, SkipGetExtent, SkipFullScan, ForceReadOnly, SkipCredentialsRequest, ParallelThreadLoading, }; typedef QFlags DataProviderReadFlags; enum class VectorProviderCapability { NoCapabilities, AddFeatures, DeleteFeatures, ChangeAttributeValues, AddAttributes, DeleteAttributes, CreateSpatialIndex, SelectAtId, ChangeGeometries, SelectEncoding, CreateAttributeIndex, SimplifyGeometries, SimplifyGeometriesWithTopologicalValidation, TransactionSupport, CircularGeometries, ChangeFeatures, RenameAttributes, FastTruncate, ReadLayerMetadata, WriteLayerMetadata, CancelSupport, CreateRenderer, CreateLabeling, ReloadData, FeatureSymbology, EditingCapabilities, }; typedef QFlags VectorProviderCapabilities; enum class FeatureCountState { Uncounted, UnknownCount, }; enum class SpatialIndexPresence { Unknown, NotPresent, Present, }; enum class FeatureAvailability { NoFeaturesAvailable, FeaturesAvailable, FeaturesMaybeAvailable }; enum class VectorDataProviderAttributeEditCapability { EditAlias, EditComment, }; typedef QFlags VectorDataProviderAttributeEditCapabilities; enum class SymbolType { Marker, Line, Fill, Hybrid }; enum class ScaleMethod { ScaleArea, ScaleDiameter }; enum class SettingsType { Custom, Variant, String, StringList, VariantMap, Bool, Integer, Double, EnumFlag, Color }; enum class SettingsTreeNodeType { Root, Standard, NamedList, }; enum class SettingsTreeNodeOption { NamedListSelectedItemSetting, }; typedef QFlags SettingsTreeNodeOptions; enum class PropertyType { Invalid, Static, Field, Expression, }; enum class SldExportOption { NoOptions, Svg, Png, }; typedef QFlags SldExportOptions; enum class SldExportVendorExtension { NoVendorExtension, GeoServerVendorExtension, DeegreeVendorExtension, }; enum class SettingsOption { SaveFormerValue, SaveEnumFlagAsInt, }; typedef QFlags SettingsOptions; enum class SnappingMode { ActiveLayer, AllLayers, AdvancedConfiguration, }; enum class SnappingType { NoSnap, Vertex, Segment, Area, Centroid, MiddleOfSegment, LineEndpoint, }; typedef QFlags SnappingTypes; enum class SymbolRenderHint { DynamicRotation, IsSymbolLayerSubSymbol, ForceVectorRendering, ExcludeSymbolBuffers, }; typedef QFlags SymbolRenderHints; enum class SymbolRotationMode { RespectMapRotation, IgnoreMapRotation, }; enum class HorizontalAnchorPoint { Left, Center, Right, }; enum class VerticalAnchorPoint { Top, Center, Bottom, Baseline, }; enum class FeatureRendererFlag { AffectsLabeling, }; typedef QFlags FeatureRendererFlags; enum class SymbolFlag { RendererShouldUseSymbolLevels, AffectsLabeling, }; typedef QFlags SymbolFlags; enum class SymbolPreviewFlag { FlagIncludeCrosshairsForMarkerSymbols, }; typedef QFlags SymbolPreviewFlags; enum class SymbolLayerFlag { DisableFeatureClipping, CanCalculateMaskGeometryPerFeature, AffectsLabeling, }; typedef QFlags SymbolLayerFlags; enum class SymbolLayerUserFlag { DisableSelectionRecoloring, }; typedef QFlags SymbolLayerUserFlags; enum class BrowserItemType { Collection, Directory, Layer, Error, Favorites, Project, Custom, Fields, Field, }; enum class BrowserItemState { NotPopulated, Populating, Populated, }; enum class BrowserItemCapability { NoCapabilities, SetCrs, Fertile, Fast, Collapse, Rename, Delete, ItemRepresentsFile, RefreshChildrenWhenItemIsRefreshed, ReadOnly, }; typedef QFlags BrowserItemCapabilities; enum class DataItemProviderCapability { NoCapabilities, Files, Directories, Databases, NetworkSources, }; typedef QFlags DataItemProviderCapabilities; enum class BrowserLayerType { NoType, Vector, Raster, Point, Line, Polygon, TableLayer, Database, Table, Plugin, Mesh, VectorTile, PointCloud, TiledScene, }; enum class BrowserDirectoryMonitoring { Default, NeverMonitor, AlwaysMonitor, }; enum class HttpMethod { Get, Post, Head, Put, Delete, }; enum class VectorExportResult { Success, ErrorCreatingDataSource, ErrorCreatingLayer, ErrorAttributeTypeUnsupported, ErrorAttributeCreationFailed, ErrorProjectingFeatures, ErrorFeatureWriteFailed, ErrorInvalidLayer, ErrorInvalidProvider, ErrorProviderUnsupportedFeature, ErrorConnectionFailed, UserCanceled, }; enum class VectorFileWriterCapability { FieldAliases, FieldComments, }; typedef QFlags VectorFileWriterCapabilities; enum class SqlLayerDefinitionCapability { SubsetStringFilter, GeometryColumn, PrimaryKeys, UnstableFeatureIds }; typedef QFlags SqlLayerDefinitionCapabilities; enum class SqlKeywordCategory { Keyword, Constant, Function, Geospatial, Operator, Math, Aggregate, String, Identifier }; enum class DriveType { Unknown, Invalid, Removable, Fixed, Remote, CdRom, RamDisk, Cloud, }; enum class ActionStart { Deferred, Immediate, }; enum class UnplacedLabelVisibility { FollowEngineSetting, NeverShow, }; enum class LabelOverlapHandling { PreventOverlap, AllowOverlapIfRequired, AllowOverlapAtNoCost, }; enum class LabelPrioritization { PreferCloser, PreferPositionOrdering, }; enum class LabelPlacement { AroundPoint, OverPoint, Line, Curved, Horizontal, Free, OrderedPositionsAroundPoint, PerimeterCurved, OutsidePolygons, }; enum class LabelPredefinedPointPosition { TopLeft, TopSlightlyLeft, TopMiddle, TopSlightlyRight, TopRight, MiddleLeft, MiddleRight, BottomLeft, BottomSlightlyLeft, BottomMiddle, BottomSlightlyRight, BottomRight, OverPoint, }; enum class LabelOffsetType { FromPoint, FromSymbolBounds, }; enum class LabelQuadrantPosition { AboveLeft, Above, AboveRight, Left, Over, Right, BelowLeft, Below, BelowRight, }; enum class LabelLinePlacementFlag { OnLine, AboveLine, BelowLine, MapOrientation, }; typedef QFlags LabelLinePlacementFlags; enum class LabelPolygonPlacementFlag { AllowPlacementOutsideOfPolygon, AllowPlacementInsideOfPolygon, }; typedef QFlags LabelPolygonPlacementFlags; enum class UpsideDownLabelHandling { FlipUpsideDownLabels, AllowUpsideDownWhenRotationIsDefined, AlwaysAllowUpsideDown }; enum class LabelMultiLineAlignment { Left, Center, Right, FollowPlacement, Justify, }; enum class FileFilterType { Vector, Raster, Mesh, MeshDataset, PointCloud, VectorTile, TiledScene, }; enum class UriCleaningFlag { RemoveCredentials, RedactCredentials, }; typedef QFlags UriCleaningFlags; enum class SublayerQueryFlag { FastScan, ResolveGeometryType, CountFeatures, IncludeSystemTables, }; typedef QFlags SublayerQueryFlags; enum class SublayerFlag { SystemTable, }; typedef QFlags SublayerFlags; enum class ShaderInterpolationMethod { Linear, Discrete, Exact, }; enum class ShaderClassificationMethod { Continuous, EqualInterval, Quantile, }; enum class RasterPipeInterfaceRole { Unknown, Provider, Renderer, Brightness, Resampler, Projector, Nuller, HueSaturation, }; enum class RasterResamplingStage { ResampleFilter, Provider, }; enum class RasterResamplingMethod { Nearest, Bilinear, Cubic, CubicSpline, Lanczos, Average, Mode, Gauss }; enum class RasterRendererFlag { InternalLayerOpacityHandling, UseNoDataForOutOfRangePixels, }; typedef QFlags RasterRendererFlags; enum class RasterRendererCapability { UsesMultipleBands, }; typedef QFlags RasterRendererCapabilities; enum class RasterRangeLimit { NotSet, MinimumMaximum, StdDev, CumulativeCut }; enum class RasterRangeExtent { WholeRaster, FixedCanvas, UpdatedCanvas, }; enum class RasterRangeAccuracy { Exact, Estimated, }; enum class RasterAttributeTableFieldUsage { Generic, PixelCount, Name, Min, Max, MinMax, Red, Green, Blue, Alpha, RedMin, GreenMin, BlueMin, AlphaMin, RedMax, GreenMax, BlueMax, AlphaMax, MaxCount }; enum class RasterAttributeTableType { Thematic, Athematic }; enum class RasterExportType { Raw, RenderedImage }; enum class RasterFileWriterResult { Success, SourceProviderError, DestinationProviderError, CreateDatasourceError, WriteError, NoDataConflict, Canceled, }; enum class MeshEditingErrorType { NoError, InvalidFace, TooManyVerticesInFace, FlatFace, UniqueSharedVertex, InvalidVertex, ManifoldFace, }; enum class FilePathType { Absolute, Relative, }; enum class SublayerPromptMode { AlwaysAsk, AskExcludingRasterBands, NeverAskSkip, NeverAskLoadAll, }; enum class FieldOrigin { Unknown, Provider, Join, Edit, Expression }; enum class FieldConfigurationFlag { NoFlag, NotSearchable, HideFromWms, HideFromWfs, }; typedef QFlags FieldConfigurationFlags; enum class FieldMetadataProperty { GeometryCrs, GeometryWkbType, CustomProperty, }; enum class SelectionRenderingMode { Default, CustomColor, CustomSymbol, }; enum class SelectBehavior { SetSelection, AddToSelection, IntersectSelection, RemoveFromSelection, }; enum class SelectGeometryRelationship { Intersect, Within, }; enum class SelectionFlag { SingleFeatureSelection, ToggleSelection, }; typedef QFlags SelectionFlags; enum class VectorEditResult { Success, EmptyGeometry, EditFailed, FetchFeatureFailed, InvalidLayer, }; enum class VertexMarkerType { SemiTransparentCircle, Cross, NoMarker, }; enum class ContentStatus { NotStarted, Running, Finished, Failed, Canceled, }; enum class GpsConnectionType { Automatic, Internal, Serial, Gpsd, }; enum class DeviceConnectionStatus { Disconnected, Connecting, Connected, }; enum class GpsFixStatus { NoData, NoFix, Fix2D, Fix3D }; enum class GnssConstellation { Unknown, Gps, Glonass, Galileo, BeiDou, Qzss, Navic, Sbas, }; enum class GpsQualityIndicator { Unknown, Invalid, GPS, DGPS, PPS, RTK, FloatRTK, Estimated, Manual, Simulation, }; enum class GpsNavigationStatus { NotValid, Safe, Caution, Unsafe, }; enum class GpsInformationComponent { Location, Altitude, GroundSpeed, Bearing, TotalTrackLength, TrackDistanceFromStart, Pdop, Hdop, Vdop, HorizontalAccuracy, VerticalAccuracy, HvAccuracy, SatellitesUsed, Timestamp, TrackStartTime, TrackEndTime, TrackDistanceSinceLastPoint, TrackTimeSinceLastPoint, GeoidalSeparation, EllipsoidAltitude, }; typedef QFlags GpsInformationComponents; enum class BabelFormatCapability { Import, Export, Waypoints, Routes, Tracks, }; typedef QFlags BabelFormatCapabilities; enum class BabelCommandFlag { QuoteFilePaths, }; typedef QFlags BabelCommandFlags; enum class GpsFeatureType { Waypoint, Route, Track, }; enum class GeometryOperationResult { Success, NothingHappened, InvalidBaseGeometry, InvalidInputGeometryType, SelectionIsEmpty, SelectionIsGreaterThanOne, GeometryEngineError, LayerNotEditable, // Add part issues AddPartSelectedGeometryNotFound, AddPartNotMultiGeometry, // Add ring issues AddRingNotClosed, AddRingNotValid, AddRingCrossesExistingRings, AddRingNotInExistingFeature, // Split features SplitCannotSplitPoint, GeometryTypeHasChanged, }; enum class GeometryValidityFlag { AllowSelfTouchingHoles, }; typedef QFlags GeometryValidityFlags; enum class GeometryValidationEngine { QgisInternal, Geos, }; enum class BufferSide { Left, Right, }; enum class EndCapStyle { Round, Flat, Square, }; enum class JoinStyle { Round, Miter, Bevel, }; enum class JoinStyle3D { Round, Flat, CylSphere, }; enum class GeosCreationFlag { RejectOnInvalidSubGeometry, SkipEmptyInteriorRings, }; typedef QFlags GeosCreationFlags; enum class CoverageValidityResult { Invalid, Valid, Error, }; enum class MakeValidMethod { Linework, Structure, }; enum class FeatureRequestFlag { NoFlags, NoGeometry, SubsetOfAttributes, ExactIntersect, IgnoreStaticNodesDuringExpressionCompilation, EmbeddedSymbols, }; typedef QFlags FeatureRequestFlags; enum class FeatureRequestFilterType { NoFilter, Fid, Expression, Fids }; enum class InvalidGeometryCheck { NoCheck, SkipInvalid, AbortOnInvalid, }; enum class SpatialFilterType { NoFilter, BoundingBox, DistanceWithin, }; enum class FileOperationFlag { IncludeMetadataFile, IncludeStyleFile, }; typedef QFlags FileOperationFlags; enum class MapLayerProperty { UsersCannotToggleEditing, IsBasemapLayer, Is3DBasemapLayer, }; typedef QFlags MapLayerProperties; enum class AutoRefreshMode { Disabled, ReloadData, RedrawOnly, }; enum class DataProviderFlag { IsBasemapSource, FastExtent2D, FastExtent3D, Is3DBasemapSource, }; typedef QFlags DataProviderFlags; enum class CrsType { Unknown, Geodetic, Geocentric, Geographic2d, Geographic3d, Vertical, Projected, Compound, Temporal, Engineering, Bound, Other, DerivedProjected, }; enum class CrsAxisDirection { North, NorthNorthEast, NorthEast, EastNorthEast, East, EastSouthEast, SouthEast, SouthSouthEast, South, SouthSouthWest, SouthWest, WestSouthWest, West, WestNorthWest, NorthWest, NorthNorthWest, GeocentricX, GeocentricY, GeocentricZ, Up, Down, Forward, Aft, Port, Starboard, Clockwise, CounterClockwise, ColumnPositive, ColumnNegative, RowPositive, RowNegative, DisplayRight, DisplayLeft, DisplayUp, DisplayDown, Future, Past, Towards, AwayFrom, Unspecified, }; enum class CoordinateOrder { Default, XY, YX, }; enum class CrsIdentifierType { ShortString, MediumString, FullString, }; enum class CrsWktVariant { Wkt1Gdal, Wkt1Esri, Wkt2_2015, Wkt2_2015Simplified, Wkt2_2019, Wkt2_2019Simplified, Preferred, PreferredSimplified, PreferredGdal, }; enum class Axis { X, Y, Z }; enum class AnnotationItemFlag { ScaleDependentBoundingBox, SupportsReferenceScale, SupportsCallouts, }; typedef QFlags AnnotationItemFlags; enum class AnnotationPlacementMode { SpatialBounds, FixedSize, RelativeToMapFrame, }; enum class AnnotationItemGuiFlag { FlagNoCreationTools, }; typedef QFlags AnnotationItemGuiFlags; enum class AnnotationItemNodeType { VertexHandle, CalloutHandle, }; enum class AnnotationItemEditOperationResult { Success, Invalid, ItemCleared, }; enum class TemporalNavigationMode { Disabled, Animated, FixedRange, Movie, }; enum class AnimationState { Forward, Reverse, Idle, }; enum class PlaybackOperation { SkipToStart, PreviousFrame, PlayReverse, Pause, PlayForward, NextFrame, SkipToEnd, }; enum class VectorTemporalMode { FixedTemporalRange, FeatureDateTimeInstantFromField, FeatureDateTimeStartAndEndFromFields, FeatureDateTimeStartAndDurationFromFields, FeatureDateTimeStartAndEndFromExpressions, RedrawLayerOnly, }; enum class VectorTemporalLimitMode { IncludeBeginExcludeEnd, IncludeBeginIncludeEnd, }; enum class VectorDataProviderTemporalMode { HasFixedTemporalRange, StoresFeatureDateTimeInstantInField, StoresFeatureDateTimeStartAndEndInSeparateFields, }; enum class RasterTemporalMode { FixedTemporalRange, TemporalRangeFromDataProvider, RedrawLayerOnly, FixedRangePerBand, RepresentsTemporalValues, FixedDateTime, }; enum class TemporalIntervalMatchMethod { MatchUsingWholeRange, MatchExactUsingStartOfRange, MatchExactUsingEndOfRange, FindClosestMatchToStartOfRange, FindClosestMatchToEndOfRange }; enum class RasterTemporalCapabilityFlag { RequestedTimesMustExactlyMatchAllAvailableTemporalRanges, }; typedef QFlags RasterTemporalCapabilityFlags; enum class TransformDirection { Forward, Reverse }; enum class CoordinateTransformationFlag { BallparkTransformsAreAppropriate, IgnoreImpossibleTransformations, }; typedef QFlags CoordinateTransformationFlags; enum class RasterizedRenderingPolicy { Default, PreferVector, ForceVector, }; enum class MapSettingsFlag { Antialiasing, DrawEditingInfo, ForceVectorOutput, UseAdvancedEffects, DrawLabeling, UseRenderingOptimization, DrawSelection, DrawSymbolBounds, RenderMapTile, RenderPartialOutput, RenderPreviewJob, RenderBlocking, LosslessImageRendering, Render3DMap, HighQualityImageTransforms, SkipSymbolRendering, ForceRasterMasks, RecordProfile, AlwaysUseGlobalMasks, }; typedef QFlags MapSettingsFlags; enum class RenderContextFlag { DrawEditingInfo, ForceVectorOutput, UseAdvancedEffects, UseRenderingOptimization, DrawSelection, DrawSymbolBounds, RenderMapTile, Antialiasing, RenderPartialOutput, RenderPreviewJob, RenderBlocking, RenderSymbolPreview, LosslessImageRendering, ApplyScalingWorkaroundForTextRendering, Render3DMap, ApplyClipAfterReprojection, RenderingSubSymbol, HighQualityImageTransforms, SkipSymbolRendering, RecordProfile, AlwaysUseGlobalMasks, DisableSymbolClippingToExtent, RenderLayerTree }; typedef QFlags RenderContextFlags; enum class MapLayerRendererFlag { RenderPartialOutputs, RenderPartialOutputOverPreviousCachedImage, AffectsLabeling, }; typedef QFlags MapLayerRendererFlags; enum class PaintEffectFlag { RequiresRasterization, }; typedef QFlags PaintEffectFlags; enum class TextRenderFormat { AlwaysOutlines, AlwaysText, PreferText, }; enum class LabelingFlag { UseAllLabels, UsePartialCandidates, // TODO QGIS 4.0: remove RenderOutlineLabels, DrawLabelRectOnly, DrawCandidates, DrawUnplacedLabels, CollectUnplacedLabels, DrawLabelMetrics, }; typedef QFlags LabelingFlags; enum class LabelPlacementEngineVersion { Version1, Version2, }; enum class TextOrientation { Horizontal, Vertical, RotationBased, }; enum class TextLayoutMode { Rectangle, Point, Labeling, RectangleCapHeightBased, RectangleAscentBased, }; enum class TextComponent { Text, Buffer, Background, Shadow, }; typedef QFlags TextComponents; enum class TextHorizontalAlignment { Left, Center, Right, Justify, }; enum class TextVerticalAlignment { Top, VerticalCenter, Bottom, }; enum class TextCharacterVerticalAlignment { Normal, SuperScript, SubScript, }; enum class VectorSimplificationAlgorithm { Distance, SnapToGrid, Visvalingam, SnappedToGridGlobal, }; enum class VectorRenderingSimplificationFlag { NoSimplification, GeometrySimplification, AntialiasingSimplification, FullSimplification, }; typedef QFlags VectorRenderingSimplificationFlags; enum class RenderSubcomponentProperty { Generic, ShadowOffset, BlurSize, GlowSpread, }; enum class VertexType { Segment, Curve, }; enum class MarkerShape { Square, Diamond, Pentagon, Hexagon, Triangle, EquilateralTriangle, Star, Arrow, Circle, Cross, CrossFill, Cross2, Line, ArrowHead, ArrowHeadFilled, SemiCircle, ThirdCircle, QuarterCircle, QuarterSquare, HalfSquare, DiagonalHalfSquare, RightHalfTriangle, LeftHalfTriangle, Octagon, SquareWithCorners, AsteriskFill, HalfArc, ThirdArc, QuarterArc, ParallelogramRight, ParallelogramLeft, Trapezoid, Shield, DiamondStar, Heart, Decagon, RoundedSquare, }; enum class MarkerLinePlacement { Interval, Vertex, LastVertex, FirstVertex, CentralPoint, CurvePoint, SegmentCenter, InnerVertices, }; typedef QFlags MarkerLinePlacements; enum class LinearReferencingPlacement { IntervalCartesian2D, IntervalZ, IntervalM, Vertex, }; enum class LinearReferencingLabelSource { CartesianDistance2D, Z, M, }; enum class GradientColorSource { SimpleTwoColor, ColorRamp, }; enum class GradientType { Linear, Radial, Conical, }; enum class SymbolCoordinateReference { Feature, Viewport, }; enum class GradientSpread { Pad, Reflect, Repeat, }; enum class PointCountMethod { Absolute, DensityBased, }; enum class MarkerClipMode { NoClipping, Shape, CentroidWithin, CompletelyWithin, }; enum class LineClipMode { ClipPainterOnly, ClipToIntersection, NoClipping, }; enum class DashPatternLineEndingRule { NoRule, FullDash, HalfDash, FullGap, HalfGap, }; enum class DashPatternSizeAdjustment { ScaleBothDashAndGap, ScaleDashOnly, ScaleGapOnly, }; enum class GraduatedMethod { Color, Size, }; enum class PlotAxisSuffixPlacement { NoLabels, EveryLabel, FirstLabel, LastLabel, FirstAndLastLabels, }; enum class PlotAxisType { Interval, Categorical, }; enum class DpiMode { All, Off, QGIS, UMN, GeoServer, }; enum class TilePixelRatio { Undefined, StandardDpi, HighDpi, }; enum class Capitalization { MixedCase, AllUppercase, AllLowercase, ForceFirstLetterToCapital, SmallCaps, TitleCase, UpperCamelCase, AllSmallCaps, }; enum class TextRendererFlag { WrapLines, }; typedef QFlags TextRendererFlags; enum class ScaleToTileZoomLevelMethod { MapBox, Esri, }; enum class AngularDirection { Clockwise, CounterClockwise, NoOrientation, }; enum class RendererUsage { View, Export, Unknown, }; enum class MapCanvasFlag { ShowMainAnnotationLayer, }; typedef QFlags MapCanvasFlags; enum class ViewSyncModeFlag { Sync3DTo2D, Sync2DTo3D, }; typedef QFlags ViewSyncModeFlags; enum class MapRecenteringMode { Always, WhenOutsideVisibleExtent, Never, }; enum class HistoryProviderBackend { LocalProfile, // Project = 1 << 1, //!< QGIS Project (not yet implemented) }; typedef QFlags HistoryProviderBackends; enum class QueryStorageBackend { LocalProfile, CurrentProject, }; enum class ProcessingSourceType { MapLayer, VectorAnyGeometry, VectorPoint, VectorLine, VectorPolygon, Raster, File, Vector, Mesh, Plugin, PointCloud, Annotation, VectorTile }; enum class ProcessingProviderFlag { DeemphasiseSearchResults, CompatibleWithVirtualRaster, }; typedef QFlags ProcessingProviderFlags; enum class ProcessingAlgorithmFlag { HideFromToolbox, HideFromModeler, SupportsBatch, CanCancel, RequiresMatchingCrs, NoThreading, DisplayNameIsLiteral, SupportsInPlaceEdits, KnownIssues, CustomException, PruneModelBranchesBasedOnAlgorithmResults, SkipGenericModelLogging, NotAvailableInStandaloneTool, RequiresProject, SecurityRisk, Deprecated, }; typedef QFlags ProcessingAlgorithmFlags; enum class ProcessingAlgorithmDocumentationFlag { RegeneratesPrimaryKey, RegeneratesPrimaryKeyInSomeScenarios, RespectsEllipsoid, }; typedef QFlags ProcessingAlgorithmDocumentationFlags; enum class ProcessingPropertyAvailability { NotAvailable, Available, }; enum class ProcessingLogLevel { DefaultLevel, Verbose, ModelDebug, }; enum class ProcessingMode { Standard, Batch, Modeler, }; enum class ProcessingFeatureSourceDefinitionFlag { OverrideDefaultGeometryCheck, CreateIndividualOutputPerInputFeature, }; typedef QFlags ProcessingFeatureSourceDefinitionFlags; enum class ProcessingFeatureSourceFlag { SkipGeometryValidityChecks, }; typedef QFlags ProcessingFeatureSourceFlags; enum class ProcessingParameterTypeFlag { ExposeToModeler }; typedef QFlags ProcessingParameterTypeFlags; enum class ProcessingParameterFlag { Advanced, Hidden, Optional, IsModelOutput, }; typedef QFlags ProcessingParameterFlags; enum class ProcessingFileParameterBehavior { File, Folder, }; enum class ProcessingNumberParameterType { Integer, Double, }; enum class ProcessingFieldParameterDataType { Any, Numeric, String, DateTime, Binary, Boolean, }; enum class ProcessingDateTimeParameterDataType { DateTime, Date, Time, }; enum class ProcessingModelChildParameterSource { ModelParameter, ChildOutput, StaticValue, Expression, ExpressionText, ModelOutput, }; enum class ProcessingModelChildAlgorithmExecutionStatus { NotExecuted, Success, Failed, }; enum class ProcessingTinInputLayerType { Vertices, StructureLines, BreakLines }; enum class CrsDefinitionFormat { Wkt, Proj, }; enum class FieldDomainSplitPolicy { DefaultValue, Duplicate, GeometryRatio, UnsetField, }; enum class FieldDomainMergePolicy { DefaultValue, Sum, GeometryWeighted, UnsetField, LargestGeometry, MinimumValue, MaximumValue, SetToNull, }; enum class FieldDuplicatePolicy { DefaultValue, Duplicate, UnsetField, }; enum class FieldDomainType { Coded, Range, Glob, }; enum class TransactionMode { Disabled, AutomaticGroups, BufferedGroups, }; enum class AltitudeClamping { Absolute, Relative, Terrain, }; enum class AltitudeBinding { Vertex, Centroid, }; enum class RangeLimits { IncludeBoth, IncludeLowerExcludeUpper, ExcludeLowerIncludeUpper, ExcludeBoth, }; enum class RasterElevationMode { FixedElevationRange, RepresentsElevationSurface, FixedRangePerBand, DynamicRangePerBand, }; enum class MeshElevationMode { FixedElevationRange, FromVertices, FixedRangePerGroup, }; enum class BetweenLineConstraint { NoConstraint, Perpendicular, Parallel }; enum class LineExtensionSide { BeforeVertex, AfterVertex, NoVertex, }; enum class CadConstraintType { Generic, Angle, Distance, XCoordinate, YCoordinate, ZValue, MValue, }; enum class ProjectFlag { EvaluateDefaultValuesOnProviderSide, TrustStoredLayerStatistics, RememberLayerEditStatusBetweenSessions, RememberAttributeTableWindowsBetweenSessions, }; typedef QFlags ProjectFlags; enum class PlotToolFlag { ShowContextMenu, }; typedef QFlags PlotToolFlags; enum class Point3DShape { Cylinder, Sphere, Cone, Cube, Torus, Plane, ExtrudedText, Model, Billboard, }; enum class LightSourceType { Point, Directional, }; enum class NavigationMode { TerrainBased, Walk, GlobeTerrainBased }; enum class SceneMode { Local, Globe }; enum class VerticalAxisInversion { Never, WhenDragging, Always, }; enum class ProfileSurfaceSymbology { Line, FillBelow, FillAbove, }; enum class VectorProfileType { IndividualFeatures, ContinuousSurface, }; enum class ProfileGeneratorFlag { RespectsMaximumErrorMapUnit, RespectsDistanceRange, RespectsElevationRange, }; typedef QFlags ProfileGeneratorFlags; enum class ProfileExportType { Features3D, Profile2D, DistanceVsElevationTable, }; enum class PointCloudSymbol { Square, Circle, }; enum class PointCloudDrawOrder { Default, BottomToTop, TopToBottom, }; enum class AvoidIntersectionsMode { AllowIntersections, AvoidIntersectionsCurrentLayer, AvoidIntersectionsLayers, }; enum class ProjectFileFormat { Qgz, Qgs, }; enum class ProjectReadFlag { DontResolveLayers, DontLoadLayouts, TrustLayerMetadata, DontStoreOriginalStyles, DontLoad3DViews, DontLoadProjectStyles, ForceReadOnlyLayers, DontUpgradeAnnotations, }; typedef QFlags ProjectReadFlags; enum class ProjectCapability { ProjectStyles, }; typedef QFlags ProjectCapabilities; enum class MapBoxGlStyleSourceType { Vector, Raster, RasterDem, GeoJson, Image, Video, Unknown, }; enum class ArcGisRestServiceType { FeatureServer, MapServer, ImageServer, GlobeServer, GPServer, GeocodeServer, Unknown, }; enum class RelationshipType { Normal, Generated, }; enum class RelationshipStrength { Association, Composition, }; enum class RelationshipCardinality { OneToOne, OneToMany, ManyToOne, ManyToMany, }; enum class RelationshipCapability { MultipleFieldKeys, ForwardPathLabel, BackwardPathLabel, }; typedef QFlags RelationshipCapabilities; enum class CoordinateDisplayType { MapCrs, MapGeographic, CustomCrs, }; enum class SettingsOrigin { Any, Global, Local, }; enum class ScriptLanguage { Css, QgisExpression, Html, JavaScript, Json, Python, R, Sql, Batch, Bash, Unknown, }; enum class ScriptLanguageCapability { Reformat, CheckSyntax, ToggleComment, }; typedef QFlags ScriptLanguageCapabilities; enum class LayerTreeInsertionMethod { AboveInsertionPoint, TopOfTree, OptimalInInsertionGroup, }; enum class LayerTreeFilterFlag { SkipVisibilityCheck, }; typedef QFlags LayerTreeFilterFlags; enum class MapLayerLegendFlag { ExcludeByDefault, }; typedef QFlags MapLayerLegendFlags; enum class LegendComponent { Undefined, Hidden, Title, Group, Subgroup, Symbol, SymbolLabel, }; enum class LegendJsonRenderFlag { ShowRuleDetails, }; typedef QFlags LegendJsonRenderFlags; enum class ActionType { Invalid, MapLayerAction, AttributeAction }; enum class MapLayerActionTarget { Layer, SingleFeature, MultipleFeatures, AllActions }; typedef QFlags MapLayerActionTargets; enum class MapLayerActionFlag { EnabledOnlyWhenEditable, EnableOnlyWhenHasGeometry, }; typedef QFlags MapLayerActionFlags; enum class AttributeActionType { Generic, GenericPython, Mac, Windows, Unix, OpenUrl, SubmitUrlEncoded, SubmitUrlMultipart, }; enum class MetadataDateType { Created, Published, Revised, Superseded, }; enum class RasterColorInterpretation { Undefined, GrayIndex, PaletteIndex, RedBand, GreenBand, BlueBand, AlphaBand, HueBand, SaturationBand, LightnessBand, CyanBand, MagentaBand, YellowBand, BlackBand, YCbCr_YBand, YCbCr_CbBand, YCbCr_CrBand, ContinuousPalette, // Note: values between PanBand and SAR_P_Band match additions done in // GDAL 3.10, except that the numeric values of the constant don't match GDAL ones PanBand, CoastalBand, RedEdgeBand, NIRBand, SWIRBand, MWIRBand, LWIRBand, TIRBand, OtherIRBand, SAR_Ka_Band, SAR_K_Band, SAR_Ku_Band, SAR_X_Band, SAR_C_Band, SAR_S_Band, SAR_L_Band, SAR_P_Band, }; enum class RasterLayerType { GrayOrUndefined, Palette, MultiBand, SingleBandColorData, }; enum class RasterDrawingStyle { Undefined, SingleBandGray, SingleBandPseudoColor, PalettedColor, PalettedSingleBandGray, PalettedSingleBandPseudoColor, PalettedMultiBandColor, MultiBandSingleBandGray, MultiBandSingleBandPseudoColor, MultiBandColor, SingleBandColorData, }; enum class RasterPyramidFormat { GeoTiff, Internal, Erdas }; enum class RasterBuildPyramidOption { No, Yes, CopyExisting }; enum class RasterIdentifyFormat { Undefined, Value, Text, Html, Feature, }; enum class RasterInterfaceCapability { NoCapabilities, Size, Create, Remove, BuildPyramids, Identify, IdentifyValue, IdentifyText, IdentifyHtml, IdentifyFeature, Prefetch, }; typedef QFlags RasterInterfaceCapabilities; enum class RasterProviderCapability { NoProviderCapabilities, ReadLayerMetadata, WriteLayerMetadata, ProviderHintBenefitsFromResampling, ProviderHintCanPerformProviderResampling, ReloadData, DpiDependentData, NativeRasterAttributeTable, BuildPyramids, }; typedef QFlags RasterProviderCapabilities; enum class ElevationMapCombineMethod { HighestElevation, NewerElevation, }; enum class BlendMode { Normal, Lighten, Screen, Dodge, Addition, Darken, Multiply, Burn, Overlay, SoftLight, HardLight, Difference, Subtract, Source, DestinationOver, Clear, Destination, SourceIn, DestinationIn, SourceOut, DestinationOut, SourceAtop, DestinationAtop, Xor, }; enum class SystemOfMeasurement { Unknown, Metric, Imperial, USCS, }; enum class MapToolUnit { Layer, Pixels, Project }; enum class UnitType { Distance, Area, Volume, Unknown, Temporal, }; enum class DistanceUnit { Meters, Kilometers, Feet, NauticalMiles, Yards, Miles, Degrees, Centimeters, Millimeters, Inches, ChainsInternational, ChainsBritishBenoit1895A, ChainsBritishBenoit1895B, ChainsBritishSears1922Truncated, ChainsBritishSears1922, ChainsClarkes, ChainsUSSurvey, FeetBritish1865, FeetBritish1936, FeetBritishBenoit1895A, FeetBritishBenoit1895B, FeetBritishSears1922Truncated, FeetBritishSears1922, FeetClarkes, FeetGoldCoast, FeetIndian, FeetIndian1937, FeetIndian1962, FeetIndian1975, FeetUSSurvey, LinksInternational, LinksBritishBenoit1895A, LinksBritishBenoit1895B, LinksBritishSears1922Truncated, LinksBritishSears1922, LinksClarkes, LinksUSSurvey, YardsBritishBenoit1895A, YardsBritishBenoit1895B, YardsBritishSears1922Truncated, YardsBritishSears1922, YardsClarkes, YardsIndian, YardsIndian1937, YardsIndian1962, YardsIndian1975, MilesUSSurvey, Fathoms, MetersGermanLegal, Unknown, }; enum class DistanceUnitType { Standard, Geographic, Unknown, }; enum class AreaUnit { SquareMeters, SquareKilometers, SquareFeet, SquareYards, SquareMiles, Hectares, Acres, SquareNauticalMiles, SquareDegrees, SquareCentimeters, SquareMillimeters, SquareInches, Unknown, }; enum class VolumeUnit { CubicMeters, CubicFeet, CubicYards, Barrel, CubicDecimeter, Liters, GallonUS, CubicInch, CubicCentimeter, CubicDegrees, Unknown, }; enum class AngleUnit { Degrees, Radians, Gon, MinutesOfArc, SecondsOfArc, Turn, MilliradiansSI, MilNATO, Unknown, }; enum class TemporalUnit { Milliseconds, Seconds, Minutes, Hours, Days, Weeks, Months, Years, Decades, Centuries, IrregularStep, Unknown }; enum class RenderUnit { Millimeters, MapUnits, Pixels, Percentage, Points, Inches, Unknown, MetersInMapUnits, }; enum class LayoutUnit { Millimeters, Centimeters, Meters, Inches, Feet, Points, Picas, Pixels }; enum class LayoutUnitType { PaperUnits, ScreenUnits }; enum class LayoutRenderFlag { Debug, OutlineOnly, Antialiasing, UseAdvancedEffects, ForceVectorOutput, HideCoverageLayer, DrawSelection, DisableTiledRasterLayerRenders, RenderLabelsByMapLayer, LosslessImageRendering, SynchronousLegendGraphics, AlwaysUseGlobalMasks, LimitCoverageLayerRenderToCurrentFeature, }; typedef QFlags LayoutRenderFlags; enum class PictureFormat { SVG, Raster, Unknown, }; enum class ScaleCalculationMethod { HorizontalTop, HorizontalMiddle, HorizontalBottom, HorizontalAverage, AtEquator, }; enum class ScaleBarAlignment { Left, Middle, Right, }; enum class ScaleBarSegmentSizeMode { Fixed, FitWidth }; enum class ScaleBarDistanceLabelVerticalPlacement { AboveSegment, BelowSegment, }; enum class ScaleBarDistanceLabelHorizontalPlacement { CenteredEdge, CenteredSegment, }; enum class InputControllerType { Map2D, Map3D }; enum class PostgresRelKind { NotSet, Unknown, OrdinaryTable, Index, Sequence, View, MaterializedView, CompositeType, ToastTable, ForeignTable, PartitionedTable, }; enum class DatabaseProviderConnectionCapability2 { SetFieldComment, SetFieldAlias, SetTableComment, }; typedef QFlags DatabaseProviderConnectionCapabilities2; enum class DatabaseProviderTableImportCapability { SetGeometryColumnName, SetPrimaryKeyName, }; typedef QFlags DatabaseProviderTableImportCapabilities; enum class ProviderStyleStorageCapability { SaveToDatabase, LoadFromDatabase, DeleteFromDatabase }; typedef QFlags ProviderStyleStorageCapabilities; enum class UserProfileSelectionPolicy { LastProfile, DefaultProfile, AskUser, }; enum class AttributeEditorType { Container, Field, Relation, QmlElement, HtmlElement, Action, TextElement, SpacerElement, Invalid, }; enum class AttributeEditorContainerType { GroupBox, Tab, Row, }; enum class AttributeFormLayout { AutoGenerated, DragAndDrop, UiFile }; enum class AttributeFormSuppression { Default, On, Off }; enum class AttributeFormPythonInitCodeSource { NoSource, File, Dialog, Environment }; enum class ExpressionType { Qgis, PointCloud, RasterCalculator, }; enum class FeatureSymbologyExport { NoSymbology, PerFeature, PerSymbolLayer }; enum class VectorTileProviderFlag { AlwaysUseTileMatrixSetFromProvider, }; typedef QFlags VectorTileProviderFlags; enum class VectorTileProviderCapability { ReadLayerMetadata, }; typedef QFlags VectorTileProviderCapabilities; enum class TileAvailability { Available, NotAvailable, AvailableNoChildren, UseLowerZoomLevelTile, }; enum class TiledSceneProviderCapability { ReadLayerMetadata, }; typedef QFlags TiledSceneProviderCapabilities; enum class TiledSceneBoundingVolumeType { Region, OrientedBox, Sphere, }; enum class TileRefinementProcess { Replacement, Additive, }; enum class TileChildrenAvailability { NoChildren, Available, NeedFetching, }; enum class TiledSceneRequestFlag { NoHierarchyFetch, }; typedef QFlags TiledSceneRequestFlags; enum class TiledSceneRendererFlag { RequiresTextures, ForceRasterRender, RendersTriangles, RendersLines, }; typedef QFlags TiledSceneRendererFlags; enum class GdalResampleAlgorithm { RA_NearestNeighbour, RA_Bilinear, RA_Cubic, RA_CubicSpline, RA_Lanczos, RA_Average, RA_Mode, RA_Max, RA_Min, RA_Median, RA_Q1, RA_Q3, }; enum class VsiHandlerType { Invalid, Archive, Network, Cloud, Memory, Other, }; enum class ZonalStatistic { Count, Sum, Mean, Median, StDev, Min, Max, Range, Minority, Majority, Variety, Variance, MinimumPoint, MaximumPoint, All, AllNumeric, Default, }; typedef QFlags ZonalStatistics; enum class ZonalStatisticResult { Success, LayerTypeWrong, LayerInvalid, RasterInvalid, RasterBandInvalid, FailedToCreateField, Canceled }; enum class Aggregate { Count, CountDistinct, CountMissing, Min, Max, Sum, Mean, Median, StDev, StDevSample, Range, Minority, Majority, FirstQuartile, ThirdQuartile, InterQuartileRange, StringMinimumLength, StringMaximumLength, StringConcatenate, GeometryCollect, ArrayAggregate, StringConcatenateUnique }; enum class Statistic { Count, CountMissing, Sum, Mean, Median, StDev, StDevSample, Min, Max, Range, Minority, Majority, Variety, FirstQuartile, ThirdQuartile, InterQuartileRange, First, Last, All }; typedef QFlags Statistics; enum class DateTimeStatistic { Count, CountDistinct, CountMissing, Min, Max, Range, All, }; typedef QFlags DateTimeStatistics; enum class StringStatistic { Count, CountDistinct, CountMissing, Min, Max, MinimumLength, MaximumLength, MeanLength, Minority, Majority, All, }; typedef QFlags StringStatistics; enum class RasterBandStatistic { NoStatistic, Min, Max, Range, Sum, Mean, StdDev, SumOfSquares, All }; typedef QFlags RasterBandStatistics; enum class SensorThingsEntity { Invalid, Thing, Location, HistoricalLocation, Datastream, Sensor, ObservedProperty, Observation, FeatureOfInterest, MultiDatastream, }; enum class ColorModel { Rgb, Cmyk, }; enum class DocumentationApi { PyQgis, PyQgisSearch, CppQgis, Qt, }; enum class DocumentationBrowser { DeveloperToolsPanel, SystemWebBrowser, }; enum class MouseHandlesAction { MoveItem, ResizeUp, ResizeDown, ResizeLeft, ResizeRight, ResizeLeftUp, ResizeRightUp, ResizeLeftDown, ResizeRightDown, RotateTopLeft, RotateTopRight, RotateBottomLeft, RotateBottomRight, SelectItem, NoAction }; enum class MeshRangeLimit { NotSet, MinimumMaximum, }; enum class MeshRangeExtent { WholeMesh, FixedCanvas, UpdatedCanvas, }; enum class PointCloudAccessType { Local, Remote }; enum class PointCloudZoomOutRenderBehavior { RenderExtents, RenderOverview, RenderOverviewAndExtents }; enum class SegmentCalculationMethod { Standard, Adaptive, AreaError, ConstantDensity }; enum class StacObjectType { Unknown, Catalog, Collection, Item, }; static const double DEFAULT_SEARCH_RADIUS_MM; static const float DEFAULT_MAPTOPIXEL_THRESHOLD; static const QColor DEFAULT_HIGHLIGHT_COLOR; static const double DEFAULT_HIGHLIGHT_BUFFER_MM; static const double DEFAULT_HIGHLIGHT_MIN_WIDTH_MM; static const double SCALE_PRECISION; static const double DEFAULT_Z_COORDINATE; static const double DEFAULT_M_COORDINATE; static const double UI_SCALE_FACTOR; static const double DEFAULT_SNAP_TOLERANCE; static const Qgis::MapToolUnit DEFAULT_SNAP_UNITS; static const int USER_CRS_START_ID; static const double DEFAULT_POINT_SIZE; static const double DEFAULT_LINE_WIDTH; static const double DEFAULT_SEGMENT_EPSILON; static QString defaultProjectScales(); %Docstring A string with default project scales. .. versionadded:: 3.12 %End static int geosVersionInt(); %Docstring GEOS version number linked .. versionadded:: 3.20 %End static int geosVersionMajor(); %Docstring GEOS Major version number linked .. versionadded:: 3.20 %End static int geosVersionMinor(); %Docstring GEOS Minor version number linked .. versionadded:: 3.20 %End static int geosVersionPatch(); %Docstring GEOS Patch version number linked .. versionadded:: 3.20 %End static QString geosVersion(); %Docstring GEOS string version linked .. versionadded:: 3.20 %End static bool hasQtWebkit(); %Docstring Returns ``True`` if the QGIS build contains QtWebkit. .. versionadded:: 4.0 %End static QString geoNone(); %Docstring Constant that holds the string representation for "No ellipse/No CRS". .. versionadded:: 3.44 %End static QString geographicCrsAuthId(); %Docstring Geographic coordinate system auth:id string for a default geographic CRS (EPSG:4326). .. versionadded:: 3.44 %End static QString geoWkt(); %Docstring WKT string that represents a geographic coord system .. deprecated:: 3.44 Will be removed in QGIS 4.0. %End static QString geoProj4(); %Docstring PROJ4 string that represents a geographic coord system. .. deprecated:: 3.44 Will be removed in QGIS 4.0. %End }; QFlags operator|(Qgis::AnnotationItemFlag f1, QFlags f2); QFlags operator|(Qgis::AnnotationItemGuiFlag f1, QFlags f2); QFlags operator|(Qgis::AuthConfigurationStorageCapability f1, QFlags f2); QFlags operator|(Qgis::BabelCommandFlag f1, QFlags f2); QFlags operator|(Qgis::BabelFormatCapability f1, QFlags f2); QFlags operator|(Qgis::BrowserItemCapability f1, QFlags f2); QFlags operator|(Qgis::CoordinateTransformationFlag f1, QFlags f2); QFlags operator|(Qgis::DatabaseProviderConnectionCapability2 f1, QFlags f2); QFlags operator|(Qgis::DatabaseProviderTableImportCapability f1, QFlags f2); QFlags operator|(Qgis::DataProviderFlag f1, QFlags f2); QFlags operator|(Qgis::FileOperationFlag f1, QFlags f2); QFlags operator|(Qgis::GeometryValidityFlag f1, QFlags f2); QFlags operator|(Qgis::GpsInformationComponent f1, QFlags f2); QFlags operator|(Qgis::HistoryProviderBackend f1, QFlags f2); QFlags operator|(Qgis::LabelingFlag f1, QFlags f2); QFlags operator|(Qgis::LabelLinePlacementFlag f1, QFlags f2); QFlags operator|(Qgis::LabelPolygonPlacementFlag f1, QFlags f2); QFlags operator|(Qgis::LayerTreeFilterFlag f1, QFlags f2); QFlags operator|(Qgis::LegendJsonRenderFlag f1, QFlags f2); QFlags operator|(Qgis::MapLayerActionFlag f1, QFlags f2); QFlags operator|(Qgis::MapLayerActionTarget f1, QFlags f2); QFlags operator|(Qgis::MapLayerProperty f1, QFlags f2); QFlags operator|(Qgis::MapLayerRendererFlag f1, QFlags f2); QFlags operator|(Qgis::LoadStyleFlag f1, QFlags f2); QFlags operator|(Qgis::MapSettingsFlag f1, QFlags f2); QFlags operator|(Qgis::MarkerLinePlacement f1, QFlags f2); QFlags operator|(Qgis::PlotToolFlag f1, QFlags f2); QFlags operator|(Qgis::ProfileGeneratorFlag f1, QFlags f2); QFlags operator|(Qgis::ProjectCapability f1, QFlags f2); QFlags operator|(Qgis::ProjectReadFlag f1, QFlags f2); QFlags operator|(Qgis::RasterRendererFlag f1, QFlags f2); QFlags operator|(Qgis::RasterRendererCapability f1, QFlags f2); QFlags operator|(Qgis::RasterTemporalCapabilityFlag f1, QFlags f2); QFlags operator|(Qgis::RelationshipCapability f1, QFlags f2); QFlags operator|(Qgis::RenderContextFlag f1, QFlags f2); QFlags operator|(Qgis::ScriptLanguageCapability f1, QFlags f2); QFlags operator|(Qgis::SelectionFlag f1, QFlags f2); QFlags operator|(Qgis::SettingsTreeNodeOption f1, QFlags f2); QFlags operator|(Qgis::SnappingType f1, QFlags f2); QFlags operator|(Qgis::SqlLayerDefinitionCapability f1, QFlags f2); QFlags operator|(Qgis::UriCleaningFlag f1, QFlags f2); QFlags operator|(Qgis::SublayerFlag f1, QFlags f2); QFlags operator|(Qgis::SublayerQueryFlag f1, QFlags f2); QFlags operator|(Qgis::FeatureRendererFlag f1, QFlags f2); QFlags operator|(Qgis::SymbolFlag f1, QFlags f2); QFlags operator|(Qgis::SymbolLayerFlag f1, QFlags f2); QFlags operator|(Qgis::SymbolLayerUserFlag f1, QFlags f2); QFlags operator|(Qgis::SymbolPreviewFlag f1, QFlags f2); QFlags operator|(Qgis::SymbolRenderHint f1, QFlags f2); QFlags operator|(Qgis::PaintEffectFlag f1, QFlags f2); QFlags operator|(Qgis::TextComponent f1, QFlags f2); QFlags operator|(Qgis::TextRendererFlag f1, QFlags f2); QFlags operator|(Qgis::TiledSceneProviderCapability f1, QFlags f2); QFlags operator|(Qgis::TiledSceneRendererFlag f1, QFlags f2); QFlags operator|(Qgis::FieldConfigurationFlag f1, QFlags f2); QFlags operator|(Qgis::LayerFilter f1, QFlags f2); QFlags operator|(Qgis::TiledSceneRequestFlag f1, QFlags f2); QFlags operator|(Qgis::VectorDataProviderAttributeEditCapability f1, QFlags f2); QFlags operator|(Qgis::VectorFileWriterCapability f1, QFlags f2); QFlags operator|(Qgis::VectorLayerTypeFlag f1, QFlags f2); QFlags operator|(Qgis::VectorTileProviderCapability f1, QFlags f2); QFlags operator|(Qgis::VectorTileProviderFlag f1, QFlags f2); QFlags operator|(Qgis::GeosCreationFlag f1, QFlags f2); QFlags operator|(Qgis::FeatureRequestFlag f1, QFlags f2); QFlags operator|(Qgis::ProcessingFeatureSourceDefinitionFlag f1, QFlags f2); QFlags operator|(Qgis::ZonalStatistic f1, QFlags f2); QFlags operator|(Qgis::Statistic f1, QFlags f2); QFlags operator|(Qgis::DateTimeStatistic f1, QFlags f2); QFlags operator|(Qgis::StringStatistic f1, QFlags f2); QFlags operator|(Qgis::RasterBandStatistic f1, QFlags f2); QFlags operator|(Qgis::RasterInterfaceCapability f1, QFlags f2); QFlags operator|(Qgis::RasterProviderCapability f1, QFlags f2); QFlags operator|(Qgis::ProcessingProviderFlag f1, QFlags f2); QFlags operator|(Qgis::ProcessingAlgorithmFlag f1, QFlags f2); QFlags operator|(Qgis::ProcessingAlgorithmDocumentationFlag f1, QFlags f2); QFlags operator|(Qgis::ProcessingFeatureSourceFlag f1, QFlags f2); QFlags operator|(Qgis::ProcessingParameterTypeFlag f1, QFlags f2); QFlags operator|(Qgis::ProcessingParameterFlag f1, QFlags f2); QFlags operator|(Qgis::DataItemProviderCapability f1, QFlags f2); QFlags operator|(Qgis::VectorRenderingSimplificationFlag f1, QFlags f2); QFlags operator|(Qgis::DataProviderReadFlag f1, QFlags f2); QFlags operator|(Qgis::VectorProviderCapability f1, QFlags f2); QFlags operator|(Qgis::MapCanvasFlag f1, QFlags f2); QFlags operator|(Qgis::LayoutRenderFlag f1, QFlags f2); QFlags operator|(Qgis::MapLayerLegendFlag f1, QFlags f2); uint qHash( const QVariant &variant ); %Docstring Hash for QVariant %End QString qgsDoubleToString( double a, int precision = 17 ); %Docstring Returns a string representation of a double :param a: double value :param precision: number of decimal places to retain %End bool qgsNanCompatibleEquals( double a, double b ); %Docstring Compare two doubles, treating nan values as equal :param a: first double :param b: second double .. versionadded:: 3.20 %End bool qgsDoubleNear( double a, double b, double epsilon = 4 * DBL_EPSILON ); %Docstring Compare two doubles (but allow some difference) :param a: first double :param b: second double :param epsilon: maximum difference allowable between doubles %End bool qgsFloatNear( float a, float b, float epsilon = 4 * FLT_EPSILON ); %Docstring Compare two floats (but allow some difference) :param a: first float :param b: second float :param epsilon: maximum difference allowable between floats %End bool qgsDoubleNearSig( double a, double b, int significantDigits = 10 ); %Docstring Compare two doubles using specified number of significant digits %End double qgsRound( double number, int places ); %Docstring Returns a double ``number``, rounded (as close as possible) to the specified number of ``places``. %End double qgsPermissiveToDouble( QString string, bool &ok ); %Docstring Converts a string to a double in a permissive way, e.g., allowing for incorrect numbers of digits between thousand separators :param string: string to convert :param ok: will be set to ``True`` if conversion was successful :return: string converted to double if possible .. seealso:: :py:func:`permissiveToInt` %End int qgsPermissiveToInt( QString string, bool &ok ); %Docstring Converts a string to an integer in a permissive way, e.g., allowing for incorrect numbers of digits between thousand separators :param string: string to convert :param ok: will be set to ``True`` if conversion was successful :return: string converted to int if possible .. seealso:: :py:func:`permissiveToDouble` %End qlonglong qgsPermissiveToLongLong( QString string, bool &ok ); %Docstring Converts a string to an qlonglong in a permissive way, e.g., allowing for incorrect numbers of digits between thousand separators :param string: string to convert :param ok: will be set to ``True`` if conversion was successful :return: string converted to int if possible .. seealso:: :py:func:`permissiveToInt` .. versionadded:: 3.4 %End int qgsVariantCompare( const QVariant &lhs, const QVariant &rhs, bool strictTypeCheck = false ); %Docstring Compares two QVariant values. :return: < 0 if lhs < rhs, > 0 if lhs > rhs, or 0 if lhs == rhs Useful for sorting lists of variants, correctly handling sorting of the various QVariant data types (such as strings, numeric values, dates and times) Invalid < NULL < Values Since QGIS 4.0 the ``strictTypeCheck`` argument can be used to specify that variants of different types should be compared using their userType ID only, and not attempt to check the actual variant value. .. seealso:: :py:func:`qgsVariantLessThan` .. seealso:: :py:func:`qgsVariantGreaterThan` .. versionadded:: 3.44 %End bool qgsVariantLessThan( const QVariant &lhs, const QVariant &rhs ); %Docstring Compares two QVariant values and returns whether the first is less than the second. Useful for sorting lists of variants, correctly handling sorting of the various QVariant data types (such as strings, numeric values, dates and times) Invalid < NULL < Values .. seealso:: :py:func:`qgsVariantGreaterThan` .. seealso:: :py:func:`qgsVariantCompare` %End bool qgsVariantEqual( const QVariant &lhs, const QVariant &rhs ); %Docstring Compares two QVariant values and returns whether they are equal, two NULL values are always treated as equal and 0 is not treated as equal with NULL :param lhs: first value :param rhs: second value :return: ``True`` if values are equal %End bool qgsVariantGreaterThan( const QVariant &lhs, const QVariant &rhs ); %Docstring Compares two QVariant values and returns whether the first is greater than the second. Useful for sorting lists of variants, correctly handling sorting of the various QVariant data types (such as strings, numeric values, dates and times) .. seealso:: :py:func:`qgsVariantLessThan` .. seealso:: :py:func:`qgsVariantCompare` %End bool operator> ( const QVariant &v1, const QVariant &v2 ); bool operator< ( const QVariant &v1, const QVariant &v2 ); QString qgsVsiPrefix( const QString &path ) /Deprecated="Since 3.44. Use QgsGdalUtils.vsiPrefixForPath() instead."/; %Docstring Returns a the vsi prefix which corresponds to a file ``path``, or an empty string if the path is not associated with a vsi prefix. .. deprecated:: 3.44 Use :py:func:`QgsGdalUtils.vsiPrefixForPath()` instead. %End const long GEOSRID; const long GEOCRS_ID; const long GEO_EPSG_CRS_ID; typedef unsigned long long qgssize; /************************************************************************ * This file has been generated automatically from * * * * src/core/qgis.h * * * * Do not edit manually ! Edit header and run scripts/sipify.py again * ************************************************************************/