QGIS API Documentation 3.41.0-Master (88383c3d16f)
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 && mJoinBuffer->containsJoins() )
1370 {
1371 success = mJoinBuffer->addFeature( feature );
1372 }
1373
1374 return success;
1375}
1376
1377bool QgsVectorLayer::updateFeature( QgsFeature &updatedFeature, bool skipDefaultValues )
1378{
1380
1381 if ( !mEditBuffer || !mDataProvider )
1382 {
1383 return false;
1384 }
1385
1386 QgsFeature currentFeature = getFeature( updatedFeature.id() );
1387 if ( currentFeature.isValid() )
1388 {
1389 bool hasChanged = false;
1390 bool hasError = false;
1391
1392 if ( ( updatedFeature.hasGeometry() || currentFeature.hasGeometry() ) && !updatedFeature.geometry().equals( currentFeature.geometry() ) )
1393 {
1394 QgsGeometry geometry = updatedFeature.geometry();
1395 if ( changeGeometry( updatedFeature.id(), geometry, true ) )
1396 {
1397 hasChanged = true;
1398 updatedFeature.setGeometry( geometry );
1399 }
1400 else
1401 {
1402 QgsDebugMsgLevel( QStringLiteral( "geometry of feature %1 could not be changed." ).arg( updatedFeature.id() ), 3 );
1403 }
1404 }
1405
1406 QgsAttributes fa = updatedFeature.attributes();
1407 QgsAttributes ca = currentFeature.attributes();
1408
1409 for ( int attr = 0; attr < fa.count(); ++attr )
1410 {
1411 if ( !qgsVariantEqual( fa.at( attr ), ca.at( attr ) ) )
1412 {
1413 if ( changeAttributeValue( updatedFeature.id(), attr, fa.at( attr ), ca.at( attr ), true ) )
1414 {
1415 hasChanged = true;
1416 }
1417 else
1418 {
1419 QgsDebugMsgLevel( QStringLiteral( "attribute %1 of feature %2 could not be changed." ).arg( attr ).arg( updatedFeature.id() ), 3 );
1420 hasError = true;
1421 }
1422 }
1423 }
1424 if ( hasChanged && !mDefaultValueOnUpdateFields.isEmpty() && !skipDefaultValues )
1425 updateDefaultValues( updatedFeature.id(), updatedFeature );
1426
1427 return !hasError;
1428 }
1429 else
1430 {
1431 QgsDebugMsgLevel( QStringLiteral( "feature %1 could not be retrieved" ).arg( updatedFeature.id() ), 3 );
1432 return false;
1433 }
1434}
1435
1436
1437bool QgsVectorLayer::insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex )
1438{
1440
1441 if ( !isValid() || !mEditBuffer || !mDataProvider )
1442 return false;
1443
1444 QgsVectorLayerEditUtils utils( this );
1445 bool result = utils.insertVertex( x, y, atFeatureId, beforeVertex );
1446 if ( result )
1447 updateExtents();
1448 return result;
1449}
1450
1451
1452bool QgsVectorLayer::insertVertex( const QgsPoint &point, QgsFeatureId atFeatureId, int beforeVertex )
1453{
1455
1456 if ( !isValid() || !mEditBuffer || !mDataProvider )
1457 return false;
1458
1459 QgsVectorLayerEditUtils utils( this );
1460 bool result = utils.insertVertex( point, atFeatureId, beforeVertex );
1461 if ( result )
1462 updateExtents();
1463 return result;
1464}
1465
1466
1467bool QgsVectorLayer::moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex )
1468{
1470
1471 if ( !isValid() || !mEditBuffer || !mDataProvider )
1472 return false;
1473
1474 QgsVectorLayerEditUtils utils( this );
1475 bool result = utils.moveVertex( x, y, atFeatureId, atVertex );
1476
1477 if ( result )
1478 updateExtents();
1479 return result;
1480}
1481
1482bool QgsVectorLayer::moveVertex( const QgsPoint &p, QgsFeatureId atFeatureId, int atVertex )
1483{
1485
1486 if ( !isValid() || !mEditBuffer || !mDataProvider )
1487 return false;
1488
1489 QgsVectorLayerEditUtils utils( this );
1490 bool result = utils.moveVertex( p, atFeatureId, atVertex );
1491
1492 if ( result )
1493 updateExtents();
1494 return result;
1495}
1496
1498{
1500
1501 if ( !isValid() || !mEditBuffer || !mDataProvider )
1503
1504 QgsVectorLayerEditUtils utils( this );
1505 Qgis::VectorEditResult result = utils.deleteVertex( featureId, vertex );
1506
1507 if ( result == Qgis::VectorEditResult::Success )
1508 updateExtents();
1509 return result;
1510}
1511
1512
1514{
1516
1517 if ( !isValid() || !mDataProvider || !( mDataProvider->capabilities() & Qgis::VectorProviderCapability::DeleteFeatures ) )
1518 {
1519 return false;
1520 }
1521
1522 if ( !isEditable() )
1523 {
1524 return false;
1525 }
1526
1527 int deleted = 0;
1528 int count = mSelectedFeatureIds.size();
1529 // Make a copy since deleteFeature modifies mSelectedFeatureIds
1530 QgsFeatureIds selectedFeatures( mSelectedFeatureIds );
1531 for ( QgsFeatureId fid : std::as_const( selectedFeatures ) )
1532 {
1533 deleted += deleteFeature( fid, context ); // removes from selection
1534 }
1535
1537 updateExtents();
1538
1539 if ( deletedCount )
1540 {
1541 *deletedCount = deleted;
1542 }
1543
1544 return deleted == count;
1545}
1546
1547static const QgsPointSequence vectorPointXY2pointSequence( const QVector<QgsPointXY> &points )
1548{
1549 QgsPointSequence pts;
1550 pts.reserve( points.size() );
1551 QVector<QgsPointXY>::const_iterator it = points.constBegin();
1552 while ( it != points.constEnd() )
1553 {
1554 pts.append( QgsPoint( *it ) );
1555 ++it;
1556 }
1557 return pts;
1558}
1559Qgis::GeometryOperationResult QgsVectorLayer::addRing( const QVector<QgsPointXY> &ring, QgsFeatureId *featureId )
1560{
1562
1563 return addRing( vectorPointXY2pointSequence( ring ), featureId );
1564}
1565
1567{
1569
1570 if ( !isValid() || !mEditBuffer || !mDataProvider )
1572
1573 QgsVectorLayerEditUtils utils( this );
1575
1576 //first try with selected features
1577 if ( !mSelectedFeatureIds.isEmpty() )
1578 {
1579 result = utils.addRing( ring, mSelectedFeatureIds, featureId );
1580 }
1581
1583 {
1584 //try with all intersecting features
1585 result = utils.addRing( ring, QgsFeatureIds(), featureId );
1586 }
1587
1588 return result;
1589}
1590
1592{
1594
1595 if ( !isValid() || !mEditBuffer || !mDataProvider )
1596 {
1597 delete ring;
1599 }
1600
1601 if ( !ring )
1602 {
1604 }
1605
1606 if ( !ring->isClosed() )
1607 {
1608 delete ring;
1610 }
1611
1612 QgsVectorLayerEditUtils utils( this );
1614
1615 //first try with selected features
1616 if ( !mSelectedFeatureIds.isEmpty() )
1617 {
1618 result = utils.addRing( static_cast< QgsCurve * >( ring->clone() ), mSelectedFeatureIds, featureId );
1619 }
1620
1622 {
1623 //try with all intersecting features
1624 result = utils.addRing( static_cast< QgsCurve * >( ring->clone() ), QgsFeatureIds(), featureId );
1625 }
1626
1627 delete ring;
1628 return result;
1629}
1630
1632{
1634
1635 QgsPointSequence pts;
1636 pts.reserve( points.size() );
1637 for ( QList<QgsPointXY>::const_iterator it = points.constBegin(); it != points.constEnd() ; ++it )
1638 {
1639 pts.append( QgsPoint( *it ) );
1640 }
1641 return addPart( pts );
1642}
1643
1644#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1645Qgis::GeometryOperationResult QgsVectorLayer::addPart( const QVector<QgsPointXY> &points )
1646{
1648
1649 return addPart( vectorPointXY2pointSequence( points ) );
1650}
1651#endif
1652
1654{
1656
1657 if ( !isValid() || !mEditBuffer || !mDataProvider )
1659
1660 //number of selected features must be 1
1661
1662 if ( mSelectedFeatureIds.empty() )
1663 {
1664 QgsDebugMsgLevel( QStringLiteral( "Number of selected features <1" ), 3 );
1666 }
1667 else if ( mSelectedFeatureIds.size() > 1 )
1668 {
1669 QgsDebugMsgLevel( QStringLiteral( "Number of selected features >1" ), 3 );
1671 }
1672
1673 QgsVectorLayerEditUtils utils( this );
1674 Qgis::GeometryOperationResult result = utils.addPart( points, *mSelectedFeatureIds.constBegin() );
1675
1677 updateExtents();
1678 return result;
1679}
1680
1682{
1684
1685 if ( !isValid() || !mEditBuffer || !mDataProvider )
1687
1688 //number of selected features must be 1
1689
1690 if ( mSelectedFeatureIds.empty() )
1691 {
1692 QgsDebugMsgLevel( QStringLiteral( "Number of selected features <1" ), 3 );
1694 }
1695 else if ( mSelectedFeatureIds.size() > 1 )
1696 {
1697 QgsDebugMsgLevel( QStringLiteral( "Number of selected features >1" ), 3 );
1699 }
1700
1701 QgsVectorLayerEditUtils utils( this );
1702 Qgis::GeometryOperationResult result = utils.addPart( ring, *mSelectedFeatureIds.constBegin() );
1703
1705 updateExtents();
1706 return result;
1707}
1708
1709// TODO QGIS 4.0 -- this should return Qgis::GeometryOperationResult, not int
1710int QgsVectorLayer::translateFeature( QgsFeatureId featureId, double dx, double dy )
1711{
1713
1714 if ( !isValid() || !mEditBuffer || !mDataProvider )
1715 return static_cast< int >( Qgis::GeometryOperationResult::LayerNotEditable );
1716
1717 QgsVectorLayerEditUtils utils( this );
1718 int result = utils.translateFeature( featureId, dx, dy );
1719
1720 if ( result == static_cast< int >( Qgis::GeometryOperationResult::Success ) )
1721 updateExtents();
1722 return result;
1723}
1724
1725Qgis::GeometryOperationResult QgsVectorLayer::splitParts( const QVector<QgsPointXY> &splitLine, bool topologicalEditing )
1726{
1728
1729 return splitParts( vectorPointXY2pointSequence( splitLine ), topologicalEditing );
1730}
1731
1733{
1735
1736 if ( !isValid() || !mEditBuffer || !mDataProvider )
1738
1739 QgsVectorLayerEditUtils utils( this );
1740 return utils.splitParts( splitLine, topologicalEditing );
1741}
1742
1743Qgis::GeometryOperationResult QgsVectorLayer::splitFeatures( const QVector<QgsPointXY> &splitLine, bool topologicalEditing )
1744{
1746
1747 return splitFeatures( vectorPointXY2pointSequence( splitLine ), topologicalEditing );
1748}
1749
1751{
1753
1754 QgsLineString splitLineString( splitLine );
1755 QgsPointSequence topologyTestPoints;
1756 bool preserveCircular = false;
1757 return splitFeatures( &splitLineString, topologyTestPoints, preserveCircular, topologicalEditing );
1758}
1759
1760Qgis::GeometryOperationResult QgsVectorLayer::splitFeatures( const QgsCurve *curve, QgsPointSequence &topologyTestPoints, bool preserveCircular, bool topologicalEditing )
1761{
1763
1764 if ( !isValid() || !mEditBuffer || !mDataProvider )
1766
1767 QgsVectorLayerEditUtils utils( this );
1768 return utils.splitFeatures( curve, topologyTestPoints, preserveCircular, topologicalEditing );
1769}
1770
1772{
1774
1775 if ( !isValid() || !mEditBuffer || !mDataProvider )
1776 return -1;
1777
1778 QgsVectorLayerEditUtils utils( this );
1779 return utils.addTopologicalPoints( geom );
1780}
1781
1788
1790{
1792
1793 if ( !isValid() || !mEditBuffer || !mDataProvider )
1794 return -1;
1795
1796 QgsVectorLayerEditUtils utils( this );
1797 return utils.addTopologicalPoints( p );
1798}
1799
1801{
1803
1804 if ( !mValid || !mEditBuffer || !mDataProvider )
1805 return -1;
1806
1807 QgsVectorLayerEditUtils utils( this );
1808 return utils.addTopologicalPoints( ps );
1809}
1810
1812{
1814
1815 if ( mLabeling == labeling )
1816 return;
1817
1818 delete mLabeling;
1819 mLabeling = labeling;
1820}
1821
1823{
1825
1826 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
1827 return project()->startEditing( this );
1828
1829 if ( !isValid() || !mDataProvider )
1830 {
1831 return false;
1832 }
1833
1834 // allow editing if provider supports any of the capabilities
1835 if ( !supportsEditing() )
1836 {
1837 return false;
1838 }
1839
1840 if ( mEditBuffer )
1841 {
1842 // editing already underway
1843 return false;
1844 }
1845
1846 mDataProvider->enterUpdateMode();
1847
1848 emit beforeEditingStarted();
1849
1850 createEditBuffer();
1851
1852 updateFields();
1853
1854 emit editingStarted();
1855
1856 return true;
1857}
1858
1860{
1862
1863 if ( mDataProvider )
1864 mDataProvider->setTransformContext( transformContext );
1865}
1866
1873
1875{
1877
1878 if ( mRenderer )
1879 if ( !mRenderer->accept( visitor ) )
1880 return false;
1881
1882 if ( mLabeling )
1883 if ( !mLabeling->accept( visitor ) )
1884 return false;
1885
1886 return true;
1887}
1888
1889bool QgsVectorLayer::readXml( const QDomNode &layer_node, QgsReadWriteContext &context )
1890{
1892
1893 QgsDebugMsgLevel( QStringLiteral( "Datasource in QgsVectorLayer::readXml: %1" ).arg( mDataSource.toLocal8Bit().data() ), 3 );
1894
1895 //process provider key
1896 QDomNode pkeyNode = layer_node.namedItem( QStringLiteral( "provider" ) );
1897
1898 if ( pkeyNode.isNull() )
1899 {
1900 mProviderKey.clear();
1901 }
1902 else
1903 {
1904 QDomElement pkeyElt = pkeyNode.toElement();
1905 mProviderKey = pkeyElt.text();
1906 }
1907
1908 // determine type of vector layer
1909 if ( !mProviderKey.isNull() )
1910 {
1911 // if the provider string isn't empty, then we successfully
1912 // got the stored provider
1913 }
1914 else if ( mDataSource.contains( QLatin1String( "dbname=" ) ) )
1915 {
1916 mProviderKey = QStringLiteral( "postgres" );
1917 }
1918 else
1919 {
1920 mProviderKey = QStringLiteral( "ogr" );
1921 }
1922
1923 const QDomElement elem = layer_node.toElement();
1925
1926 mDataSourceReadOnly = mReadFlags & QgsMapLayer::FlagForceReadOnly;
1928
1929 if ( ( mReadFlags & QgsMapLayer::FlagDontResolveLayers ) || !setDataProvider( mProviderKey, options, flags ) )
1930 {
1932 {
1933 QgsDebugError( QStringLiteral( "Could not set data provider for layer %1" ).arg( publicSource() ) );
1934 }
1935
1936 // for invalid layer sources, we fallback to stored wkbType if available
1937 if ( elem.hasAttribute( QStringLiteral( "wkbType" ) ) )
1938 mWkbType = qgsEnumKeyToValue( elem.attribute( QStringLiteral( "wkbType" ) ), mWkbType );
1939 }
1940
1941 QDomElement pkeyElem = pkeyNode.toElement();
1942 if ( !pkeyElem.isNull() )
1943 {
1944 QString encodingString = pkeyElem.attribute( QStringLiteral( "encoding" ) );
1945 if ( mDataProvider && !encodingString.isEmpty() )
1946 {
1947 mDataProvider->setEncoding( encodingString );
1948 }
1949 }
1950
1951 // load vector joins - does not resolve references to layers yet
1952 mJoinBuffer->readXml( layer_node );
1953
1954 updateFields();
1955
1956 // If style doesn't include a legend, we'll need to make a default one later...
1957 mSetLegendFromStyle = false;
1958
1959 QString errorMsg;
1960 if ( !readSymbology( layer_node, errorMsg, context ) )
1961 {
1962 return false;
1963 }
1964
1965 readStyleManager( layer_node );
1966
1967 QDomNode depsNode = layer_node.namedItem( QStringLiteral( "dataDependencies" ) );
1968 QDomNodeList depsNodes = depsNode.childNodes();
1969 QSet<QgsMapLayerDependency> sources;
1970 for ( int i = 0; i < depsNodes.count(); i++ )
1971 {
1972 QString source = depsNodes.at( i ).toElement().attribute( QStringLiteral( "id" ) );
1973 sources << QgsMapLayerDependency( source );
1974 }
1975 setDependencies( sources );
1976
1977 if ( !mSetLegendFromStyle )
1979
1980 // read extent
1982 {
1983 mReadExtentFromXml = true;
1984 }
1985 if ( mReadExtentFromXml )
1986 {
1987 const QDomNode extentNode = layer_node.namedItem( QStringLiteral( "extent" ) );
1988 if ( !extentNode.isNull() )
1989 {
1990 mXmlExtent2D = QgsXmlUtils::readRectangle( extentNode.toElement() );
1991 }
1992 const QDomNode extent3DNode = layer_node.namedItem( QStringLiteral( "extent3D" ) );
1993 if ( !extent3DNode.isNull() )
1994 {
1995 mXmlExtent3D = QgsXmlUtils::readBox3D( extent3DNode.toElement() );
1996 }
1997 }
1998
1999 // auxiliary layer
2000 const QDomNode asNode = layer_node.namedItem( QStringLiteral( "auxiliaryLayer" ) );
2001 const QDomElement asElem = asNode.toElement();
2002 if ( !asElem.isNull() )
2003 {
2004 mAuxiliaryLayerKey = asElem.attribute( QStringLiteral( "key" ) );
2005 }
2006
2007 // QGIS Server WMS Dimensions
2008 mServerProperties->readXml( layer_node );
2009
2010 return isValid(); // should be true if read successfully
2011
2012} // void QgsVectorLayer::readXml
2013
2014
2015void QgsVectorLayer::setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider,
2017{
2019
2020 Qgis::GeometryType geomType = geometryType();
2021
2022 mDataSource = dataSource;
2023 setName( baseName );
2024 setDataProvider( provider, options, flags );
2025
2026 if ( !isValid() )
2027 {
2028 return;
2029 }
2030
2031 // Always set crs
2033
2034 bool loadDefaultStyleFlag = false;
2036 {
2037 loadDefaultStyleFlag = true;
2038 }
2039
2040 // reset style if loading default style, style is missing, or geometry type is has changed (and layer is valid)
2041 if ( !renderer() || !legend() || ( isValid() && geomType != geometryType() ) || loadDefaultStyleFlag )
2042 {
2043 std::unique_ptr< QgsScopedRuntimeProfile > profile;
2044 if ( QgsApplication::profiler()->groupIsActive( QStringLiteral( "projectload" ) ) )
2045 profile = std::make_unique< QgsScopedRuntimeProfile >( tr( "Load layer style" ), QStringLiteral( "projectload" ) );
2046
2047 bool defaultLoadedFlag = false;
2048
2049 // defer style changed signal until we've set the renderer, labeling, everything.
2050 // we don't want multiple signals!
2051 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
2052
2053 // need to check whether the default style included a legend, and if not, we need to make a default legend
2054 // later...
2055 mSetLegendFromStyle = false;
2056
2057 // first check if there is a default style / propertysheet defined
2058 // for this layer and if so apply it
2059 // this should take precedence over all
2060 if ( !defaultLoadedFlag && loadDefaultStyleFlag )
2061 {
2062 loadDefaultStyle( defaultLoadedFlag );
2063 }
2064
2065 if ( loadDefaultStyleFlag && !defaultLoadedFlag && isSpatial() && mDataProvider->capabilities() & Qgis::VectorProviderCapability::CreateRenderer )
2066 {
2067 // if we didn't load a default style for this layer, try to create a renderer directly from the data provider
2068 std::unique_ptr< QgsFeatureRenderer > defaultRenderer( mDataProvider->createRenderer() );
2069 if ( defaultRenderer )
2070 {
2071 defaultLoadedFlag = true;
2072 setRenderer( defaultRenderer.release() );
2073 }
2074 }
2075
2076 // if the default style failed to load or was disabled use some very basic defaults
2077 if ( !defaultLoadedFlag )
2078 {
2079 // add single symbol renderer for spatial layers
2081 }
2082
2083 if ( !mSetLegendFromStyle )
2085
2087 {
2088 std::unique_ptr< QgsAbstractVectorLayerLabeling > defaultLabeling( mDataProvider->createLabeling() );
2089 if ( defaultLabeling )
2090 {
2091 setLabeling( defaultLabeling.release() );
2092 setLabelsEnabled( true );
2093 }
2094 }
2095
2096 styleChangedSignalBlocker.release();
2098 }
2099}
2100
2101QString QgsVectorLayer::loadDefaultStyle( bool &resultFlag )
2102{
2104
2105 // first try to load a user-defined default style - this should always take precedence
2106 QString styleXml = QgsMapLayer::loadDefaultStyle( resultFlag );
2107
2108 if ( resultFlag )
2109 {
2110 // Try to load all stored styles from DB
2111 if ( mLoadAllStoredStyle && mDataProvider && mDataProvider->styleStorageCapabilities().testFlag( Qgis::ProviderStyleStorageCapability::LoadFromDatabase ) )
2112 {
2113 QStringList ids, names, descriptions;
2114 QString errorMessage;
2115 // Get the number of styles related to current layer.
2116 const int relatedStylesCount { listStylesInDatabase( ids, names, descriptions, errorMessage ) };
2117 Q_ASSERT( ids.count() == names.count() );
2118 const QString currentStyleName { mStyleManager->currentStyle() };
2119 for ( int i = 0; i < relatedStylesCount; ++i )
2120 {
2121 if ( names.at( i ) == currentStyleName )
2122 {
2123 continue;
2124 }
2125 errorMessage.clear();
2126 const QString styleXml { getStyleFromDatabase( ids.at( i ), errorMessage ) };
2127 if ( ! styleXml.isEmpty() && errorMessage.isEmpty() )
2128 {
2129 mStyleManager->addStyle( names.at( i ), QgsMapLayerStyle( styleXml ) );
2130 }
2131 else
2132 {
2133 QgsDebugMsgLevel( QStringLiteral( "Error retrieving style %1 from DB: %2" ).arg( ids.at( i ), errorMessage ), 2 );
2134 }
2135 }
2136 }
2137 return styleXml ;
2138 }
2139
2141 {
2142 // otherwise try to create a renderer directly from the data provider
2143 std::unique_ptr< QgsFeatureRenderer > defaultRenderer( mDataProvider->createRenderer() );
2144 if ( defaultRenderer )
2145 {
2146 resultFlag = true;
2147 setRenderer( defaultRenderer.release() );
2148 return QString();
2149 }
2150 }
2151
2152 return QString();
2153}
2154
2155bool QgsVectorLayer::setDataProvider( QString const &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags )
2156{
2158
2159 mProviderKey = provider;
2160 delete mDataProvider;
2161
2162 // For Postgres provider primary key unicity is tested at construction time,
2163 // so it has to be set before initializing the provider,
2164 // this manipulation is necessary to preserve default behavior when
2165 // "trust layer metadata" project level option is set and checkPrimaryKeyUnicity
2166 // was not explicitly passed in the uri
2167 if ( provider.compare( QLatin1String( "postgres" ) ) == 0 )
2168 {
2169 const QString checkUnicityKey { QStringLiteral( "checkPrimaryKeyUnicity" ) };
2171 if ( ! uri.hasParam( checkUnicityKey ) )
2172 {
2173 uri.setParam( checkUnicityKey, mReadExtentFromXml ? "0" : "1" );
2174 mDataSource = uri.uri( false );
2175 }
2176 }
2177
2178 std::unique_ptr< QgsScopedRuntimeProfile > profile;
2179 if ( QgsApplication::profiler()->groupIsActive( QStringLiteral( "projectload" ) ) )
2180 profile = std::make_unique< QgsScopedRuntimeProfile >( tr( "Create %1 provider" ).arg( provider ), QStringLiteral( "projectload" ) );
2181
2182 if ( mPreloadedProvider )
2183 mDataProvider = qobject_cast< QgsVectorDataProvider * >( mPreloadedProvider.release() );
2184 else
2185 mDataProvider = qobject_cast<QgsVectorDataProvider *>( QgsProviderRegistry::instance()->createProvider( provider, mDataSource, options, flags ) );
2186
2187 if ( !mDataProvider )
2188 {
2189 setValid( false );
2190 QgsDebugMsgLevel( QStringLiteral( "Unable to get data provider" ), 2 );
2191 return false;
2192 }
2193
2194 mDataProvider->setParent( this );
2195 connect( mDataProvider, &QgsVectorDataProvider::raiseError, this, &QgsVectorLayer::raiseError );
2196
2197 QgsDebugMsgLevel( QStringLiteral( "Instantiated the data provider plugin" ), 2 );
2198
2199 setValid( mDataProvider->isValid() );
2200 if ( !isValid() )
2201 {
2202 QgsDebugMsgLevel( QStringLiteral( "Invalid provider plugin %1" ).arg( QString( mDataSource.toUtf8() ) ), 2 );
2203 return false;
2204 }
2205
2206 if ( profile )
2207 profile->switchTask( tr( "Read layer metadata" ) );
2209 {
2210 // we combine the provider metadata with the layer's existing metadata, so as not to reset any user customizations to the metadata
2211 // back to the default if a layer's data source is changed
2212 QgsLayerMetadata newMetadata = mDataProvider->layerMetadata();
2213 // this overwrites the provider metadata with any properties which are non-empty from the existing layer metadata
2214 newMetadata.combine( &mMetadata );
2215
2216 setMetadata( newMetadata );
2217 QgsDebugMsgLevel( QStringLiteral( "Set Data provider QgsLayerMetadata identifier[%1]" ).arg( metadata().identifier() ), 4 );
2218 }
2219
2220 // TODO: Check if the provider has the capability to send fullExtentCalculated
2221 connect( mDataProvider, &QgsVectorDataProvider::fullExtentCalculated, this, [this] { updateExtents(); } );
2222
2223 // get and store the feature type
2224 mWkbType = mDataProvider->wkbType();
2225
2226 // before we update the layer fields from the provider, we first copy any default set alias and
2227 // editor widget config from the data provider fields, if present
2228 const QgsFields providerFields = mDataProvider->fields();
2229 for ( const QgsField &field : providerFields )
2230 {
2231 // we only copy defaults from the provider if we aren't overriding any configuration made in the layer
2232 if ( !field.editorWidgetSetup().isNull() && mFieldWidgetSetups.value( field.name() ).isNull() )
2233 {
2234 mFieldWidgetSetups[ field.name() ] = field.editorWidgetSetup();
2235 }
2236 if ( !field.alias().isEmpty() && mAttributeAliasMap.value( field.name() ).isEmpty() )
2237 {
2238 mAttributeAliasMap[ field.name() ] = field.alias();
2239 }
2240 if ( !mAttributeSplitPolicy.contains( field.name() ) )
2241 {
2242 mAttributeSplitPolicy[ field.name() ] = field.splitPolicy();
2243 }
2244 if ( !mAttributeDuplicatePolicy.contains( field.name() ) )
2245 {
2246 mAttributeDuplicatePolicy[ field.name() ] = field.duplicatePolicy();
2247 }
2248 }
2249
2250 if ( profile )
2251 profile->switchTask( tr( "Read layer fields" ) );
2252 updateFields();
2253
2254 if ( mProviderKey == QLatin1String( "postgres" ) )
2255 {
2256 // update datasource from data provider computed one
2257 mDataSource = mDataProvider->dataSourceUri( false );
2258
2259 QgsDebugMsgLevel( QStringLiteral( "Beautifying layer name %1" ).arg( name() ), 3 );
2260
2261 // adjust the display name for postgres layers
2262 const thread_local QRegularExpression reg( R"lit("[^"]+"\."([^"] + )"( \‍([^)]+\))?)lit" );
2263 const QRegularExpressionMatch match = reg.match( name() );
2264 if ( match.hasMatch() )
2265 {
2266 QStringList stuff = match.capturedTexts();
2267 QString lName = stuff[1];
2268
2269 const QMap<QString, QgsMapLayer *> &layers = QgsProject::instance()->mapLayers(); // skip-keyword-check
2270
2271 QMap<QString, QgsMapLayer *>::const_iterator it;
2272 for ( it = layers.constBegin(); it != layers.constEnd() && ( *it )->name() != lName; ++it )
2273 ;
2274
2275 if ( it != layers.constEnd() && stuff.size() > 2 )
2276 {
2277 lName += '.' + stuff[2].mid( 2, stuff[2].length() - 3 );
2278 }
2279
2280 if ( !lName.isEmpty() )
2281 setName( lName );
2282 }
2283 QgsDebugMsgLevel( QStringLiteral( "Beautified layer name %1" ).arg( name() ), 3 );
2284 }
2285 else if ( mProviderKey == QLatin1String( "osm" ) )
2286 {
2287 // make sure that the "observer" has been removed from URI to avoid crashes
2288 mDataSource = mDataProvider->dataSourceUri();
2289 }
2290 else if ( provider == QLatin1String( "ogr" ) )
2291 {
2292 // make sure that the /vsigzip or /vsizip is added to uri, if applicable
2293 mDataSource = mDataProvider->dataSourceUri();
2294 if ( mDataSource.right( 10 ) == QLatin1String( "|layerid=0" ) )
2295 mDataSource.chop( 10 );
2296 }
2297 else if ( provider == QLatin1String( "memory" ) )
2298 {
2299 // required so that source differs between memory layers
2300 mDataSource = mDataSource + QStringLiteral( "&uid=%1" ).arg( QUuid::createUuid().toString() );
2301 }
2302 else if ( provider == QLatin1String( "hana" ) )
2303 {
2304 // update datasource from data provider computed one
2305 mDataSource = mDataProvider->dataSourceUri( false );
2306 }
2307
2308 connect( mDataProvider, &QgsVectorDataProvider::dataChanged, this, &QgsVectorLayer::emitDataChanged );
2310
2311 return true;
2312} // QgsVectorLayer:: setDataProvider
2313
2314
2315
2316
2317/* virtual */
2318bool QgsVectorLayer::writeXml( QDomNode &layer_node,
2319 QDomDocument &document,
2320 const QgsReadWriteContext &context ) const
2321{
2323
2324 // first get the layer element so that we can append the type attribute
2325
2326 QDomElement mapLayerNode = layer_node.toElement();
2327
2328 if ( mapLayerNode.isNull() || ( "maplayer" != mapLayerNode.nodeName() ) )
2329 {
2330 QgsDebugMsgLevel( QStringLiteral( "can't find <maplayer>" ), 2 );
2331 return false;
2332 }
2333
2334 mapLayerNode.setAttribute( QStringLiteral( "type" ), QgsMapLayerFactory::typeToString( Qgis::LayerType::Vector ) );
2335
2336 // set the geometry type
2337 mapLayerNode.setAttribute( QStringLiteral( "geometry" ), QgsWkbTypes::geometryDisplayString( geometryType() ) );
2338 mapLayerNode.setAttribute( QStringLiteral( "wkbType" ), qgsEnumValueToKey( wkbType() ) );
2339
2340 // add provider node
2341 if ( mDataProvider )
2342 {
2343 QDomElement provider = document.createElement( QStringLiteral( "provider" ) );
2344 provider.setAttribute( QStringLiteral( "encoding" ), mDataProvider->encoding() );
2345 QDomText providerText = document.createTextNode( providerType() );
2346 provider.appendChild( providerText );
2347 layer_node.appendChild( provider );
2348 }
2349
2350 //save joins
2351 mJoinBuffer->writeXml( layer_node, document );
2352
2353 // dependencies
2354 QDomElement dependenciesElement = document.createElement( QStringLiteral( "layerDependencies" ) );
2355 const auto constDependencies = dependencies();
2356 for ( const QgsMapLayerDependency &dep : constDependencies )
2357 {
2359 continue;
2360 QDomElement depElem = document.createElement( QStringLiteral( "layer" ) );
2361 depElem.setAttribute( QStringLiteral( "id" ), dep.layerId() );
2362 dependenciesElement.appendChild( depElem );
2363 }
2364 layer_node.appendChild( dependenciesElement );
2365
2366 // change dependencies
2367 QDomElement dataDependenciesElement = document.createElement( QStringLiteral( "dataDependencies" ) );
2368 for ( const QgsMapLayerDependency &dep : constDependencies )
2369 {
2370 if ( dep.type() != QgsMapLayerDependency::DataDependency )
2371 continue;
2372 QDomElement depElem = document.createElement( QStringLiteral( "layer" ) );
2373 depElem.setAttribute( QStringLiteral( "id" ), dep.layerId() );
2374 dataDependenciesElement.appendChild( depElem );
2375 }
2376 layer_node.appendChild( dataDependenciesElement );
2377
2378 // save expression fields
2379 mExpressionFieldBuffer->writeXml( layer_node, document );
2380
2381 writeStyleManager( layer_node, document );
2382
2383 // auxiliary layer
2384 QDomElement asElem = document.createElement( QStringLiteral( "auxiliaryLayer" ) );
2385 if ( mAuxiliaryLayer )
2386 {
2387 const QString pkField = mAuxiliaryLayer->joinInfo().targetFieldName();
2388 asElem.setAttribute( QStringLiteral( "key" ), pkField );
2389 }
2390 layer_node.appendChild( asElem );
2391
2392 // save QGIS Server properties (WMS Dimension, metadata URLS...)
2393 mServerProperties->writeXml( layer_node, document );
2394
2395 // renderer specific settings
2396 QString errorMsg;
2397 return writeSymbology( layer_node, document, errorMsg, context );
2398}
2399
2400QString QgsVectorLayer::encodedSource( const QString &source, const QgsReadWriteContext &context ) const
2401{
2403
2404 if ( providerType() == QLatin1String( "memory" ) )
2405 {
2406 // Refetch the source from the provider, because adding fields actually changes the source for this provider.
2407 return dataProvider()->dataSourceUri();
2408 }
2409
2411}
2412
2413QString QgsVectorLayer::decodedSource( const QString &source, const QString &provider, const QgsReadWriteContext &context ) const
2414{
2416
2417 return QgsProviderRegistry::instance()->relativeToAbsoluteUri( provider, source, context );
2418}
2419
2420
2421
2429
2430
2431bool QgsVectorLayer::readSymbology( const QDomNode &layerNode, QString &errorMessage,
2433{
2435
2436 if ( categories.testFlag( Fields ) )
2437 {
2438 if ( !mExpressionFieldBuffer )
2439 mExpressionFieldBuffer = new QgsExpressionFieldBuffer();
2440 mExpressionFieldBuffer->readXml( layerNode );
2441
2442 updateFields();
2443 }
2444
2445 if ( categories.testFlag( Relations ) )
2446 {
2447 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Relations" ) );
2448
2449 // Restore referenced layers: relations where "this" is the child layer (the referencing part, that holds the FK)
2450 QDomNodeList referencedLayersNodeList = layerNode.toElement().elementsByTagName( QStringLiteral( "referencedLayers" ) );
2451 if ( referencedLayersNodeList.size() > 0 )
2452 {
2453 const QDomNodeList relationNodes { referencedLayersNodeList.at( 0 ).childNodes() };
2454 for ( int i = 0; i < relationNodes.length(); ++i )
2455 {
2456 const QDomElement relationElement = relationNodes.at( i ).toElement();
2457
2458 mWeakRelations.push_back( QgsWeakRelation::readXml( this, QgsWeakRelation::Referencing, relationElement, context.pathResolver() ) );
2459 }
2460 }
2461
2462 // Restore referencing layers: relations where "this" is the parent layer (the referenced part where the FK points to)
2463 QDomNodeList referencingLayersNodeList = layerNode.toElement().elementsByTagName( QStringLiteral( "referencingLayers" ) );
2464 if ( referencingLayersNodeList.size() > 0 )
2465 {
2466 const QDomNodeList relationNodes { referencingLayersNodeList.at( 0 ).childNodes() };
2467 for ( int i = 0; i < relationNodes.length(); ++i )
2468 {
2469 const QDomElement relationElement = relationNodes.at( i ).toElement();
2470 mWeakRelations.push_back( QgsWeakRelation::readXml( this, QgsWeakRelation::Referenced, relationElement, context.pathResolver() ) );
2471 }
2472 }
2473 }
2474
2475 QDomElement layerElement = layerNode.toElement();
2476
2477 readCommonStyle( layerElement, context, categories );
2478
2479 readStyle( layerNode, errorMessage, context, categories );
2480
2481 if ( categories.testFlag( MapTips ) )
2482 {
2483 QDomElement mapTipElem = layerNode.namedItem( QStringLiteral( "mapTip" ) ).toElement();
2484 setMapTipTemplate( mapTipElem.text() );
2485 setMapTipsEnabled( mapTipElem.attribute( QStringLiteral( "enabled" ), QStringLiteral( "1" ) ).toInt() == 1 );
2486 }
2487
2488 if ( categories.testFlag( LayerConfiguration ) )
2489 mDisplayExpression = layerNode.namedItem( QStringLiteral( "previewExpression" ) ).toElement().text();
2490
2491 // Try to migrate pre QGIS 3.0 display field property
2492 QString displayField = layerNode.namedItem( QStringLiteral( "displayfield" ) ).toElement().text();
2493 if ( mFields.lookupField( displayField ) < 0 )
2494 {
2495 // if it's not a field, it's a maptip
2496 if ( mMapTipTemplate.isEmpty() && categories.testFlag( MapTips ) )
2497 mMapTipTemplate = displayField;
2498 }
2499 else
2500 {
2501 if ( mDisplayExpression.isEmpty() && categories.testFlag( LayerConfiguration ) )
2502 mDisplayExpression = QgsExpression::quotedColumnRef( displayField );
2503 }
2504
2505 // process the attribute actions
2506 if ( categories.testFlag( Actions ) )
2507 mActions->readXml( layerNode );
2508
2509 if ( categories.testFlag( Fields ) )
2510 {
2511 // IMPORTANT - we don't clear mAttributeAliasMap here, as it may contain aliases which are coming direct
2512 // from the data provider. Instead we leave any existing aliases and only overwrite them if the style
2513 // has a specific value for that field's alias
2514 QDomNode aliasesNode = layerNode.namedItem( QStringLiteral( "aliases" ) );
2515 if ( !aliasesNode.isNull() )
2516 {
2517 QDomElement aliasElem;
2518
2519 QDomNodeList aliasNodeList = aliasesNode.toElement().elementsByTagName( QStringLiteral( "alias" ) );
2520 for ( int i = 0; i < aliasNodeList.size(); ++i )
2521 {
2522 aliasElem = aliasNodeList.at( i ).toElement();
2523
2524 QString field;
2525 if ( aliasElem.hasAttribute( QStringLiteral( "field" ) ) )
2526 {
2527 field = aliasElem.attribute( QStringLiteral( "field" ) );
2528 }
2529 else
2530 {
2531 int index = aliasElem.attribute( QStringLiteral( "index" ) ).toInt();
2532
2533 if ( index >= 0 && index < fields().count() )
2534 field = fields().at( index ).name();
2535 }
2536
2537 QString alias;
2538
2539 if ( !aliasElem.attribute( QStringLiteral( "name" ) ).isEmpty() )
2540 {
2541 //if it has alias
2542 alias = context.projectTranslator()->translate( QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ), aliasElem.attribute( QStringLiteral( "name" ) ) );
2543 QgsDebugMsgLevel( "context" + QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ) + " source " + aliasElem.attribute( QStringLiteral( "name" ) ), 3 );
2544 }
2545 else
2546 {
2547 //if it has no alias, it should be the fields translation
2548 alias = context.projectTranslator()->translate( QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ), field );
2549 QgsDebugMsgLevel( "context" + QStringLiteral( "project:layers:%1:fieldaliases" ).arg( layerNode.namedItem( QStringLiteral( "id" ) ).toElement().text() ) + " source " + field, 3 );
2550 //if it gets the exact field value, there has been no translation (or not even translation loaded) - so no alias should be generated;
2551 if ( alias == aliasElem.attribute( QStringLiteral( "field" ) ) )
2552 alias.clear();
2553 }
2554
2555 QgsDebugMsgLevel( "field " + field + " origalias " + aliasElem.attribute( QStringLiteral( "name" ) ) + " trans " + alias, 3 );
2556 mAttributeAliasMap.insert( field, alias );
2557 }
2558 }
2559
2560 // IMPORTANT - we don't clear mAttributeSplitPolicy here, as it may contain policies which are coming direct
2561 // from the data provider. Instead we leave any existing policies and only overwrite them if the style
2562 // has a specific value for that field's policy
2563 const QDomNode splitPoliciesNode = layerNode.namedItem( QStringLiteral( "splitPolicies" ) );
2564 if ( !splitPoliciesNode.isNull() )
2565 {
2566 const QDomNodeList splitPolicyNodeList = splitPoliciesNode.toElement().elementsByTagName( QStringLiteral( "policy" ) );
2567 for ( int i = 0; i < splitPolicyNodeList.size(); ++i )
2568 {
2569 const QDomElement splitPolicyElem = splitPolicyNodeList.at( i ).toElement();
2570 const QString field = splitPolicyElem.attribute( QStringLiteral( "field" ) );
2571 const Qgis::FieldDomainSplitPolicy policy = qgsEnumKeyToValue( splitPolicyElem.attribute( QStringLiteral( "policy" ) ), Qgis::FieldDomainSplitPolicy::Duplicate );
2572 mAttributeSplitPolicy.insert( field, policy );
2573 }
2574 }
2575
2576 // The duplicate policy is - unlike alias and split policy - never defined by the data provider, so we clear the map
2577 mAttributeDuplicatePolicy.clear();
2578 const QDomNode duplicatePoliciesNode = layerNode.namedItem( QStringLiteral( "duplicatePolicies" ) );
2579 if ( !duplicatePoliciesNode.isNull() )
2580 {
2581 const QDomNodeList duplicatePolicyNodeList = duplicatePoliciesNode.toElement().elementsByTagName( QStringLiteral( "policy" ) );
2582 for ( int i = 0; i < duplicatePolicyNodeList.size(); ++i )
2583 {
2584 const QDomElement duplicatePolicyElem = duplicatePolicyNodeList.at( i ).toElement();
2585 const QString field = duplicatePolicyElem.attribute( QStringLiteral( "field" ) );
2586 const Qgis::FieldDuplicatePolicy policy = qgsEnumKeyToValue( duplicatePolicyElem.attribute( QStringLiteral( "policy" ) ), Qgis::FieldDuplicatePolicy::Duplicate );
2587 mAttributeDuplicatePolicy.insert( field, policy );
2588 }
2589 }
2590
2591 // default expressions
2592 mDefaultExpressionMap.clear();
2593 QDomNode defaultsNode = layerNode.namedItem( QStringLiteral( "defaults" ) );
2594 if ( !defaultsNode.isNull() )
2595 {
2596 QDomNodeList defaultNodeList = defaultsNode.toElement().elementsByTagName( QStringLiteral( "default" ) );
2597 for ( int i = 0; i < defaultNodeList.size(); ++i )
2598 {
2599 QDomElement defaultElem = defaultNodeList.at( i ).toElement();
2600
2601 QString field = defaultElem.attribute( QStringLiteral( "field" ), QString() );
2602 QString expression = defaultElem.attribute( QStringLiteral( "expression" ), QString() );
2603 bool applyOnUpdate = defaultElem.attribute( QStringLiteral( "applyOnUpdate" ), QStringLiteral( "0" ) ) == QLatin1String( "1" );
2604 if ( field.isEmpty() || expression.isEmpty() )
2605 continue;
2606
2607 mDefaultExpressionMap.insert( field, QgsDefaultValue( expression, applyOnUpdate ) );
2608 }
2609 }
2610
2611 // constraints
2612 mFieldConstraints.clear();
2613 mFieldConstraintStrength.clear();
2614 QDomNode constraintsNode = layerNode.namedItem( QStringLiteral( "constraints" ) );
2615 if ( !constraintsNode.isNull() )
2616 {
2617 QDomNodeList constraintNodeList = constraintsNode.toElement().elementsByTagName( QStringLiteral( "constraint" ) );
2618 for ( int i = 0; i < constraintNodeList.size(); ++i )
2619 {
2620 QDomElement constraintElem = constraintNodeList.at( i ).toElement();
2621
2622 QString field = constraintElem.attribute( QStringLiteral( "field" ), QString() );
2623 int constraints = constraintElem.attribute( QStringLiteral( "constraints" ), QStringLiteral( "0" ) ).toInt();
2624 if ( field.isEmpty() || constraints == 0 )
2625 continue;
2626
2627 mFieldConstraints.insert( field, static_cast< QgsFieldConstraints::Constraints >( constraints ) );
2628
2629 int uniqueStrength = constraintElem.attribute( QStringLiteral( "unique_strength" ), QStringLiteral( "1" ) ).toInt();
2630 int notNullStrength = constraintElem.attribute( QStringLiteral( "notnull_strength" ), QStringLiteral( "1" ) ).toInt();
2631 int expStrength = constraintElem.attribute( QStringLiteral( "exp_strength" ), QStringLiteral( "1" ) ).toInt();
2632
2633 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintUnique ), static_cast< QgsFieldConstraints::ConstraintStrength >( uniqueStrength ) );
2634 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintNotNull ), static_cast< QgsFieldConstraints::ConstraintStrength >( notNullStrength ) );
2635 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintExpression ), static_cast< QgsFieldConstraints::ConstraintStrength >( expStrength ) );
2636 }
2637 }
2638 mFieldConstraintExpressions.clear();
2639 QDomNode constraintExpressionsNode = layerNode.namedItem( QStringLiteral( "constraintExpressions" ) );
2640 if ( !constraintExpressionsNode.isNull() )
2641 {
2642 QDomNodeList constraintNodeList = constraintExpressionsNode.toElement().elementsByTagName( QStringLiteral( "constraint" ) );
2643 for ( int i = 0; i < constraintNodeList.size(); ++i )
2644 {
2645 QDomElement constraintElem = constraintNodeList.at( i ).toElement();
2646
2647 QString field = constraintElem.attribute( QStringLiteral( "field" ), QString() );
2648 QString exp = constraintElem.attribute( QStringLiteral( "exp" ), QString() );
2649 QString desc = constraintElem.attribute( QStringLiteral( "desc" ), QString() );
2650 if ( field.isEmpty() || exp.isEmpty() )
2651 continue;
2652
2653 mFieldConstraintExpressions.insert( field, qMakePair( exp, desc ) );
2654 }
2655 }
2656
2657 updateFields();
2658 }
2659
2660 // load field configuration
2661 if ( categories.testFlag( Fields ) || categories.testFlag( Forms ) )
2662 {
2663 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Forms" ) );
2664
2665 QDomElement widgetsElem = layerNode.namedItem( QStringLiteral( "fieldConfiguration" ) ).toElement();
2666 QDomNodeList fieldConfigurationElementList = widgetsElem.elementsByTagName( QStringLiteral( "field" ) );
2667 for ( int i = 0; i < fieldConfigurationElementList.size(); ++i )
2668 {
2669 const QDomElement fieldConfigElement = fieldConfigurationElementList.at( i ).toElement();
2670 const QDomElement fieldWidgetElement = fieldConfigElement.elementsByTagName( QStringLiteral( "editWidget" ) ).at( 0 ).toElement();
2671
2672 QString fieldName = fieldConfigElement.attribute( QStringLiteral( "name" ) );
2673
2674 if ( categories.testFlag( Fields ) )
2675 mFieldConfigurationFlags[fieldName] = qgsFlagKeysToValue( fieldConfigElement.attribute( QStringLiteral( "configurationFlags" ) ), Qgis::FieldConfigurationFlag::NoFlag );
2676
2677 // Load editor widget configuration
2678 if ( categories.testFlag( Forms ) )
2679 {
2680 const QString widgetType = fieldWidgetElement.attribute( QStringLiteral( "type" ) );
2681 const QDomElement cfgElem = fieldConfigElement.elementsByTagName( QStringLiteral( "config" ) ).at( 0 ).toElement();
2682 const QDomElement optionsElem = cfgElem.childNodes().at( 0 ).toElement();
2683 QVariantMap optionsMap = QgsXmlUtils::readVariant( optionsElem ).toMap();
2684 if ( widgetType == QLatin1String( "ValueRelation" ) )
2685 {
2686 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() );
2687 }
2688 QgsEditorWidgetSetup setup = QgsEditorWidgetSetup( widgetType, optionsMap );
2689 mFieldWidgetSetups[fieldName] = setup;
2690 }
2691 }
2692 }
2693
2694 // Legacy reading for QGIS 3.14 and older projects
2695 // Attributes excluded from WMS and WFS
2696 if ( categories.testFlag( Fields ) )
2697 {
2698 const QList<QPair<QString, Qgis::FieldConfigurationFlag>> legacyConfig
2699 {
2700 qMakePair( QStringLiteral( "excludeAttributesWMS" ), Qgis::FieldConfigurationFlag::HideFromWms ),
2701 qMakePair( QStringLiteral( "excludeAttributesWFS" ), Qgis::FieldConfigurationFlag::HideFromWfs )
2702 };
2703 for ( const auto &config : legacyConfig )
2704 {
2705 QDomNode excludeNode = layerNode.namedItem( config.first );
2706 if ( !excludeNode.isNull() )
2707 {
2708 QDomNodeList attributeNodeList = excludeNode.toElement().elementsByTagName( QStringLiteral( "attribute" ) );
2709 for ( int i = 0; i < attributeNodeList.size(); ++i )
2710 {
2711 QString fieldName = attributeNodeList.at( i ).toElement().text();
2712 if ( !mFieldConfigurationFlags.contains( fieldName ) )
2713 mFieldConfigurationFlags[fieldName] = config.second;
2714 else
2715 mFieldConfigurationFlags[fieldName].setFlag( config.second, true );
2716 }
2717 }
2718 }
2719 }
2720
2721 if ( categories.testFlag( GeometryOptions ) )
2722 mGeometryOptions->readXml( layerNode.namedItem( QStringLiteral( "geometryOptions" ) ) );
2723
2724 if ( categories.testFlag( Forms ) )
2725 mEditFormConfig.readXml( layerNode, context );
2726
2727 if ( categories.testFlag( AttributeTable ) )
2728 {
2729 mAttributeTableConfig.readXml( layerNode );
2730 mConditionalStyles->readXml( layerNode, context );
2731 mStoredExpressionManager->readXml( layerNode );
2732 }
2733
2734 if ( categories.testFlag( CustomProperties ) )
2735 readCustomProperties( layerNode, QStringLiteral( "variable" ) );
2736
2737 QDomElement mapLayerNode = layerNode.toElement();
2738 if ( categories.testFlag( LayerConfiguration )
2739 && mapLayerNode.attribute( QStringLiteral( "readOnly" ), QStringLiteral( "0" ) ).toInt() == 1 )
2740 mReadOnly = true;
2741
2742 updateFields();
2743
2744 if ( categories.testFlag( Legend ) )
2745 {
2746 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Legend" ) );
2747
2748 const QDomElement legendElem = layerNode.firstChildElement( QStringLiteral( "legend" ) );
2749 if ( !legendElem.isNull() )
2750 {
2751 std::unique_ptr< QgsMapLayerLegend > legend( QgsMapLayerLegend::defaultVectorLegend( this ) );
2752 legend->readXml( legendElem, context );
2753 setLegend( legend.release() );
2754 mSetLegendFromStyle = true;
2755 }
2756 }
2757
2758 return true;
2759}
2760
2761bool QgsVectorLayer::readStyle( const QDomNode &node, QString &errorMessage,
2763{
2765
2766 bool result = true;
2767 emit readCustomSymbology( node.toElement(), errorMessage );
2768
2769 // we must try to restore a renderer if our geometry type is unknown
2770 // as this allows the renderer to be correctly restored even for layers
2771 // with broken sources
2772 if ( isSpatial() || mWkbType == Qgis::WkbType::Unknown )
2773 {
2774 // defer style changed signal until we've set the renderer, labeling, everything.
2775 // we don't want multiple signals!
2776 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
2777
2778 // try renderer v2 first
2779 if ( categories.testFlag( Symbology ) )
2780 {
2781 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Symbology" ) );
2782
2783 QDomElement rendererElement = node.firstChildElement( RENDERER_TAG_NAME );
2784 if ( !rendererElement.isNull() )
2785 {
2786 QgsFeatureRenderer *r = QgsFeatureRenderer::load( rendererElement, context );
2787 if ( r )
2788 {
2789 setRenderer( r );
2790 }
2791 else
2792 {
2793 result = false;
2794 }
2795 }
2796 // make sure layer has a renderer - if none exists, fallback to a default renderer
2797 if ( isSpatial() && !renderer() )
2798 {
2800 }
2801
2802 if ( mSelectionProperties )
2803 mSelectionProperties->readXml( node.toElement(), context );
2804 }
2805
2806 // read labeling definition
2807 if ( categories.testFlag( Labeling ) )
2808 {
2809 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Labeling" ) );
2810
2811 QDomElement labelingElement = node.firstChildElement( QStringLiteral( "labeling" ) );
2813 if ( labelingElement.isNull() ||
2814 ( labelingElement.attribute( QStringLiteral( "type" ) ) == QLatin1String( "simple" ) && labelingElement.firstChildElement( QStringLiteral( "settings" ) ).isNull() ) )
2815 {
2816 // make sure we have custom properties for labeling for 2.x projects
2817 // (custom properties should be already loaded when reading the whole layer from XML,
2818 // but when reading style, custom properties are not read)
2819 readCustomProperties( node, QStringLiteral( "labeling" ) );
2820
2821 // support for pre-QGIS 3 labeling configurations written in custom properties
2822 labeling = readLabelingFromCustomProperties();
2823 }
2824 else
2825 {
2826 labeling = QgsAbstractVectorLayerLabeling::create( labelingElement, context );
2827 }
2829
2830 if ( node.toElement().hasAttribute( QStringLiteral( "labelsEnabled" ) ) )
2831 mLabelsEnabled = node.toElement().attribute( QStringLiteral( "labelsEnabled" ) ).toInt();
2832 else
2833 mLabelsEnabled = true;
2834 }
2835
2836 if ( categories.testFlag( Symbology ) )
2837 {
2838 // get and set the blend mode if it exists
2839 QDomNode blendModeNode = node.namedItem( QStringLiteral( "blendMode" ) );
2840 if ( !blendModeNode.isNull() )
2841 {
2842 QDomElement e = blendModeNode.toElement();
2843 setBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
2844 }
2845
2846 // get and set the feature blend mode if it exists
2847 QDomNode featureBlendModeNode = node.namedItem( QStringLiteral( "featureBlendMode" ) );
2848 if ( !featureBlendModeNode.isNull() )
2849 {
2850 QDomElement e = featureBlendModeNode.toElement();
2851 setFeatureBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
2852 }
2853 }
2854
2855 // get and set the layer transparency and scale visibility if they exists
2856 if ( categories.testFlag( Rendering ) )
2857 {
2858 QDomNode layerTransparencyNode = node.namedItem( QStringLiteral( "layerTransparency" ) );
2859 if ( !layerTransparencyNode.isNull() )
2860 {
2861 QDomElement e = layerTransparencyNode.toElement();
2862 setOpacity( 1.0 - e.text().toInt() / 100.0 );
2863 }
2864 QDomNode layerOpacityNode = node.namedItem( QStringLiteral( "layerOpacity" ) );
2865 if ( !layerOpacityNode.isNull() )
2866 {
2867 QDomElement e = layerOpacityNode.toElement();
2868 setOpacity( e.text().toDouble() );
2869 }
2870
2871 const bool hasScaleBasedVisibiliy { node.attributes().namedItem( QStringLiteral( "hasScaleBasedVisibilityFlag" ) ).nodeValue() == '1' };
2872 setScaleBasedVisibility( hasScaleBasedVisibiliy );
2873 bool ok;
2874 const double maxScale { node.attributes().namedItem( QStringLiteral( "maxScale" ) ).nodeValue().toDouble( &ok ) };
2875 if ( ok )
2876 {
2877 setMaximumScale( maxScale );
2878 }
2879 const double minScale { node.attributes().namedItem( QStringLiteral( "minScale" ) ).nodeValue().toDouble( &ok ) };
2880 if ( ok )
2881 {
2882 setMinimumScale( minScale );
2883 }
2884
2885 QDomElement e = node.toElement();
2886
2887 // get the simplification drawing settings
2888 mSimplifyMethod.setSimplifyHints( static_cast< Qgis::VectorRenderingSimplificationFlags >( e.attribute( QStringLiteral( "simplifyDrawingHints" ), QStringLiteral( "1" ) ).toInt() ) );
2889 mSimplifyMethod.setSimplifyAlgorithm( static_cast< Qgis::VectorSimplificationAlgorithm >( e.attribute( QStringLiteral( "simplifyAlgorithm" ), QStringLiteral( "0" ) ).toInt() ) );
2890 mSimplifyMethod.setThreshold( e.attribute( QStringLiteral( "simplifyDrawingTol" ), QStringLiteral( "1" ) ).toFloat() );
2891 mSimplifyMethod.setForceLocalOptimization( e.attribute( QStringLiteral( "simplifyLocal" ), QStringLiteral( "1" ) ).toInt() );
2892 mSimplifyMethod.setMaximumScale( e.attribute( QStringLiteral( "simplifyMaxScale" ), QStringLiteral( "1" ) ).toFloat() );
2893
2894 if ( mRenderer )
2895 mRenderer->setReferenceScale( e.attribute( QStringLiteral( "symbologyReferenceScale" ), QStringLiteral( "-1" ) ).toDouble() );
2896 }
2897
2898 //diagram renderer and diagram layer settings
2899 if ( categories.testFlag( Diagrams ) )
2900 {
2901 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Diagrams" ) );
2902
2903 delete mDiagramRenderer;
2904 mDiagramRenderer = nullptr;
2905 QDomElement singleCatDiagramElem = node.firstChildElement( QStringLiteral( "SingleCategoryDiagramRenderer" ) );
2906 if ( !singleCatDiagramElem.isNull() )
2907 {
2908 mDiagramRenderer = new QgsSingleCategoryDiagramRenderer();
2909 mDiagramRenderer->readXml( singleCatDiagramElem, context );
2910 }
2911 QDomElement linearDiagramElem = node.firstChildElement( QStringLiteral( "LinearlyInterpolatedDiagramRenderer" ) );
2912 if ( !linearDiagramElem.isNull() )
2913 {
2914 if ( linearDiagramElem.hasAttribute( QStringLiteral( "classificationAttribute" ) ) )
2915 {
2916 // fix project from before QGIS 3.0
2917 int idx = linearDiagramElem.attribute( QStringLiteral( "classificationAttribute" ) ).toInt();
2918 if ( idx >= 0 && idx < mFields.count() )
2919 linearDiagramElem.setAttribute( QStringLiteral( "classificationField" ), mFields.at( idx ).name() );
2920 }
2921
2922 mDiagramRenderer = new QgsLinearlyInterpolatedDiagramRenderer();
2923 mDiagramRenderer->readXml( linearDiagramElem, context );
2924 }
2925 QDomElement stackedDiagramElem = node.firstChildElement( QStringLiteral( "StackedDiagramRenderer" ) );
2926 if ( !stackedDiagramElem.isNull() )
2927 {
2928 mDiagramRenderer = new QgsStackedDiagramRenderer();
2929 mDiagramRenderer->readXml( stackedDiagramElem, context );
2930 }
2931
2932 if ( mDiagramRenderer )
2933 {
2934 QDomElement diagramSettingsElem = node.firstChildElement( QStringLiteral( "DiagramLayerSettings" ) );
2935 if ( !diagramSettingsElem.isNull() )
2936 {
2937 bool oldXPos = diagramSettingsElem.hasAttribute( QStringLiteral( "xPosColumn" ) );
2938 bool oldYPos = diagramSettingsElem.hasAttribute( QStringLiteral( "yPosColumn" ) );
2939 bool oldShow = diagramSettingsElem.hasAttribute( QStringLiteral( "showColumn" ) );
2940 if ( oldXPos || oldYPos || oldShow )
2941 {
2942 // fix project from before QGIS 3.0
2944 if ( oldXPos )
2945 {
2946 int xPosColumn = diagramSettingsElem.attribute( QStringLiteral( "xPosColumn" ) ).toInt();
2947 if ( xPosColumn >= 0 && xPosColumn < mFields.count() )
2949 }
2950 if ( oldYPos )
2951 {
2952 int yPosColumn = diagramSettingsElem.attribute( QStringLiteral( "yPosColumn" ) ).toInt();
2953 if ( yPosColumn >= 0 && yPosColumn < mFields.count() )
2955 }
2956 if ( oldShow )
2957 {
2958 int showColumn = diagramSettingsElem.attribute( QStringLiteral( "showColumn" ) ).toInt();
2959 if ( showColumn >= 0 && showColumn < mFields.count() )
2960 ddp.setProperty( QgsDiagramLayerSettings::Property::Show, QgsProperty::fromField( mFields.at( showColumn ).name(), true ) );
2961 }
2962 QDomElement propertiesElem = diagramSettingsElem.ownerDocument().createElement( QStringLiteral( "properties" ) );
2964 {
2965 { static_cast< int >( QgsDiagramLayerSettings::Property::PositionX ), QgsPropertyDefinition( "positionX", QObject::tr( "Position (X)" ), QgsPropertyDefinition::Double ) },
2966 { static_cast< int >( QgsDiagramLayerSettings::Property::PositionY ), QgsPropertyDefinition( "positionY", QObject::tr( "Position (Y)" ), QgsPropertyDefinition::Double ) },
2967 { static_cast< int >( QgsDiagramLayerSettings::Property::Show ), QgsPropertyDefinition( "show", QObject::tr( "Show diagram" ), QgsPropertyDefinition::Boolean ) },
2968 };
2969 ddp.writeXml( propertiesElem, defs );
2970 diagramSettingsElem.appendChild( propertiesElem );
2971 }
2972
2973 delete mDiagramLayerSettings;
2974 mDiagramLayerSettings = new QgsDiagramLayerSettings();
2975 mDiagramLayerSettings->readXml( diagramSettingsElem );
2976 }
2977 }
2978 }
2979 // end diagram
2980
2981 styleChangedSignalBlocker.release();
2983 }
2984 return result;
2985}
2986
2987
2988bool QgsVectorLayer::writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage,
2989 const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
2990{
2992
2993 QDomElement layerElement = node.toElement();
2994 writeCommonStyle( layerElement, doc, context, categories );
2995
2996 ( void )writeStyle( node, doc, errorMessage, context, categories );
2997
2998 if ( categories.testFlag( GeometryOptions ) )
2999 mGeometryOptions->writeXml( node );
3000
3001 if ( categories.testFlag( Legend ) && legend() )
3002 {
3003 QDomElement legendElement = legend()->writeXml( doc, context );
3004 if ( !legendElement.isNull() )
3005 node.appendChild( legendElement );
3006 }
3007
3008 // Relation information for both referenced and referencing sides
3009 if ( categories.testFlag( Relations ) )
3010 {
3011 if ( QgsProject *p = project() )
3012 {
3013 // Store referenced layers: relations where "this" is the child layer (the referencing part, that holds the FK)
3014 QDomElement referencedLayersElement = doc.createElement( QStringLiteral( "referencedLayers" ) );
3015 node.appendChild( referencedLayersElement );
3016
3017 const QList<QgsRelation> referencingRelations { p->relationManager()->referencingRelations( this ) };
3018 for ( const QgsRelation &rel : referencingRelations )
3019 {
3020 switch ( rel.type() )
3021 {
3023 QgsWeakRelation::writeXml( this, QgsWeakRelation::Referencing, rel, referencedLayersElement, doc );
3024 break;
3026 break;
3027 }
3028 }
3029
3030 // Store referencing layers: relations where "this" is the parent layer (the referenced part, that holds the FK)
3031 QDomElement referencingLayersElement = doc.createElement( QStringLiteral( "referencingLayers" ) );
3032 node.appendChild( referencedLayersElement );
3033
3034 const QList<QgsRelation> referencedRelations { p->relationManager()->referencedRelations( this ) };
3035 for ( const QgsRelation &rel : referencedRelations )
3036 {
3037 switch ( rel.type() )
3038 {
3040 QgsWeakRelation::writeXml( this, QgsWeakRelation::Referenced, rel, referencingLayersElement, doc );
3041 break;
3043 break;
3044 }
3045 }
3046 }
3047 }
3048
3049 // write field configurations
3050 if ( categories.testFlag( Fields ) || categories.testFlag( Forms ) )
3051 {
3052 QDomElement fieldConfigurationElement;
3053 // field configuration flag
3054 fieldConfigurationElement = doc.createElement( QStringLiteral( "fieldConfiguration" ) );
3055 node.appendChild( fieldConfigurationElement );
3056
3057 for ( const QgsField &field : std::as_const( mFields ) )
3058 {
3059 QDomElement fieldElement = doc.createElement( QStringLiteral( "field" ) );
3060 fieldElement.setAttribute( QStringLiteral( "name" ), field.name() );
3061 fieldConfigurationElement.appendChild( fieldElement );
3062
3063 if ( categories.testFlag( Fields ) )
3064 {
3065 fieldElement.setAttribute( QStringLiteral( "configurationFlags" ), qgsFlagValueToKeys( field.configurationFlags() ) );
3066 }
3067
3068 if ( categories.testFlag( Forms ) )
3069 {
3070 QgsEditorWidgetSetup widgetSetup = field.editorWidgetSetup();
3071
3072 // TODO : wrap this part in an if to only save if it was user-modified
3073 QDomElement editWidgetElement = doc.createElement( QStringLiteral( "editWidget" ) );
3074 fieldElement.appendChild( editWidgetElement );
3075 editWidgetElement.setAttribute( QStringLiteral( "type" ), field.editorWidgetSetup().type() );
3076 QDomElement editWidgetConfigElement = doc.createElement( QStringLiteral( "config" ) );
3077
3078 editWidgetConfigElement.appendChild( QgsXmlUtils::writeVariant( widgetSetup.config(), doc ) );
3079 editWidgetElement.appendChild( editWidgetConfigElement );
3080 // END TODO : wrap this part in an if to only save if it was user-modified
3081 }
3082 }
3083 }
3084
3085 if ( categories.testFlag( Fields ) )
3086 {
3087 //attribute aliases
3088 QDomElement aliasElem = doc.createElement( QStringLiteral( "aliases" ) );
3089 for ( const QgsField &field : std::as_const( mFields ) )
3090 {
3091 QDomElement aliasEntryElem = doc.createElement( QStringLiteral( "alias" ) );
3092 aliasEntryElem.setAttribute( QStringLiteral( "field" ), field.name() );
3093 aliasEntryElem.setAttribute( QStringLiteral( "index" ), mFields.indexFromName( field.name() ) );
3094 aliasEntryElem.setAttribute( QStringLiteral( "name" ), field.alias() );
3095 aliasElem.appendChild( aliasEntryElem );
3096 }
3097 node.appendChild( aliasElem );
3098
3099 //split policies
3100 {
3101 QDomElement splitPoliciesElement = doc.createElement( QStringLiteral( "splitPolicies" ) );
3102 for ( const QgsField &field : std::as_const( mFields ) )
3103 {
3104 QDomElement splitPolicyElem = doc.createElement( QStringLiteral( "policy" ) );
3105 splitPolicyElem.setAttribute( QStringLiteral( "field" ), field.name() );
3106 splitPolicyElem.setAttribute( QStringLiteral( "policy" ), qgsEnumValueToKey( field.splitPolicy() ) );
3107 splitPoliciesElement.appendChild( splitPolicyElem );
3108 }
3109 node.appendChild( splitPoliciesElement );
3110 }
3111
3112 //duplicate policies
3113 {
3114 QDomElement duplicatePoliciesElement = doc.createElement( QStringLiteral( "duplicatePolicies" ) );
3115 for ( const QgsField &field : std::as_const( mFields ) )
3116 {
3117 QDomElement duplicatePolicyElem = doc.createElement( QStringLiteral( "policy" ) );
3118 duplicatePolicyElem.setAttribute( QStringLiteral( "field" ), field.name() );
3119 duplicatePolicyElem.setAttribute( QStringLiteral( "policy" ), qgsEnumValueToKey( field.duplicatePolicy() ) );
3120 duplicatePoliciesElement.appendChild( duplicatePolicyElem );
3121 }
3122 node.appendChild( duplicatePoliciesElement );
3123 }
3124
3125 //default expressions
3126 QDomElement defaultsElem = doc.createElement( QStringLiteral( "defaults" ) );
3127 for ( const QgsField &field : std::as_const( mFields ) )
3128 {
3129 QDomElement defaultElem = doc.createElement( QStringLiteral( "default" ) );
3130 defaultElem.setAttribute( QStringLiteral( "field" ), field.name() );
3131 defaultElem.setAttribute( QStringLiteral( "expression" ), field.defaultValueDefinition().expression() );
3132 defaultElem.setAttribute( QStringLiteral( "applyOnUpdate" ), field.defaultValueDefinition().applyOnUpdate() ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
3133 defaultsElem.appendChild( defaultElem );
3134 }
3135 node.appendChild( defaultsElem );
3136
3137 // constraints
3138 QDomElement constraintsElem = doc.createElement( QStringLiteral( "constraints" ) );
3139 for ( const QgsField &field : std::as_const( mFields ) )
3140 {
3141 QDomElement constraintElem = doc.createElement( QStringLiteral( "constraint" ) );
3142 constraintElem.setAttribute( QStringLiteral( "field" ), field.name() );
3143 constraintElem.setAttribute( QStringLiteral( "constraints" ), field.constraints().constraints() );
3144 constraintElem.setAttribute( QStringLiteral( "unique_strength" ), field.constraints().constraintStrength( QgsFieldConstraints::ConstraintUnique ) );
3145 constraintElem.setAttribute( QStringLiteral( "notnull_strength" ), field.constraints().constraintStrength( QgsFieldConstraints::ConstraintNotNull ) );
3146 constraintElem.setAttribute( QStringLiteral( "exp_strength" ), field.constraints().constraintStrength( QgsFieldConstraints::ConstraintExpression ) );
3147
3148 constraintsElem.appendChild( constraintElem );
3149 }
3150 node.appendChild( constraintsElem );
3151
3152 // constraint expressions
3153 QDomElement constraintExpressionsElem = doc.createElement( QStringLiteral( "constraintExpressions" ) );
3154 for ( const QgsField &field : std::as_const( mFields ) )
3155 {
3156 QDomElement constraintExpressionElem = doc.createElement( QStringLiteral( "constraint" ) );
3157 constraintExpressionElem.setAttribute( QStringLiteral( "field" ), field.name() );
3158 constraintExpressionElem.setAttribute( QStringLiteral( "exp" ), field.constraints().constraintExpression() );
3159 constraintExpressionElem.setAttribute( QStringLiteral( "desc" ), field.constraints().constraintDescription() );
3160 constraintExpressionsElem.appendChild( constraintExpressionElem );
3161 }
3162 node.appendChild( constraintExpressionsElem );
3163
3164 // save expression fields
3165 if ( !mExpressionFieldBuffer )
3166 {
3167 // can happen when saving style on a invalid layer
3169 dummy.writeXml( node, doc );
3170 }
3171 else
3172 {
3173 mExpressionFieldBuffer->writeXml( node, doc );
3174 }
3175 }
3176
3177 // add attribute actions
3178 if ( categories.testFlag( Actions ) )
3179 mActions->writeXml( node );
3180
3181 if ( categories.testFlag( AttributeTable ) )
3182 {
3183 mAttributeTableConfig.writeXml( node );
3184 mConditionalStyles->writeXml( node, doc, context );
3185 mStoredExpressionManager->writeXml( node );
3186 }
3187
3188 if ( categories.testFlag( Forms ) )
3189 mEditFormConfig.writeXml( node, context );
3190
3191 // save readonly state
3192 if ( categories.testFlag( LayerConfiguration ) )
3193 node.toElement().setAttribute( QStringLiteral( "readOnly" ), mReadOnly );
3194
3195 // save preview expression
3196 if ( categories.testFlag( LayerConfiguration ) )
3197 {
3198 QDomElement prevExpElem = doc.createElement( QStringLiteral( "previewExpression" ) );
3199 QDomText prevExpText = doc.createTextNode( mDisplayExpression );
3200 prevExpElem.appendChild( prevExpText );
3201 node.appendChild( prevExpElem );
3202 }
3203
3204 // save map tip
3205 if ( categories.testFlag( MapTips ) )
3206 {
3207 QDomElement mapTipElem = doc.createElement( QStringLiteral( "mapTip" ) );
3208 mapTipElem.setAttribute( QStringLiteral( "enabled" ), mapTipsEnabled() );
3209 QDomText mapTipText = doc.createTextNode( mMapTipTemplate );
3210 mapTipElem.appendChild( mapTipText );
3211 node.toElement().appendChild( mapTipElem );
3212 }
3213
3214 return true;
3215}
3216
3217bool QgsVectorLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage,
3218 const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
3219{
3221
3222 QDomElement mapLayerNode = node.toElement();
3223
3224 emit writeCustomSymbology( mapLayerNode, doc, errorMessage );
3225
3226 // we must try to write the renderer if our geometry type is unknown
3227 // as this allows the renderer to be correctly restored even for layers
3228 // with broken sources
3229 if ( isSpatial() || mWkbType == Qgis::WkbType::Unknown )
3230 {
3231 if ( categories.testFlag( Symbology ) )
3232 {
3233 if ( mRenderer )
3234 {
3235 QDomElement rendererElement = mRenderer->save( doc, context );
3236 node.appendChild( rendererElement );
3237 }
3238 if ( mSelectionProperties )
3239 {
3240 mSelectionProperties->writeXml( mapLayerNode, doc, context );
3241 }
3242 }
3243
3244 if ( categories.testFlag( Labeling ) )
3245 {
3246 if ( mLabeling )
3247 {
3248 QDomElement labelingElement = mLabeling->save( doc, context );
3249 node.appendChild( labelingElement );
3250 }
3251 mapLayerNode.setAttribute( QStringLiteral( "labelsEnabled" ), mLabelsEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
3252 }
3253
3254 // save the simplification drawing settings
3255 if ( categories.testFlag( Rendering ) )
3256 {
3257 mapLayerNode.setAttribute( QStringLiteral( "simplifyDrawingHints" ), QString::number( static_cast< int >( mSimplifyMethod.simplifyHints() ) ) );
3258 mapLayerNode.setAttribute( QStringLiteral( "simplifyAlgorithm" ), QString::number( static_cast< int >( mSimplifyMethod.simplifyAlgorithm() ) ) );
3259 mapLayerNode.setAttribute( QStringLiteral( "simplifyDrawingTol" ), QString::number( mSimplifyMethod.threshold() ) );
3260 mapLayerNode.setAttribute( QStringLiteral( "simplifyLocal" ), mSimplifyMethod.forceLocalOptimization() ? 1 : 0 );
3261 mapLayerNode.setAttribute( QStringLiteral( "simplifyMaxScale" ), QString::number( mSimplifyMethod.maximumScale() ) );
3262 }
3263
3264 //save customproperties
3265 if ( categories.testFlag( CustomProperties ) )
3266 {
3267 writeCustomProperties( node, doc );
3268 }
3269
3270 if ( categories.testFlag( Symbology ) )
3271 {
3272 // add the blend mode field
3273 QDomElement blendModeElem = doc.createElement( QStringLiteral( "blendMode" ) );
3274 QDomText blendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( blendMode() ) ) ) );
3275 blendModeElem.appendChild( blendModeText );
3276 node.appendChild( blendModeElem );
3277
3278 // add the feature blend mode field
3279 QDomElement featureBlendModeElem = doc.createElement( QStringLiteral( "featureBlendMode" ) );
3280 QDomText featureBlendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( featureBlendMode() ) ) ) );
3281 featureBlendModeElem.appendChild( featureBlendModeText );
3282 node.appendChild( featureBlendModeElem );
3283 }
3284
3285 // add the layer opacity and scale visibility
3286 if ( categories.testFlag( Rendering ) )
3287 {
3288 QDomElement layerOpacityElem = doc.createElement( QStringLiteral( "layerOpacity" ) );
3289 QDomText layerOpacityText = doc.createTextNode( QString::number( opacity() ) );
3290 layerOpacityElem.appendChild( layerOpacityText );
3291 node.appendChild( layerOpacityElem );
3292 mapLayerNode.setAttribute( QStringLiteral( "hasScaleBasedVisibilityFlag" ), hasScaleBasedVisibility() ? 1 : 0 );
3293 mapLayerNode.setAttribute( QStringLiteral( "maxScale" ), maximumScale() );
3294 mapLayerNode.setAttribute( QStringLiteral( "minScale" ), minimumScale() );
3295
3296 mapLayerNode.setAttribute( QStringLiteral( "symbologyReferenceScale" ), mRenderer ? mRenderer->referenceScale() : -1 );
3297 }
3298
3299 if ( categories.testFlag( Diagrams ) && mDiagramRenderer )
3300 {
3301 mDiagramRenderer->writeXml( mapLayerNode, doc, context );
3302 if ( mDiagramLayerSettings )
3303 mDiagramLayerSettings->writeXml( mapLayerNode, doc );
3304 }
3305 }
3306 return true;
3307}
3308
3309bool QgsVectorLayer::readSld( const QDomNode &node, QString &errorMessage )
3310{
3312
3313 // get the Name element
3314 QDomElement nameElem = node.firstChildElement( QStringLiteral( "Name" ) );
3315 if ( nameElem.isNull() )
3316 {
3317 errorMessage = QStringLiteral( "Warning: Name element not found within NamedLayer while it's required." );
3318 }
3319
3320 if ( isSpatial() )
3321 {
3322 QgsFeatureRenderer *r = QgsFeatureRenderer::loadSld( node, geometryType(), errorMessage );
3323 if ( !r )
3324 return false;
3325
3326 // defer style changed signal until we've set the renderer, labeling, everything.
3327 // we don't want multiple signals!
3328 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
3329
3330 setRenderer( r );
3331
3332 // labeling
3333 readSldLabeling( node );
3334
3335 styleChangedSignalBlocker.release();
3337 }
3338 return true;
3339}
3340
3341bool QgsVectorLayer::writeSld( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QVariantMap &props ) const
3342{
3344
3345 Q_UNUSED( errorMessage )
3346
3347 QVariantMap localProps = QVariantMap( props );
3349 {
3351 }
3352
3353 if ( isSpatial() )
3354 {
3355 // store the Name element
3356 QDomElement nameNode = doc.createElement( QStringLiteral( "se:Name" ) );
3357 nameNode.appendChild( doc.createTextNode( name() ) );
3358 node.appendChild( nameNode );
3359
3360 QDomElement userStyleElem = doc.createElement( QStringLiteral( "UserStyle" ) );
3361 node.appendChild( userStyleElem );
3362
3363 QDomElement nameElem = doc.createElement( QStringLiteral( "se:Name" ) );
3364 nameElem.appendChild( doc.createTextNode( name() ) );
3365
3366 userStyleElem.appendChild( nameElem );
3367
3368 QDomElement featureTypeStyleElem = doc.createElement( QStringLiteral( "se:FeatureTypeStyle" ) );
3369 userStyleElem.appendChild( featureTypeStyleElem );
3370
3371 mRenderer->toSld( doc, featureTypeStyleElem, localProps );
3372 if ( labelsEnabled() )
3373 {
3374 mLabeling->toSld( featureTypeStyleElem, localProps );
3375 }
3376 }
3377 return true;
3378}
3379
3380
3381bool QgsVectorLayer::changeGeometry( QgsFeatureId fid, QgsGeometry &geom, bool skipDefaultValue )
3382{
3384
3385 if ( !mEditBuffer || !mDataProvider )
3386 {
3387 return false;
3388 }
3389
3390 if ( mGeometryOptions->isActive() )
3391 mGeometryOptions->apply( geom );
3392
3393 updateExtents();
3394
3395 bool result = mEditBuffer->changeGeometry( fid, geom );
3396
3397 if ( result )
3398 {
3399 updateExtents();
3400 if ( !skipDefaultValue && !mDefaultValueOnUpdateFields.isEmpty() )
3401 updateDefaultValues( fid );
3402 }
3403 return result;
3404}
3405
3406
3407bool QgsVectorLayer::changeAttributeValue( QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue, bool skipDefaultValues, QgsVectorLayerToolsContext *context )
3408{
3410
3411 bool result = false;
3412
3413 switch ( fields().fieldOrigin( field ) )
3414 {
3416 result = mJoinBuffer->changeAttributeValue( fid, field, newValue, oldValue );
3417 if ( result )
3418 emit attributeValueChanged( fid, field, newValue );
3419 break;
3420
3424 {
3425 if ( mEditBuffer && mDataProvider )
3426 result = mEditBuffer->changeAttributeValue( fid, field, newValue, oldValue );
3427 break;
3428 }
3429
3431 break;
3432 }
3433
3434 if ( result && !skipDefaultValues && !mDefaultValueOnUpdateFields.isEmpty() )
3435 updateDefaultValues( fid, QgsFeature(), context ? context->expressionContext() : nullptr );
3436
3437 return result;
3438}
3439
3440bool QgsVectorLayer::changeAttributeValues( QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues, bool skipDefaultValues, QgsVectorLayerToolsContext *context )
3441{
3443
3444 bool result = true;
3445
3446 QgsAttributeMap newValuesJoin;
3447 QgsAttributeMap oldValuesJoin;
3448
3449 QgsAttributeMap newValuesNotJoin;
3450 QgsAttributeMap oldValuesNotJoin;
3451
3452 for ( auto it = newValues.constBegin(); it != newValues.constEnd(); ++it )
3453 {
3454 const int field = it.key();
3455 const QVariant newValue = it.value();
3456 QVariant oldValue;
3457
3458 if ( oldValues.contains( field ) )
3459 oldValue = oldValues[field];
3460
3461 switch ( fields().fieldOrigin( field ) )
3462 {
3464 newValuesJoin[field] = newValue;
3465 oldValuesJoin[field] = oldValue;
3466 break;
3467
3471 {
3472 newValuesNotJoin[field] = newValue;
3473 oldValuesNotJoin[field] = oldValue;
3474 break;
3475 }
3476
3478 break;
3479 }
3480 }
3481
3482 if ( ! newValuesJoin.isEmpty() && mJoinBuffer )
3483 {
3484 result = mJoinBuffer->changeAttributeValues( fid, newValuesJoin, oldValuesJoin );
3485 }
3486
3487 if ( ! newValuesNotJoin.isEmpty() )
3488 {
3489 if ( mEditBuffer && mDataProvider )
3490 result &= mEditBuffer->changeAttributeValues( fid, newValuesNotJoin, oldValues );
3491 else
3492 result = false;
3493 }
3494
3495 if ( result && !skipDefaultValues && !mDefaultValueOnUpdateFields.isEmpty() )
3496 {
3497 updateDefaultValues( fid, QgsFeature(), context ? context->expressionContext() : nullptr );
3498 }
3499
3500 return result;
3501}
3502
3504{
3506
3507 if ( !mEditBuffer || !mDataProvider )
3508 return false;
3509
3510 return mEditBuffer->addAttribute( field );
3511}
3512
3514{
3516
3517 if ( attIndex < 0 || attIndex >= fields().count() )
3518 return;
3519
3520 QString name = fields().at( attIndex ).name();
3521 mFields[ attIndex ].setAlias( QString() );
3522 if ( mAttributeAliasMap.contains( name ) )
3523 {
3524 mAttributeAliasMap.remove( name );
3525 updateFields();
3526 mEditFormConfig.setFields( mFields );
3527 emit layerModified();
3528 }
3529}
3530
3531bool QgsVectorLayer::renameAttribute( int index, const QString &newName )
3532{
3534
3535 if ( index < 0 || index >= fields().count() )
3536 return false;
3537
3538 switch ( mFields.fieldOrigin( index ) )
3539 {
3541 {
3542 if ( mExpressionFieldBuffer )
3543 {
3544 int oi = mFields.fieldOriginIndex( index );
3545 mExpressionFieldBuffer->renameExpression( oi, newName );
3546 updateFields();
3547 return true;
3548 }
3549 else
3550 {
3551 return false;
3552 }
3553 }
3554
3557
3558 if ( !mEditBuffer || !mDataProvider )
3559 return false;
3560
3561 return mEditBuffer->renameAttribute( index, newName );
3562
3565 return false;
3566
3567 }
3568
3569 return false; // avoid warning
3570}
3571
3572void QgsVectorLayer::setFieldAlias( int attIndex, const QString &aliasString )
3573{
3575
3576 if ( attIndex < 0 || attIndex >= fields().count() )
3577 return;
3578
3579 QString name = fields().at( attIndex ).name();
3580
3581 mAttributeAliasMap.insert( name, aliasString );
3582 mFields[ attIndex ].setAlias( aliasString );
3583 mEditFormConfig.setFields( mFields );
3584 emit layerModified(); // TODO[MD]: should have a different signal?
3585}
3586
3587QString QgsVectorLayer::attributeAlias( int index ) const
3588{
3590
3591 if ( index < 0 || index >= fields().count() )
3592 return QString();
3593
3594 return fields().at( index ).alias();
3595}
3596
3598{
3600
3601 if ( index >= 0 && index < mFields.count() )
3602 return mFields.at( index ).displayName();
3603 else
3604 return QString();
3605}
3606
3608{
3610
3611 return mAttributeAliasMap;
3612}
3613
3615{
3617
3618 if ( index < 0 || index >= fields().count() )
3619 return;
3620
3621 const QString name = fields().at( index ).name();
3622
3623 mAttributeSplitPolicy.insert( name, policy );
3624 mFields[ index ].setSplitPolicy( policy );
3625 mEditFormConfig.setFields( mFields );
3626 emit layerModified(); // TODO[MD]: should have a different signal?
3627}
3628
3630{
3632
3633 if ( index < 0 || index >= fields().count() )
3634 return;
3635
3636 const QString name = fields().at( index ).name();
3637
3638 mAttributeDuplicatePolicy.insert( name, policy );
3639 mFields[ index ].setDuplicatePolicy( policy );
3640 mEditFormConfig.setFields( mFields );
3641 emit layerModified(); // TODO[MD]: should have a different signal?
3642}
3643
3644
3646{
3648
3649 QSet<QString> excludeList;
3650 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
3651 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
3652 {
3653 if ( flagsIt->testFlag( Qgis::FieldConfigurationFlag::HideFromWms ) )
3654 {
3655 excludeList << flagsIt.key();
3656 }
3657 }
3658 return excludeList;
3659}
3660
3661void QgsVectorLayer::setExcludeAttributesWms( const QSet<QString> &att )
3662{
3664
3665 QMap< QString, Qgis::FieldConfigurationFlags >::iterator flagsIt = mFieldConfigurationFlags.begin();
3666 for ( ; flagsIt != mFieldConfigurationFlags.end(); ++flagsIt )
3667 {
3668 flagsIt->setFlag( Qgis::FieldConfigurationFlag::HideFromWms, att.contains( flagsIt.key() ) );
3669 }
3670 updateFields();
3671}
3672
3674{
3676
3677 QSet<QString> excludeList;
3678 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
3679 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
3680 {
3681 if ( flagsIt->testFlag( Qgis::FieldConfigurationFlag::HideFromWfs ) )
3682 {
3683 excludeList << flagsIt.key();
3684 }
3685 }
3686 return excludeList;
3687}
3688
3689void QgsVectorLayer::setExcludeAttributesWfs( const QSet<QString> &att )
3690{
3692
3693 QMap< QString, Qgis::FieldConfigurationFlags >::iterator flagsIt = mFieldConfigurationFlags.begin();
3694 for ( ; flagsIt != mFieldConfigurationFlags.end(); ++flagsIt )
3695 {
3696 flagsIt->setFlag( Qgis::FieldConfigurationFlag::HideFromWfs, att.contains( flagsIt.key() ) );
3697 }
3698 updateFields();
3699}
3700
3702{
3704
3705 if ( index < 0 || index >= fields().count() )
3706 return false;
3707
3708 if ( mFields.fieldOrigin( index ) == Qgis::FieldOrigin::Expression )
3709 {
3710 removeExpressionField( index );
3711 return true;
3712 }
3713
3714 if ( !mEditBuffer || !mDataProvider )
3715 return false;
3716
3717 return mEditBuffer->deleteAttribute( index );
3718}
3719
3720bool QgsVectorLayer::deleteAttributes( const QList<int> &attrs )
3721{
3723
3724 bool deleted = false;
3725
3726 // Remove multiple occurrences of same attribute
3727 QList<int> attrList = qgis::setToList( qgis::listToSet( attrs ) );
3728
3729 std::sort( attrList.begin(), attrList.end(), std::greater<int>() );
3730
3731 for ( int attr : std::as_const( attrList ) )
3732 {
3733 if ( deleteAttribute( attr ) )
3734 {
3735 deleted = true;
3736 }
3737 }
3738
3739 return deleted;
3740}
3741
3742bool QgsVectorLayer::deleteFeatureCascade( QgsFeatureId fid, QgsVectorLayer::DeleteContext *context )
3743{
3745
3746 if ( !mEditBuffer )
3747 return false;
3748
3749 if ( context && context->cascade )
3750 {
3751 const QList<QgsRelation> relations = context->project->relationManager()->referencedRelations( this );
3752 const bool hasRelationsOrJoins = !relations.empty() || mJoinBuffer->containsJoins();
3753 if ( hasRelationsOrJoins )
3754 {
3755 if ( context->mHandledFeatures.contains( this ) )
3756 {
3757 QgsFeatureIds &handledFeatureIds = context->mHandledFeatures[ this ];
3758 if ( handledFeatureIds.contains( fid ) )
3759 {
3760 // avoid endless recursion
3761 return false;
3762 }
3763 else
3764 {
3765 // add feature id
3766 handledFeatureIds << fid;
3767 }
3768 }
3769 else
3770 {
3771 // add layer and feature id
3772 context->mHandledFeatures.insert( this, QgsFeatureIds() << fid );
3773 }
3774
3775 for ( const QgsRelation &relation : relations )
3776 {
3777 //check if composition (and not association)
3778 switch ( relation.strength() )
3779 {
3781 {
3782 //get features connected over this relation
3783 QgsFeatureIterator relatedFeaturesIt = relation.getRelatedFeatures( getFeature( fid ) );
3784 QgsFeatureIds childFeatureIds;
3785 QgsFeature childFeature;
3786 while ( relatedFeaturesIt.nextFeature( childFeature ) )
3787 {
3788 childFeatureIds.insert( childFeature.id() );
3789 }
3790 if ( childFeatureIds.count() > 0 )
3791 {
3792 relation.referencingLayer()->startEditing();
3793 relation.referencingLayer()->deleteFeatures( childFeatureIds, context );
3794 }
3795 break;
3796 }
3797
3799 break;
3800 }
3801 }
3802 }
3803 }
3804
3805 if ( mJoinBuffer->containsJoins() )
3806 mJoinBuffer->deleteFeature( fid, context );
3807
3808 bool res = mEditBuffer->deleteFeature( fid );
3809
3810 return res;
3811}
3812
3814{
3816
3817 if ( !mEditBuffer )
3818 return false;
3819
3820 return deleteFeatureCascade( fid, context );
3821}
3822
3824{
3826
3827 bool res = true;
3828
3829 if ( ( context && context->cascade ) || mJoinBuffer->containsJoins() )
3830 {
3831 // should ideally be "deleteFeaturesCascade" for performance!
3832 for ( QgsFeatureId fid : fids )
3833 res = deleteFeatureCascade( fid, context ) && res;
3834 }
3835 else
3836 {
3837 res = mEditBuffer && mEditBuffer->deleteFeatures( fids );
3838 }
3839
3840 if ( res )
3841 {
3842 mSelectedFeatureIds.subtract( fids ); // remove it from selection
3843 updateExtents();
3844 }
3845
3846 return res;
3847}
3848
3850{
3851 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
3853
3854 return mFields;
3855}
3856
3858{
3860
3861 QgsAttributeList pkAttributesList;
3862 if ( !mDataProvider )
3863 return pkAttributesList;
3864
3865 QgsAttributeList providerIndexes = mDataProvider->pkAttributeIndexes();
3866 for ( int i = 0; i < mFields.count(); ++i )
3867 {
3868 if ( mFields.fieldOrigin( i ) == Qgis::FieldOrigin::Provider &&
3869 providerIndexes.contains( mFields.fieldOriginIndex( i ) ) )
3870 pkAttributesList << i;
3871 }
3872
3873 return pkAttributesList;
3874}
3875
3877{
3879
3880 if ( !mDataProvider )
3881 return static_cast< long long >( Qgis::FeatureCountState::UnknownCount );
3882 return mDataProvider->featureCount() +
3883 ( mEditBuffer && ! mDataProvider->transaction() ? mEditBuffer->addedFeatures().size() - mEditBuffer->deletedFeatureIds().size() : 0 );
3884}
3885
3887{
3889
3890 const QgsFeatureIds deletedFeatures( mEditBuffer && ! mDataProvider->transaction() ? mEditBuffer->deletedFeatureIds() : QgsFeatureIds() );
3891 const QgsFeatureMap addedFeatures( mEditBuffer && ! mDataProvider->transaction() ? mEditBuffer->addedFeatures() : QgsFeatureMap() );
3892
3893 if ( mEditBuffer && !deletedFeatures.empty() )
3894 {
3895 if ( addedFeatures.size() > deletedFeatures.size() )
3897 else
3899 }
3900
3901 if ( ( !mEditBuffer || addedFeatures.empty() ) && mDataProvider && mDataProvider->empty() )
3903 else
3905}
3906
3907bool QgsVectorLayer::commitChanges( bool stopEditing )
3908{
3910
3911 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
3912 return project()->commitChanges( mCommitErrors, stopEditing, this );
3913
3914 mCommitErrors.clear();
3915
3916 if ( !mDataProvider )
3917 {
3918 mCommitErrors << tr( "ERROR: no provider" );
3919 return false;
3920 }
3921
3922 if ( !mEditBuffer )
3923 {
3924 mCommitErrors << tr( "ERROR: layer not editable" );
3925 return false;
3926 }
3927
3928 emit beforeCommitChanges( stopEditing );
3929
3930 if ( !mAllowCommit )
3931 return false;
3932
3933 mCommitChangesActive = true;
3934
3935 bool success = false;
3936 if ( mEditBuffer->editBufferGroup() )
3937 success = mEditBuffer->editBufferGroup()->commitChanges( mCommitErrors, stopEditing );
3938 else
3939 success = mEditBuffer->commitChanges( mCommitErrors );
3940
3941 mCommitChangesActive = false;
3942
3943 if ( !mDeletedFids.empty() )
3944 {
3945 emit featuresDeleted( mDeletedFids );
3946 mDeletedFids.clear();
3947 }
3948
3949 if ( success )
3950 {
3951 if ( stopEditing )
3952 {
3953 clearEditBuffer();
3954 }
3955 undoStack()->clear();
3956 emit afterCommitChanges();
3957 if ( stopEditing )
3958 emit editingStopped();
3959 }
3960 else
3961 {
3962 QgsMessageLog::logMessage( tr( "Commit errors:\n %1" ).arg( mCommitErrors.join( QLatin1String( "\n " ) ) ) );
3963 }
3964
3965 updateFields();
3966
3967 mDataProvider->updateExtents();
3968
3969 if ( stopEditing )
3970 {
3971 mDataProvider->leaveUpdateMode();
3972 }
3973
3974 // This second call is required because OGR provider with JSON
3975 // driver might have changed fields order after the call to
3976 // leaveUpdateMode
3977 if ( mFields.names() != mDataProvider->fields().names() )
3978 {
3979 updateFields();
3980 }
3981
3983
3984 return success;
3985}
3986
3988{
3990
3991 return mCommitErrors;
3992}
3993
3994bool QgsVectorLayer::rollBack( bool deleteBuffer )
3995{
3997
3998 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
3999 return project()->rollBack( mCommitErrors, deleteBuffer, this );
4000
4001 if ( !mEditBuffer )
4002 {
4003 return false;
4004 }
4005
4006 if ( !mDataProvider )
4007 {
4008 mCommitErrors << tr( "ERROR: no provider" );
4009 return false;
4010 }
4011
4012 bool rollbackExtent = !mDataProvider->transaction() && ( !mEditBuffer->deletedFeatureIds().isEmpty() ||
4013 !mEditBuffer->addedFeatures().isEmpty() ||
4014 !mEditBuffer->changedGeometries().isEmpty() );
4015
4016 emit beforeRollBack();
4017
4018 mEditBuffer->rollBack();
4019
4020 emit afterRollBack();
4021
4022 if ( isModified() )
4023 {
4024 // new undo stack roll back method
4025 // old method of calling every undo could cause many canvas refreshes
4026 undoStack()->setIndex( 0 );
4027 }
4028
4029 updateFields();
4030
4031 if ( deleteBuffer )
4032 {
4033 delete mEditBuffer;
4034 mEditBuffer = nullptr;
4035 undoStack()->clear();
4036 }
4037 emit editingStopped();
4038
4039 if ( rollbackExtent )
4040 updateExtents();
4041
4042 mDataProvider->leaveUpdateMode();
4043
4045 return true;
4046}
4047
4049{
4051
4052 return mSelectedFeatureIds.size();
4053}
4054
4056{
4057 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4059
4060 return mSelectedFeatureIds;
4061}
4062
4064{
4066
4067 QgsFeatureList features;
4068 features.reserve( mSelectedFeatureIds.count() );
4069 QgsFeature f;
4070
4072
4073 while ( it.nextFeature( f ) )
4074 {
4075 features.push_back( f );
4076 }
4077
4078 return features;
4079}
4080
4082{
4084
4085 if ( mSelectedFeatureIds.isEmpty() )
4086 return QgsFeatureIterator();
4087
4090
4091 if ( mSelectedFeatureIds.count() == 1 )
4092 request.setFilterFid( *mSelectedFeatureIds.constBegin() );
4093 else
4094 request.setFilterFids( mSelectedFeatureIds );
4095
4096 return getFeatures( request );
4097}
4098
4100{
4102
4103 if ( !mEditBuffer || !mDataProvider )
4104 return false;
4105
4106 if ( mGeometryOptions->isActive() )
4107 {
4108 for ( auto feature = features.begin(); feature != features.end(); ++feature )
4109 {
4110 QgsGeometry geom = feature->geometry();
4111 mGeometryOptions->apply( geom );
4112 feature->setGeometry( geom );
4113 }
4114 }
4115
4116 bool res = mEditBuffer->addFeatures( features );
4117 updateExtents();
4118
4119 if ( res && mJoinBuffer->containsJoins() )
4120 res = mJoinBuffer->addFeatures( features );
4121
4122 return res;
4123}
4124
4126{
4128
4129 // if layer is not spatial, it has not CRS!
4130 setCrs( ( isSpatial() && mDataProvider ) ? mDataProvider->crs() : QgsCoordinateReferenceSystem() );
4131}
4132
4134{
4136
4138 if ( exp.isField() )
4139 {
4140 return static_cast<const QgsExpressionNodeColumnRef *>( exp.rootNode() )->name();
4141 }
4142
4143 return QString();
4144}
4145
4146void QgsVectorLayer::setDisplayExpression( const QString &displayExpression )
4147{
4149
4150 if ( mDisplayExpression == displayExpression )
4151 return;
4152
4153 mDisplayExpression = displayExpression;
4155}
4156
4158{
4160
4161 if ( !mDisplayExpression.isEmpty() || mFields.isEmpty() )
4162 {
4163 return mDisplayExpression;
4164 }
4165 else
4166 {
4167 const QString candidateName = QgsVectorLayerUtils::guessFriendlyIdentifierField( mFields );
4168 if ( !candidateName.isEmpty() )
4169 {
4170 return QgsExpression::quotedColumnRef( candidateName );
4171 }
4172 else
4173 {
4174 return QString();
4175 }
4176 }
4177}
4178
4180{
4182
4183 // display expressions are used as a fallback when no explicit map tip template is set
4184 return mapTipsEnabled() && ( !mapTipTemplate().isEmpty() || !displayExpression().isEmpty() );
4185}
4186
4188{
4190
4191 return ( mEditBuffer && mDataProvider );
4192}
4193
4195{
4196 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4198
4201}
4202
4203bool QgsVectorLayer::isReadOnly() const
4204{
4206
4207 return mDataSourceReadOnly || mReadOnly;
4208}
4209
4210bool QgsVectorLayer::setReadOnly( bool readonly )
4211{
4213
4214 // exit if the layer is in editing mode
4215 if ( readonly && mEditBuffer )
4216 return false;
4217
4218 // exit if the data source is in read-only mode
4219 if ( !readonly && mDataSourceReadOnly )
4220 return false;
4221
4222 mReadOnly = readonly;
4223 emit readOnlyChanged();
4224 return true;
4225}
4226
4228{
4230
4231 if ( ! mDataProvider )
4232 return false;
4233
4234 if ( mDataSourceReadOnly )
4235 return false;
4236
4237 return mDataProvider->capabilities() & QgsVectorDataProvider::EditingCapabilities && ! mReadOnly;
4238}
4239
4241{
4243
4244 emit beforeModifiedCheck();
4245 return mEditBuffer && mEditBuffer->isModified();
4246}
4247
4248bool QgsVectorLayer::isAuxiliaryField( int index, int &srcIndex ) const
4249{
4251
4252 bool auxiliaryField = false;
4253 srcIndex = -1;
4254
4255 if ( !auxiliaryLayer() )
4256 return auxiliaryField;
4257
4258 if ( index >= 0 && fields().fieldOrigin( index ) == Qgis::FieldOrigin::Join )
4259 {
4260 const QgsVectorLayerJoinInfo *info = mJoinBuffer->joinForFieldIndex( index, fields(), srcIndex );
4261
4262 if ( info && info->joinLayerId() == auxiliaryLayer()->id() )
4263 auxiliaryField = true;
4264 }
4265
4266 return auxiliaryField;
4267}
4268
4270{
4272
4273 // we must allow setting a renderer if our geometry type is unknown
4274 // as this allows the renderer to be correctly set even for layers
4275 // with broken sources
4276 // (note that we allow REMOVING the renderer for non-spatial layers,
4277 // e.g. to permit removing the renderer when the layer changes from
4278 // a spatial layer to a non-spatial one)
4279 if ( r && !isSpatial() && mWkbType != Qgis::WkbType::Unknown )
4280 return;
4281
4282 if ( r != mRenderer )
4283 {
4284 delete mRenderer;
4285 mRenderer = r;
4286 mSymbolFeatureCounted = false;
4287 mSymbolFeatureCountMap.clear();
4288 mSymbolFeatureIdMap.clear();
4289
4290 if ( mRenderer )
4291 {
4292 const double refreshRate = QgsSymbolLayerUtils::rendererFrameRate( mRenderer );
4293 if ( refreshRate <= 0 )
4294 {
4295 mRefreshRendererTimer->stop();
4296 mRefreshRendererTimer->setInterval( 0 );
4297 }
4298 else
4299 {
4300 mRefreshRendererTimer->setInterval( 1000 / refreshRate );
4301 mRefreshRendererTimer->start();
4302 }
4303 }
4304
4305 emit rendererChanged();
4307 }
4308}
4309
4311{
4313
4314 if ( generator )
4315 {
4316 mRendererGenerators << generator;
4317 }
4318}
4319
4321{
4323
4324 for ( int i = mRendererGenerators.count() - 1; i >= 0; --i )
4325 {
4326 if ( mRendererGenerators.at( i )->id() == id )
4327 {
4328 delete mRendererGenerators.at( i );
4329 mRendererGenerators.removeAt( i );
4330 }
4331 }
4332}
4333
4334QList<const QgsFeatureRendererGenerator *> QgsVectorLayer::featureRendererGenerators() const
4335{
4336 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4338
4339 QList< const QgsFeatureRendererGenerator * > res;
4340 for ( const QgsFeatureRendererGenerator *generator : mRendererGenerators )
4341 res << generator;
4342 return res;
4343}
4344
4345void QgsVectorLayer::beginEditCommand( const QString &text )
4346{
4348
4349 if ( !mDataProvider )
4350 {
4351 return;
4352 }
4353 if ( mDataProvider->transaction() )
4354 {
4355 QString ignoredError;
4356 mDataProvider->transaction()->createSavepoint( ignoredError );
4357 }
4358 undoStack()->beginMacro( text );
4359 mEditCommandActive = true;
4360 emit editCommandStarted( text );
4361}
4362
4364{
4366
4367 if ( !mDataProvider )
4368 {
4369 return;
4370 }
4371 undoStack()->endMacro();
4372 mEditCommandActive = false;
4373 if ( !mDeletedFids.isEmpty() )
4374 {
4375 if ( selectedFeatureCount() > 0 )
4376 {
4377 mSelectedFeatureIds.subtract( mDeletedFids );
4378 }
4379 emit featuresDeleted( mDeletedFids );
4380 mDeletedFids.clear();
4381 }
4382 emit editCommandEnded();
4383}
4384
4386{
4388
4389 if ( !mDataProvider )
4390 {
4391 return;
4392 }
4393 undoStack()->endMacro();
4394 undoStack()->undo();
4395
4396 // it's not directly possible to pop the last command off the stack (the destroyed one)
4397 // and delete, so we add a dummy obsolete command to force this to occur.
4398 // Pushing the new command deletes the destroyed one, and since the new
4399 // command is obsolete it's automatically deleted by the undo stack.
4400 auto command = std::make_unique< QUndoCommand >();
4401 command->setObsolete( true );
4402 undoStack()->push( command.release() );
4403
4404 mEditCommandActive = false;
4405 mDeletedFids.clear();
4406 emit editCommandDestroyed();
4407}
4408
4410{
4412
4413 return mJoinBuffer->addJoin( joinInfo );
4414}
4415
4416bool QgsVectorLayer::removeJoin( const QString &joinLayerId )
4417{
4419
4420 return mJoinBuffer->removeJoin( joinLayerId );
4421}
4422
4423const QList< QgsVectorLayerJoinInfo > QgsVectorLayer::vectorJoins() const
4424{
4426
4427 return mJoinBuffer->vectorJoins();
4428}
4429
4430int QgsVectorLayer::addExpressionField( const QString &exp, const QgsField &fld )
4431{
4433
4434 emit beforeAddingExpressionField( fld.name() );
4435 mExpressionFieldBuffer->addExpression( exp, fld );
4436 updateFields();
4437 int idx = mFields.indexFromName( fld.name() );
4438 emit attributeAdded( idx );
4439 return idx;
4440}
4441
4443{
4445
4446 emit beforeRemovingExpressionField( index );
4447 int oi = mFields.fieldOriginIndex( index );
4448 mExpressionFieldBuffer->removeExpression( oi );
4449 updateFields();
4450 emit attributeDeleted( index );
4451}
4452
4453QString QgsVectorLayer::expressionField( int index ) const
4454{
4456
4457 if ( mFields.fieldOrigin( index ) != Qgis::FieldOrigin::Expression )
4458 return QString();
4459
4460 int oi = mFields.fieldOriginIndex( index );
4461 if ( oi < 0 || oi >= mExpressionFieldBuffer->expressions().size() )
4462 return QString();
4463
4464 return mExpressionFieldBuffer->expressions().at( oi ).cachedExpression.expression();
4465}
4466
4467void QgsVectorLayer::updateExpressionField( int index, const QString &exp )
4468{
4470
4471 int oi = mFields.fieldOriginIndex( index );
4472 mExpressionFieldBuffer->updateExpression( oi, exp );
4473}
4474
4476{
4477 // non fatal for now -- the QgsVirtualLayerTask class is not thread safe and calls this
4479
4480 if ( !mDataProvider )
4481 return;
4482
4483 QgsFields oldFields = mFields;
4484
4485 mFields = mDataProvider->fields();
4486
4487 // added / removed fields
4488 if ( mEditBuffer )
4489 mEditBuffer->updateFields( mFields );
4490
4491 // joined fields
4492 if ( mJoinBuffer->containsJoins() )
4493 mJoinBuffer->updateFields( mFields );
4494
4495 if ( mExpressionFieldBuffer )
4496 mExpressionFieldBuffer->updateFields( mFields );
4497
4498 // set aliases and default values
4499 for ( auto aliasIt = mAttributeAliasMap.constBegin(); aliasIt != mAttributeAliasMap.constEnd(); ++aliasIt )
4500 {
4501 int index = mFields.lookupField( aliasIt.key() );
4502 if ( index < 0 )
4503 continue;
4504
4505 mFields[ index ].setAlias( aliasIt.value() );
4506 }
4507
4508 for ( auto splitPolicyIt = mAttributeSplitPolicy.constBegin(); splitPolicyIt != mAttributeSplitPolicy.constEnd(); ++splitPolicyIt )
4509 {
4510 int index = mFields.lookupField( splitPolicyIt.key() );
4511 if ( index < 0 )
4512 continue;
4513
4514 mFields[ index ].setSplitPolicy( splitPolicyIt.value() );
4515 }
4516
4517 for ( auto duplicatePolicyIt = mAttributeDuplicatePolicy.constBegin(); duplicatePolicyIt != mAttributeDuplicatePolicy.constEnd(); ++duplicatePolicyIt )
4518 {
4519 int index = mFields.lookupField( duplicatePolicyIt.key() );
4520 if ( index < 0 )
4521 continue;
4522
4523 mFields[ index ].setDuplicatePolicy( duplicatePolicyIt.value() );
4524 }
4525
4526 // Update configuration flags
4527 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
4528 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
4529 {
4530 int index = mFields.lookupField( flagsIt.key() );
4531 if ( index < 0 )
4532 continue;
4533
4534 mFields[index].setConfigurationFlags( flagsIt.value() );
4535 }
4536
4537 // Update default values
4538 mDefaultValueOnUpdateFields.clear();
4539 QMap< QString, QgsDefaultValue >::const_iterator defaultIt = mDefaultExpressionMap.constBegin();
4540 for ( ; defaultIt != mDefaultExpressionMap.constEnd(); ++defaultIt )
4541 {
4542 int index = mFields.lookupField( defaultIt.key() );
4543 if ( index < 0 )
4544 continue;
4545
4546 mFields[ index ].setDefaultValueDefinition( defaultIt.value() );
4547 if ( defaultIt.value().applyOnUpdate() )
4548 mDefaultValueOnUpdateFields.insert( index );
4549 }
4550
4551 QMap< QString, QgsFieldConstraints::Constraints >::const_iterator constraintIt = mFieldConstraints.constBegin();
4552 for ( ; constraintIt != mFieldConstraints.constEnd(); ++constraintIt )
4553 {
4554 int index = mFields.lookupField( constraintIt.key() );
4555 if ( index < 0 )
4556 continue;
4557
4558 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4559
4560 // always keep provider constraints intact
4561 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintNotNull ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintNotNull ) )
4563 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintUnique ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintUnique ) )
4565 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintExpression ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintExpression ) )
4567 mFields[ index ].setConstraints( constraints );
4568 }
4569
4570 QMap< QString, QPair< QString, QString > >::const_iterator constraintExpIt = mFieldConstraintExpressions.constBegin();
4571 for ( ; constraintExpIt != mFieldConstraintExpressions.constEnd(); ++constraintExpIt )
4572 {
4573 int index = mFields.lookupField( constraintExpIt.key() );
4574 if ( index < 0 )
4575 continue;
4576
4577 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4578
4579 // always keep provider constraints intact
4581 continue;
4582
4583 constraints.setConstraintExpression( constraintExpIt.value().first, constraintExpIt.value().second );
4584 mFields[ index ].setConstraints( constraints );
4585 }
4586
4587 QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength >::const_iterator constraintStrengthIt = mFieldConstraintStrength.constBegin();
4588 for ( ; constraintStrengthIt != mFieldConstraintStrength.constEnd(); ++constraintStrengthIt )
4589 {
4590 int index = mFields.lookupField( constraintStrengthIt.key().first );
4591 if ( index < 0 )
4592 continue;
4593
4594 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4595
4596 // always keep provider constraints intact
4598 continue;
4599
4600 constraints.setConstraintStrength( constraintStrengthIt.key().second, constraintStrengthIt.value() );
4601 mFields[ index ].setConstraints( constraints );
4602 }
4603
4604 auto fieldWidgetIterator = mFieldWidgetSetups.constBegin();
4605 for ( ; fieldWidgetIterator != mFieldWidgetSetups.constEnd(); ++ fieldWidgetIterator )
4606 {
4607 int index = mFields.indexOf( fieldWidgetIterator.key() );
4608 if ( index < 0 )
4609 continue;
4610
4611 mFields[index].setEditorWidgetSetup( fieldWidgetIterator.value() );
4612 }
4613
4614 if ( oldFields != mFields )
4615 {
4616 emit updatedFields();
4617 mEditFormConfig.setFields( mFields );
4618 }
4619
4620}
4621
4622QVariant QgsVectorLayer::defaultValue( int index, const QgsFeature &feature, QgsExpressionContext *context ) const
4623{
4625
4626 if ( index < 0 || index >= mFields.count() || !mDataProvider )
4627 return QVariant();
4628
4629 QString expression = mFields.at( index ).defaultValueDefinition().expression();
4630 if ( expression.isEmpty() )
4631 return mDataProvider->defaultValue( index );
4632
4633 QgsExpressionContext *evalContext = context;
4634 std::unique_ptr< QgsExpressionContext > tempContext;
4635 if ( !evalContext )
4636 {
4637 // no context passed, so we create a default one
4639 evalContext = tempContext.get();
4640 }
4641
4642 if ( feature.isValid() )
4643 {
4645 featScope->setFeature( feature );
4646 featScope->setFields( feature.fields() );
4647 evalContext->appendScope( featScope );
4648 }
4649
4650 QVariant val;
4651 QgsExpression exp( expression );
4652 exp.prepare( evalContext );
4653 if ( exp.hasEvalError() )
4654 {
4655 QgsLogger::warning( "Error evaluating default value: " + exp.evalErrorString() );
4656 }
4657 else
4658 {
4659 val = exp.evaluate( evalContext );
4660 }
4661
4662 if ( feature.isValid() )
4663 {
4664 delete evalContext->popScope();
4665 }
4666
4667 return val;
4668}
4669
4671{
4673
4674 if ( index < 0 || index >= mFields.count() )
4675 return;
4676
4677 if ( definition.isValid() )
4678 {
4679 mDefaultExpressionMap.insert( mFields.at( index ).name(), definition );
4680 }
4681 else
4682 {
4683 mDefaultExpressionMap.remove( mFields.at( index ).name() );
4684 }
4685 updateFields();
4686}
4687
4689{
4691
4692 if ( index < 0 || index >= mFields.count() )
4693 return QgsDefaultValue();
4694 else
4695 return mFields.at( index ).defaultValueDefinition();
4696}
4697
4698QSet<QVariant> QgsVectorLayer::uniqueValues( int index, int limit ) const
4699{
4701
4702 QSet<QVariant> uniqueValues;
4703 if ( !mDataProvider )
4704 {
4705 return uniqueValues;
4706 }
4707
4708 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
4709 switch ( origin )
4710 {
4712 return uniqueValues;
4713
4714 case Qgis::FieldOrigin::Provider: //a provider field
4715 {
4716 uniqueValues = mDataProvider->uniqueValues( index, limit );
4717
4718 if ( mEditBuffer && ! mDataProvider->transaction() )
4719 {
4720 QSet<QString> vals;
4721 const auto constUniqueValues = uniqueValues;
4722 for ( const QVariant &v : constUniqueValues )
4723 {
4724 vals << v.toString();
4725 }
4726
4727 QgsFeatureMap added = mEditBuffer->addedFeatures();
4728 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
4729 while ( addedIt.hasNext() && ( limit < 0 || uniqueValues.count() < limit ) )
4730 {
4731 addedIt.next();
4732 QVariant v = addedIt.value().attribute( index );
4733 if ( v.isValid() )
4734 {
4735 QString vs = v.toString();
4736 if ( !vals.contains( vs ) )
4737 {
4738 vals << vs;
4739 uniqueValues << v;
4740 }
4741 }
4742 }
4743
4744 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
4745 while ( it.hasNext() && ( limit < 0 || uniqueValues.count() < limit ) )
4746 {
4747 it.next();
4748 QVariant v = it.value().value( index );
4749 if ( v.isValid() )
4750 {
4751 QString vs = v.toString();
4752 if ( !vals.contains( vs ) )
4753 {
4754 vals << vs;
4755 uniqueValues << v;
4756 }
4757 }
4758 }
4759 }
4760
4761 return uniqueValues;
4762 }
4763
4765 // the layer is editable, but in certain cases it can still be avoided going through all features
4766 if ( mDataProvider->transaction() || (
4767 mEditBuffer->deletedFeatureIds().isEmpty() &&
4768 mEditBuffer->addedFeatures().isEmpty() &&
4769 !mEditBuffer->deletedAttributeIds().contains( index ) &&
4770 mEditBuffer->changedAttributeValues().isEmpty() ) )
4771 {
4772 uniqueValues = mDataProvider->uniqueValues( index, limit );
4773 return uniqueValues;
4774 }
4775 [[fallthrough]];
4776 //we need to go through each feature
4779 {
4780 QgsAttributeList attList;
4781 attList << index;
4782
4785 .setSubsetOfAttributes( attList ) );
4786
4787 QgsFeature f;
4788 QVariant currentValue;
4789 QHash<QString, QVariant> val;
4790 while ( fit.nextFeature( f ) )
4791 {
4792 currentValue = f.attribute( index );
4793 val.insert( currentValue.toString(), currentValue );
4794 if ( limit >= 0 && val.size() >= limit )
4795 {
4796 break;
4797 }
4798 }
4799
4800 return qgis::listToSet( val.values() );
4801 }
4802 }
4803
4804 Q_ASSERT_X( false, "QgsVectorLayer::uniqueValues()", "Unknown source of the field!" );
4805 return uniqueValues;
4806}
4807
4808QStringList QgsVectorLayer::uniqueStringsMatching( int index, const QString &substring, int limit, QgsFeedback *feedback ) const
4809{
4811
4812 QStringList results;
4813 if ( !mDataProvider )
4814 {
4815 return results;
4816 }
4817
4818 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
4819 switch ( origin )
4820 {
4822 return results;
4823
4824 case Qgis::FieldOrigin::Provider: //a provider field
4825 {
4826 results = mDataProvider->uniqueStringsMatching( index, substring, limit, feedback );
4827
4828 if ( mEditBuffer && ! mDataProvider->transaction() )
4829 {
4830 QgsFeatureMap added = mEditBuffer->addedFeatures();
4831 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
4832 while ( addedIt.hasNext() && ( limit < 0 || results.count() < limit ) && ( !feedback || !feedback->isCanceled() ) )
4833 {
4834 addedIt.next();
4835 QVariant v = addedIt.value().attribute( index );
4836 if ( v.isValid() )
4837 {
4838 QString vs = v.toString();
4839 if ( vs.contains( substring, Qt::CaseInsensitive ) && !results.contains( vs ) )
4840 {
4841 results << vs;
4842 }
4843 }
4844 }
4845
4846 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
4847 while ( it.hasNext() && ( limit < 0 || results.count() < limit ) && ( !feedback || !feedback->isCanceled() ) )
4848 {
4849 it.next();
4850 QVariant v = it.value().value( index );
4851 if ( v.isValid() )
4852 {
4853 QString vs = v.toString();
4854 if ( vs.contains( substring, Qt::CaseInsensitive ) && !results.contains( vs ) )
4855 {
4856 results << vs;
4857 }
4858 }
4859 }
4860 }
4861
4862 return results;
4863 }
4864
4866 // the layer is editable, but in certain cases it can still be avoided going through all features
4867 if ( mDataProvider->transaction() || ( mEditBuffer->deletedFeatureIds().isEmpty() &&
4868 mEditBuffer->addedFeatures().isEmpty() &&
4869 !mEditBuffer->deletedAttributeIds().contains( index ) &&
4870 mEditBuffer->changedAttributeValues().isEmpty() ) )
4871 {
4872 return mDataProvider->uniqueStringsMatching( index, substring, limit, feedback );
4873 }
4874 [[fallthrough]];
4875 //we need to go through each feature
4878 {
4879 QgsAttributeList attList;
4880 attList << index;
4881
4882 QgsFeatureRequest request;
4883 request.setSubsetOfAttributes( attList );
4885 QString fieldName = mFields.at( index ).name();
4886 request.setFilterExpression( QStringLiteral( "\"%1\" ILIKE '%%2%'" ).arg( fieldName, substring ) );
4887 QgsFeatureIterator fit = getFeatures( request );
4888
4889 QgsFeature f;
4890 QString currentValue;
4891 while ( fit.nextFeature( f ) )
4892 {
4893 currentValue = f.attribute( index ).toString();
4894 if ( !results.contains( currentValue ) )
4895 results << currentValue;
4896
4897 if ( ( limit >= 0 && results.size() >= limit ) || ( feedback && feedback->isCanceled() ) )
4898 {
4899 break;
4900 }
4901 }
4902
4903 return results;
4904 }
4905 }
4906
4907 Q_ASSERT_X( false, "QgsVectorLayer::uniqueStringsMatching()", "Unknown source of the field!" );
4908 return results;
4909}
4910
4911QVariant QgsVectorLayer::minimumValue( int index ) const
4912{
4914
4915 QVariant minimum;
4916 minimumOrMaximumValue( index, &minimum, nullptr );
4917 return minimum;
4918}
4919
4920QVariant QgsVectorLayer::maximumValue( int index ) const
4921{
4923
4924 QVariant maximum;
4925 minimumOrMaximumValue( index, nullptr, &maximum );
4926 return maximum;
4927}
4928
4929void QgsVectorLayer::minimumAndMaximumValue( int index, QVariant &minimum, QVariant &maximum ) const
4930{
4932
4933 minimumOrMaximumValue( index, &minimum, &maximum );
4934}
4935
4936void QgsVectorLayer::minimumOrMaximumValue( int index, QVariant *minimum, QVariant *maximum ) const
4937{
4939
4940 if ( minimum )
4941 *minimum = QVariant();
4942 if ( maximum )
4943 *maximum = QVariant();
4944
4945 if ( !mDataProvider )
4946 {
4947 return;
4948 }
4949
4950 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
4951
4952 switch ( origin )
4953 {
4955 {
4956 return;
4957 }
4958
4959 case Qgis::FieldOrigin::Provider: //a provider field
4960 {
4961 if ( minimum )
4962 *minimum = mDataProvider->minimumValue( index );
4963 if ( maximum )
4964 *maximum = mDataProvider->maximumValue( index );
4965 if ( mEditBuffer && ! mDataProvider->transaction() )
4966 {
4967 const QgsFeatureMap added = mEditBuffer->addedFeatures();
4968 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
4969 while ( addedIt.hasNext() )
4970 {
4971 addedIt.next();
4972 const QVariant v = addedIt.value().attribute( index );
4973 if ( minimum && v.isValid() && qgsVariantLessThan( v, *minimum ) )
4974 *minimum = v;
4975 if ( maximum && v.isValid() && qgsVariantGreaterThan( v, *maximum ) )
4976 *maximum = v;
4977 }
4978
4979 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
4980 while ( it.hasNext() )
4981 {
4982 it.next();
4983 const QVariant v = it.value().value( index );
4984 if ( minimum && v.isValid() && qgsVariantLessThan( v, *minimum ) )
4985 *minimum = v;
4986 if ( maximum && v.isValid() && qgsVariantGreaterThan( v, *maximum ) )
4987 *maximum = v;
4988 }
4989 }
4990 return;
4991 }
4992
4994 {
4995 // the layer is editable, but in certain cases it can still be avoided going through all features
4996 if ( mDataProvider->transaction() || ( mEditBuffer->deletedFeatureIds().isEmpty() &&
4997 mEditBuffer->addedFeatures().isEmpty() &&
4998 !mEditBuffer->deletedAttributeIds().contains( index ) &&
4999 mEditBuffer->changedAttributeValues().isEmpty() ) )
5000 {
5001 if ( minimum )
5002 *minimum = mDataProvider->minimumValue( index );
5003 if ( maximum )
5004 *maximum = mDataProvider->maximumValue( index );
5005 return;
5006 }
5007 }
5008 [[fallthrough]];
5009 // no choice but to go through all features
5012 {
5013 // we need to go through each feature
5014 QgsAttributeList attList;
5015 attList << index;
5016
5019 .setSubsetOfAttributes( attList ) );
5020
5021 QgsFeature f;
5022 bool firstValue = true;
5023 while ( fit.nextFeature( f ) )
5024 {
5025 const QVariant currentValue = f.attribute( index );
5026 if ( QgsVariantUtils::isNull( currentValue ) )
5027 continue;
5028
5029 if ( firstValue )
5030 {
5031 if ( minimum )
5032 *minimum = currentValue;
5033 if ( maximum )
5034 *maximum = currentValue;
5035 firstValue = false;
5036 }
5037 else
5038 {
5039 if ( minimum && currentValue.isValid() && qgsVariantLessThan( currentValue, *minimum ) )
5040 *minimum = currentValue;
5041 if ( maximum && currentValue.isValid() && qgsVariantGreaterThan( currentValue, *maximum ) )
5042 *maximum = currentValue;
5043 }
5044 }
5045 return;
5046 }
5047 }
5048
5049 Q_ASSERT_X( false, "QgsVectorLayer::minimumOrMaximumValue()", "Unknown source of the field!" );
5050}
5051
5052void QgsVectorLayer::createEditBuffer()
5053{
5055
5056 if ( mEditBuffer )
5057 clearEditBuffer();
5058
5059 if ( mDataProvider->transaction() )
5060 {
5061 mEditBuffer = new QgsVectorLayerEditPassthrough( this );
5062
5063 connect( mDataProvider->transaction(), &QgsTransaction::dirtied, this, &QgsVectorLayer::onDirtyTransaction, Qt::UniqueConnection );
5064 }
5065 else
5066 {
5067 mEditBuffer = new QgsVectorLayerEditBuffer( this );
5068 }
5069 // forward signals
5070 connect( mEditBuffer, &QgsVectorLayerEditBuffer::layerModified, this, &QgsVectorLayer::invalidateSymbolCountedFlag );
5071 connect( mEditBuffer, &QgsVectorLayerEditBuffer::layerModified, this, &QgsVectorLayer::layerModified ); // TODO[MD]: necessary?
5072 //connect( mEditBuffer, SIGNAL( layerModified() ), this, SLOT( triggerRepaint() ) ); // TODO[MD]: works well?
5073 connect( mEditBuffer, &QgsVectorLayerEditBuffer::featureAdded, this, &QgsVectorLayer::onFeatureAdded );
5074 connect( mEditBuffer, &QgsVectorLayerEditBuffer::featureDeleted, this, &QgsVectorLayer::onFeatureDeleted );
5085
5086}
5087
5088void QgsVectorLayer::clearEditBuffer()
5089{
5091
5092 delete mEditBuffer;
5093 mEditBuffer = nullptr;
5094}
5095
5096QVariant QgsVectorLayer::aggregate( Qgis::Aggregate aggregate, const QString &fieldOrExpression,
5098 bool *ok, QgsFeatureIds *fids, QgsFeedback *feedback, QString *error ) const
5099{
5100 // non fatal for now -- the aggregate expression functions are not thread safe and call this
5102
5103 if ( ok )
5104 *ok = false;
5105 if ( error )
5106 error->clear();
5107
5108 if ( !mDataProvider )
5109 {
5110 if ( error )
5111 *error = tr( "Layer is invalid" );
5112 return QVariant();
5113 }
5114
5115 // test if we are calculating based on a field
5116 const int attrIndex = QgsExpression::expressionToLayerFieldIndex( fieldOrExpression, this );
5117 if ( attrIndex >= 0 )
5118 {
5119 // aggregate is based on a field - if it's a provider field, we could possibly hand over the calculation
5120 // to the provider itself
5121 Qgis::FieldOrigin origin = mFields.fieldOrigin( attrIndex );
5122 if ( origin == Qgis::FieldOrigin::Provider )
5123 {
5124 bool providerOk = false;
5125 QVariant val = mDataProvider->aggregate( aggregate, attrIndex, parameters, context, providerOk, fids );
5126 if ( providerOk )
5127 {
5128 // provider handled calculation
5129 if ( ok )
5130 *ok = true;
5131 return val;
5132 }
5133 }
5134 }
5135
5136 // fallback to using aggregate calculator to determine aggregate
5137 QgsAggregateCalculator c( this );
5138 if ( fids )
5139 c.setFidsFilter( *fids );
5140 c.setParameters( parameters );
5141 bool aggregateOk = false;
5142 const QVariant result = c.calculate( aggregate, fieldOrExpression, context, &aggregateOk, feedback );
5143 if ( ok )
5144 *ok = aggregateOk;
5145 if ( !aggregateOk && error )
5146 *error = c.lastError();
5147
5148 return result;
5149}
5150
5151void QgsVectorLayer::setFeatureBlendMode( QPainter::CompositionMode featureBlendMode )
5152{
5154
5155 if ( mFeatureBlendMode == featureBlendMode )
5156 return;
5157
5158 mFeatureBlendMode = featureBlendMode;
5161}
5162
5163QPainter::CompositionMode QgsVectorLayer::featureBlendMode() const
5164{
5165 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
5167
5168 return mFeatureBlendMode;
5169}
5170
5171void QgsVectorLayer::readSldLabeling( const QDomNode &node )
5172{
5174
5175 setLabeling( nullptr ); // start with no labeling
5176 setLabelsEnabled( false );
5177
5178 QDomElement element = node.toElement();
5179 if ( element.isNull() )
5180 return;
5181
5182 QDomElement userStyleElem = element.firstChildElement( QStringLiteral( "UserStyle" ) );
5183 if ( userStyleElem.isNull() )
5184 {
5185 QgsDebugMsgLevel( QStringLiteral( "Info: UserStyle element not found." ), 4 );
5186 return;
5187 }
5188
5189 QDomElement featTypeStyleElem = userStyleElem.firstChildElement( QStringLiteral( "FeatureTypeStyle" ) );
5190 if ( featTypeStyleElem.isNull() )
5191 {
5192 QgsDebugMsgLevel( QStringLiteral( "Info: FeatureTypeStyle element not found." ), 4 );
5193 return;
5194 }
5195
5196 // create empty FeatureTypeStyle element to merge TextSymbolizer's Rule's from all FeatureTypeStyle's
5197 QDomElement mergedFeatTypeStyle = featTypeStyleElem.cloneNode( false ).toElement();
5198
5199 // use the RuleRenderer when more rules are present or the rule
5200 // has filters or min/max scale denominators set,
5201 // otherwise use the Simple labeling
5202 bool needRuleBasedLabeling = false;
5203 int ruleCount = 0;
5204
5205 while ( !featTypeStyleElem.isNull() )
5206 {
5207 QDomElement ruleElem = featTypeStyleElem.firstChildElement( QStringLiteral( "Rule" ) );
5208 while ( !ruleElem.isNull() )
5209 {
5210 // test rule children element to check if we need to create RuleRenderer
5211 // and if the rule has a symbolizer
5212 bool hasTextSymbolizer = false;
5213 bool hasRuleBased = false;
5214 QDomElement ruleChildElem = ruleElem.firstChildElement();
5215 while ( !ruleChildElem.isNull() )
5216 {
5217 // rule has filter or min/max scale denominator, use the RuleRenderer
5218 if ( ruleChildElem.localName() == QLatin1String( "Filter" ) ||
5219 ruleChildElem.localName() == QLatin1String( "MinScaleDenominator" ) ||
5220 ruleChildElem.localName() == QLatin1String( "MaxScaleDenominator" ) )
5221 {
5222 hasRuleBased = true;
5223 }
5224 // rule has a renderer symbolizer, not a text symbolizer
5225 else if ( ruleChildElem.localName() == QLatin1String( "TextSymbolizer" ) )
5226 {
5227 QgsDebugMsgLevel( QStringLiteral( "Info: TextSymbolizer element found" ), 4 );
5228 hasTextSymbolizer = true;
5229 }
5230
5231 ruleChildElem = ruleChildElem.nextSiblingElement();
5232 }
5233
5234 if ( hasTextSymbolizer )
5235 {
5236 ruleCount++;
5237
5238 // append a clone of all Rules to the merged FeatureTypeStyle element
5239 mergedFeatTypeStyle.appendChild( ruleElem.cloneNode().toElement() );
5240
5241 if ( hasRuleBased )
5242 {
5243 QgsDebugMsgLevel( QStringLiteral( "Info: Filter or Min/MaxScaleDenominator element found: need a RuleBasedLabeling" ), 4 );
5244 needRuleBasedLabeling = true;
5245 }
5246 }
5247
5248 // more rules present, use the RuleRenderer
5249 if ( ruleCount > 1 )
5250 {
5251 QgsDebugMsgLevel( QStringLiteral( "Info: More Rule elements found: need a RuleBasedLabeling" ), 4 );
5252 needRuleBasedLabeling = true;
5253 }
5254
5255 // not use the rule based labeling if no rules with textSymbolizer
5256 if ( ruleCount == 0 )
5257 {
5258 needRuleBasedLabeling = false;
5259 }
5260
5261 ruleElem = ruleElem.nextSiblingElement( QStringLiteral( "Rule" ) );
5262 }
5263 featTypeStyleElem = featTypeStyleElem.nextSiblingElement( QStringLiteral( "FeatureTypeStyle" ) );
5264 }
5265
5266 if ( ruleCount == 0 )
5267 {
5268 QgsDebugMsgLevel( QStringLiteral( "Info: No TextSymbolizer element." ), 4 );
5269 return;
5270 }
5271
5272 QDomElement ruleElem = mergedFeatTypeStyle.firstChildElement( QStringLiteral( "Rule" ) );
5273
5274 if ( needRuleBasedLabeling )
5275 {
5276 QgsDebugMsgLevel( QStringLiteral( "Info: rule based labeling" ), 4 );
5277 QgsRuleBasedLabeling::Rule *rootRule = new QgsRuleBasedLabeling::Rule( nullptr );
5278 while ( !ruleElem.isNull() )
5279 {
5280
5281 QString label, description, filterExp;
5282 int scaleMinDenom = 0, scaleMaxDenom = 0;
5283 QgsPalLayerSettings settings;
5284
5285 // retrieve the Rule element child nodes
5286 QDomElement childElem = ruleElem.firstChildElement();
5287 while ( !childElem.isNull() )
5288 {
5289 if ( childElem.localName() == QLatin1String( "Name" ) )
5290 {
5291 // <se:Name> tag contains the rule identifier,
5292 // so prefer title tag for the label property value
5293 if ( label.isEmpty() )
5294 label = childElem.firstChild().nodeValue();
5295 }
5296 else if ( childElem.localName() == QLatin1String( "Description" ) )
5297 {
5298 // <se:Description> can contains a title and an abstract
5299 QDomElement titleElem = childElem.firstChildElement( QStringLiteral( "Title" ) );
5300 if ( !titleElem.isNull() )
5301 {
5302 label = titleElem.firstChild().nodeValue();
5303 }
5304
5305 QDomElement abstractElem = childElem.firstChildElement( QStringLiteral( "Abstract" ) );
5306 if ( !abstractElem.isNull() )
5307 {
5308 description = abstractElem.firstChild().nodeValue();
5309 }
5310 }
5311 else if ( childElem.localName() == QLatin1String( "Abstract" ) )
5312 {
5313 // <sld:Abstract> (v1.0)
5314 description = childElem.firstChild().nodeValue();
5315 }
5316 else if ( childElem.localName() == QLatin1String( "Title" ) )
5317 {
5318 // <sld:Title> (v1.0)
5319 label = childElem.firstChild().nodeValue();
5320 }
5321 else if ( childElem.localName() == QLatin1String( "Filter" ) )
5322 {
5324 if ( filter )
5325 {
5326 if ( filter->hasParserError() )
5327 {
5328 QgsDebugMsgLevel( QStringLiteral( "SLD Filter parsing error: %1" ).arg( filter->parserErrorString() ), 3 );
5329 }
5330 else
5331 {
5332 filterExp = filter->expression();
5333 }
5334 delete filter;
5335 }
5336 }
5337 else if ( childElem.localName() == QLatin1String( "MinScaleDenominator" ) )
5338 {
5339 bool ok;
5340 int v = childElem.firstChild().nodeValue().toInt( &ok );
5341 if ( ok )
5342 scaleMinDenom = v;
5343 }
5344 else if ( childElem.localName() == QLatin1String( "MaxScaleDenominator" ) )
5345 {
5346 bool ok;
5347 int v = childElem.firstChild().nodeValue().toInt( &ok );
5348 if ( ok )
5349 scaleMaxDenom = v;
5350 }
5351 else if ( childElem.localName() == QLatin1String( "TextSymbolizer" ) )
5352 {
5353 readSldTextSymbolizer( childElem, settings );
5354 }
5355
5356 childElem = childElem.nextSiblingElement();
5357 }
5358
5359 QgsRuleBasedLabeling::Rule *ruleLabeling = new QgsRuleBasedLabeling::Rule( new QgsPalLayerSettings( settings ), scaleMinDenom, scaleMaxDenom, filterExp, label );
5360 rootRule->appendChild( ruleLabeling );
5361
5362 ruleElem = ruleElem.nextSiblingElement();
5363 }
5364
5365 setLabeling( new QgsRuleBasedLabeling( rootRule ) );
5366 setLabelsEnabled( true );
5367 }
5368 else
5369 {
5370 QgsDebugMsgLevel( QStringLiteral( "Info: simple labeling" ), 4 );
5371 // retrieve the TextSymbolizer element child node
5372 QDomElement textSymbolizerElem = ruleElem.firstChildElement( QStringLiteral( "TextSymbolizer" ) );
5374 if ( readSldTextSymbolizer( textSymbolizerElem, s ) )
5375 {
5377 setLabelsEnabled( true );
5378 }
5379 }
5380}
5381
5382bool QgsVectorLayer::readSldTextSymbolizer( const QDomNode &node, QgsPalLayerSettings &settings ) const
5383{
5385
5386 if ( node.localName() != QLatin1String( "TextSymbolizer" ) )
5387 {
5388 QgsDebugMsgLevel( QStringLiteral( "Not a TextSymbolizer element: %1" ).arg( node.localName() ), 3 );
5389 return false;
5390 }
5391 QDomElement textSymbolizerElem = node.toElement();
5392 // Label
5393 QDomElement labelElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Label" ) );
5394 if ( !labelElem.isNull() )
5395 {
5396 QDomElement propertyNameElem = labelElem.firstChildElement( QStringLiteral( "PropertyName" ) );
5397 if ( !propertyNameElem.isNull() )
5398 {
5399 // set labeling defaults
5400
5401 // label attribute
5402 QString labelAttribute = propertyNameElem.text();
5403 settings.fieldName = labelAttribute;
5404 settings.isExpression = false;
5405
5406 int fieldIndex = mFields.lookupField( labelAttribute );
5407 if ( fieldIndex == -1 )
5408 {
5409 // label attribute is not in columns, check if it is an expression
5410 QgsExpression exp( labelAttribute );
5411 if ( !exp.hasEvalError() )
5412 {
5413 settings.isExpression = true;
5414 }
5415 else
5416 {
5417 QgsDebugMsgLevel( QStringLiteral( "SLD label attribute error: %1" ).arg( exp.evalErrorString() ), 3 );
5418 }
5419 }
5420 }
5421 else
5422 {
5423 QgsDebugMsgLevel( QStringLiteral( "Info: PropertyName element not found." ), 4 );
5424 return false;
5425 }
5426 }
5427 else
5428 {
5429 QgsDebugMsgLevel( QStringLiteral( "Info: Label element not found." ), 4 );
5430 return false;
5431 }
5432
5434 if ( textSymbolizerElem.hasAttribute( QStringLiteral( "uom" ) ) )
5435 {
5436 sldUnitSize = QgsSymbolLayerUtils::decodeSldUom( textSymbolizerElem.attribute( QStringLiteral( "uom" ) ) );
5437 }
5438
5439 QString fontFamily = QStringLiteral( "Sans-Serif" );
5440 int fontPointSize = 10;
5442 int fontWeight = -1;
5443 bool fontItalic = false;
5444 bool fontUnderline = false;
5445
5446 // Font
5447 QDomElement fontElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Font" ) );
5448 if ( !fontElem.isNull() )
5449 {
5450 QgsStringMap fontSvgParams = QgsSymbolLayerUtils::getSvgParameterList( fontElem );
5451 for ( QgsStringMap::iterator it = fontSvgParams.begin(); it != fontSvgParams.end(); ++it )
5452 {
5453 QgsDebugMsgLevel( QStringLiteral( "found fontSvgParams %1: %2" ).arg( it.key(), it.value() ), 4 );
5454
5455 if ( it.key() == QLatin1String( "font-family" ) )
5456 {
5457 fontFamily = it.value();
5458 }
5459 else if ( it.key() == QLatin1String( "font-style" ) )
5460 {
5461 fontItalic = ( it.value() == QLatin1String( "italic" ) ) || ( it.value() == QLatin1String( "Italic" ) );
5462 }
5463 else if ( it.key() == QLatin1String( "font-size" ) )
5464 {
5465 bool ok;
5466 int fontSize = it.value().toInt( &ok );
5467 if ( ok )
5468 {
5469 fontPointSize = fontSize;
5470 fontUnitSize = sldUnitSize;
5471 }
5472 }
5473 else if ( it.key() == QLatin1String( "font-weight" ) )
5474 {
5475 if ( ( it.value() == QLatin1String( "bold" ) ) || ( it.value() == QLatin1String( "Bold" ) ) )
5476 fontWeight = QFont::Bold;
5477 }
5478 else if ( it.key() == QLatin1String( "font-underline" ) )
5479 {
5480 fontUnderline = ( it.value() == QLatin1String( "underline" ) ) || ( it.value() == QLatin1String( "Underline" ) );
5481 }
5482 }
5483 }
5484
5485 QgsTextFormat format;
5486 QFont font( fontFamily, fontPointSize, fontWeight, fontItalic );
5487 font.setUnderline( fontUnderline );
5488 format.setFont( font );
5489 format.setSize( fontPointSize );
5490 format.setSizeUnit( fontUnitSize );
5491
5492 // Fill
5493 QDomElement fillElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Fill" ) );
5494 QColor textColor;
5495 Qt::BrushStyle textBrush = Qt::SolidPattern;
5496 QgsSymbolLayerUtils::fillFromSld( fillElem, textBrush, textColor );
5497 if ( textColor.isValid() )
5498 {
5499 QgsDebugMsgLevel( QStringLiteral( "Info: textColor %1." ).arg( QVariant( textColor ).toString() ), 4 );
5500 format.setColor( textColor );
5501 }
5502
5503 QgsTextBufferSettings bufferSettings;
5504
5505 // Halo
5506 QDomElement haloElem = textSymbolizerElem.firstChildElement( QStringLiteral( "Halo" ) );
5507 if ( !haloElem.isNull() )
5508 {
5509 bufferSettings.setEnabled( true );
5510 bufferSettings.setSize( 1 );
5511
5512 QDomElement radiusElem = haloElem.firstChildElement( QStringLiteral( "Radius" ) );
5513 if ( !radiusElem.isNull() )
5514 {
5515 bool ok;
5516 double bufferSize = radiusElem.text().toDouble( &ok );
5517 if ( ok )
5518 {
5519 bufferSettings.setSize( bufferSize );
5520 bufferSettings.setSizeUnit( sldUnitSize );
5521 }
5522 }
5523
5524 QDomElement haloFillElem = haloElem.firstChildElement( QStringLiteral( "Fill" ) );
5525 QColor bufferColor;
5526 Qt::BrushStyle bufferBrush = Qt::SolidPattern;
5527 QgsSymbolLayerUtils::fillFromSld( haloFillElem, bufferBrush, bufferColor );
5528 if ( bufferColor.isValid() )
5529 {
5530 QgsDebugMsgLevel( QStringLiteral( "Info: bufferColor %1." ).arg( QVariant( bufferColor ).toString() ), 4 );
5531 bufferSettings.setColor( bufferColor );
5532 }
5533 }
5534
5535 // LabelPlacement
5536 QDomElement labelPlacementElem = textSymbolizerElem.firstChildElement( QStringLiteral( "LabelPlacement" ) );
5537 if ( !labelPlacementElem.isNull() )
5538 {
5539 // PointPlacement
5540 QDomElement pointPlacementElem = labelPlacementElem.firstChildElement( QStringLiteral( "PointPlacement" ) );
5541 if ( !pointPlacementElem.isNull() )
5542 {
5545 {
5547 }
5548
5549 QDomElement displacementElem = pointPlacementElem.firstChildElement( QStringLiteral( "Displacement" ) );
5550 if ( !displacementElem.isNull() )
5551 {
5552 QDomElement displacementXElem = displacementElem.firstChildElement( QStringLiteral( "DisplacementX" ) );
5553 if ( !displacementXElem.isNull() )
5554 {
5555 bool ok;
5556 double xOffset = displacementXElem.text().toDouble( &ok );
5557 if ( ok )
5558 {
5559 settings.xOffset = xOffset;
5560 settings.offsetUnits = sldUnitSize;
5561 }
5562 }
5563 QDomElement displacementYElem = displacementElem.firstChildElement( QStringLiteral( "DisplacementY" ) );
5564 if ( !displacementYElem.isNull() )
5565 {
5566 bool ok;
5567 double yOffset = displacementYElem.text().toDouble( &ok );
5568 if ( ok )
5569 {
5570 settings.yOffset = yOffset;
5571 settings.offsetUnits = sldUnitSize;
5572 }
5573 }
5574 }
5575 QDomElement anchorPointElem = pointPlacementElem.firstChildElement( QStringLiteral( "AnchorPoint" ) );
5576 if ( !anchorPointElem.isNull() )
5577 {
5578 QDomElement anchorPointXElem = anchorPointElem.firstChildElement( QStringLiteral( "AnchorPointX" ) );
5579 if ( !anchorPointXElem.isNull() )
5580 {
5581 bool ok;
5582 double xOffset = anchorPointXElem.text().toDouble( &ok );
5583 if ( ok )
5584 {
5585 settings.xOffset = xOffset;
5586 settings.offsetUnits = sldUnitSize;
5587 }
5588 }
5589 QDomElement anchorPointYElem = anchorPointElem.firstChildElement( QStringLiteral( "AnchorPointY" ) );
5590 if ( !anchorPointYElem.isNull() )
5591 {
5592 bool ok;
5593 double yOffset = anchorPointYElem.text().toDouble( &ok );
5594 if ( ok )
5595 {
5596 settings.yOffset = yOffset;
5597 settings.offsetUnits = sldUnitSize;
5598 }
5599 }
5600 }
5601
5602 QDomElement rotationElem = pointPlacementElem.firstChildElement( QStringLiteral( "Rotation" ) );
5603 if ( !rotationElem.isNull() )
5604 {
5605 bool ok;
5606 double rotation = rotationElem.text().toDouble( &ok );
5607 if ( ok )
5608 {
5609 settings.angleOffset = 360 - rotation;
5610 }
5611 }
5612 }
5613 else
5614 {
5615 // PointPlacement
5616 QDomElement linePlacementElem = labelPlacementElem.firstChildElement( QStringLiteral( "LinePlacement" ) );
5617 if ( !linePlacementElem.isNull() )
5618 {
5620 }
5621 }
5622 }
5623
5624 // read vendor options
5625 QgsStringMap vendorOptions;
5626 QDomElement vendorOptionElem = textSymbolizerElem.firstChildElement( QStringLiteral( "VendorOption" ) );
5627 while ( !vendorOptionElem.isNull() && vendorOptionElem.localName() == QLatin1String( "VendorOption" ) )
5628 {
5629 QString optionName = vendorOptionElem.attribute( QStringLiteral( "name" ) );
5630 QString optionValue;
5631 if ( vendorOptionElem.firstChild().nodeType() == QDomNode::TextNode )
5632 {
5633 optionValue = vendorOptionElem.firstChild().nodeValue();
5634 }
5635 else
5636 {
5637 if ( vendorOptionElem.firstChild().nodeType() == QDomNode::ElementNode &&
5638 vendorOptionElem.firstChild().localName() == QLatin1String( "Literal" ) )
5639 {
5640 QgsDebugMsgLevel( vendorOptionElem.firstChild().localName(), 2 );
5641 optionValue = vendorOptionElem.firstChild().firstChild().nodeValue();
5642 }
5643 else
5644 {
5645 QgsDebugError( QStringLiteral( "unexpected child of %1 named %2" ).arg( vendorOptionElem.localName(), optionName ) );
5646 }
5647 }
5648
5649 if ( !optionName.isEmpty() && !optionValue.isEmpty() )
5650 {
5651 vendorOptions[ optionName ] = optionValue;
5652 }
5653
5654 vendorOptionElem = vendorOptionElem.nextSiblingElement();
5655 }
5656 if ( !vendorOptions.isEmpty() )
5657 {
5658 for ( QgsStringMap::iterator it = vendorOptions.begin(); it != vendorOptions.end(); ++it )
5659 {
5660 if ( it.key() == QLatin1String( "underlineText" ) && it.value() == QLatin1String( "true" ) )
5661 {
5662 font.setUnderline( true );
5663 format.setFont( font );
5664 }
5665 else if ( it.key() == QLatin1String( "strikethroughText" ) && it.value() == QLatin1String( "true" ) )
5666 {
5667 font.setStrikeOut( true );
5668 format.setFont( font );
5669 }
5670 else if ( it.key() == QLatin1String( "maxDisplacement" ) )
5671 {
5673 }
5674 else if ( it.key() == QLatin1String( "followLine" ) && it.value() == QLatin1String( "true" ) )
5675 {
5677 {
5679 }
5680 else
5681 {
5683 }
5684 }
5685 else if ( it.key() == QLatin1String( "maxAngleDelta" ) )
5686 {
5687 bool ok;
5688 double angle = it.value().toDouble( &ok );
5689 if ( ok )
5690 {
5691 settings.maxCurvedCharAngleIn = angle;
5692 settings.maxCurvedCharAngleOut = angle;
5693 }
5694 }
5695 // miscellaneous options
5696 else if ( it.key() == QLatin1String( "conflictResolution" ) && it.value() == QLatin1String( "false" ) )
5697 {
5699 }
5700 else if ( it.key() == QLatin1String( "forceLeftToRight" ) && it.value() == QLatin1String( "false" ) )
5701 {
5703 }
5704 else if ( it.key() == QLatin1String( "group" ) && it.value() == QLatin1String( "yes" ) )
5705 {
5706 settings.lineSettings().setMergeLines( true );
5707 }
5708 else if ( it.key() == QLatin1String( "labelAllGroup" ) && it.value() == QLatin1String( "true" ) )
5709 {
5710 settings.lineSettings().setMergeLines( true );
5711 }
5712 }
5713 }
5714
5715 format.setBuffer( bufferSettings );
5716 settings.setFormat( format );
5717 return true;
5718}
5719
5721{
5723
5724 return mEditFormConfig;
5725}
5726
5728{
5730
5731 if ( mEditFormConfig == editFormConfig )
5732 return;
5733
5734 mEditFormConfig = editFormConfig;
5735 mEditFormConfig.onRelationsLoaded();
5736 emit editFormConfigChanged();
5737}
5738
5740{
5742
5743 QgsAttributeTableConfig config = mAttributeTableConfig;
5744
5745 if ( config.isEmpty() )
5746 config.update( fields() );
5747
5748 return config;
5749}
5750
5752{
5754
5755 if ( mAttributeTableConfig != attributeTableConfig )
5756 {
5757 mAttributeTableConfig = attributeTableConfig;
5758 emit configChanged();
5759 }
5760}
5761
5763{
5764 // called in a non-thread-safe way in some cases when calculating aggregates in a different thread
5766
5768}
5769
5776
5778{
5780
5781 if ( !mDiagramLayerSettings )
5782 mDiagramLayerSettings = new QgsDiagramLayerSettings();
5783 *mDiagramLayerSettings = s;
5784}
5785
5787{
5789
5790 QgsLayerMetadataFormatter htmlFormatter( metadata() );
5791 QString myMetadata = QStringLiteral( "<html><head></head>\n<body>\n" );
5792
5793 myMetadata += generalHtmlMetadata();
5794
5795 // Begin Provider section
5796 myMetadata += QStringLiteral( "<h1>" ) + tr( "Information from provider" ) + QStringLiteral( "</h1>\n<hr>\n" );
5797 myMetadata += QLatin1String( "<table class=\"list-view\">\n" );
5798
5799 // storage type
5800 if ( !storageType().isEmpty() )
5801 {
5802 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Storage" ) + QStringLiteral( "</td><td>" ) + storageType() + QStringLiteral( "</td></tr>\n" );
5803 }
5804
5805 // comment
5806 if ( !dataComment().isEmpty() )
5807 {
5808 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Comment" ) + QStringLiteral( "</td><td>" ) + dataComment() + QStringLiteral( "</td></tr>\n" );
5809 }
5810
5811 // encoding
5812 if ( const QgsVectorDataProvider *provider = dataProvider() )
5813 {
5814 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Encoding" ) + QStringLiteral( "</td><td>" ) + provider->encoding() + QStringLiteral( "</td></tr>\n" );
5815 myMetadata += provider->htmlMetadata();
5816 }
5817
5818 if ( isSpatial() )
5819 {
5820 // geom type
5822 if ( static_cast<int>( type ) < 0 || static_cast< int >( type ) > static_cast< int >( Qgis::GeometryType::Null ) )
5823 {
5824 QgsDebugMsgLevel( QStringLiteral( "Invalid vector type" ), 2 );
5825 }
5826 else
5827 {
5828 QString typeString( QStringLiteral( "%1 (%2)" ).arg( QgsWkbTypes::geometryDisplayString( geometryType() ),
5830 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Geometry" ) + QStringLiteral( "</td><td>" ) + typeString + QStringLiteral( "</td></tr>\n" );
5831 }
5832
5833 // Extent
5834 // Try to display extent 3D by default. If empty (probably because the data is 2D), fallback to the 2D version
5835 const QgsBox3D extentBox3D = extent3D();
5836 const QString extentAsStr = !extentBox3D.isEmpty() ? extentBox3D.toString() : extent().toString();
5837 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Extent" ) + QStringLiteral( "</td><td>" ) + extentAsStr + QStringLiteral( "</td></tr>\n" );
5838 }
5839
5840 // feature count
5841 QLocale locale = QLocale();
5842 locale.setNumberOptions( locale.numberOptions() &= ~QLocale::NumberOption::OmitGroupSeparator );
5843 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" )
5844 + tr( "Feature count" ) + QStringLiteral( "</td><td>" )
5845 + ( featureCount() == -1 ? tr( "unknown" ) : locale.toString( static_cast<qlonglong>( featureCount() ) ) )
5846 + QStringLiteral( "</td></tr>\n" );
5847
5848 // End Provider section
5849 myMetadata += QLatin1String( "</table>\n<br><br>" );
5850
5851 if ( isSpatial() )
5852 {
5853 // CRS
5854 myMetadata += crsHtmlMetadata();
5855 }
5856
5857 // identification section
5858 myMetadata += QStringLiteral( "<h1>" ) + tr( "Identification" ) + QStringLiteral( "</h1>\n<hr>\n" );
5859 myMetadata += htmlFormatter.identificationSectionHtml( );
5860 myMetadata += QLatin1String( "<br><br>\n" );
5861
5862 // extent section
5863 myMetadata += QStringLiteral( "<h1>" ) + tr( "Extent" ) + QStringLiteral( "</h1>\n<hr>\n" );
5864 myMetadata += htmlFormatter.extentSectionHtml( isSpatial() );
5865 myMetadata += QLatin1String( "<br><br>\n" );
5866
5867 // Start the Access section
5868 myMetadata += QStringLiteral( "<h1>" ) + tr( "Access" ) + QStringLiteral( "</h1>\n<hr>\n" );
5869 myMetadata += htmlFormatter.accessSectionHtml( );
5870 myMetadata += QLatin1String( "<br><br>\n" );
5871
5872 // Fields section
5873 myMetadata += QStringLiteral( "<h1>" ) + tr( "Fields" ) + QStringLiteral( "</h1>\n<hr>\n<table class=\"list-view\">\n" );
5874
5875 // primary key
5877 if ( !pkAttrList.isEmpty() )
5878 {
5879 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Primary key attributes" ) + QStringLiteral( "</td><td>" );
5880 const auto constPkAttrList = pkAttrList;
5881 for ( int idx : constPkAttrList )
5882 {
5883 myMetadata += fields().at( idx ).name() + ' ';
5884 }
5885 myMetadata += QLatin1String( "</td></tr>\n" );
5886 }
5887
5888 const QgsFields myFields = fields();
5889
5890 // count fields
5891 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Count" ) + QStringLiteral( "</td><td>" ) + QString::number( myFields.size() ) + QStringLiteral( "</td></tr>\n" );
5892
5893 myMetadata += QLatin1String( "</table>\n<br><table width=\"100%\" class=\"tabular-view\">\n" );
5894 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" );
5895
5896 for ( int i = 0; i < myFields.size(); ++i )
5897 {
5898 QgsField myField = myFields.at( i );
5899 QString rowClass;
5900 if ( i % 2 )
5901 rowClass = QStringLiteral( "class=\"odd-row\"" );
5902 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" );
5903 }
5904
5905 //close field list
5906 myMetadata += QLatin1String( "</table>\n<br><br>" );
5907
5908 // Start the contacts section
5909 myMetadata += QStringLiteral( "<h1>" ) + tr( "Contacts" ) + QStringLiteral( "</h1>\n<hr>\n" );
5910 myMetadata += htmlFormatter.contactsSectionHtml( );
5911 myMetadata += QLatin1String( "<br><br>\n" );
5912
5913 // Start the links section
5914 myMetadata += QStringLiteral( "<h1>" ) + tr( "Links" ) + QStringLiteral( "</h1>\n<hr>\n" );
5915 myMetadata += htmlFormatter.linksSectionHtml( );
5916 myMetadata += QLatin1String( "<br><br>\n" );
5917
5918 // Start the history section
5919 myMetadata += QStringLiteral( "<h1>" ) + tr( "History" ) + QStringLiteral( "</h1>\n<hr>\n" );
5920 myMetadata += htmlFormatter.historySectionHtml( );
5921 myMetadata += QLatin1String( "<br><br>\n" );
5922
5923 myMetadata += customPropertyHtmlMetadata();
5924
5925 myMetadata += QLatin1String( "\n</body>\n</html>\n" );
5926 return myMetadata;
5927}
5928
5929void QgsVectorLayer::invalidateSymbolCountedFlag()
5930{
5932
5933 mSymbolFeatureCounted = false;
5934}
5935
5936void QgsVectorLayer::onFeatureCounterCompleted()
5937{
5939
5940 onSymbolsCounted();
5941 mFeatureCounter = nullptr;
5942}
5943
5944void QgsVectorLayer::onFeatureCounterTerminated()
5945{
5947
5948 mFeatureCounter = nullptr;
5949}
5950
5951void QgsVectorLayer::onJoinedFieldsChanged()
5952{
5954
5955 // some of the fields of joined layers have changed -> we need to update this layer's fields too
5956 updateFields();
5957}
5958
5959void QgsVectorLayer::onFeatureAdded( QgsFeatureId fid )
5960{
5962
5963 updateExtents();
5964
5965 emit featureAdded( fid );
5966}
5967
5968void QgsVectorLayer::onFeatureDeleted( QgsFeatureId fid )
5969{
5971
5972 updateExtents();
5973
5974 if ( mEditCommandActive || mCommitChangesActive )
5975 {
5976 mDeletedFids << fid;
5977 }
5978 else
5979 {
5980 mSelectedFeatureIds.remove( fid );
5981 emit featuresDeleted( QgsFeatureIds() << fid );
5982 }
5983
5984 emit featureDeleted( fid );
5985}
5986
5987void QgsVectorLayer::onRelationsLoaded()
5988{
5990
5991 mEditFormConfig.onRelationsLoaded();
5992}
5993
5994void QgsVectorLayer::onSymbolsCounted()
5995{
5997
5998 if ( mFeatureCounter )
5999 {
6000 mSymbolFeatureCounted = true;
6001 mSymbolFeatureCountMap = mFeatureCounter->symbolFeatureCountMap();
6002 mSymbolFeatureIdMap = mFeatureCounter->symbolFeatureIdMap();
6004 }
6005}
6006
6007QList<QgsRelation> QgsVectorLayer::referencingRelations( int idx ) const
6008{
6010
6011 if ( QgsProject *p = project() )
6012 return p->relationManager()->referencingRelations( this, idx );
6013 else
6014 return {};
6015}
6016
6017QList<QgsWeakRelation> QgsVectorLayer::weakRelations() const
6018{
6020
6021 return mWeakRelations;
6022}
6023
6024void QgsVectorLayer::setWeakRelations( const QList<QgsWeakRelation> &relations )
6025{
6027
6028 mWeakRelations = relations;
6029}
6030
6031bool QgsVectorLayer::loadAuxiliaryLayer( const QgsAuxiliaryStorage &storage, const QString &key )
6032{
6034
6035 bool rc = false;
6036
6037 QString joinKey = mAuxiliaryLayerKey;
6038 if ( !key.isEmpty() )
6039 joinKey = key;
6040
6041 if ( storage.isValid() && !joinKey.isEmpty() )
6042 {
6043 QgsAuxiliaryLayer *alayer = nullptr;
6044
6045 int idx = fields().lookupField( joinKey );
6046
6047 if ( idx >= 0 )
6048 {
6049 alayer = storage.createAuxiliaryLayer( fields().field( idx ), this );
6050
6051 if ( alayer )
6052 {
6053 setAuxiliaryLayer( alayer );
6054 rc = true;
6055 }
6056 }
6057 }
6058
6059 return rc;
6060}
6061
6063{
6065
6066 mAuxiliaryLayerKey.clear();
6067
6068 if ( mAuxiliaryLayer )
6069 removeJoin( mAuxiliaryLayer->id() );
6070
6071 if ( alayer )
6072 {
6073 addJoin( alayer->joinInfo() );
6074
6075 if ( !alayer->isEditable() )
6076 alayer->startEditing();
6077
6078 mAuxiliaryLayerKey = alayer->joinInfo().targetFieldName();
6079 }
6080
6081 mAuxiliaryLayer.reset( alayer );
6082 if ( mAuxiliaryLayer )
6083 mAuxiliaryLayer->setParent( this );
6084 updateFields();
6085}
6086
6088{
6090
6091 return mAuxiliaryLayer.get();
6092}
6093
6095{
6097
6098 return mAuxiliaryLayer.get();
6099}
6100
6101QSet<QgsMapLayerDependency> QgsVectorLayer::dependencies() const
6102{
6104
6105 if ( mDataProvider )
6106 return mDataProvider->dependencies() + mDependencies;
6107 return mDependencies;
6108}
6109
6110void QgsVectorLayer::emitDataChanged()
6111{
6113
6114 if ( mDataChangedFired )
6115 return;
6116
6117 // If we are asked to fire dataChanged from a layer we depend on,
6118 // be sure that this layer is not in the process of committing its changes, because
6119 // we will be asked to fire dataChanged at the end of his commit, and we don't
6120 // want to fire this signal more than necessary.
6121 if ( QgsVectorLayer *layerWeDependUpon = qobject_cast<QgsVectorLayer *>( sender() );
6122 layerWeDependUpon && layerWeDependUpon->mCommitChangesActive )
6123 return;
6124
6125 updateExtents(); // reset cached extent to reflect data changes
6126
6127 mDataChangedFired = true;
6128 emit dataChanged();
6129 mDataChangedFired = false;
6130}
6131
6132bool QgsVectorLayer::setDependencies( const QSet<QgsMapLayerDependency> &oDeps )
6133{
6135
6136 QSet<QgsMapLayerDependency> deps;
6137 const auto constODeps = oDeps;
6138 for ( const QgsMapLayerDependency &dep : constODeps )
6139 {
6140 if ( dep.origin() == QgsMapLayerDependency::FromUser )
6141 deps << dep;
6142 }
6143
6144 QSet<QgsMapLayerDependency> toAdd = deps - dependencies();
6145
6146 // disconnect layers that are not present in the list of dependencies anymore
6147 if ( QgsProject *p = project() )
6148 {
6149 for ( const QgsMapLayerDependency &dep : std::as_const( mDependencies ) )
6150 {
6151 QgsVectorLayer *lyr = static_cast<QgsVectorLayer *>( p->mapLayer( dep.layerId() ) );
6152 if ( !lyr )
6153 continue;
6154 disconnect( lyr, &QgsVectorLayer::featureAdded, this, &QgsVectorLayer::emitDataChanged );
6155 disconnect( lyr, &QgsVectorLayer::featureDeleted, this, &QgsVectorLayer::emitDataChanged );
6156 disconnect( lyr, &QgsVectorLayer::geometryChanged, this, &QgsVectorLayer::emitDataChanged );
6157 disconnect( lyr, &QgsVectorLayer::dataChanged, this, &QgsVectorLayer::emitDataChanged );
6159 disconnect( lyr, &QgsVectorLayer::afterCommitChanges, this, &QgsVectorLayer::emitDataChanged );
6160 }
6161 }
6162
6163 // assign new dependencies
6164 if ( mDataProvider )
6165 mDependencies = mDataProvider->dependencies() + deps;
6166 else
6167 mDependencies = deps;
6168 emit dependenciesChanged();
6169
6170 // connect to new layers
6171 if ( QgsProject *p = project() )
6172 {
6173 for ( const QgsMapLayerDependency &dep : std::as_const( mDependencies ) )
6174 {
6175 QgsVectorLayer *lyr = static_cast<QgsVectorLayer *>( p->mapLayer( dep.layerId() ) );
6176 if ( !lyr )
6177 continue;
6178 connect( lyr, &QgsVectorLayer::featureAdded, this, &QgsVectorLayer::emitDataChanged );
6179 connect( lyr, &QgsVectorLayer::featureDeleted, this, &QgsVectorLayer::emitDataChanged );
6180 connect( lyr, &QgsVectorLayer::geometryChanged, this, &QgsVectorLayer::emitDataChanged );
6181 connect( lyr, &QgsVectorLayer::dataChanged, this, &QgsVectorLayer::emitDataChanged );
6183 connect( lyr, &QgsVectorLayer::afterCommitChanges, this, &QgsVectorLayer::emitDataChanged );
6184 }
6185 }
6186
6187 // if new layers are present, emit a data change
6188 if ( ! toAdd.isEmpty() )
6189 emitDataChanged();
6190
6191 return true;
6192}
6193
6195{
6197
6198 if ( fieldIndex < 0 || fieldIndex >= mFields.count() || !mDataProvider )
6200
6201 QgsFieldConstraints::Constraints constraints = mFields.at( fieldIndex ).constraints().constraints();
6202
6203 // make sure provider constraints are always present!
6204 if ( mFields.fieldOrigin( fieldIndex ) == Qgis::FieldOrigin::Provider )
6205 {
6206 constraints |= mDataProvider->fieldConstraints( mFields.fieldOriginIndex( fieldIndex ) );
6207 }
6208
6209 return constraints;
6210}
6211
6212QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength> QgsVectorLayer::fieldConstraintsAndStrength( int fieldIndex ) const
6213{
6215
6216 QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength > m;
6217
6218 if ( fieldIndex < 0 || fieldIndex >= mFields.count() )
6219 return m;
6220
6221 QString name = mFields.at( fieldIndex ).name();
6222
6223 QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength >::const_iterator conIt = mFieldConstraintStrength.constBegin();
6224 for ( ; conIt != mFieldConstraintStrength.constEnd(); ++conIt )
6225 {
6226 if ( conIt.key().first == name )
6227 {
6228 m[ conIt.key().second ] = mFieldConstraintStrength.value( conIt.key() );
6229 }
6230 }
6231
6232 return m;
6233}
6234
6236{
6238
6239 if ( index < 0 || index >= mFields.count() )
6240 return;
6241
6242 QString name = mFields.at( index ).name();
6243
6244 // add constraint to existing constraints
6245 QgsFieldConstraints::Constraints constraints = mFieldConstraints.value( name, QgsFieldConstraints::Constraints() );
6246 constraints |= constraint;
6247 mFieldConstraints.insert( name, constraints );
6248
6249 mFieldConstraintStrength.insert( qMakePair( name, constraint ), strength );
6250
6251 updateFields();
6252}
6253
6255{
6257
6258 if ( index < 0 || index >= mFields.count() )
6259 return;
6260
6261 QString name = mFields.at( index ).name();
6262
6263 // remove constraint from existing constraints
6264 QgsFieldConstraints::Constraints constraints = mFieldConstraints.value( name, QgsFieldConstraints::Constraints() );
6265 constraints &= ~constraint;
6266 mFieldConstraints.insert( name, constraints );
6267
6268 mFieldConstraintStrength.remove( qMakePair( name, constraint ) );
6269
6270 updateFields();
6271}
6272
6274{
6276
6277 if ( index < 0 || index >= mFields.count() )
6278 return QString();
6279
6280 return mFields.at( index ).constraints().constraintExpression();
6281}
6282
6284{
6286
6287 if ( index < 0 || index >= mFields.count() )
6288 return QString();
6289
6290 return mFields.at( index ).constraints().constraintDescription();
6291}
6292
6293void QgsVectorLayer::setConstraintExpression( int index, const QString &expression, const QString &description )
6294{
6296
6297 if ( index < 0 || index >= mFields.count() )
6298 return;
6299
6300 if ( expression.isEmpty() )
6301 {
6302 mFieldConstraintExpressions.remove( mFields.at( index ).name() );
6303 }
6304 else
6305 {
6306 mFieldConstraintExpressions.insert( mFields.at( index ).name(), qMakePair( expression, description ) );
6307 }
6308 updateFields();
6309}
6310
6312{
6314
6315 if ( index < 0 || index >= mFields.count() )
6316 return;
6317
6318 mFieldConfigurationFlags.insert( mFields.at( index ).name(), flags );
6319 updateFields();
6320}
6321
6323{
6325
6326 if ( index < 0 || index >= mFields.count() )
6327 return;
6329 flags.setFlag( flag, active );
6331}
6332
6334{
6336
6337 if ( index < 0 || index >= mFields.count() )
6339
6340 return mFields.at( index ).configurationFlags();
6341}
6342
6344{
6346
6347 if ( index < 0 || index >= mFields.count() )
6348 return;
6349
6350 if ( setup.isNull() )
6351 mFieldWidgetSetups.remove( mFields.at( index ).name() );
6352 else
6353 mFieldWidgetSetups.insert( mFields.at( index ).name(), setup );
6354 updateFields();
6355}
6356
6358{
6360
6361 if ( index < 0 || index >= mFields.count() )
6362 return QgsEditorWidgetSetup();
6363
6364 return mFields.at( index ).editorWidgetSetup();
6365}
6366
6367QgsAbstractVectorLayerLabeling *QgsVectorLayer::readLabelingFromCustomProperties()
6368{
6370
6372 if ( customProperty( QStringLiteral( "labeling" ) ).toString() == QLatin1String( "pal" ) )
6373 {
6374 if ( customProperty( QStringLiteral( "labeling/enabled" ), QVariant( false ) ).toBool() )
6375 {
6376 // try to load from custom properties
6377 QgsPalLayerSettings settings;
6378 settings.readFromLayerCustomProperties( this );
6379 labeling = new QgsVectorLayerSimpleLabeling( settings );
6380 }
6381
6382 // also clear old-style labeling config
6383 removeCustomProperty( QStringLiteral( "labeling" ) );
6384 const auto constCustomPropertyKeys = customPropertyKeys();
6385 for ( const QString &key : constCustomPropertyKeys )
6386 {
6387 if ( key.startsWith( QLatin1String( "labeling/" ) ) )
6388 removeCustomProperty( key );
6389 }
6390 }
6391
6392 return labeling;
6393}
6394
6396{
6398
6399 return mAllowCommit;
6400}
6401
6402void QgsVectorLayer::setAllowCommit( bool allowCommit )
6403{
6405
6406 if ( mAllowCommit == allowCommit )
6407 return;
6408
6409 mAllowCommit = allowCommit;
6410 emit allowCommitChanged();
6411}
6412
6414{
6416
6417 return mGeometryOptions.get();
6418}
6419
6420void QgsVectorLayer::setReadExtentFromXml( bool readExtentFromXml )
6421{
6423
6424 mReadExtentFromXml = readExtentFromXml;
6425}
6426
6428{
6430
6431 return mReadExtentFromXml;
6432}
6433
6434void QgsVectorLayer::onDirtyTransaction( const QString &sql, const QString &name )
6435{
6437
6439 if ( tr && mEditBuffer )
6440 {
6441 qobject_cast<QgsVectorLayerEditPassthrough *>( mEditBuffer )->update( tr, sql, name );
6442 }
6443}
6444
6445QList<QgsVectorLayer *> QgsVectorLayer::DeleteContext::handledLayers( bool includeAuxiliaryLayers ) const
6446{
6447 QList<QgsVectorLayer *> layers;
6448 QMap<QgsVectorLayer *, QgsFeatureIds>::const_iterator i;
6449 for ( i = mHandledFeatures.begin(); i != mHandledFeatures.end(); ++i )
6450 {
6451 if ( includeAuxiliaryLayers || !qobject_cast< QgsAuxiliaryLayer * >( i.key() ) )
6452 layers.append( i.key() );
6453 }
6454 return layers;
6455}
6456
6458{
6459 return mHandledFeatures[layer];
6460}
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:2904
@ 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:1972
@ 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:2889
@ 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:2873
@ 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:3711
@ Duplicate
Duplicate original value.
BlendMode
Blending modes defining the available composition modes that can be used when painting.
Definition qgis.h:4677
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:3743
@ Duplicate
Duplicate original value.
static const float DEFAULT_MAPTOPIXEL_THRESHOLD
Default threshold between map coordinates and device coordinates for map2pixel simplification.
Definition qgis.h:5788
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:1634
@ 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:4930
@ 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:5497
VertexMarkerType
Editing vertex markers, used for showing vertices during a edit operation.
Definition qgis.h:1763
@ SemiTransparentCircle
Semi-transparent circle marker.
@ Cross
Cross marker.
VectorEditResult
Specifies the result of a vector layer edit operation.
Definition qgis.h:1748
@ 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:1651
@ 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:1666
@ AlwaysAllowUpsideDown
Show upside down for all labels, including dynamic ones.
SelectBehavior
Specifies how a selection should be applied.
Definition qgis.h:1701
@ 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
QString toString(int precision=16) const
Returns a string representation of form xmin,ymin,zmin : xmax,ymax,zmax Coordinates will be truncated...
Definition qgsbox3d.cpp:325
bool isNull() const
Test if the box is null (holding no spatial information).
Definition qgsbox3d.cpp:310
bool isEmpty() const
Returns true if the box is empty.
Definition qgsbox3d.cpp:320
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:162
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:104
QString displayName() const
Returns the name to use when displaying this field.
Definition qgsfield.cpp:96
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:746
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, const char *file=__builtin_FILE(), const char *function=__builtin_FUNCTION(), int line=__builtin_LINE())
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.
Q_INVOKABLE 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
double yMinimum
double xMaximum
void set(const QgsPointXY &p1, const QgsPointXY &p2, bool normalize=true)
Sets the rectangle from two QgsPoints.
double yMaximum
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.
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:6335
QString qgsEnumValueToKey(const T &value, bool *returnOk=nullptr)
Returns the value for the given key of an enum.
Definition qgis.h:6316
QString qgsFlagValueToKeys(const T &value, bool *returnOk=nullptr)
Returns the value for the given keys of a flag.
Definition qgis.h:6374
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:6396
QMap< QString, QString > QgsStringMap
Definition qgis.h:6663
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:41
#define QgsDebugError(str)
Definition qgslogger.h:40
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.