-
-
Notifications
You must be signed in to change notification settings - Fork 3k
/
qgsvectorlayer.h
2035 lines (1747 loc) · 77.2 KB
/
qgsvectorlayer.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/***************************************************************************
qgsvectorlayer.h - description
-------------------
begin : Oct 29, 2003
copyright : (C) 2003 by Gary E.Sherman
email : sherman at mrcc.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef QGSVECTORLAYER_H
#define QGSVECTORLAYER_H
#include <QMap>
#include <QSet>
#include <QList>
#include <QStringList>
#include <QFont>
#include <QMutex>
#include "qgis.h"
#include "qgsmaplayer.h"
#include "qgsfeature.h"
#include "qgsfeaturerequest.h"
#include "qgseditorwidgetconfig.h"
#include "qgsfields.h"
#include "qgssnapper.h"
#include "qgsvectorsimplifymethod.h"
#include "qgseditformconfig.h"
#include "qgsattributetableconfig.h"
#include "qgsaggregatecalculator.h"
#include "qgsfeatureiterator.h"
#include "qgsexpressioncontextgenerator.h"
class QPainter;
class QImage;
class QgsAbstractGeometrySimplifier;
class QgsActionManager;
class QgsConditionalLayerStyles;
class QgsCoordinateTransform;
class QgsCurve;
class QgsDiagramLayerSettings;
class QgsDiagramRenderer;
class QgsEditorWidgetWrapper;
class QgsExpressionFieldBuffer;
class QgsFeatureRenderer;
class QgsGeometry;
class QgsGeometryCache;
class QgsGeometryVertexIndex;
class QgsMapToPixel;
class QgsRectangle;
class QgsRectangle;
class QgsRelation;
class QgsRelationManager;
class QgsSingleSymbolRenderer;
class QgsSymbol;
class QgsVectorDataProvider;
class QgsVectorLayerEditBuffer;
class QgsVectorLayerJoinBuffer;
class QgsAbstractVectorLayerLabeling;
class QgsPointV2;
typedef QList<int> QgsAttributeList;
typedef QSet<int> QgsAttributeIds;
typedef QList<QgsPointV2> QgsPointSequence;
struct CORE_EXPORT QgsVectorJoinInfo
{
QgsVectorJoinInfo()
: memoryCache( false )
, cacheDirty( true )
, targetFieldIndex( -1 )
, joinFieldIndex( -1 )
{}
//! Join field in the target layer
QString targetFieldName;
//! Source layer
QString joinLayerId;
//! Join field in the source layer
QString joinFieldName;
//! True if the join is cached in virtual memory
bool memoryCache;
//! True if the cached join attributes need to be updated
bool cacheDirty;
/** Cache for joined attributes to provide fast lookup (size is 0 if no memory caching)
* @note not available in python bindings
*/
QHash< QString, QgsAttributes> cachedAttributes;
//! Join field index in the target layer. For backward compatibility with 1.x (x>=7)
int targetFieldIndex;
//! Join field index in the source layer. For backward compatibility with 1.x (x>=7)
int joinFieldIndex;
/** An optional prefix. If it is a Null string "{layername}_" will be used
* @note Added in 2.8
*/
QString prefix;
bool operator==( const QgsVectorJoinInfo& other ) const
{
return targetFieldName == other.targetFieldName &&
joinLayerId == other.joinLayerId &&
joinFieldName == other.joinFieldName &&
joinFieldsSubset == other.joinFieldsSubset &&
memoryCache == other.memoryCache &&
prefix == other.prefix;
}
/** Set subset of fields to be used from joined layer. Takes ownership of the passed pointer. Null pointer tells to use all fields.
@note added in 2.6 */
void setJoinFieldNamesSubset( QStringList* fieldNamesSubset ) { joinFieldsSubset = QSharedPointer<QStringList>( fieldNamesSubset ); }
/** Get subset of fields to be used from joined layer. All fields will be used if null is returned.
@note added in 2.6 */
QStringList* joinFieldNamesSubset() const { return joinFieldsSubset.data(); }
protected:
//! Subset of fields to use from joined layer. null = use all fields
QSharedPointer<QStringList> joinFieldsSubset;
};
/** \ingroup core
* Represents a vector layer which manages a vector based data sets.
*
* The QgsVectorLayer is instantiated by specifying the name of a data provider,
* such as postgres or wfs, and url defining the specific data set to connect to.
* The vector layer constructor in turn instantiates a QgsVectorDataProvider subclass
* corresponding to the provider type, and passes it the url. The data provider
* connects to the data source.
*
* The QgsVectorLayer provides a common interface to the different data types. It also
* manages editing transactions.
*
* Sample usage of the QgsVectorLayer class:
*
* \code
* QString uri = "point?crs=epsg:4326&field=id:integer";
* QgsVectorLayer *scratchLayer = new QgsVectorLayer(uri, "Scratch point layer", "memory");
* \endcode
*
* The main data providers supported by QGIS are listed below.
*
* \section providers Vector data providers
*
* \subsection memory Memory data providerType (memory)
*
* The memory data provider is used to construct in memory data, for example scratch
* data or data generated from spatial operations such as contouring. There is no
* inherent persistent storage of the data. The data source uri is constructed. The
* url specifies the geometry type ("point", "linestring", "polygon",
* "multipoint","multilinestring","multipolygon"), optionally followed by url parameters
* as follows:
*
* - crs=definition
* Defines the coordinate reference system to use for the layer.
* definition is any string accepted by QgsCoordinateReferenceSystem::createFromString()
*
* - index=yes
* Specifies that the layer will be constructed with a spatial index
*
* - field=name:type(length,precision)
* Defines an attribute of the layer. Multiple field parameters can be added
* to the data provider definition. type is one of "integer", "double", "string".
*
* An example url is "Point?crs=epsg:4326&field=id:integer&field=name:string(20)&index=yes"
*
* \subsection ogr OGR data provider (ogr)
*
* Accesses data using the OGR drivers (http://www.gdal.org/ogr/ogr_formats.html). The url
* is the OGR connection string. A wide variety of data formats can be accessed using this
* driver, including file based formats used by many GIS systems, database formats, and
* web services. Some of these formats are also supported by custom data providers listed
* below.
*
* \subsection spatialite Spatialite data provider (spatialite)
*
* Access data in a spatialite database. The url defines the connection parameters, table,
* geometry column, and other attributes. The url can be constructed using the
* QgsDataSourceUri class.
*
* \subsection postgres Postgresql data provider (postgres)
*
* Connects to a postgresql database. The url defines the connection parameters, table,
* geometry column, and other attributes. The url can be constructed using the
* QgsDataSourceUri class.
*
* \subsection mssql Microsoft SQL server data provider (mssql)
*
* Connects to a Microsoft SQL server database. The url defines the connection parameters, table,
* geometry column, and other attributes. The url can be constructed using the
* QgsDataSourceUri class.
*
* \subsection wfs WFS (web feature service) data provider (wfs)
*
* Used to access data provided by a web feature service.
*
* The url can be a HTTP url to a WFS server (legacy, e.g. http://foobar/wfs?TYPENAME=xxx&SRSNAME=yyy[&FILTER=zzz]), or,
* starting with QGIS 2.16, a URI constructed using the QgsDataSourceUri class with the following parameters :
* - url=string (mandatory): HTTP url to a WFS server endpoint. e.g http://foobar/wfs
* - typename=string (mandatory): WFS typename
* - srsname=string (recommended): SRS like 'EPSG:XXXX'
* - username=string
* - password=string
* - authcfg=string
* - version=auto/1.0.0/1.1.0/2.0.0
* -sql=string: full SELECT SQL statement with optional WHERE, ORDER BY and possibly with JOIN if supported on server
* - filter=string: QGIS expression or OGC/FES filter
* - restrictToRequestBBOX=1: to download only features in the view extent (or more generally
* in the bounding box of the feature iterator)
* - maxNumFeatures=number
* - IgnoreAxisOrientation=1: to ignore EPSG axis order for WFS 1.1 or 2.0
* - InvertAxisOrientation=1: to invert axis order
* - hideDownloadProgressDialog=1: to hide the download progress dialog
*
* The ‘FILTER’ query string parameter can be used to filter
* the WFS feature type. The ‘FILTER’ key value can either be a QGIS expression
* or an OGC XML filter. If the value is set to a QGIS expression the driver will
* turn it into OGC XML filter before passing it to the WFS server. Beware the
* QGIS expression filter only supports” =, !=, <, >, <=, >=, AND, OR, NOT, LIKE, IS NULL”
* attribute operators, “BBOX, Disjoint, Intersects, Touches, Crosses, Contains, Overlaps, Within”
* spatial binary operators and the QGIS local “geomFromWKT, geomFromGML”
* geometry constructor functions.
*
* Also note:
*
* - You can use various functions available in the QGIS Expression list,
* however the function must exist server side and have the same name and arguments to work.
*
* - Use the special $geometry parameter to provide the layer geometry column as input
* into the spatial binary operators e.g intersects($geometry, geomFromWKT('POINT (5 6)'))
*
* \subsection delimitedtext Delimited text file data provider (delimitedtext)
*
* Accesses data in a delimited text file, for example CSV files generated by
* spreadsheets. The contents of the file are split into columns based on specified
* delimiter characters. Each record may be represented spatially either by an
* X and Y coordinate column, or by a WKT (well known text) formatted columns.
*
* The url defines the filename, the formatting options (how the
* text in the file is divided into data fields, and which fields contain the
* X,Y coordinates or WKT text definition. The options are specified as url query
* items.
*
* At its simplest the url can just be the filename, in which case it will be loaded
* as a CSV formatted file.
*
* The url may include the following items:
*
* - encoding=UTF-8
*
* Defines the character encoding in the file. The default is UTF-8. To use
* the default encoding for the operating system use "System".
*
* - type=(csv|regexp|whitespace|plain)
*
* Defines the algorithm used to split records into columns. Records are
* defined by new lines, except for csv format files for which quoted fields
* may span multiple records. The default type is csv.
*
* - "csv" splits the file based on three sets of characters:
* delimiter characters, quote characters,
* and escape characters. Delimiter characters mark the end
* of a field. Quote characters enclose a field which can contain
* delimiter characters, and newlines. Escape characters cause the
* following character to be treated literally (including delimiter,
* quote, and newline characters). Escape and quote characters must
* be different from delimiter characters. Escape characters that are
* also quote characters are treated specially - they can only
* escape themselves within quotes. Elsewhere they are treated as
* quote characters. The defaults for delimiter, quote, and escape
* are ',', '"', '"'.
* - "regexp" splits each record using a regular expression (see QRegExp
* documentation for details).
* - "whitespace" splits each record based on whitespace (on or more whitespace
* characters. Leading whitespace in the record is ignored.
* - "plain" is provided for backwards compatibility. It is equivalent to
* CSV except that the default quote characters are single and double quotes,
* and there is no escape characters.
*
* - delimiter=characters
*
* Defines the delimiter characters used for csv and plain type files, or the
* regular expression for regexp type files. It is a literal string of characters
* except that "\t" may be used to represent a tab character.
*
* - quote=characters
*
* Defines the characters that are used as quote characters for csv and plain type
* files.
*
* - escape=characters
*
* Defines the characters used to escape delimiter, quote, and newline characters.
*
* - skipLines=n
*
* Defines the number of lines to ignore at the beginning of the file (default 0)
*
* - useHeader=(yes|no)
*
* Defines whether the first record in the file (after skipped lines) contains
* column names (default yes)
*
* - trimFields=(yes|no)
*
* If yes then leading and trailing whitespace will be removed from fields
*
* - skipEmptyFields=(yes|no)
*
* If yes then empty fields will be discarded (eqivalent to concatenating consecutive
* delimiters)
*
* - maxFields=#
*
* Specifies the maximum number of fields to load for each record. Additional
* fields will be discarded. Default is 0 - load all fields.
*
* - decimalPoint=c
*
* Defines a character that is used as a decimal point in the numeric columns
* The default is '.'.
*
* - xField=column yField=column
*
* Defines the name of the columns holding the x and y coordinates for XY point geometries.
* If the useHeader is no (ie there are no column names), then this is the column
* number (with the first column as 1).
*
* - xyDms=(yes|no)
*
* If yes then the X and Y coordinates are interpreted as
* degrees/minutes/seconds format (fairly permissively),
* or degree/minutes format.
*
* - wktField=column
*
* Defines the name of the columns holding the WKT geometry definition for WKT geometries.
* If the useHeader is no (ie there are no column names), then this is the column
* number (with the first column as 1).
*
* - geomType=(point|line|polygon|none)
*
* Defines the geometry type for WKT type geometries. QGIS will only display one
* type of geometry for the layer - any others will be ignored when the file is
* loaded. By default the provider uses the type of the first geometry in the file.
* Use geomType to override this type.
*
* geomType can also be set to none, in which case the layer is loaded without
* geometries.
*
* - subset=expression
*
* Defines an expression that will identify a subset of records to display
*
* - crs=crsstring
*
* Defines the coordinate reference system used for the layer. This can be
* any string accepted by QgsCoordinateReferenceSystem::createFromString()
*
* -subsetIndex=(yes|no)
*
* Determines whether the provider generates an index to improve the efficiency
* of subsets. The default is yes
*
* -spatialIndex=(yes|no)
*
* Determines whether the provider generates a spatial index. The default is no.
*
* -watchFile=(yes|no)
*
* Defines whether the file will be monitored for changes. The default is
* to monitor for changes.
*
* - quiet
*
* Errors encountered loading the file will not be reported in a user dialog if
* quiet is included (They will still be shown in the output log).
*
* \subsection gpx GPX data provider (gpx)
*
* Provider reads tracks, routes, and waypoints from a GPX file. The url
* defines the name of the file, and the type of data to retrieve from it
* ("track", "route", or "waypoint").
*
* An example url is "/home/user/data/holiday.gpx?type=route"
*
* \subsection grass Grass data provider (grass)
*
* Provider to display vector data in a GRASS GIS layer.
*
* TODO QGIS3: Remove virtual from non-inherited methods (like isModified)
*/
class CORE_EXPORT QgsVectorLayer : public QgsMapLayer, public QgsExpressionContextGenerator
{
Q_OBJECT
Q_PROPERTY( QString displayExpression READ displayExpression WRITE setDisplayExpression NOTIFY displayExpressionChanged )
Q_PROPERTY( QString mapTipTemplate READ mapTipTemplate WRITE setMapTipTemplate NOTIFY mapTipTemplateChanged )
Q_PROPERTY( QgsEditFormConfig editFormConfig READ editFormConfig WRITE setEditFormConfig NOTIFY editFormConfigChanged )
Q_PROPERTY( bool readOnly READ isReadOnly WRITE setReadOnly NOTIFY readOnlyChanged )
public:
//! Result of an edit operation
enum EditResult
{
Success = 0, //!< Edit operation was successful
EmptyGeometry = 1, //!< Edit operation resulted in an empty geometry
EditFailed = 2, //!< Edit operation failed
FetchFeatureFailed = 3, //!< Unable to fetch requested feature
InvalidLayer = 4, //!< Edit failed due to invalid layer
};
//! Selection behaviour
enum SelectBehaviour
{
SetSelection, //!< Set selection, removing any existing selection
AddToSelection, //!< Add selection to current selection
IntersectSelection, //!< Modify current selection to include only select features which match
RemoveFromSelection, //!< Remove from current selection
};
/** Constructor - creates a vector layer
*
* The QgsVectorLayer is constructed by instantiating a data provider. The provider
* interprets the supplied path (url) of the data source to connect to and access the
* data.
*
* @param path The path or url of the parameter. Typically this encodes
* parameters used by the data provider as url query items.
* @param baseName The name used to represent the layer in the legend
* @param providerLib The name of the data provider, eg "memory", "postgres"
* @param loadDefaultStyleFlag whether to load the default style
*
*/
QgsVectorLayer( const QString& path = QString::null, const QString& baseName = QString::null,
const QString& providerLib = QString::null, bool loadDefaultStyleFlag = true );
//! Destructor
virtual ~QgsVectorLayer();
//! Returns the permanent storage type for this layer as a friendly name.
QString storageType() const;
//! Capabilities for this layer in a friendly format.
QString capabilitiesString() const;
//! Returns a comment for the data in the layer
QString dataComment() const;
/**
* This is a shorthand for accessing the displayExpression if it is a simple field.
* If the displayExpression is more complex than a simple field, a null string will
* be returned.
*
* @see displayExpression
*/
QString displayField() const;
/** Set the preview expression, used to create a human readable preview string.
* Used e.g. in the attribute table feature list. Uses { @link QgsExpression }.
*
* @param displayExpression The expression which will be used to preview features
* for this layer
*/
void setDisplayExpression( const QString& displayExpression );
/**
* Get the preview expression, used to create a human readable preview string.
* Uses { @link QgsExpression }
*
* @return The expression which will be used to preview features for this layer
*/
QString displayExpression() const;
//! Returns the data provider
QgsVectorDataProvider* dataProvider();
/** Returns the data provider in a const-correct manner
* @note not available in python bindings
*/
const QgsVectorDataProvider* dataProvider() const;
//! Sets the textencoding of the data provider
void setProviderEncoding( const QString& encoding );
//! Setup the coordinate system transformation for the layer
void setCoordinateSystem();
/** Joins another vector layer to this layer
@param joinInfo join object containing join layer id, target and source field
@note since 2.6 returns bool indicating whether the join can be added */
bool addJoin( const QgsVectorJoinInfo& joinInfo );
/** Removes a vector layer join
@returns true if join was found and successfully removed */
bool removeJoin( const QString& joinLayerId );
/**
* Acccessor to the join buffer object
* @note added 2.14.7
*/
QgsVectorLayerJoinBuffer* joinBuffer() { return mJoinBuffer; }
const QList<QgsVectorJoinInfo> vectorJoins() const;
/**
* Sets the list of dependencies.
* @see dependencies()
*
* @param layers set of QgsMapLayerDependency. Only user-defined dependencies will be added
* @returns false if a dependency cycle has been detected
* @note added in QGIS 3.0
*/
virtual bool setDependencies( const QSet<QgsMapLayerDependency>& layers ) override;
/**
* Gets the list of dependencies. This includes data dependencies set by the user (@see setDataDependencies)
* as well as dependencies given by the provider
*
* @returns a set of QgsMapLayerDependency
* @note added in QGIS 3.0
*/
virtual QSet<QgsMapLayerDependency> dependencies() const override;
/**
* Add a new field which is calculated by the expression specified
*
* @param exp The expression which calculates the field
* @param fld The field to calculate
*
* @return The index of the new field
*
* @note added in 2.6, return value added in 2.9
*/
int addExpressionField( const QString& exp, const QgsField& fld );
/**
* Remove an expression field
*
* @param index The index of the field
*
* @note added in 2.6
*/
void removeExpressionField( int index );
/**
* Returns the expression used for a given expression field
*
* @param index An index of an epxression based (virtual) field
*
* @return The expression for the field at index
*
* @note added in 2.9
*/
QString expressionField( int index ) const;
/**
* Changes the expression used to define an expression based (virtual) field
*
* @param index The index of the expression to change
*
* @param exp The new expression to set
*
* @note added in 2.9
*/
void updateExpressionField( int index, const QString& exp );
/**
* Get all layer actions defined on this layer.
*
* The pointer which is returned directly points to the actions object
* which is used by the layer, so any changes are immediately applied.
*/
QgsActionManager* actions() { return mActions; }
/**
* The number of features that are selected in this layer
*
* @return See description
*/
int selectedFeatureCount() const;
/**
* Select features found within the search rectangle (in layer's coordinates)
* @param rect search rectangle
* @param behaviour selection type, allows adding to current selection, removing
* from selection, etc.
* @see invertSelectionInRectangle(QgsRectangle & rect)
* @see selectByExpression()
* @see selectByIds()
*/
void selectByRect( QgsRectangle & rect, SelectBehaviour behaviour = SetSelection );
/** Select matching features using an expression.
* @param expression expression to evaluate to select features
* @param behaviour selection type, allows adding to current selection, removing
* from selection, etc.
* @note added in QGIS 2.16
* @see selectByRect()
* @see selectByIds()
*/
void selectByExpression( const QString& expression, SelectBehaviour behaviour = SetSelection );
/** Select matching features using a list of feature IDs. Will emit the
* selectionChanged() signal with the clearAndSelect flag set.
* @param ids feature IDs to select
* @param behaviour selection type, allows adding to current selection, removing
* from selection, etc.
* @note added in QGIS 2.16
* @see selectByRect()
* @see selectByExpression()
*/
void selectByIds( const QgsFeatureIds &ids, SelectBehaviour behaviour = SetSelection );
/**
* Modifies the current selection on this layer
*
* @param selectIds Select these ids
* @param deselectIds Deselect these ids
*
* @see select(QgsFeatureIds)
* @see select(QgsFeatureId)
* @see deselect(QgsFeatureIds)
* @see deselect(QgsFeatureId)
* @see selectByExpression()
*/
void modifySelection( const QgsFeatureIds& selectIds, const QgsFeatureIds &deselectIds );
//! Select not selected features and deselect selected ones
void invertSelection();
//! Select all the features
void selectAll();
//! Get all feature Ids
QgsFeatureIds allFeatureIds() const;
/**
* Invert selection of features found within the search rectangle (in layer's coordinates)
*
* @param rect The rectangle in which the selection of features will be inverted
*
* @see invertSelection()
*/
void invertSelectionInRectangle( QgsRectangle & rect );
/**
* Get a copy of the user-selected features
*
* @return A list of { @link QgsFeature } 's
*
* @see selectedFeaturesIds()
* @see selectedFeaturesIterator() which is more memory friendly when handling large selections
*/
QgsFeatureList selectedFeatures() const;
/**
* Get an iterator of the selected features
*
* @param request You may specify a request, e.g. to limit the set of requested attributes.
* Any filter on the request will be discarded.
*
* @return Iterator over the selected features
*
* @see selectedFeaturesIds()
* @see selectedFeatures()
*/
QgsFeatureIterator selectedFeaturesIterator( QgsFeatureRequest request = QgsFeatureRequest() ) const;
/**
* Return reference to identifiers of selected features
*
* @return A list of { @link QgsFeatureId } 's
* @see selectedFeatures()
*/
const QgsFeatureIds &selectedFeaturesIds() const;
//! Returns the bounding box of the selected features. If there is no selection, QgsRectangle(0,0,0,0) is returned
QgsRectangle boundingBoxOfSelected() const;
/** Returns whether the layer contains labels which are enabled and should be drawn.
* @return true if layer contains enabled labels
* @note added in QGIS 2.9
*/
bool labelsEnabled() const;
/** Returns whether the layer contains diagrams which are enabled and should be drawn.
* @return true if layer contains enabled diagrams
* @note added in QGIS 2.9
*/
bool diagramsEnabled() const;
//! Sets diagram rendering object (takes ownership)
void setDiagramRenderer( QgsDiagramRenderer* r );
const QgsDiagramRenderer* diagramRenderer() const { return mDiagramRenderer; }
void setDiagramLayerSettings( const QgsDiagramLayerSettings& s );
const QgsDiagramLayerSettings *diagramLayerSettings() const { return mDiagramLayerSettings; }
//! Return renderer.
QgsFeatureRenderer* renderer() { return mRenderer; }
/** Return const renderer.
* @note not available in python bindings
*/
const QgsFeatureRenderer* renderer() const { return mRenderer; }
/**
* Set renderer which will be invoked to represent this layer.
* Ownership is transferred.
*/
void setRenderer( QgsFeatureRenderer* r );
//! Returns point, line or polygon
QgsWkbTypes::GeometryType geometryType() const;
//! Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeometry
bool hasGeometryType() const;
//! Returns the WKBType or WKBUnknown in case of error
QgsWkbTypes::Type wkbType() const;
//! Return the provider type for this layer
QString providerType() const;
/** Reads vector layer specific state from project file Dom node.
* @note Called by QgsMapLayer::readXml().
*/
virtual bool readXml( const QDomNode& layer_node ) override;
/** Write vector layer specific state to project file Dom node.
* @note Called by QgsMapLayer::writeXml().
*/
virtual bool writeXml( QDomNode & layer_node, QDomDocument & doc ) const override;
/**
* Save named and sld style of the layer to the style table in the db.
* @param name
* @param description
* @param useAsDefault
* @param uiFileContent
* @param msgError
*/
virtual void saveStyleToDatabase( const QString& name, const QString& description,
bool useAsDefault, const QString& uiFileContent,
QString &msgError );
/**
* Lists all the style in db split into related to the layer and not related to
* @param ids the list in which will be stored the style db ids
* @param names the list in which will be stored the style names
* @param descriptions the list in which will be stored the style descriptions
* @param msgError
* @return the number of styles related to current layer
*/
virtual int listStylesInDatabase( QStringList &ids, QStringList &names,
QStringList &descriptions, QString &msgError );
/**
* Will return the named style corresponding to style id provided
*/
virtual QString getStyleFromDatabase( const QString& styleId, QString &msgError );
/**
* Load a named style from file/local db/datasource db
* @param theURI the URI of the style or the URI of the layer
* @param theResultFlag will be set to true if a named style is correctly loaded
* @param loadFromLocalDb if true forces to load from local db instead of datasource one
*/
virtual QString loadNamedStyle( const QString &theURI, bool &theResultFlag, bool loadFromLocalDb );
/**
* Calls loadNamedStyle( theURI, theResultFlag, false );
* Retained for backward compatibility
*/
virtual QString loadNamedStyle( const QString &theURI, bool &theResultFlag ) override;
/** Read the symbology for the current layer from the Dom node supplied.
* @param node node that will contain the symbology definition for this layer.
* @param errorMessage reference to string that will be updated with any error messages
* @return true in case of success.
*/
bool readSymbology( const QDomNode& node, QString& errorMessage ) override;
/** Read the style for the current layer from the Dom node supplied.
* @param node node that will contain the style definition for this layer.
* @param errorMessage reference to string that will be updated with any error messages
* @return true in case of success.
*/
bool readStyle( const QDomNode& node, QString& errorMessage ) override;
/** Write the symbology for the layer into the docment provided.
* @param node the node that will have the style element added to it.
* @param doc the document that will have the QDomNode added.
* @param errorMessage reference to string that will be updated with any error messages
* @return true in case of success.
*/
bool writeSymbology( QDomNode& node, QDomDocument& doc, QString& errorMessage ) const override;
/** Write just the style information for the layer into the document
* @param node the node that will have the style element added to it.
* @param doc the document that will have the QDomNode added.
* @param errorMessage reference to string that will be updated with any error messages
* @return true in case of success.
*/
bool writeStyle( QDomNode& node, QDomDocument& doc, QString& errorMessage ) const override;
/**
* Writes the symbology of the layer into the document provided in SLD 1.1 format
* @param node the node that will have the style element added to it.
* @param doc the document that will have the QDomNode added.
* @param errorMessage reference to string that will be updated with any error messages
* @param props a open ended set of properties that can drive/inform the SLD encoding
* @return true in case of success
*/
bool writeSld( QDomNode& node, QDomDocument& doc, QString& errorMessage, const QgsStringMap &props = QgsStringMap() ) const;
bool readSld( const QDomNode& node, QString& errorMessage ) override;
/**
* Number of features rendered with specified symbol. Features must be first
* calculated by countSymbolFeatures()
* @param symbol the symbol
* @return number of features rendered by symbol or -1 if failed or counts are not available
*/
long featureCount( QgsSymbol* symbol ) const;
/**
* Update the data source of the layer. The layer's renderer and legend will be preserved only
* if the geometry type of the new data source matches the current geometry type of the layer.
* @param dataSource new layer data source
* @param baseName base name of the layer
* @param provider provider string
* @param loadDefaultStyleFlag set to true to reset the layer's style to the default for the
* data source
* @note added in QGIS 2.10
*/
void setDataSource( const QString& dataSource, const QString& baseName, const QString& provider, bool loadDefaultStyleFlag = false );
/**
* Count features for symbols. Feature counts may be get by featureCount( QgsSymbol*).
* @param showProgress show progress dialog
* @return true if calculated, false if failed or was canceled by user
*/
bool countSymbolFeatures( bool showProgress = true );
/**
* Set the string (typically sql) used to define a subset of the layer
* @param subset The subset string. This may be the where clause of a sql statement
* or other defintion string specific to the underlying dataprovider
* and data store.
* @return true, when setting the subset string was successful, false otherwise
*/
virtual bool setSubsetString( const QString& subset );
/**
* Get the string (typically sql) used to define a subset of the layer
* @return The subset string or QString::null if not implemented by the provider
*/
virtual QString subsetString() const;
/**
* Query the layer for features specified in request.
* @param request feature request describing parameters of features to return
* @returns iterator for matching features from provider
*/
QgsFeatureIterator getFeatures( const QgsFeatureRequest& request = QgsFeatureRequest() ) const;
/**
* Query the layer for features matching a given expression.
*/
inline QgsFeatureIterator getFeatures( const QString& expression )
{
return getFeatures( QgsFeatureRequest( expression ) );
}
/**
* Query the layer for the feature with the given id.
* If there is no such feature, the returned feature will be invalid.
*/
inline QgsFeature getFeature( QgsFeatureId fid )
{
QgsFeature feature;
getFeatures( QgsFeatureRequest( fid ) ).nextFeature( feature );
return feature;
}
/**
* Query the layer for the features with the given ids.
*/
inline QgsFeatureIterator getFeatures( const QgsFeatureIds& fids )
{
return getFeatures( QgsFeatureRequest( fids ) );
}
/**
* Query the layer for the features which intersect the specified rectangle.
*/
inline QgsFeatureIterator getFeatures( const QgsRectangle& rectangle )
{
return getFeatures( QgsFeatureRequest( rectangle ) );
}
/** Adds a feature
@param feature feature to add
@param alsoUpdateExtent If True, will also go to the effort of e.g. updating the extents.
@return True in case of success and False in case of error
*/
bool addFeature( QgsFeature& feature, bool alsoUpdateExtent = true );
/** Updates an existing feature. This method needs to query the datasource
on every call. Consider using {@link changeAttributeValue()} or
{@link changeGeometry()} instead.
@param f Feature to update
@return True in case of success and False in case of error
*/
bool updateFeature( QgsFeature &f );
/** Insert a new vertex before the given vertex number,
* in the given ring, item (first number is index 0), and feature
* Not meaningful for Point geometries
*/
bool insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex );
/** Moves the vertex at the given position number,
* ring and item (first number is index 0), and feature
* to the given coordinates
*/
bool moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex );
/** Moves the vertex at the given position number,
* ring and item (first number is index 0), and feature
* to the given coordinates
* @note available in python as moveVertexV2
*/
bool moveVertex( const QgsPointV2& p, QgsFeatureId atFeatureId, int atVertex );
/** Deletes a vertex from a feature.
* @param featureId ID of feature to remove vertex from
* @param vertex index of vertex to delete
* @note added in QGIS 2.14
*/
EditResult deleteVertex( QgsFeatureId featureId, int vertex );
/** Deletes the selected features
* @return true in case of success and false otherwise
*/
bool deleteSelectedFeatures( int *deletedCount = nullptr );
/** Adds a ring to polygon/multipolygon features
* @param ring ring to add
* @param featureId if specified, feature ID for feature ring was added to will be stored in this parameter
* @return
* 0 in case of success,
* 1 problem with feature type,
* 2 ring not closed,
* 3 ring not valid,
* 4 ring crosses existing rings,
* 5 no feature found where ring can be inserted
* 6 layer not editable
*/
// TODO QGIS 3.0 returns an enum instead of a magic constant
int addRing( const QList<QgsPoint>& ring, QgsFeatureId* featureId = nullptr );
/** Adds a ring to polygon/multipolygon features (takes ownership)
* @param ring ring to add
* @param featureId if specified, feature ID for feature ring was added to will be stored in this parameter
* @return
* 0 in case of success
* 1 problem with feature type
* 2 ring not closed
* 6 layer not editable
* @note available in python as addCurvedRing
*/
// TODO QGIS 3.0 returns an enum instead of a magic constant
int addRing( QgsCurve* ring, QgsFeatureId* featureId = nullptr );
/** Adds a new part polygon to a multipart feature
* @return
* 0 in case of success,
* 1 if selected feature is not multipart,
* 2 if ring is not a valid geometry,
* 3 if new polygon ring not disjoint with existing rings,
* 4 if no feature was selected,