QGIS API Documentation 3.41.0-Master (fda2aa46e9a)
Loading...
Searching...
No Matches
qgsvectorlayer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsvectorlayer.cpp
3 --------------------
4 begin : Oct 29, 2003
5 copyright : (C) 2003 by Gary E.Sherman
6 email : sherman at mrcc.com
7
8 This class implements a generic means to display vector layers. The features
9 and attributes are read from the data store using a "data provider" plugin.
10 QgsVectorLayer can be used with any data store for which an appropriate
11 plugin is available.
12
13***************************************************************************/
14
15/***************************************************************************
16 * *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
21 * *
22 ***************************************************************************/
23
24#include "qgis.h" //for globals
25#include "qgssettings.h"
26#include "qgsvectorlayer.h"
27#include "moc_qgsvectorlayer.cpp"
28#include "qgsactionmanager.h"
29#include "qgsapplication.h"
30#include "qgsconditionalstyle.h"
32#include "qgscurve.h"
33#include "qgsdatasourceuri.h"
36#include "qgsfeature.h"
37#include "qgsfeaturerequest.h"
38#include "qgsfields.h"
39#include "qgsmaplayerfactory.h"
41#include "qgsgeometry.h"
43#include "qgslogger.h"
44#include "qgsmaplayerlegend.h"
45#include "qgsmessagelog.h"
46#include "qgsogcutils.h"
47#include "qgspainting.h"
48#include "qgspointxy.h"
49#include "qgsproject.h"
50#include "qgsproviderregistry.h"
51#include "qgsrectangle.h"
52#include "qgsrelationmanager.h"
53#include "qgsweakrelation.h"
54#include "qgsrendercontext.h"
67#include "qgspoint.h"
68#include "qgsrenderer.h"
69#include "qgssymbollayer.h"
70#include "qgsdiagramrenderer.h"
71#include "qgspallabeling.h"
75#include "qgsfeedback.h"
76#include "qgsxmlutils.h"
77#include "qgstaskmanager.h"
78#include "qgstransaction.h"
79#include "qgsauxiliarystorage.h"
80#include "qgsgeometryoptions.h"
82#include "qgsruntimeprofiler.h"
84#include "qgsvectorlayerutils.h"
86#include "qgsprofilerequest.h"
87#include "qgssymbollayerutils.h"
88#include "qgsthreadingutils.h"
89
90#include <QDir>
91#include <QFile>
92#include <QImage>
93#include <QPainter>
94#include <QPainterPath>
95#include <QPolygonF>
96#include <QProgressDialog>
97#include <QString>
98#include <QDomNode>
99#include <QVector>
100#include <QStringBuilder>
101#include <QUrl>
102#include <QUndoCommand>
103#include <QUrlQuery>
104#include <QUuid>
105#include <QRegularExpression>
106#include <QTimer>
107
108#include <limits>
109#include <optional>
110
112#include "qgssettingsentryimpl.h"
113#include "qgssettingstree.h"
114
120
121
122#ifdef TESTPROVIDERLIB
123#include <dlfcn.h>
124#endif
125
126typedef bool saveStyle_t(
127 const QString &uri,
128 const QString &qmlStyle,
129 const QString &sldStyle,
130 const QString &styleName,
131 const QString &styleDescription,
132 const QString &uiFileContent,
133 bool useAsDefault,
134 QString &errCause
135);
136
137typedef QString loadStyle_t(
138 const QString &uri,
139 QString &errCause
140);
141
142typedef int listStyles_t(
143 const QString &uri,
144 QStringList &ids,
145 QStringList &names,
146 QStringList &descriptions,
147 QString &errCause
148);
149
150typedef QString getStyleById_t(
151 const QString &uri,
152 QString styleID,
153 QString &errCause
154);
155
156typedef bool deleteStyleById_t(
157 const QString &uri,
158 QString styleID,
159 QString &errCause
160);
161
162
163QgsVectorLayer::QgsVectorLayer( const QString &vectorLayerPath,
164 const QString &baseName,
165 const QString &providerKey,
166 const QgsVectorLayer::LayerOptions &options )
167 : QgsMapLayer( Qgis::LayerType::Vector, baseName, vectorLayerPath )
168 , mSelectionProperties( new QgsVectorLayerSelectionProperties( this ) )
169 , mTemporalProperties( new QgsVectorLayerTemporalProperties( this ) )
170 , mElevationProperties( new QgsVectorLayerElevationProperties( this ) )
171 , mAuxiliaryLayer( nullptr )
172 , mAuxiliaryLayerKey( QString() )
173 , mReadExtentFromXml( options.readExtentFromXml )
174 , mRefreshRendererTimer( new QTimer( this ) )
175{
177 mLoadAllStoredStyle = options.loadAllStoredStyles;
178
179 if ( options.fallbackCrs.isValid() )
180 setCrs( options.fallbackCrs, false );
181 mWkbType = options.fallbackWkbType;
182
183 setProviderType( providerKey );
184
185 mGeometryOptions = std::make_unique<QgsGeometryOptions>();
186 mActions = new QgsActionManager( this );
187 mConditionalStyles = new QgsConditionalLayerStyles( this );
188 mStoredExpressionManager = new QgsStoredExpressionManager();
189 mStoredExpressionManager->setParent( this );
190
191 mJoinBuffer = new QgsVectorLayerJoinBuffer( this );
192 mJoinBuffer->setParent( this );
193 connect( mJoinBuffer, &QgsVectorLayerJoinBuffer::joinedFieldsChanged, this, &QgsVectorLayer::onJoinedFieldsChanged );
194
195 mExpressionFieldBuffer = new QgsExpressionFieldBuffer();
196 // if we're given a provider type, try to create and bind one to this layer
197 if ( !vectorLayerPath.isEmpty() && !mProviderKey.isEmpty() )
198 {
199 QgsDataProvider::ProviderOptions providerOptions { options.transformContext };
200 Qgis::DataProviderReadFlags providerFlags;
201 if ( options.loadDefaultStyle )
202 {
204 }
205 if ( options.forceReadOnly )
206 {
208 mDataSourceReadOnly = true;
209 }
210 setDataSource( vectorLayerPath, baseName, providerKey, providerOptions, providerFlags );
211 }
212
213 for ( const QgsField &field : std::as_const( mFields ) )
214 {
215 if ( !mAttributeAliasMap.contains( field.name() ) )
216 mAttributeAliasMap.insert( field.name(), QString() );
217 }
218
219 if ( isValid() )
220 {
221 mTemporalProperties->setDefaultsFromDataProviderTemporalCapabilities( mDataProvider->temporalCapabilities() );
222 if ( !mTemporalProperties->isActive() )
223 {
224 // didn't populate temporal properties from provider metadata, so at least try to setup some initially nice
225 // selections
226 mTemporalProperties->guessDefaultsFromFields( mFields );
227 }
228
229 mElevationProperties->setDefaultsFromLayer( this );
230 }
231
232 connect( this, &QgsVectorLayer::selectionChanged, this, [this] { triggerRepaint(); } );
233 connect( QgsProject::instance()->relationManager(), &QgsRelationManager::relationsLoaded, this, &QgsVectorLayer::onRelationsLoaded ); // skip-keyword-check
234
238
239 // Default simplify drawing settings
240 QgsSettings settings;
241 mSimplifyMethod.setSimplifyHints( QgsVectorLayer::settingsSimplifyDrawingHints->valueWithDefaultOverride( mSimplifyMethod.simplifyHints() ) );
242 mSimplifyMethod.setSimplifyAlgorithm( QgsVectorLayer::settingsSimplifyAlgorithm->valueWithDefaultOverride( mSimplifyMethod.simplifyAlgorithm() ) );
243 mSimplifyMethod.setThreshold( QgsVectorLayer::settingsSimplifyDrawingTol->valueWithDefaultOverride( mSimplifyMethod.threshold() ) );
244 mSimplifyMethod.setForceLocalOptimization( QgsVectorLayer::settingsSimplifyLocal->valueWithDefaultOverride( mSimplifyMethod.forceLocalOptimization() ) );
245 mSimplifyMethod.setMaximumScale( QgsVectorLayer::settingsSimplifyMaxScale->valueWithDefaultOverride( mSimplifyMethod.maximumScale() ) );
246
247 connect( mRefreshRendererTimer, &QTimer::timeout, this, [this] { triggerRepaint( true ); } );
248}
249
251{
252 emit willBeDeleted();
253
254 setValid( false );
255
256 delete mDataProvider;
257 delete mEditBuffer;
258 delete mJoinBuffer;
259 delete mExpressionFieldBuffer;
260 delete mLabeling;
261 delete mDiagramLayerSettings;
262 delete mDiagramRenderer;
263
264 delete mActions;
265
266 delete mRenderer;
267 delete mConditionalStyles;
268 delete mStoredExpressionManager;
269
270 if ( mFeatureCounter )
271 mFeatureCounter->cancel();
272
273 qDeleteAll( mRendererGenerators );
274}
275
277{
279
281 // We get the data source string from the provider when
282 // possible because some providers may have changed it
283 // directly (memory provider does that).
284 QString dataSource;
285 if ( mDataProvider )
286 {
287 dataSource = mDataProvider->dataSourceUri();
288 options.transformContext = mDataProvider->transformContext();
289 }
290 else
291 {
292 dataSource = source();
293 }
294 options.forceReadOnly = mDataSourceReadOnly;
295 QgsVectorLayer *layer = new QgsVectorLayer( dataSource, name(), mProviderKey, options );
296 if ( mDataProvider && layer->dataProvider() )
297 {
298 layer->dataProvider()->handlePostCloneOperations( mDataProvider );
299 }
300 QgsMapLayer::clone( layer );
301 layer->mXmlExtent2D = mXmlExtent2D;
302 layer->mLazyExtent2D = mLazyExtent2D;
303 layer->mValidExtent2D = mValidExtent2D;
304 layer->mXmlExtent3D = mXmlExtent3D;
305 layer->mLazyExtent3D = mLazyExtent3D;
306 layer->mValidExtent3D = mValidExtent3D;
307
308 QList<QgsVectorLayerJoinInfo> joins = vectorJoins();
309 const auto constJoins = joins;
310 for ( const QgsVectorLayerJoinInfo &join : constJoins )
311 {
312 // do not copy join information for auxiliary layer
313 if ( !auxiliaryLayer()
314 || ( auxiliaryLayer() && auxiliaryLayer()->id() != join.joinLayerId() ) )
315 layer->addJoin( join );
316 }
317
318 if ( mDataProvider )
319 layer->setProviderEncoding( mDataProvider->encoding() );
320 layer->setSubsetString( subsetString() );
324 layer->setReadOnly( isReadOnly() );
329
330 const auto constActions = actions()->actions();
331 for ( const QgsAction &action : constActions )
332 {
333 layer->actions()->addAction( action );
334 }
335
336 if ( auto *lRenderer = renderer() )
337 {
338 layer->setRenderer( lRenderer->clone() );
339 }
340
341 if ( auto *lLabeling = labeling() )
342 {
343 layer->setLabeling( lLabeling->clone() );
344 }
346
348
349 if ( auto *lDiagramRenderer = diagramRenderer() )
350 {
351 layer->setDiagramRenderer( lDiagramRenderer->clone() );
352 }
353
354 if ( auto *lDiagramLayerSettings = diagramLayerSettings() )
355 {
356 layer->setDiagramLayerSettings( *lDiagramLayerSettings );
357 }
358
359 for ( int i = 0; i < fields().count(); i++ )
360 {
361 layer->setFieldAlias( i, attributeAlias( i ) );
363 layer->setEditorWidgetSetup( i, editorWidgetSetup( i ) );
366
367 QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength> constraints = fieldConstraintsAndStrength( i );
368 auto constraintIt = constraints.constBegin();
369 for ( ; constraintIt != constraints.constEnd(); ++ constraintIt )
370 {
371 layer->setFieldConstraint( i, constraintIt.key(), constraintIt.value() );
372 }
373
374 if ( fields().fieldOrigin( i ) == Qgis::FieldOrigin::Expression )
375 {
376 layer->addExpressionField( expressionField( i ), fields().at( i ) );
377 }
378 }
379
381
382 if ( auto *lAuxiliaryLayer = auxiliaryLayer() )
383 layer->setAuxiliaryLayer( lAuxiliaryLayer->clone( layer ) );
384
385 layer->mElevationProperties = mElevationProperties->clone();
386 layer->mElevationProperties->setParent( layer );
387
388 layer->mSelectionProperties = mSelectionProperties->clone();
389 layer->mSelectionProperties->setParent( layer );
390
391 return layer;
392}
393
395{
397
398 if ( mDataProvider )
399 {
400 return mDataProvider->storageType();
401 }
402 return QString();
403}
404
405
407{
409
410 if ( mDataProvider )
411 {
412 return mDataProvider->capabilitiesString();
413 }
414 return QString();
415}
416
418{
420
421 return mDataProvider && mDataProvider->isSqlQuery();
422}
423
430
432{
434
435 if ( mDataProvider )
436 {
437 return mDataProvider->dataComment();
438 }
439 return QString();
440}
441
448
450{
452
453 return name();
454}
455
457{
458 // non fatal for now -- the QgsVirtualLayerTask class is not thread safe and calls this
460
461 if ( mDataProvider )
462 {
463 mDataProvider->reloadData();
464 updateFields();
465 }
466}
467
469{
470 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
472
473 return new QgsVectorLayerRenderer( this, rendererContext );
474}
475
476
477void QgsVectorLayer::drawVertexMarker( double x, double y, QPainter &p, Qgis::VertexMarkerType type, int m )
478{
479 switch ( type )
480 {
482 p.setPen( QColor( 50, 100, 120, 200 ) );
483 p.setBrush( QColor( 200, 200, 210, 120 ) );
484 p.drawEllipse( x - m, y - m, m * 2 + 1, m * 2 + 1 );
485 break;
486
488 p.setPen( QColor( 255, 0, 0 ) );
489 p.drawLine( x - m, y + m, x + m, y - m );
490 p.drawLine( x - m, y - m, x + m, y + m );
491 break;
492
494 break;
495 }
496}
497
499{
501
502 mSelectedFeatureIds.insert( fid );
503 mPreviousSelectedFeatureIds.clear();
504
505 emit selectionChanged( QgsFeatureIds() << fid, QgsFeatureIds(), false );
506}
507
508void QgsVectorLayer::select( const QgsFeatureIds &featureIds )
509{
511
512 mSelectedFeatureIds.unite( featureIds );
513 mPreviousSelectedFeatureIds.clear();
514
515 emit selectionChanged( featureIds, QgsFeatureIds(), false );
516}
517
519{
521
522 mSelectedFeatureIds.remove( fid );
523 mPreviousSelectedFeatureIds.clear();
524
525 emit selectionChanged( QgsFeatureIds(), QgsFeatureIds() << fid, false );
526}
527
529{
531
532 mSelectedFeatureIds.subtract( featureIds );
533 mPreviousSelectedFeatureIds.clear();
534
535 emit selectionChanged( QgsFeatureIds(), featureIds, false );
536}
537
539{
541
542 // normalize the rectangle
543 rect.normalize();
544
545 QgsFeatureIds newSelection;
546
548 .setFilterRect( rect )
550 .setNoAttributes() );
551
552 QgsFeature feat;
553 while ( features.nextFeature( feat ) )
554 {
555 newSelection << feat.id();
556 }
557 features.close();
558
559 selectByIds( newSelection, behavior );
560}
561
562void QgsVectorLayer::selectByExpression( const QString &expression, Qgis::SelectBehavior behavior, QgsExpressionContext *context )
563{
565
566 QgsFeatureIds newSelection;
567
568 std::optional< QgsExpressionContext > defaultContext;
569 if ( !context )
570 {
571 defaultContext.emplace( QgsExpressionContextUtils::globalProjectLayerScopes( this ) );
572 context = &defaultContext.value();
573 }
574
576 {
578 .setExpressionContext( *context )
581
582 QgsFeatureIterator features = getFeatures( request );
583
584 if ( behavior == Qgis::SelectBehavior::AddToSelection )
585 {
586 newSelection = selectedFeatureIds();
587 }
588 QgsFeature feat;
589 while ( features.nextFeature( feat ) )
590 {
591 newSelection << feat.id();
592 }
593 features.close();
594 }
596 {
597 QgsExpression exp( expression );
598 exp.prepare( context );
599
600 QgsFeatureIds oldSelection = selectedFeatureIds();
601 QgsFeatureRequest request = QgsFeatureRequest().setFilterFids( oldSelection );
602
603 //refine request
604 if ( !exp.needsGeometry() )
607
608 QgsFeatureIterator features = getFeatures( request );
609 QgsFeature feat;
610 while ( features.nextFeature( feat ) )
611 {
612 context->setFeature( feat );
613 bool matches = exp.evaluate( context ).toBool();
614
615 if ( matches && behavior == Qgis::SelectBehavior::IntersectSelection )
616 {
617 newSelection << feat.id();
618 }
619 else if ( !matches && behavior == Qgis::SelectBehavior::RemoveFromSelection )
620 {
621 newSelection << feat.id();
622 }
623 }
624 }
625
626 selectByIds( newSelection );
627}
628
630{
632
633 QgsFeatureIds newSelection;
634
635 switch ( behavior )
636 {
638 newSelection = ids;
639 break;
640
642 newSelection = mSelectedFeatureIds + ids;
643 break;
644
646 newSelection = mSelectedFeatureIds - ids;
647 break;
648
650 newSelection = mSelectedFeatureIds.intersect( ids );
651 break;
652 }
653
654 QgsFeatureIds deselectedFeatures = mSelectedFeatureIds - newSelection;
655 mSelectedFeatureIds = newSelection;
656 mPreviousSelectedFeatureIds.clear();
657
658 emit selectionChanged( newSelection, deselectedFeatures, true );
659}
660
661void QgsVectorLayer::modifySelection( const QgsFeatureIds &selectIds, const QgsFeatureIds &deselectIds )
662{
664
665 QgsFeatureIds intersectingIds = selectIds & deselectIds;
666 if ( !intersectingIds.isEmpty() )
667 {
668 QgsDebugMsgLevel( QStringLiteral( "Trying to select and deselect the same item at the same time. Unsure what to do. Selecting dubious items." ), 3 );
669 }
670
671 mSelectedFeatureIds -= deselectIds;
672 mSelectedFeatureIds += selectIds;
673 mPreviousSelectedFeatureIds.clear();
674
675 emit selectionChanged( selectIds, deselectIds - intersectingIds, false );
676}
677
679{
681
683 ids.subtract( mSelectedFeatureIds );
684 selectByIds( ids );
685}
686
693
695{
697
698 // normalize the rectangle
699 rect.normalize();
700
702 .setFilterRect( rect )
704 .setNoAttributes() );
705
706 QgsFeatureIds selectIds;
707 QgsFeatureIds deselectIds;
708
709 QgsFeature fet;
710 while ( fit.nextFeature( fet ) )
711 {
712 if ( mSelectedFeatureIds.contains( fet.id() ) )
713 {
714 deselectIds << fet.id();
715 }
716 else
717 {
718 selectIds << fet.id();
719 }
720 }
721
722 modifySelection( selectIds, deselectIds );
723}
724
726{
728
729 if ( mSelectedFeatureIds.isEmpty() )
730 return;
731
732 const QgsFeatureIds previous = mSelectedFeatureIds;
734 mPreviousSelectedFeatureIds = previous;
735}
736
738{
740
741 if ( mPreviousSelectedFeatureIds.isEmpty() || !mSelectedFeatureIds.empty() )
742 return;
743
744 selectByIds( mPreviousSelectedFeatureIds );
745}
746
748{
749 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
751
752 return mDataProvider;
753}
754
756{
757 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
759
760 return mDataProvider;
761}
762
764{
765 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
767
768 return mSelectionProperties;
769}
770
777
784
786{
788
789 QgsProfileRequest modifiedRequest( request );
790 modifiedRequest.expressionContext().appendScope( createExpressionContextScope() );
791 return new QgsVectorLayerProfileGenerator( this, modifiedRequest );
792}
793
794void QgsVectorLayer::setProviderEncoding( const QString &encoding )
795{
797
798 if ( isValid() && mDataProvider && mDataProvider->encoding() != encoding )
799 {
800 mDataProvider->setEncoding( encoding );
801 updateFields();
802 }
803}
804
806{
808
809 delete mDiagramRenderer;
810 mDiagramRenderer = r;
811 emit rendererChanged();
812 emit styleChanged();
813}
814
816{
817 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
819
820 return QgsWkbTypes::geometryType( mWkbType );
821}
822
824{
826
827 return mWkbType;
828}
829
831{
833
834 if ( !isValid() || !isSpatial() || mSelectedFeatureIds.isEmpty() || !mDataProvider ) //no selected features
835 {
836 return QgsRectangle( 0, 0, 0, 0 );
837 }
838
839 QgsRectangle r, retval;
840 retval.setNull();
841
842 QgsFeature fet;
844 {
846 .setFilterFids( mSelectedFeatureIds )
847 .setNoAttributes() );
848
849 while ( fit.nextFeature( fet ) )
850 {
851 if ( !fet.hasGeometry() )
852 continue;
853 r = fet.geometry().boundingBox();
854 retval.combineExtentWith( r );
855 }
856 }
857 else
858 {
860 .setNoAttributes() );
861
862 while ( fit.nextFeature( fet ) )
863 {
864 if ( mSelectedFeatureIds.contains( fet.id() ) )
865 {
866 if ( fet.hasGeometry() )
867 {
868 r = fet.geometry().boundingBox();
869 retval.combineExtentWith( r );
870 }
871 }
872 }
873 }
874
875 if ( retval.width() == 0.0 || retval.height() == 0.0 )
876 {
877 // If all of the features are at the one point, buffer the
878 // rectangle a bit. If they are all at zero, do something a bit
879 // more crude.
880
881 if ( retval.xMinimum() == 0.0 && retval.xMaximum() == 0.0 &&
882 retval.yMinimum() == 0.0 && retval.yMaximum() == 0.0 )
883 {
884 retval.set( -1.0, -1.0, 1.0, 1.0 );
885 }
886 }
887
888 return retval;
889}
890
892{
893 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
895
896 return mLabelsEnabled && static_cast< bool >( mLabeling );
897}
898
900{
902
903 mLabelsEnabled = enabled;
904}
905
907{
908 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
910
911 if ( !mDiagramRenderer || !mDiagramLayerSettings )
912 return false;
913
914 QList<QgsDiagramSettings> settingList = mDiagramRenderer->diagramSettings();
915 if ( !settingList.isEmpty() )
916 {
917 return settingList.at( 0 ).enabled;
918 }
919 return false;
920}
921
922long long QgsVectorLayer::featureCount( const QString &legendKey ) const
923{
925
926 if ( !mSymbolFeatureCounted )
927 return -1;
928
929 return mSymbolFeatureCountMap.value( legendKey, -1 );
930}
931
932QgsFeatureIds QgsVectorLayer::symbolFeatureIds( const QString &legendKey ) const
933{
935
936 if ( !mSymbolFeatureCounted )
937 return QgsFeatureIds();
938
939 return mSymbolFeatureIdMap.value( legendKey, QgsFeatureIds() );
940}
942{
944
945 if ( ( mSymbolFeatureCounted || mFeatureCounter ) && !( storeSymbolFids && mSymbolFeatureIdMap.isEmpty() ) )
946 return mFeatureCounter;
947
948 mSymbolFeatureCountMap.clear();
949 mSymbolFeatureIdMap.clear();
950
951 if ( !isValid() )
952 {
953 QgsDebugMsgLevel( QStringLiteral( "invoked with invalid layer" ), 3 );
954 return mFeatureCounter;
955 }
956 if ( !mDataProvider )
957 {
958 QgsDebugMsgLevel( QStringLiteral( "invoked with null mDataProvider" ), 3 );
959 return mFeatureCounter;
960 }
961 if ( !mRenderer )
962 {
963 QgsDebugMsgLevel( QStringLiteral( "invoked with null mRenderer" ), 3 );
964 return mFeatureCounter;
965 }
966
967 if ( !mFeatureCounter || ( storeSymbolFids && mSymbolFeatureIdMap.isEmpty() ) )
968 {
969 mFeatureCounter = new QgsVectorLayerFeatureCounter( this, QgsExpressionContext(), storeSymbolFids );
970 connect( mFeatureCounter, &QgsTask::taskCompleted, this, &QgsVectorLayer::onFeatureCounterCompleted, Qt::UniqueConnection );
971 connect( mFeatureCounter, &QgsTask::taskTerminated, this, &QgsVectorLayer::onFeatureCounterTerminated, Qt::UniqueConnection );
972 QgsApplication::taskManager()->addTask( mFeatureCounter );
973 }
974
975 return mFeatureCounter;
976}
977
979{
981
982 // do not update extent by default when trust project option is activated
983 if ( force || !mReadExtentFromXml || ( mReadExtentFromXml && mXmlExtent2D.isNull() && mXmlExtent3D.isNull() ) )
984 {
985 mValidExtent2D = false;
986 mValidExtent3D = false;
987 }
988}
989
991{
993
995 mValidExtent2D = true;
996}
997
999{
1001
1003 mValidExtent3D = true;
1004}
1005
1006void QgsVectorLayer::updateDefaultValues( QgsFeatureId fid, QgsFeature feature, QgsExpressionContext *context )
1007{
1009
1010 if ( !mDefaultValueOnUpdateFields.isEmpty() )
1011 {
1012 if ( !feature.isValid() )
1013 feature = getFeature( fid );
1014
1015 int size = mFields.size();
1016 for ( int idx : std::as_const( mDefaultValueOnUpdateFields ) )
1017 {
1018 if ( idx < 0 || idx >= size )
1019 continue;
1020 feature.setAttribute( idx, defaultValue( idx, feature, context ) );
1021 updateFeature( feature, true );
1022 }
1023 }
1024}
1025
1027{
1029
1030 QgsRectangle rect;
1031 rect.setNull();
1032
1033 if ( !isSpatial() )
1034 return rect;
1035
1036 if ( mDataProvider && mDataProvider->isValid() && ( mDataProvider->flags() & Qgis::DataProviderFlag::FastExtent2D ) )
1037 {
1038 // Provider has a trivial 2D extent calculation => always get extent from provider.
1039 // Things are nice and simple this way, e.g. we can always trust that this extent is
1040 // accurate and up to date.
1041 updateExtent( mDataProvider->extent() );
1042 mValidExtent2D = true;
1043 mLazyExtent2D = false;
1044 }
1045 else
1046 {
1047 if ( !mValidExtent2D && mLazyExtent2D && mReadExtentFromXml && !mXmlExtent2D.isNull() )
1048 {
1049 updateExtent( mXmlExtent2D );
1050 mValidExtent2D = true;
1051 mLazyExtent2D = false;
1052 }
1053
1054 if ( !mValidExtent2D && mLazyExtent2D && mDataProvider && mDataProvider->isValid() )
1055 {
1056 // store the extent
1057 updateExtent( mDataProvider->extent() );
1058 mValidExtent2D = true;
1059 mLazyExtent2D = false;
1060
1061 // show the extent
1062 QgsDebugMsgLevel( QStringLiteral( "2D Extent of layer: %1" ).arg( mExtent2D.toString() ), 3 );
1063 }
1064 }
1065
1066 if ( mValidExtent2D )
1067 return QgsMapLayer::extent();
1068
1069 if ( !isValid() || !mDataProvider )
1070 {
1071 QgsDebugMsgLevel( QStringLiteral( "invoked with invalid layer or null mDataProvider" ), 3 );
1072 return rect;
1073 }
1074
1075 if ( !mEditBuffer ||
1076 ( !mDataProvider->transaction() && ( mEditBuffer->deletedFeatureIds().isEmpty() && mEditBuffer->changedGeometries().isEmpty() ) ) ||
1078 {
1079 mDataProvider->updateExtents();
1080
1081 // get the extent of the layer from the provider
1082 // but only when there are some features already
1083 if ( mDataProvider->featureCount() != 0 )
1084 {
1085 const QgsRectangle r = mDataProvider->extent();
1086 rect.combineExtentWith( r );
1087 }
1088
1089 if ( mEditBuffer && !mDataProvider->transaction() )
1090 {
1091 const auto addedFeatures = mEditBuffer->addedFeatures();
1092 for ( QgsFeatureMap::const_iterator it = addedFeatures.constBegin(); it != addedFeatures.constEnd(); ++it )
1093 {
1094 if ( it->hasGeometry() )
1095 {
1096 const QgsRectangle r = it->geometry().boundingBox();
1097 rect.combineExtentWith( r );
1098 }
1099 }
1100 }
1101 }
1102 else
1103 {
1105 .setNoAttributes() );
1106
1107 QgsFeature fet;
1108 while ( fit.nextFeature( fet ) )
1109 {
1110 if ( fet.hasGeometry() && fet.geometry().type() != Qgis::GeometryType::Unknown )
1111 {
1112 const QgsRectangle bb = fet.geometry().boundingBox();
1113 rect.combineExtentWith( bb );
1114 }
1115 }
1116 }
1117
1118 if ( rect.xMinimum() > rect.xMaximum() && rect.yMinimum() > rect.yMaximum() )
1119 {
1120 // special case when there are no features in provider nor any added
1121 rect = QgsRectangle(); // use rectangle with zero coordinates
1122 }
1123
1124 updateExtent( rect );
1125 mValidExtent2D = true;
1126
1127 // Send this (hopefully) up the chain to the map canvas
1128 emit recalculateExtents();
1129
1130 return rect;
1131}
1132
1134{
1136
1137 // if data is 2D, redirect to 2D extend computation, and save it as 2D extent (in 3D bbox)
1138 if ( mDataProvider && mDataProvider->elevationProperties() && !mDataProvider->elevationProperties()->containsElevationData() )
1139 {
1140 return QgsBox3D( extent() );
1141 }
1142
1144 extent.setNull();
1145
1146 if ( !isSpatial() )
1147 return extent;
1148
1149 if ( mDataProvider && mDataProvider->isValid() && ( mDataProvider->flags() & Qgis::DataProviderFlag::FastExtent3D ) )
1150 {
1151 // Provider has a trivial 3D extent calculation => always get extent from provider.
1152 // Things are nice and simple this way, e.g. we can always trust that this extent is
1153 // accurate and up to date.
1154 updateExtent( mDataProvider->extent3D() );
1155 mValidExtent3D = true;
1156 mLazyExtent3D = false;
1157 }
1158 else
1159 {
1160 if ( !mValidExtent3D && mLazyExtent3D && mReadExtentFromXml && !mXmlExtent3D.isNull() )
1161 {
1162 updateExtent( mXmlExtent3D );
1163 mValidExtent3D = true;
1164 mLazyExtent3D = false;
1165 }
1166
1167 if ( !mValidExtent3D && mLazyExtent3D && mDataProvider && mDataProvider->isValid() )
1168 {
1169 // store the extent
1170 updateExtent( mDataProvider->extent3D() );
1171 mValidExtent3D = true;
1172 mLazyExtent3D = false;
1173
1174 // show the extent
1175 QgsDebugMsgLevel( QStringLiteral( "3D Extent of layer: %1" ).arg( mExtent3D.toString() ), 3 );
1176 }
1177 }
1178
1179 if ( mValidExtent3D )
1180 return QgsMapLayer::extent3D();
1181
1182 if ( !isValid() || !mDataProvider )
1183 {
1184 QgsDebugMsgLevel( QStringLiteral( "invoked with invalid layer or null mDataProvider" ), 3 );
1185 return extent;
1186 }
1187
1188 if ( !mEditBuffer ||
1189 ( !mDataProvider->transaction() && ( mEditBuffer->deletedFeatureIds().isEmpty() && mEditBuffer->changedGeometries().isEmpty() ) ) ||
1191 {
1192 mDataProvider->updateExtents();
1193
1194 // get the extent of the layer from the provider
1195 // but only when there are some features already
1196 if ( mDataProvider->featureCount() != 0 )
1197 {
1198 const QgsBox3D ext = mDataProvider->extent3D();
1199 extent.combineWith( ext );
1200 }
1201
1202 if ( mEditBuffer && !mDataProvider->transaction() )
1203 {
1204 const auto addedFeatures = mEditBuffer->addedFeatures();
1205 for ( QgsFeatureMap::const_iterator it = addedFeatures.constBegin(); it != addedFeatures.constEnd(); ++it )
1206 {
1207 if ( it->hasGeometry() )
1208 {
1209 const QgsBox3D bbox = it->geometry().boundingBox3D();
1210 extent.combineWith( bbox );
1211 }
1212 }
1213 }
1214 }
1215 else
1216 {
1218 .setNoAttributes() );
1219
1220 QgsFeature fet;
1221 while ( fit.nextFeature( fet ) )
1222 {
1223 if ( fet.hasGeometry() && fet.geometry().type() != Qgis::GeometryType::Unknown )
1224 {
1225 const QgsBox3D bb = fet.geometry().boundingBox3D();
1226 extent.combineWith( bb );
1227 }
1228 }
1229 }
1230
1231 if ( extent.xMinimum() > extent.xMaximum() && extent.yMinimum() > extent.yMaximum() && extent.zMinimum() > extent.zMaximum() )
1232 {
1233 // special case when there are no features in provider nor any added
1234 extent = QgsBox3D(); // use rectangle with zero coordinates
1235 }
1236
1237 updateExtent( extent );
1238 mValidExtent3D = true;
1239
1240 // Send this (hopefully) up the chain to the map canvas
1241 emit recalculateExtents();
1242
1243 return extent;
1244}
1245
1252
1259
1261{
1263
1264 if ( !isValid() || !mDataProvider )
1265 {
1266 QgsDebugMsgLevel( QStringLiteral( "invoked with invalid layer or null mDataProvider" ), 3 );
1267 return customProperty( QStringLiteral( "storedSubsetString" ) ).toString();
1268 }
1269 return mDataProvider->subsetString();
1270}
1271
1272bool QgsVectorLayer::setSubsetString( const QString &subset )
1273{
1275
1276 if ( !isValid() || !mDataProvider )
1277 {
1278 QgsDebugMsgLevel( QStringLiteral( "invoked with invalid layer or null mDataProvider or while editing" ), 3 );
1279 setCustomProperty( QStringLiteral( "storedSubsetString" ), subset );
1280 return false;
1281 }
1282 else if ( mEditBuffer )
1283 {
1284 QgsDebugMsgLevel( QStringLiteral( "invoked while editing" ), 3 );
1285 return false;
1286 }
1287
1288 if ( subset == mDataProvider->subsetString() )
1289 return true;
1290
1291 bool res = mDataProvider->setSubsetString( subset );
1292
1293 // get the updated data source string from the provider
1294 mDataSource = mDataProvider->dataSourceUri();
1295 updateExtents();
1296 updateFields();
1297
1298 if ( res )
1299 {
1300 emit subsetStringChanged();
1302 }
1303
1304 return res;
1305}
1306
1308{
1309 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
1311
1312 if ( isValid() && mDataProvider && !mEditBuffer && ( isSpatial() && geometryType() != Qgis::GeometryType::Point ) && ( mSimplifyMethod.simplifyHints() & simplifyHint ) && renderContext.useRenderingOptimization() )
1313 {
1314 double maximumSimplificationScale = mSimplifyMethod.maximumScale();
1315
1316 // check maximum scale at which generalisation should be carried out
1317 return !( maximumSimplificationScale > 1 && renderContext.rendererScale() <= maximumSimplificationScale );
1318 }
1319 return false;
1320}
1321
1323{
1325
1326 return mConditionalStyles;
1327}
1328
1330{
1331 // non fatal for now -- the aggregate expression functions are not thread safe and call this
1333
1334 if ( !isValid() || !mDataProvider )
1335 return QgsFeatureIterator();
1336
1337 return QgsFeatureIterator( new QgsVectorLayerFeatureIterator( new QgsVectorLayerFeatureSource( this ), true, request ) );
1338}
1339
1341{
1343
1344 QgsFeature feature;
1346 if ( feature.isValid() )
1347 return feature.geometry();
1348 else
1349 return QgsGeometry();
1350}
1351
1353{
1355
1356 if ( !isValid() || !mEditBuffer || !mDataProvider )
1357 return false;
1358
1359
1360 if ( mGeometryOptions->isActive() )
1361 {
1362 QgsGeometry geom = feature.geometry();
1363 mGeometryOptions->apply( geom );
1364 feature.setGeometry( geom );
1365 }
1366
1367 bool success = mEditBuffer->addFeature( feature );
1368
1369 if ( success )
1370 {
1371 updateExtents();
1372
1373 if ( mJoinBuffer->containsJoins() )
1374 success = mJoinBuffer->addFeature( feature );
1375 }
1376
1377 return success;
1378}
1379
1380bool QgsVectorLayer::updateFeature( QgsFeature &updatedFeature, bool skipDefaultValues )
1381{
1383
1384 if ( !mEditBuffer || !mDataProvider )
1385 {
1386 return false;
1387 }
1388
1389 QgsFeature currentFeature = getFeature( updatedFeature.id() );
1390 if ( currentFeature.isValid() )
1391 {
1392 bool hasChanged = false;
1393 bool hasError = false;
1394
1395 if ( ( updatedFeature.hasGeometry() || currentFeature.hasGeometry() ) && !updatedFeature.geometry().equals( currentFeature.geometry() ) )
1396 {
1397 QgsGeometry geometry = updatedFeature.geometry();
1398 if ( changeGeometry( updatedFeature.id(), geometry, true ) )
1399 {
1400 hasChanged = true;
1401 updatedFeature.setGeometry( geometry );
1402 }
1403 else
1404 {
1405 QgsDebugMsgLevel( QStringLiteral( "geometry of feature %1 could not be changed." ).arg( updatedFeature.id() ), 3 );
1406 }
1407 }
1408
1409 QgsAttributes fa = updatedFeature.attributes();
1410 QgsAttributes ca = currentFeature.attributes();
1411
1412 for ( int attr = 0; attr < fa.count(); ++attr )
1413 {
1414 if ( !qgsVariantEqual( fa.at( attr ), ca.at( attr ) ) )
1415 {
1416 if ( changeAttributeValue( updatedFeature.id(), attr, fa.at( attr ), ca.at( attr ), true ) )
1417 {
1418 hasChanged = true;
1419 }
1420 else
1421 {
1422 QgsDebugMsgLevel( QStringLiteral( "attribute %1 of feature %2 could not be changed." ).arg( attr ).arg( updatedFeature.id() ), 3 );
1423 hasError = true;
1424 }
1425 }
1426 }
1427 if ( hasChanged && !mDefaultValueOnUpdateFields.isEmpty() && !skipDefaultValues )
1428 updateDefaultValues( updatedFeature.id(), updatedFeature );
1429
1430 return !hasError;
1431 }
1432 else
1433 {
1434 QgsDebugMsgLevel( QStringLiteral( "feature %1 could not be retrieved" ).arg( updatedFeature.id() ), 3 );
1435 return false;
1436 }
1437}
1438
1439
1440bool QgsVectorLayer::insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex )
1441{
1443
1444 if ( !isValid() || !mEditBuffer || !mDataProvider )
1445 return false;
1446
1447 QgsVectorLayerEditUtils utils( this );
1448 bool result = utils.insertVertex( x, y, atFeatureId, beforeVertex );
1449 if ( result )
1450 updateExtents();
1451 return result;
1452}
1453
1454
1455bool QgsVectorLayer::insertVertex( const QgsPoint &point, QgsFeatureId atFeatureId, int beforeVertex )
1456{
1458
1459 if ( !isValid() || !mEditBuffer || !mDataProvider )
1460 return false;
1461
1462 QgsVectorLayerEditUtils utils( this );
1463 bool result = utils.insertVertex( point, atFeatureId, beforeVertex );
1464 if ( result )
1465 updateExtents();
1466 return result;
1467}
1468
1469
1470bool QgsVectorLayer::moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex )
1471{
1473
1474 if ( !isValid() || !mEditBuffer || !mDataProvider )
1475 return false;
1476
1477 QgsVectorLayerEditUtils utils( this );
1478 bool result = utils.moveVertex( x, y, atFeatureId, atVertex );
1479
1480 if ( result )
1481 updateExtents();
1482 return result;
1483}
1484
1485bool QgsVectorLayer::moveVertex( const QgsPoint &p, QgsFeatureId atFeatureId, int atVertex )
1486{
1488
1489 if ( !isValid() || !mEditBuffer || !mDataProvider )
1490 return false;
1491
1492 QgsVectorLayerEditUtils utils( this );
1493 bool result = utils.moveVertex( p, atFeatureId, atVertex );
1494
1495 if ( result )
1496 updateExtents();
1497 return result;
1498}
1499
1501{
1503
1504 if ( !isValid() || !mEditBuffer || !mDataProvider )
1506
1507 QgsVectorLayerEditUtils utils( this );
1508 Qgis::VectorEditResult result = utils.deleteVertex( featureId, vertex );
1509
1510 if ( result == Qgis::VectorEditResult::Success )
1511 updateExtents();
1512 return result;
1513}
1514
1515
1517{
1519
1520 if ( !isValid() || !mDataProvider || !( mDataProvider->capabilities() & Qgis::VectorProviderCapability::DeleteFeatures ) )
1521 {
1522 return false;
1523 }
1524
1525 if ( !isEditable() )
1526 {
1527 return false;
1528 }
1529
1530 int deleted = 0;
1531 int count = mSelectedFeatureIds.size();
1532 // Make a copy since deleteFeature modifies mSelectedFeatureIds
1533 QgsFeatureIds selectedFeatures( mSelectedFeatureIds );
1534 for ( QgsFeatureId fid : std::as_const( selectedFeatures ) )
1535 {
1536 deleted += deleteFeature( fid, context ); // removes from selection
1537 }
1538
1540 updateExtents();
1541
1542 if ( deletedCount )
1543 {
1544 *deletedCount = deleted;
1545 }
1546
1547 return deleted == count;
1548}
1549
1550static const QgsPointSequence vectorPointXY2pointSequence( const QVector<QgsPointXY> &points )
1551{
1552 QgsPointSequence pts;
1553 pts.reserve( points.size() );
1554 QVector<QgsPointXY>::const_iterator it = points.constBegin();
1555 while ( it != points.constEnd() )
1556 {
1557 pts.append( QgsPoint( *it ) );
1558 ++it;
1559 }
1560 return pts;
1561}
1562Qgis::GeometryOperationResult QgsVectorLayer::addRing( const QVector<QgsPointXY> &ring, QgsFeatureId *featureId )
1563{
1565
1566 return addRing( vectorPointXY2pointSequence( ring ), featureId );
1567}
1568
1570{
1572
1573 if ( !isValid() || !mEditBuffer || !mDataProvider )
1575
1576 QgsVectorLayerEditUtils utils( this );
1578
1579 //first try with selected features
1580 if ( !mSelectedFeatureIds.isEmpty() )
1581 {
1582 result = utils.addRing( ring, mSelectedFeatureIds, featureId );
1583 }
1584
1586 {
1587 //try with all intersecting features
1588 result = utils.addRing( ring, QgsFeatureIds(), featureId );
1589 }
1590
1591 return result;
1592}
1593
1595{
1597
1598 if ( !isValid() || !mEditBuffer || !mDataProvider )
1599 {
1600 delete ring;
1602 }
1603
1604 if ( !ring )
1605 {
1607 }
1608
1609 if ( !ring->isClosed() )
1610 {
1611 delete ring;
1613 }
1614
1615 QgsVectorLayerEditUtils utils( this );
1617
1618 //first try with selected features
1619 if ( !mSelectedFeatureIds.isEmpty() )
1620 {
1621 result = utils.addRing( static_cast< QgsCurve * >( ring->clone() ), mSelectedFeatureIds, featureId );
1622 }
1623
1625 {
1626 //try with all intersecting features
1627 result = utils.addRing( static_cast< QgsCurve * >( ring->clone() ), QgsFeatureIds(), featureId );
1628 }
1629
1630 delete ring;
1631 return result;
1632}
1633
1635{
1637
1638 QgsPointSequence pts;
1639 pts.reserve( points.size() );
1640 for ( QList<QgsPointXY>::const_iterator it = points.constBegin(); it != points.constEnd() ; ++it )
1641 {
1642 pts.append( QgsPoint( *it ) );
1643 }
1644 return addPart( pts );
1645}
1646
1647#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1648Qgis::GeometryOperationResult QgsVectorLayer::addPart( const QVector<QgsPointXY> &points )
1649{
1651
1652 return addPart( vectorPointXY2pointSequence( points ) );
1653}
1654#endif
1655
1657{
1659
1660 if ( !isValid() || !mEditBuffer || !mDataProvider )
1662
1663 //number of selected features must be 1
1664
1665 if ( mSelectedFeatureIds.empty() )
1666 {
1667 QgsDebugMsgLevel( QStringLiteral( "Number of selected features <1" ), 3 );
1669 }
1670 else if ( mSelectedFeatureIds.size() > 1 )
1671 {
1672 QgsDebugMsgLevel( QStringLiteral( "Number of selected features >1" ), 3 );
1674 }
1675
1676 QgsVectorLayerEditUtils utils( this );
1677 Qgis::GeometryOperationResult result = utils.addPart( points, *mSelectedFeatureIds.constBegin() );
1678
1680 updateExtents();
1681 return result;
1682}
1683
1685{
1687
1688 if ( !isValid() || !mEditBuffer || !mDataProvider )
1690
1691 //number of selected features must be 1
1692
1693 if ( mSelectedFeatureIds.empty() )
1694 {
1695 QgsDebugMsgLevel( QStringLiteral( "Number of selected features <1" ), 3 );
1697 }
1698 else if ( mSelectedFeatureIds.size() > 1 )
1699 {
1700 QgsDebugMsgLevel( QStringLiteral( "Number of selected features >1" ), 3 );
1702 }
1703
1704 QgsVectorLayerEditUtils utils( this );
1705 Qgis::GeometryOperationResult result = utils.addPart( ring, *mSelectedFeatureIds.constBegin() );
1706
1708 updateExtents();
1709 return result;
1710}
1711
1712// TODO QGIS 4.0 -- this should return Qgis::GeometryOperationResult, not int
1713int QgsVectorLayer::translateFeature( QgsFeatureId featureId, double dx, double dy )
1714{
1716
1717 if ( !isValid() || !mEditBuffer || !mDataProvider )
1718 return static_cast< int >( Qgis::GeometryOperationResult::LayerNotEditable );
1719
1720 QgsVectorLayerEditUtils utils( this );
1721 int result = utils.translateFeature( featureId, dx, dy );
1722
1723 if ( result == static_cast< int >( Qgis::GeometryOperationResult::Success ) )
1724 updateExtents();
1725 return result;
1726}
1727
1728Qgis::GeometryOperationResult QgsVectorLayer::splitParts( const QVector<QgsPointXY> &splitLine, bool topologicalEditing )
1729{
1731
1732 return splitParts( vectorPointXY2pointSequence( splitLine ), topologicalEditing );
1733}
1734
1736{
1738
1739 if ( !isValid() || !mEditBuffer || !mDataProvider )
1741
1742 QgsVectorLayerEditUtils utils( this );
1743 return utils.splitParts( splitLine, topologicalEditing );
1744}
1745
1746Qgis::GeometryOperationResult QgsVectorLayer::splitFeatures( const QVector<QgsPointXY> &splitLine, bool topologicalEditing )
1747{
1749
1750 return splitFeatures( vectorPointXY2pointSequence( splitLine ), topologicalEditing );
1751}
1752
1754{
1756
1757 QgsLineString splitLineString( splitLine );
1758 QgsPointSequence topologyTestPoints;
1759 bool preserveCircular = false;
1760 return splitFeatures( &splitLineString, topologyTestPoints, preserveCircular, topologicalEditing );
1761}
1762
1763Qgis::GeometryOperationResult QgsVectorLayer::splitFeatures( const QgsCurve *curve, QgsPointSequence &topologyTestPoints, bool preserveCircular, bool topologicalEditing )
1764{
1766
1767 if ( !isValid() || !mEditBuffer || !mDataProvider )
1769
1770 QgsVectorLayerEditUtils utils( this );
1771 return utils.splitFeatures( curve, topologyTestPoints, preserveCircular, topologicalEditing );
1772}
1773
1775{
1777
1778 if ( !isValid() || !mEditBuffer || !mDataProvider )
1779 return -1;
1780
1781 QgsVectorLayerEditUtils utils( this );
1782 return utils.addTopologicalPoints( geom );
1783}
1784
1791
1793{
1795
1796 if ( !isValid() || !mEditBuffer || !mDataProvider )
1797 return -1;
1798
1799 QgsVectorLayerEditUtils utils( this );
1800 return utils.addTopologicalPoints( p );
1801}
1802
1804{
1806
1807 if ( !mValid || !mEditBuffer || !mDataProvider )
1808 return -1;
1809
1810 QgsVectorLayerEditUtils utils( this );
1811 return utils.addTopologicalPoints( ps );
1812}
1813
1815{
1817
1818 if ( mLabeling == labeling )
1819 return;
1820
1821 delete mLabeling;
1822 mLabeling = labeling;
1823}
1824
1826{
1828
1829 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
1830 return project()->startEditing( this );
1831
1832 if ( !isValid() || !mDataProvider )
1833 {
1834 return false;
1835 }
1836
1837 // allow editing if provider supports any of the capabilities
1838 if ( !supportsEditing() )
1839 {
1840 return false;
1841 }
1842
1843 if ( mEditBuffer )
1844 {
1845 // editing already underway
1846 return false;
1847 }
1848
1849 mDataProvider->enterUpdateMode();
1850
1851 emit beforeEditingStarted();
1852
1853 createEditBuffer();
1854
1855 updateFields();
1856
1857 emit editingStarted();
1858
1859 return true;
1860}
1861
1863{
1865
1866 if ( mDataProvider )
1867 mDataProvider->setTransformContext( transformContext );
1868}
1869
1876
1878{
1880
1881 if ( mRenderer )
1882 if ( !mRenderer->accept( visitor ) )
1883 return false;
1884
1885 if ( mLabeling )
1886 if ( !mLabeling->accept( visitor ) )
1887 return false;
1888
1889 return true;
1890}
1891
1892bool QgsVectorLayer::readXml( const QDomNode &layer_node, QgsReadWriteContext &context )
1893{
1895
1896 QgsDebugMsgLevel( QStringLiteral( "Datasource in QgsVectorLayer::readXml: %1" ).arg( mDataSource.toLocal8Bit().data() ), 3 );
1897
1898 //process provider key
1899 QDomNode pkeyNode = layer_node.namedItem( QStringLiteral( "provider" ) );
1900
1901 if ( pkeyNode.isNull() )
1902 {
1903 mProviderKey.clear();
1904 }
1905 else
1906 {
1907 QDomElement pkeyElt = pkeyNode.toElement();
1908 mProviderKey = pkeyElt.text();
1909 }
1910
1911 // determine type of vector layer
1912 if ( !mProviderKey.isNull() )
1913 {
1914 // if the provider string isn't empty, then we successfully
1915 // got the stored provider
1916 }
1917 else if ( mDataSource.contains( QLatin1String( "dbname=" ) ) )
1918 {
1919 mProviderKey = QStringLiteral( "postgres" );
1920 }
1921 else
1922 {
1923 mProviderKey = QStringLiteral( "ogr" );
1924 }
1925
1926 const QDomElement elem = layer_node.toElement();
1928
1929 mDataSourceReadOnly = mReadFlags & QgsMapLayer::FlagForceReadOnly;
1931
1932 if ( ( mReadFlags & QgsMapLayer::FlagDontResolveLayers ) || !setDataProvider( mProviderKey, options, flags ) )
1933 {
1935 {
1936 QgsDebugError( QStringLiteral( "Could not set data provider for layer %1" ).arg( publicSource() ) );
1937 }
1938
1939 // for invalid layer sources, we fallback to stored wkbType if available
1940 if ( elem.hasAttribute( QStringLiteral( "wkbType" ) ) )
1941 mWkbType = qgsEnumKeyToValue( elem.attribute( QStringLiteral( "wkbType" ) ), mWkbType );
1942 }
1943
1944 QDomElement pkeyElem = pkeyNode.toElement();
1945 if ( !pkeyElem.isNull() )
1946 {
1947 QString encodingString = pkeyElem.attribute( QStringLiteral( "encoding" ) );
1948 if ( mDataProvider && !encodingString.isEmpty() )
1949 {
1950 mDataProvider->setEncoding( encodingString );
1951 }
1952 }
1953
1954 // load vector joins - does not resolve references to layers yet
1955 mJoinBuffer->readXml( layer_node );
1956
1957 updateFields();
1958
1959 // If style doesn't include a legend, we'll need to make a default one later...
1960 mSetLegendFromStyle = false;
1961
1962 QString errorMsg;
1963 if ( !readSymbology( layer_node, errorMsg, context ) )
1964 {
1965 return false;
1966 }
1967
1968 readStyleManager( layer_node );
1969
1970 QDomNode depsNode = layer_node.namedItem( QStringLiteral( "dataDependencies" ) );
1971 QDomNodeList depsNodes = depsNode.childNodes();
1972 QSet<QgsMapLayerDependency> sources;
1973 for ( int i = 0; i < depsNodes.count(); i++ )
1974 {
1975 QString source = depsNodes.at( i ).toElement().attribute( QStringLiteral( "id" ) );
1976 sources << QgsMapLayerDependency( source );
1977 }
1978 setDependencies( sources );
1979
1980 if ( !mSetLegendFromStyle )
1982
1983 // read extent
1985 {
1986 mReadExtentFromXml = true;
1987 }
1988 if ( mReadExtentFromXml )
1989 {
1990 const QDomNode extentNode = layer_node.namedItem( QStringLiteral( "extent" ) );
1991 if ( !extentNode.isNull() )
1992 {
1993 mXmlExtent2D = QgsXmlUtils::readRectangle( extentNode.toElement() );
1994 }
1995 const QDomNode extent3DNode = layer_node.namedItem( QStringLiteral( "extent3D" ) );
1996 if ( !extent3DNode.isNull() )
1997 {
1998 mXmlExtent3D = QgsXmlUtils::readBox3D( extent3DNode.toElement() );
1999 }
2000 }
2001
2002 // auxiliary layer
2003 const QDomNode asNode = layer_node.namedItem( QStringLiteral( "auxiliaryLayer" ) );
2004 const QDomElement asElem = asNode.toElement();
2005 if ( !asElem.isNull() )
2006 {
2007 mAuxiliaryLayerKey = asElem.attribute( QStringLiteral( "key" ) );
2008 }
2009
2010 // QGIS Server WMS Dimensions
2011 mServerProperties->readXml( layer_node );
2012
2013 return isValid(); // should be true if read successfully
2014
2015} // void QgsVectorLayer::readXml
2016
2017
2018void QgsVectorLayer::setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider,
2020{
2022
2023 Qgis::GeometryType geomType = geometryType();
2024
2025 mDataSource = dataSource;
2026 setName( baseName );
2027 setDataProvider( provider, options, flags );
2028
2029 if ( !isValid() )
2030 {
2031 return;
2032 }
2033
2034 // Always set crs
2036
2037 bool loadDefaultStyleFlag = false;
2039 {
2040 loadDefaultStyleFlag = true;
2041 }
2042
2043 // reset style if loading default style, style is missing, or geometry type is has changed (and layer is valid)
2044 if ( !renderer() || !legend() || ( isValid() && geomType != geometryType() ) || loadDefaultStyleFlag )
2045 {
2046 std::unique_ptr< QgsScopedRuntimeProfile > profile;
2047 if ( QgsApplication::profiler()->groupIsActive( QStringLiteral( "projectload" ) ) )
2048 profile = std::make_unique< QgsScopedRuntimeProfile >( tr( "Load layer style" ), QStringLiteral( "projectload" ) );
2049
2050 bool defaultLoadedFlag = false;
2051
2052 // defer style changed signal until we've set the renderer, labeling, everything.
2053 // we don't want multiple signals!
2054 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
2055
2056 // need to check whether the default style included a legend, and if not, we need to make a default legend
2057 // later...
2058 mSetLegendFromStyle = false;
2059
2060 // first check if there is a default style / propertysheet defined
2061 // for this layer and if so apply it
2062 // this should take precedence over all
2063 if ( !defaultLoadedFlag && loadDefaultStyleFlag )
2064 {
2065 loadDefaultStyle( defaultLoadedFlag );
2066 }
2067
2068 if ( loadDefaultStyleFlag && !defaultLoadedFlag && isSpatial() && mDataProvider->capabilities() & Qgis::VectorProviderCapability::CreateRenderer )
2069 {
2070 // if we didn't load a default style for this layer, try to create a renderer directly from the data provider
2071 std::unique_ptr< QgsFeatureRenderer > defaultRenderer( mDataProvider->createRenderer() );
2072 if ( defaultRenderer )
2073 {
2074 defaultLoadedFlag = true;
2075 setRenderer( defaultRenderer.release() );
2076 }
2077 }
2078
2079 // if the default style failed to load or was disabled use some very basic defaults
2080 if ( !defaultLoadedFlag )
2081 {
2082 // add single symbol renderer for spatial layers
2084 }
2085
2086 if ( !mSetLegendFromStyle )
2088
2090 {
2091 std::unique_ptr< QgsAbstractVectorLayerLabeling > defaultLabeling( mDataProvider->createLabeling() );
2092 if ( defaultLabeling )
2093 {
2094 setLabeling( defaultLabeling.release() );
2095 setLabelsEnabled( true );
2096 }
2097 }
2098
2099 styleChangedSignalBlocker.release();
2101 }
2102}
2103
2104QString QgsVectorLayer::loadDefaultStyle( bool &resultFlag )
2105{
2107
2108 // first try to load a user-defined default style - this should always take precedence
2109 QString styleXml = QgsMapLayer::loadDefaultStyle( resultFlag );
2110
2111 if ( resultFlag )
2112 {
2113 // Try to load all stored styles from DB
2114 if ( mLoadAllStoredStyle && mDataProvider && mDataProvider->styleStorageCapabilities().testFlag( Qgis::ProviderStyleStorageCapability::LoadFromDatabase ) )
2115 {
2116 QStringList ids, names, descriptions;
2117 QString errorMessage;
2118 // Get the number of styles related to current layer.
2119 const int relatedStylesCount { listStylesInDatabase( ids, names, descriptions, errorMessage ) };
2120 Q_ASSERT( ids.count() == names.count() );
2121 const QString currentStyleName { mStyleManager->currentStyle() };
2122 for ( int i = 0; i < relatedStylesCount; ++i )
2123 {
2124 if ( names.at( i ) == currentStyleName )
2125 {
2126 continue;
2127 }
2128 errorMessage.clear();
2129 const QString styleXml { getStyleFromDatabase( ids.at( i ), errorMessage ) };
2130 if ( ! styleXml.isEmpty() && errorMessage.isEmpty() )
2131 {
2132 mStyleManager->addStyle( names.at( i ), QgsMapLayerStyle( styleXml ) );
2133 }
2134 else
2135 {
2136 QgsDebugMsgLevel( QStringLiteral( "Error retrieving style %1 from DB: %2" ).arg( ids.at( i ), errorMessage ), 2 );
2137 }
2138 }
2139 }
2140 return styleXml ;
2141 }
2142
2144 {
2145 // otherwise try to create a renderer directly from the data provider
2146 std::unique_ptr< QgsFeatureRenderer > defaultRenderer( mDataProvider->createRenderer() );
2147 if ( defaultRenderer )
2148 {
2149 resultFlag = true;
2150 setRenderer( defaultRenderer.release() );
2151 return QString();
2152 }
2153 }
2154
2155 return QString();
2156}
2157
2158bool QgsVectorLayer::setDataProvider( QString const &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags )
2159{
2161
2162 mProviderKey = provider;
2163 delete mDataProvider;
2164
2165 // For Postgres provider primary key unicity is tested at construction time,
2166 // so it has to be set before initializing the provider,
2167 // this manipulation is necessary to preserve default behavior when
2168 // "trust layer metadata" project level option is set and checkPrimaryKeyUnicity
2169 // was not explicitly passed in the uri
2170 if ( provider.compare( QLatin1String( "postgres" ) ) == 0 )
2171 {
2172 const QString checkUnicityKey { QStringLiteral( "checkPrimaryKeyUnicity" ) };
2174 if ( ! uri.hasParam( checkUnicityKey ) )
2175 {
2176 uri.setParam( checkUnicityKey, mReadExtentFromXml ? "0" : "1" );
2177 mDataSource = uri.uri( false );
2178 }
2179 }
2180
2181 std::unique_ptr< QgsScopedRuntimeProfile > profile;
2182 if ( QgsApplication::profiler()->groupIsActive( QStringLiteral( "projectload" ) ) )
2183 profile = std::make_unique< QgsScopedRuntimeProfile >( tr( "Create %1 provider" ).arg( provider ), QStringLiteral( "projectload" ) );
2184
2185 if ( mPreloadedProvider )
2186 mDataProvider = qobject_cast< QgsVectorDataProvider * >( mPreloadedProvider.release() );
2187 else
2188 mDataProvider = qobject_cast<QgsVectorDataProvider *>( QgsProviderRegistry::instance()->createProvider( provider, mDataSource, options, flags ) );
2189
2190 if ( !mDataProvider )
2191 {
2192 setValid( false );
2193 QgsDebugMsgLevel( QStringLiteral( "Unable to get data provider" ), 2 );
2194 return false;
2195 }
2196
2197 mDataProvider->setParent( this );
2198 connect( mDataProvider, &QgsVectorDataProvider::raiseError, this, &QgsVectorLayer::raiseError );
2199
2200 QgsDebugMsgLevel( QStringLiteral( "Instantiated the data provider plugin" ), 2 );
2201
2202 setValid( mDataProvider->isValid() );
2203 if ( !isValid() )
2204 {
2205 QgsDebugMsgLevel( QStringLiteral( "Invalid provider plugin %1" ).arg( QString( mDataSource.toUtf8() ) ), 2 );
2206 return false;
2207 }
2208
2209 if ( profile )
2210 profile->switchTask( tr( "Read layer metadata" ) );
2212 {
2213 // we combine the provider metadata with the layer's existing metadata, so as not to reset any user customizations to the metadata
2214 // back to the default if a layer's data source is changed
2215 QgsLayerMetadata newMetadata = mDataProvider->layerMetadata();
2216 // this overwrites the provider metadata with any properties which are non-empty from the existing layer metadata
2217 newMetadata.combine( &mMetadata );
2218
2219 setMetadata( newMetadata );
2220 QgsDebugMsgLevel( QStringLiteral( "Set Data provider QgsLayerMetadata identifier[%1]" ).arg( metadata().identifier() ), 4 );
2221 }
2222
2223 // TODO: Check if the provider has the capability to send fullExtentCalculated
2224 connect( mDataProvider, &QgsVectorDataProvider::fullExtentCalculated, this, [this] { updateExtents(); } );
2225
2226 // get and store the feature type
2227 mWkbType = mDataProvider->wkbType();
2228
2229 // before we update the layer fields from the provider, we first copy any default set alias and
2230 // editor widget config from the data provider fields, if present
2231 const QgsFields providerFields = mDataProvider->fields();
2232 for ( const QgsField &field : providerFields )
2233 {
2234 // we only copy defaults from the provider if we aren't overriding any configuration made in the layer
2235 if ( !field.editorWidgetSetup().isNull() && mFieldWidgetSetups.value( field.name() ).isNull() )
2236 {
2237 mFieldWidgetSetups[ field.name() ] = field.editorWidgetSetup();
2238 }
2239 if ( !field.alias().isEmpty() && mAttributeAliasMap.value( field.name() ).isEmpty() )
2240 {
2241 mAttributeAliasMap[ field.name() ] = field.alias();
2242 }
2243 if ( !mAttributeSplitPolicy.contains( field.name() ) )
2244 {
2245 mAttributeSplitPolicy[ field.name() ] = field.splitPolicy();
2246 }
2247 if ( !mAttributeDuplicatePolicy.contains( field.name() ) )
2248 {
2249 mAttributeDuplicatePolicy[ field.name() ] = field.duplicatePolicy();
2250 }
2251 }
2252
2253 if ( profile )
2254 profile->switchTask( tr( "Read layer fields" ) );
2255 updateFields();
2256
2257 if ( mProviderKey == QLatin1String( "postgres" ) )
2258 {
2259 // update datasource from data provider computed one
2260 mDataSource = mDataProvider->dataSourceUri( false );
2261
2262 QgsDebugMsgLevel( QStringLiteral( "Beautifying layer name %1" ).arg( name() ), 3 );
2263
2264 // adjust the display name for postgres layers
2265 const thread_local QRegularExpression reg( R"lit("[^"]+"\."([^"] + )"( \‍([^)]+\))?)lit" );
2266 const QRegularExpressionMatch match = reg.match( name() );
2267 if ( match.hasMatch() )
2268 {
2269 QStringList stuff = match.capturedTexts();
2270 QString lName = stuff[1];
2271
2272 const QMap<QString, QgsMapLayer *> &layers = QgsProject::instance()->mapLayers(); // skip-keyword-check
2273
2274 QMap<QString, QgsMapLayer *>::const_iterator it;
2275 for ( it = layers.constBegin(); it != layers.constEnd() && ( *it )->name() != lName; ++it )
2276 ;
2277
2278 if ( it != layers.constEnd() && stuff.size() > 2 )
2279 {
2280 lName += '.' + stuff[2].mid( 2, stuff[2].length() - 3 );
2281 }
2282
2283 if ( !lName.isEmpty() )
2284 setName( lName );
2285 }
2286 QgsDebugMsgLevel( QStringLiteral( "Beautified layer name %1" ).arg( name() ), 3 );
2287 }
2288 else if ( mProviderKey == QLatin1String( "osm" ) )
2289 {
2290 // make sure that the "observer" has been removed from URI to avoid crashes
2291 mDataSource = mDataProvider->dataSourceUri();
2292 }
2293 else if ( provider == QLatin1String( "ogr" ) )
2294 {
2295 // make sure that the /vsigzip or /vsizip is added to uri, if applicable
2296 mDataSource = mDataProvider->dataSourceUri();
2297 if ( mDataSource.right( 10 ) == QLatin1String( "|layerid=0" ) )
2298 mDataSource.chop( 10 );
2299 }
2300 else if ( provider == QLatin1String( "memory" ) )
2301 {
2302 // required so that source differs between memory layers
2303 mDataSource = mDataSource + QStringLiteral( "&uid=%1" ).arg( QUuid::createUuid().toString() );
2304 }
2305 else if ( provider == QLatin1String( "hana" ) )
2306 {
2307 // update datasource from data provider computed one
2308 mDataSource = mDataProvider->dataSourceUri( false );
2309 }
2310
2311 connect( mDataProvider, &QgsVectorDataProvider::dataChanged, this, &QgsVectorLayer::emitDataChanged );
2313
2314 return true;
2315} // QgsVectorLayer:: setDataProvider
2316
2317
2318
2319
2320/* virtual */
2321bool QgsVectorLayer::writeXml( QDomNode &layer_node,
2322 QDomDocument &document,
2323 const QgsReadWriteContext &context ) const
2324{
2326
2327 // first get the layer element so that we can append the type attribute
2328
2329 QDomElement mapLayerNode = layer_node.toElement();
2330
2331 if ( mapLayerNode.isNull() || ( "maplayer" != mapLayerNode.nodeName() ) )
2332 {
2333 QgsDebugMsgLevel( QStringLiteral( "can't find <maplayer>" ), 2 );
2334 return false;
2335 }
2336
2337 mapLayerNode.setAttribute( QStringLiteral( "type" ), QgsMapLayerFactory::typeToString( Qgis::LayerType::Vector ) );
2338
2339 // set the geometry type
2340 mapLayerNode.setAttribute( QStringLiteral( "geometry" ), QgsWkbTypes::geometryDisplayString( geometryType() ) );
2341 mapLayerNode.setAttribute( QStringLiteral( "wkbType" ), qgsEnumValueToKey( wkbType() ) );
2342
2343 // add provider node
2344 if ( mDataProvider )
2345 {
2346 QDomElement provider = document.createElement( QStringLiteral( "provider" ) );
2347 provider.setAttribute( QStringLiteral( "encoding" ), mDataProvider->encoding() );
2348 QDomText providerText = document.createTextNode( providerType() );
2349 provider.appendChild( providerText );
2350 layer_node.appendChild( provider );
2351 }
2352
2353 //save joins
2354 mJoinBuffer->writeXml( layer_node, document );
2355
2356 // dependencies
2357 QDomElement dependenciesElement = document.createElement( QStringLiteral( "layerDependencies" ) );
2358 const auto constDependencies = dependencies();
2359 for ( const QgsMapLayerDependency &dep : constDependencies )
2360 {
2362 continue;
2363 QDomElement depElem = document.createElement( QStringLiteral( "layer" ) );
2364 depElem.setAttribute( QStringLiteral( "id" ), dep.layerId() );
2365 dependenciesElement.appendChild( depElem );
2366 }
2367 layer_node.appendChild( dependenciesElement );
2368
2369 // change dependencies
2370 QDomElement dataDependenciesElement = document.createElement( QStringLiteral( "dataDependencies" ) );
2371 for ( const QgsMapLayerDependency &dep : constDependencies )
2372 {
2373 if ( dep.type() != QgsMapLayerDependency::DataDependency )
2374 continue;
2375 QDomElement depElem = document.createElement( QStringLiteral( "layer" ) );
2376 depElem.setAttribute( QStringLiteral( "id" ), dep.layerId() );
2377 dataDependenciesElement.appendChild( depElem );
2378 }
2379 layer_node.appendChild( dataDependenciesElement );
2380
2381 // save expression fields
2382 mExpressionFieldBuffer->writeXml( layer_node, document );
2383
2384 writeStyleManager( layer_node, document );
2385
2386 // auxiliary layer
2387 QDomElement asElem = document.createElement( QStringLiteral( "auxiliaryLayer" ) );
2388 if ( mAuxiliaryLayer )
2389 {
2390 const QString pkField = mAuxiliaryLayer->joinInfo().targetFieldName();
2391 asElem.setAttribute( QStringLiteral( "key" ), pkField );
2392 }
2393 layer_node.appendChild( asElem );
2394
2395 // save QGIS Server properties (WMS Dimension, metadata URLS...)
2396 mServerProperties->writeXml( layer_node, document );
2397
2398 // renderer specific settings
2399 QString errorMsg;
2400 return writeSymbology( layer_node, document, errorMsg, context );
2401}
2402
2403QString QgsVectorLayer::encodedSource( const QString &source, const QgsReadWriteContext &context ) const
2404{
2406
2407 if ( providerType() == QLatin1String( "memory" ) )
2408 {
2409 // Refetch the source from the provider, because adding fields actually changes the source for this provider.
2410 return dataProvider()->dataSourceUri();
2411 }
2412
2414}
2415
2416QString QgsVectorLayer::decodedSource( const QString &source, const QString &provider, const QgsReadWriteContext &context ) const
2417{
2419
2420 return QgsProviderRegistry::instance()->relativeToAbsoluteUri( provider, source, context );
2421}
2422
2423
2424
2432
2433
2434bool QgsVectorLayer::readSymbology( const QDomNode &layerNode, QString &errorMessage,
2436{
2438
2439 if ( categories.testFlag( Fields ) )
2440 {
2441 if ( !mExpressionFieldBuffer )
2442 mExpressionFieldBuffer = new QgsExpressionFieldBuffer();
2443 mExpressionFieldBuffer->readXml( layerNode );
2444
2445 updateFields();
2446 }
2447
2448 if ( categories.testFlag( Relations ) )
2449 {
2450 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Relations" ) );
2451
2452 // Restore referenced layers: relations where "this" is the child layer (the referencing part, that holds the FK)
2453 QDomNodeList referencedLayersNodeList = layerNode.toElement().elementsByTagName( QStringLiteral( "referencedLayers" ) );
2454 if ( referencedLayersNodeList.size() > 0 )
2455 {
2456 const QDomNodeList relationNodes { referencedLayersNodeList.at( 0 ).childNodes() };
2457 for ( int i = 0; i < relationNodes.length(); ++i )
2458 {
2459 const QDomElement relationElement = relationNodes.at( i ).toElement();
2460
2461 mWeakRelations.push_back( QgsWeakRelation::readXml( this, QgsWeakRelation::Referencing, relationElement, context.pathResolver() ) );
2462 }
2463 }
2464
2465 // Restore referencing layers: relations where "this" is the parent layer (the referenced part where the FK points to)
2466 QDomNodeList referencingLayersNodeList = layerNode.toElement().elementsByTagName( QStringLiteral( "referencingLayers" ) );
2467 if ( referencingLayersNodeList.size() > 0 )
2468 {
2469 const QDomNodeList relationNodes { referencingLayersNodeList.at( 0 ).childNodes() };
2470 for ( int i = 0; i < relationNodes.length(); ++i )
2471 {
2472 const QDomElement relationElement = relationNodes.at( i ).toElement();
2473 mWeakRelations.push_back( QgsWeakRelation::readXml( this, QgsWeakRelation::Referenced, relationElement, context.pathResolver() ) );
2474 }
2475 }
2476 }
2477
2478 QDomElement layerElement = layerNode.toElement();
2479
2480 readCommonStyle( layerElement, context, categories );
2481
2482 readStyle( layerNode, errorMessage, context, categories );
2483
2484 if ( categories.testFlag( MapTips ) )
2485 {
2486 QDomElement mapTipElem = layerNode.namedItem( QStringLiteral( "mapTip" ) ).toElement();
2487 setMapTipTemplate( mapTipElem.text() );
2488 setMapTipsEnabled( mapTipElem.attribute( QStringLiteral( "enabled" ), QStringLiteral( "1" ) ).toInt() == 1 );
2489 }
2490
2491 if ( categories.testFlag( LayerConfiguration ) )
2492 mDisplayExpression = layerNode.namedItem( QStringLiteral( "previewExpression" ) ).toElement().text();
2493
2494 // Try to migrate pre QGIS 3.0 display field property
2495 QString displayField = layerNode.namedItem( QStringLiteral( "displayfield" ) ).toElement().text();
2496 if ( mFields.lookupField( displayField ) < 0 )
2497 {
2498 // if it's not a field, it's a maptip
2499 if ( mMapTipTemplate.isEmpty() && categories.testFlag( MapTips ) )
2500 mMapTipTemplate = displayField;
2501 }
2502 else
2503 {
2504 if ( mDisplayExpression.isEmpty() && categories.testFlag( LayerConfiguration ) )
2505 mDisplayExpression = QgsExpression::quotedColumnRef( displayField );
2506 }
2507
2508 // process the attribute actions
2509 if ( categories.testFlag( Actions ) )
2510 mActions->readXml( layerNode );
2511
2512 if ( categories.testFlag( Fields ) )
2513 {
2514 // IMPORTANT - we don't clear mAttributeAliasMap here, as it may contain aliases which are coming direct
2515 // from the data provider. Instead we leave any existing aliases and only overwrite them if the style
2516 // has a specific value for that field's alias
2517 QDomNode aliasesNode = layerNode.namedItem( QStringLiteral( "aliases" ) );
2518 if ( !aliasesNode.isNull() )
2519 {
2520 QDomElement aliasElem;
2521
2522 QDomNodeList aliasNodeList = aliasesNode.toElement().elementsByTagName( QStringLiteral( "alias" ) );
2523 for ( int i = 0; i < aliasNodeList.size(); ++i )
2524 {
2525 aliasElem = aliasNodeList.at( i ).toElement();
2526
2527 QString field;
2528 if ( aliasElem.hasAttribute( QStringLiteral( "field" ) ) )
2529 {
2530 field = aliasElem.attribute( QStringLiteral( "field" ) );
2531 }
2532 else
2533 {
2534 int index = aliasElem.attribute( QStringLiteral( "index" ) ).toInt();
2535
2536 if ( index >= 0 && index < fields().count() )
2537 field = fields().at( index ).name();
2538 }
2539
2540 QString alias;
2541
2542 if ( !aliasElem.attribute( QStringLiteral( "name" ) ).isEmpty() )
2543 {
2544 //if it has alias
2545 alias = context.projectTranslator()->translate( QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ), aliasElem.attribute( QStringLiteral( "name" ) ) );
2546 QgsDebugMsgLevel( "context" + QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ) + " source " + aliasElem.attribute( QStringLiteral( "name" ) ), 3 );
2547 }
2548 else
2549 {
2550 //if it has no alias, it should be the fields translation
2551 alias = context.projectTranslator()->translate( QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ), field );
2552 QgsDebugMsgLevel( "context" + QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ) + " source " + field, 3 );
2553 //if it gets the exact field value, there has been no translation (or not even translation loaded) - so no alias should be generated;
2554 if ( alias == aliasElem.attribute( QStringLiteral( "field" ) ) )
2555 alias.clear();
2556 }
2557
2558 QgsDebugMsgLevel( "field " + field + " origalias " + aliasElem.attribute( QStringLiteral( "name" ) ) + " trans " + alias, 3 );
2559 mAttributeAliasMap.insert( field, alias );
2560 }
2561 }
2562
2563 // IMPORTANT - we don't clear mAttributeSplitPolicy here, as it may contain policies which are coming direct
2564 // from the data provider. Instead we leave any existing policies and only overwrite them if the style
2565 // has a specific value for that field's policy
2566 const QDomNode splitPoliciesNode = layerNode.namedItem( QStringLiteral( "splitPolicies" ) );
2567 if ( !splitPoliciesNode.isNull() )
2568 {
2569 const QDomNodeList splitPolicyNodeList = splitPoliciesNode.toElement().elementsByTagName( QStringLiteral( "policy" ) );
2570 for ( int i = 0; i < splitPolicyNodeList.size(); ++i )
2571 {
2572 const QDomElement splitPolicyElem = splitPolicyNodeList.at( i ).toElement();
2573 const QString field = splitPolicyElem.attribute( QStringLiteral( "field" ) );
2574 const Qgis::FieldDomainSplitPolicy policy = qgsEnumKeyToValue( splitPolicyElem.attribute( QStringLiteral( "policy" ) ), Qgis::FieldDomainSplitPolicy::Duplicate );
2575 mAttributeSplitPolicy.insert( field, policy );
2576 }
2577 }
2578
2579 // The duplicate policy is - unlike alias and split policy - never defined by the data provider, so we clear the map
2580 mAttributeDuplicatePolicy.clear();
2581 const QDomNode duplicatePoliciesNode = layerNode.namedItem( QStringLiteral( "duplicatePolicies" ) );
2582 if ( !duplicatePoliciesNode.isNull() )
2583 {
2584 const QDomNodeList duplicatePolicyNodeList = duplicatePoliciesNode.toElement().elementsByTagName( QStringLiteral( "policy" ) );
2585 for ( int i = 0; i < duplicatePolicyNodeList.size(); ++i )
2586 {
2587 const QDomElement duplicatePolicyElem = duplicatePolicyNodeList.at( i ).toElement();
2588 const QString field = duplicatePolicyElem.attribute( QStringLiteral( "field" ) );
2589 const Qgis::FieldDuplicatePolicy policy = qgsEnumKeyToValue( duplicatePolicyElem.attribute( QStringLiteral( "policy" ) ), Qgis::FieldDuplicatePolicy::Duplicate );
2590 mAttributeDuplicatePolicy.insert( field, policy );
2591 }
2592 }
2593
2594 // default expressions
2595 mDefaultExpressionMap.clear();
2596 QDomNode defaultsNode = layerNode.namedItem( QStringLiteral( "defaults" ) );
2597 if ( !defaultsNode.isNull() )
2598 {
2599 QDomNodeList defaultNodeList = defaultsNode.toElement().elementsByTagName( QStringLiteral( "default" ) );
2600 for ( int i = 0; i < defaultNodeList.size(); ++i )
2601 {
2602 QDomElement defaultElem = defaultNodeList.at( i ).toElement();
2603
2604 QString field = defaultElem.attribute( QStringLiteral( "field" ), QString() );
2605 QString expression = defaultElem.attribute( QStringLiteral( "expression" ), QString() );
2606 bool applyOnUpdate = defaultElem.attribute( QStringLiteral( "applyOnUpdate" ), QStringLiteral( "0" ) ) == QLatin1String( "1" );
2607 if ( field.isEmpty() || expression.isEmpty() )
2608 continue;
2609
2610 mDefaultExpressionMap.insert( field, QgsDefaultValue( expression, applyOnUpdate ) );
2611 }
2612 }
2613
2614 // constraints
2615 mFieldConstraints.clear();
2616 mFieldConstraintStrength.clear();
2617 QDomNode constraintsNode = layerNode.namedItem( QStringLiteral( "constraints" ) );
2618 if ( !constraintsNode.isNull() )
2619 {
2620 QDomNodeList constraintNodeList = constraintsNode.toElement().elementsByTagName( QStringLiteral( "constraint" ) );
2621 for ( int i = 0; i < constraintNodeList.size(); ++i )
2622 {
2623 QDomElement constraintElem = constraintNodeList.at( i ).toElement();
2624
2625 QString field = constraintElem.attribute( QStringLiteral( "field" ), QString() );
2626 int constraints = constraintElem.attribute( QStringLiteral( "constraints" ), QStringLiteral( "0" ) ).toInt();
2627 if ( field.isEmpty() || constraints == 0 )
2628 continue;
2629
2630 mFieldConstraints.insert( field, static_cast< QgsFieldConstraints::Constraints >( constraints ) );
2631
2632 int uniqueStrength = constraintElem.attribute( QStringLiteral( "unique_strength" ), QStringLiteral( "1" ) ).toInt();
2633 int notNullStrength = constraintElem.attribute( QStringLiteral( "notnull_strength" ), QStringLiteral( "1" ) ).toInt();
2634 int expStrength = constraintElem.attribute( QStringLiteral( "exp_strength" ), QStringLiteral( "1" ) ).toInt();
2635
2636 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintUnique ), static_cast< QgsFieldConstraints::ConstraintStrength >( uniqueStrength ) );
2637 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintNotNull ), static_cast< QgsFieldConstraints::ConstraintStrength >( notNullStrength ) );
2638 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintExpression ), static_cast< QgsFieldConstraints::ConstraintStrength >( expStrength ) );
2639 }
2640 }
2641 mFieldConstraintExpressions.clear();
2642 QDomNode constraintExpressionsNode = layerNode.namedItem( QStringLiteral( "constraintExpressions" ) );
2643 if ( !constraintExpressionsNode.isNull() )
2644 {
2645 QDomNodeList constraintNodeList = constraintExpressionsNode.toElement().elementsByTagName( QStringLiteral( "constraint" ) );
2646 for ( int i = 0; i < constraintNodeList.size(); ++i )
2647 {
2648 QDomElement constraintElem = constraintNodeList.at( i ).toElement();
2649
2650 QString field = constraintElem.attribute( QStringLiteral( "field" ), QString() );
2651 QString exp = constraintElem.attribute( QStringLiteral( "exp" ), QString() );
2652 QString desc = constraintElem.attribute( QStringLiteral( "desc" ), QString() );
2653 if ( field.isEmpty() || exp.isEmpty() )
2654 continue;
2655
2656 mFieldConstraintExpressions.insert( field, qMakePair( exp, desc ) );
2657 }
2658 }
2659
2660 updateFields();
2661 }
2662
2663 // load field configuration
2664 if ( categories.testFlag( Fields ) || categories.testFlag( Forms ) )
2665 {
2666 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Forms" ) );
2667
2668 QDomElement widgetsElem = layerNode.namedItem( QStringLiteral( "fieldConfiguration" ) ).toElement();
2669 QDomNodeList fieldConfigurationElementList = widgetsElem.elementsByTagName( QStringLiteral( "field" ) );
2670 for ( int i = 0; i < fieldConfigurationElementList.size(); ++i )
2671 {
2672 const QDomElement fieldConfigElement = fieldConfigurationElementList.at( i ).toElement();
2673 const QDomElement fieldWidgetElement = fieldConfigElement.elementsByTagName( QStringLiteral( "editWidget" ) ).at( 0 ).toElement();
2674
2675 QString fieldName = fieldConfigElement.attribute( QStringLiteral( "name" ) );
2676
2677 if ( categories.testFlag( Fields ) )
2678 mFieldConfigurationFlags[fieldName] = qgsFlagKeysToValue( fieldConfigElement.attribute( QStringLiteral( "configurationFlags" ) ), Qgis::FieldConfigurationFlag::NoFlag );
2679
2680 // Load editor widget configuration
2681 if ( categories.testFlag( Forms ) )
2682 {
2683 const QString widgetType = fieldWidgetElement.attribute( QStringLiteral( "type" ) );
2684 const QDomElement cfgElem = fieldConfigElement.elementsByTagName( QStringLiteral( "config" ) ).at( 0 ).toElement();
2685 const QDomElement optionsElem = cfgElem.childNodes().at( 0 ).toElement();
2686 QVariantMap optionsMap = QgsXmlUtils::readVariant( optionsElem ).toMap();
2687 if ( widgetType == QLatin1String( "ValueRelation" ) )
2688 {
2689 optionsMap[ QStringLiteral( "Value" ) ] = context.projectTranslator()->translate( QStringLiteral( "project:layers:%1:fields:%2:valuerelationvalue" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text(), fieldName ), optionsMap[ QStringLiteral( "Value" ) ].toString() );
2690 }
2691 QgsEditorWidgetSetup setup = QgsEditorWidgetSetup( widgetType, optionsMap );
2692 mFieldWidgetSetups[fieldName] = setup;
2693 }
2694 }
2695 }
2696
2697 // Legacy reading for QGIS 3.14 and older projects
2698 // Attributes excluded from WMS and WFS
2699 if ( categories.testFlag( Fields ) )
2700 {
2701 const QList<QPair<QString, Qgis::FieldConfigurationFlag>> legacyConfig
2702 {
2703 qMakePair( QStringLiteral( "excludeAttributesWMS" ), Qgis::FieldConfigurationFlag::HideFromWms ),
2704 qMakePair( QStringLiteral( "excludeAttributesWFS" ), Qgis::FieldConfigurationFlag::HideFromWfs )
2705 };
2706 for ( const auto &config : legacyConfig )
2707 {
2708 QDomNode excludeNode = layerNode.namedItem( config.first );
2709 if ( !excludeNode.isNull() )
2710 {
2711 QDomNodeList attributeNodeList = excludeNode.toElement().elementsByTagName( QStringLiteral( "attribute" ) );
2712 for ( int i = 0; i < attributeNodeList.size(); ++i )
2713 {
2714 QString fieldName = attributeNodeList.at( i ).toElement().text();
2715 if ( !mFieldConfigurationFlags.contains( fieldName ) )
2716 mFieldConfigurationFlags[fieldName] = config.second;
2717 else
2718 mFieldConfigurationFlags[fieldName].setFlag( config.second, true );
2719 }
2720 }
2721 }
2722 }
2723
2724 if ( categories.testFlag( GeometryOptions ) )
2725 mGeometryOptions->readXml( layerNode.namedItem( QStringLiteral( "geometryOptions" ) ) );
2726
2727 if ( categories.testFlag( Forms ) )
2728 mEditFormConfig.readXml( layerNode, context );
2729
2730 if ( categories.testFlag( AttributeTable ) )
2731 {
2732 mAttributeTableConfig.readXml( layerNode );
2733 mConditionalStyles->readXml( layerNode, context );
2734 mStoredExpressionManager->readXml( layerNode );
2735 }
2736
2737 if ( categories.testFlag( CustomProperties ) )
2738 readCustomProperties( layerNode, QStringLiteral( "variable" ) );
2739
2740 QDomElement mapLayerNode = layerNode.toElement();
2741 if ( categories.testFlag( LayerConfiguration )
2742 && mapLayerNode.attribute( QStringLiteral( "readOnly" ), QStringLiteral( "0" ) ).toInt() == 1 )
2743 mReadOnly = true;
2744
2745 updateFields();
2746
2747 if ( categories.testFlag( Legend ) )
2748 {
2749 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Legend" ) );
2750
2751 const QDomElement legendElem = layerNode.firstChildElement( QStringLiteral( "legend" ) );
2752 if ( !legendElem.isNull() )
2753 {
2754 std::unique_ptr< QgsMapLayerLegend > legend( QgsMapLayerLegend::defaultVectorLegend( this ) );
2755 legend->readXml( legendElem, context );
2756 setLegend( legend.release() );
2757 mSetLegendFromStyle = true;
2758 }
2759 }
2760
2761 return true;
2762}
2763
2764bool QgsVectorLayer::readStyle( const QDomNode &node, QString &errorMessage,
2766{
2768
2769 bool result = true;
2770 emit readCustomSymbology( node.toElement(), errorMessage );
2771
2772 // we must try to restore a renderer if our geometry type is unknown
2773 // as this allows the renderer to be correctly restored even for layers
2774 // with broken sources
2775 if ( isSpatial() || mWkbType == Qgis::WkbType::Unknown )
2776 {
2777 // defer style changed signal until we've set the renderer, labeling, everything.
2778 // we don't want multiple signals!
2779 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
2780
2781 // try renderer v2 first
2782 if ( categories.testFlag( Symbology ) )
2783 {
2784 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Symbology" ) );
2785
2786 QDomElement rendererElement = node.firstChildElement( RENDERER_TAG_NAME );
2787 if ( !rendererElement.isNull() )
2788 {
2789 QgsFeatureRenderer *r = QgsFeatureRenderer::load( rendererElement, context );
2790 if ( r )
2791 {
2792 setRenderer( r );
2793 }
2794 else
2795 {
2796 result = false;
2797 }
2798 }
2799 // make sure layer has a renderer - if none exists, fallback to a default renderer
2800 if ( isSpatial() && !renderer() )
2801 {
2803 }
2804
2805 if ( mSelectionProperties )
2806 mSelectionProperties->readXml( node.toElement(), context );
2807 }
2808
2809 // read labeling definition
2810 if ( categories.testFlag( Labeling ) )
2811 {
2812 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Labeling" ) );
2813
2814 QDomElement labelingElement = node.firstChildElement( QStringLiteral( "labeling" ) );
2816 if ( labelingElement.isNull() ||
2817 ( labelingElement.attribute( QStringLiteral( "type" ) ) == QLatin1String( "simple" ) && labelingElement.firstChildElement( QStringLiteral( "settings" ) ).isNull() ) )
2818 {
2819 // make sure we have custom properties for labeling for 2.x projects
2820 // (custom properties should be already loaded when reading the whole layer from XML,
2821 // but when reading style, custom properties are not read)
2822 readCustomProperties( node, QStringLiteral( "labeling" ) );
2823
2824 // support for pre-QGIS 3 labeling configurations written in custom properties
2825 labeling = readLabelingFromCustomProperties();
2826 }
2827 else
2828 {
2829 labeling = QgsAbstractVectorLayerLabeling::create( labelingElement, context );
2830 }
2832
2833 if ( node.toElement().hasAttribute( QStringLiteral( "labelsEnabled" ) ) )
2834 mLabelsEnabled = node.toElement().attribute( QStringLiteral( "labelsEnabled" ) ).toInt();
2835 else
2836 mLabelsEnabled = true;
2837 }
2838
2839 if ( categories.testFlag( Symbology ) )
2840 {
2841 // get and set the blend mode if it exists
2842 QDomNode blendModeNode = node.namedItem( QStringLiteral( "blendMode" ) );
2843 if ( !blendModeNode.isNull() )
2844 {
2845 QDomElement e = blendModeNode.toElement();
2846 setBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
2847 }
2848
2849 // get and set the feature blend mode if it exists
2850 QDomNode featureBlendModeNode = node.namedItem( QStringLiteral( "featureBlendMode" ) );
2851 if ( !featureBlendModeNode.isNull() )
2852 {
2853 QDomElement e = featureBlendModeNode.toElement();
2854 setFeatureBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
2855 }
2856 }
2857
2858 // get and set the layer transparency and scale visibility if they exists
2859 if ( categories.testFlag( Rendering ) )
2860 {
2861 QDomNode layerTransparencyNode = node.namedItem( QStringLiteral( "layerTransparency" ) );
2862 if ( !layerTransparencyNode.isNull() )
2863 {
2864 QDomElement e = layerTransparencyNode.toElement();
2865 setOpacity( 1.0 - e.text().toInt() / 100.0 );
2866 }
2867 QDomNode layerOpacityNode = node.namedItem( QStringLiteral( "layerOpacity" ) );
2868 if ( !layerOpacityNode.isNull() )
2869 {
2870 QDomElement e = layerOpacityNode.toElement();
2871 setOpacity( e.text().toDouble() );
2872 }
2873
2874 const bool hasScaleBasedVisibiliy { node.attributes().namedItem( QStringLiteral( "hasScaleBasedVisibilityFlag" ) ).nodeValue() == '1' };
2875 setScaleBasedVisibility( hasScaleBasedVisibiliy );
2876 bool ok;
2877 const double maxScale { node.attributes().namedItem( QStringLiteral( "maxScale" ) ).nodeValue().toDouble( &ok ) };
2878 if ( ok )
2879 {
2880 setMaximumScale( maxScale );
2881 }
2882 const double minScale { node.attributes().namedItem( QStringLiteral( "minScale" ) ).nodeValue().toDouble( &ok ) };
2883 if ( ok )
2884 {
2885 setMinimumScale( minScale );
2886 }
2887
2888 QDomElement e = node.toElement();
2889
2890 // get the simplification drawing settings
2891 mSimplifyMethod.setSimplifyHints( static_cast< Qgis::VectorRenderingSimplificationFlags >( e.attribute( QStringLiteral( "simplifyDrawingHints" ), QStringLiteral( "1" ) ).toInt() ) );
2892 mSimplifyMethod.setSimplifyAlgorithm( static_cast< Qgis::VectorSimplificationAlgorithm >( e.attribute( QStringLiteral( "simplifyAlgorithm" ), QStringLiteral( "0" ) ).toInt() ) );
2893 mSimplifyMethod.setThreshold( e.attribute( QStringLiteral( "simplifyDrawingTol" ), QStringLiteral( "1" ) ).toFloat() );
2894 mSimplifyMethod.setForceLocalOptimization( e.attribute( QStringLiteral( "simplifyLocal" ), QStringLiteral( "1" ) ).toInt() );
2895 mSimplifyMethod.setMaximumScale( e.attribute( QStringLiteral( "simplifyMaxScale" ), QStringLiteral( "1" ) ).toFloat() );
2896
2897 if ( mRenderer )
2898 mRenderer->setReferenceScale( e.attribute( QStringLiteral( "symbologyReferenceScale" ), QStringLiteral( "-1" ) ).toDouble() );
2899 }
2900
2901 //diagram renderer and diagram layer settings
2902 if ( categories.testFlag( Diagrams ) )
2903 {
2904 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Diagrams" ) );
2905
2906 delete mDiagramRenderer;
2907 mDiagramRenderer = nullptr;
2908 QDomElement singleCatDiagramElem = node.firstChildElement( QStringLiteral( "SingleCategoryDiagramRenderer" ) );
2909 if ( !singleCatDiagramElem.isNull() )
2910 {
2911 mDiagramRenderer = new QgsSingleCategoryDiagramRenderer();
2912 mDiagramRenderer->readXml( singleCatDiagramElem, context );
2913 }
2914 QDomElement linearDiagramElem = node.firstChildElement( QStringLiteral( "LinearlyInterpolatedDiagramRenderer" ) );
2915 if ( !linearDiagramElem.isNull() )
2916 {
2917 if ( linearDiagramElem.hasAttribute( QStringLiteral( "classificationAttribute" ) ) )
2918 {
2919 // fix project from before QGIS 3.0
2920 int idx = linearDiagramElem.attribute( QStringLiteral( "classificationAttribute" ) ).toInt();
2921 if ( idx >= 0 && idx < mFields.count() )
2922 linearDiagramElem.setAttribute( QStringLiteral( "classificationField" ), mFields.at( idx ).name() );
2923 }
2924
2925 mDiagramRenderer = new QgsLinearlyInterpolatedDiagramRenderer();
2926 mDiagramRenderer->readXml( linearDiagramElem, context );
2927 }
2928 QDomElement stackedDiagramElem = node.firstChildElement( QStringLiteral( "StackedDiagramRenderer" ) );
2929 if ( !stackedDiagramElem.isNull() )
2930 {
2931 mDiagramRenderer = new QgsStackedDiagramRenderer();
2932 mDiagramRenderer->readXml( stackedDiagramElem, context );
2933 }
2934
2935 if ( mDiagramRenderer )
2936 {
2937 QDomElement diagramSettingsElem = node.firstChildElement( QStringLiteral( "DiagramLayerSettings" ) );
2938 if ( !diagramSettingsElem.isNull() )
2939 {
2940 bool oldXPos = diagramSettingsElem.hasAttribute( QStringLiteral( "xPosColumn" ) );
2941 bool oldYPos = diagramSettingsElem.hasAttribute( QStringLiteral( "yPosColumn" ) );
2942 bool oldShow = diagramSettingsElem.hasAttribute( QStringLiteral( "showColumn" ) );
2943 if ( oldXPos || oldYPos || oldShow )
2944 {
2945 // fix project from before QGIS 3.0
2947 if ( oldXPos )
2948 {
2949 int xPosColumn = diagramSettingsElem.attribute( QStringLiteral( "xPosColumn" ) ).toInt();
2950 if ( xPosColumn >= 0 && xPosColumn < mFields.count() )
2952 }
2953 if ( oldYPos )
2954 {
2955 int yPosColumn = diagramSettingsElem.attribute( QStringLiteral( "yPosColumn" ) ).toInt();
2956 if ( yPosColumn >= 0 && yPosColumn < mFields.count() )
2958 }
2959 if ( oldShow )
2960 {
2961 int showColumn = diagramSettingsElem.attribute( QStringLiteral( "showColumn" ) ).toInt();
2962 if ( showColumn >= 0 && showColumn < mFields.count() )
2963 ddp.setProperty( QgsDiagramLayerSettings::Property::Show, QgsProperty::fromField( mFields.at( showColumn ).name(), true ) );
2964 }
2965 QDomElement propertiesElem = diagramSettingsElem.ownerDocument().createElement( QStringLiteral( "properties" ) );
2967 {
2968 { static_cast< int >( QgsDiagramLayerSettings::Property::PositionX ), QgsPropertyDefinition( "positionX", QObject::tr( "Position (X)" ), QgsPropertyDefinition::Double ) },
2969 { static_cast< int >( QgsDiagramLayerSettings::Property::PositionY ), QgsPropertyDefinition( "positionY", QObject::tr( "Position (Y)" ), QgsPropertyDefinition::Double ) },
2970 { static_cast< int >( QgsDiagramLayerSettings::Property::Show ), QgsPropertyDefinition( "show", QObject::tr( "Show diagram" ), QgsPropertyDefinition::Boolean ) },
2971 };
2972 ddp.writeXml( propertiesElem, defs );
2973 diagramSettingsElem.appendChild( propertiesElem );
2974 }
2975
2976 delete mDiagramLayerSettings;
2977 mDiagramLayerSettings = new QgsDiagramLayerSettings();
2978 mDiagramLayerSettings->readXml( diagramSettingsElem );
2979 }
2980 }
2981 }
2982 // end diagram
2983
2984 styleChangedSignalBlocker.release();
2986 }
2987 return result;
2988}
2989
2990
2991bool QgsVectorLayer::writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage,
2992 const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
2993{
2995
2996 QDomElement layerElement = node.toElement();
2997 writeCommonStyle( layerElement, doc, context, categories );
2998
2999 ( void )writeStyle( node, doc, errorMessage, context, categories );
3000
3001 if ( categories.testFlag( GeometryOptions ) )
3002 mGeometryOptions->writeXml( node );
3003
3004 if ( categories.testFlag( Legend ) && legend() )
3005 {
3006 QDomElement legendElement = legend()->writeXml( doc, context );
3007 if ( !legendElement.isNull() )
3008 node.appendChild( legendElement );
3009 }
3010
3011 // Relation information for both referenced and referencing sides
3012 if ( categories.testFlag( Relations ) )
3013 {
3014 if ( QgsProject *p = project() )
3015 {
3016 // Store referenced layers: relations where "this" is the child layer (the referencing part, that holds the FK)
3017 QDomElement referencedLayersElement = doc.createElement( QStringLiteral( "referencedLayers" ) );
3018 node.appendChild( referencedLayersElement );
3019
3020 const QList<QgsRelation> referencingRelations { p->relationManager()->referencingRelations( this ) };
3021 for ( const QgsRelation &rel : referencingRelations )
3022 {
3023 switch ( rel.type() )
3024 {
3026 QgsWeakRelation::writeXml( this, QgsWeakRelation::Referencing, rel, referencedLayersElement, doc );
3027 break;
3029 break;
3030 }
3031 }
3032
3033 // Store referencing layers: relations where "this" is the parent layer (the referenced part, that holds the FK)
3034 QDomElement referencingLayersElement = doc.createElement( QStringLiteral( "referencingLayers" ) );
3035 node.appendChild( referencedLayersElement );
3036
3037 const QList<QgsRelation> referencedRelations { p->relationManager()->referencedRelations( this ) };
3038 for ( const QgsRelation &rel : referencedRelations )
3039 {
3040 switch ( rel.type() )
3041 {
3043 QgsWeakRelation::writeXml( this, QgsWeakRelation::Referenced, rel, referencingLayersElement, doc );
3044 break;
3046 break;
3047 }
3048 }
3049 }
3050 }
3051
3052 // write field configurations
3053 if ( categories.testFlag( Fields ) || categories.testFlag( Forms ) )
3054 {
3055 QDomElement fieldConfigurationElement;
3056 // field configuration flag
3057 fieldConfigurationElement = doc.createElement( QStringLiteral( "fieldConfiguration" ) );
3058 node.appendChild( fieldConfigurationElement );
3059
3060 for ( const QgsField &field : std::as_const( mFields ) )
3061 {
3062 QDomElement fieldElement = doc.createElement( QStringLiteral( "field" ) );
3063 fieldElement.setAttribute( QStringLiteral( "name" ), field.name() );
3064 fieldConfigurationElement.appendChild( fieldElement );
3065
3066 if ( categories.testFlag( Fields ) )
3067 {
3068 fieldElement.setAttribute( QStringLiteral( "configurationFlags" ), qgsFlagValueToKeys( field.configurationFlags() ) );
3069 }
3070
3071 if ( categories.testFlag( Forms ) )
3072 {
3073 QgsEditorWidgetSetup widgetSetup = field.editorWidgetSetup();
3074
3075 // TODO : wrap this part in an if to only save if it was user-modified
3076 QDomElement editWidgetElement = doc.createElement( QStringLiteral( "editWidget" ) );
3077 fieldElement.appendChild( editWidgetElement );
3078 editWidgetElement.setAttribute( QStringLiteral( "type" ), field.editorWidgetSetup().type() );
3079 QDomElement editWidgetConfigElement = doc.createElement( QStringLiteral( "config" ) );
3080
3081 editWidgetConfigElement.appendChild( QgsXmlUtils::writeVariant( widgetSetup.config(), doc ) );
3082 editWidgetElement.appendChild( editWidgetConfigElement );
3083 // END TODO : wrap this part in an if to only save if it was user-modified
3084 }
3085 }
3086 }
3087
3088 if ( categories.testFlag( Fields ) )
3089 {
3090 //attribute aliases
3091 QDomElement aliasElem = doc.createElement( QStringLiteral( "aliases" ) );
3092 for ( const QgsField &field : std::as_const( mFields ) )
3093 {
3094 QDomElement aliasEntryElem = doc.createElement( QStringLiteral( "alias" ) );
3095 aliasEntryElem.setAttribute( QStringLiteral( "field" ), field.name() );
3096 aliasEntryElem.setAttribute( QStringLiteral( "index" ), mFields.indexFromName( field.name() ) );
3097 aliasEntryElem.setAttribute( QStringLiteral( "name" ), field.alias() );
3098 aliasElem.appendChild( aliasEntryElem );
3099 }
3100 node.appendChild( aliasElem );
3101
3102 //split policies
3103 {
3104 QDomElement splitPoliciesElement = doc.createElement( QStringLiteral( "splitPolicies" ) );
3105 for ( const QgsField &field : std::as_const( mFields ) )
3106 {
3107 QDomElement splitPolicyElem = doc.createElement( QStringLiteral( "policy" ) );
3108 splitPolicyElem.setAttribute( QStringLiteral( "field" ), field.name() );
3109 splitPolicyElem.setAttribute( QStringLiteral( "policy" ), qgsEnumValueToKey( field.splitPolicy() ) );
3110 splitPoliciesElement.appendChild( splitPolicyElem );
3111 }
3112 node.appendChild( splitPoliciesElement );
3113 }
3114
3115 //duplicate policies
3116 {
3117 QDomElement duplicatePoliciesElement = doc.createElement( QStringLiteral( "duplicatePolicies" ) );
3118 for ( const QgsField &field : std::as_const( mFields ) )
3119 {
3120 QDomElement duplicatePolicyElem = doc.createElement( QStringLiteral( "policy" ) );
3121 duplicatePolicyElem.setAttribute( QStringLiteral( "field" ), field.name() );
3122 duplicatePolicyElem.setAttribute( QStringLiteral( "policy" ), qgsEnumValueToKey( field.duplicatePolicy() ) );
3123 duplicatePoliciesElement.appendChild( duplicatePolicyElem );
3124 }
3125 node.appendChild( duplicatePoliciesElement );
3126 }
3127
3128 //default expressions
3129 QDomElement defaultsElem = doc.createElement( QStringLiteral( "defaults" ) );
3130 for ( const QgsField &field : std::as_const( mFields ) )
3131 {
3132 QDomElement defaultElem = doc.createElement( QStringLiteral( "default" ) );
3133 defaultElem.setAttribute( QStringLiteral( "field" ), field.name() );
3134 defaultElem.setAttribute( QStringLiteral( "expression" ), field.defaultValueDefinition().expression() );
3135 defaultElem.setAttribute( QStringLiteral( "applyOnUpdate" ), field.defaultValueDefinition().applyOnUpdate() ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
3136 defaultsElem.appendChild( defaultElem );
3137 }
3138 node.appendChild( defaultsElem );
3139
3140 // constraints
3141 QDomElement constraintsElem = doc.createElement( QStringLiteral( "constraints" ) );
3142 for ( const QgsField &field : std::as_const( mFields ) )
3143 {
3144 QDomElement constraintElem = doc.createElement( QStringLiteral( "constraint" ) );
3145 constraintElem.setAttribute( QStringLiteral( "field" ), field.name() );
3146 constraintElem.setAttribute( QStringLiteral( "constraints" ), field.constraints().constraints() );
3147 constraintElem.setAttribute( QStringLiteral( "unique_strength" ), field.constraints().constraintStrength( QgsFieldConstraints::ConstraintUnique ) );
3148 constraintElem.setAttribute( QStringLiteral( "notnull_strength" ), field.constraints().constraintStrength( QgsFieldConstraints::ConstraintNotNull ) );
3149 constraintElem.setAttribute( QStringLiteral( "exp_strength" ), field.constraints().constraintStrength( QgsFieldConstraints::ConstraintExpression ) );
3150
3151 constraintsElem.appendChild( constraintElem );
3152 }
3153 node.appendChild( constraintsElem );
3154
3155 // constraint expressions
3156 QDomElement constraintExpressionsElem = doc.createElement( QStringLiteral( "constraintExpressions" ) );
3157 for ( const QgsField &field : std::as_const( mFields ) )
3158 {
3159 QDomElement constraintExpressionElem = doc.createElement( QStringLiteral( "constraint" ) );
3160 constraintExpressionElem.setAttribute( QStringLiteral( "field" ), field.name() );
3161 constraintExpressionElem.setAttribute( QStringLiteral( "exp" ), field.constraints().constraintExpression() );
3162 constraintExpressionElem.setAttribute( QStringLiteral( "desc" ), field.constraints().constraintDescription() );
3163 constraintExpressionsElem.appendChild( constraintExpressionElem );
3164 }
3165 node.appendChild( constraintExpressionsElem );
3166
3167 // save expression fields
3168 if ( !mExpressionFieldBuffer )
3169 {
3170 // can happen when saving style on a invalid layer
3172 dummy.writeXml( node, doc );
3173 }
3174 else
3175 {
3176 mExpressionFieldBuffer->writeXml( node, doc );
3177 }
3178 }
3179
3180 // add attribute actions
3181 if ( categories.testFlag( Actions ) )
3182 mActions->writeXml( node );
3183
3184 if ( categories.testFlag( AttributeTable ) )
3185 {
3186 mAttributeTableConfig.writeXml( node );
3187 mConditionalStyles->writeXml( node, doc, context );
3188 mStoredExpressionManager->writeXml( node );
3189 }
3190
3191 if ( categories.testFlag( Forms ) )
3192 mEditFormConfig.writeXml( node, context );
3193
3194 // save readonly state
3195 if ( categories.testFlag( LayerConfiguration ) )
3196 node.toElement().setAttribute( QStringLiteral( "readOnly" ), mReadOnly );
3197
3198 // save preview expression
3199 if ( categories.testFlag( LayerConfiguration ) )
3200 {
3201 QDomElement prevExpElem = doc.createElement( QStringLiteral( "previewExpression" ) );
3202 QDomText prevExpText = doc.createTextNode( mDisplayExpression );
3203 prevExpElem.appendChild( prevExpText );
3204 node.appendChild( prevExpElem );
3205 }
3206
3207 // save map tip
3208 if ( categories.testFlag( MapTips ) )
3209 {
3210 QDomElement mapTipElem = doc.createElement( QStringLiteral( "mapTip" ) );
3211 mapTipElem.setAttribute( QStringLiteral( "enabled" ), mapTipsEnabled() );
3212 QDomText mapTipText = doc.createTextNode( mMapTipTemplate );
3213 mapTipElem.appendChild( mapTipText );
3214 node.toElement().appendChild( mapTipElem );
3215 }
3216
3217 return true;
3218}
3219
3220bool QgsVectorLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage,
3221 const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
3222{
3224
3225 QDomElement mapLayerNode = node.toElement();
3226
3227 emit writeCustomSymbology( mapLayerNode, doc, errorMessage );
3228
3229 // we must try to write the renderer if our geometry type is unknown
3230 // as this allows the renderer to be correctly restored even for layers
3231 // with broken sources
3232 if ( isSpatial() || mWkbType == Qgis::WkbType::Unknown )
3233 {
3234 if ( categories.testFlag( Symbology ) )
3235 {
3236 if ( mRenderer )
3237 {
3238 QDomElement rendererElement = mRenderer->save( doc, context );
3239 node.appendChild( rendererElement );
3240 }
3241 if ( mSelectionProperties )
3242 {
3243 mSelectionProperties->writeXml( mapLayerNode, doc, context );
3244 }
3245 }
3246
3247 if ( categories.testFlag( Labeling ) )
3248 {
3249 if ( mLabeling )
3250 {
3251 QDomElement labelingElement = mLabeling->save( doc, context );
3252 node.appendChild( labelingElement );
3253 }
3254 mapLayerNode.setAttribute( QStringLiteral( "labelsEnabled" ), mLabelsEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
3255 }
3256
3257 // save the simplification drawing settings
3258 if ( categories.testFlag( Rendering ) )
3259 {
3260 mapLayerNode.setAttribute( QStringLiteral( "simplifyDrawingHints" ), QString::number( static_cast< int >( mSimplifyMethod.simplifyHints() ) ) );
3261 mapLayerNode.setAttribute( QStringLiteral( "simplifyAlgorithm" ), QString::number( static_cast< int >( mSimplifyMethod.simplifyAlgorithm() ) ) );
3262 mapLayerNode.setAttribute( QStringLiteral( "simplifyDrawingTol" ), QString::number( mSimplifyMethod.threshold() ) );
3263 mapLayerNode.setAttribute( QStringLiteral( "simplifyLocal" ), mSimplifyMethod.forceLocalOptimization() ? 1 : 0 );
3264 mapLayerNode.setAttribute( QStringLiteral( "simplifyMaxScale" ), QString::number( mSimplifyMethod.maximumScale() ) );
3265 }
3266
3267 //save customproperties
3268 if ( categories.testFlag( CustomProperties ) )
3269 {
3270 writeCustomProperties( node, doc );
3271 }
3272
3273 if ( categories.testFlag( Symbology ) )
3274 {
3275 // add the blend mode field
3276 QDomElement blendModeElem = doc.createElement( QStringLiteral( "blendMode" ) );
3277 QDomText blendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( blendMode() ) ) ) );
3278 blendModeElem.appendChild( blendModeText );
3279 node.appendChild( blendModeElem );
3280
3281 // add the feature blend mode field
3282 QDomElement featureBlendModeElem = doc.createElement( QStringLiteral( "featureBlendMode" ) );
3283 QDomText featureBlendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( featureBlendMode() ) ) ) );
3284 featureBlendModeElem.appendChild( featureBlendModeText );
3285 node.appendChild( featureBlendModeElem );
3286 }
3287
3288 // add the layer opacity and scale visibility
3289 if ( categories.testFlag( Rendering ) )
3290 {
3291 QDomElement layerOpacityElem = doc.createElement( QStringLiteral( "layerOpacity" ) );
3292 QDomText layerOpacityText = doc.createTextNode( QString::number( opacity() ) );
3293 layerOpacityElem.appendChild( layerOpacityText );
3294 node.appendChild( layerOpacityElem );
3295 mapLayerNode.setAttribute( QStringLiteral( "hasScaleBasedVisibilityFlag" ), hasScaleBasedVisibility() ? 1 : 0 );
3296 mapLayerNode.setAttribute( QStringLiteral( "maxScale" ), maximumScale() );
3297 mapLayerNode.setAttribute( QStringLiteral( "minScale" ), minimumScale() );
3298
3299 mapLayerNode.setAttribute( QStringLiteral( "symbologyReferenceScale" ), mRenderer ? mRenderer->referenceScale() : -1 );
3300 }
3301
3302 if ( categories.testFlag( Diagrams ) && mDiagramRenderer )
3303 {
3304 mDiagramRenderer->writeXml( mapLayerNode, doc, context );
3305 if ( mDiagramLayerSettings )
3306 mDiagramLayerSettings->writeXml( mapLayerNode, doc );
3307 }
3308 }
3309 return true;
3310}
3311
3312bool QgsVectorLayer::readSld( const QDomNode &node, QString &errorMessage )
3313{
3315
3316 // get the Name element
3317 QDomElement nameElem = node.firstChildElement( QStringLiteral( "Name" ) );
3318 if ( nameElem.isNull() )
3319 {
3320 errorMessage = QStringLiteral( "Warning: Name element not found within NamedLayer while it's required." );
3321 }
3322
3323 if ( isSpatial() )
3324 {
3325 QgsFeatureRenderer *r = QgsFeatureRenderer::loadSld( node, geometryType(), errorMessage );
3326 if ( !r )
3327 return false;
3328
3329 // defer style changed signal until we've set the renderer, labeling, everything.
3330 // we don't want multiple signals!
3331 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
3332
3333 setRenderer( r );
3334
3335 // labeling
3336 readSldLabeling( node );
3337
3338 styleChangedSignalBlocker.release();
3340 }
3341 return true;
3342}
3343
3344bool QgsVectorLayer::writeSld( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QVariantMap &props ) const
3345{
3347
3348 Q_UNUSED( errorMessage )
3349
3350 QVariantMap localProps = QVariantMap( props );
3352 {
3354 }
3355
3356 if ( isSpatial() )
3357 {
3358 // store the Name element
3359 QDomElement nameNode = doc.createElement( QStringLiteral( "se:Name" ) );
3360 nameNode.appendChild( doc.createTextNode( name() ) );
3361 node.appendChild( nameNode );
3362
3363 QDomElement userStyleElem = doc.createElement( QStringLiteral( "UserStyle" ) );
3364 node.appendChild( userStyleElem );
3365
3366 QDomElement nameElem = doc.createElement( QStringLiteral( "se:Name" ) );
3367 nameElem.appendChild( doc.createTextNode( name() ) );
3368
3369 userStyleElem.appendChild( nameElem );
3370
3371 QDomElement featureTypeStyleElem = doc.createElement( QStringLiteral( "se:FeatureTypeStyle" ) );
3372 userStyleElem.appendChild( featureTypeStyleElem );
3373
3374 mRenderer->toSld( doc, featureTypeStyleElem, localProps );
3375 if ( labelsEnabled() )
3376 {
3377 mLabeling->toSld( featureTypeStyleElem, localProps );
3378 }
3379 }
3380 return true;
3381}
3382
3383
3384bool QgsVectorLayer::changeGeometry( QgsFeatureId fid, QgsGeometry &geom, bool skipDefaultValue )
3385{
3387
3388 if ( !mEditBuffer || !mDataProvider )
3389 {
3390 return false;
3391 }
3392
3393 if ( mGeometryOptions->isActive() )
3394 mGeometryOptions->apply( geom );
3395
3396 updateExtents();
3397
3398 bool result = mEditBuffer->changeGeometry( fid, geom );
3399
3400 if ( result )
3401 {
3402 updateExtents();
3403 if ( !skipDefaultValue && !mDefaultValueOnUpdateFields.isEmpty() )
3404 updateDefaultValues( fid );
3405 }
3406 return result;
3407}
3408
3409
3410bool QgsVectorLayer::changeAttributeValue( QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue, bool skipDefaultValues, QgsVectorLayerToolsContext *context )
3411{
3413
3414 bool result = false;
3415
3416 switch ( fields().fieldOrigin( field ) )
3417 {
3419 result = mJoinBuffer->changeAttributeValue( fid, field, newValue, oldValue );
3420 if ( result )
3421 emit attributeValueChanged( fid, field, newValue );
3422 break;
3423
3427 {
3428 if ( mEditBuffer && mDataProvider )
3429 result = mEditBuffer->changeAttributeValue( fid, field, newValue, oldValue );
3430 break;
3431 }
3432
3434 break;
3435 }
3436
3437 if ( result && !skipDefaultValues && !mDefaultValueOnUpdateFields.isEmpty() )
3438 updateDefaultValues( fid, QgsFeature(), context ? context->expressionContext() : nullptr );
3439
3440 return result;
3441}
3442
3443bool QgsVectorLayer::changeAttributeValues( QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues, bool skipDefaultValues, QgsVectorLayerToolsContext *context )
3444{
3446
3447 bool result = true;
3448
3449 QgsAttributeMap newValuesJoin;
3450 QgsAttributeMap oldValuesJoin;
3451
3452 QgsAttributeMap newValuesNotJoin;
3453 QgsAttributeMap oldValuesNotJoin;
3454
3455 for ( auto it = newValues.constBegin(); it != newValues.constEnd(); ++it )
3456 {
3457 const int field = it.key();
3458 const QVariant newValue = it.value();
3459 QVariant oldValue;
3460
3461 if ( oldValues.contains( field ) )
3462 oldValue = oldValues[field];
3463
3464 switch ( fields().fieldOrigin( field ) )
3465 {
3467 newValuesJoin[field] = newValue;
3468 oldValuesJoin[field] = oldValue;
3469 break;
3470
3474 {
3475 newValuesNotJoin[field] = newValue;
3476 oldValuesNotJoin[field] = oldValue;
3477 break;
3478 }
3479
3481 break;
3482 }
3483 }
3484
3485 if ( ! newValuesJoin.isEmpty() && mJoinBuffer )
3486 {
3487 result = mJoinBuffer->changeAttributeValues( fid, newValuesJoin, oldValuesJoin );
3488 }
3489
3490 if ( ! newValuesNotJoin.isEmpty() )
3491 {
3492 if ( mEditBuffer && mDataProvider )
3493 result &= mEditBuffer->changeAttributeValues( fid, newValuesNotJoin, oldValues );
3494 else
3495 result = false;
3496 }
3497
3498 if ( result && !skipDefaultValues && !mDefaultValueOnUpdateFields.isEmpty() )
3499 {
3500 updateDefaultValues( fid, QgsFeature(), context ? context->expressionContext() : nullptr );
3501 }
3502
3503 return result;
3504}
3505
3507{
3509
3510 if ( !mEditBuffer || !mDataProvider )
3511 return false;
3512
3513 return mEditBuffer->addAttribute( field );
3514}
3515
3517{
3519
3520 if ( attIndex < 0 || attIndex >= fields().count() )
3521 return;
3522
3523 QString name = fields().at( attIndex ).name();
3524 mFields[ attIndex ].setAlias( QString() );
3525 if ( mAttributeAliasMap.contains( name ) )
3526 {
3527 mAttributeAliasMap.remove( name );
3528 updateFields();
3529 mEditFormConfig.setFields( mFields );
3530 emit layerModified();
3531 }
3532}
3533
3534bool QgsVectorLayer::renameAttribute( int index, const QString &newName )
3535{
3537
3538 if ( index < 0 || index >= fields().count() )
3539 return false;
3540
3541 switch ( mFields.fieldOrigin( index ) )
3542 {
3544 {
3545 if ( mExpressionFieldBuffer )
3546 {
3547 int oi = mFields.fieldOriginIndex( index );
3548 mExpressionFieldBuffer->renameExpression( oi, newName );
3549 updateFields();
3550 return true;
3551 }
3552 else
3553 {
3554 return false;
3555 }
3556 }
3557
3560
3561 if ( !mEditBuffer || !mDataProvider )
3562 return false;
3563
3564 return mEditBuffer->renameAttribute( index, newName );
3565
3568 return false;
3569
3570 }
3571
3572 return false; // avoid warning
3573}
3574
3575void QgsVectorLayer::setFieldAlias( int attIndex, const QString &aliasString )
3576{
3578
3579 if ( attIndex < 0 || attIndex >= fields().count() )
3580 return;
3581
3582 QString name = fields().at( attIndex ).name();
3583
3584 mAttributeAliasMap.insert( name, aliasString );
3585 mFields[ attIndex ].setAlias( aliasString );
3586 mEditFormConfig.setFields( mFields );
3587 emit layerModified(); // TODO[MD]: should have a different signal?
3588}
3589
3590QString QgsVectorLayer::attributeAlias( int index ) const
3591{
3593
3594 if ( index < 0 || index >= fields().count() )
3595 return QString();
3596
3597 return fields().at( index ).alias();
3598}
3599
3601{
3603
3604 if ( index >= 0 && index < mFields.count() )
3605 return mFields.at( index ).displayName();
3606 else
3607 return QString();
3608}
3609
3611{
3613
3614 return mAttributeAliasMap;
3615}
3616
3618{
3620
3621 if ( index < 0 || index >= fields().count() )
3622 return;
3623
3624 const QString name = fields().at( index ).name();
3625
3626 mAttributeSplitPolicy.insert( name, policy );
3627 mFields[ index ].setSplitPolicy( policy );
3628 mEditFormConfig.setFields( mFields );
3629 emit layerModified(); // TODO[MD]: should have a different signal?
3630}
3631
3633{
3635
3636 if ( index < 0 || index >= fields().count() )
3637 return;
3638
3639 const QString name = fields().at( index ).name();
3640
3641 mAttributeDuplicatePolicy.insert( name, policy );
3642 mFields[ index ].setDuplicatePolicy( policy );
3643 mEditFormConfig.setFields( mFields );
3644 emit layerModified(); // TODO[MD]: should have a different signal?
3645}
3646
3647
3649{
3651
3652 QSet<QString> excludeList;
3653 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
3654 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
3655 {
3656 if ( flagsIt->testFlag( Qgis::FieldConfigurationFlag::HideFromWms ) )
3657 {
3658 excludeList << flagsIt.key();
3659 }
3660 }
3661 return excludeList;
3662}
3663
3664void QgsVectorLayer::setExcludeAttributesWms( const QSet<QString> &att )
3665{
3667
3668 QMap< QString, Qgis::FieldConfigurationFlags >::iterator flagsIt = mFieldConfigurationFlags.begin();
3669 for ( ; flagsIt != mFieldConfigurationFlags.end(); ++flagsIt )
3670 {
3671 flagsIt->setFlag( Qgis::FieldConfigurationFlag::HideFromWms, att.contains( flagsIt.key() ) );
3672 }
3673 updateFields();
3674}
3675
3677{
3679
3680 QSet<QString> excludeList;
3681 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
3682 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
3683 {
3684 if ( flagsIt->testFlag( Qgis::FieldConfigurationFlag::HideFromWfs ) )
3685 {
3686 excludeList << flagsIt.key();
3687 }
3688 }
3689 return excludeList;
3690}
3691
3692void QgsVectorLayer::setExcludeAttributesWfs( const QSet<QString> &att )
3693{
3695
3696 QMap< QString, Qgis::FieldConfigurationFlags >::iterator flagsIt = mFieldConfigurationFlags.begin();
3697 for ( ; flagsIt != mFieldConfigurationFlags.end(); ++flagsIt )
3698 {
3699 flagsIt->setFlag( Qgis::FieldConfigurationFlag::HideFromWfs, att.contains( flagsIt.key() ) );
3700 }
3701 updateFields();
3702}
3703
3705{
3707
3708 if ( index < 0 || index >= fields().count() )
3709 return false;
3710
3711 if ( mFields.fieldOrigin( index ) == Qgis::FieldOrigin::Expression )
3712 {
3713 removeExpressionField( index );
3714 return true;
3715 }
3716
3717 if ( !mEditBuffer || !mDataProvider )
3718 return false;
3719
3720 return mEditBuffer->deleteAttribute( index );
3721}
3722
3723bool QgsVectorLayer::deleteAttributes( const QList<int> &attrs )
3724{
3726
3727 bool deleted = false;
3728
3729 // Remove multiple occurrences of same attribute
3730 QList<int> attrList = qgis::setToList( qgis::listToSet( attrs ) );
3731
3732 std::sort( attrList.begin(), attrList.end(), std::greater<int>() );
3733
3734 for ( int attr : std::as_const( attrList ) )
3735 {
3736 if ( deleteAttribute( attr ) )
3737 {
3738 deleted = true;
3739 }
3740 }
3741
3742 return deleted;
3743}
3744
3745bool QgsVectorLayer::deleteFeatureCascade( QgsFeatureId fid, QgsVectorLayer::DeleteContext *context )
3746{
3748
3749 if ( !mEditBuffer )
3750 return false;
3751
3752 if ( context && context->cascade )
3753 {
3754 const QList<QgsRelation> relations = context->project->relationManager()->referencedRelations( this );
3755 const bool hasRelationsOrJoins = !relations.empty() || mJoinBuffer->containsJoins();
3756 if ( hasRelationsOrJoins )
3757 {
3758 if ( context->mHandledFeatures.contains( this ) )
3759 {
3760 QgsFeatureIds &handledFeatureIds = context->mHandledFeatures[ this ];
3761 if ( handledFeatureIds.contains( fid ) )
3762 {
3763 // avoid endless recursion
3764 return false;
3765 }
3766 else
3767 {
3768 // add feature id
3769 handledFeatureIds << fid;
3770 }
3771 }
3772 else
3773 {
3774 // add layer and feature id
3775 context->mHandledFeatures.insert( this, QgsFeatureIds() << fid );
3776 }
3777
3778 for ( const QgsRelation &relation : relations )
3779 {
3780 //check if composition (and not association)
3781 switch ( relation.strength() )
3782 {
3784 {
3785 //get features connected over this relation
3786 QgsFeatureIterator relatedFeaturesIt = relation.getRelatedFeatures( getFeature( fid ) );
3787 QgsFeatureIds childFeatureIds;
3788 QgsFeature childFeature;
3789 while ( relatedFeaturesIt.nextFeature( childFeature ) )
3790 {
3791 childFeatureIds.insert( childFeature.id() );
3792 }
3793 if ( childFeatureIds.count() > 0 )
3794 {
3795 relation.referencingLayer()->startEditing();
3796 relation.referencingLayer()->deleteFeatures( childFeatureIds, context );
3797 }
3798 break;
3799 }
3800
3802 break;
3803 }
3804 }
3805 }
3806 }
3807
3808 if ( mJoinBuffer->containsJoins() )
3809 mJoinBuffer->deleteFeature( fid, context );
3810
3811 bool res = mEditBuffer->deleteFeature( fid );
3812
3813 return res;
3814}
3815
3817{
3819
3820 if ( !mEditBuffer )
3821 return false;
3822
3823 bool res = deleteFeatureCascade( fid, context );
3824
3825 if ( res )
3826 {
3827 updateExtents();
3828 }
3829
3830 return res;
3831}
3832
3834{
3836
3837 bool res = true;
3838
3839 if ( ( context && context->cascade ) || mJoinBuffer->containsJoins() )
3840 {
3841 // should ideally be "deleteFeaturesCascade" for performance!
3842 for ( QgsFeatureId fid : fids )
3843 res = deleteFeatureCascade( fid, context ) && res;
3844 }
3845 else
3846 {
3847 res = mEditBuffer && mEditBuffer->deleteFeatures( fids );
3848 }
3849
3850 if ( res )
3851 {
3852 mSelectedFeatureIds.subtract( fids ); // remove it from selection
3853 updateExtents();
3854 }
3855
3856 return res;
3857}
3858
3860{
3861 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
3863
3864 return mFields;
3865}
3866
3868{
3870
3871 QgsAttributeList pkAttributesList;
3872 if ( !mDataProvider )
3873 return pkAttributesList;
3874
3875 QgsAttributeList providerIndexes = mDataProvider->pkAttributeIndexes();
3876 for ( int i = 0; i < mFields.count(); ++i )
3877 {
3878 if ( mFields.fieldOrigin( i ) == Qgis::FieldOrigin::Provider &&
3879 providerIndexes.contains( mFields.fieldOriginIndex( i ) ) )
3880 pkAttributesList << i;
3881 }
3882
3883 return pkAttributesList;
3884}
3885
3887{
3889
3890 if ( !mDataProvider )
3891 return static_cast< long long >( Qgis::FeatureCountState::UnknownCount );
3892 return mDataProvider->featureCount() +
3893 ( mEditBuffer && ! mDataProvider->transaction() ? mEditBuffer->addedFeatures().size() - mEditBuffer->deletedFeatureIds().size() : 0 );
3894}
3895
3897{
3899
3900 const QgsFeatureIds deletedFeatures( mEditBuffer && ! mDataProvider->transaction() ? mEditBuffer->deletedFeatureIds() : QgsFeatureIds() );
3901 const QgsFeatureMap addedFeatures( mEditBuffer && ! mDataProvider->transaction() ? mEditBuffer->addedFeatures() : QgsFeatureMap() );
3902
3903 if ( mEditBuffer && !deletedFeatures.empty() )
3904 {
3905 if ( addedFeatures.size() > deletedFeatures.size() )
3907 else
3909 }
3910
3911 if ( ( !mEditBuffer || addedFeatures.empty() ) && mDataProvider && mDataProvider->empty() )
3913 else
3915}
3916
3917bool QgsVectorLayer::commitChanges( bool stopEditing )
3918{
3920
3921 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
3922 return project()->commitChanges( mCommitErrors, stopEditing, this );
3923
3924 mCommitErrors.clear();
3925
3926 if ( !mDataProvider )
3927 {
3928 mCommitErrors << tr( "ERROR: no provider" );
3929 return false;
3930 }
3931
3932 if ( !mEditBuffer )
3933 {
3934 mCommitErrors << tr( "ERROR: layer not editable" );
3935 return false;
3936 }
3937
3938 emit beforeCommitChanges( stopEditing );
3939
3940 if ( !mAllowCommit )
3941 return false;
3942
3943 mCommitChangesActive = true;
3944
3945 bool success = false;
3946 if ( mEditBuffer->editBufferGroup() )
3947 success = mEditBuffer->editBufferGroup()->commitChanges( mCommitErrors, stopEditing );
3948 else
3949 success = mEditBuffer->commitChanges( mCommitErrors );
3950
3951 mCommitChangesActive = false;
3952
3953 if ( !mDeletedFids.empty() )
3954 {
3955 emit featuresDeleted( mDeletedFids );
3956 mDeletedFids.clear();
3957 }
3958
3959 if ( success )
3960 {
3961 if ( stopEditing )
3962 {
3963 clearEditBuffer();
3964 }
3965 undoStack()->clear();
3966 emit afterCommitChanges();
3967 if ( stopEditing )
3968 emit editingStopped();
3969 }
3970 else
3971 {
3972 QgsMessageLog::logMessage( tr( "Commit errors:\n %1" ).arg( mCommitErrors.join( QLatin1String( "\n " ) ) ) );
3973 }
3974
3975 updateFields();
3976
3977 mDataProvider->updateExtents();
3978
3979 if ( stopEditing )
3980 {
3981 mDataProvider->leaveUpdateMode();
3982 }
3983
3984 // This second call is required because OGR provider with JSON
3985 // driver might have changed fields order after the call to
3986 // leaveUpdateMode
3987 if ( mFields.names() != mDataProvider->fields().names() )
3988 {
3989 updateFields();
3990 }
3991
3993
3994 return success;
3995}
3996
3998{
4000
4001 return mCommitErrors;
4002}
4003
4004bool QgsVectorLayer::rollBack( bool deleteBuffer )
4005{
4007
4008 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
4009 return project()->rollBack( mCommitErrors, deleteBuffer, this );
4010
4011 if ( !mEditBuffer )
4012 {
4013 return false;
4014 }
4015
4016 if ( !mDataProvider )
4017 {
4018 mCommitErrors << tr( "ERROR: no provider" );
4019 return false;
4020 }
4021
4022 bool rollbackExtent = !mDataProvider->transaction() && ( !mEditBuffer->deletedFeatureIds().isEmpty() ||
4023 !mEditBuffer->addedFeatures().isEmpty() ||
4024 !mEditBuffer->changedGeometries().isEmpty() );
4025
4026 emit beforeRollBack();
4027
4028 mEditBuffer->rollBack();
4029
4030 emit afterRollBack();
4031
4032 if ( isModified() )
4033 {
4034 // new undo stack roll back method
4035 // old method of calling every undo could cause many canvas refreshes
4036 undoStack()->setIndex( 0 );
4037 }
4038
4039 updateFields();
4040
4041 if ( deleteBuffer )
4042 {
4043 delete mEditBuffer;
4044 mEditBuffer = nullptr;
4045 undoStack()->clear();
4046 }
4047 emit editingStopped();
4048
4049 if ( rollbackExtent )
4050 updateExtents();
4051
4052 mDataProvider->leaveUpdateMode();
4053
4055 return true;
4056}
4057
4059{
4061
4062 return mSelectedFeatureIds.size();
4063}
4064
4066{
4067 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4069
4070 return mSelectedFeatureIds;
4071}
4072
4074{
4076
4077 QgsFeatureList features;
4078 features.reserve( mSelectedFeatureIds.count() );
4079 QgsFeature f;
4080
4082
4083 while ( it.nextFeature( f ) )
4084 {
4085 features.push_back( f );
4086 }
4087
4088 return features;
4089}
4090
4092{
4094
4095 if ( mSelectedFeatureIds.isEmpty() )
4096 return QgsFeatureIterator();
4097
4100
4101 if ( mSelectedFeatureIds.count() == 1 )
4102 request.setFilterFid( *mSelectedFeatureIds.constBegin() );
4103 else
4104 request.setFilterFids( mSelectedFeatureIds );
4105
4106 return getFeatures( request );
4107}
4108
4110{
4112
4113 if ( !mEditBuffer || !mDataProvider )
4114 return false;
4115
4116 if ( mGeometryOptions->isActive() )
4117 {
4118 for ( auto feature = features.begin(); feature != features.end(); ++feature )
4119 {
4120 QgsGeometry geom = feature->geometry();
4121 mGeometryOptions->apply( geom );
4122 feature->setGeometry( geom );
4123 }
4124 }
4125
4126 bool res = mEditBuffer->addFeatures( features );
4127 updateExtents();
4128
4129 if ( res && mJoinBuffer->containsJoins() )
4130 res = mJoinBuffer->addFeatures( features );
4131
4132 return res;
4133}
4134
4136{
4138
4139 // if layer is not spatial, it has not CRS!
4140 setCrs( ( isSpatial() && mDataProvider ) ? mDataProvider->crs() : QgsCoordinateReferenceSystem() );
4141}
4142
4144{
4146
4148 if ( exp.isField() )
4149 {
4150 return static_cast<const QgsExpressionNodeColumnRef *>( exp.rootNode() )->name();
4151 }
4152
4153 return QString();
4154}
4155
4156void QgsVectorLayer::setDisplayExpression( const QString &displayExpression )
4157{
4159
4160 if ( mDisplayExpression == displayExpression )
4161 return;
4162
4163 mDisplayExpression = displayExpression;
4165}
4166
4168{
4170
4171 if ( !mDisplayExpression.isEmpty() || mFields.isEmpty() )
4172 {
4173 return mDisplayExpression;
4174 }
4175 else
4176 {
4177 const QString candidateName = QgsVectorLayerUtils::guessFriendlyIdentifierField( mFields );
4178 if ( !candidateName.isEmpty() )
4179 {
4180 return QgsExpression::quotedColumnRef( candidateName );
4181 }
4182 else
4183 {
4184 return QString();
4185 }
4186 }
4187}
4188
4190{
4192
4193 // display expressions are used as a fallback when no explicit map tip template is set
4194 return mapTipsEnabled() && ( !mapTipTemplate().isEmpty() || !displayExpression().isEmpty() );
4195}
4196
4198{
4200
4201 return ( mEditBuffer && mDataProvider );
4202}
4203
4205{
4206 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4208
4211}
4212
4213bool QgsVectorLayer::isReadOnly() const
4214{
4216
4217 return mDataSourceReadOnly || mReadOnly;
4218}
4219
4220bool QgsVectorLayer::setReadOnly( bool readonly )
4221{
4223
4224 // exit if the layer is in editing mode
4225 if ( readonly && mEditBuffer )
4226 return false;
4227
4228 // exit if the data source is in read-only mode
4229 if ( !readonly && mDataSourceReadOnly )
4230 return false;
4231
4232 mReadOnly = readonly;
4233 emit readOnlyChanged();
4234 return true;
4235}
4236
4238{
4240
4241 if ( ! mDataProvider )
4242 return false;
4243
4244 if ( mDataSourceReadOnly )
4245 return false;
4246
4247 return mDataProvider->capabilities() & QgsVectorDataProvider::EditingCapabilities && ! mReadOnly;
4248}
4249
4251{
4253
4254 emit beforeModifiedCheck();
4255 return mEditBuffer && mEditBuffer->isModified();
4256}
4257
4258bool QgsVectorLayer::isAuxiliaryField( int index, int &srcIndex ) const
4259{
4261
4262 bool auxiliaryField = false;
4263 srcIndex = -1;
4264
4265 if ( !auxiliaryLayer() )
4266 return auxiliaryField;
4267
4268 if ( index >= 0 && fields().fieldOrigin( index ) == Qgis::FieldOrigin::Join )
4269 {
4270 const QgsVectorLayerJoinInfo *info = mJoinBuffer->joinForFieldIndex( index, fields(), srcIndex );
4271
4272 if ( info && info->joinLayerId() == auxiliaryLayer()->id() )
4273 auxiliaryField = true;
4274 }
4275
4276 return auxiliaryField;
4277}
4278
4280{
4282
4283 // we must allow setting a renderer if our geometry type is unknown
4284 // as this allows the renderer to be correctly set even for layers
4285 // with broken sources
4286 // (note that we allow REMOVING the renderer for non-spatial layers,
4287 // e.g. to permit removing the renderer when the layer changes from
4288 // a spatial layer to a non-spatial one)
4289 if ( r && !isSpatial() && mWkbType != Qgis::WkbType::Unknown )
4290 return;
4291
4292 if ( r != mRenderer )
4293 {
4294 delete mRenderer;
4295 mRenderer = r;
4296 mSymbolFeatureCounted = false;
4297 mSymbolFeatureCountMap.clear();
4298 mSymbolFeatureIdMap.clear();
4299
4300 if ( mRenderer )
4301 {
4302 const double refreshRate = QgsSymbolLayerUtils::rendererFrameRate( mRenderer );
4303 if ( refreshRate <= 0 )
4304 {
4305 mRefreshRendererTimer->stop();
4306 mRefreshRendererTimer->setInterval( 0 );
4307 }
4308 else
4309 {
4310 mRefreshRendererTimer->setInterval( 1000 / refreshRate );
4311 mRefreshRendererTimer->start();
4312 }
4313 }
4314
4315 emit rendererChanged();
4317 }
4318}
4319
4321{
4323
4324 if ( generator )
4325 {
4326 mRendererGenerators << generator;
4327 }
4328}
4329
4331{
4333
4334 for ( int i = mRendererGenerators.count() - 1; i >= 0; --i )
4335 {
4336 if ( mRendererGenerators.at( i )->id() == id )
4337 {
4338 delete mRendererGenerators.at( i );
4339 mRendererGenerators.removeAt( i );
4340 }
4341 }
4342}
4343
4344QList<const QgsFeatureRendererGenerator *> QgsVectorLayer::featureRendererGenerators() const
4345{
4346 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4348
4349 QList< const QgsFeatureRendererGenerator * > res;
4350 for ( const QgsFeatureRendererGenerator *generator : mRendererGenerators )
4351 res << generator;
4352 return res;
4353}
4354
4355void QgsVectorLayer::beginEditCommand( const QString &text )
4356{
4358
4359 if ( !mDataProvider )
4360 {
4361 return;
4362 }
4363 if ( mDataProvider->transaction() )
4364 {
4365 QString ignoredError;
4366 mDataProvider->transaction()->createSavepoint( ignoredError );
4367 }
4368 undoStack()->beginMacro( text );
4369 mEditCommandActive = true;
4370 emit editCommandStarted( text );
4371}
4372
4374{
4376
4377 if ( !mDataProvider )
4378 {
4379 return;
4380 }
4381 undoStack()->endMacro();
4382 mEditCommandActive = false;
4383 if ( !mDeletedFids.isEmpty() )
4384 {
4385 if ( selectedFeatureCount() > 0 )
4386 {
4387 mSelectedFeatureIds.subtract( mDeletedFids );
4388 }
4389 emit featuresDeleted( mDeletedFids );
4390 mDeletedFids.clear();
4391 }
4392 emit editCommandEnded();
4393}
4394
4396{
4398
4399 if ( !mDataProvider )
4400 {
4401 return;
4402 }
4403 undoStack()->endMacro();
4404 undoStack()->undo();
4405
4406 // it's not directly possible to pop the last command off the stack (the destroyed one)
4407 // and delete, so we add a dummy obsolete command to force this to occur.
4408 // Pushing the new command deletes the destroyed one, and since the new
4409 // command is obsolete it's automatically deleted by the undo stack.
4410 std::unique_ptr< QUndoCommand > command = std::make_unique< QUndoCommand >();
4411 command->setObsolete( true );
4412 undoStack()->push( command.release() );
4413
4414 mEditCommandActive = false;
4415 mDeletedFids.clear();
4416 emit editCommandDestroyed();
4417}
4418
4420{
4422
4423 return mJoinBuffer->addJoin( joinInfo );
4424}
4425
4426bool QgsVectorLayer::removeJoin( const QString &joinLayerId )
4427{
4429
4430 return mJoinBuffer->removeJoin( joinLayerId );
4431}
4432
4433const QList< QgsVectorLayerJoinInfo > QgsVectorLayer::vectorJoins() const
4434{
4436
4437 return mJoinBuffer->vectorJoins();
4438}
4439
4440int QgsVectorLayer::addExpressionField( const QString &exp, const QgsField &fld )
4441{
4443
4444 emit beforeAddingExpressionField( fld.name() );
4445 mExpressionFieldBuffer->addExpression( exp, fld );
4446 updateFields();
4447 int idx = mFields.indexFromName( fld.name() );
4448 emit attributeAdded( idx );
4449 return idx;
4450}
4451
4453{
4455
4456 emit beforeRemovingExpressionField( index );
4457 int oi = mFields.fieldOriginIndex( index );
4458 mExpressionFieldBuffer->removeExpression( oi );
4459 updateFields();
4460 emit attributeDeleted( index );
4461}
4462
4463QString QgsVectorLayer::expressionField( int index ) const
4464{
4466
4467 if ( mFields.fieldOrigin( index ) != Qgis::FieldOrigin::Expression )
4468 return QString();
4469
4470 int oi = mFields.fieldOriginIndex( index );
4471 if ( oi < 0 || oi >= mExpressionFieldBuffer->expressions().size() )
4472 return QString();
4473
4474 return mExpressionFieldBuffer->expressions().at( oi ).cachedExpression.expression();
4475}
4476
4477void QgsVectorLayer::updateExpressionField( int index, const QString &exp )
4478{
4480
4481 int oi = mFields.fieldOriginIndex( index );
4482 mExpressionFieldBuffer->updateExpression( oi, exp );
4483}
4484
4486{
4487 // non fatal for now -- the QgsVirtualLayerTask class is not thread safe and calls this
4489
4490 if ( !mDataProvider )
4491 return;
4492
4493 QgsFields oldFields = mFields;
4494
4495 mFields = mDataProvider->fields();
4496
4497 // added / removed fields
4498 if ( mEditBuffer )
4499 mEditBuffer->updateFields( mFields );
4500
4501 // joined fields
4502 if ( mJoinBuffer->containsJoins() )
4503 mJoinBuffer->updateFields( mFields );
4504
4505 if ( mExpressionFieldBuffer )
4506 mExpressionFieldBuffer->updateFields( mFields );
4507
4508 // set aliases and default values
4509 for ( auto aliasIt = mAttributeAliasMap.constBegin(); aliasIt != mAttributeAliasMap.constEnd(); ++aliasIt )
4510 {
4511 int index = mFields.lookupField( aliasIt.key() );
4512 if ( index < 0 )
4513 continue;
4514
4515 mFields[ index ].setAlias( aliasIt.value() );
4516 }
4517
4518 for ( auto splitPolicyIt = mAttributeSplitPolicy.constBegin(); splitPolicyIt != mAttributeSplitPolicy.constEnd(); ++splitPolicyIt )
4519 {
4520 int index = mFields.lookupField( splitPolicyIt.key() );
4521 if ( index < 0 )
4522 continue;
4523
4524 mFields[ index ].setSplitPolicy( splitPolicyIt.value() );
4525 }
4526
4527 for ( auto duplicatePolicyIt = mAttributeDuplicatePolicy.constBegin(); duplicatePolicyIt != mAttributeDuplicatePolicy.constEnd(); ++duplicatePolicyIt )
4528 {
4529 int index = mFields.lookupField( duplicatePolicyIt.key() );
4530 if ( index < 0 )
4531 continue;
4532
4533 mFields[ index ].setDuplicatePolicy( duplicatePolicyIt.value() );
4534 }
4535
4536 // Update configuration flags
4537 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
4538 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
4539 {
4540 int index = mFields.lookupField( flagsIt.key() );
4541 if ( index < 0 )
4542 continue;
4543
4544 mFields[index].setConfigurationFlags( flagsIt.value() );
4545 }
4546
4547 // Update default values
4548 mDefaultValueOnUpdateFields.clear();
4549 QMap< QString, QgsDefaultValue >::const_iterator defaultIt = mDefaultExpressionMap.constBegin();
4550 for ( ; defaultIt != mDefaultExpressionMap.constEnd(); ++defaultIt )
4551 {
4552 int index = mFields.lookupField( defaultIt.key() );
4553 if ( index < 0 )
4554 continue;
4555
4556 mFields[ index ].setDefaultValueDefinition( defaultIt.value() );
4557 if ( defaultIt.value().applyOnUpdate() )
4558 mDefaultValueOnUpdateFields.insert( index );
4559 }
4560
4561 QMap< QString, QgsFieldConstraints::Constraints >::const_iterator constraintIt = mFieldConstraints.constBegin();
4562 for ( ; constraintIt != mFieldConstraints.constEnd(); ++constraintIt )
4563 {
4564 int index = mFields.lookupField( constraintIt.key() );
4565 if ( index < 0 )
4566 continue;
4567
4568 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4569
4570 // always keep provider constraints intact
4571 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintNotNull ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintNotNull ) )
4573 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintUnique ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintUnique ) )
4575 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintExpression ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintExpression ) )
4577 mFields[ index ].setConstraints( constraints );
4578 }
4579
4580 QMap< QString, QPair< QString, QString > >::const_iterator constraintExpIt = mFieldConstraintExpressions.constBegin();
4581 for ( ; constraintExpIt != mFieldConstraintExpressions.constEnd(); ++constraintExpIt )
4582 {
4583 int index = mFields.lookupField( constraintExpIt.key() );
4584 if ( index < 0 )
4585 continue;
4586
4587 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4588
4589 // always keep provider constraints intact
4591 continue;
4592
4593 constraints.setConstraintExpression( constraintExpIt.value().first, constraintExpIt.value().second );
4594 mFields[ index ].setConstraints( constraints );
4595 }
4596
4597 QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength >::const_iterator constraintStrengthIt = mFieldConstraintStrength.constBegin();
4598 for ( ; constraintStrengthIt != mFieldConstraintStrength.constEnd(); ++constraintStrengthIt )
4599 {
4600 int index = mFields.lookupField( constraintStrengthIt.key().first );
4601 if ( index < 0 )
4602 continue;
4603
4604 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4605
4606 // always keep provider constraints intact
4608 continue;
4609
4610 constraints.setConstraintStrength( constraintStrengthIt.key().second, constraintStrengthIt.value() );
4611 mFields[ index ].setConstraints( constraints );
4612 }
4613
4614 auto fieldWidgetIterator = mFieldWidgetSetups.constBegin();
4615 for ( ; fieldWidgetIterator != mFieldWidgetSetups.constEnd(); ++ fieldWidgetIterator )
4616 {
4617 int index = mFields.indexOf( fieldWidgetIterator.key() );
4618 if ( index < 0 )
4619 continue;
4620
4621 mFields[index].setEditorWidgetSetup( fieldWidgetIterator.value() );
4622 }
4623
4624 if ( oldFields != mFields )
4625 {
4626 emit updatedFields();
4627 mEditFormConfig.setFields( mFields );
4628 }
4629
4630}
4631
4632QVariant QgsVectorLayer::defaultValue( int index, const QgsFeature &feature, QgsExpressionContext *context ) const
4633{
4635
4636 if ( index < 0 || index >= mFields.count() || !mDataProvider )
4637 return QVariant();
4638
4639 QString expression = mFields.at( index ).defaultValueDefinition().expression();
4640 if ( expression.isEmpty() )
4641 return mDataProvider->defaultValue( index );
4642
4643 QgsExpressionContext *evalContext = context;
4644 std::unique_ptr< QgsExpressionContext > tempContext;
4645 if ( !evalContext )
4646 {
4647 // no context passed, so we create a default one
4649 evalContext = tempContext.get();
4650 }
4651
4652 if ( feature.isValid() )
4653 {
4655 featScope->setFeature( feature );
4656 featScope->setFields( feature.fields() );
4657 evalContext->appendScope( featScope );
4658 }
4659
4660 QVariant val;
4661 QgsExpression exp( expression );
4662 exp.prepare( evalContext );
4663 if ( exp.hasEvalError() )
4664 {
4665 QgsLogger::warning( "Error evaluating default value: " + exp.evalErrorString() );
4666 }
4667 else
4668 {
4669 val = exp.evaluate( evalContext );
4670 }
4671
4672 if ( feature.isValid() )
4673 {
4674 delete evalContext->popScope();
4675 }
4676
4677 return val;
4678}
4679
4681{
4683
4684 if ( index < 0 || index >= mFields.count() )
4685 return;
4686
4687 if ( definition.isValid() )
4688 {
4689 mDefaultExpressionMap.insert( mFields.at( index ).name(), definition );
4690 }
4691 else
4692 {
4693 mDefaultExpressionMap.remove( mFields.at( index ).name() );
4694 }
4695 updateFields();
4696}
4697
4699{
4701
4702 if ( index < 0 || index >= mFields.count() )
4703 return QgsDefaultValue();
4704 else
4705 return mFields.at( index ).defaultValueDefinition();
4706}
4707
4708QSet<QVariant> QgsVectorLayer::uniqueValues( int index, int limit ) const
4709{
4711
4712 QSet<QVariant> uniqueValues;
4713 if ( !mDataProvider )
4714 {
4715 return uniqueValues;
4716 }
4717
4718 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
4719 switch ( origin )
4720 {
4722 return uniqueValues;
4723
4724 case Qgis::FieldOrigin::Provider: //a provider field
4725 {
4726 uniqueValues = mDataProvider->uniqueValues( index, limit );
4727
4728 if ( mEditBuffer && ! mDataProvider->transaction() )
4729 {
4730 QSet<QString> vals;
4731 const auto constUniqueValues = uniqueValues;
4732 for ( const QVariant &v : constUniqueValues )
4733 {
4734 vals << v.toString();
4735 }
4736
4737 QgsFeatureMap added = mEditBuffer->addedFeatures();
4738 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
4739 while ( addedIt.hasNext() && ( limit < 0 || uniqueValues.count() < limit ) )
4740 {
4741 addedIt.next();
4742 QVariant v = addedIt.value().attribute( index );
4743 if ( v.isValid() )
4744 {
4745 QString vs = v.toString();
4746 if ( !vals.contains( vs ) )
4747 {
4748 vals << vs;
4749 uniqueValues << v;
4750 }
4751 }
4752 }
4753
4754 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
4755 while ( it.hasNext() && ( limit < 0 || uniqueValues.count() < limit ) )
4756 {
4757 it.next();
4758 QVariant v = it.value().value( index );
4759 if ( v.isValid() )
4760 {
4761 QString vs = v.toString();
4762 if ( !vals.contains( vs ) )
4763 {
4764 vals << vs;
4765 uniqueValues << v;
4766 }
4767 }
4768 }
4769 }
4770
4771 return uniqueValues;
4772 }
4773
4775 // the layer is editable, but in certain cases it can still be avoided going through all features
4776 if ( mDataProvider->transaction() || (
4777 mEditBuffer->deletedFeatureIds().isEmpty() &&
4778 mEditBuffer->addedFeatures().isEmpty() &&
4779 !mEditBuffer->deletedAttributeIds().contains( index ) &&
4780 mEditBuffer->changedAttributeValues().isEmpty() ) )
4781 {
4782 uniqueValues = mDataProvider->uniqueValues( index, limit );
4783 return uniqueValues;
4784 }
4785 [[fallthrough]];
4786 //we need to go through each feature
4789 {
4790 QgsAttributeList attList;
4791 attList << index;
4792
4795 .setSubsetOfAttributes( attList ) );
4796
4797 QgsFeature f;
4798 QVariant currentValue;
4799 QHash<QString, QVariant> val;
4800 while ( fit.nextFeature( f ) )
4801 {
4802 currentValue = f.attribute( index );
4803 val.insert( currentValue.toString(), currentValue );
4804 if ( limit >= 0 && val.size() >= limit )
4805 {
4806 break;
4807 }
4808 }
4809
4810 return qgis::listToSet( val.values() );
4811 }
4812 }
4813
4814 Q_ASSERT_X( false, "QgsVectorLayer::uniqueValues()", "Unknown source of the field!" );
4815 return uniqueValues;
4816}
4817
4818QStringList QgsVectorLayer::uniqueStringsMatching( int index, const QString &substring, int limit, QgsFeedback *feedback ) const
4819{
4821
4822 QStringList results;
4823 if ( !mDataProvider )
4824 {
4825 return results;
4826 }
4827
4828 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
4829 switch ( origin )
4830 {
4832 return results;
4833
4834 case Qgis::FieldOrigin::Provider: //a provider field
4835 {
4836 results = mDataProvider->uniqueStringsMatching( index, substring, limit, feedback );
4837
4838 if ( mEditBuffer && ! mDataProvider->transaction() )
4839 {
4840 QgsFeatureMap added = mEditBuffer->addedFeatures();
4841 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
4842 while ( addedIt.hasNext() && ( limit < 0 || results.count() < limit ) && ( !feedback || !feedback->isCanceled() ) )
4843 {
4844 addedIt.next();
4845 QVariant v = addedIt.value().attribute( index );
4846 if ( v.isValid() )
4847 {
4848 QString vs = v.toString();
4849 if ( vs.contains( substring, Qt::CaseInsensitive ) && !results.contains( vs ) )
4850 {
4851 results << vs;
4852 }
4853 }
4854 }
4855
4856 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
4857 while ( it.hasNext() && ( limit < 0 || results.count() < limit ) && ( !feedback || !feedback->isCanceled() ) )
4858 {
4859 it.next();
4860 QVariant v = it.value().value( index );
4861 if ( v.isValid() )
4862 {
4863 QString vs = v.toString();
4864 if ( vs.contains( substring, Qt::CaseInsensitive ) && !results.contains( vs ) )
4865 {
4866 results << vs;
4867 }
4868 }
4869 }
4870 }
4871
4872 return results;
4873 }
4874
4876 // the layer is editable, but in certain cases it can still be avoided going through all features
4877 if ( mDataProvider->transaction() || ( mEditBuffer->deletedFeatureIds().isEmpty() &&
4878 mEditBuffer->addedFeatures().isEmpty() &&
4879 !mEditBuffer->deletedAttributeIds().contains( index ) &&
4880 mEditBuffer->changedAttributeValues().isEmpty() ) )
4881 {
4882 return mDataProvider->uniqueStringsMatching( index, substring, limit, feedback );
4883 }
4884 [[fallthrough]];
4885 //we need to go through each feature
4888 {
4889 QgsAttributeList attList;
4890 attList << index;
4891
4892 QgsFeatureRequest request;
4893 request.setSubsetOfAttributes( attList );
4895 QString fieldName = mFields.at( index ).name();
4896 request.setFilterExpression( QStringLiteral( "\"%1\" ILIKE '%%2%'" ).arg( fieldName, substring ) );
4897 QgsFeatureIterator fit = getFeatures( request );
4898
4899 QgsFeature f;
4900 QString currentValue;
4901 while ( fit.nextFeature( f ) )
4902 {
4903 currentValue = f.attribute( index ).toString();
4904 if ( !results.contains( currentValue ) )
4905 results << currentValue;
4906
4907 if ( ( limit >= 0 && results.size() >= limit ) || ( feedback && feedback->isCanceled() ) )
4908 {
4909 break;
4910 }
4911 }
4912
4913 return results;
4914 }
4915 }
4916
4917 Q_ASSERT_X( false, "QgsVectorLayer::uniqueStringsMatching()", "Unknown source of the field!" );
4918 return results;
4919}
4920
4921QVariant QgsVectorLayer::minimumValue( int index ) const
4922{
4924
4925 QVariant minimum;
4926 minimumOrMaximumValue( index, &minimum, nullptr );
4927 return minimum;
4928}
4929
4930QVariant QgsVectorLayer::maximumValue( int index ) const
4931{
4933
4934 QVariant maximum;
4935 minimumOrMaximumValue( index, nullptr, &maximum );
4936 return maximum;
4937}
4938
4939void QgsVectorLayer::minimumAndMaximumValue( int index, QVariant &minimum, QVariant &maximum ) const
4940{
4942
4943 minimumOrMaximumValue( index, &minimum, &maximum );
4944}
4945
4946void QgsVectorLayer::minimumOrMaximumValue( int index, QVariant *minimum, QVariant *maximum ) const
4947{
4949
4950 if ( minimum )
4951 *minimum = QVariant();
4952 if ( maximum )
4953 *maximum = QVariant();
4954
4955 if ( !mDataProvider )
4956 {
4957 return;
4958 }
4959
4960 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
4961
4962 switch ( origin )
4963 {
4965 {
4966 return;
4967 }
4968
4969 case Qgis::FieldOrigin::Provider: //a provider field
4970 {
4971 if ( minimum )
4972 *minimum = mDataProvider->minimumValue( index );
4973 if ( maximum )
4974 *maximum = mDataProvider->maximumValue( index );
4975 if ( mEditBuffer && ! mDataProvider->transaction() )
4976 {
4977 const QgsFeatureMap added = mEditBuffer->addedFeatures();
4978 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
4979 while ( addedIt.hasNext() )
4980 {
4981 addedIt.next();
4982 const QVariant v = addedIt.value().attribute( index );
4983 if ( minimum && v.isValid() && qgsVariantLessThan( v, *minimum ) )
4984 *minimum = v;
4985 if ( maximum && v.isValid() && qgsVariantGreaterThan( v, *maximum ) )
4986 *maximum = v;
4987 }
4988
4989 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
4990 while ( it.hasNext() )
4991 {
4992 it.next();
4993 const QVariant v = it.value().value( index );
4994 if ( minimum && v.isValid() && qgsVariantLessThan( v, *minimum ) )
4995 *minimum = v;
4996 if ( maximum && v.isValid() && qgsVariantGreaterThan( v, *maximum ) )
4997 *maximum = v;
4998 }
4999 }
5000 return;
5001 }
5002
5004 {
5005 // the layer is editable, but in certain cases it can still be avoided going through all features
5006 if ( mDataProvider->transaction() || ( mEditBuffer->deletedFeatureIds().isEmpty() &&
5007 mEditBuffer->addedFeatures().isEmpty() &&
5008 !mEditBuffer->deletedAttributeIds().contains( index ) &&
5009 mEditBuffer->changedAttributeValues().isEmpty() ) )
5010 {
5011 if ( minimum )
5012 *minimum = mDataProvider->minimumValue( index );
5013 if ( maximum )
5014 *maximum = mDataProvider->maximumValue( index );
5015 return;
5016 }
5017 }
5018 [[fallthrough]];
5019 // no choice but to go through all features
5022 {
5023 // we need to go through each feature
5024 QgsAttributeList attList;
5025 attList << index;
5026
5029 .setSubsetOfAttributes( attList ) );
5030
5031 QgsFeature f;
5032 bool firstValue = true;
5033 while ( fit.nextFeature( f ) )
5034 {
5035 const QVariant currentValue = f.attribute( index );
5036 if ( QgsVariantUtils::isNull( currentValue ) )
5037 continue;
5038
5039 if ( firstValue )
5040 {
5041 if ( minimum )
5042 *minimum = currentValue;
5043 if ( maximum )
5044 *maximum = currentValue;
5045 firstValue = false;
5046 }
5047 else
5048 {
5049 if ( minimum && currentValue.isValid() && qgsVariantLessThan( currentValue, *minimum ) )
5050 *minimum = currentValue;
5051 if ( maximum && currentValue.isValid() && qgsVariantGreaterThan( currentValue, *maximum ) )
5052 *maximum = currentValue;
5053 }
5054 }
5055 return;
5056 }
5057 }
5058
5059 Q_ASSERT_X( false, "QgsVectorLayer::minimumOrMaximumValue()", "Unknown source of the field!" );
5060}
5061
5062void QgsVectorLayer::createEditBuffer()
5063{
5065
5066 if ( mEditBuffer )
5067 clearEditBuffer();
5068
5069 if ( mDataProvider->transaction() )
5070 {
5071 mEditBuffer = new QgsVectorLayerEditPassthrough( this );
5072
5073 connect( mDataProvider->transaction(), &QgsTransaction::dirtied, this, &QgsVectorLayer::onDirtyTransaction, Qt::UniqueConnection );
5074 }
5075 else
5076 {
5077 mEditBuffer = new QgsVectorLayerEditBuffer( this );
5078 }
5079 // forward signals
5080 connect( mEditBuffer, &QgsVectorLayerEditBuffer::layerModified, this, &QgsVectorLayer::invalidateSymbolCountedFlag );
5081 connect( mEditBuffer, &QgsVectorLayerEditBuffer::layerModified, this, &QgsVectorLayer::layerModified ); // TODO[MD]: necessary?
5082 //connect( mEditBuffer, SIGNAL( layerModified() ), this, SLOT( triggerRepaint() ) ); // TODO[MD]: works well?
5084 connect( mEditBuffer, &QgsVectorLayerEditBuffer::featureDeleted, this, &QgsVectorLayer::onFeatureDeleted );
5095
5096}
5097
5098void QgsVectorLayer::clearEditBuffer()
5099{
5101
5102 delete mEditBuffer;
5103 mEditBuffer = nullptr;
5104}
5105
5106QVariant QgsVectorLayer::aggregate( Qgis::Aggregate aggregate, const QString &fieldOrExpression,
5108 bool *ok, QgsFeatureIds *fids, QgsFeedback *feedback, QString *error ) const
5109{
5110 // non fatal for now -- the aggregate expression functions are not thread safe and call this
5112
5113 if ( ok )
5114 *ok = false;
5115 if ( error )
5116 error->clear();
5117
5118 if ( !mDataProvider )
5119 {
5120 if ( error )
5121 *error = tr( "Layer is invalid" );
5122 return QVariant();
5123 }
5124
5125 // test if we are calculating based on a field
5126 const int attrIndex = QgsExpression::expressionToLayerFieldIndex( fieldOrExpression, this );
5127 if ( attrIndex >= 0 )
5128 {
5129 // aggregate is based on a field - if it's a provider field, we could possibly hand over the calculation
5130 // to the provider itself
5131 Qgis::FieldOrigin origin = mFields.fieldOrigin( attrIndex );
5132 if ( origin == Qgis::FieldOrigin::Provider )
5133 {
5134 bool providerOk = false;
5135 QVariant val = mDataProvider->aggregate( aggregate, attrIndex, parameters, context, providerOk, fids );
5136 if ( providerOk )
5137 {
5138 // provider handled calculation
5139 if ( ok )
5140 *ok = true;
5141 return val;
5142 }
5143 }
5144 }
5145
5146 // fallback to using aggregate calculator to determine aggregate
5147 QgsAggregateCalculator c( this );
5148 if ( fids )
5149 c.setFidsFilter( *fids );
5150 c.setParameters( parameters );
5151 bool aggregateOk = false;
5152 const QVariant result = c.calculate( aggregate, fieldOrExpression, context, &aggregateOk, feedback );
5153 if ( ok )
5154 *ok = aggregateOk;
5155 if ( !aggregateOk && error )
5156 *error = c.lastError();
5157
5158 return result;
5159}
5160
5161void QgsVectorLayer::setFeatureBlendMode( QPainter::CompositionMode featureBlendMode )
5162{
5164
5165 if ( mFeatureBlendMode == featureBlendMode )
5166 return;
5167
5168 mFeatureBlendMode = featureBlendMode;
5171}
5172
5173QPainter::CompositionMode QgsVectorLayer::featureBlendMode() const
5174{
5175 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
5177
5178 return mFeatureBlendMode;
5179}
5180
5181void QgsVectorLayer::readSldLabeling( const QDomNode &node )
5182{
5184
5185 setLabeling( nullptr ); // start with no labeling
5186 setLabelsEnabled( false );
5187
5188 QDomElement element = node.toElement();
5189 if ( element.isNull() )
5190 return;
5191
5192 QDomElement userStyleElem = element.firstChildElement( QStringLiteral( "UserStyle" ) );
5193 if ( userStyleElem.isNull() )
5194 {
5195 QgsDebugMsgLevel( QStringLiteral( "Info: UserStyle element not found." ), 4 );
5196 return;
5197 }
5198
5199 QDomElement featTypeStyleElem = userStyleElem.firstChildElement( QStringLiteral( "FeatureTypeStyle" ) );
5200 if ( featTypeStyleElem.isNull() )
5201 {
5202 QgsDebugMsgLevel( QStringLiteral( "Info: FeatureTypeStyle element not found." ), 4 );
5203 return;
5204 }
5205
5206 // create empty FeatureTypeStyle element to merge TextSymbolizer's Rule's from all FeatureTypeStyle's
5207 QDomElement mergedFeatTypeStyle = featTypeStyleElem.cloneNode( false ).toElement();
5208
5209 // use the RuleRenderer when more rules are present or the rule
5210 // has filters or min/max scale denominators set,
5211 // otherwise use the Simple labeling
5212 bool needRuleBasedLabeling = false;
5213 int ruleCount = 0;
5214
5215 while ( !featTypeStyleElem.isNull() )
5216 {
5217 QDomElement ruleElem = featTypeStyleElem.firstChildElement( QStringLiteral( "Rule" ) );
5218 while ( !ruleElem.isNull() )
5219 {
5220 // test rule children element to check if we need to create RuleRenderer
5221 // and if the rule has a symbolizer
5222 bool hasTextSymbolizer = false;
5223 bool hasRuleBased = false;
5224 QDomElement ruleChildElem = ruleElem.firstChildElement();
5225 while ( !ruleChildElem.isNull() )
5226 {
5227 // rule has filter or min/max scale denominator, use the RuleRenderer
5228 if ( ruleChildElem.localName() == QLatin1String( "Filter" ) ||
5229 ruleChildElem.localName() == QLatin1String( "MinScaleDenominator" ) ||
5230 ruleChildElem.localName() == QLatin1String( "MaxScaleDenominator" ) )
5231 {
5232 hasRuleBased = true;
5233 }
5234 // rule has a renderer symbolizer, not a text symbolizer
5235 else if ( ruleChildElem.localName() == QLatin1String( "TextSymbolizer" ) )
5236 {
5237 QgsDebugMsgLevel( QStringLiteral( "Info: TextSymbolizer element found" ), 4 );
5238 hasTextSymbolizer = true;
5239 }
5240
5241 ruleChildElem = ruleChildElem.nextSiblingElement();
5242 }
5243
5244 if ( hasTextSymbolizer )
5245 {
5246 ruleCount++;
5247
5248 // append a clone of all Rules to the merged FeatureTypeStyle element
5249 mergedFeatTypeStyle.appendChild( ruleElem.cloneNode().toElement() );
5250
5251 if ( hasRuleBased )
5252 {
5253 QgsDebugMsgLevel( QStringLiteral( "Info: Filter or Min/MaxScaleDenominator element found: need a RuleBasedLabeling" ), 4 );
5254 needRuleBasedLabeling = true;
5255 }
5256 }
5257
5258 // more rules present, use the RuleRenderer
5259 if ( ruleCount > 1 )
5260 {
5261 QgsDebugMsgLevel( QStringLiteral( "Info: More Rule elements found: need a RuleBasedLabeling" ), 4 );
5262 needRuleBasedLabeling = true;
5263 }
5264
5265 // not use the rule based labeling if no rules with textSymbolizer
5266 if ( ruleCount == 0 )
5267 {
5268 needRuleBasedLabeling = false;
5269 }
5270
5271 ruleElem = ruleElem.nextSiblingElement( QStringLiteral( "Rule" ) );
5272 }
5273 featTypeStyleElem = featTypeStyleElem.nextSiblingElement( QStringLiteral( "FeatureTypeStyle" ) );
5274 }
5275
5276 if ( ruleCount == 0 )
5277 {
5278 QgsDebugMsgLevel( QStringLiteral( "Info: No TextSymbolizer element." ), 4 );
5279 return;
5280 }
5281
5282 QDomElement ruleElem = mergedFeatTypeStyle.firstChildElement( QStringLiteral( "Rule" ) );
5283
5284 if ( needRuleBasedLabeling )
5285 {
5286 QgsDebugMsgLevel( QStringLiteral( "Info: rule based labeling" ), 4 );
5287 QgsRuleBasedLabeling::Rule *rootRule = new QgsRuleBasedLabeling::Rule( nullptr );
5288 while ( !ruleElem.isNull() )
5289 {
5290
5291 QString label, description, filterExp;
5292 int scaleMinDenom = 0, scaleMaxDenom = 0;
5293 QgsPalLayerSettings settings;
5294
5295 // retrieve the Rule element child nodes
5296 QDomElement childElem = ruleElem.firstChildElement();
5297 while ( !childElem.isNull() )
5298 {
5299 if ( childElem.localName() == QLatin1String( "Name" ) )
5300 {
5301 // <se:Name> tag contains the rule identifier,
5302 // so prefer title tag for the label property value
5303 if ( label.isEmpty() )
5304 label = childElem.firstChild().nodeValue();
5305 }
5306 else if ( childElem.localName() == QLatin1String( "Description" ) )
5307 {
5308 // <se:Description> can contains a title and an abstract
5309 QDomElement titleElem = childElem.firstChildElement( QStringLiteral( "Title" ) );
5310 if ( !titleElem.isNull() )
5311 {
5312 label = titleElem.firstChild().nodeValue();
5313 }
5314
5315 QDomElement abstractElem = childElem.firstChildElement( QStringLiteral( "Abstract" ) );
5316 if ( !abstractElem.isNull() )
5317 {
5318 description = abstractElem.firstChild().nodeValue();
5319 }
5320 }
5321 else if ( childElem.localName() == QLatin1String( "Abstract" ) )
5322 {
5323 // <sld:Abstract> (v1.0)
5324 description = childElem.firstChild().nodeValue();
5325 }
5326 else if ( childElem.localName() == QLatin1String( "Title" ) )
5327 {
5328 // <sld:Title> (v1.0)
5329 label = childElem.firstChild().nodeValue();
5330 }
5331 else if ( childElem.localName() == QLatin1String( "Filter" ) )
5332 {
5334 if ( filter )
5335 {
5336 if ( filter->hasParserError() )
5337 {
5338 QgsDebugMsgLevel( QStringLiteral( "SLD Filter parsing error: %1" ).arg( filter->parserErrorString() ), 3 );
5339 }
5340 else
5341 {
5342 filterExp = filter->expression();
5343 }
5344 delete filter;
5345 }
5346 }
5347 else if ( childElem.localName() == QLatin1String( "MinScaleDenominator" ) )
5348 {
5349 bool ok;
5350 int v = childElem.firstChild().nodeValue().toInt( &ok );
5351 if ( ok )
5352 scaleMinDenom = v;
5353 }
5354 else if ( childElem.localName() == QLatin1String( "MaxScaleDenominator" ) )
5355 {
5356 bool ok;
5357 int v = childElem.firstChild().nodeValue().toInt( &ok );
5358 if ( ok )
5359 scaleMaxDenom = v;
5360 }
5361 else if ( childElem.localName() == QLatin1String( "TextSymbolizer" ) )
5362 {
5363 readSldTextSymbolizer( childElem, settings );
5364 }
5365
5366 childElem = childElem.nextSiblingElement();
5367 }
5368
5369 QgsRuleBasedLabeling::Rule *ruleLabeling = new QgsRuleBasedLabeling::Rule( new QgsPalLayerSettings( settings ), scaleMinDenom, scaleMaxDenom, filterExp, label );
5370 rootRule->appendChild( ruleLabeling );
5371
5372 ruleElem = ruleElem.nextSiblingElement();
5373 }
5374
5375 setLabeling( new QgsRuleBasedLabeling( rootRule ) );
5376 setLabelsEnabled( true );
5377 }
5378 else
5379 {
5380 QgsDebugMsgLevel( QStringLiteral( "Info: simple labeling" ), 4 );
5381 // retrieve the TextSymbolizer element child node
5382 QDomElement textSymbolizerElem = ruleElem.firstChildElement( QStringLiteral( "TextSymbolizer" ) );
5384 if ( readSldTextSymbolizer( textSymbolizerElem, s ) )
5385 {
5387 setLabelsEnabled( true );
5388 }
5389 }
5390}
5391
5392bool QgsVectorLayer::readSldTextSymbolizer( const QDomNode &node, QgsPalLayerSettings &settings ) const
5393{
5395
5396 if ( node.localName() != QLatin1String( "TextSymbolizer" ) )
5397 {
5398 QgsDebugMsgLevel( QStringLiteral( "Not a TextSymbolizer element: %1" ).arg( node.localName() ), 3 );
5399 return false;
5400 }
5401 QDomElement textSymbolizerElem = node.toElement();
5402 // Label
5403 QDomElement labelElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Label" ) );
5404 if ( !labelElem.isNull() )
5405 {
5406 QDomElement propertyNameElem = labelElem.firstChildElement( QStringLiteral( "PropertyName" ) );
5407 if ( !propertyNameElem.isNull() )
5408 {
5409 // set labeling defaults
5410
5411 // label attribute
5412 QString labelAttribute = propertyNameElem.text();
5413 settings.fieldName = labelAttribute;
5414 settings.isExpression = false;
5415
5416 int fieldIndex = mFields.lookupField( labelAttribute );
5417 if ( fieldIndex == -1 )
5418 {
5419 // label attribute is not in columns, check if it is an expression
5420 QgsExpression exp( labelAttribute );
5421 if ( !exp.hasEvalError() )
5422 {
5423 settings.isExpression = true;
5424 }
5425 else
5426 {
5427 QgsDebugMsgLevel( QStringLiteral( "SLD label attribute error: %1" ).arg( exp.evalErrorString() ), 3 );
5428 }
5429 }
5430 }
5431 else
5432 {
5433 QgsDebugMsgLevel( QStringLiteral( "Info: PropertyName element not found." ), 4 );
5434 return false;
5435 }
5436 }
5437 else
5438 {
5439 QgsDebugMsgLevel( QStringLiteral( "Info: Label element not found." ), 4 );
5440 return false;
5441 }
5442
5444 if ( textSymbolizerElem.hasAttribute( QStringLiteral( "uom" ) ) )
5445 {
5446 sldUnitSize = QgsSymbolLayerUtils::decodeSldUom( textSymbolizerElem.attribute( QStringLiteral( "uom" ) ) );
5447 }
5448
5449 QString fontFamily = QStringLiteral( "Sans-Serif" );
5450 int fontPointSize = 10;
5452 int fontWeight = -1;
5453 bool fontItalic = false;
5454 bool fontUnderline = false;
5455
5456 // Font
5457 QDomElement fontElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Font" ) );
5458 if ( !fontElem.isNull() )
5459 {
5460 QgsStringMap fontSvgParams = QgsSymbolLayerUtils::getSvgParameterList( fontElem );
5461 for ( QgsStringMap::iterator it = fontSvgParams.begin(); it != fontSvgParams.end(); ++it )
5462 {
5463 QgsDebugMsgLevel( QStringLiteral( "found fontSvgParams %1: %2" ).arg( it.key(), it.value() ), 4 );
5464
5465 if ( it.key() == QLatin1String( "font-family" ) )
5466 {
5467 fontFamily = it.value();
5468 }
5469 else if ( it.key() == QLatin1String( "font-style" ) )
5470 {
5471 fontItalic = ( it.value() == QLatin1String( "italic" ) ) || ( it.value() == QLatin1String( "Italic" ) );
5472 }
5473 else if ( it.key() == QLatin1String( "font-size" ) )
5474 {
5475 bool ok;
5476 int fontSize = it.value().toInt( &ok );
5477 if ( ok )
5478 {
5479 fontPointSize = fontSize;
5480 fontUnitSize = sldUnitSize;
5481 }
5482 }
5483 else if ( it.key() == QLatin1String( "font-weight" ) )
5484 {
5485 if ( ( it.value() == QLatin1String( "bold" ) ) || ( it.value() == QLatin1String( "Bold" ) ) )
5486 fontWeight = QFont::Bold;
5487 }
5488 else if ( it.key() == QLatin1String( "font-underline" ) )
5489 {
5490 fontUnderline = ( it.value() == QLatin1String( "underline" ) ) || ( it.value() == QLatin1String( "Underline" ) );
5491 }
5492 }
5493 }
5494
5495 QgsTextFormat format;
5496 QFont font( fontFamily, fontPointSize, fontWeight, fontItalic );
5497 font.setUnderline( fontUnderline );
5498 format.setFont( font );
5499 format.setSize( fontPointSize );
5500 format.setSizeUnit( fontUnitSize );
5501
5502 // Fill
5503 QDomElement fillElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Fill" ) );
5504 QColor textColor;
5505 Qt::BrushStyle textBrush = Qt::SolidPattern;
5506 QgsSymbolLayerUtils::fillFromSld( fillElem, textBrush, textColor );
5507 if ( textColor.isValid() )
5508 {
5509 QgsDebugMsgLevel( QStringLiteral( "Info: textColor %1." ).arg( QVariant( textColor ).toString() ), 4 );
5510 format.setColor( textColor );
5511 }
5512
5513 QgsTextBufferSettings bufferSettings;
5514
5515 // Halo
5516 QDomElement haloElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Halo" ) );
5517 if ( !haloElem.isNull() )
5518 {
5519 bufferSettings.setEnabled( true );
5520 bufferSettings.setSize( 1 );
5521
5522 QDomElement radiusElem = haloElem.firstChildElement( QStringLiteral( "Radius" ) );
5523 if ( !radiusElem.isNull() )
5524 {
5525 bool ok;
5526 double bufferSize = radiusElem.text().toDouble( &ok );
5527 if ( ok )
5528 {
5529 bufferSettings.setSize( bufferSize );
5530 bufferSettings.setSizeUnit( sldUnitSize );
5531 }
5532 }
5533
5534 QDomElement haloFillElem = haloElem.firstChildElement( QStringLiteral( "Fill" ) );
5535 QColor bufferColor;
5536 Qt::BrushStyle bufferBrush = Qt::SolidPattern;
5537 QgsSymbolLayerUtils::fillFromSld( haloFillElem, bufferBrush, bufferColor );
5538 if ( bufferColor.isValid() )
5539 {
5540 QgsDebugMsgLevel( QStringLiteral( "Info: bufferColor %1." ).arg( QVariant( bufferColor ).toString() ), 4 );
5541 bufferSettings.setColor( bufferColor );
5542 }
5543 }
5544
5545 // LabelPlacement
5546 QDomElement labelPlacementElem = textSymbolizerElem.firstChildElement( QStringLiteral( "LabelPlacement" ) );
5547 if ( !labelPlacementElem.isNull() )
5548 {
5549 // PointPlacement
5550 QDomElement pointPlacementElem = labelPlacementElem.firstChildElement( QStringLiteral( "PointPlacement" ) );
5551 if ( !pointPlacementElem.isNull() )
5552 {
5555 {
5557 }
5558
5559 QDomElement displacementElem = pointPlacementElem.firstChildElement( QStringLiteral( "Displacement" ) );
5560 if ( !displacementElem.isNull() )
5561 {
5562 QDomElement displacementXElem = displacementElem.firstChildElement( QStringLiteral( "DisplacementX" ) );
5563 if ( !displacementXElem.isNull() )
5564 {
5565 bool ok;
5566 double xOffset = displacementXElem.text().toDouble( &ok );
5567 if ( ok )
5568 {
5569 settings.xOffset = xOffset;
5570 settings.offsetUnits = sldUnitSize;
5571 }
5572 }
5573 QDomElement displacementYElem = displacementElem.firstChildElement( QStringLiteral( "DisplacementY" ) );
5574 if ( !displacementYElem.isNull() )
5575 {
5576 bool ok;
5577 double yOffset = displacementYElem.text().toDouble( &ok );
5578 if ( ok )
5579 {
5580 settings.yOffset = yOffset;
5581 settings.offsetUnits = sldUnitSize;
5582 }
5583 }
5584 }
5585 QDomElement anchorPointElem = pointPlacementElem.firstChildElement( QStringLiteral( "AnchorPoint" ) );
5586 if ( !anchorPointElem.isNull() )
5587 {
5588 QDomElement anchorPointXElem = anchorPointElem.firstChildElement( QStringLiteral( "AnchorPointX" ) );
5589 if ( !anchorPointXElem.isNull() )
5590 {
5591 bool ok;
5592 double xOffset = anchorPointXElem.text().toDouble( &ok );
5593 if ( ok )
5594 {
5595 settings.xOffset = xOffset;
5596 settings.offsetUnits = sldUnitSize;
5597 }
5598 }
5599 QDomElement anchorPointYElem = anchorPointElem.firstChildElement( QStringLiteral( "AnchorPointY" ) );
5600 if ( !anchorPointYElem.isNull() )
5601 {
5602 bool ok;
5603 double yOffset = anchorPointYElem.text().toDouble( &ok );
5604 if ( ok )
5605 {
5606 settings.yOffset = yOffset;
5607 settings.offsetUnits = sldUnitSize;
5608 }
5609 }
5610 }
5611
5612 QDomElement rotationElem = pointPlacementElem.firstChildElement( QStringLiteral( "Rotation" ) );
5613 if ( !rotationElem.isNull() )
5614 {
5615 bool ok;
5616 double rotation = rotationElem.text().toDouble( &ok );
5617 if ( ok )
5618 {
5619 settings.angleOffset = 360 - rotation;
5620 }
5621 }
5622 }
5623 else
5624 {
5625 // PointPlacement
5626 QDomElement linePlacementElem = labelPlacementElem.firstChildElement( QStringLiteral( "LinePlacement" ) );
5627 if ( !linePlacementElem.isNull() )
5628 {
5630 }
5631 }
5632 }
5633
5634 // read vendor options
5635 QgsStringMap vendorOptions;
5636 QDomElement vendorOptionElem = textSymbolizerElem.firstChildElement( QStringLiteral( "VendorOption" ) );
5637 while ( !vendorOptionElem.isNull() && vendorOptionElem.localName() == QLatin1String( "VendorOption" ) )
5638 {
5639 QString optionName = vendorOptionElem.attribute( QStringLiteral( "name" ) );
5640 QString optionValue;
5641 if ( vendorOptionElem.firstChild().nodeType() == QDomNode::TextNode )
5642 {
5643 optionValue = vendorOptionElem.firstChild().nodeValue();
5644 }
5645 else
5646 {
5647 if ( vendorOptionElem.firstChild().nodeType() == QDomNode::ElementNode &&
5648 vendorOptionElem.firstChild().localName() == QLatin1String( "Literal" ) )
5649 {
5650 QgsDebugMsgLevel( vendorOptionElem.firstChild().localName(), 2 );
5651 optionValue = vendorOptionElem.firstChild().firstChild().nodeValue();
5652 }
5653 else
5654 {
5655 QgsDebugError( QStringLiteral( "unexpected child of %1 named %2" ).arg( vendorOptionElem.localName(), optionName ) );
5656 }
5657 }
5658
5659 if ( !optionName.isEmpty() && !optionValue.isEmpty() )
5660 {
5661 vendorOptions[ optionName ] = optionValue;
5662 }
5663
5664 vendorOptionElem = vendorOptionElem.nextSiblingElement();
5665 }
5666 if ( !vendorOptions.isEmpty() )
5667 {
5668 for ( QgsStringMap::iterator it = vendorOptions.begin(); it != vendorOptions.end(); ++it )
5669 {
5670 if ( it.key() == QLatin1String( "underlineText" ) && it.value() == QLatin1String( "true" ) )
5671 {
5672 font.setUnderline( true );
5673 format.setFont( font );
5674 }
5675 else if ( it.key() == QLatin1String( "strikethroughText" ) && it.value() == QLatin1String( "true" ) )
5676 {
5677 font.setStrikeOut( true );
5678 format.setFont( font );
5679 }
5680 else if ( it.key() == QLatin1String( "maxDisplacement" ) )
5681 {
5683 }
5684 else if ( it.key() == QLatin1String( "followLine" ) && it.value() == QLatin1String( "true" ) )
5685 {
5687 {
5689 }
5690 else
5691 {
5693 }
5694 }
5695 else if ( it.key() == QLatin1String( "maxAngleDelta" ) )
5696 {
5697 bool ok;
5698 double angle = it.value().toDouble( &ok );
5699 if ( ok )
5700 {
5701 settings.maxCurvedCharAngleIn = angle;
5702 settings.maxCurvedCharAngleOut = angle;
5703 }
5704 }
5705 // miscellaneous options
5706 else if ( it.key() == QLatin1String( "conflictResolution" ) && it.value() == QLatin1String( "false" ) )
5707 {
5709 }
5710 else if ( it.key() == QLatin1String( "forceLeftToRight" ) && it.value() == QLatin1String( "false" ) )
5711 {
5713 }
5714 else if ( it.key() == QLatin1String( "group" ) && it.value() == QLatin1String( "yes" ) )
5715 {
5716 settings.lineSettings().setMergeLines( true );
5717 }
5718 else if ( it.key() == QLatin1String( "labelAllGroup" ) && it.value() == QLatin1String( "true" ) )
5719 {
5720 settings.lineSettings().setMergeLines( true );
5721 }
5722 }
5723 }
5724
5725 format.setBuffer( bufferSettings );
5726 settings.setFormat( format );
5727 return true;
5728}
5729
5731{
5733
5734 return mEditFormConfig;
5735}
5736
5738{
5740
5741 if ( mEditFormConfig == editFormConfig )
5742 return;
5743
5744 mEditFormConfig = editFormConfig;
5745 mEditFormConfig.onRelationsLoaded();
5746 emit editFormConfigChanged();
5747}
5748
5750{
5752
5753 QgsAttributeTableConfig config = mAttributeTableConfig;
5754
5755 if ( config.isEmpty() )
5756 config.update( fields() );
5757
5758 return config;
5759}
5760
5762{
5764
5765 if ( mAttributeTableConfig != attributeTableConfig )
5766 {
5767 mAttributeTableConfig = attributeTableConfig;
5768 emit configChanged();
5769 }
5770}
5771
5773{
5774 // called in a non-thread-safe way in some cases when calculating aggregates in a different thread
5776
5778}
5779
5786
5788{
5790
5791 if ( !mDiagramLayerSettings )
5792 mDiagramLayerSettings = new QgsDiagramLayerSettings();
5793 *mDiagramLayerSettings = s;
5794}
5795
5797{
5799
5800 QgsLayerMetadataFormatter htmlFormatter( metadata() );
5801 QString myMetadata = QStringLiteral( "<html><head></head>\n<body>\n" );
5802
5803 myMetadata += generalHtmlMetadata();
5804
5805 // Begin Provider section
5806 myMetadata += QStringLiteral( "<h1>" ) + tr( "Information from provider" ) + QStringLiteral( "</h1>\n<hr>\n" );
5807 myMetadata += QLatin1String( "<table class=\"list-view\">\n" );
5808
5809 // storage type
5810 if ( !storageType().isEmpty() )
5811 {
5812 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Storage" ) + QStringLiteral( "</td><td>" ) + storageType() + QStringLiteral( "</td></tr>\n" );
5813 }
5814
5815 // comment
5816 if ( !dataComment().isEmpty() )
5817 {
5818 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Comment" ) + QStringLiteral( "</td><td>" ) + dataComment() + QStringLiteral( "</td></tr>\n" );
5819 }
5820
5821 // encoding
5822 if ( const QgsVectorDataProvider *provider = dataProvider() )
5823 {
5824 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Encoding" ) + QStringLiteral( "</td><td>" ) + provider->encoding() + QStringLiteral( "</td></tr>\n" );
5825 myMetadata += provider->htmlMetadata();
5826 }
5827
5828 if ( isSpatial() )
5829 {
5830 // geom type
5832 if ( static_cast<int>( type ) < 0 || static_cast< int >( type ) > static_cast< int >( Qgis::GeometryType::Null ) )
5833 {
5834 QgsDebugMsgLevel( QStringLiteral( "Invalid vector type" ), 2 );
5835 }
5836 else
5837 {
5838 QString typeString( QStringLiteral( "%1 (%2)" ).arg( QgsWkbTypes::geometryDisplayString( geometryType() ),
5840 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Geometry" ) + QStringLiteral( "</td><td>" ) + typeString + QStringLiteral( "</td></tr>\n" );
5841 }
5842
5843 // Extent
5844 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Extent" ) + QStringLiteral( "</td><td>" ) + extent().toString() + QStringLiteral( "</td></tr>\n" );
5845 }
5846
5847 // feature count
5848 QLocale locale = QLocale();
5849 locale.setNumberOptions( locale.numberOptions() &= ~QLocale::NumberOption::OmitGroupSeparator );
5850 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" )
5851 + tr( "Feature count" ) + QStringLiteral( "</td><td>" )
5852 + ( featureCount() == -1 ? tr( "unknown" ) : locale.toString( static_cast<qlonglong>( featureCount() ) ) )
5853 + QStringLiteral( "</td></tr>\n" );
5854
5855 // End Provider section
5856 myMetadata += QLatin1String( "</table>\n<br><br>" );
5857
5858 if ( isSpatial() )
5859 {
5860 // CRS
5861 myMetadata += crsHtmlMetadata();
5862 }
5863
5864 // identification section
5865 myMetadata += QStringLiteral( "<h1>" ) + tr( "Identification" ) + QStringLiteral( "</h1>\n<hr>\n" );
5866 myMetadata += htmlFormatter.identificationSectionHtml( );
5867 myMetadata += QLatin1String( "<br><br>\n" );
5868
5869 // extent section
5870 myMetadata += QStringLiteral( "<h1>" ) + tr( "Extent" ) + QStringLiteral( "</h1>\n<hr>\n" );
5871 myMetadata += htmlFormatter.extentSectionHtml( isSpatial() );
5872 myMetadata += QLatin1String( "<br><br>\n" );
5873
5874 // Start the Access section
5875 myMetadata += QStringLiteral( "<h1>" ) + tr( "Access" ) + QStringLiteral( "</h1>\n<hr>\n" );
5876 myMetadata += htmlFormatter.accessSectionHtml( );
5877 myMetadata += QLatin1String( "<br><br>\n" );
5878
5879 // Fields section
5880 myMetadata += QStringLiteral( "<h1>" ) + tr( "Fields" ) + QStringLiteral( "</h1>\n<hr>\n<table class=\"list-view\">\n" );
5881
5882 // primary key
5884 if ( !pkAttrList.isEmpty() )
5885 {
5886 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Primary key attributes" ) + QStringLiteral( "</td><td>" );
5887 const auto constPkAttrList = pkAttrList;
5888 for ( int idx : constPkAttrList )
5889 {
5890 myMetadata += fields().at( idx ).name() + ' ';
5891 }
5892 myMetadata += QLatin1String( "</td></tr>\n" );
5893 }
5894
5895 const QgsFields myFields = fields();
5896
5897 // count fields
5898 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Count" ) + QStringLiteral( "</td><td>" ) + QString::number( myFields.size() ) + QStringLiteral( "</td></tr>\n" );
5899
5900 myMetadata += QLatin1String( "</table>\n<br><table width=\"100%\" class=\"tabular-view\">\n" );
5901 myMetadata += QLatin1String( "<tr><th>" ) + tr( "Field" ) + QLatin1String( "</th><th>" ) + tr( "Type" ) + QLatin1String( "</th><th>" ) + tr( "Length" ) + QLatin1String( "</th><th>" ) + tr( "Precision" ) + QLatin1String( "</th><th>" ) + tr( "Comment" ) + QLatin1String( "</th></tr>\n" );
5902
5903 for ( int i = 0; i < myFields.size(); ++i )
5904 {
5905 QgsField myField = myFields.at( i );
5906 QString rowClass;
5907 if ( i % 2 )
5908 rowClass = QStringLiteral( "class=\"odd-row\"" );
5909 myMetadata += QLatin1String( "<tr " ) + rowClass + QLatin1String( "><td>" ) + myField.displayNameWithAlias() + QLatin1String( "</td><td>" ) + myField.typeName() + QLatin1String( "</td><td>" ) + QString::number( myField.length() ) + QLatin1String( "</td><td>" ) + QString::number( myField.precision() ) + QLatin1String( "</td><td>" ) + myField.comment() + QLatin1String( "</td></tr>\n" );
5910 }
5911
5912 //close field list
5913 myMetadata += QLatin1String( "</table>\n<br><br>" );
5914
5915 // Start the contacts section
5916 myMetadata += QStringLiteral( "<h1>" ) + tr( "Contacts" ) + QStringLiteral( "</h1>\n<hr>\n" );
5917 myMetadata += htmlFormatter.contactsSectionHtml( );
5918 myMetadata += QLatin1String( "<br><br>\n" );
5919
5920 // Start the links section
5921 myMetadata += QStringLiteral( "<h1>" ) + tr( "Links" ) + QStringLiteral( "</h1>\n<hr>\n" );
5922 myMetadata += htmlFormatter.linksSectionHtml( );
5923 myMetadata += QLatin1String( "<br><br>\n" );
5924
5925 // Start the history section
5926 myMetadata += QStringLiteral( "<h1>" ) + tr( "History" ) + QStringLiteral( "</h1>\n<hr>\n" );
5927 myMetadata += htmlFormatter.historySectionHtml( );
5928 myMetadata += QLatin1String( "<br><br>\n" );
5929
5930 myMetadata += customPropertyHtmlMetadata();
5931
5932 myMetadata += QLatin1String( "\n</body>\n</html>\n" );
5933 return myMetadata;
5934}
5935
5936void QgsVectorLayer::invalidateSymbolCountedFlag()
5937{
5939
5940 mSymbolFeatureCounted = false;
5941}
5942
5943void QgsVectorLayer::onFeatureCounterCompleted()
5944{
5946
5947 onSymbolsCounted();
5948 mFeatureCounter = nullptr;
5949}
5950
5951void QgsVectorLayer::onFeatureCounterTerminated()
5952{
5954
5955 mFeatureCounter = nullptr;
5956}
5957
5958void QgsVectorLayer::onJoinedFieldsChanged()
5959{
5961
5962 // some of the fields of joined layers have changed -> we need to update this layer's fields too
5963 updateFields();
5964}
5965
5966void QgsVectorLayer::onFeatureDeleted( QgsFeatureId fid )
5967{
5969
5970 if ( mEditCommandActive || mCommitChangesActive )
5971 {
5972 mDeletedFids << fid;
5973 }
5974 else
5975 {
5976 mSelectedFeatureIds.remove( fid );
5977 emit featuresDeleted( QgsFeatureIds() << fid );
5978 }
5979
5980 emit featureDeleted( fid );
5981}
5982
5983void QgsVectorLayer::onRelationsLoaded()
5984{
5986
5987 mEditFormConfig.onRelationsLoaded();
5988}
5989
5990void QgsVectorLayer::onSymbolsCounted()
5991{
5993
5994 if ( mFeatureCounter )
5995 {
5996 mSymbolFeatureCounted = true;
5997 mSymbolFeatureCountMap = mFeatureCounter->symbolFeatureCountMap();
5998 mSymbolFeatureIdMap = mFeatureCounter->symbolFeatureIdMap();
6000 }
6001}
6002
6003QList<QgsRelation> QgsVectorLayer::referencingRelations( int idx ) const
6004{
6006
6007 if ( QgsProject *p = project() )
6008 return p->relationManager()->referencingRelations( this, idx );
6009 else
6010 return {};
6011}
6012
6013QList<QgsWeakRelation> QgsVectorLayer::weakRelations() const
6014{
6016
6017 return mWeakRelations;
6018}
6019
6020void QgsVectorLayer::setWeakRelations( const QList<QgsWeakRelation> &relations )
6021{
6023
6024 mWeakRelations = relations;
6025}
6026
6027bool QgsVectorLayer::loadAuxiliaryLayer( const QgsAuxiliaryStorage &storage, const QString &key )
6028{
6030
6031 bool rc = false;
6032
6033 QString joinKey = mAuxiliaryLayerKey;
6034 if ( !key.isEmpty() )
6035 joinKey = key;
6036
6037 if ( storage.isValid() && !joinKey.isEmpty() )
6038 {
6039 QgsAuxiliaryLayer *alayer = nullptr;
6040
6041 int idx = fields().lookupField( joinKey );
6042
6043 if ( idx >= 0 )
6044 {
6045 alayer = storage.createAuxiliaryLayer( fields().field( idx ), this );
6046
6047 if ( alayer )
6048 {
6049 setAuxiliaryLayer( alayer );
6050 rc = true;
6051 }
6052 }
6053 }
6054
6055 return rc;
6056}
6057
6059{
6061
6062 mAuxiliaryLayerKey.clear();
6063
6064 if ( mAuxiliaryLayer )
6065 removeJoin( mAuxiliaryLayer->id() );
6066
6067 if ( alayer )
6068 {
6069 addJoin( alayer->joinInfo() );
6070
6071 if ( !alayer->isEditable() )
6072 alayer->startEditing();
6073
6074 mAuxiliaryLayerKey = alayer->joinInfo().targetFieldName();
6075 }
6076
6077 mAuxiliaryLayer.reset( alayer );
6078 if ( mAuxiliaryLayer )
6079 mAuxiliaryLayer->setParent( this );
6080 updateFields();
6081}
6082
6084{
6086
6087 return mAuxiliaryLayer.get();
6088}
6089
6091{
6093
6094 return mAuxiliaryLayer.get();
6095}
6096
6097QSet<QgsMapLayerDependency> QgsVectorLayer::dependencies() const
6098{
6100
6101 if ( mDataProvider )
6102 return mDataProvider->dependencies() + mDependencies;
6103 return mDependencies;
6104}
6105
6106void QgsVectorLayer::emitDataChanged()
6107{
6109
6110 if ( mDataChangedFired )
6111 return;
6112
6113 updateExtents(); // reset cached extent to reflect data changes
6114
6115 mDataChangedFired = true;
6116 emit dataChanged();
6117 mDataChangedFired = false;
6118}
6119
6120void QgsVectorLayer::onAfterCommitChangesDependency()
6121{
6123
6124 mDataChangedFired = true;
6125 reload();
6126 mDataChangedFired = false;
6127}
6128
6129bool QgsVectorLayer::setDependencies( const QSet<QgsMapLayerDependency> &oDeps )
6130{
6132
6133 QSet<QgsMapLayerDependency> deps;
6134 const auto constODeps = oDeps;
6135 for ( const QgsMapLayerDependency &dep : constODeps )
6136 {
6137 if ( dep.origin() == QgsMapLayerDependency::FromUser )
6138 deps << dep;
6139 }
6140
6141 QSet<QgsMapLayerDependency> toAdd = deps - dependencies();
6142
6143 // disconnect layers that are not present in the list of dependencies anymore
6144 if ( QgsProject *p = project() )
6145 {
6146 for ( const QgsMapLayerDependency &dep : std::as_const( mDependencies ) )
6147 {
6148 QgsVectorLayer *lyr = static_cast<QgsVectorLayer *>( p->mapLayer( dep.layerId() ) );
6149 if ( !lyr )
6150 continue;
6151 disconnect( lyr, &QgsVectorLayer::featureAdded, this, &QgsVectorLayer::emitDataChanged );
6152 disconnect( lyr, &QgsVectorLayer::featureDeleted, this, &QgsVectorLayer::emitDataChanged );
6153 disconnect( lyr, &QgsVectorLayer::geometryChanged, this, &QgsVectorLayer::emitDataChanged );
6154 disconnect( lyr, &QgsVectorLayer::dataChanged, this, &QgsVectorLayer::emitDataChanged );
6156 disconnect( lyr, &QgsVectorLayer::afterCommitChanges, this, &QgsVectorLayer::onAfterCommitChangesDependency );
6157 }
6158 }
6159
6160 // assign new dependencies
6161 if ( mDataProvider )
6162 mDependencies = mDataProvider->dependencies() + deps;
6163 else
6164 mDependencies = deps;
6165 emit dependenciesChanged();
6166
6167 // connect to new layers
6168 if ( QgsProject *p = project() )
6169 {
6170 for ( const QgsMapLayerDependency &dep : std::as_const( mDependencies ) )
6171 {
6172 QgsVectorLayer *lyr = static_cast<QgsVectorLayer *>( p->mapLayer( dep.layerId() ) );
6173 if ( !lyr )
6174 continue;
6175 connect( lyr, &QgsVectorLayer::featureAdded, this, &QgsVectorLayer::emitDataChanged );
6176 connect( lyr, &QgsVectorLayer::featureDeleted, this, &QgsVectorLayer::emitDataChanged );
6177 connect( lyr, &QgsVectorLayer::geometryChanged, this, &QgsVectorLayer::emitDataChanged );
6178 connect( lyr, &QgsVectorLayer::dataChanged, this, &QgsVectorLayer::emitDataChanged );
6180 connect( lyr, &QgsVectorLayer::afterCommitChanges, this, &QgsVectorLayer::onAfterCommitChangesDependency );
6181 }
6182 }
6183
6184 // if new layers are present, emit a data change
6185 if ( ! toAdd.isEmpty() )
6186 emitDataChanged();
6187
6188 return true;
6189}
6190
6192{
6194
6195 if ( fieldIndex < 0 || fieldIndex >= mFields.count() || !mDataProvider )
6197
6198 QgsFieldConstraints::Constraints constraints = mFields.at( fieldIndex ).constraints().constraints();
6199
6200 // make sure provider constraints are always present!
6201 if ( mFields.fieldOrigin( fieldIndex ) == Qgis::FieldOrigin::Provider )
6202 {
6203 constraints |= mDataProvider->fieldConstraints( mFields.fieldOriginIndex( fieldIndex ) );
6204 }
6205
6206 return constraints;
6207}
6208
6209QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength> QgsVectorLayer::fieldConstraintsAndStrength( int fieldIndex ) const
6210{
6212
6213 QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength > m;
6214
6215 if ( fieldIndex < 0 || fieldIndex >= mFields.count() )
6216 return m;
6217
6218 QString name = mFields.at( fieldIndex ).name();
6219
6220 QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength >::const_iterator conIt = mFieldConstraintStrength.constBegin();
6221 for ( ; conIt != mFieldConstraintStrength.constEnd(); ++conIt )
6222 {
6223 if ( conIt.key().first == name )
6224 {
6225 m[ conIt.key().second ] = mFieldConstraintStrength.value( conIt.key() );
6226 }
6227 }
6228
6229 return m;
6230}
6231
6233{
6235
6236 if ( index < 0 || index >= mFields.count() )
6237 return;
6238
6239 QString name = mFields.at( index ).name();
6240
6241 // add constraint to existing constraints
6242 QgsFieldConstraints::Constraints constraints = mFieldConstraints.value( name, QgsFieldConstraints::Constraints() );
6243 constraints |= constraint;
6244 mFieldConstraints.insert( name, constraints );
6245
6246 mFieldConstraintStrength.insert( qMakePair( name, constraint ), strength );
6247
6248 updateFields();
6249}
6250
6252{
6254
6255 if ( index < 0 || index >= mFields.count() )
6256 return;
6257
6258 QString name = mFields.at( index ).name();
6259
6260 // remove constraint from existing constraints
6261 QgsFieldConstraints::Constraints constraints = mFieldConstraints.value( name, QgsFieldConstraints::Constraints() );
6262 constraints &= ~constraint;
6263 mFieldConstraints.insert( name, constraints );
6264
6265 mFieldConstraintStrength.remove( qMakePair( name, constraint ) );
6266
6267 updateFields();
6268}
6269
6271{
6273
6274 if ( index < 0 || index >= mFields.count() )
6275 return QString();
6276
6277 return mFields.at( index ).constraints().constraintExpression();
6278}
6279
6281{
6283
6284 if ( index < 0 || index >= mFields.count() )
6285 return QString();
6286
6287 return mFields.at( index ).constraints().constraintDescription();
6288}
6289
6290void QgsVectorLayer::setConstraintExpression( int index, const QString &expression, const QString &description )
6291{
6293
6294 if ( index < 0 || index >= mFields.count() )
6295 return;
6296
6297 if ( expression.isEmpty() )
6298 {
6299 mFieldConstraintExpressions.remove( mFields.at( index ).name() );
6300 }
6301 else
6302 {
6303 mFieldConstraintExpressions.insert( mFields.at( index ).name(), qMakePair( expression, description ) );
6304 }
6305 updateFields();
6306}
6307
6309{
6311
6312 if ( index < 0 || index >= mFields.count() )
6313 return;
6314
6315 mFieldConfigurationFlags.insert( mFields.at( index ).name(), flags );
6316 updateFields();
6317}
6318
6320{
6322
6323 if ( index < 0 || index >= mFields.count() )
6324 return;
6326 flags.setFlag( flag, active );
6328}
6329
6331{
6333
6334 if ( index < 0 || index >= mFields.count() )
6336
6337 return mFields.at( index ).configurationFlags();
6338}
6339
6341{
6343
6344 if ( index < 0 || index >= mFields.count() )
6345 return;
6346
6347 if ( setup.isNull() )
6348 mFieldWidgetSetups.remove( mFields.at( index ).name() );
6349 else
6350 mFieldWidgetSetups.insert( mFields.at( index ).name(), setup );
6351 updateFields();
6352}
6353
6355{
6357
6358 if ( index < 0 || index >= mFields.count() )
6359 return QgsEditorWidgetSetup();
6360
6361 return mFields.at( index ).editorWidgetSetup();
6362}
6363
6364QgsAbstractVectorLayerLabeling *QgsVectorLayer::readLabelingFromCustomProperties()
6365{
6367
6369 if ( customProperty( QStringLiteral( "labeling" ) ).toString() == QLatin1String( "pal" ) )
6370 {
6371 if ( customProperty( QStringLiteral( "labeling/enabled" ), QVariant( false ) ).toBool() )
6372 {
6373 // try to load from custom properties
6374 QgsPalLayerSettings settings;
6375 settings.readFromLayerCustomProperties( this );
6376 labeling = new QgsVectorLayerSimpleLabeling( settings );
6377 }
6378
6379 // also clear old-style labeling config
6380 removeCustomProperty( QStringLiteral( "labeling" ) );
6381 const auto constCustomPropertyKeys = customPropertyKeys();
6382 for ( const QString &key : constCustomPropertyKeys )
6383 {
6384 if ( key.startsWith( QLatin1String( "labeling/" ) ) )
6385 removeCustomProperty( key );
6386 }
6387 }
6388
6389 return labeling;
6390}
6391
6393{
6395
6396 return mAllowCommit;
6397}
6398
6399void QgsVectorLayer::setAllowCommit( bool allowCommit )
6400{
6402
6403 if ( mAllowCommit == allowCommit )
6404 return;
6405
6406 mAllowCommit = allowCommit;
6407 emit allowCommitChanged();
6408}
6409
6411{
6413
6414 return mGeometryOptions.get();
6415}
6416
6417void QgsVectorLayer::setReadExtentFromXml( bool readExtentFromXml )
6418{
6420
6421 mReadExtentFromXml = readExtentFromXml;
6422}
6423
6425{
6427
6428 return mReadExtentFromXml;
6429}
6430
6431void QgsVectorLayer::onDirtyTransaction( const QString &sql, const QString &name )
6432{
6434
6436 if ( tr && mEditBuffer )
6437 {
6438 qobject_cast<QgsVectorLayerEditPassthrough *>( mEditBuffer )->update( tr, sql, name );
6439 }
6440}
6441
6442QList<QgsVectorLayer *> QgsVectorLayer::DeleteContext::handledLayers( bool includeAuxiliaryLayers ) const
6443{
6444 QList<QgsVectorLayer *> layers;
6445 QMap<QgsVectorLayer *, QgsFeatureIds>::const_iterator i;
6446 for ( i = mHandledFeatures.begin(); i != mHandledFeatures.end(); ++i )
6447 {
6448 if ( includeAuxiliaryLayers || !qobject_cast< QgsAuxiliaryLayer * >( i.key() ) )
6449 layers.append( i.key() );
6450 }
6451 return layers;
6452}
6453
6455{
6456 return mHandledFeatures[layer];
6457}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ SelectAtId
Fast access to features using their ID.
@ CreateRenderer
Provider can create feature renderers using backend-specific formatting information....
@ CreateLabeling
Provider can set labeling settings using backend-specific formatting information. Since QGIS 3....
@ ReadLayerMetadata
Provider can read layer metadata from data store. Since QGIS 3.0. See QgsDataProvider::layerMetadata(...
@ DeleteFeatures
Allows deletion of features.
QFlags< VectorRenderingSimplificationFlag > VectorRenderingSimplificationFlags
Simplification flags for vector feature rendering.
Definition qgis.h:2813
@ Composition
Fix relation, related elements are part of the parent and a parent copy will copy any children or del...
@ Association
Loose relation, related elements are not part of the parent and a parent copy will not copy any child...
GeometryOperationResult
Success or failure of a geometry operation.
Definition qgis.h:1889
@ InvalidInputGeometryType
The input geometry (ring, part, split line, etc.) has not the correct geometry type.
@ Success
Operation succeeded.
@ SelectionIsEmpty
No features were selected.
@ AddRingNotInExistingFeature
The input ring doesn't have any existing ring to fit into.
@ AddRingNotClosed
The input ring is not closed.
@ SelectionIsGreaterThanOne
More than one features were selected.
@ LayerNotEditable
Cannot edit layer.
SpatialIndexPresence
Enumeration of spatial index presence states.
Definition qgis.h:522
@ Unknown
Spatial index presence cannot be determined, index may or may not exist.
VectorRenderingSimplificationFlag
Simplification flags for vector feature rendering.
Definition qgis.h:2798
@ NoSimplification
No simplification can be applied.
@ OverPoint
Arranges candidates over a point (or centroid of a polygon), or at a preset offset from the point....
@ Curved
Arranges candidates following the curvature of a line feature. Applies to line layers only.
@ AroundPoint
Arranges candidates in a circle around a point (or centroid of a polygon). Applies to point or polygo...
@ Line
Arranges candidates parallel to a generalised line representing the feature or parallel to a polygon'...
@ Horizontal
Arranges horizontal candidates scattered throughout a polygon feature. Applies to polygon layers only...
@ PerimeterCurved
Arranges candidates following the curvature of a polygon's boundary. Applies to polygon layers only.
QFlags< VectorLayerTypeFlag > VectorLayerTypeFlags
Vector layer type flags.
Definition qgis.h:395
VectorSimplificationAlgorithm
Simplification algorithms for vector features.
Definition qgis.h:2782
@ Distance
The simplification uses the distance between points to remove duplicate points.
@ ExactIntersect
Use exact geometry intersection (slower) instead of bounding boxes.
@ SubsetOfAttributes
Fetch only a subset of attributes (setSubsetOfAttributes sets this flag)
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
@ FastExtent3D
Provider's 3D extent retrieval via QgsDataProvider::extent3D() is always guaranteed to be trivial/fas...
@ FastExtent2D
Provider's 2D extent retrieval via QgsDataProvider::extent() is always guaranteed to be trivial/fast ...
@ BufferedGroups
Buffered transactional editing means that all editable layers in the buffered transaction group are t...
FieldDomainSplitPolicy
Split policy for field domains.
Definition qgis.h:3620
@ Duplicate
Duplicate original value.
BlendMode
Blending modes defining the available composition modes that can be used when painting.
Definition qgis.h:4586
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition qgis.h:337
@ Polygon
Polygons.
@ Unknown
Unknown types.
@ Null
No geometry.
@ Generated
A generated relation is a child of a polymorphic relation.
@ Normal
A normal relation.
FieldDuplicatePolicy
Duplicate policy for fields.
Definition qgis.h:3652
@ Duplicate
Duplicate original value.
static const float DEFAULT_MAPTOPIXEL_THRESHOLD
Default threshold between map coordinates and device coordinates for map2pixel simplification.
Definition qgis.h:5582
QFlags< DataProviderReadFlag > DataProviderReadFlags
Flags which control data provider construction.
Definition qgis.h:450
FeatureAvailability
Possible return value for QgsFeatureSource::hasFeatures() to determine if a source is empty.
Definition qgis.h:541
@ FeaturesMaybeAvailable
There may be features available in this source.
@ FeaturesAvailable
There is at least one feature available in this source.
@ NoFeaturesAvailable
There are certainly no features available in this source.
@ Vector
Vector layer.
FieldOrigin
Field origin.
Definition qgis.h:1551
@ Provider
Field originates from the underlying data provider of the vector layer.
@ Edit
Field has been temporarily added in editing mode.
@ Unknown
The field origin has not been specified.
@ Expression
Field is calculated from an expression.
@ Join
Field originates from a joined layer.
RenderUnit
Rendering size units.
Definition qgis.h:4839
@ Points
Points (e.g., for font sizes)
@ LoadDefaultStyle
Reset the layer's style to the default for the datasource.
@ ForceReadOnly
Open layer in a read-only mode.
Aggregate
Available aggregates to calculate.
Definition qgis.h:5400
VertexMarkerType
Editing vertex markers, used for showing vertices during a edit operation.
Definition qgis.h:1680
@ SemiTransparentCircle
Semi-transparent circle marker.
@ Cross
Cross marker.
VectorEditResult
Specifies the result of a vector layer edit operation.
Definition qgis.h:1665
@ Success
Edit operation was successful.
@ InvalidLayer
Edit failed due to invalid layer.
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:256
@ Unknown
Unknown.
FieldConfigurationFlag
Configuration flags for fields These flags are meant to be user-configurable and are not describing a...
Definition qgis.h:1568
@ HideFromWfs
Field is not available if layer is served as WFS from QGIS server.
@ NoFlag
No flag is defined.
@ HideFromWms
Field is not available if layer is served as WMS from QGIS server.
@ AllowOverlapIfRequired
Avoids overlapping labels when possible, but permit overlaps if labels for features cannot otherwise ...
QFlags< FieldConfigurationFlag > FieldConfigurationFlags
Configuration flags for fields These flags are meant to be user-configurable and are not describing a...
Definition qgis.h:1583
@ AlwaysAllowUpsideDown
Show upside down for all labels, including dynamic ones.
SelectBehavior
Specifies how a selection should be applied.
Definition qgis.h:1618
@ 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.
Abstract base class for objects which generate elevation profiles.
virtual bool writeXml(QDomElement &collectionElem, const QgsPropertiesDefinition &definitions) const
Writes the current state of the property collection into an XML element.
Abstract base class - its implementations define different approaches to the labeling of a vector lay...
virtual bool accept(QgsStyleEntityVisitorInterface *visitor) const
Accepts the specified symbology visitor, causing it to visit all symbols associated with the labeling...
virtual void toSld(QDomNode &parent, const QVariantMap &props) const
Writes the SE 1.1 TextSymbolizer element based on the current layer labeling settings.
static QgsAbstractVectorLayerLabeling * create(const QDomElement &element, const QgsReadWriteContext &context)
Try to create instance of an implementation based on the XML data.
virtual QDomElement save(QDomDocument &doc, const QgsReadWriteContext &context) const =0
Returns labeling configuration as XML element.
Storage and management of actions associated with a layer.
bool writeXml(QDomNode &layer_node) const
Writes the actions out in XML format.
QList< QgsAction > actions(const QString &actionScope=QString()) const
Returns a list of actions that are available in the given action scope.
QUuid addAction(Qgis::AttributeActionType type, const QString &name, const QString &command, bool capture=false)
Add an action with the given name and action details.
bool readXml(const QDomNode &layer_node)
Reads the actions in in XML format.
Utility class that encapsulates an action based on vector attributes.
Definition qgsaction.h:37
Utility class for calculating aggregates for a field (or expression) over the features from a vector ...
static QgsRuntimeProfiler * profiler()
Returns the application runtime profiler.
static QgsTaskManager * taskManager()
Returns the application's task manager, used for managing application wide background task handling.
This is a container for configuration of the attribute table.
void readXml(const QDomNode &node)
Deserialize to XML on layer load.
void update(const QgsFields &fields)
Update the configuration with the given fields.
void writeXml(QDomNode &node) const
Serialize to XML on layer save.
A vector of attributes.
Class allowing to manage the auxiliary storage for a vector layer.
QgsVectorLayerJoinInfo joinInfo() const
Returns information to use for joining with primary key and so on.
Class providing some utility methods to manage auxiliary storage.
QgsAuxiliaryLayer * createAuxiliaryLayer(const QgsField &field, QgsVectorLayer *layer) const
Creates an auxiliary layer for a vector layer.
bool isValid() const
Returns the status of the auxiliary storage currently defined.
A 3-dimensional box composed of x, y, z coordinates.
Definition qgsbox3d.h:43
bool isNull() const
Test if the box is null (holding no spatial information).
Definition qgsbox3d.cpp:310
The QgsConditionalLayerStyles class holds conditional style information for a layer.
bool readXml(const QDomNode &node, const QgsReadWriteContext &context)
Reads the condition styles state from a DOM node.
bool writeXml(QDomNode &node, QDomDocument &doc, const QgsReadWriteContext &context) const
Writes the condition styles state to a DOM node.
This class represents a coordinate reference system (CRS).
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
Contains information about the context in which a coordinate transform is executed.
Abstract base class for curved geometry type.
Definition qgscurve.h:35
virtual bool isClosed() const
Returns true if the curve is closed.
Definition qgscurve.cpp:53
QgsCurve * clone() const override=0
Clones the geometry by performing a deep copy.
virtual bool containsElevationData() const
Returns true if the data provider definitely contains elevation related data.
virtual bool leaveUpdateMode()
Leave update mode.
virtual QString subsetString() const
Returns the subset definition string currently in use by the layer and used by the provider to limit ...
QgsCoordinateTransformContext transformContext() const
Returns data provider coordinate transform context.
virtual Qgis::DataProviderFlags flags() const
Returns the generic data provider flags.
virtual QgsCoordinateReferenceSystem crs() const =0
Returns the coordinate system for the data source.
void dataChanged()
Emitted whenever a change is made to the data provider which may have caused changes in the provider'...
void fullExtentCalculated()
Emitted whenever a deferred extent calculation is completed by the provider.
virtual Qgis::ProviderStyleStorageCapabilities styleStorageCapabilities() const
Returns the style storage capabilities.
virtual QgsBox3D extent3D() const
Returns the 3D extent of the layer.
virtual QgsLayerMetadata layerMetadata() const
Returns layer metadata collected from the provider's source.
virtual bool isValid() const =0
Returns true if this is a valid layer.
virtual bool setSubsetString(const QString &subset, bool updateFeatureCount=true)
Set the subset string used to create a subset of features in the layer.
virtual QString dataSourceUri(bool expandAuthConfig=false) const
Gets the data source specification.
virtual void updateExtents()
Update the extents of the layer.
virtual void reloadData()
Reloads the data from the source for providers with data caches to synchronize, changes in the data s...
virtual bool enterUpdateMode()
Enter update mode.
virtual QgsRectangle extent() const =0
Returns the extent of the layer.
virtual void setTransformContext(const QgsCoordinateTransformContext &transformContext)
Sets data coordinate transform context to transformContext.
Class for storing the component parts of a RDBMS data source URI (e.g.
bool useEstimatedMetadata() const
Returns true if estimated metadata should be used for the connection.
The QgsDefaultValue class provides a container for managing client side default values for fields.
bool isValid() const
Returns if this default value should be applied.
Stores the settings for rendering of all diagrams for a layer.
@ PositionX
X-coordinate data defined diagram position.
@ PositionY
Y-coordinate data defined diagram position.
@ Show
Whether to show the diagram.
void readXml(const QDomElement &elem)
Reads the diagram settings from a DOM element.
void writeXml(QDomElement &layerElem, QDomDocument &doc) const
Writes the diagram settings to a DOM element.
Evaluates and returns the diagram settings relating to a diagram for a specific feature.
virtual void writeXml(QDomElement &layerElem, QDomDocument &doc, const QgsReadWriteContext &context) const =0
Writes diagram state to a DOM element.
virtual QList< QgsDiagramSettings > diagramSettings() const =0
Returns list with all diagram settings in the renderer.
virtual void readXml(const QDomElement &elem, const QgsReadWriteContext &context)=0
Reads diagram state from a DOM element.
Contains configuration settings for an editor form.
void readXml(const QDomNode &node, QgsReadWriteContext &context)
Read XML information Deserialize on project load.
void writeXml(QDomNode &node, const QgsReadWriteContext &context) const
Write XML information Serialize on project save.
Holder for the widget type and its configuration for a field.
QVariantMap config() const
void clear()
Clear error messages.
Definition qgserror.h:126
Single scope for storing variables and functions for use within a QgsExpressionContext.
void setFields(const QgsFields &fields)
Convenience function for setting a fields for the scope.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the scope.
static QList< QgsExpressionContextScope * > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer's project and layer.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QgsExpressionContextScope * popScope()
Removes the last scope from the expression context and return it.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
void setFeature(const QgsFeature &feature)
Convenience function for setting a feature for the context.
Buffers information about expression fields for a vector layer.
void removeExpression(int index)
Remove an expression from the buffer.
void writeXml(QDomNode &layer_node, QDomDocument &document) const
Saves expressions to xml under the layer node.
void readXml(const QDomNode &layer_node)
Reads expressions from project file.
void updateFields(QgsFields &flds) const
Adds fields with the expressions buffered in this object to a QgsFields object.
void addExpression(const QString &exp, const QgsField &fld)
Add an expression to the buffer.
QList< QgsExpressionFieldBuffer::ExpressionField > expressions() const
void updateExpression(int index, const QString &exp)
Changes the expression at a given index.
void renameExpression(int index, const QString &name)
Renames an expression field at a given index.
An expression node which takes it value from a feature's field.
Class for parsing and evaluation of expressions (formerly called "search strings").
bool prepare(const QgsExpressionContext *context)
Gets the expression ready for evaluation - find out column indexes.
QString expression() const
Returns the original, unmodified expression string.
bool hasParserError() const
Returns true if an error occurred when parsing the input expression.
QString evalErrorString() const
Returns evaluation error.
QString parserErrorString() const
Returns parser error.
QSet< QString > referencedColumns() const
Gets list of columns referenced by the expression.
static QString quotedColumnRef(QString name)
Returns a quoted column reference (in double quotes)
bool hasEvalError() const
Returns true if an error occurred when evaluating last input.
static int expressionToLayerFieldIndex(const QString &expression, const QgsVectorLayer *layer)
Attempts to resolve an expression to a field index from the given layer.
bool needsGeometry() const
Returns true if the expression uses feature geometry for some computation.
QVariant evaluate()
Evaluate the feature and return the result.
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
bool close()
Call to end the iteration.
An interface for objects which generate feature renderers for vector layers.
Abstract base class for all 2D vector feature renderers.
static QgsFeatureRenderer * defaultRenderer(Qgis::GeometryType geomType)
Returns a new renderer - used by default in vector layers.
virtual void toSld(QDomDocument &doc, QDomElement &element, const QVariantMap &props=QVariantMap()) const
used from subclasses to create SLD Rule elements following SLD v1.1 specs
virtual QDomElement save(QDomDocument &doc, const QgsReadWriteContext &context)
Stores renderer properties to an XML element.
double referenceScale() const
Returns the symbology reference scale.
void setReferenceScale(double scale)
Sets the symbology reference scale.
static QgsFeatureRenderer * load(QDomElement &symbologyElem, const QgsReadWriteContext &context)
create a renderer from XML element
virtual bool accept(QgsStyleEntityVisitorInterface *visitor) const
Accepts the specified symbology visitor, causing it to visit all symbols associated with the renderer...
static QgsFeatureRenderer * loadSld(const QDomNode &node, Qgis::GeometryType geomType, QString &errorMessage)
Create a new renderer according to the information contained in the UserStyle element of a SLD style ...
This class wraps a request for features to a vector layer (or directly its vector data provider).
QgsFeatureRequest & setFlags(Qgis::FeatureRequestFlags flags)
Sets flags that affect how features will be fetched.
QgsFeatureRequest & setFilterFids(const QgsFeatureIds &fids)
Sets the feature IDs that should be fetched.
QgsFeatureRequest & setSubsetOfAttributes(const QgsAttributeList &attrs)
Set a subset of attributes that will be fetched.
QgsFeatureRequest & setFilterExpression(const QString &expression)
Set the filter expression.
QgsFeatureRequest & setExpressionContext(const QgsExpressionContext &context)
Sets the expression context used to evaluate filter expressions.
QgsFeatureRequest & setNoAttributes()
Set that no attributes will be fetched.
QgsFeatureRequest & setFilterFid(QgsFeatureId fid)
Sets the feature ID that should be fetched.
virtual bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags())
Adds a single feature to the sink.
QFlags< Flag > Flags
virtual QSet< QVariant > uniqueValues(int fieldIndex, int limit=-1) const
Returns the set of unique values contained within the specified fieldIndex from this source.
virtual Qgis::SpatialIndexPresence hasSpatialIndex() const
Returns an enum value representing the presence of a valid spatial index on the source,...
virtual QgsFeatureIds allFeatureIds() const
Returns a list of all feature IDs for features present in the source.
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Definition qgsfeature.h:58
Q_INVOKABLE bool setAttribute(int field, const QVariant &attr)
Sets an attribute's value by field index.
QgsAttributes attributes
Definition qgsfeature.h:67
QgsFields fields
Definition qgsfeature.h:68
QgsFeatureId id
Definition qgsfeature.h:66
QgsGeometry geometry
Definition qgsfeature.h:69
bool hasGeometry() const
Returns true if the feature has an associated geometry.
bool isValid() const
Returns the validity of this feature.
Q_INVOKABLE QVariant attribute(const QString &name) const
Lookup attribute value by attribute name.
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
Stores information about constraints which may be present on a field.
ConstraintStrength
Strength of constraints.
void setConstraintStrength(Constraint constraint, ConstraintStrength strength)
Sets the strength of a constraint.
void setConstraintExpression(const QString &expression, const QString &description=QString())
Set the constraint expression for the field.
@ ConstraintOriginProvider
Constraint was set at data provider.
@ ConstraintOriginLayer
Constraint was set by layer.
ConstraintOrigin constraintOrigin(Constraint constraint) const
Returns the origin of a field constraint, or ConstraintOriginNotSet if the constraint is not present ...
QString constraintExpression() const
Returns the constraint expression for the field, if set.
Constraint
Constraints which may be present on a field.
@ ConstraintNotNull
Field may not be null.
@ ConstraintUnique
Field must have a unique value.
@ ConstraintExpression
Field has an expression constraint set. See constraintExpression().
QString constraintDescription() const
Returns the descriptive name for the constraint expression.
void setConstraint(Constraint constraint, ConstraintOrigin origin=ConstraintOriginLayer)
Sets a constraint on the field.
QFlags< Constraint > Constraints
Encapsulate a field in an attribute table or data source.
Definition qgsfield.h:53
QString typeName() const
Gets the field type.
Definition qgsfield.cpp:161
QString name
Definition qgsfield.h:62
int precision
Definition qgsfield.h:59
int length
Definition qgsfield.h:58
QString displayNameWithAlias() const
Returns the name to use when displaying this field and adds the alias in parenthesis if it is defined...
Definition qgsfield.cpp:103
QString displayName() const
Returns the name to use when displaying this field.
Definition qgsfield.cpp:95
Qgis::FieldConfigurationFlags configurationFlags
Definition qgsfield.h:66
QString alias
Definition qgsfield.h:63
QgsDefaultValue defaultValueDefinition
Definition qgsfield.h:64
QString comment
Definition qgsfield.h:61
QgsFieldConstraints constraints
Definition qgsfield.h:65
QgsEditorWidgetSetup editorWidgetSetup() const
Gets the editor widget setup for the field.
Definition qgsfield.cpp:740
Container of fields for a vector layer.
Definition qgsfields.h:46
int count
Definition qgsfields.h:50
bool isEmpty
Definition qgsfields.h:49
Q_INVOKABLE int indexFromName(const QString &fieldName) const
Gets the field index from the field name.
Q_INVOKABLE int indexOf(const QString &fieldName) const
Gets the field index from the field name.
Qgis::FieldOrigin fieldOrigin(int fieldIdx) const
Returns the field's origin (value from an enumeration).
int size() const
Returns number of items.
QgsField at(int i) const
Returns the field at particular index (must be in range 0..N-1).
int fieldOriginIndex(int fieldIdx) const
Returns the field's origin index (its meaning is specific to each type of origin).
Q_INVOKABLE int lookupField(const QString &fieldName) const
Looks up field's index from the field name.
QStringList names
Definition qgsfields.h:51
The QgsGeometryOptions class contains options to automatically adjust geometries to constraints on a ...
A geometry is the spatial representation of a feature.
QgsBox3D boundingBox3D() const
Returns the 3D bounding box of the geometry.
bool equals(const QgsGeometry &geometry) const
Test if this geometry is exactly equal to another geometry.
Qgis::GeometryType type
QgsRectangle boundingBox() const
Returns the bounding box of the geometry.
void setMergeLines(bool merge)
Sets whether connected line features with identical label text should be merged prior to generating l...
void setOverlapHandling(Qgis::LabelOverlapHandling handling)
Sets the technique used to handle overlapping labels.
Class for metadata formatter.
A structured metadata store for a map layer.
void combine(const QgsAbstractMetadataBase *other) override
Combines the metadata from this object with the metadata from an other object.
Line string geometry type, with support for z-dimension and m-values.
Alters the size of rendered diagrams using a linear scaling.
static void warning(const QString &msg)
Goes to qWarning.
This class models dependencies with or between map layers.
Base class for storage of map layer elevation properties.
static QString typeToString(Qgis::LayerType type)
Converts a map layer type to a string value.
virtual void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Reads configuration from a DOM element previously written by writeXml()
virtual QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Writes configuration to a DOM element, to be used later with readXml()
static QgsMapLayerLegend * defaultVectorLegend(QgsVectorLayer *vl)
Create new legend implementation for vector layer.
Base class for utility classes that encapsulate information necessary for rendering of map layers.
Base class for storage of map layer selection properties.
Stores style information (renderer, opacity, labeling, diagrams etc.) applicable to a map layer.
Base class for storage of map layer temporal properties.
Base class for all map layer types.
Definition qgsmaplayer.h:76
QString name
Definition qgsmaplayer.h:80
void readStyleManager(const QDomNode &layerNode)
Read style manager's configuration (if any). To be called by subclasses.
void dependenciesChanged()
Emitted when dependencies are changed.
void writeStyleManager(QDomNode &layerNode, QDomDocument &doc) const
Write style manager's configuration (if exists). To be called by subclasses.
QgsMapLayerLegend * legend() const
Can be nullptr.
void editingStopped()
Emitted when edited changes have been successfully written to the data provider.
void recalculateExtents() const
This is used to send a request that any mapcanvas using this layer update its extents.
virtual QgsRectangle extent() const
Returns the extent of the layer.
QString source() const
Returns the source for the layer.
Q_INVOKABLE QVariant customProperty(const QString &value, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer.
int mBlockStyleChangedSignal
If non-zero, the styleChanged signal should not be emitted.
QString providerType() const
Returns the provider type (provider key) for this layer.
virtual void setExtent3D(const QgsBox3D &box)
Sets the extent.
void removeCustomProperty(const QString &key)
Remove a custom property from layer.
void setBlendMode(QPainter::CompositionMode blendMode)
Set the blending mode used for rendering a layer.
void configChanged()
Emitted whenever the configuration is changed.
void setMinimumScale(double scale)
Sets the minimum map scale (i.e.
static Qgis::DataProviderReadFlags providerReadFlags(const QDomNode &layerNode, QgsMapLayer::ReadFlags layerReadFlags)
Returns provider read flag deduced from layer read flags layerReadFlags and a dom node layerNode that...
QgsMapLayer::LayerFlags flags() const
Returns the flags for this layer.
void editingStarted()
Emitted when editing on this layer has started.
QgsCoordinateReferenceSystem crs
Definition qgsmaplayer.h:83
friend class QgsVectorLayer
void writeCustomProperties(QDomNode &layerNode, QDomDocument &doc) const
Write custom properties to project file.
virtual int listStylesInDatabase(QStringList &ids, QStringList &names, QStringList &descriptions, QString &msgError)
Lists all the style in db split into related to the layer and not related to.
virtual QString loadDefaultStyle(bool &resultFlag)
Retrieve the default style for this layer if one exists (either as a .qml file on disk or as a record...
void setDataSource(const QString &dataSource, const QString &baseName=QString(), const QString &provider=QString(), bool loadDefaultStyleFlag=false)
Updates the data source of the layer.
QString id
Definition qgsmaplayer.h:79
void triggerRepaint(bool deferredUpdate=false)
Will advise the map canvas (and any other interested party) that this layer requires to be repainted.
QString crsHtmlMetadata() const
Returns a HTML fragment containing the layer's CRS metadata, for use in the htmlMetadata() method.
void setMaximumScale(double scale)
Sets the maximum map scale (i.e.
QgsLayerMetadata metadata
Definition qgsmaplayer.h:82
Qgis::LayerType type
Definition qgsmaplayer.h:86
QPainter::CompositionMode blendMode() const
Returns the current blending mode for a layer.
virtual void setOpacity(double opacity)
Sets the opacity for the layer, where opacity is a value between 0 (totally transparent) and 1....
void setFlags(QgsMapLayer::LayerFlags flags)
Returns the flags for this layer.
QString publicSource(bool hidePassword=false) const
Gets a version of the internal layer definition that has sensitive bits removed (for example,...
QSet< QgsMapLayerDependency > mDependencies
List of layers that may modify this layer on modification.
void readCustomProperties(const QDomNode &layerNode, const QString &keyStartsWith=QString())
Read custom properties from project file.
virtual void setMetadata(const QgsLayerMetadata &metadata)
Sets the layer's metadata store.
QFlags< StyleCategory > StyleCategories
Q_INVOKABLE void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for layer.
QString mProviderKey
Data provider key (name of the data provider)
QgsCoordinateTransformContext transformContext() const
Returns the layer data provider coordinate transform context or a default transform context if the la...
void styleChanged()
Signal emitted whenever a change affects the layer's style.
QUndoStack * undoStack()
Returns pointer to layer's undo stack.
std::unique_ptr< QgsDataProvider > mPreloadedProvider
Optionally used when loading a project, it is released when the layer is effectively created.
void rendererChanged()
Signal emitted when renderer is changed.
virtual QgsError error() const
Gets current status error.
void setScaleBasedVisibility(bool enabled)
Sets whether scale based visibility is enabled for the layer.
void dataSourceChanged()
Emitted whenever the layer's data source has been changed.
bool hasScaleBasedVisibility() const
Returns whether scale based visibility is enabled for the layer.
virtual QString getStyleFromDatabase(const QString &styleId, QString &msgError)
Returns the named style corresponding to style id provided.
void emitStyleChanged()
Triggers an emission of the styleChanged() signal.
void dataChanged()
Data of layer changed.
void willBeDeleted()
Emitted in the destructor when the layer is about to be deleted, but it is still in a perfectly valid...
virtual QgsBox3D extent3D() const
Returns the 3D extent of the layer.
virtual QgsMapLayer * clone() const =0
Returns a new instance equivalent to this one except for the id which is still unique.
void setName(const QString &name)
Set the display name of the layer.
virtual void setExtent(const QgsRectangle &rect)
Sets the extent.
virtual void resolveReferences(QgsProject *project)
Resolve references to other layers (kept as layer IDs after reading XML) into layer objects.
QString mDataSource
Data source description string, varies by layer type.
void setMapTipsEnabled(bool enabled)
Enable or disable map tips for this layer.
@ FlagReadExtentFromXml
Read extent from xml and skip get extent from provider.
@ FlagForceReadOnly
Force open as read only.
@ FlagDontResolveLayers
Don't resolve layer paths or create data providers for layers.
void setValid(bool valid)
Sets whether layer is valid or not.
void readCommonStyle(const QDomElement &layerElement, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories)
Read style data common to all layer types.
QgsMapLayer::ReadFlags mReadFlags
Read flags. It's up to the subclass to respect these when restoring state from XML.
double minimumScale() const
Returns the minimum map scale (i.e.
void repaintRequested(bool deferredUpdate=false)
By emitting this signal the layer tells that either appearance or content have been changed and any v...
void setMapTipTemplate(const QString &mapTipTemplate)
The mapTip is a pretty, html representation for feature information.
Q_INVOKABLE QStringList customPropertyKeys() const
Returns list of all keys within custom properties.
QgsProject * project() const
Returns the parent project if this map layer is added to a project.
bool mapTipsEnabled
Definition qgsmaplayer.h:90
void setLegend(QgsMapLayerLegend *legend)
Assign a legend controller to the map layer.
double opacity
Definition qgsmaplayer.h:88
bool mValid
Indicates if the layer is valid and can be drawn.
@ GeometryOptions
Geometry validation configuration.
@ AttributeTable
Attribute table settings: choice and order of columns, conditional styling.
@ LayerConfiguration
General configuration: identifiable, removable, searchable, display expression, read-only.
@ Symbology
Symbology.
@ MapTips
Map tips.
@ Rendering
Rendering: scale visibility, simplify method, opacity.
@ Relations
Relations.
@ CustomProperties
Custom properties (by plugins for instance)
@ Actions
Actions.
@ Forms
Feature form.
@ Fields
Aliases, widgets, WMS/WFS, expressions, constraints, virtual fields.
@ Legend
Legend settings.
@ Diagrams
Diagrams.
@ Labeling
Labeling.
void layerModified()
Emitted when modifications has been done on layer.
void setProviderType(const QString &providerType)
Sets the providerType (provider key)
QString customPropertyHtmlMetadata() const
Returns an HTML fragment containing custom property information, for use in the htmlMetadata() method...
QString generalHtmlMetadata() const
Returns an HTML fragment containing general metadata information, for use in the htmlMetadata() metho...
void writeCommonStyle(QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) const
Write style data common to all layer types.
double maximumScale() const
Returns the maximum map scale (i.e.
QString mapTipTemplate
Definition qgsmaplayer.h:89
bool mShouldValidateCrs
true if the layer's CRS should be validated and invalid CRSes are not permitted.
void setCrs(const QgsCoordinateReferenceSystem &srs, bool emitSignal=true)
Sets layer's spatial reference system.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
static QgsExpression * expressionFromOgcFilter(const QDomElement &element, QgsVectorLayer *layer=nullptr)
Parse XML with OGC filter into QGIS expression.
static Qgis::BlendMode getBlendModeEnum(QPainter::CompositionMode blendMode)
Returns a Qgis::BlendMode corresponding to a QPainter::CompositionMode.
static QPainter::CompositionMode getCompositionMode(Qgis::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a Qgis::BlendMode.
Contains settings for how a map layer will be labeled.
double yOffset
Vertical offset of label.
const QgsLabelPlacementSettings & placementSettings() const
Returns the label placement settings.
double maxCurvedCharAngleIn
Maximum angle between inside curved label characters (valid range 20.0 to 60.0).
void setFormat(const QgsTextFormat &format)
Sets the label text formatting settings, e.g., font settings, buffer settings, etc.
double xOffset
Horizontal offset of label.
Qgis::LabelPlacement placement
Label placement mode.
double angleOffset
Label rotation, in degrees clockwise.
double maxCurvedCharAngleOut
Maximum angle between outside curved label characters (valid range -20.0 to -95.0)
Qgis::RenderUnit offsetUnits
Units for offsets of label.
bool isExpression
true if this label is made from a expression string, e.g., FieldName || 'mm'
const QgsLabelLineSettings & lineSettings() const
Returns the label line settings, which contain settings related to how the label engine places and fo...
Qgis::UpsideDownLabelHandling upsidedownLabels
Controls whether upside down labels are displayed and how they are handled.
QString fieldName
Name of field (or an expression) to use for label text.
A class to represent a 2D point.
Definition qgspointxy.h:60
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
Encapsulates properties and constraints relating to fetching elevation profiles from different source...
virtual QString translate(const QString &context, const QString &sourceText, const char *disambiguation=nullptr, int n=-1) const =0
Translates a string using the Qt QTranslator mechanism.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition qgsproject.h:107
QgsRelationManager * relationManager
Definition qgsproject.h:117
bool commitChanges(QStringList &commitErrors, bool stopEditing=true, QgsVectorLayer *vectorLayer=nullptr)
Attempts to commit to the underlying data provider any buffered changes made since the last to call t...
static QgsProject * instance()
Returns the QgsProject singleton instance.
bool rollBack(QStringList &rollbackErrors, bool stopEditing=true, QgsVectorLayer *vectorLayer=nullptr)
Stops a current editing operation on vectorLayer and discards any uncommitted edits.
bool startEditing(QgsVectorLayer *vectorLayer=nullptr)
Makes the layer editable.
QMap< QString, QgsMapLayer * > mapLayers(const bool validOnly=false) const
Returns a map of all registered layers by layer ID.
A grouped map of multiple QgsProperty objects, each referenced by a integer key value.
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
Definition for a property.
Definition qgsproperty.h:45
@ Double
Double value (including negative values)
Definition qgsproperty.h:55
@ Boolean
Boolean value.
Definition qgsproperty.h:51
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
QString absoluteToRelativeUri(const QString &providerKey, const QString &uri, const QgsReadWriteContext &context) const
Converts absolute path(s) to relative path(s) in the given provider-specific URI.
static QgsProviderRegistry * instance(const QString &pluginPath=QString())
Means of accessing canonical single instance.
QString relativeToAbsoluteUri(const QString &providerKey, const QString &uri, const QgsReadWriteContext &context) const
Converts relative path(s) to absolute path(s) in the given provider-specific URI.
Allows entering a context category and takes care of leaving this category on deletion of the class.
The class is used as a container of context for various read/write operations on other objects.
MAYBE_UNUSED NODISCARD QgsReadWriteContextCategoryPopper enterCategory(const QString &category, const QString &details=QString()) const
Push a category to the stack.
const QgsProjectTranslator * projectTranslator() const
Returns the project translator.
QgsCoordinateTransformContext transformContext() const
Returns data provider coordinate transform context.
const QgsPathResolver & pathResolver() const
Returns path resolver for conversion between relative and absolute paths.
A rectangle specified with double values.
QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
double xMinimum() const
Returns the x minimum value (left side of rectangle).
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
double width() const
Returns the width of the rectangle.
double xMaximum() const
Returns the x maximum value (right side of rectangle).
bool isNull() const
Test if the rectangle is null (holding no spatial information).
double yMaximum() const
Returns the y maximum value (top side of rectangle).
void set(const QgsPointXY &p1, const QgsPointXY &p2, bool normalize=true)
Sets the rectangle from two QgsPoints.
void combineExtentWith(const QgsRectangle &rect)
Expands the rectangle so that it covers both the original rectangle and the given rectangle.
void normalize()
Normalize the rectangle so it has non-negative width/height.
double height() const
Returns the height of the rectangle.
void setNull()
Mark a rectangle as being null (holding no spatial information).
QList< QgsRelation > referencedRelations(const QgsVectorLayer *layer=nullptr) const
Gets all relations where this layer is the referenced part (i.e.
void relationsLoaded()
Emitted when the relations were loaded after reading a project.
Represents a relationship between two vector layers.
Definition qgsrelation.h:44
Contains information about the context of a rendering operation.
double rendererScale() const
Returns the renderer map scale.
bool useRenderingOptimization() const
Returns true if the rendering optimization (geometry simplification) can be executed.
A child rule for QgsRuleBasedLabeling.
void appendChild(QgsRuleBasedLabeling::Rule *rule)
add child rule, take ownership, sets this as parent
Rule based labeling for a vector layer.
A boolean settings entry.
A double settings entry.
A template class for enum and flag settings entry.
static QgsSettingsTreeNode * sTreeQgis
This class is a composition of two QSettings instances:
Definition qgssettings.h:64
Renders the diagrams for all features with the same settings.
Renders diagrams using mixed diagram render types.
Manages stored expressions regarding creation, modification and storing in the project.
bool writeXml(QDomNode &layerNode) const
Writes the stored expressions out in XML format.
bool readXml(const QDomNode &layerNode)
Reads the stored expressions in in XML format.
An interface for classes which can visit style entity (e.g.
static double rendererFrameRate(const QgsFeatureRenderer *renderer)
Calculates the frame rate (in frames per second) at which the given renderer must be redrawn.
static QgsStringMap getSvgParameterList(QDomElement &element)
static void mergeScaleDependencies(double mScaleMinDenom, double mScaleMaxDenom, QVariantMap &props)
Merges the local scale limits, if any, with the ones already in the map, if any.
static bool fillFromSld(QDomElement &element, Qt::BrushStyle &brushStyle, QColor &color)
static Qgis::RenderUnit decodeSldUom(const QString &str, double *scaleFactor=nullptr)
Decodes a SLD unit of measure string to a render unit.
long addTask(QgsTask *task, int priority=0)
Adds a task to the manager.
void taskCompleted()
Will be emitted by task to indicate its successful completion.
void taskTerminated()
Will be emitted by task if it has terminated for any reason other then completion (e....
bool isActive() const
Returns true if the temporal property is active.
Container for settings relating to a text buffer.
void setColor(const QColor &color)
Sets the color for the buffer.
void setSizeUnit(Qgis::RenderUnit unit)
Sets the units used for the buffer size.
void setEnabled(bool enabled)
Sets whether the text buffer will be drawn.
void setSize(double size)
Sets the size of the buffer.
Container for all settings relating to text rendering.
void setColor(const QColor &color)
Sets the color that text will be rendered in.
void setSize(double size)
Sets the size for rendered text.
void setFont(const QFont &font)
Sets the font used for rendering text.
void setSizeUnit(Qgis::RenderUnit unit)
Sets the units for the size of rendered text.
void setBuffer(const QgsTextBufferSettings &bufferSettings)
Sets the text's buffer settings.
This class allows including a set of layers in a database-side transaction, provided the layer data p...
QString createSavepoint(QString &error)
creates a save point returns empty string on error returns the last created savepoint if it's not dir...
void dirtied(const QString &sql, const QString &name)
Emitted if a sql query is executed and the underlying data is modified.
static bool isNull(const QVariant &variant, bool silenceNullWarnings=false)
Returns true if the specified variant should be considered a NULL value.
This is the base class for vector data providers.
virtual QString dataComment() const override
Returns a short comment for the data that this provider is providing access to (e....
virtual QVariant aggregate(Qgis::Aggregate aggregate, int index, const QgsAggregateCalculator::AggregateParameters &parameters, QgsExpressionContext *context, bool &ok, QgsFeatureIds *fids=nullptr) const
Calculates an aggregated value from the layer's features.
static const int EditingCapabilities
Bitmask of all provider's editing capabilities.
long long featureCount() const override=0
Number of features in the layer.
virtual QgsFeatureRenderer * createRenderer(const QVariantMap &configuration=QVariantMap()) const
Creates a new vector layer feature renderer, using provider backend specific information.
virtual QString storageType() const
Returns the permanent storage type for this layer as a friendly name.
virtual QStringList uniqueStringsMatching(int index, const QString &substring, int limit=-1, QgsFeedback *feedback=nullptr) const
Returns unique string values of an attribute which contain a specified subset string.
void raiseError(const QString &msg) const
Signals an error in this provider.
virtual bool isSqlQuery() const
Returns true if the layer is a query (SQL) layer.
virtual bool empty() const
Returns true if the layer does not contain any feature.
virtual Q_INVOKABLE Qgis::VectorProviderCapabilities capabilities() const
Returns flags containing the supported capabilities.
virtual QgsAttributeList pkAttributeIndexes() const
Returns list of indexes of fields that make up the primary key.
virtual void handlePostCloneOperations(QgsVectorDataProvider *source)
Handles any post-clone operations required after this vector data provider was cloned from the source...
virtual QSet< QgsMapLayerDependency > dependencies() const
Gets the list of layer ids on which this layer depends.
virtual void setEncoding(const QString &e)
Set encoding used for accessing data from layer.
virtual Qgis::VectorLayerTypeFlags vectorLayerTypeFlags() const
Returns the vector layer type flags.
QVariant maximumValue(int index) const override
Returns the maximum value of an attribute.
QgsDataProviderElevationProperties * elevationProperties() override
Returns the provider's elevation properties.
QgsFields fields() const override=0
Returns the fields associated with this data provider.
Qgis::WkbType wkbType() const override=0
Returns the geometry type which is returned by this layer.
QVariant minimumValue(int index) const override
Returns the minimum value of an attribute.
QString encoding() const
Returns the encoding which is used for accessing data.
virtual QVariant defaultValue(int fieldIndex) const
Returns any literal default values which are present at the provider for a specified field index.
QgsFieldConstraints::Constraints fieldConstraints(int fieldIndex) const
Returns any constraints which are present at the provider for a specified field index.
virtual QgsTransaction * transaction() const
Returns the transaction this data provider is included in, if any.
virtual QgsAbstractVectorLayerLabeling * createLabeling(const QVariantMap &configuration=QVariantMap()) const
Creates labeling settings, using provider backend specific information.
QgsVectorDataProviderTemporalCapabilities * temporalCapabilities() override
Returns the provider's temporal capabilities.
QString capabilitiesString() const
Returns the above in friendly format.
bool commitChanges(QStringList &commitErrors, bool stopEditing=true)
Attempts to commit any changes to disk.
void committedAttributesDeleted(const QString &layerId, const QgsAttributeList &deletedAttributes)
Emitted after attribute deletion has been committed to the layer.
virtual bool deleteFeature(QgsFeatureId fid)
Delete a feature from the layer (but does not commit it)
QgsFeatureIds deletedFeatureIds() const
Returns a list of deleted feature IDs which are not committed.
QgsChangedAttributesMap changedAttributeValues() const
Returns a map of features with changed attributes values which are not committed.
void committedAttributeValuesChanges(const QString &layerId, const QgsChangedAttributesMap &changedAttributesValues)
Emitted after feature attribute value changes have been committed to the layer.
virtual bool renameAttribute(int attr, const QString &newName)
Renames an attribute field (but does not commit it)
void geometryChanged(QgsFeatureId fid, const QgsGeometry &geom)
Emitted when a feature's geometry is changed.
virtual bool deleteFeatures(const QgsFeatureIds &fid)
Deletes a set of features from the layer (but does not commit it)
virtual bool addAttribute(const QgsField &field)
Adds an attribute field (but does not commit it) returns true if the field was added.
void committedAttributesAdded(const QString &layerId, const QList< QgsField > &addedAttributes)
Emitted after attribute addition has been committed to the layer.
virtual bool addFeatures(QgsFeatureList &features)
Insert a copy of the given features into the layer (but does not commit it)
virtual bool changeAttributeValues(QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues)
Changes values of attributes (but does not commit it).
QgsFeatureMap addedFeatures() const
Returns a map of new features which are not committed.
virtual bool isModified() const
Returns true if the provider has been modified since the last commit.
void updateFields(QgsFields &fields)
Updates fields.
void committedFeaturesAdded(const QString &layerId, const QgsFeatureList &addedFeatures)
Emitted after feature addition has been committed to the layer.
void featureDeleted(QgsFeatureId fid)
Emitted when a feature was deleted from the buffer.
QgsGeometryMap changedGeometries() const
Returns a map of features with changed geometries which are not committed.
QgsVectorLayerEditBufferGroup * editBufferGroup() const
Returns the parent edit buffer group for this edit buffer, or nullptr if not part of a group.
QgsAttributeList deletedAttributeIds() const
Returns a list of deleted attributes fields which are not committed.
void attributeAdded(int idx)
Emitted when an attribute was added to the buffer.
void committedGeometriesChanges(const QString &layerId, const QgsGeometryMap &changedGeometries)
Emitted after feature geometry changes have been committed to the layer.
virtual bool addFeature(QgsFeature &f)
Adds a feature.
virtual void rollBack()
Stop editing and discard the edits.
void attributeValueChanged(QgsFeatureId fid, int idx, const QVariant &value)
Emitted when a feature's attribute value has been changed.
void attributeDeleted(int idx)
Emitted when an attribute was deleted from the buffer.
void featureAdded(QgsFeatureId fid)
Emitted when a feature has been added to the buffer.
virtual bool commitChanges(QStringList &commitErrors)
Attempts to commit any changes to disk.
virtual bool deleteAttribute(int attr)
Deletes an attribute field (but does not commit it)
virtual bool changeAttributeValue(QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue=QVariant())
Changed an attribute value (but does not commit it)
virtual bool changeGeometry(QgsFeatureId fid, const QgsGeometry &geom)
Change feature's geometry.
void layerModified()
Emitted when modifications has been done on layer.
void committedFeaturesRemoved(const QString &layerId, const QgsFeatureIds &deletedFeatureIds)
Emitted after feature removal has been committed to the layer.
Contains utility functions for editing vector layers.
int translateFeature(QgsFeatureId featureId, double dx, double dy)
Translates feature by dx, dy.
bool insertVertex(double x, double y, QgsFeatureId atFeatureId, int beforeVertex)
Insert a new vertex before the given vertex number, in the given ring, item (first number is index 0)...
Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart(const QVector< QgsPointXY > &ring, QgsFeatureId featureId)
Adds a new part polygon to a multipart feature.
Qgis::VectorEditResult deleteVertex(QgsFeatureId featureId, int vertex)
Deletes a vertex from a feature.
int addTopologicalPoints(const QgsGeometry &geom)
Adds topological points for every vertex of the geometry.
Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitParts(const QVector< QgsPointXY > &splitLine, bool topologicalEditing=false)
Splits parts cut by the given line.
Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitFeatures(const QVector< QgsPointXY > &splitLine, bool topologicalEditing=false)
Splits features cut by the given line.
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),...
Q_DECL_DEPRECATED Qgis::GeometryOperationResult addRing(const QVector< QgsPointXY > &ring, const QgsFeatureIds &targetFeatureIds=QgsFeatureIds(), QgsFeatureId *modifiedFeatureId=nullptr)
Adds a ring to polygon/multipolygon features.
Vector layer specific subclass of QgsMapLayerElevationProperties.
void setDefaultsFromLayer(QgsMapLayer *layer) override
Sets default properties based on sensible choices for the given map layer.
QgsVectorLayerElevationProperties * clone() const override
Creates a clone of the properties.
Counts the features in a QgsVectorLayer in task.
QHash< QString, long long > symbolFeatureCountMap() const
Returns the count for each symbol.
void cancel() override
Notifies the task that it should terminate.
QHash< QString, QgsFeatureIds > symbolFeatureIdMap() const
Returns the QgsFeatureIds for each symbol.
A feature iterator which iterates over features from a QgsVectorLayer.
Manages joined fields for a vector layer.
void resolveReferences(QgsProject *project)
Resolves layer IDs of joined layers using given project's available layers.
bool addJoin(const QgsVectorLayerJoinInfo &joinInfo)
Joins another vector layer to this layer.
void readXml(const QDomNode &layer_node)
Reads joins from project file.
void writeXml(QDomNode &layer_node, QDomDocument &document) const
Saves mVectorJoins to xml under the layer node.
const QgsVectorLayerJoinInfo * joinForFieldIndex(int index, const QgsFields &fields, int &sourceFieldIndex) const
Finds the vector join for a layer field index.
bool changeAttributeValue(QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue=QVariant())
Changes attribute value in joined layers.
bool removeJoin(const QString &joinLayerId)
Removes a vector layer join.
bool containsJoins() const
Quick way to test if there is any join at all.
bool changeAttributeValues(QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues=QgsAttributeMap())
Changes attributes' values in joined layers.
bool addFeatures(QgsFeatureList &features, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) override
Adds a list of features in joined layers.
void joinedFieldsChanged()
Emitted whenever the list of joined fields changes (e.g.
void updateFields(QgsFields &fields)
Updates field map with joined attributes.
bool deleteFeature(QgsFeatureId fid, QgsVectorLayer::DeleteContext *context=nullptr) const
Deletes a feature from joined layers.
const QgsVectorJoinList & vectorJoins() const
Defines left outer join from our vector layer to some other vector layer.
QString targetFieldName() const
Returns name of the field of our layer that will be used for join.
QString joinLayerId() const
ID of the joined layer - may be used to resolve reference to the joined layer.
Implementation of QgsAbstractProfileGenerator for vector layers.
Implementation of threaded rendering for vector layers.
Implementation of layer selection properties for vector layers.
QgsVectorLayerSelectionProperties * clone() const override
Creates a clone of the properties.
QDomElement writeXml(QDomElement &element, QDomDocument &doc, const QgsReadWriteContext &context) override
Writes the properties to a DOM element, to be used later with readXml().
bool readXml(const QDomElement &element, const QgsReadWriteContext &context) override
Reads temporal properties from a DOM element previously written by writeXml().
Basic implementation of the labeling interface.
Implementation of map layer temporal properties for vector layers.
void guessDefaultsFromFields(const QgsFields &fields)
Attempts to setup the temporal properties by scanning a set of fields and looking for standard naming...
void setDefaultsFromDataProviderTemporalCapabilities(const QgsDataProviderTemporalCapabilities *capabilities) override
Sets the layers temporal settings to appropriate defaults based on a provider's temporal capabilities...
Contains settings which reflect the context in which vector layer tool operations should consider.
QgsExpressionContext * expressionContext() const
Returns the optional expression context used by the vector layer tools.
static QString guessFriendlyIdentifierField(const QgsFields &fields, bool *foundFriendly=nullptr)
Given a set of fields, attempts to pick the "most useful" field for user-friendly identification of f...
Represents a vector layer which manages a vector based data sets.
void setLabeling(QgsAbstractVectorLayerLabeling *labeling)
Sets labeling configuration.
QString attributeDisplayName(int index) const
Convenience function that returns the attribute alias if defined or the field name else.
QVariant maximumValue(int index) const FINAL
Returns the maximum value for an attribute column or an invalid variant in case of error.
int addExpressionField(const QString &exp, const QgsField &fld)
Add a new field which is calculated by the expression specified.
void committedFeaturesAdded(const QString &layerId, const QgsFeatureList &addedFeatures)
Emitted when features are added to the provider if not in transaction mode.
void setExtent(const QgsRectangle &rect) FINAL
Sets the extent.
Q_DECL_DEPRECATED Qgis::GeometryOperationResult addPart(const QList< QgsPointXY > &ring)
Adds a new part polygon to a multipart feature.
static const QgsSettingsEntryEnumFlag< Qgis::VectorRenderingSimplificationFlags > * settingsSimplifyDrawingHints
QgsRectangle sourceExtent() const FINAL
Returns the extent of all geometries from the source.
void featureBlendModeChanged(QPainter::CompositionMode blendMode)
Signal emitted when setFeatureBlendMode() is called.
bool labelsEnabled() const
Returns whether the layer contains labels which are enabled and should be drawn.
bool writeSymbology(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) const FINAL
Write the style for the layer into the document provided.
bool isModified() const override
Returns true if the provider has been modified since the last commit.
bool writeStyle(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) const FINAL
Write just the symbology information for the layer into the document.
void addFeatureRendererGenerator(QgsFeatureRendererGenerator *generator)
Adds a new feature renderer generator to the layer.
Q_DECL_DEPRECATED void setExcludeAttributesWfs(const QSet< QString > &att)
A set of attributes that are not advertised in WFS requests with QGIS server.
Q_INVOKABLE bool deleteSelectedFeatures(int *deletedCount=nullptr, QgsVectorLayer::DeleteContext *context=nullptr)
Deletes the selected features.
Q_INVOKABLE void selectByRect(QgsRectangle &rect, Qgis::SelectBehavior behavior=Qgis::SelectBehavior::SetSelection)
Selects features found within the search rectangle (in layer's coordinates)
void removeFieldAlias(int index)
Removes an alias (a display name) for attributes to display in dialogs.
void setAuxiliaryLayer(QgsAuxiliaryLayer *layer=nullptr)
Sets the current auxiliary layer.
void beforeRemovingExpressionField(int idx)
Will be emitted, when an expression field is going to be deleted from this vector layer.
Q_INVOKABLE bool deleteFeatures(const QgsFeatureIds &fids, QgsVectorLayer::DeleteContext *context=nullptr)
Deletes a set of features from the layer (but does not commit it)
QString loadDefaultStyle(bool &resultFlag) FINAL
Retrieve the default style for this layer if one exists (either as a .qml file on disk or as a record...
void committedGeometriesChanges(const QString &layerId, const QgsGeometryMap &changedGeometries)
Emitted when geometry changes are saved to the provider if not in transaction mode.
void beforeCommitChanges(bool stopEditing)
Emitted before changes are committed to the data provider.
Q_INVOKABLE bool startEditing()
Makes the layer editable.
void setFieldConfigurationFlags(int index, Qgis::FieldConfigurationFlags flags)
Sets the configuration flags of the field at given index.
QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength > fieldConstraintsAndStrength(int fieldIndex) const
Returns a map of constraint with their strength for a specific field of the layer.
bool addJoin(const QgsVectorLayerJoinInfo &joinInfo)
Joins another vector layer to this layer.
QSet< QgsMapLayerDependency > dependencies() const FINAL
Gets the list of dependencies.
QgsMapLayerTemporalProperties * temporalProperties() override
Returns the layer's temporal properties.
Q_INVOKABLE bool changeAttributeValue(QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue=QVariant(), bool skipDefaultValues=false, QgsVectorLayerToolsContext *context=nullptr)
Changes an attribute value for a feature (but does not immediately commit the changes).
Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitFeatures(const QVector< QgsPointXY > &splitLine, bool topologicalEditing=false)
Splits features cut by the given line.
QgsDefaultValue defaultValueDefinition(int index) const
Returns the definition of the expression used when calculating the default value for a field.
QgsExpressionContextScope * createExpressionContextScope() const FINAL
This method needs to be reimplemented in all classes which implement this interface and return an exp...
QgsMapLayerRenderer * createMapRenderer(QgsRenderContext &rendererContext) FINAL
Returns new instance of QgsMapLayerRenderer that will be used for rendering of given context.
QgsVectorLayerFeatureCounter * countSymbolFeatures(bool storeSymbolFids=false)
Count features for symbols.
QPainter::CompositionMode featureBlendMode() const
Returns the current blending mode for features.
bool hasMapTips() const FINAL
Returns true if the layer contains map tips.
QString constraintExpression(int index) const
Returns the constraint expression for for a specified field index, if set.
bool addAttribute(const QgsField &field)
Add an attribute field (but does not commit it) returns true if the field was added.
void attributeAdded(int idx)
Will be emitted, when a new attribute has been added to this vector layer.
QString capabilitiesString() const
Capabilities for this layer, comma separated and translated.
void deselect(QgsFeatureId featureId)
Deselects feature by its ID.
void allowCommitChanged()
Emitted whenever the allowCommit() property of this layer changes.
friend class QgsVectorLayerEditBuffer
void editCommandStarted(const QString &text)
Signal emitted when a new edit command has been started.
void updateFields()
Will regenerate the fields property of this layer by obtaining all fields from the dataProvider,...
bool isSpatial() const FINAL
Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeome...
const QgsDiagramLayerSettings * diagramLayerSettings() const
void setFieldConstraint(int index, QgsFieldConstraints::Constraint constraint, QgsFieldConstraints::ConstraintStrength strength=QgsFieldConstraints::ConstraintStrengthHard)
Sets a constraint for a specified field index.
bool loadAuxiliaryLayer(const QgsAuxiliaryStorage &storage, const QString &key=QString())
Loads the auxiliary layer for this vector layer.
bool insertVertex(double x, double y, QgsFeatureId atFeatureId, int beforeVertex)
Inserts a new vertex before the given vertex number, in the given ring, item (first number is index 0...
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
QgsAbstractProfileGenerator * createProfileGenerator(const QgsProfileRequest &request) override
Given a profile request, returns a new profile generator ready for generating elevation profiles.
QString htmlMetadata() const FINAL
Obtain a formatted HTML string containing assorted metadata for this layer.
Q_INVOKABLE QgsRectangle boundingBoxOfSelected() const
Returns the bounding box of the selected features. If there is no selection, QgsRectangle(0,...
bool addFeatures(QgsFeatureList &features, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) FINAL
Adds a list of features to the sink.
Q_INVOKABLE QgsFeatureList selectedFeatures() const
Returns a copy of the user-selected features.
QString expressionField(int index) const
Returns the expression used for a given expression field.
bool readSymbology(const QDomNode &layerNode, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) FINAL
Read the symbology for the current layer from the DOM node supplied.
void removeFeatureRendererGenerator(const QString &id)
Removes the feature renderer with matching id from the layer.
Q_INVOKABLE bool deleteFeature(QgsFeatureId fid, QgsVectorLayer::DeleteContext *context=nullptr)
Deletes a feature from the layer (but does not commit it).
friend class QgsVectorLayerEditPassthrough
void setSimplifyMethod(const QgsVectorSimplifyMethod &simplifyMethod)
Sets the simplification settings for fast rendering of features.
void editCommandDestroyed()
Signal emitted, when an edit command is destroyed.
QVariant aggregate(Qgis::Aggregate aggregate, const QString &fieldOrExpression, const QgsAggregateCalculator::AggregateParameters &parameters=QgsAggregateCalculator::AggregateParameters(), QgsExpressionContext *context=nullptr, bool *ok=nullptr, QgsFeatureIds *fids=nullptr, QgsFeedback *feedback=nullptr, QString *error=nullptr) const
Calculates an aggregated value from the layer's features.
QgsFieldConstraints::Constraints fieldConstraints(int fieldIndex) const
Returns any constraints which are present for a specified field index.
static const QgsSettingsEntryEnumFlag< Qgis::VectorSimplificationAlgorithm > * settingsSimplifyAlgorithm
Q_DECL_DEPRECATED QSet< QString > excludeAttributesWms() const
A set of attributes that are not advertised in WMS requests with QGIS server.
QgsBox3D sourceExtent3D() const FINAL
Returns the 3D extent of all geometries from the source.
QgsFeatureIds symbolFeatureIds(const QString &legendKey) const
Ids of features rendered with specified legend key.
void removeFieldConstraint(int index, QgsFieldConstraints::Constraint constraint)
Removes a constraint for a specified field index.
int selectedFeatureCount() const
Returns the number of features that are selected in this layer.
void featuresDeleted(const QgsFeatureIds &fids)
Emitted when features have been deleted.
Qgis::VectorLayerTypeFlags vectorLayerTypeFlags() const
Returns the vector layer type flags.
void setLabelsEnabled(bool enabled)
Sets whether labels should be enabled for the layer.
void subsetStringChanged()
Emitted when the layer's subset string has changed.
QgsAuxiliaryLayer * auxiliaryLayer()
Returns the current auxiliary layer.
void setCoordinateSystem()
Setup the coordinate system transformation for the layer.
void committedFeaturesRemoved(const QString &layerId, const QgsFeatureIds &deletedFeatureIds)
Emitted when features are deleted from the provider if not in transaction mode.
void updateExpressionField(int index, const QString &exp)
Changes the expression used to define an expression based (virtual) field.
Q_INVOKABLE void selectByExpression(const QString &expression, Qgis::SelectBehavior behavior=Qgis::SelectBehavior::SetSelection, QgsExpressionContext *context=nullptr)
Selects matching features using an expression.
static const QgsSettingsEntryDouble * settingsSimplifyMaxScale
~QgsVectorLayer() override
QgsCoordinateReferenceSystem sourceCrs() const FINAL
Returns the coordinate reference system for features in the source.
void endEditCommand()
Finish edit command and add it to undo/redo stack.
void destroyEditCommand()
Destroy active command and reverts all changes in it.
bool isAuxiliaryField(int index, int &srcIndex) const
Returns true if the field comes from the auxiliary layer, false otherwise.
QgsExpressionContext createExpressionContext() const FINAL
This method needs to be reimplemented in all classes which implement this interface and return an exp...
QList< QgsRelation > referencingRelations(int idx) const
Returns the layer's relations, where the foreign key is on this layer.
Q_DECL_DEPRECATED QSet< QString > excludeAttributesWfs() const
A set of attributes that are not advertised in WFS requests with QGIS server.
Q_DECL_DEPRECATED Qgis::GeometryOperationResult splitParts(const QVector< QgsPointXY > &splitLine, bool topologicalEditing=false)
Splits parts cut by the given line.
void setDefaultValueDefinition(int index, const QgsDefaultValue &definition)
Sets the definition of the expression to use when calculating the default value for a field.
bool diagramsEnabled() const
Returns whether the layer contains diagrams which are enabled and should be drawn.
void setAllowCommit(bool allowCommit)
Controls, if the layer is allowed to commit changes.
bool setDependencies(const QSet< QgsMapLayerDependency > &layers) FINAL
Sets the list of dependencies.
void symbolFeatureCountMapChanged()
Emitted when the feature count for symbols on this layer has been recalculated.
Q_INVOKABLE const QgsFeatureIds & selectedFeatureIds() const
Returns a list of the selected features IDs in this layer.
Qgis::VectorEditResult deleteVertex(QgsFeatureId featureId, int vertex)
Deletes a vertex from a feature.
void setFeatureBlendMode(QPainter::CompositionMode blendMode)
Sets the blending mode used for rendering each feature.
QString constraintDescription(int index) const
Returns the descriptive name for the constraint expression for a specified field index.
void writeCustomSymbology(QDomElement &element, QDomDocument &doc, QString &errorMessage) const
Signal emitted whenever the symbology (QML-file) for this layer is being written.
const QgsAbstractVectorLayerLabeling * labeling() const
Access to const labeling configuration.
void setProviderEncoding(const QString &encoding)
Sets the text encoding of the data provider.
bool writeSld(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QVariantMap &props=QVariantMap()) const
Writes the symbology of the layer into the document provided in SLD 1.1 format.
void setDisplayExpression(const QString &displayExpression)
Set the preview expression, used to create a human readable preview string.
virtual bool deleteAttribute(int attr)
Deletes an attribute field (but does not commit it).
static const QgsSettingsEntryBool * settingsSimplifyLocal
void resolveReferences(QgsProject *project) FINAL
Resolves references to other layers (kept as layer IDs after reading XML) into layer objects.
bool simplifyDrawingCanbeApplied(const QgsRenderContext &renderContext, Qgis::VectorRenderingSimplificationFlag simplifyHint) const
Returns whether the VectorLayer can apply the specified simplification hint.
QgsMapLayerElevationProperties * elevationProperties() override
Returns the layer's elevation properties.
bool removeJoin(const QString &joinLayerId)
Removes a vector layer join.
Q_INVOKABLE void invertSelectionInRectangle(QgsRectangle &rect)
Inverts selection of features found within the search rectangle (in layer's coordinates)
void setRenderer(QgsFeatureRenderer *r)
Sets the feature renderer which will be invoked to represent this layer in 2D map views.
Q_INVOKABLE void selectAll()
Select all the features.
bool isEditable() const FINAL
Returns true if the provider is in editing mode.
QStringList commitErrors() const
Returns a list containing any error messages generated when attempting to commit changes to the layer...
QString storageType() const
Returns the permanent storage type for this layer as a friendly name.
bool readExtentFromXml() const
Returns true if the extent is read from the XML document when data source has no metadata,...
QString dataComment() const
Returns a description for this layer as defined in the data provider.
bool accept(QgsStyleEntityVisitorInterface *visitor) const override
QgsGeometryOptions * geometryOptions() const
Configuration and logic to apply automatically on any edit happening on this layer.
QgsStringMap attributeAliases() const
Returns a map of field name to attribute alias.
Q_INVOKABLE int translateFeature(QgsFeatureId featureId, double dx, double dy)
Translates feature by dx, dy.
Q_INVOKABLE Qgis::WkbType wkbType() const FINAL
Returns the WKBType or WKBUnknown in case of error.
virtual void updateExtents(bool force=false)
Update the extents for the layer.
void attributeDeleted(int idx)
Will be emitted, when an attribute has been deleted from this vector layer.
QgsFeatureRenderer * renderer()
Returns the feature renderer used for rendering the features in the layer in 2D map views.
void beforeEditingStarted()
Emitted before editing on this layer is started.
void committedAttributeValuesChanges(const QString &layerId, const QgsChangedAttributesMap &changedAttributesValues)
Emitted when attribute value changes are saved to the provider if not in transaction mode.
void committedAttributesAdded(const QString &layerId, const QList< QgsField > &addedAttributes)
Emitted when attributes are added to the provider if not in transaction mode.
void setEditFormConfig(const QgsEditFormConfig &editFormConfig)
Sets the editFormConfig (configuration) of the form used to represent this vector layer.
Qgis::FieldConfigurationFlags fieldConfigurationFlags(int index) const
Returns the configuration flags of the field at given index.
void committedAttributesDeleted(const QString &layerId, const QgsAttributeList &deletedAttributes)
Emitted when attributes are deleted from the provider if not in transaction mode.
QString displayExpression
void displayExpressionChanged()
Emitted when the display expression changes.
QVariant minimumValue(int index) const FINAL
Returns the minimum value for an attribute column or an invalid variant in case of error.
QgsFeatureIterator getSelectedFeatures(QgsFeatureRequest request=QgsFeatureRequest()) const
Returns an iterator of the selected features.
void setEditorWidgetSetup(int index, const QgsEditorWidgetSetup &setup)
Sets the editor widget setup for the field at the specified index.
void setConstraintExpression(int index, const QString &expression, const QString &description=QString())
Sets the constraint expression for the specified field index.
Q_INVOKABLE bool rollBack(bool deleteBuffer=true)
Stops a current editing operation and discards any uncommitted edits.
bool readStyle(const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) FINAL
Read the style for the current layer from the DOM node supplied.
bool updateFeature(QgsFeature &feature, bool skipDefaultValues=false)
Updates an existing feature in the layer, replacing the attributes and geometry for the feature with ...
Q_INVOKABLE bool commitChanges(bool stopEditing=true)
Attempts to commit to the underlying data provider any buffered changes made since the last to call t...
void setFieldConfigurationFlag(int index, Qgis::FieldConfigurationFlag flag, bool active)
Sets the given configuration flag for the field at given index to be active or not.
QgsVectorDataProvider * dataProvider() FINAL
Returns the layer's data provider, it may be nullptr.
void setFieldDuplicatePolicy(int index, Qgis::FieldDuplicatePolicy policy)
Sets a duplicate policy for the field with the specified index.
bool setReadOnly(bool readonly=true)
Makes layer read-only (editing disabled) or not.
void editFormConfigChanged()
Will be emitted whenever the edit form configuration of this layer changes.
Q_INVOKABLE void modifySelection(const QgsFeatureIds &selectIds, const QgsFeatureIds &deselectIds)
Modifies the current selection on this layer.
void setWeakRelations(const QList< QgsWeakRelation > &relations)
Sets the layer's weak relations.
void reselect()
Reselects the previous set of selected features.
void select(QgsFeatureId featureId)
Selects feature by its ID.
QgsEditorWidgetSetup editorWidgetSetup(int index) const
Returns the editor widget setup for the field at the specified index.
long long featureCount() const FINAL
Returns feature count including changes which have not yet been committed If you need only the count ...
void setReadExtentFromXml(bool readExtentFromXml)
Flag allowing to indicate if the extent has to be read from the XML document when data source has no ...
void afterCommitChanges()
Emitted after changes are committed to the data provider.
QgsVectorLayer * clone() const override
Returns a new instance equivalent to this one.
QgsAttributeTableConfig attributeTableConfig() const
Returns the attribute table configuration object.
QgsActionManager * actions()
Returns all layer actions defined on this layer.
bool readSld(const QDomNode &node, QString &errorMessage) FINAL
Q_INVOKABLE void selectByIds(const QgsFeatureIds &ids, Qgis::SelectBehavior behavior=Qgis::SelectBehavior::SetSelection)
Selects matching features using a list of feature IDs.
QStringList uniqueStringsMatching(int index, const QString &substring, int limit=-1, QgsFeedback *feedback=nullptr) const
Returns unique string values of an attribute which contain a specified subset string.
void raiseError(const QString &msg)
Signals an error related to this vector layer.
void editCommandEnded()
Signal emitted, when an edit command successfully ended.
void supportsEditingChanged()
Emitted when the read only state or the data provider of this layer is changed.
void readOnlyChanged()
Emitted when the read only state of this layer is changed.
void removeExpressionField(int index)
Removes an expression field.
virtual void setTransformContext(const QgsCoordinateTransformContext &transformContext) override
Sets the coordinate transform context to transformContext.
void attributeValueChanged(QgsFeatureId fid, int idx, const QVariant &value)
Emitted whenever an attribute value change is done in the edit buffer.
static Q_DECL_DEPRECATED void drawVertexMarker(double x, double y, QPainter &p, Qgis::VertexMarkerType type, int vertexSize)
Draws a vertex symbol at (screen) coordinates x, y.
bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) FINAL
Adds a single feature to the sink.
void setFieldAlias(int index, const QString &aliasString)
Sets an alias (a display name) for attributes to display in dialogs.
friend class QgsVectorLayerFeatureSource
void minimumAndMaximumValue(int index, QVariant &minimum, QVariant &maximum) const
Calculates both the minimum and maximum value for an attribute column.
Q_INVOKABLE Qgis::GeometryType geometryType() const
Returns point, line or polygon.
QgsRectangle extent() const FINAL
Returns the extent of the layer.
Q_DECL_DEPRECATED void setExcludeAttributesWms(const QSet< QString > &att)
A set of attributes that are not advertised in WMS requests with QGIS server.
void setAttributeTableConfig(const QgsAttributeTableConfig &attributeTableConfig)
Sets the attribute table configuration object.
virtual bool setSubsetString(const QString &subset)
Sets the string (typically sql) used to define a subset of the layer.
bool readXml(const QDomNode &layer_node, QgsReadWriteContext &context) FINAL
Reads vector layer specific state from project file Dom node.
void afterRollBack()
Emitted after changes are rolled back.
QString decodedSource(const QString &source, const QString &provider, const QgsReadWriteContext &context) const FINAL
Called by readLayerXML(), used by derived classes to decode provider's specific data source from proj...
void setDiagramLayerSettings(const QgsDiagramLayerSettings &s)
QList< QgsWeakRelation > weakRelations() const
Returns the layer's weak relations as specified in the layer's style.
const QgsVectorSimplifyMethod & simplifyMethod() const
Returns the simplification settings for fast rendering of features.
void selectionChanged(const QgsFeatureIds &selected, const QgsFeatureIds &deselected, bool clearAndSelect)
Emitted when selection was changed.
void beforeAddingExpressionField(const QString &fieldName)
Will be emitted, when an expression field is going to be added to this vector layer.
bool deleteAttributes(const QList< int > &attrs)
Deletes a list of attribute fields (but does not commit it)
void updatedFields()
Emitted whenever the fields available from this layer have been changed.
QVariant defaultValue(int index, const QgsFeature &feature=QgsFeature(), QgsExpressionContext *context=nullptr) const
Returns the calculated default value for the specified field index.
void featureAdded(QgsFeatureId fid)
Emitted when a new feature has been added to the layer.
QString sourceName() const FINAL
Returns a friendly display name for the source.
QString attributeAlias(int index) const
Returns the alias of an attribute name or a null string if there is no alias.
void featureDeleted(QgsFeatureId fid)
Emitted when a feature has been deleted.
QgsBox3D extent3D() const FINAL
Returns the 3D extent of the layer.
Q_INVOKABLE void removeSelection()
Clear selection.
bool allowCommit() const
Controls, if the layer is allowed to commit changes.
QgsConditionalLayerStyles * conditionalStyles() const
Returns the conditional styles that are set for this layer.
void readCustomSymbology(const QDomElement &element, QString &errorMessage)
Signal emitted whenever the symbology (QML-file) for this layer is being read.
void reload() FINAL
Synchronises with changes in the datasource.
const QList< QgsVectorLayerJoinInfo > vectorJoins() const
bool renameAttribute(int index, const QString &newName)
Renames an attribute field (but does not commit it).
bool isSqlQuery() const
Returns true if the layer is a query (SQL) layer.
void beforeRollBack()
Emitted before changes are rolled back.
QgsAttributeList primaryKeyAttributes() const
Returns the list of attributes which make up the layer's primary keys.
bool writeXml(QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context) const FINAL
Writes vector layer specific state to project file Dom node.
QString encodedSource(const QString &source, const QgsReadWriteContext &context) const FINAL
Called by writeLayerXML(), used by derived classes to encode provider's specific data source to proje...
void beginEditCommand(const QString &text)
Create edit command for undo/redo operations.
QString displayField() const
This is a shorthand for accessing the displayExpression if it is a simple field.
Q_DECL_DEPRECATED Qgis::GeometryOperationResult addRing(const QVector< QgsPointXY > &ring, QgsFeatureId *featureId=nullptr)
Adds a ring to polygon/multipolygon features.
void setDiagramRenderer(QgsDiagramRenderer *r)
Sets diagram rendering object (takes ownership)
void geometryChanged(QgsFeatureId fid, const QgsGeometry &geometry)
Emitted whenever a geometry change is done in the edit buffer.
QgsEditFormConfig editFormConfig
QList< const QgsFeatureRendererGenerator * > featureRendererGenerators() const
Returns a list of the feature renderer generators owned by the layer.
Qgis::FeatureAvailability hasFeatures() const FINAL
Determines if this vector layer has features.
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),...
QgsGeometry getGeometry(QgsFeatureId fid) const
Queries the layer for the geometry at the given id.
int addTopologicalPoints(const QgsGeometry &geom)
Adds topological points for every vertex of the geometry.
void beforeModifiedCheck() const
Emitted when the layer is checked for modifications. Use for last-minute additions.
Q_INVOKABLE QgsFeature getFeature(QgsFeatureId fid) const
Queries the layer for the feature with the given id.
Q_INVOKABLE void invertSelection()
Selects not selected features and deselects selected ones.
const QgsDiagramRenderer * diagramRenderer() const
void setExtent3D(const QgsBox3D &rect) FINAL
Sets the extent.
Q_INVOKABLE bool changeAttributeValues(QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues=QgsAttributeMap(), bool skipDefaultValues=false, QgsVectorLayerToolsContext *context=nullptr)
Changes attributes' values for a feature (but does not immediately commit the changes).
QgsMapLayerSelectionProperties * selectionProperties() override
Returns the layer's selection properties.
bool changeGeometry(QgsFeatureId fid, QgsGeometry &geometry, bool skipDefaultValue=false)
Changes a feature's geometry within the layer's edit buffer (but does not immediately commit the chan...
static const QgsSettingsEntryDouble * settingsSimplifyDrawingTol
Qgis::SpatialIndexPresence hasSpatialIndex() const override
QSet< QVariant > uniqueValues(int fieldIndex, int limit=-1) const FINAL
Calculates a list of unique values contained within an attribute in the layer.
void setFieldSplitPolicy(int index, Qgis::FieldDomainSplitPolicy policy)
Sets a split policy for the field with the specified index.
bool forceLocalOptimization() const
Gets where the simplification executes, after fetch the geometries from provider, or when supported,...
Qgis::VectorRenderingSimplificationFlags simplifyHints() const
Gets the simplification hints of the vector layer managed.
float maximumScale() const
Gets the maximum scale at which the layer should be simplified.
Qgis::VectorSimplificationAlgorithm simplifyAlgorithm() const
Gets the local simplification algorithm of the vector layer managed.
void setThreshold(float threshold)
Sets the simplification threshold of the vector layer managed.
void setForceLocalOptimization(bool localOptimization)
Sets where the simplification executes, after fetch the geometries from provider, or when supported,...
void setSimplifyHints(Qgis::VectorRenderingSimplificationFlags simplifyHints)
Sets the simplification hints of the vector layer managed.
float threshold() const
Gets the simplification threshold of the vector layer managed.
void setMaximumScale(float maximumScale)
Sets the maximum scale at which the layer should be simplified.
void setSimplifyAlgorithm(Qgis::VectorSimplificationAlgorithm simplifyAlgorithm)
Sets the local simplification algorithm of the vector layer managed.
@ Referencing
The layer is referencing (or the "child" / "right" layer in the relationship)
@ Referenced
The layer is referenced (or the "parent" / "left" left in the relationship)
static void writeXml(const QgsVectorLayer *layer, WeakRelationType type, const QgsRelation &relation, QDomNode &node, QDomDocument &doc)
Writes a weak relation infoto an XML structure.
static QgsWeakRelation readXml(const QgsVectorLayer *layer, WeakRelationType type, const QDomNode &node, const QgsPathResolver resolver)
Returns a weak relation for the given layer.
static Qgis::GeometryType geometryType(Qgis::WkbType type)
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
static QString displayString(Qgis::WkbType type)
Returns a non-translated display string type for a WKB type, e.g., the geometry name used in WKT geom...
static QString geometryDisplayString(Qgis::GeometryType type)
Returns a display string for a geometry type.
static QDomElement writeVariant(const QVariant &value, QDomDocument &doc)
Write a QVariant to a QDomElement.
static QgsBox3D readBox3D(const QDomElement &element)
Decodes a DOM element to a 3D box.
static QVariant readVariant(const QDomElement &element)
Read a QVariant from a QDomElement.
static QgsRectangle readRectangle(const QDomElement &element)
@ UnknownCount
Provider returned an unknown feature count.
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
bool qgsVariantEqual(const QVariant &lhs, const QVariant &rhs)
Compares two QVariant values and returns whether they are equal, two NULL values are always treated a...
Definition qgis.cpp:248
bool qgsVariantLessThan(const QVariant &lhs, const QVariant &rhs)
Compares two QVariant values and returns whether the first is less than the second.
Definition qgis.cpp:121
bool qgsVariantGreaterThan(const QVariant &lhs, const QVariant &rhs)
Compares two QVariant values and returns whether the first is greater than the second.
Definition qgis.cpp:189
T qgsEnumKeyToValue(const QString &key, const T &defaultValue, bool tryValueAsKey=true, bool *returnOk=nullptr)
Returns the value corresponding to the given key of an enum.
Definition qgis.h:6127
QString qgsEnumValueToKey(const T &value, bool *returnOk=nullptr)
Returns the value for the given key of an enum.
Definition qgis.h:6108
QString qgsFlagValueToKeys(const T &value, bool *returnOk=nullptr)
Returns the value for the given keys of a flag.
Definition qgis.h:6166
T qgsFlagKeysToValue(const QString &keys, const T &defaultValue, bool tryValueAsKey=true, bool *returnOk=nullptr)
Returns the value corresponding to the given keys of a flag.
Definition qgis.h:6188
QMap< QString, QString > QgsStringMap
Definition qgis.h:6455
QVector< QgsPoint > QgsPointSequence
QMap< int, QVariant > QgsAttributeMap
QList< QgsFeature > QgsFeatureList
QSet< QgsFeatureId > QgsFeatureIds
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
QList< int > QgsAttributeList
Definition qgsfield.h:27
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39
#define QgsDebugError(str)
Definition qgslogger.h:38
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
#define RENDERER_TAG_NAME
Definition qgsrenderer.h:53
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS_NON_FATAL
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
bool saveStyle_t(const QString &uri, const QString &qmlStyle, const QString &sldStyle, const QString &styleName, const QString &styleDescription, const QString &uiFileContent, bool useAsDefault, QString &errCause)
int listStyles_t(const QString &uri, QStringList &ids, QStringList &names, QStringList &descriptions, QString &errCause)
QString getStyleById_t(const QString &uri, QString styleID, QString &errCause)
bool deleteStyleById_t(const QString &uri, QString styleID, QString &errCause)
QString loadStyle_t(const QString &uri, QString &errCause)
QList< int > QgsAttributeList
QMap< QgsFeatureId, QgsFeature > QgsFeatureMap
A bundle of parameters controlling aggregate calculation.
Setting options for creating vector data providers.
Context for cascade delete features.
QList< QgsVectorLayer * > handledLayers(bool includeAuxiliaryLayers=true) const
Returns a list of all layers affected by the delete operation.
QMap< QgsVectorLayer *, QgsFeatureIds > mHandledFeatures
QgsFeatureIds handledFeatures(QgsVectorLayer *layer) const
Returns a list of feature IDs from the specified layer affected by the delete operation.
Setting options for loading vector layers.
bool skipCrsValidation
Controls whether the layer is allowed to have an invalid/unknown CRS.
bool forceReadOnly
Controls whether the layer is forced to be load as Read Only.
bool loadDefaultStyle
Set to true if the default layer style should be loaded.
QgsCoordinateTransformContext transformContext
Coordinate transform context.
QgsCoordinateReferenceSystem fallbackCrs
Fallback layer coordinate reference system.
Qgis::WkbType fallbackWkbType
Fallback geometry type.
bool loadAllStoredStyles
Controls whether the stored styles will be all loaded.