QGIS API Documentation 4.3.0-Master (0cef2469b72)
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 "qgsvectorlayer.h"
25
26#include <limits>
27#include <memory>
28#include <optional>
29
30#include "qgis.h"
31#include "qgsactionmanager.h"
32#include "qgsapplication.h"
33#include "qgsauxiliarystorage.h"
34#include "qgsconditionalstyle.h"
36#include "qgscurve.h"
37#include "qgscurvepolygon.h"
38#include "qgsdatasourceuri.h"
39#include "qgsdiagramrenderer.h"
44#include "qgsfeature.h"
46#include "qgsfeaturerequest.h"
47#include "qgsfeedback.h"
48#include "qgsfields.h"
49#include "qgsgeometry.h"
50#include "qgsgeometryoptions.h"
53#include "qgslogger.h"
54#include "qgsmaplayerfactory.h"
55#include "qgsmaplayerlegend.h"
57#include "qgsmessagelog.h"
59#include "qgsobjectvisitor.h"
60#include "qgsogcutils.h"
61#include "qgspainting.h"
62#include "qgspallabeling.h"
63#include "qgspoint.h"
64#include "qgspointxy.h"
65#include "qgsprofilerequest.h"
66#include "qgsproject.h"
67#include "qgsproviderregistry.h"
68#include "qgsrectangle.h"
69#include "qgsrelationmanager.h"
70#include "qgsrendercontext.h"
71#include "qgsrenderer.h"
73#include "qgsruntimeprofiler.h"
76#include "qgssettingstree.h"
77#include "qgssldexportcontext.h"
79#include "qgssymbollayer.h"
80#include "qgssymbollayerutils.h"
81#include "qgstaskmanager.h"
82#include "qgsthreadingutils.h"
83#include "qgstransaction.h"
84#include "qgstransactiongroup.h"
98#include "qgsvectorlayerutils.h"
99#include "qgsweakrelation.h"
100#include "qgsxmlutils.h"
101
102#include <QDir>
103#include <QDomNode>
104#include <QFile>
105#include <QImage>
106#include <QPainter>
107#include <QPainterPath>
108#include <QPolygonF>
109#include <QProgressDialog>
110#include <QRegularExpression>
111#include <QString>
112#include <QStringBuilder>
113#include <QTimer>
114#include <QUndoCommand>
115#include <QUrl>
116#include <QUrlQuery>
117#include <QUuid>
118#include <QVector>
119
120#include "moc_qgsvectorlayer.cpp"
121
122using namespace Qt::StringLiterals;
123
131
132
133#ifdef TESTPROVIDERLIB
134#include <dlfcn.h>
135#endif
136
137typedef bool saveStyle_t(
138 const QString &uri, const QString &qmlStyle, const QString &sldStyle, const QString &styleName, const QString &styleDescription, const QString &uiFileContent, bool useAsDefault, QString &errCause
139);
140
141typedef QString loadStyle_t( const QString &uri, QString &errCause );
142
143typedef int listStyles_t( const QString &uri, QStringList &ids, QStringList &names, QStringList &descriptions, QString &errCause );
144
145typedef QString getStyleById_t( const QString &uri, QString styleID, QString &errCause );
146
147typedef bool deleteStyleById_t( const QString &uri, QString styleID, QString &errCause );
148
149
150QgsVectorLayer::QgsVectorLayer( const QString &vectorLayerPath, const QString &baseName, const QString &providerKey, const QgsVectorLayer::LayerOptions &options )
151 : QgsMapLayer( Qgis::LayerType::Vector, baseName, vectorLayerPath )
152 , mSelectionProperties( new QgsVectorLayerSelectionProperties( this ) )
153 , mTemporalProperties( new QgsVectorLayerTemporalProperties( this ) )
154 , mElevationProperties( new QgsVectorLayerElevationProperties( this ) )
155 , mAuxiliaryLayer( nullptr )
156 , mAuxiliaryLayerKey( QString() )
157 , mReadExtentFromXml( options.readExtentFromXml )
158 , mRefreshRendererTimer( new QTimer( this ) )
159{
161 mLoadAllStoredStyle = options.loadAllStoredStyles;
162
163 if ( options.fallbackCrs.isValid() )
164 setCrs( options.fallbackCrs, false );
165 mWkbType = options.fallbackWkbType;
166
167 setProviderType( providerKey );
168
169 mGeometryOptions = std::make_unique<QgsGeometryOptions>();
170 mActions = new QgsActionManager( this );
171 mActions->setParent( this );
172 mConditionalStyles = new QgsConditionalLayerStyles( this );
173 mStoredExpressionManager = new QgsStoredExpressionManager();
174 mStoredExpressionManager->setParent( this );
175
176 mJoinBuffer = new QgsVectorLayerJoinBuffer( this );
177 mJoinBuffer->setParent( this );
178 connect( mJoinBuffer, &QgsVectorLayerJoinBuffer::joinedFieldsChanged, this, &QgsVectorLayer::onJoinedFieldsChanged );
179
180 mExpressionFieldBuffer = std::make_unique<QgsExpressionFieldBuffer>();
181 // if we're given a provider type, try to create and bind one to this layer
182 if ( !vectorLayerPath.isEmpty() && !mProviderKey.isEmpty() )
183 {
184 QgsDataProvider::ProviderOptions providerOptions { options.transformContext };
185 Qgis::DataProviderReadFlags providerFlags;
186 if ( options.loadDefaultStyle )
187 {
189 }
190 if ( options.forceReadOnly )
191 {
193 mDataSourceReadOnly = true;
194 }
195 setDataSource( vectorLayerPath, baseName, providerKey, providerOptions, providerFlags );
196 }
197
198 for ( const QgsField &field : std::as_const( mFields ) )
199 {
200 if ( !mAttributeAliasMap.contains( field.name() ) )
201 mAttributeAliasMap.insert( field.name(), QString() );
202 }
203
204 if ( isValid() )
205 {
206 mTemporalProperties->setDefaultsFromDataProviderTemporalCapabilities( mDataProvider->temporalCapabilities() );
207 if ( !mTemporalProperties->isActive() )
208 {
209 // didn't populate temporal properties from provider metadata, so at least try to setup some initially nice
210 // selections
211 mTemporalProperties->guessDefaultsFromFields( mFields );
212 }
213
214 mElevationProperties->setDefaultsFromLayer( this );
215 }
216
217 connect( this, &QgsVectorLayer::selectionChanged, this, [this] { triggerRepaint(); } );
218 connect( QgsProject::instance()->relationManager(), &QgsRelationManager::relationsLoaded, this, &QgsVectorLayer::onRelationsLoaded ); // skip-keyword-check
219
223
224 // Default simplify drawing settings
225 mSimplifyMethod.setSimplifyHints( QgsVectorLayer::settingsSimplifyDrawingHints->valueWithDefaultOverride( mSimplifyMethod.simplifyHints() ) );
226 mSimplifyMethod.setSimplifyAlgorithm( QgsVectorLayer::settingsSimplifyAlgorithm->valueWithDefaultOverride( mSimplifyMethod.simplifyAlgorithm() ) );
227 mSimplifyMethod.setThreshold( QgsVectorLayer::settingsSimplifyDrawingTol->valueWithDefaultOverride( mSimplifyMethod.threshold() ) );
228 mSimplifyMethod.setForceLocalOptimization( QgsVectorLayer::settingsSimplifyLocal->valueWithDefaultOverride( mSimplifyMethod.forceLocalOptimization() ) );
229 mSimplifyMethod.setMaximumScale( QgsVectorLayer::settingsSimplifyMaxScale->valueWithDefaultOverride( mSimplifyMethod.maximumScale() ) );
230
231 connect( mRefreshRendererTimer, &QTimer::timeout, this, [this] { triggerRepaint( true ); } );
232}
233
235{
236 emit willBeDeleted();
237
238 setValid( false );
239
240 if ( mFeatureCounter )
241 mFeatureCounter->cancel();
242
243 qDeleteAll( mRendererGenerators );
244}
245
247{
249
251 // We get the data source string from the provider when
252 // possible because some providers may have changed it
253 // directly (memory provider does that).
254 QString dataSource;
255 if ( mDataProvider )
256 {
257 dataSource = mDataProvider->dataSourceUri();
258 options.transformContext = mDataProvider->transformContext();
259 }
260 else
261 {
262 dataSource = source();
263 }
264 options.forceReadOnly = mDataSourceReadOnly;
265 QgsVectorLayer *layer = new QgsVectorLayer( dataSource, name(), mProviderKey, options );
266 if ( mDataProvider && layer->dataProvider() )
267 {
268 layer->dataProvider()->handlePostCloneOperations( mDataProvider );
269 }
270 QgsMapLayer::clone( layer );
271 layer->mXmlExtent2D = mXmlExtent2D;
272 layer->mLazyExtent2D = mLazyExtent2D;
273 layer->mValidExtent2D = mValidExtent2D;
274 layer->mXmlExtent3D = mXmlExtent3D;
275 layer->mLazyExtent3D = mLazyExtent3D;
276 layer->mValidExtent3D = mValidExtent3D;
277
278 QList<QgsVectorLayerJoinInfo> joins = vectorJoins();
279 const auto constJoins = joins;
280 for ( const QgsVectorLayerJoinInfo &join : constJoins )
281 {
282 // do not copy join information for auxiliary layer
283 if ( !auxiliaryLayer() || ( auxiliaryLayer() && auxiliaryLayer()->id() != join.joinLayerId() ) )
284 layer->addJoin( join );
285 }
286
287 if ( mDataProvider )
288 layer->setProviderEncoding( mDataProvider->encoding() );
289 layer->setSubsetString( subsetString() );
293 layer->setReadOnly( isReadOnly() );
298
299 const auto constActions = actions()->actions();
300 for ( const QgsAction &action : constActions )
301 {
302 layer->actions()->addAction( action );
303 }
304
305 if ( auto *lRenderer = renderer() )
306 {
307 layer->setRenderer( lRenderer->clone() );
308 }
309
310 if ( auto *lLabeling = labeling() )
311 {
312 layer->setLabeling( lLabeling->clone() );
313 }
315
317
318 if ( auto *lDiagramRenderer = diagramRenderer() )
319 {
320 layer->setDiagramRenderer( lDiagramRenderer->clone() );
321 }
322
323 if ( auto *lDiagramLayerSettings = diagramLayerSettings() )
324 {
325 layer->setDiagramLayerSettings( *lDiagramLayerSettings );
326 }
327
328 for ( int i = 0; i < fields().count(); i++ )
329 {
330 layer->setFieldAlias( i, attributeAlias( i ) );
332 layer->setEditorWidgetSetup( i, editorWidgetSetup( i ) );
335
336 QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength> constraints = fieldConstraintsAndStrength( i );
337 auto constraintIt = constraints.constBegin();
338 for ( ; constraintIt != constraints.constEnd(); ++constraintIt )
339 {
340 layer->setFieldConstraint( i, constraintIt.key(), constraintIt.value() );
341 }
342
343 if ( fields().fieldOrigin( i ) == Qgis::FieldOrigin::Expression )
344 {
345 layer->addExpressionField( expressionField( i ), fields().at( i ) );
346 }
347 }
348
350
351 if ( auto *lAuxiliaryLayer = auxiliaryLayer() )
352 layer->setAuxiliaryLayer( lAuxiliaryLayer->clone( layer ) );
353
354 layer->mElevationProperties = mElevationProperties->clone();
355 layer->mElevationProperties->setParent( layer );
356
357 layer->mSelectionProperties = mSelectionProperties->clone();
358 layer->mSelectionProperties->setParent( layer );
359
360 return layer;
361}
362
364{
366
367 if ( mDataProvider )
368 {
369 return mDataProvider->storageType();
370 }
371 return QString();
372}
373
374
376{
378
379 if ( mDataProvider )
380 {
381 return mDataProvider->capabilitiesString();
382 }
383 return QString();
384}
385
387{
389
390 return mDataProvider && mDataProvider->isSqlQuery();
391}
392
394{
396
397 return mDataProvider ? mDataProvider->vectorLayerTypeFlags() : Qgis::VectorLayerTypeFlags();
398}
399
401{
403
404 if ( mDataProvider )
405 {
406 return mDataProvider->dataComment();
407 }
408 return QString();
409}
410
417
419{
421
422 return name();
423}
424
426{
427 // non fatal for now -- the QgsVirtualLayerTask class is not thread safe and calls this
429
430 if ( mDataProvider )
431 {
432 mDataProvider->reloadData();
433 updateFields();
434 }
435}
436
438{
439 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
441
442 return new QgsVectorLayerRenderer( this, rendererContext );
443}
444
445
446void QgsVectorLayer::drawVertexMarker( double x, double y, QPainter &p, Qgis::VertexMarkerType type, int m )
447{
448 switch ( type )
449 {
451 p.setPen( QColor( 50, 100, 120, 200 ) );
452 p.setBrush( QColor( 200, 200, 210, 120 ) );
453 p.drawEllipse( x - m, y - m, m * 2 + 1, m * 2 + 1 );
454 break;
455
457 p.setPen( QColor( 255, 0, 0 ) );
458 p.drawLine( x - m, y + m, x + m, y - m );
459 p.drawLine( x - m, y - m, x + m, y + m );
460 break;
461
463 break;
464 }
465}
466
468{
470
471 mSelectedFeatureIds.insert( fid );
472 mPreviousSelectedFeatureIds.clear();
473
474 emit selectionChanged( QgsFeatureIds() << fid, QgsFeatureIds(), false );
475}
476
477void QgsVectorLayer::select( const QgsFeatureIds &featureIds )
478{
480
481 mSelectedFeatureIds.unite( featureIds );
482 mPreviousSelectedFeatureIds.clear();
483
484 emit selectionChanged( featureIds, QgsFeatureIds(), false );
485}
486
488{
490
491 mSelectedFeatureIds.remove( fid );
492 mPreviousSelectedFeatureIds.clear();
493
494 emit selectionChanged( QgsFeatureIds(), QgsFeatureIds() << fid, false );
495}
496
498{
500
501 mSelectedFeatureIds.subtract( featureIds );
502 mPreviousSelectedFeatureIds.clear();
503
504 emit selectionChanged( QgsFeatureIds(), featureIds, false );
505}
506
508{
510
511 // normalize the rectangle
512 QgsRectangle normalizedRect = rect;
513 normalizedRect.normalize();
514
515 QgsFeatureIds newSelection;
516
519 );
520
521 QgsFeature feat;
522 while ( features.nextFeature( feat ) )
523 {
524 newSelection << feat.id();
525 }
526 features.close();
527
528 selectByIds( newSelection, behavior );
529}
530
531void QgsVectorLayer::selectByExpression( const QString &expression, Qgis::SelectBehavior behavior, QgsExpressionContext *context )
532{
534
535 QgsFeatureIds newSelection;
536
537 std::optional< QgsExpressionContext > defaultContext;
538 if ( !context )
539 {
540 defaultContext.emplace( QgsExpressionContextUtils::globalProjectLayerScopes( this ) );
541 context = &defaultContext.value();
542 }
543 else
544 {
546 }
547
548 QgsExpression exp( expression );
549 exp.prepare( context );
550
552 {
555
556 if ( !exp.needsGeometry() )
558
559 QgsFeatureIterator features = getFeatures( request );
560
561 if ( behavior == Qgis::SelectBehavior::AddToSelection )
562 {
563 newSelection = selectedFeatureIds();
564 }
565 QgsFeature feat;
566 while ( features.nextFeature( feat ) )
567 {
568 newSelection << feat.id();
569 }
570 features.close();
571 }
573 {
574 QgsFeatureIds oldSelection = selectedFeatureIds();
575 QgsFeatureRequest request = QgsFeatureRequest().setFilterFids( oldSelection );
576
577 //refine request
578 if ( !exp.needsGeometry() )
581
582 QgsFeatureIterator features = getFeatures( request );
583 QgsFeature feat;
584 while ( features.nextFeature( feat ) )
585 {
586 context->setFeature( feat );
587 bool matches = exp.evaluate( context ).toBool();
588
589 if ( matches && behavior == Qgis::SelectBehavior::IntersectSelection )
590 {
591 newSelection << feat.id();
592 }
593 else if ( !matches && behavior == Qgis::SelectBehavior::RemoveFromSelection )
594 {
595 newSelection << feat.id();
596 }
597 }
598 }
599
600 selectByIds( newSelection );
601}
602
603void QgsVectorLayer::selectByIds( const QgsFeatureIds &ids, Qgis::SelectBehavior behavior, bool validateIds )
604{
606
607 // Opt-in validation: filter invalid IDs if requested
608 QgsFeatureIds idsToSelect = ids;
609 if ( validateIds )
611 idsToSelect = QgsVectorLayerUtils::filterValidFeatureIds( this, ids );
612 }
613
614 QgsFeatureIds newSelection;
615
616 switch ( behavior )
617 {
619 newSelection = idsToSelect;
620 break;
621
623 newSelection = mSelectedFeatureIds + idsToSelect;
624 break;
625
627 newSelection = mSelectedFeatureIds - idsToSelect;
628 break;
629
631 newSelection = mSelectedFeatureIds.intersect( idsToSelect );
632 break;
633 }
634
635 QgsFeatureIds deselectedFeatures = mSelectedFeatureIds - newSelection;
636 mSelectedFeatureIds = newSelection;
637 mPreviousSelectedFeatureIds.clear();
638
639 emit selectionChanged( newSelection, deselectedFeatures, true );
640}
641
642void QgsVectorLayer::modifySelection( const QgsFeatureIds &selectIds, const QgsFeatureIds &deselectIds )
643{
645
646 QgsFeatureIds intersectingIds = selectIds & deselectIds;
647 if ( !intersectingIds.isEmpty() )
648 {
649 QgsDebugMsgLevel( u"Trying to select and deselect the same item at the same time. Unsure what to do. Selecting dubious items."_s, 3 );
650 }
651
652 mSelectedFeatureIds -= deselectIds;
653 mSelectedFeatureIds += selectIds;
654 mPreviousSelectedFeatureIds.clear();
655
656 emit selectionChanged( selectIds, deselectIds - intersectingIds, false );
657}
658
660{
662
664 ids.subtract( mSelectedFeatureIds );
665 selectByIds( ids );
666}
667
674
676{
678
679 // normalize the rectangle
680 QgsRectangle normalizedRect = rect;
681 normalizedRect.normalize();
682
684
685 QgsFeatureIds selectIds;
686 QgsFeatureIds deselectIds;
687
688 QgsFeature fet;
689 while ( fit.nextFeature( fet ) )
690 {
691 if ( mSelectedFeatureIds.contains( fet.id() ) )
692 {
693 deselectIds << fet.id();
694 }
695 else
696 {
697 selectIds << fet.id();
698 }
699 }
700
701 modifySelection( selectIds, deselectIds );
702}
703
705{
707
708 if ( mSelectedFeatureIds.isEmpty() )
709 return;
710
711 const QgsFeatureIds previous = mSelectedFeatureIds;
713 mPreviousSelectedFeatureIds = previous;
714}
715
717{
719
720 if ( mPreviousSelectedFeatureIds.isEmpty() || !mSelectedFeatureIds.empty() )
721 return;
722
723 selectByIds( mPreviousSelectedFeatureIds );
724}
725
727{
728 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
730
731 return mDataProvider;
732}
733
735{
736 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
738
739 return mDataProvider;
740}
741
743{
744 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
746
747 return mSelectionProperties;
748}
749
756
763
765{
767
768 QgsProfileRequest modifiedRequest( request );
769 modifiedRequest.expressionContext().appendScope( createExpressionContextScope() );
770 return new QgsVectorLayerProfileGenerator( this, modifiedRequest );
771}
772
773void QgsVectorLayer::setProviderEncoding( const QString &encoding )
774{
776
777 if ( isValid() && mDataProvider && mDataProvider->encoding() != encoding )
778 {
779 mDataProvider->setEncoding( encoding );
780 updateFields();
781 }
782}
783
785{
787
788 mDiagramRenderer.reset( r );
789 emit rendererChanged();
790 emit styleChanged();
791}
792
794{
795 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
797
798 return QgsWkbTypes::geometryType( mWkbType );
799}
800
802{
804
805 return mWkbType;
806}
807
809{
811
812 if ( !isValid() || !isSpatial() || mSelectedFeatureIds.isEmpty() || !mDataProvider ) //no selected features
813 {
814 return QgsRectangle( 0, 0, 0, 0 );
815 }
816
817 QgsRectangle r, retval;
818 retval.setNull();
819
820 QgsFeature fet;
821 if ( mDataProvider->capabilities() & Qgis::VectorProviderCapability::SelectAtId )
822 {
823 QgsFeatureIterator fit = getFeatures( QgsFeatureRequest().setFilterFids( mSelectedFeatureIds ).setNoAttributes() );
824
825 while ( fit.nextFeature( fet ) )
826 {
827 if ( !fet.hasGeometry() )
828 continue;
829 r = fet.geometry().boundingBox();
830 retval.combineExtentWith( r );
831 }
832 }
833 else
834 {
835 QgsFeatureIterator fit = getFeatures( QgsFeatureRequest().setNoAttributes() );
836
837 while ( fit.nextFeature( fet ) )
838 {
839 if ( mSelectedFeatureIds.contains( fet.id() ) )
840 {
841 if ( fet.hasGeometry() )
842 {
843 r = fet.geometry().boundingBox();
844 retval.combineExtentWith( r );
845 }
846 }
847 }
848 }
849
850 if ( retval.width() == 0.0 || retval.height() == 0.0 )
851 {
852 // If all of the features are at the one point, buffer the
853 // rectangle a bit. If they are all at zero, do something a bit
854 // more crude.
855
856 if ( retval.xMinimum() == 0.0 && retval.xMaximum() == 0.0 && retval.yMinimum() == 0.0 && retval.yMaximum() == 0.0 )
857 {
858 retval.set( -1.0, -1.0, 1.0, 1.0 );
859 }
860 }
861
862 return retval;
863}
864
866{
867 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
869
870 return mLabelsEnabled && static_cast< bool >( mLabeling );
871}
872
874{
876
877 mLabelsEnabled = enabled;
878}
879
881{
882 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
884
885 if ( !mDiagramRenderer || !mDiagramLayerSettings )
886 return false;
887
888 QList<QgsDiagramSettings> settingList = mDiagramRenderer->diagramSettings();
889 if ( !settingList.isEmpty() )
890 {
891 return settingList.at( 0 ).enabled;
892 }
893 return false;
894}
895
896long long QgsVectorLayer::featureCount( const QString &legendKey ) const
897{
899
900 if ( !mSymbolFeatureCounted )
901 return -1;
902
903 return mSymbolFeatureCountMap.value( legendKey, -1 );
904}
905
906QgsFeatureIds QgsVectorLayer::symbolFeatureIds( const QString &legendKey ) const
907{
909
910 if ( !mSymbolFeatureCounted )
911 return QgsFeatureIds();
912
913 return mSymbolFeatureIdMap.value( legendKey, QgsFeatureIds() );
914}
916{
918
919 if ( ( mSymbolFeatureCounted || mFeatureCounter ) && !( storeSymbolFids && mSymbolFeatureIdMap.isEmpty() ) )
920 return mFeatureCounter;
921
922 mSymbolFeatureCountMap.clear();
923 mSymbolFeatureIdMap.clear();
924
925 if ( !isValid() )
926 {
927 QgsDebugMsgLevel( u"invoked with invalid layer"_s, 3 );
928 return mFeatureCounter;
929 }
930 if ( !mDataProvider )
931 {
932 QgsDebugMsgLevel( u"invoked with null mDataProvider"_s, 3 );
933 return mFeatureCounter;
934 }
935 if ( !mRenderer )
936 {
937 QgsDebugMsgLevel( u"invoked with null mRenderer"_s, 3 );
938 return mFeatureCounter;
939 }
940
941 if ( !mFeatureCounter || ( storeSymbolFids && mSymbolFeatureIdMap.isEmpty() ) )
942 {
943 mFeatureCounter = new QgsVectorLayerFeatureCounter( this, QgsExpressionContext(), storeSymbolFids );
944 connect( mFeatureCounter, &QgsTask::taskCompleted, this, &QgsVectorLayer::onFeatureCounterCompleted, Qt::UniqueConnection );
945 connect( mFeatureCounter, &QgsTask::taskTerminated, this, &QgsVectorLayer::onFeatureCounterTerminated, Qt::UniqueConnection );
946 QgsApplication::taskManager()->addTask( mFeatureCounter );
947 }
948
949 return mFeatureCounter;
950}
951
953{
955
956 // do not update extent by default when trust project option is activated
957 if ( force || !mReadExtentFromXml || ( mReadExtentFromXml && mXmlExtent2D.isNull() && mXmlExtent3D.isNull() ) )
958 {
959 mValidExtent2D = false;
960 mValidExtent3D = false;
961 }
962}
963
965{
967
969 mValidExtent2D = true;
970}
971
973{
975
977 mValidExtent3D = true;
978}
979
980void QgsVectorLayer::updateDefaultValues( QgsFeatureId fid, QgsFeature feature, QgsExpressionContext *context )
981{
983
984 if ( !mDefaultValueOnUpdateFields.isEmpty() )
985 {
986 if ( !feature.isValid() )
987 feature = getFeature( fid );
988
989 int size = mFields.size();
990 for ( int idx : std::as_const( mDefaultValueOnUpdateFields ) )
991 {
992 if ( idx < 0 || idx >= size )
993 continue;
994 feature.setAttribute( idx, defaultValue( idx, feature, context ) );
995 updateFeature( feature, true );
996 }
997 }
998}
999
1001{
1003
1004 QgsRectangle rect;
1005 rect.setNull();
1006
1007 if ( !isSpatial() )
1008 return rect;
1009
1010 // Don't do lazy extent if the layer is currently in edit mode
1011 if ( mLazyExtent2D && isEditable() )
1012 mLazyExtent2D = false;
1013
1014 if ( mDataProvider && mDataProvider->isValid() && ( mDataProvider->flags() & Qgis::DataProviderFlag::FastExtent2D ) )
1015 {
1016 // Provider has a trivial 2D extent calculation => always get extent from provider.
1017 // Things are nice and simple this way, e.g. we can always trust that this extent is
1018 // accurate and up to date.
1019 updateExtent( mDataProvider->extent() );
1020 mValidExtent2D = true;
1021 mLazyExtent2D = false;
1022 }
1023 else
1024 {
1025 if ( !mValidExtent2D && mLazyExtent2D && mReadExtentFromXml && !mXmlExtent2D.isNull() )
1026 {
1027 updateExtent( mXmlExtent2D );
1028 mValidExtent2D = true;
1029 mLazyExtent2D = false;
1030 }
1031
1032 if ( !mValidExtent2D && mLazyExtent2D && mDataProvider && mDataProvider->isValid() )
1033 {
1034 // store the extent
1035 updateExtent( mDataProvider->extent() );
1036 mValidExtent2D = true;
1037 mLazyExtent2D = false;
1038
1039 // show the extent
1040 QgsDebugMsgLevel( u"2D Extent of layer: %1"_s.arg( mExtent2D.toString() ), 3 );
1041 }
1042 }
1043
1044 if ( mValidExtent2D )
1045 return QgsMapLayer::extent();
1046
1047 if ( !isValid() || !mDataProvider )
1048 {
1049 QgsDebugMsgLevel( u"invoked with invalid layer or null mDataProvider"_s, 3 );
1050 return rect;
1051 }
1052
1053 if ( !mEditBuffer
1054 || ( !mDataProvider->transaction() && ( mEditBuffer->deletedFeatureIds().isEmpty() && mEditBuffer->changedGeometries().isEmpty() ) )
1055 || QgsDataSourceUri( mDataProvider->dataSourceUri() ).useEstimatedMetadata() )
1056 {
1057 mDataProvider->updateExtents();
1058
1059 // get the extent of the layer from the provider
1060 // but only when there are some features already
1061 if ( mDataProvider->featureCount() != 0 )
1062 {
1063 const QgsRectangle r = mDataProvider->extent();
1064 rect.combineExtentWith( r );
1065 }
1066
1067 if ( mEditBuffer && !mDataProvider->transaction() )
1068 {
1069 const auto addedFeatures = mEditBuffer->addedFeatures();
1070 for ( QgsFeatureMap::const_iterator it = addedFeatures.constBegin(); it != addedFeatures.constEnd(); ++it )
1071 {
1072 if ( it->hasGeometry() )
1073 {
1074 const QgsRectangle r = it->geometry().boundingBox();
1075 rect.combineExtentWith( r );
1076 }
1077 }
1078 }
1079 }
1080 else
1081 {
1082 QgsFeatureIterator fit = getFeatures( QgsFeatureRequest().setNoAttributes() );
1083
1084 QgsFeature fet;
1085 while ( fit.nextFeature( fet ) )
1086 {
1087 if ( fet.hasGeometry() && fet.geometry().type() != Qgis::GeometryType::Unknown )
1088 {
1089 const QgsRectangle bb = fet.geometry().boundingBox();
1090 rect.combineExtentWith( bb );
1091 }
1092 }
1093 }
1094
1095 if ( rect.xMinimum() > rect.xMaximum() && rect.yMinimum() > rect.yMaximum() )
1096 {
1097 // special case when there are no features in provider nor any added
1098 rect = QgsRectangle(); // use rectangle with zero coordinates
1099 }
1100
1101 updateExtent( rect );
1102 mValidExtent2D = true;
1103
1104 // Send this (hopefully) up the chain to the map canvas
1105 emit recalculateExtents();
1106
1107 return rect;
1108}
1109
1111{
1113
1114 // if data is 2D, redirect to 2D extend computation, and save it as 2D extent (in 3D bbox)
1115 if ( mDataProvider && mDataProvider->elevationProperties() && !mDataProvider->elevationProperties()->containsElevationData() )
1116 {
1117 return QgsBox3D( extent() );
1118 }
1119
1121 extent.setNull();
1122
1123 if ( !isSpatial() )
1124 return extent;
1125
1126 if ( mDataProvider && mDataProvider->isValid() && ( mDataProvider->flags() & Qgis::DataProviderFlag::FastExtent3D ) )
1127 {
1128 // Provider has a trivial 3D extent calculation => always get extent from provider.
1129 // Things are nice and simple this way, e.g. we can always trust that this extent is
1130 // accurate and up to date.
1131 updateExtent( mDataProvider->extent3D() );
1132 mValidExtent3D = true;
1133 mLazyExtent3D = false;
1134 }
1135 else
1136 {
1137 if ( !mValidExtent3D && mLazyExtent3D && mReadExtentFromXml && !mXmlExtent3D.isNull() )
1138 {
1139 updateExtent( mXmlExtent3D );
1140 mValidExtent3D = true;
1141 mLazyExtent3D = false;
1142 }
1143
1144 if ( !mValidExtent3D && mLazyExtent3D && mDataProvider && mDataProvider->isValid() )
1145 {
1146 // store the extent
1147 updateExtent( mDataProvider->extent3D() );
1148 mValidExtent3D = true;
1149 mLazyExtent3D = false;
1150
1151 // show the extent
1152 QgsDebugMsgLevel( u"3D Extent of layer: %1"_s.arg( mExtent3D.toString() ), 3 );
1153 }
1154 }
1155
1156 if ( mValidExtent3D )
1157 return QgsMapLayer::extent3D();
1158
1159 if ( !isValid() || !mDataProvider )
1160 {
1161 QgsDebugMsgLevel( u"invoked with invalid layer or null mDataProvider"_s, 3 );
1162 return extent;
1163 }
1164
1165 if ( !mEditBuffer
1166 || ( !mDataProvider->transaction() && ( mEditBuffer->deletedFeatureIds().isEmpty() && mEditBuffer->changedGeometries().isEmpty() ) )
1167 || QgsDataSourceUri( mDataProvider->dataSourceUri() ).useEstimatedMetadata() )
1168 {
1169 mDataProvider->updateExtents();
1170
1171 // get the extent of the layer from the provider
1172 // but only when there are some features already
1173 if ( mDataProvider->featureCount() != 0 )
1174 {
1175 const QgsBox3D ext = mDataProvider->extent3D();
1176 extent.combineWith( ext );
1177 }
1178
1179 if ( mEditBuffer && !mDataProvider->transaction() )
1180 {
1181 const auto addedFeatures = mEditBuffer->addedFeatures();
1182 for ( QgsFeatureMap::const_iterator it = addedFeatures.constBegin(); it != addedFeatures.constEnd(); ++it )
1183 {
1184 if ( it->hasGeometry() )
1185 {
1186 const QgsBox3D bbox = it->geometry().boundingBox3D();
1187 extent.combineWith( bbox );
1188 }
1189 }
1190 }
1191 }
1192 else
1193 {
1194 QgsFeatureIterator fit = getFeatures( QgsFeatureRequest().setNoAttributes() );
1195
1196 QgsFeature fet;
1197 while ( fit.nextFeature( fet ) )
1198 {
1199 if ( fet.hasGeometry() && fet.geometry().type() != Qgis::GeometryType::Unknown )
1200 {
1201 const QgsBox3D bb = fet.geometry().boundingBox3D();
1202 extent.combineWith( bb );
1203 }
1204 }
1205 }
1206
1207 if ( extent.xMinimum() > extent.xMaximum() && extent.yMinimum() > extent.yMaximum() && extent.zMinimum() > extent.zMaximum() )
1208 {
1209 // special case when there are no features in provider nor any added
1210 extent = QgsBox3D(); // use rectangle with zero coordinates
1211 }
1212
1213 updateExtent( extent );
1214 mValidExtent3D = true;
1215
1216 // Send this (hopefully) up the chain to the map canvas
1217 emit recalculateExtents();
1218
1219 return extent;
1220}
1221
1228
1235
1237{
1239
1240 if ( !isValid() || !mDataProvider )
1241 {
1242 QgsDebugMsgLevel( u"invoked with invalid layer or null mDataProvider"_s, 3 );
1243 return customProperty( u"storedSubsetString"_s ).toString();
1244 }
1245 return mDataProvider->subsetString();
1246}
1247
1248bool QgsVectorLayer::setSubsetString( const QString &subset )
1249{
1251
1252 if ( !isValid() || !mDataProvider )
1253 {
1254 QgsDebugMsgLevel( u"invoked with invalid layer or null mDataProvider or while editing"_s, 3 );
1255 setCustomProperty( u"storedSubsetString"_s, subset );
1256 return false;
1257 }
1258 else if ( mEditBuffer )
1259 {
1260 QgsDebugMsgLevel( u"invoked while editing"_s, 3 );
1261 return false;
1262 }
1263
1264 if ( subset == mDataProvider->subsetString() )
1265 return true;
1266
1267 bool res = mDataProvider->setSubsetString( subset );
1268
1269 // get the updated data source string from the provider
1270 mDataSource = mDataProvider->dataSourceUri();
1271 updateExtents();
1272 updateFields();
1273
1274 if ( res )
1275 {
1276 emit subsetStringChanged();
1278 }
1279
1280 return res;
1281}
1282
1284{
1285 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
1287
1288 if ( isValid()
1289 && mDataProvider
1290 && !mEditBuffer
1292 && ( mSimplifyMethod.simplifyHints() & simplifyHint )
1293 && renderContext.useRenderingOptimization() )
1294 {
1295 double maximumSimplificationScale = mSimplifyMethod.maximumScale();
1296
1297 // check maximum scale at which generalisation should be carried out
1298 return !( maximumSimplificationScale > 1 && renderContext.rendererScale() <= maximumSimplificationScale );
1299 }
1300 return false;
1301}
1302
1304{
1306
1307 return mConditionalStyles;
1308}
1309
1311{
1312 // non fatal for now -- the aggregate expression functions are not thread safe and call this
1314
1315 if ( !isValid() || !mDataProvider )
1316 return QgsFeatureIterator();
1317
1318 return QgsFeatureIterator( new QgsVectorLayerFeatureIterator( new QgsVectorLayerFeatureSource( this ), true, request ) );
1319}
1320
1322{
1324
1325 QgsFeature feature;
1327 if ( feature.isValid() )
1328 return feature.geometry();
1329 else
1330 return QgsGeometry();
1331}
1332
1334{
1336
1337 if ( !isValid() || !mEditBuffer || !mDataProvider )
1338 return false;
1339
1340
1341 if ( mGeometryOptions->isActive() )
1342 {
1343 QgsGeometry geom = feature.geometry();
1344 mGeometryOptions->apply( geom );
1345 feature.setGeometry( geom );
1346 }
1347
1348 bool success = mEditBuffer->addFeature( feature );
1349
1350 if ( success && mJoinBuffer->containsJoins() )
1351 {
1352 success = mJoinBuffer->addFeature( feature );
1353 }
1354
1355 return success;
1356}
1357
1358bool QgsVectorLayer::updateFeature( QgsFeature &updatedFeature, bool skipDefaultValues )
1359{
1361
1362 if ( !mEditBuffer || !mDataProvider )
1363 {
1364 return false;
1365 }
1366
1367 QgsFeature currentFeature = getFeature( updatedFeature.id() );
1368 if ( currentFeature.isValid() )
1369 {
1370 bool hasChanged = false;
1371 bool hasError = false;
1372
1373 if ( ( updatedFeature.hasGeometry() || currentFeature.hasGeometry() ) && !updatedFeature.geometry().isExactlyEqual( currentFeature.geometry() ) )
1374 {
1375 QgsGeometry geometry = updatedFeature.geometry();
1376 if ( changeGeometry( updatedFeature.id(), geometry, true ) )
1377 {
1378 hasChanged = true;
1379 updatedFeature.setGeometry( geometry );
1380 }
1381 else
1382 {
1383 QgsDebugMsgLevel( u"geometry of feature %1 could not be changed."_s.arg( updatedFeature.id() ), 3 );
1384 }
1385 }
1386
1387 QgsAttributes fa = updatedFeature.attributes();
1388 QgsAttributes ca = currentFeature.attributes();
1389
1390 for ( int attr = 0; attr < fa.count(); ++attr )
1391 {
1392 if ( !qgsVariantEqual( fa.at( attr ), ca.at( attr ) ) )
1393 {
1394 if ( changeAttributeValue( updatedFeature.id(), attr, fa.at( attr ), ca.at( attr ), true ) )
1395 {
1396 hasChanged = true;
1397 }
1398 else
1399 {
1400 QgsDebugMsgLevel( u"attribute %1 of feature %2 could not be changed."_s.arg( attr ).arg( updatedFeature.id() ), 3 );
1401 hasError = true;
1402 }
1403 }
1404 }
1405 if ( hasChanged && !mDefaultValueOnUpdateFields.isEmpty() && !skipDefaultValues )
1406 updateDefaultValues( updatedFeature.id(), updatedFeature );
1407
1408 return !hasError;
1409 }
1410 else
1411 {
1412 QgsDebugMsgLevel( u"feature %1 could not be retrieved"_s.arg( updatedFeature.id() ), 3 );
1413 return false;
1414 }
1415}
1416
1417
1418bool QgsVectorLayer::insertVertex( double x, double y, QgsFeatureId atFeatureId, int beforeVertex )
1419{
1421
1422 if ( !isValid() || !mEditBuffer || !mDataProvider )
1423 return false;
1424
1425 QgsVectorLayerEditUtils utils( this );
1426 bool result = utils.insertVertex( x, y, atFeatureId, beforeVertex );
1427 if ( result )
1428 updateExtents();
1429 return result;
1430}
1431
1432
1433bool QgsVectorLayer::insertVertex( const QgsPoint &point, QgsFeatureId atFeatureId, int beforeVertex )
1434{
1436
1437 if ( !isValid() || !mEditBuffer || !mDataProvider )
1438 return false;
1439
1440 QgsVectorLayerEditUtils utils( this );
1441 bool result = utils.insertVertex( point, atFeatureId, beforeVertex );
1442 if ( result )
1443 updateExtents();
1444 return result;
1445}
1446
1447
1448bool QgsVectorLayer::moveVertex( double x, double y, QgsFeatureId atFeatureId, int atVertex )
1449{
1451
1452 if ( !isValid() || !mEditBuffer || !mDataProvider )
1453 return false;
1454
1455 QgsVectorLayerEditUtils utils( this );
1456 bool result = utils.moveVertex( x, y, atFeatureId, atVertex );
1457
1458 if ( result )
1459 updateExtents();
1460 return result;
1461}
1462
1463bool QgsVectorLayer::moveVertex( const QgsPoint &p, QgsFeatureId atFeatureId, int atVertex )
1464{
1466
1467 if ( !isValid() || !mEditBuffer || !mDataProvider )
1468 return false;
1469
1470 QgsVectorLayerEditUtils utils( this );
1471 bool result = utils.moveVertex( p, atFeatureId, atVertex );
1472
1473 if ( result )
1474 updateExtents();
1475 return result;
1476}
1477
1479{
1480 return deleteVertices( featureId, { vertex } );
1481}
1482
1484{
1486
1487 if ( !isValid() || !mEditBuffer || !mDataProvider )
1489
1490 QgsVectorLayerEditUtils utils( this );
1491 Qgis::VectorEditResult result = utils.deleteVertices( featureId, vertices );
1492
1494 updateExtents();
1495 return result;
1496}
1497
1499{
1501
1502 if ( !isValid() || !mDataProvider || !( mDataProvider->capabilities() & Qgis::VectorProviderCapability::DeleteFeatures ) )
1503 {
1504 return false;
1505 }
1506
1507 if ( !isEditable() )
1508 {
1509 return false;
1510 }
1511
1512 int deleted = 0;
1513 int count = mSelectedFeatureIds.size();
1514 // Make a copy since deleteFeature modifies mSelectedFeatureIds
1515 QgsFeatureIds selectedFeatures( mSelectedFeatureIds );
1516 for ( QgsFeatureId fid : std::as_const( selectedFeatures ) )
1517 {
1518 deleted += deleteFeature( fid, context ); // removes from selection
1519 }
1520
1522 updateExtents();
1523
1524 if ( deletedCount )
1525 {
1526 *deletedCount = deleted;
1527 }
1528
1529 return deleted == count;
1530}
1531
1532static const QgsPointSequence vectorPointXY2pointSequence( const QVector<QgsPointXY> &points )
1533{
1534 QgsPointSequence pts;
1535 pts.reserve( points.size() );
1536 QVector<QgsPointXY>::const_iterator it = points.constBegin();
1537 while ( it != points.constEnd() )
1538 {
1539 pts.append( QgsPoint( *it ) );
1540 ++it;
1541 }
1542 return pts;
1543}
1544Qgis::GeometryOperationResult QgsVectorLayer::addRing( const QVector<QgsPointXY> &ring, QgsFeatureId *featureId )
1545{
1547
1548 return addRing( vectorPointXY2pointSequence( ring ), featureId );
1549}
1550
1552{
1554
1555 if ( !isValid() || !mEditBuffer || !mDataProvider )
1557
1558 QgsVectorLayerEditUtils utils( this );
1560
1561 //first try with selected features
1562 if ( !mSelectedFeatureIds.isEmpty() )
1563 {
1564 result = utils.addRing( ring, mSelectedFeatureIds, featureId );
1565 }
1566
1568 {
1569 //try with all intersecting features
1570 result = utils.addRing( ring, QgsFeatureIds(), featureId );
1571 }
1572
1573 return result;
1574}
1575
1577{
1579
1580 std::unique_ptr<QgsCurve> uniquePtrRing( ring );
1581
1582 if ( !isValid() || !mEditBuffer || !mDataProvider )
1584
1585 if ( !uniquePtrRing )
1587
1588 if ( !uniquePtrRing->isClosed() )
1590
1591 QgsVectorLayerEditUtils utils( this );
1593
1594 //first try with selected features
1595 if ( !mSelectedFeatureIds.isEmpty() )
1596 {
1597 result = utils.addRing( static_cast< QgsCurve * >( uniquePtrRing->clone() ), mSelectedFeatureIds, featureId );
1598 }
1599
1601 {
1602 //try with all intersecting features
1603 result = utils.addRing( static_cast< QgsCurve * >( uniquePtrRing.release() ), QgsFeatureIds(), featureId );
1604 }
1605
1606 return result;
1607}
1608
1610{
1612
1613 QgsPointSequence pts;
1614 pts.reserve( points.size() );
1615 for ( QList<QgsPointXY>::const_iterator it = points.constBegin(); it != points.constEnd(); ++it )
1616 {
1617 pts.append( QgsPoint( *it ) );
1618 }
1619 return addPart( pts );
1620}
1621
1623{
1625
1626 if ( !isValid() || !mEditBuffer || !mDataProvider )
1628
1629 //number of selected features must be 1
1630
1631 if ( mSelectedFeatureIds.empty() )
1632 {
1633 QgsDebugMsgLevel( u"Number of selected features <1"_s, 3 );
1635 }
1636 else if ( mSelectedFeatureIds.size() > 1 )
1637 {
1638 QgsDebugMsgLevel( u"Number of selected features >1"_s, 3 );
1640 }
1641
1642 QgsVectorLayerEditUtils utils( this );
1643 Qgis::GeometryOperationResult result = utils.addPart( points, *mSelectedFeatureIds.constBegin() );
1644
1646 updateExtents();
1647 return result;
1648}
1649
1651{
1653
1654 std::unique_ptr<QgsCurve> uniquePtrRing( ring );
1655
1656 if ( !isValid() || !mEditBuffer || !mDataProvider )
1658
1659 //number of selected features must be 1
1660
1661 if ( mSelectedFeatureIds.empty() )
1662 {
1663 QgsDebugMsgLevel( u"Number of selected features <1"_s, 3 );
1665 }
1666 else if ( mSelectedFeatureIds.size() > 1 )
1667 {
1668 QgsDebugMsgLevel( u"Number of selected features >1"_s, 3 );
1670 }
1671
1672 QgsVectorLayerEditUtils utils( this );
1673 Qgis::GeometryOperationResult result = utils.addPart( uniquePtrRing.release(), *mSelectedFeatureIds.constBegin() );
1674
1676 updateExtents();
1677 return result;
1678}
1679
1681{
1683
1684 std::unique_ptr<QgsCurvePolygon> uniquePtrPolygon( polygon );
1685
1686 if ( !isValid() || !mEditBuffer || !mDataProvider )
1688
1689 //number of selected features must be 1
1690
1691 if ( mSelectedFeatureIds.empty() )
1692 {
1693 QgsDebugMsgLevel( u"Number of selected features <1"_s, 3 );
1695 }
1696 else if ( mSelectedFeatureIds.size() > 1 )
1697 {
1698 QgsDebugMsgLevel( u"Number of selected features >1"_s, 3 );
1700 }
1701
1702 QgsVectorLayerEditUtils utils( this );
1703 Qgis::GeometryOperationResult result = utils.addPart( uniquePtrPolygon.release(), *mSelectedFeatureIds.constBegin() );
1704
1706 updateExtents();
1707 return result;
1708}
1709
1710// TODO QGIS 5.0 -- this should return Qgis::GeometryOperationResult, not int
1711int QgsVectorLayer::translateFeature( QgsFeatureId featureId, double dx, double dy )
1712{
1714
1715 if ( !isValid() || !mEditBuffer || !mDataProvider )
1716 return static_cast< int >( Qgis::GeometryOperationResult::LayerNotEditable );
1717
1718 QgsVectorLayerEditUtils utils( this );
1719 int result = utils.translateFeature( featureId, dx, dy );
1720
1721 if ( result == static_cast< int >( Qgis::GeometryOperationResult::Success ) )
1722 updateExtents();
1723 return result;
1724}
1725
1726Qgis::GeometryOperationResult QgsVectorLayer::splitParts( const QVector<QgsPointXY> &splitLine, bool topologicalEditing )
1727{
1729
1730 return splitParts( vectorPointXY2pointSequence( splitLine ), topologicalEditing );
1731}
1732
1734{
1736
1737 if ( !isValid() || !mEditBuffer || !mDataProvider )
1739
1740 QgsVectorLayerEditUtils utils( this );
1741 return utils.splitParts( splitLine, topologicalEditing );
1742}
1743
1744Qgis::GeometryOperationResult QgsVectorLayer::splitFeatures( const QVector<QgsPointXY> &splitLine, bool topologicalEditing )
1745{
1747
1748 return splitFeatures( vectorPointXY2pointSequence( splitLine ), topologicalEditing );
1749}
1750
1752{
1754
1755 QgsLineString splitLineString( splitLine );
1756 QgsPointSequence topologyTestPoints;
1757 bool preserveCircular = false;
1758 return splitFeatures( &splitLineString, topologyTestPoints, preserveCircular, topologicalEditing );
1759}
1760
1761Qgis::GeometryOperationResult QgsVectorLayer::splitFeatures( const QgsCurve *curve, QgsPointSequence &topologyTestPoints, bool preserveCircular, bool topologicalEditing )
1762{
1764
1765 if ( !isValid() || !mEditBuffer || !mDataProvider )
1767
1768 QgsVectorLayerEditUtils utils( this );
1769 return utils.splitFeatures( curve, topologyTestPoints, preserveCircular, topologicalEditing );
1770}
1771
1773{
1775
1776 if ( !isValid() || !mEditBuffer || !mDataProvider )
1777 return -1;
1778
1779 QgsVectorLayerEditUtils utils( this );
1780 return utils.addTopologicalPoints( geom );
1781}
1782
1789
1791{
1793
1794 if ( !isValid() || !mEditBuffer || !mDataProvider )
1795 return -1;
1796
1797 QgsVectorLayerEditUtils utils( this );
1798 return utils.addTopologicalPoints( p );
1799}
1800
1802{
1804
1805 if ( !mValid || !mEditBuffer || !mDataProvider )
1806 return -1;
1807
1808 QgsVectorLayerEditUtils utils( this );
1809 return utils.addTopologicalPoints( ps );
1810}
1811
1813{
1815
1816 if ( mLabeling.get() == labeling )
1817 return;
1818
1819 mLabeling.reset( 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
1868{
1870
1871 return mDataProvider ? mDataProvider->hasSpatialIndex() : Qgis::SpatialIndexPresence::Unknown;
1872}
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
1890{
1892
1893 if ( mActions )
1894 {
1895 const QList<QgsAction> actions = mActions->actions();
1896 for ( const QgsAction &action : actions )
1897 {
1898 if ( action.command().isEmpty() )
1899 {
1900 continue;
1901 }
1902
1903 switch ( action.type() )
1904 {
1909 {
1910 QgsEmbeddedScriptEntity entity( Qgis::EmbeddedScriptType::Action, tr( "%1: Action ’%2’" ).arg( name(), action.name() ), action.command() );
1911 if ( !visitor->visitEmbeddedScript( entity, context ) )
1912 {
1913 return false;
1914 }
1915 break;
1916 }
1917
1922 {
1923 break;
1924 }
1925 }
1926 }
1927 }
1928
1929 QString initCode;
1930 switch ( mEditFormConfig.initCodeSource() )
1931 {
1933 {
1934 initCode = u"# Calling function ’%1’\n\n%2"_s.arg( mEditFormConfig.initFunction(), mEditFormConfig.initCode() );
1935 break;
1936 }
1937
1939 {
1940 QFile *inputFile = QgsApplication::networkContentFetcherRegistry()->localFile( mEditFormConfig.initFilePath() );
1941 if ( inputFile && inputFile->open( QFile::ReadOnly ) )
1942 {
1943 // Read it into a string
1944 QTextStream inf( inputFile );
1945 initCode = inf.readAll();
1946 inputFile->close();
1947 initCode = u"# Calling function ’%1’\n# From file %2\n\n"_s.arg( mEditFormConfig.initFunction(), mEditFormConfig.initFilePath() ) + initCode;
1948 }
1949 break;
1950 }
1951
1953 {
1954 initCode = u"# Calling function ’%1’\n# From environment\n\n"_s.arg( mEditFormConfig.initFunction() );
1955 break;
1956 }
1957
1959 {
1960 break;
1961 }
1962 }
1963
1964 if ( !initCode.isEmpty() )
1965 {
1966 QgsEmbeddedScriptEntity entity( Qgis::EmbeddedScriptType::FormInitCode, tr( "%1: Attribute form init code" ).arg( name() ), initCode );
1967 if ( !visitor->visitEmbeddedScript( entity, context ) )
1968 {
1969 return false;
1970 }
1971 }
1972
1973 return true;
1974}
1975
1976bool QgsVectorLayer::readXml( const QDomNode &layer_node, QgsReadWriteContext &context )
1977{
1979
1980 QgsDebugMsgLevel( u"Datasource in QgsVectorLayer::readXml: %1"_s.arg( mDataSource.toLocal8Bit().data() ), 3 );
1981
1982 //process provider key
1983 QDomNode pkeyNode = layer_node.namedItem( u"provider"_s );
1984
1985 if ( pkeyNode.isNull() )
1986 {
1987 mProviderKey.clear();
1988 }
1989 else
1990 {
1991 QDomElement pkeyElt = pkeyNode.toElement();
1992 mProviderKey = pkeyElt.text();
1993 }
1994
1995 // determine type of vector layer
1996 if ( !mProviderKey.isNull() )
1997 {
1998 // if the provider string isn't empty, then we successfully
1999 // got the stored provider
2000 }
2001 else if ( mDataSource.contains( "dbname="_L1 ) )
2002 {
2003 mProviderKey = u"postgres"_s;
2004 }
2005 else
2006 {
2007 mProviderKey = u"ogr"_s;
2008 }
2009
2010 const QDomElement elem = layer_node.toElement();
2012
2013 mDataSourceReadOnly = mReadFlags & QgsMapLayer::FlagForceReadOnly;
2015
2016 if ( ( mReadFlags & QgsMapLayer::FlagDontResolveLayers ) || !setDataProvider( mProviderKey, options, flags ) )
2017 {
2019 {
2020 QgsDebugError( u"Could not set data provider for layer %1"_s.arg( publicSource() ) );
2021 }
2022
2023 // for invalid layer sources, we fallback to stored wkbType if available
2024 if ( elem.hasAttribute( u"wkbType"_s ) )
2025 mWkbType = qgsEnumKeyToValue( elem.attribute( u"wkbType"_s ), mWkbType );
2026 }
2027
2028 QDomElement pkeyElem = pkeyNode.toElement();
2029 if ( !pkeyElem.isNull() )
2030 {
2031 QString encodingString = pkeyElem.attribute( u"encoding"_s );
2032 if ( mDataProvider && !encodingString.isEmpty() )
2033 {
2034 mDataProvider->setEncoding( encodingString );
2035 }
2036 }
2037
2038 // load vector joins - does not resolve references to layers yet
2039 mJoinBuffer->readXml( layer_node );
2040
2041 updateFields();
2042
2043 // If style doesn't include a legend, we'll need to make a default one later...
2044 mSetLegendFromStyle = false;
2045
2046 QString errorMsg;
2047 if ( !readSymbology( layer_node, errorMsg, context ) )
2048 {
2049 return false;
2050 }
2051
2052 readStyleManager( layer_node );
2053
2054 QDomNode depsNode = layer_node.namedItem( u"dataDependencies"_s );
2055 QDomNodeList depsNodes = depsNode.childNodes();
2056 QSet<QgsMapLayerDependency> sources;
2057 for ( int i = 0; i < depsNodes.count(); i++ )
2058 {
2059 QString source = depsNodes.at( i ).toElement().attribute( u"id"_s );
2060 sources << QgsMapLayerDependency( source );
2061 }
2062 setDependencies( sources );
2063
2064 if ( !mSetLegendFromStyle )
2066
2067 // read extent
2069 {
2070 mReadExtentFromXml = true;
2071 }
2072 if ( mReadExtentFromXml )
2073 {
2074 const QDomNode extentNode = layer_node.namedItem( u"extent"_s );
2075 if ( !extentNode.isNull() )
2076 {
2077 mXmlExtent2D = QgsXmlUtils::readRectangle( extentNode.toElement() );
2078 }
2079 const QDomNode extent3DNode = layer_node.namedItem( u"extent3D"_s );
2080 if ( !extent3DNode.isNull() )
2081 {
2082 mXmlExtent3D = QgsXmlUtils::readBox3D( extent3DNode.toElement() );
2083 }
2084 }
2085
2086 // auxiliary layer
2087 const QDomNode asNode = layer_node.namedItem( u"auxiliaryLayer"_s );
2088 const QDomElement asElem = asNode.toElement();
2089 if ( !asElem.isNull() )
2090 {
2091 mAuxiliaryLayerKey = asElem.attribute( u"key"_s );
2092 }
2093
2094 // QGIS Server WMS Dimensions
2095 mServerProperties->readXml( layer_node );
2096
2097 return isValid(); // should be true if read successfully
2098
2099} // void QgsVectorLayer::readXml
2100
2101
2102void QgsVectorLayer::setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags )
2103{
2105
2106 Qgis::GeometryType geomType = geometryType();
2107
2108 mDataSource = dataSource;
2109 setName( baseName );
2110 setDataProvider( provider, options, flags );
2111
2112 if ( !isValid() )
2113 {
2114 return;
2115 }
2116
2117 // Always set crs
2119
2120 bool loadDefaultStyleFlag = false;
2122 {
2123 loadDefaultStyleFlag = true;
2124 }
2125
2126 // reset style if loading default style, style is missing, or geometry type is has changed (and layer is valid)
2127 if ( !renderer() || !legend() || ( isValid() && geomType != geometryType() ) || loadDefaultStyleFlag )
2128 {
2129 std::unique_ptr< QgsScopedRuntimeProfile > profile;
2130 if ( QgsApplication::profiler()->groupIsActive( u"projectload"_s ) )
2131 profile = std::make_unique< QgsScopedRuntimeProfile >( tr( "Load layer style" ), u"projectload"_s );
2132
2133 bool defaultLoadedFlag = false;
2134
2135 // defer style changed signal until we've set the renderer, labeling, everything.
2136 // we don't want multiple signals!
2137 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
2138
2139 // need to check whether the default style included a legend, and if not, we need to make a default legend
2140 // later...
2141 mSetLegendFromStyle = false;
2142
2143 // first check if there is a default style / propertysheet defined
2144 // for this layer and if so apply it
2145 // this should take precedence over all
2146 if ( !defaultLoadedFlag && loadDefaultStyleFlag )
2147 {
2148 loadDefaultStyle( defaultLoadedFlag );
2149 }
2150
2151 if ( loadDefaultStyleFlag && !defaultLoadedFlag && isSpatial() && mDataProvider->capabilities() & Qgis::VectorProviderCapability::CreateRenderer )
2152 {
2153 // if we didn't load a default style for this layer, try to create a renderer directly from the data provider
2154 std::unique_ptr< QgsFeatureRenderer > defaultRenderer( mDataProvider->createRenderer() );
2155 if ( defaultRenderer )
2156 {
2157 defaultLoadedFlag = true;
2158 setRenderer( defaultRenderer.release() );
2159
2160 applyRendererSettings();
2161 }
2162 }
2163
2164 // if the default style failed to load or was disabled use some very basic defaults
2165 if ( !defaultLoadedFlag )
2166 {
2167 // add single symbol renderer for spatial layers
2169 }
2170
2171 if ( !mSetLegendFromStyle )
2173
2174 if ( mDataProvider->capabilities() & Qgis::VectorProviderCapability::CreateLabeling )
2175 {
2176 std::unique_ptr< QgsAbstractVectorLayerLabeling > defaultLabeling( mDataProvider->createLabeling() );
2177 if ( defaultLabeling )
2178 {
2179 setLabeling( defaultLabeling.release() );
2180 setLabelsEnabled( true );
2181 }
2182 }
2183
2184 styleChangedSignalBlocker.release();
2186 }
2187}
2188
2189QString QgsVectorLayer::loadDefaultStyle( bool &resultFlag )
2190{
2192
2193 // first try to load a user-defined default style - this should always take precedence
2194 QString styleXml = QgsMapLayer::loadDefaultStyle( resultFlag );
2195
2196 if ( resultFlag )
2197 {
2198 // Try to load all stored styles from DB
2199 if ( mLoadAllStoredStyle && mDataProvider && mDataProvider->styleStorageCapabilities().testFlag( Qgis::ProviderStyleStorageCapability::LoadFromDatabase ) )
2200 {
2201 QStringList ids, names, descriptions;
2202 QString errorMessage;
2203 // Get the number of styles related to current layer.
2204 const int relatedStylesCount { listStylesInDatabase( ids, names, descriptions, errorMessage ) };
2205 Q_ASSERT( ids.count() == names.count() );
2206 const QString currentStyleName { mStyleManager->currentStyle() };
2207 for ( int i = 0; i < relatedStylesCount; ++i )
2208 {
2209 if ( names.at( i ) == currentStyleName )
2210 {
2211 continue;
2212 }
2213 errorMessage.clear();
2214 const QString styleXml { getStyleFromDatabase( ids.at( i ), errorMessage ) };
2215 if ( !styleXml.isEmpty() && errorMessage.isEmpty() )
2216 {
2217 mStyleManager->addStyle( names.at( i ), QgsMapLayerStyle( styleXml ) );
2218 }
2219 else
2220 {
2221 QgsDebugMsgLevel( u"Error retrieving style %1 from DB: %2"_s.arg( ids.at( i ), errorMessage ), 2 );
2222 }
2223 }
2224 }
2225 return styleXml;
2226 }
2227
2228 if ( isSpatial() && mDataProvider->capabilities() & Qgis::VectorProviderCapability::CreateRenderer )
2229 {
2230 // otherwise try to create a renderer directly from the data provider
2231 std::unique_ptr< QgsFeatureRenderer > defaultRenderer( mDataProvider->createRenderer() );
2232 if ( defaultRenderer )
2233 {
2234 resultFlag = true;
2235 setRenderer( defaultRenderer.release() );
2236
2237 applyRendererSettings();
2238
2239 return QString();
2240 }
2241 }
2242
2243 return QString();
2244}
2245
2246bool QgsVectorLayer::setDataProvider( QString const &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags )
2247{
2249
2250 mProviderKey = provider;
2251 delete mDataProvider;
2252
2253 // For Postgres provider primary key unicity is tested at construction time,
2254 // so it has to be set before initializing the provider,
2255 // this manipulation is necessary to preserve default behavior when
2256 // "trust layer metadata" project level option is set and checkPrimaryKeyUnicity
2257 // was not explicitly passed in the uri
2258 if ( provider.compare( "postgres"_L1 ) == 0 )
2259 {
2260 const QString checkUnicityKey { u"checkPrimaryKeyUnicity"_s };
2261 QgsDataSourceUri uri( mDataSource );
2262 if ( !uri.hasParam( checkUnicityKey ) )
2263 {
2264 uri.setParam( checkUnicityKey, mReadExtentFromXml ? "0" : "1" );
2265 mDataSource = uri.uri( false );
2266 }
2267 }
2268
2269 std::unique_ptr< QgsScopedRuntimeProfile > profile;
2270 if ( QgsApplication::profiler()->groupIsActive( u"projectload"_s ) )
2271 profile = std::make_unique< QgsScopedRuntimeProfile >( tr( "Create %1 provider" ).arg( provider ), u"projectload"_s );
2272
2273 if ( mPreloadedProvider )
2274 {
2275 QgsDebugMsgLevel( u"Attaching map layer %1 to preloaded data provider. Provider belongs to thread %2"_s.arg( id(), QgsThreadingUtils::threadDescription( mPreloadedProvider->thread() ) ), 2 );
2276 mDataProvider = qobject_cast< QgsVectorDataProvider * >( mPreloadedProvider.release() );
2277 }
2278 else
2279 {
2280 mDataProvider = qobject_cast<QgsVectorDataProvider *>( QgsProviderRegistry::instance()->createProvider( provider, mDataSource, options, flags ) );
2281 }
2282
2283 if ( !mDataProvider )
2284 {
2285 setValid( false );
2286 QgsDebugMsgLevel( u"Unable to get data provider"_s, 2 );
2287 return false;
2288 }
2289
2290 mDataProvider->setParent( this );
2291 connect( mDataProvider, &QgsVectorDataProvider::raiseError, this, &QgsVectorLayer::raiseError );
2292
2293 QgsDebugMsgLevel( u"Instantiated the data provider plugin"_s, 2 );
2294
2295 setValid( mDataProvider->isValid() );
2296 if ( !isValid() )
2297 {
2298 QgsDebugMsgLevel( u"Invalid provider plugin %1"_s.arg( QString( mDataSource.toUtf8() ) ), 2 );
2299 return false;
2300 }
2301
2302 if ( profile )
2303 profile->switchTask( tr( "Read layer metadata" ) );
2304 if ( mDataProvider->capabilities() & Qgis::VectorProviderCapability::ReadLayerMetadata )
2305 {
2306 // we combine the provider metadata with the layer's existing metadata, so as not to reset any user customizations to the metadata
2307 // back to the default if a layer's data source is changed
2308 QgsLayerMetadata newMetadata = mDataProvider->layerMetadata();
2309 // this overwrites the provider metadata with any properties which are non-empty from the existing layer metadata
2310 newMetadata.combine( &mMetadata );
2311
2312 setMetadata( newMetadata );
2313 QgsDebugMsgLevel( u"Set Data provider QgsLayerMetadata identifier[%1]"_s.arg( metadata().identifier() ), 4 );
2314 }
2315
2316 // TODO: Check if the provider has the capability to send fullExtentCalculated
2317 connect( mDataProvider, &QgsVectorDataProvider::fullExtentCalculated, this, [this] { updateExtents(); } );
2318
2319 // get and store the feature type
2320 mWkbType = mDataProvider->wkbType();
2321
2322 // before we update the layer fields from the provider, we first copy any default set alias and
2323 // editor widget config from the data provider fields, if present
2324 const QgsFields providerFields = mDataProvider->fields();
2325 for ( const QgsField &field : providerFields )
2326 {
2327 // we only copy defaults from the provider if we aren't overriding any configuration made in the layer
2328 if ( !field.editorWidgetSetup().isNull() && mFieldWidgetSetups.value( field.name() ).isNull() )
2329 {
2330 mFieldWidgetSetups[field.name()] = field.editorWidgetSetup();
2331 }
2332 if ( !field.alias().isEmpty() && mAttributeAliasMap.value( field.name() ).isEmpty() )
2333 {
2334 mAttributeAliasMap[field.name()] = field.alias();
2335 }
2336 if ( !mAttributeSplitPolicy.contains( field.name() ) )
2337 {
2338 mAttributeSplitPolicy[field.name()] = field.splitPolicy();
2339 }
2340 if ( !mAttributeDuplicatePolicy.contains( field.name() ) )
2341 {
2342 mAttributeDuplicatePolicy[field.name()] = field.duplicatePolicy();
2343 }
2344 if ( !mAttributeMergePolicy.contains( field.name() ) )
2345 {
2346 mAttributeMergePolicy[field.name()] = field.mergePolicy();
2347 }
2348 }
2349
2350 if ( profile )
2351 profile->switchTask( tr( "Read layer fields" ) );
2352 updateFields();
2353
2354 if ( mProviderKey == "postgres"_L1 )
2355 {
2356 // update datasource from data provider computed one
2357 mDataSource = mDataProvider->dataSourceUri( false );
2358 }
2359 else if ( mProviderKey == "osm"_L1 )
2360 {
2361 // make sure that the "observer" has been removed from URI to avoid crashes
2362 mDataSource = mDataProvider->dataSourceUri();
2363 }
2364 else if ( provider == "ogr"_L1 )
2365 {
2366 // make sure that the /vsigzip or /vsizip is added to uri, if applicable
2367 mDataSource = mDataProvider->dataSourceUri();
2368 if ( mDataSource.right( 10 ) == "|layerid=0"_L1 )
2369 mDataSource.chop( 10 );
2370 }
2371 else if ( provider == "memory"_L1 )
2372 {
2373 // required so that source differs between memory layers
2374 mDataSource = mDataSource + u"&uid=%1"_s.arg( QUuid::createUuid().toString() );
2375 }
2376 else if ( provider == "hana"_L1 )
2377 {
2378 // update datasource from data provider computed one
2379 mDataSource = mDataProvider->dataSourceUri( false );
2380 }
2381
2382 connect( mDataProvider, &QgsVectorDataProvider::dataChanged, this, &QgsVectorLayer::emitDataChanged );
2384
2385 return true;
2386} // QgsVectorLayer:: setDataProvider
2387
2388
2389/* virtual */
2390bool QgsVectorLayer::writeXml( QDomNode &layer_node, QDomDocument &document, const QgsReadWriteContext &context ) const
2391{
2393
2394 // first get the layer element so that we can append the type attribute
2395
2396 QDomElement mapLayerNode = layer_node.toElement();
2397
2398 if ( mapLayerNode.isNull() || ( "maplayer" != mapLayerNode.nodeName() ) )
2399 {
2400 QgsDebugMsgLevel( u"can't find <maplayer>"_s, 2 );
2401 return false;
2402 }
2403
2404 mapLayerNode.setAttribute( u"type"_s, QgsMapLayerFactory::typeToString( Qgis::LayerType::Vector ) );
2405
2406 // set the geometry type
2407 mapLayerNode.setAttribute( u"geometry"_s, QgsWkbTypes::geometryDisplayString( geometryType() ) );
2408 mapLayerNode.setAttribute( u"wkbType"_s, qgsEnumValueToKey( wkbType() ) );
2409
2410 // add provider node
2411 if ( mDataProvider )
2412 {
2413 QDomElement provider = document.createElement( u"provider"_s );
2414 provider.setAttribute( u"encoding"_s, mDataProvider->encoding() );
2415 QDomText providerText = document.createTextNode( providerType() );
2416 provider.appendChild( providerText );
2417 layer_node.appendChild( provider );
2418 }
2419
2420 //save joins
2421 mJoinBuffer->writeXml( layer_node, document );
2422
2423 // dependencies
2424 QDomElement dependenciesElement = document.createElement( u"layerDependencies"_s );
2425 const auto constDependencies = dependencies();
2426 for ( const QgsMapLayerDependency &dep : constDependencies )
2427 {
2429 continue;
2430 QDomElement depElem = document.createElement( u"layer"_s );
2431 depElem.setAttribute( u"id"_s, dep.layerId() );
2432 dependenciesElement.appendChild( depElem );
2433 }
2434 layer_node.appendChild( dependenciesElement );
2435
2436 // change dependencies
2437 QDomElement dataDependenciesElement = document.createElement( u"dataDependencies"_s );
2438 for ( const QgsMapLayerDependency &dep : constDependencies )
2439 {
2440 if ( dep.type() != QgsMapLayerDependency::DataDependency )
2441 continue;
2442 QDomElement depElem = document.createElement( u"layer"_s );
2443 depElem.setAttribute( u"id"_s, dep.layerId() );
2444 dataDependenciesElement.appendChild( depElem );
2445 }
2446 layer_node.appendChild( dataDependenciesElement );
2447
2448 // save expression fields
2449 mExpressionFieldBuffer->writeXml( layer_node, document );
2450
2451 writeStyleManager( layer_node, document );
2452
2453 // auxiliary layer
2454 QDomElement asElem = document.createElement( u"auxiliaryLayer"_s );
2455 if ( mAuxiliaryLayer )
2456 {
2457 const QString pkField = mAuxiliaryLayer->joinInfo().targetFieldName();
2458 asElem.setAttribute( u"key"_s, pkField );
2459 }
2460 layer_node.appendChild( asElem );
2461
2462 // renderer specific settings
2463 QString errorMsg;
2464 return writeSymbology( layer_node, document, errorMsg, context );
2465}
2466
2467QString QgsVectorLayer::encodedSource( const QString &source, const QgsReadWriteContext &context ) const
2468{
2470
2471 if ( providerType() == "memory"_L1 )
2472 {
2473 // Refetch the source from the provider, because adding fields actually changes the source for this provider.
2474 return dataProvider()->dataSourceUri();
2475 }
2476
2478}
2479
2480QString QgsVectorLayer::decodedSource( const QString &source, const QString &provider, const QgsReadWriteContext &context ) const
2481{
2483
2484 return QgsProviderRegistry::instance()->relativeToAbsoluteUri( provider, source, context );
2485}
2486
2487
2495
2496
2497bool QgsVectorLayer::readSymbology( const QDomNode &layerNode, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
2498{
2500
2501 if ( categories.testFlag( Fields ) )
2502 {
2503 if ( !mExpressionFieldBuffer )
2504 mExpressionFieldBuffer = std::make_unique<QgsExpressionFieldBuffer>();
2505 mExpressionFieldBuffer->readXml( layerNode );
2506
2507 updateFields();
2508 }
2509
2510 if ( categories.testFlag( Relations ) )
2511 {
2512 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Relations" ) );
2513
2514 // Restore referenced layers: relations where "this" is the child layer (the referencing part, that holds the FK)
2515 QDomNodeList referencedLayersNodeList = layerNode.toElement().elementsByTagName( u"referencedLayers"_s );
2516 if ( referencedLayersNodeList.size() > 0 )
2517 {
2518 const QDomNodeList relationNodes { referencedLayersNodeList.at( 0 ).childNodes() };
2519 for ( int i = 0; i < relationNodes.length(); ++i )
2520 {
2521 const QDomElement relationElement = relationNodes.at( i ).toElement();
2522
2523 mWeakRelations.push_back( QgsWeakRelation::readXml( this, QgsWeakRelation::Referencing, relationElement, context.pathResolver() ) );
2524 }
2525 }
2526
2527 // Restore referencing layers: relations where "this" is the parent layer (the referenced part where the FK points to)
2528 QDomNodeList referencingLayersNodeList = layerNode.toElement().elementsByTagName( u"referencingLayers"_s );
2529 if ( referencingLayersNodeList.size() > 0 )
2530 {
2531 const QDomNodeList relationNodes { referencingLayersNodeList.at( 0 ).childNodes() };
2532 for ( int i = 0; i < relationNodes.length(); ++i )
2533 {
2534 const QDomElement relationElement = relationNodes.at( i ).toElement();
2535 mWeakRelations.push_back( QgsWeakRelation::readXml( this, QgsWeakRelation::Referenced, relationElement, context.pathResolver() ) );
2536 }
2537 }
2538 }
2539
2540 QDomElement layerElement = layerNode.toElement();
2541
2542 readCommonStyle( layerElement, context, categories );
2543
2544 readStyle( layerNode, errorMessage, context, categories );
2545
2546 if ( categories.testFlag( MapTips ) )
2547 {
2548 QDomElement mapTipElem = layerNode.namedItem( u"mapTip"_s ).toElement();
2549 setMapTipTemplate( mapTipElem.text() );
2550 setMapTipsEnabled( mapTipElem.attribute( u"enabled"_s, u"1"_s ).toInt() == 1 );
2551 }
2552
2553 if ( categories.testFlag( LayerConfiguration ) )
2554 mDisplayExpression = layerNode.namedItem( u"previewExpression"_s ).toElement().text();
2555
2556 // Try to migrate pre QGIS 3.0 display field property
2557 QString displayField = layerNode.namedItem( u"displayfield"_s ).toElement().text();
2558 if ( mFields.lookupField( displayField ) < 0 )
2559 {
2560 // if it's not a field, it's a maptip
2561 if ( mMapTipTemplate.isEmpty() && categories.testFlag( MapTips ) )
2562 mMapTipTemplate = displayField;
2563 }
2564 else
2565 {
2566 if ( mDisplayExpression.isEmpty() && categories.testFlag( LayerConfiguration ) )
2567 mDisplayExpression = QgsExpression::quotedColumnRef( displayField );
2568 }
2569
2570 // process the attribute actions
2571 if ( categories.testFlag( Actions ) )
2572 mActions->readXml( layerNode, context );
2573
2574 if ( categories.testFlag( Fields ) )
2575 {
2576 // IMPORTANT - we don't clear mAttributeAliasMap here, as it may contain aliases which are coming direct
2577 // from the data provider. Instead we leave any existing aliases and only overwrite them if the style
2578 // has a specific value for that field's alias
2579 QDomNode aliasesNode = layerNode.namedItem( u"aliases"_s );
2580 if ( !aliasesNode.isNull() )
2581 {
2582 QDomElement aliasElem;
2583
2584 QDomNodeList aliasNodeList = aliasesNode.toElement().elementsByTagName( u"alias"_s );
2585 for ( int i = 0; i < aliasNodeList.size(); ++i )
2586 {
2587 aliasElem = aliasNodeList.at( i ).toElement();
2588
2589 QString field;
2590 if ( aliasElem.hasAttribute( u"field"_s ) )
2591 {
2592 field = aliasElem.attribute( u"field"_s );
2593 }
2594 else
2595 {
2596 int index = aliasElem.attribute( u"index"_s ).toInt();
2597
2598 if ( index >= 0 && index < fields().count() )
2599 field = fields().at( index ).name();
2600 }
2601
2602 QString alias;
2603
2604 if ( !aliasElem.attribute( u"name"_s ).isEmpty() )
2605 {
2606 //if it has alias
2607 alias = context.projectTranslator()->translate( u"project:layers:%1:fieldaliases"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ), aliasElem.attribute( u"name"_s ) );
2608 QgsDebugMsgLevel( "context" + u"project:layers:%1:fieldaliases"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ) + " source " + aliasElem.attribute( u"name"_s ), 3 );
2609 }
2610 else
2611 {
2612 //if it has no alias, it should be the fields translation
2613 alias = context.projectTranslator()->translate( u"project:layers:%1:fieldaliases"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ), field );
2614 QgsDebugMsgLevel( "context" + u"project:layers:%1:fieldaliases"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ) + " source " + field, 3 );
2615 //if it gets the exact field value, there has been no translation (or not even translation loaded) - so no alias should be generated;
2616 if ( alias == aliasElem.attribute( u"field"_s ) )
2617 alias.clear();
2618 }
2619
2620 QgsDebugMsgLevel( "field " + field + " origalias " + aliasElem.attribute( u"name"_s ) + " trans " + alias, 3 );
2621 mAttributeAliasMap.insert( field, alias );
2622 }
2623 }
2624
2625 // custom comments
2626 // mAttributeCustomCommentMap is cleared, because when a custom comment is null the provider comment should be considered
2627 mAttributeCustomCommentMap.clear();
2628 QDomNode customCommentsNode = layerNode.namedItem( u"customComments"_s );
2629 if ( !customCommentsNode.isNull() )
2630 {
2631 QDomElement customCommentEntryElem;
2632
2633 QDomNodeList customCommentNodeList = customCommentsNode.toElement().elementsByTagName( u"customComment"_s );
2634 for ( int i = 0; i < customCommentNodeList.size(); ++i )
2635 {
2636 customCommentEntryElem = customCommentNodeList.at( i ).toElement();
2637
2638 const QString field = customCommentEntryElem.attribute( u"field"_s );
2639
2640 //empty values are important as well (to override provider comments with nothing)
2641 const QString customCommentEntryValue = customCommentEntryElem.attribute( u"value"_s );
2642 QString customComment = customCommentEntryValue;
2643 if ( !customCommentEntryValue.isEmpty() )
2644 {
2645 //translate comment if it's not empty
2646 customComment = context.projectTranslator()->translate( u"project:layers:%1:fieldcustomcomments"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ), customCommentEntryValue );
2647 QgsDebugMsgLevel( "context" + u"project:layers:%1:fieldcustomcomments"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ) + " source " + customCommentEntryValue, 3 );
2648 }
2649 if ( fields().lookupField( field ) < 0 )
2650 {
2651 QgsDebugMsgLevel( u"Warning: Field %1 not found in layer %2 to load custom comment from setting "_s.arg( field, name() ), 2 );
2652 continue;
2653 }
2654 mAttributeCustomCommentMap.insert( field, customComment );
2655 }
2656 }
2657
2658 // IMPORTANT - we don't clear mAttributeSplitPolicy here, as it may contain policies which are coming direct
2659 // from the data provider. Instead we leave any existing policies and only overwrite them if the style
2660 // has a specific value for that field's policy
2661 const QDomNode splitPoliciesNode = layerNode.namedItem( u"splitPolicies"_s );
2662 if ( !splitPoliciesNode.isNull() )
2663 {
2664 const QDomNodeList splitPolicyNodeList = splitPoliciesNode.toElement().elementsByTagName( u"policy"_s );
2665 for ( int i = 0; i < splitPolicyNodeList.size(); ++i )
2666 {
2667 const QDomElement splitPolicyElem = splitPolicyNodeList.at( i ).toElement();
2668 const QString field = splitPolicyElem.attribute( u"field"_s );
2669 const Qgis::FieldDomainSplitPolicy policy = qgsEnumKeyToValue( splitPolicyElem.attribute( u"policy"_s ), Qgis::FieldDomainSplitPolicy::Duplicate );
2670 mAttributeSplitPolicy.insert( field, policy );
2671 }
2672 }
2673
2674 // The duplicate policy is - unlike alias and split policy - never defined by the data provider, so we clear the map
2675 mAttributeDuplicatePolicy.clear();
2676 const QDomNode duplicatePoliciesNode = layerNode.namedItem( u"duplicatePolicies"_s );
2677 if ( !duplicatePoliciesNode.isNull() )
2678 {
2679 const QDomNodeList duplicatePolicyNodeList = duplicatePoliciesNode.toElement().elementsByTagName( u"policy"_s );
2680 for ( int i = 0; i < duplicatePolicyNodeList.size(); ++i )
2681 {
2682 const QDomElement duplicatePolicyElem = duplicatePolicyNodeList.at( i ).toElement();
2683 const QString field = duplicatePolicyElem.attribute( u"field"_s );
2684 const Qgis::FieldDuplicatePolicy policy = qgsEnumKeyToValue( duplicatePolicyElem.attribute( u"policy"_s ), Qgis::FieldDuplicatePolicy::Duplicate );
2685 mAttributeDuplicatePolicy.insert( field, policy );
2686 }
2687 }
2688
2689 const QDomNode mergePoliciesNode = layerNode.namedItem( u"mergePolicies"_s );
2690 if ( !mergePoliciesNode.isNull() )
2691 {
2692 const QDomNodeList mergePolicyNodeList = mergePoliciesNode.toElement().elementsByTagName( u"policy"_s );
2693 for ( int i = 0; i < mergePolicyNodeList.size(); ++i )
2694 {
2695 const QDomElement mergePolicyElem = mergePolicyNodeList.at( i ).toElement();
2696 const QString field = mergePolicyElem.attribute( u"field"_s );
2697 const Qgis::FieldDomainMergePolicy policy = qgsEnumKeyToValue( mergePolicyElem.attribute( u"policy"_s ), Qgis::FieldDomainMergePolicy::UnsetField );
2698 mAttributeMergePolicy.insert( field, policy );
2699 }
2700 }
2701
2702 // default expressions
2703 mDefaultExpressionMap.clear();
2704 QDomNode defaultsNode = layerNode.namedItem( u"defaults"_s );
2705 if ( !defaultsNode.isNull() )
2706 {
2707 QDomNodeList defaultNodeList = defaultsNode.toElement().elementsByTagName( u"default"_s );
2708 for ( int i = 0; i < defaultNodeList.size(); ++i )
2709 {
2710 QDomElement defaultElem = defaultNodeList.at( i ).toElement();
2711
2712 QString field = defaultElem.attribute( u"field"_s, QString() );
2713 QString expression = defaultElem.attribute( u"expression"_s, QString() );
2714 bool applyOnUpdate = defaultElem.attribute( u"applyOnUpdate"_s, u"0"_s ) == "1"_L1;
2715 if ( field.isEmpty() || expression.isEmpty() )
2716 continue;
2717
2718 mDefaultExpressionMap.insert( field, QgsDefaultValue( expression, applyOnUpdate ) );
2719 }
2720 }
2721
2722 // constraints
2723 mFieldConstraints.clear();
2724 mFieldConstraintStrength.clear();
2725 QDomNode constraintsNode = layerNode.namedItem( u"constraints"_s );
2726 if ( !constraintsNode.isNull() )
2727 {
2728 QDomNodeList constraintNodeList = constraintsNode.toElement().elementsByTagName( u"constraint"_s );
2729 for ( int i = 0; i < constraintNodeList.size(); ++i )
2730 {
2731 QDomElement constraintElem = constraintNodeList.at( i ).toElement();
2732
2733 QString field = constraintElem.attribute( u"field"_s, QString() );
2734 int constraints = constraintElem.attribute( u"constraints"_s, u"0"_s ).toInt();
2735 if ( field.isEmpty() || constraints == 0 )
2736 continue;
2737
2738 mFieldConstraints.insert( field, static_cast< QgsFieldConstraints::Constraints >( constraints ) );
2739
2740 int uniqueStrength = constraintElem.attribute( u"unique_strength"_s, u"1"_s ).toInt();
2741 int notNullStrength = constraintElem.attribute( u"notnull_strength"_s, u"1"_s ).toInt();
2742 int expStrength = constraintElem.attribute( u"exp_strength"_s, u"1"_s ).toInt();
2743
2744 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintUnique ), static_cast< QgsFieldConstraints::ConstraintStrength >( uniqueStrength ) );
2745 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintNotNull ), static_cast< QgsFieldConstraints::ConstraintStrength >( notNullStrength ) );
2746 mFieldConstraintStrength.insert( qMakePair( field, QgsFieldConstraints::ConstraintExpression ), static_cast< QgsFieldConstraints::ConstraintStrength >( expStrength ) );
2747 }
2748 }
2749 mFieldConstraintExpressions.clear();
2750 QDomNode constraintExpressionsNode = layerNode.namedItem( u"constraintExpressions"_s );
2751 if ( !constraintExpressionsNode.isNull() )
2752 {
2753 QDomNodeList constraintNodeList = constraintExpressionsNode.toElement().elementsByTagName( u"constraint"_s );
2754 for ( int i = 0; i < constraintNodeList.size(); ++i )
2755 {
2756 QDomElement constraintElem = constraintNodeList.at( i ).toElement();
2757
2758 QString field = constraintElem.attribute( u"field"_s, QString() );
2759 QString exp = constraintElem.attribute( u"exp"_s, QString() );
2760 QString desc
2761 = context.projectTranslator()->translate( u"project:layers:%1:constraintdescriptions"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ), constraintElem.attribute( u"desc"_s, QString() ) );
2762 QgsDebugMsgLevel( "context" + u"project:layers:%1:constraintdescriptions"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text() ) + " source " + constraintElem.attribute( u"desc"_s, QString() ), 3 );
2763 if ( field.isEmpty() || exp.isEmpty() )
2764 continue;
2765
2766 mFieldConstraintExpressions.insert( field, qMakePair( exp, desc ) );
2767 }
2768 }
2769
2770 updateFields();
2771 }
2772
2773 // load field configuration
2774 if ( categories.testFlag( Fields ) || categories.testFlag( Forms ) )
2775 {
2776 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Forms" ) );
2777
2778 QDomElement widgetsElem = layerNode.namedItem( u"fieldConfiguration"_s ).toElement();
2779 QDomNodeList fieldConfigurationElementList = widgetsElem.elementsByTagName( u"field"_s );
2780 for ( int i = 0; i < fieldConfigurationElementList.size(); ++i )
2781 {
2782 const QDomElement fieldConfigElement = fieldConfigurationElementList.at( i ).toElement();
2783 const QDomElement fieldWidgetElement = fieldConfigElement.elementsByTagName( u"editWidget"_s ).at( 0 ).toElement();
2784
2785 QString fieldName = fieldConfigElement.attribute( u"name"_s );
2786
2787 if ( categories.testFlag( Fields ) )
2788 mFieldConfigurationFlags[fieldName] = qgsFlagKeysToValue( fieldConfigElement.attribute( u"configurationFlags"_s ), Qgis::FieldConfigurationFlag::NoFlag );
2789
2790 // load editor widget configuration
2791 if ( categories.testFlag( Forms ) )
2792 {
2793 const QString widgetType = fieldWidgetElement.attribute( u"type"_s );
2794 const QDomElement cfgElem = fieldConfigElement.elementsByTagName( u"config"_s ).at( 0 ).toElement();
2795 const QDomElement optionsElem = cfgElem.childNodes().at( 0 ).toElement();
2796 QVariantMap optionsMap = QgsXmlUtils::readVariant( optionsElem ).toMap();
2797 // translate widget configuration strings
2798 if ( widgetType == "ValueRelation"_L1 )
2799 {
2800 optionsMap[u"Value"_s]
2801 = context.projectTranslator()->translate( u"project:layers:%1:fields:%2:valuerelationvalue"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text(), fieldName ), optionsMap[u"Value"_s].toString() );
2802 optionsMap[u"Description"_s]
2803 = context.projectTranslator()
2804 ->translate( u"project:layers:%1:fields:%2:valuerelationdescription"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text(), fieldName ), optionsMap[u"Description"_s].toString() );
2805 }
2806 if ( widgetType == "ValueMap"_L1 )
2807 {
2808 if ( optionsMap[u"map"_s].canConvert<QList<QVariant>>() )
2809 {
2810 QList<QVariant> translatedValueList;
2811 const QList<QVariant> valueList = optionsMap[u"map"_s].toList();
2812 for ( int i = 0; i < valueList.count(); i++ )
2813 {
2814 QMap<QString, QVariant> translatedValueMap;
2815 QString translatedKey
2816 = context.projectTranslator()
2817 ->translate( u"project:layers:%1:fields:%2:valuemapdescriptions"_s.arg( layerNode.namedItem( u"id"_s ).toElement().text(), fieldName ), valueList[i].toMap().constBegin().key() );
2818 translatedValueMap.insert( translatedKey, valueList[i].toMap().constBegin().value() );
2819 translatedValueList.append( translatedValueMap );
2820 }
2821 optionsMap.insert( u"map"_s, translatedValueList );
2822 }
2823 }
2824 QgsEditorWidgetSetup setup = QgsEditorWidgetSetup( widgetType, optionsMap );
2825 mFieldWidgetSetups[fieldName] = setup;
2826 }
2827 }
2828 }
2829
2830 // Legacy reading for QGIS 3.14 and older projects
2831 // Attributes excluded from WMS and WFS
2832 if ( categories.testFlag( Fields ) )
2833 {
2834 const QList<QPair<QString, Qgis::FieldConfigurationFlag>>
2835 legacyConfig { qMakePair( u"excludeAttributesWMS"_s, Qgis::FieldConfigurationFlag::HideFromWms ), qMakePair( u"excludeAttributesWFS"_s, Qgis::FieldConfigurationFlag::HideFromWfs ) };
2836 for ( const auto &config : legacyConfig )
2837 {
2838 QDomNode excludeNode = layerNode.namedItem( config.first );
2839 if ( !excludeNode.isNull() )
2840 {
2841 QDomNodeList attributeNodeList = excludeNode.toElement().elementsByTagName( u"attribute"_s );
2842 for ( int i = 0; i < attributeNodeList.size(); ++i )
2843 {
2844 QString fieldName = attributeNodeList.at( i ).toElement().text();
2845 if ( !mFieldConfigurationFlags.contains( fieldName ) )
2846 mFieldConfigurationFlags[fieldName] = config.second;
2847 else
2848 mFieldConfigurationFlags[fieldName].setFlag( config.second, true );
2849 }
2850 }
2851 }
2852 }
2853
2854 if ( categories.testFlag( GeometryOptions ) )
2855 mGeometryOptions->readXml( layerNode.namedItem( u"geometryOptions"_s ) );
2856
2857 if ( categories.testFlag( Forms ) )
2858 mEditFormConfig.readXml( layerNode, context );
2859
2860 if ( categories.testFlag( AttributeTable ) )
2861 {
2862 mAttributeTableConfig.readXml( layerNode );
2863 mConditionalStyles->readXml( layerNode, context );
2864 mStoredExpressionManager->readXml( layerNode );
2865 }
2866
2867 if ( categories.testFlag( CustomProperties ) )
2868 readCustomProperties( layerNode, u"variable"_s );
2869
2870 QDomElement mapLayerNode = layerNode.toElement();
2871 if ( categories.testFlag( LayerConfiguration ) && mapLayerNode.attribute( u"readOnly"_s, u"0"_s ).toInt() == 1 )
2872 mReadOnly = true;
2873
2874 updateFields();
2875
2876 if ( categories.testFlag( Legend ) )
2877 {
2878 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Legend" ) );
2879
2880 const QDomElement legendElem = layerNode.firstChildElement( u"legend"_s );
2881 if ( !legendElem.isNull() )
2882 {
2883 std::unique_ptr< QgsMapLayerLegend > legend( QgsMapLayerLegend::defaultVectorLegend( this ) );
2884 legend->readXml( legendElem, context );
2885 setLegend( legend.release() );
2886 mSetLegendFromStyle = true;
2887 }
2888 }
2889
2890 return true;
2891}
2892
2893bool QgsVectorLayer::readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
2894{
2896
2897 bool result = true;
2898 emit readCustomSymbology( node.toElement(), errorMessage );
2899
2900 // we must try to restore a renderer if our geometry type is unknown
2901 // as this allows the renderer to be correctly restored even for layers
2902 // with broken sources
2903 if ( isSpatial() || mWkbType == Qgis::WkbType::Unknown )
2904 {
2905 // defer style changed signal until we've set the renderer, labeling, everything.
2906 // we don't want multiple signals!
2907 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
2908
2909 // try renderer v2 first
2910 if ( categories.testFlag( Symbology ) )
2911 {
2912 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Symbology" ) );
2913
2914 QDomElement rendererElement = node.firstChildElement( RENDERER_TAG_NAME );
2915 if ( !rendererElement.isNull() )
2916 {
2917 std::unique_ptr<QgsFeatureRenderer> r = QgsFeatureRenderer::load( rendererElement, context );
2918 if ( r )
2919 {
2920 setRenderer( r.release() );
2921 }
2922 else
2923 {
2924 result = false;
2925 }
2926 }
2927 // make sure layer has a renderer - if none exists, fallback to a default renderer
2928 if ( isSpatial() && !renderer() )
2929 {
2931 }
2932
2933 if ( mSelectionProperties )
2934 mSelectionProperties->readXml( node.toElement(), context );
2935 }
2936
2937 // read labeling definition
2938 if ( categories.testFlag( Labeling ) )
2939 {
2940 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Labeling" ) );
2941
2942 QDomElement labelingElement = node.firstChildElement( u"labeling"_s );
2943 std::unique_ptr<QgsAbstractVectorLayerLabeling> labeling;
2944 if ( labelingElement.isNull() || ( labelingElement.attribute( u"type"_s ) == "simple"_L1 && labelingElement.firstChildElement( u"settings"_s ).isNull() ) )
2945 {
2946 // make sure we have custom properties for labeling for 2.x projects
2947 // (custom properties should be already loaded when reading the whole layer from XML,
2948 // but when reading style, custom properties are not read)
2949 readCustomProperties( node, u"labeling"_s );
2950
2951 // support for pre-QGIS 3 labeling configurations written in custom properties
2952 labeling = readLabelingFromCustomProperties();
2953 }
2954 else
2955 {
2956 labeling = QgsAbstractVectorLayerLabeling::create( labelingElement, context );
2957 }
2958 setLabeling( labeling.release() );
2959
2960 if ( node.toElement().hasAttribute( u"labelsEnabled"_s ) )
2961 mLabelsEnabled = node.toElement().attribute( u"labelsEnabled"_s ).toInt();
2962 else
2963 mLabelsEnabled = true;
2964 }
2965
2966 if ( categories.testFlag( Symbology ) )
2967 {
2968 // get and set the blend mode if it exists
2969 QDomNode blendModeNode = node.namedItem( u"blendMode"_s );
2970 if ( !blendModeNode.isNull() )
2971 {
2972 QDomElement e = blendModeNode.toElement();
2973 setBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
2974 }
2975
2976 // get and set the feature blend mode if it exists
2977 QDomNode featureBlendModeNode = node.namedItem( u"featureBlendMode"_s );
2978 if ( !featureBlendModeNode.isNull() )
2979 {
2980 QDomElement e = featureBlendModeNode.toElement();
2981 setFeatureBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
2982 }
2983 }
2984
2985 // get and set the layer transparency and scale visibility if they exists
2986 if ( categories.testFlag( Rendering ) )
2987 {
2988 QDomNode layerTransparencyNode = node.namedItem( u"layerTransparency"_s );
2989 if ( !layerTransparencyNode.isNull() )
2990 {
2991 QDomElement e = layerTransparencyNode.toElement();
2992 setOpacity( 1.0 - e.text().toInt() / 100.0 );
2993 }
2994 QDomNode layerOpacityNode = node.namedItem( u"layerOpacity"_s );
2995 if ( !layerOpacityNode.isNull() )
2996 {
2997 QDomElement e = layerOpacityNode.toElement();
2998 setOpacity( e.text().toDouble() );
2999 }
3000
3001 const bool hasScaleBasedVisibiliy { node.attributes().namedItem( u"hasScaleBasedVisibilityFlag"_s ).nodeValue() == '1' };
3002 setScaleBasedVisibility( hasScaleBasedVisibiliy );
3003 bool ok;
3004 const double maxScale { node.attributes().namedItem( u"maxScale"_s ).nodeValue().toDouble( &ok ) };
3005 if ( ok )
3006 {
3007 setMaximumScale( maxScale );
3008 }
3009 const double minScale { node.attributes().namedItem( u"minScale"_s ).nodeValue().toDouble( &ok ) };
3010 if ( ok )
3011 {
3012 setMinimumScale( minScale );
3013 }
3014
3015 QDomElement e = node.toElement();
3016
3017 // get the simplification drawing settings
3018 mSimplifyMethod.setSimplifyHints( static_cast< Qgis::VectorRenderingSimplificationFlags >( e.attribute( u"simplifyDrawingHints"_s, u"1"_s ).toInt() ) );
3019 mSimplifyMethod.setSimplifyAlgorithm( static_cast< Qgis::VectorSimplificationAlgorithm >( e.attribute( u"simplifyAlgorithm"_s, u"0"_s ).toInt() ) );
3020 mSimplifyMethod.setThreshold( e.attribute( u"simplifyDrawingTol"_s, u"1"_s ).toFloat() );
3021 mSimplifyMethod.setForceLocalOptimization( e.attribute( u"simplifyLocal"_s, u"1"_s ).toInt() );
3022 mSimplifyMethod.setMaximumScale( e.attribute( u"simplifyMaxScale"_s, u"1"_s ).toFloat() );
3023
3024 if ( mRenderer )
3025 mRenderer->setReferenceScale( e.attribute( u"symbologyReferenceScale"_s, u"-1"_s ).toDouble() );
3026 }
3027
3028 //diagram renderer and diagram layer settings
3029 if ( categories.testFlag( Diagrams ) )
3030 {
3031 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Diagrams" ) );
3032
3033 mDiagramRenderer.reset();
3034 QDomElement singleCatDiagramElem = node.firstChildElement( u"SingleCategoryDiagramRenderer"_s );
3035 if ( !singleCatDiagramElem.isNull() )
3036 {
3037 mDiagramRenderer = std::make_unique<QgsSingleCategoryDiagramRenderer>();
3038 mDiagramRenderer->readXml( singleCatDiagramElem, context );
3039 }
3040 QDomElement linearDiagramElem = node.firstChildElement( u"LinearlyInterpolatedDiagramRenderer"_s );
3041 if ( !linearDiagramElem.isNull() )
3042 {
3043 if ( linearDiagramElem.hasAttribute( u"classificationAttribute"_s ) )
3044 {
3045 // fix project from before QGIS 3.0
3046 int idx = linearDiagramElem.attribute( u"classificationAttribute"_s ).toInt();
3047 if ( idx >= 0 && idx < mFields.count() )
3048 linearDiagramElem.setAttribute( u"classificationField"_s, mFields.at( idx ).name() );
3049 }
3050
3051 mDiagramRenderer = std::make_unique<QgsLinearlyInterpolatedDiagramRenderer>();
3052 mDiagramRenderer->readXml( linearDiagramElem, context );
3053 }
3054 QDomElement stackedDiagramElem = node.firstChildElement( u"StackedDiagramRenderer"_s );
3055 if ( !stackedDiagramElem.isNull() )
3056 {
3057 mDiagramRenderer = std::make_unique<QgsStackedDiagramRenderer>();
3058 mDiagramRenderer->readXml( stackedDiagramElem, context );
3059 }
3060
3061 if ( mDiagramRenderer )
3062 {
3063 QDomElement diagramSettingsElem = node.firstChildElement( u"DiagramLayerSettings"_s );
3064 if ( !diagramSettingsElem.isNull() )
3065 {
3066 bool oldXPos = diagramSettingsElem.hasAttribute( u"xPosColumn"_s );
3067 bool oldYPos = diagramSettingsElem.hasAttribute( u"yPosColumn"_s );
3068 bool oldShow = diagramSettingsElem.hasAttribute( u"showColumn"_s );
3069 if ( oldXPos || oldYPos || oldShow )
3070 {
3071 // fix project from before QGIS 3.0
3073 if ( oldXPos )
3074 {
3075 int xPosColumn = diagramSettingsElem.attribute( u"xPosColumn"_s ).toInt();
3076 if ( xPosColumn >= 0 && xPosColumn < mFields.count() )
3077 ddp.setProperty( QgsDiagramLayerSettings::Property::PositionX, QgsProperty::fromField( mFields.at( xPosColumn ).name(), true ) );
3078 }
3079 if ( oldYPos )
3080 {
3081 int yPosColumn = diagramSettingsElem.attribute( u"yPosColumn"_s ).toInt();
3082 if ( yPosColumn >= 0 && yPosColumn < mFields.count() )
3083 ddp.setProperty( QgsDiagramLayerSettings::Property::PositionY, QgsProperty::fromField( mFields.at( yPosColumn ).name(), true ) );
3084 }
3085 if ( oldShow )
3086 {
3087 int showColumn = diagramSettingsElem.attribute( u"showColumn"_s ).toInt();
3088 if ( showColumn >= 0 && showColumn < mFields.count() )
3089 ddp.setProperty( QgsDiagramLayerSettings::Property::Show, QgsProperty::fromField( mFields.at( showColumn ).name(), true ) );
3090 }
3091 QDomElement propertiesElem = diagramSettingsElem.ownerDocument().createElement( u"properties"_s );
3093 { static_cast< int >( QgsDiagramLayerSettings::Property::PositionX ), QgsPropertyDefinition( "positionX", QObject::tr( "Position (X)" ), QgsPropertyDefinition::Double ) },
3094 { static_cast< int >( QgsDiagramLayerSettings::Property::PositionY ), QgsPropertyDefinition( "positionY", QObject::tr( "Position (Y)" ), QgsPropertyDefinition::Double ) },
3095 { static_cast< int >( QgsDiagramLayerSettings::Property::Show ), QgsPropertyDefinition( "show", QObject::tr( "Show diagram" ), QgsPropertyDefinition::Boolean ) },
3096 };
3097 ddp.writeXml( propertiesElem, defs );
3098 diagramSettingsElem.appendChild( propertiesElem );
3099 }
3100
3101 mDiagramLayerSettings = std::make_unique<QgsDiagramLayerSettings>();
3102 mDiagramLayerSettings->readXml( diagramSettingsElem );
3103 }
3104 }
3105 }
3106 // end diagram
3107
3108 styleChangedSignalBlocker.release();
3110 }
3111 return result;
3112}
3113
3114
3115bool QgsVectorLayer::writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
3116{
3118
3119 QDomElement layerElement = node.toElement();
3120 writeCommonStyle( layerElement, doc, context, categories );
3121
3122 ( void ) writeStyle( node, doc, errorMessage, context, categories );
3123
3124 if ( categories.testFlag( GeometryOptions ) )
3125 mGeometryOptions->writeXml( node );
3126
3127 if ( categories.testFlag( Legend ) && legend() )
3128 {
3129 QDomElement legendElement = legend()->writeXml( doc, context );
3130 if ( !legendElement.isNull() )
3131 node.appendChild( legendElement );
3132 }
3133
3134 // Relation information for both referenced and referencing sides
3135 if ( categories.testFlag( Relations ) )
3136 {
3137 if ( QgsProject *p = project() )
3138 {
3139 // Store referenced layers: relations where "this" is the child layer (the referencing part, that holds the FK)
3140 QDomElement referencedLayersElement = doc.createElement( u"referencedLayers"_s );
3141 node.appendChild( referencedLayersElement );
3142
3143 const QList<QgsRelation> referencingRelations { p->relationManager()->referencingRelations( this ) };
3144 for ( const QgsRelation &rel : referencingRelations )
3145 {
3146 switch ( rel.type() )
3147 {
3149 QgsWeakRelation::writeXml( this, QgsWeakRelation::Referencing, rel, referencedLayersElement, doc );
3150 break;
3152 break;
3153 }
3154 }
3155
3156 // Store referencing layers: relations where "this" is the parent layer (the referenced part, that holds the FK)
3157 QDomElement referencingLayersElement = doc.createElement( u"referencingLayers"_s );
3158 node.appendChild( referencingLayersElement );
3159
3160 const QList<QgsRelation> referencedRelations { p->relationManager()->referencedRelations( this ) };
3161 for ( const QgsRelation &rel : referencedRelations )
3162 {
3163 switch ( rel.type() )
3164 {
3166 QgsWeakRelation::writeXml( this, QgsWeakRelation::Referenced, rel, referencingLayersElement, doc );
3167 break;
3169 break;
3170 }
3171 }
3172 }
3173 }
3174
3175 // write field configurations
3176 if ( categories.testFlag( Fields ) || categories.testFlag( Forms ) )
3177 {
3178 QDomElement fieldConfigurationElement;
3179 // field configuration flag
3180 fieldConfigurationElement = doc.createElement( u"fieldConfiguration"_s );
3181 node.appendChild( fieldConfigurationElement );
3182
3183 for ( const QgsField &field : std::as_const( mFields ) )
3184 {
3185 QDomElement fieldElement = doc.createElement( u"field"_s );
3186 fieldElement.setAttribute( u"name"_s, field.name() );
3187 fieldConfigurationElement.appendChild( fieldElement );
3188
3189 if ( categories.testFlag( Fields ) )
3190 {
3191 fieldElement.setAttribute( u"configurationFlags"_s, qgsFlagValueToKeys( field.configurationFlags() ) );
3192 }
3193
3194 if ( categories.testFlag( Forms ) )
3195 {
3196 QgsEditorWidgetSetup widgetSetup = field.editorWidgetSetup();
3197
3198 // TODO : wrap this part in an if to only save if it was user-modified
3199 QDomElement editWidgetElement = doc.createElement( u"editWidget"_s );
3200 fieldElement.appendChild( editWidgetElement );
3201 editWidgetElement.setAttribute( u"type"_s, field.editorWidgetSetup().type() );
3202 QDomElement editWidgetConfigElement = doc.createElement( u"config"_s );
3203
3204 editWidgetConfigElement.appendChild( QgsXmlUtils::writeVariant( widgetSetup.config(), doc ) );
3205 editWidgetElement.appendChild( editWidgetConfigElement );
3206 // END TODO : wrap this part in an if to only save if it was user-modified
3207 }
3208 }
3209 }
3210
3211 if ( categories.testFlag( Fields ) )
3212 {
3213 //attribute aliases
3214 QDomElement aliasElem = doc.createElement( u"aliases"_s );
3215 for ( const QgsField &field : std::as_const( mFields ) )
3216 {
3217 QDomElement aliasEntryElem = doc.createElement( u"alias"_s );
3218 aliasEntryElem.setAttribute( u"field"_s, field.name() );
3219 aliasEntryElem.setAttribute( u"index"_s, mFields.indexFromName( field.name() ) );
3220 aliasEntryElem.setAttribute( u"name"_s, field.alias() );
3221 aliasElem.appendChild( aliasEntryElem );
3222 }
3223 node.appendChild( aliasElem );
3224
3225 //custom comments
3226 QDomElement customCommentElem = doc.createElement( u"customComments"_s );
3227 bool hasCustomComments = false;
3228 for ( const QgsField &field : std::as_const( mFields ) )
3229 {
3230 //if empty ("") we store it, if null we don't store it
3231 const QString customComment = field.customComment();
3232 if ( customComment.isNull() )
3233 continue;
3234
3235 hasCustomComments = true;
3236 QDomElement customCommentEntryElem = doc.createElement( u"customComment"_s );
3237 customCommentEntryElem.setAttribute( u"field"_s, field.name() );
3238 customCommentEntryElem.setAttribute( u"value"_s, customComment );
3239 customCommentElem.appendChild( customCommentEntryElem );
3240 }
3241 if ( hasCustomComments )
3242 {
3243 node.appendChild( customCommentElem );
3244 }
3245
3246 //split policies
3247 {
3248 QDomElement splitPoliciesElement = doc.createElement( u"splitPolicies"_s );
3249 bool hasNonDefaultSplitPolicies = false;
3250 for ( const QgsField &field : std::as_const( mFields ) )
3251 {
3252 if ( field.splitPolicy() != Qgis::FieldDomainSplitPolicy::Duplicate )
3253 {
3254 QDomElement splitPolicyElem = doc.createElement( u"policy"_s );
3255 splitPolicyElem.setAttribute( u"field"_s, field.name() );
3256 splitPolicyElem.setAttribute( u"policy"_s, qgsEnumValueToKey( field.splitPolicy() ) );
3257 splitPoliciesElement.appendChild( splitPolicyElem );
3258 hasNonDefaultSplitPolicies = true;
3259 }
3260 }
3261 if ( hasNonDefaultSplitPolicies )
3262 node.appendChild( splitPoliciesElement );
3263 }
3264
3265 //duplicate policies
3266 {
3267 QDomElement duplicatePoliciesElement = doc.createElement( u"duplicatePolicies"_s );
3268 bool hasNonDefaultDuplicatePolicies = false;
3269 for ( const QgsField &field : std::as_const( mFields ) )
3270 {
3271 if ( field.duplicatePolicy() != Qgis::FieldDuplicatePolicy::Duplicate )
3272 {
3273 QDomElement duplicatePolicyElem = doc.createElement( u"policy"_s );
3274 duplicatePolicyElem.setAttribute( u"field"_s, field.name() );
3275 duplicatePolicyElem.setAttribute( u"policy"_s, qgsEnumValueToKey( field.duplicatePolicy() ) );
3276 duplicatePoliciesElement.appendChild( duplicatePolicyElem );
3277 hasNonDefaultDuplicatePolicies = true;
3278 }
3279 }
3280 if ( hasNonDefaultDuplicatePolicies )
3281 node.appendChild( duplicatePoliciesElement );
3282 }
3283
3284 //merge policies
3285 {
3286 QDomElement mergePoliciesElement = doc.createElement( u"mergePolicies"_s );
3287 bool hasNonDefaultMergePolicies = false;
3288 for ( const QgsField &field : std::as_const( mFields ) )
3289 {
3290 if ( field.mergePolicy() != Qgis::FieldDomainMergePolicy::UnsetField )
3291 {
3292 QDomElement mergePolicyElem = doc.createElement( u"policy"_s );
3293 mergePolicyElem.setAttribute( u"field"_s, field.name() );
3294 mergePolicyElem.setAttribute( u"policy"_s, qgsEnumValueToKey( field.mergePolicy() ) );
3295 mergePoliciesElement.appendChild( mergePolicyElem );
3296 hasNonDefaultMergePolicies = true;
3297 }
3298 }
3299 if ( hasNonDefaultMergePolicies )
3300 node.appendChild( mergePoliciesElement );
3301 }
3302
3303 //default expressions
3304 QDomElement defaultsElem = doc.createElement( u"defaults"_s );
3305 for ( const QgsField &field : std::as_const( mFields ) )
3306 {
3307 QDomElement defaultElem = doc.createElement( u"default"_s );
3308 defaultElem.setAttribute( u"field"_s, field.name() );
3309 defaultElem.setAttribute( u"expression"_s, field.defaultValueDefinition().expression() );
3310 defaultElem.setAttribute( u"applyOnUpdate"_s, field.defaultValueDefinition().applyOnUpdate() ? u"1"_s : u"0"_s );
3311 defaultsElem.appendChild( defaultElem );
3312 }
3313 node.appendChild( defaultsElem );
3314
3315 // constraints
3316 QDomElement constraintsElem = doc.createElement( u"constraints"_s );
3317 for ( const QgsField &field : std::as_const( mFields ) )
3318 {
3319 QDomElement constraintElem = doc.createElement( u"constraint"_s );
3320 constraintElem.setAttribute( u"field"_s, field.name() );
3321 constraintElem.setAttribute( u"constraints"_s, field.constraints().constraints() );
3322 constraintElem.setAttribute( u"unique_strength"_s, field.constraints().constraintStrength( QgsFieldConstraints::ConstraintUnique ) );
3323 constraintElem.setAttribute( u"notnull_strength"_s, field.constraints().constraintStrength( QgsFieldConstraints::ConstraintNotNull ) );
3324 constraintElem.setAttribute( u"exp_strength"_s, field.constraints().constraintStrength( QgsFieldConstraints::ConstraintExpression ) );
3325
3326 constraintsElem.appendChild( constraintElem );
3327 }
3328 node.appendChild( constraintsElem );
3329
3330 // constraint expressions
3331 QDomElement constraintExpressionsElem = doc.createElement( u"constraintExpressions"_s );
3332 for ( const QgsField &field : std::as_const( mFields ) )
3333 {
3334 QDomElement constraintExpressionElem = doc.createElement( u"constraint"_s );
3335 constraintExpressionElem.setAttribute( u"field"_s, field.name() );
3336 constraintExpressionElem.setAttribute( u"exp"_s, field.constraints().constraintExpression() );
3337 constraintExpressionElem.setAttribute( u"desc"_s, field.constraints().constraintDescription() );
3338 constraintExpressionsElem.appendChild( constraintExpressionElem );
3339 }
3340 node.appendChild( constraintExpressionsElem );
3341
3342 // save expression fields
3343 if ( !mExpressionFieldBuffer )
3344 {
3345 // can happen when saving style on a invalid layer
3347 dummy.writeXml( node, doc );
3348 }
3349 else
3350 {
3351 mExpressionFieldBuffer->writeXml( node, doc );
3352 }
3353 }
3354
3355 // add attribute actions
3356 if ( categories.testFlag( Actions ) )
3357 mActions->writeXml( node );
3358
3359 if ( categories.testFlag( AttributeTable ) )
3360 {
3361 mAttributeTableConfig.writeXml( node );
3362 mConditionalStyles->writeXml( node, doc, context );
3363 mStoredExpressionManager->writeXml( node );
3364 }
3365
3366 if ( categories.testFlag( Forms ) )
3367 mEditFormConfig.writeXml( node, context );
3368
3369 // save readonly state
3370 if ( categories.testFlag( LayerConfiguration ) )
3371 node.toElement().setAttribute( u"readOnly"_s, mReadOnly );
3372
3373 // save preview expression
3374 if ( categories.testFlag( LayerConfiguration ) )
3375 {
3376 QDomElement prevExpElem = doc.createElement( u"previewExpression"_s );
3377 QDomText prevExpText = doc.createTextNode( mDisplayExpression );
3378 prevExpElem.appendChild( prevExpText );
3379 node.appendChild( prevExpElem );
3380 }
3381
3382 // save map tip
3383 if ( categories.testFlag( MapTips ) )
3384 {
3385 QDomElement mapTipElem = doc.createElement( u"mapTip"_s );
3386 mapTipElem.setAttribute( u"enabled"_s, mapTipsEnabled() );
3387 QDomText mapTipText = doc.createTextNode( mMapTipTemplate );
3388 mapTipElem.appendChild( mapTipText );
3389 node.toElement().appendChild( mapTipElem );
3390 }
3391
3392 return true;
3393}
3394
3395bool QgsVectorLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
3396{
3398
3399 QDomElement mapLayerNode = node.toElement();
3400
3401 emit writeCustomSymbology( mapLayerNode, doc, errorMessage );
3402
3403 // we must try to write the renderer if our geometry type is unknown
3404 // as this allows the renderer to be correctly restored even for layers
3405 // with broken sources
3406 if ( isSpatial() || mWkbType == Qgis::WkbType::Unknown )
3407 {
3408 if ( categories.testFlag( Symbology ) )
3409 {
3410 if ( mRenderer )
3411 {
3412 QDomElement rendererElement = mRenderer->save( doc, context );
3413 node.appendChild( rendererElement );
3414 }
3415 if ( mSelectionProperties )
3416 {
3417 mSelectionProperties->writeXml( mapLayerNode, doc, context );
3418 }
3419 }
3420
3421 if ( categories.testFlag( Labeling ) )
3422 {
3423 if ( mLabeling )
3424 {
3425 QDomElement labelingElement = mLabeling->save( doc, context );
3426 node.appendChild( labelingElement );
3427 }
3428 mapLayerNode.setAttribute( u"labelsEnabled"_s, mLabelsEnabled ? u"1"_s : u"0"_s );
3429 }
3430
3431 // save the simplification drawing settings
3432 if ( categories.testFlag( Rendering ) )
3433 {
3434 mapLayerNode.setAttribute( u"simplifyDrawingHints"_s, QString::number( static_cast< int >( mSimplifyMethod.simplifyHints() ) ) );
3435 mapLayerNode.setAttribute( u"simplifyAlgorithm"_s, QString::number( static_cast< int >( mSimplifyMethod.simplifyAlgorithm() ) ) );
3436 mapLayerNode.setAttribute( u"simplifyDrawingTol"_s, QString::number( mSimplifyMethod.threshold() ) );
3437 mapLayerNode.setAttribute( u"simplifyLocal"_s, mSimplifyMethod.forceLocalOptimization() ? 1 : 0 );
3438 mapLayerNode.setAttribute( u"simplifyMaxScale"_s, QString::number( mSimplifyMethod.maximumScale() ) );
3439 }
3440
3441 //save customproperties
3442 if ( categories.testFlag( CustomProperties ) )
3443 {
3444 writeCustomProperties( node, doc );
3445 }
3446
3447 if ( categories.testFlag( Symbology ) )
3448 {
3449 // add the blend mode field
3450 QDomElement blendModeElem = doc.createElement( u"blendMode"_s );
3451 QDomText blendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( blendMode() ) ) ) );
3452 blendModeElem.appendChild( blendModeText );
3453 node.appendChild( blendModeElem );
3454
3455 // add the feature blend mode field
3456 QDomElement featureBlendModeElem = doc.createElement( u"featureBlendMode"_s );
3457 QDomText featureBlendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( featureBlendMode() ) ) ) );
3458 featureBlendModeElem.appendChild( featureBlendModeText );
3459 node.appendChild( featureBlendModeElem );
3460 }
3461
3462 // add the layer opacity and scale visibility
3463 if ( categories.testFlag( Rendering ) )
3464 {
3465 QDomElement layerOpacityElem = doc.createElement( u"layerOpacity"_s );
3466 QDomText layerOpacityText = doc.createTextNode( QString::number( opacity() ) );
3467 layerOpacityElem.appendChild( layerOpacityText );
3468 node.appendChild( layerOpacityElem );
3469 mapLayerNode.setAttribute( u"hasScaleBasedVisibilityFlag"_s, hasScaleBasedVisibility() ? 1 : 0 );
3470 mapLayerNode.setAttribute( u"maxScale"_s, maximumScale() );
3471 mapLayerNode.setAttribute( u"minScale"_s, minimumScale() );
3472
3473 mapLayerNode.setAttribute( u"symbologyReferenceScale"_s, mRenderer ? mRenderer->referenceScale() : -1 );
3474 }
3475
3476 if ( categories.testFlag( Diagrams ) && mDiagramRenderer )
3477 {
3478 mDiagramRenderer->writeXml( mapLayerNode, doc, context );
3479 if ( mDiagramLayerSettings )
3480 mDiagramLayerSettings->writeXml( mapLayerNode, doc );
3481 }
3482 }
3483 return true;
3484}
3485
3486bool QgsVectorLayer::readSld( const QDomNode &node, QString &errorMessage )
3487{
3489
3490 // get the Name element
3491 QDomElement nameElem = node.firstChildElement( u"Name"_s );
3492 if ( nameElem.isNull() )
3493 {
3494 errorMessage = u"Warning: Name element not found within NamedLayer while it's required."_s;
3495 }
3496
3497 if ( isSpatial() )
3498 {
3499 std::unique_ptr<QgsFeatureRenderer> r = QgsFeatureRenderer::loadSld( node, geometryType(), errorMessage );
3500 if ( !r )
3501 return false;
3502
3503 // defer style changed signal until we've set the renderer, labeling, everything.
3504 // we don't want multiple signals!
3505 ScopedIntIncrementor styleChangedSignalBlocker( &mBlockStyleChangedSignal );
3506
3507 setRenderer( r.release() );
3508
3509 // labeling
3510 readSldLabeling( node );
3511
3512 styleChangedSignalBlocker.release();
3514 }
3515 return true;
3516}
3517
3518bool QgsVectorLayer::writeSld( QDomNode &node, QDomDocument &doc, QString &, const QVariantMap &props ) const
3519{
3521 QgsSldExportContext context;
3522 context.setExtraProperties( props );
3523 writeSld( node, doc, context );
3524 return true;
3525}
3526
3527bool QgsVectorLayer::writeSld( QDomNode &node, QDomDocument &doc, QgsSldExportContext &context ) const
3528{
3530
3531 QVariantMap localProps = context.extraProperties();
3533 {
3535 }
3536 context.setExtraProperties( localProps );
3537
3538 if ( isSpatial() )
3539 {
3540 // store the Name element
3541 QDomElement nameNode = doc.createElement( u"se:Name"_s );
3542 nameNode.appendChild( doc.createTextNode( name() ) );
3543 node.appendChild( nameNode );
3544
3545 QDomElement userStyleElem = doc.createElement( u"UserStyle"_s );
3546 node.appendChild( userStyleElem );
3547
3548 QDomElement nameElem = doc.createElement( u"se:Name"_s );
3549 nameElem.appendChild( doc.createTextNode( name() ) );
3550
3551 userStyleElem.appendChild( nameElem );
3552
3553 QDomElement featureTypeStyleElem = doc.createElement( u"se:FeatureTypeStyle"_s );
3554 userStyleElem.appendChild( featureTypeStyleElem );
3555
3556 mRenderer->toSld( doc, featureTypeStyleElem, context );
3557 if ( labelsEnabled() )
3558 {
3559 mLabeling->toSld( featureTypeStyleElem, context );
3560 }
3561 }
3562 return true;
3563}
3564
3565bool QgsVectorLayer::changeGeometry( QgsFeatureId fid, QgsGeometry &geom, bool skipDefaultValue )
3566{
3568
3569 if ( !mEditBuffer || !mDataProvider )
3570 {
3571 return false;
3572 }
3573
3574 if ( mGeometryOptions->isActive() )
3575 mGeometryOptions->apply( geom );
3576
3577 updateExtents();
3578
3579 bool result = mEditBuffer->changeGeometry( fid, geom );
3580
3581 if ( result )
3582 {
3583 updateExtents();
3584 if ( !skipDefaultValue && !mDefaultValueOnUpdateFields.isEmpty() )
3585 updateDefaultValues( fid );
3586 }
3587 return result;
3588}
3589
3590
3591bool QgsVectorLayer::changeAttributeValue( QgsFeatureId fid, int field, const QVariant &newValue, const QVariant &oldValue, bool skipDefaultValues, QgsVectorLayerToolsContext *context )
3592{
3594
3595 bool result = false;
3596
3597 switch ( fields().fieldOrigin( field ) )
3598 {
3600 result = mJoinBuffer->changeAttributeValue( fid, field, newValue, oldValue );
3601 if ( result )
3602 emit attributeValueChanged( fid, field, newValue );
3603 break;
3604
3608 {
3609 if ( mEditBuffer && mDataProvider )
3610 result = mEditBuffer->changeAttributeValue( fid, field, newValue, oldValue );
3611 break;
3612 }
3613
3615 break;
3616 }
3617
3618 if ( result && !skipDefaultValues && !mDefaultValueOnUpdateFields.isEmpty() )
3619 updateDefaultValues( fid, QgsFeature(), context ? context->expressionContext() : nullptr );
3620
3621 return result;
3622}
3623
3624bool QgsVectorLayer::changeAttributeValues( QgsFeatureId fid, const QgsAttributeMap &newValues, const QgsAttributeMap &oldValues, bool skipDefaultValues, QgsVectorLayerToolsContext *context )
3625{
3627
3628 bool result = true;
3629
3630 QgsAttributeMap newValuesJoin;
3631 QgsAttributeMap oldValuesJoin;
3632
3633 QgsAttributeMap newValuesNotJoin;
3634 QgsAttributeMap oldValuesNotJoin;
3635
3636 for ( auto it = newValues.constBegin(); it != newValues.constEnd(); ++it )
3637 {
3638 const int field = it.key();
3639 const QVariant newValue = it.value();
3640 QVariant oldValue;
3641
3642 if ( oldValues.contains( field ) )
3643 oldValue = oldValues[field];
3644
3645 switch ( fields().fieldOrigin( field ) )
3646 {
3648 newValuesJoin[field] = newValue;
3649 oldValuesJoin[field] = oldValue;
3650 break;
3651
3655 {
3656 newValuesNotJoin[field] = newValue;
3657 oldValuesNotJoin[field] = oldValue;
3658 break;
3659 }
3660
3662 break;
3663 }
3664 }
3665
3666 if ( !newValuesJoin.isEmpty() && mJoinBuffer )
3667 {
3668 result = mJoinBuffer->changeAttributeValues( fid, newValuesJoin, oldValuesJoin );
3669 }
3670
3671 if ( !newValuesNotJoin.isEmpty() )
3672 {
3673 if ( mEditBuffer && mDataProvider )
3674 result &= mEditBuffer->changeAttributeValues( fid, newValuesNotJoin, oldValues );
3675 else
3676 result = false;
3677 }
3678
3679 if ( result && !skipDefaultValues && !mDefaultValueOnUpdateFields.isEmpty() )
3680 {
3681 updateDefaultValues( fid, QgsFeature(), context ? context->expressionContext() : nullptr );
3682 }
3683
3684 return result;
3685}
3686
3688{
3690
3691 if ( !mEditBuffer || !mDataProvider )
3692 return false;
3693
3694 return mEditBuffer->addAttribute( field );
3695}
3696
3698{
3700
3701 if ( attIndex < 0 || attIndex >= fields().count() )
3702 return;
3703
3704 QString name = fields().at( attIndex ).name();
3705 mFields[attIndex].setAlias( QString() );
3706 if ( mAttributeAliasMap.contains( name ) )
3707 {
3708 mAttributeAliasMap.remove( name );
3709 updateFields();
3710 mEditFormConfig.setFields( mFields );
3711 emit layerModified();
3712 }
3713}
3714
3715bool QgsVectorLayer::renameAttribute( int index, const QString &newName )
3716{
3718
3719 if ( index < 0 || index >= fields().count() )
3720 return false;
3721
3722 switch ( mFields.fieldOrigin( index ) )
3723 {
3725 {
3726 if ( mExpressionFieldBuffer )
3727 {
3728 int oi = mFields.fieldOriginIndex( index );
3729 mExpressionFieldBuffer->renameExpression( oi, newName );
3730 updateFields();
3731 return true;
3732 }
3733 else
3734 {
3735 return false;
3736 }
3737 }
3738
3741
3742 if ( !mEditBuffer || !mDataProvider )
3743 return false;
3744
3745 return mEditBuffer->renameAttribute( index, newName );
3746
3749 return false;
3750 }
3751
3752 return false; // avoid warning
3753}
3754
3755void QgsVectorLayer::setFieldAlias( int attIndex, const QString &aliasString )
3756{
3758
3759 if ( attIndex < 0 || attIndex >= fields().count() )
3760 return;
3761
3762 QString name = fields().at( attIndex ).name();
3763
3764 mAttributeAliasMap.insert( name, aliasString );
3765 mFields[attIndex].setAlias( aliasString );
3766 mEditFormConfig.setFields( mFields );
3767 emit layerModified(); // TODO[MD]: should have a different signal?
3768}
3769
3770QString QgsVectorLayer::attributeAlias( int index ) const
3771{
3773
3774 if ( index < 0 || index >= fields().count() )
3775 return QString();
3776
3777 return fields().at( index ).alias();
3778}
3779
3780void QgsVectorLayer::setFieldCustomComment( int attIndex, const QString &customCommentString )
3781{
3783
3784 if ( attIndex < 0 || attIndex >= fields().count() )
3785 return;
3786
3787 QString name = fields().at( attIndex ).name();
3788
3789 mAttributeCustomCommentMap.insert( name, customCommentString );
3790 mFields[attIndex].setCustomComment( customCommentString );
3791 mEditFormConfig.setFields( mFields );
3792 emit layerModified();
3793}
3794
3796{
3798
3799 if ( attIndex < 0 || attIndex >= fields().count() )
3800 return;
3801
3802 QString name = fields().at( attIndex ).name();
3803 mFields[attIndex].setCustomComment( QString() );
3804 if ( mAttributeCustomCommentMap.contains( name ) )
3805 {
3806 mAttributeCustomCommentMap.remove( name );
3807 updateFields();
3808 mEditFormConfig.setFields( mFields );
3809 emit layerModified();
3810 }
3811}
3812
3814{
3816
3817 if ( index < 0 || index >= fields().count() )
3818 return QString();
3819
3820 return fields().at( index ).customComment();
3821}
3822
3824{
3826
3827 return mAttributeCustomCommentMap;
3828}
3829
3831{
3833
3834 if ( index >= 0 && index < mFields.count() )
3835 return mFields.at( index ).displayName();
3836 else
3837 return QString();
3838}
3839
3841{
3843
3844 return mAttributeAliasMap;
3845}
3846
3848{
3850
3851 if ( index < 0 || index >= fields().count() )
3852 return;
3853
3854 const QString name = fields().at( index ).name();
3855
3856 mAttributeSplitPolicy.insert( name, policy );
3857 mFields[index].setSplitPolicy( policy );
3858 mEditFormConfig.setFields( mFields );
3859 emit layerModified(); // TODO[MD]: should have a different signal?
3860}
3861
3863{
3865
3866 if ( index < 0 || index >= fields().count() )
3867 return;
3868
3869 const QString name = fields().at( index ).name();
3870
3871 mAttributeDuplicatePolicy.insert( name, policy );
3872 mFields[index].setDuplicatePolicy( policy );
3873 mEditFormConfig.setFields( mFields );
3874 emit layerModified(); // TODO[MD]: should have a different signal?
3875}
3876
3878{
3880
3881 if ( index < 0 || index >= fields().count() )
3882 return;
3883
3884 const QString name = fields().at( index ).name();
3885
3886 mAttributeMergePolicy.insert( name, policy );
3887 mFields[index].setMergePolicy( policy );
3888 mEditFormConfig.setFields( mFields );
3889 emit layerModified(); // TODO[MD]: should have a different signal?
3890}
3891
3893{
3895
3896 QSet<QString> excludeList;
3897 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
3898 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
3899 {
3900 if ( flagsIt->testFlag( Qgis::FieldConfigurationFlag::HideFromWms ) )
3901 {
3902 excludeList << flagsIt.key();
3903 }
3904 }
3905 return excludeList;
3906}
3907
3908void QgsVectorLayer::setExcludeAttributesWms( const QSet<QString> &att )
3909{
3911
3912 QMap< QString, Qgis::FieldConfigurationFlags >::iterator flagsIt = mFieldConfigurationFlags.begin();
3913 for ( ; flagsIt != mFieldConfigurationFlags.end(); ++flagsIt )
3914 {
3915 flagsIt->setFlag( Qgis::FieldConfigurationFlag::HideFromWms, att.contains( flagsIt.key() ) );
3916 }
3917 updateFields();
3918}
3919
3921{
3923
3924 QSet<QString> excludeList;
3925 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
3926 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
3927 {
3928 if ( flagsIt->testFlag( Qgis::FieldConfigurationFlag::HideFromWfs ) )
3929 {
3930 excludeList << flagsIt.key();
3931 }
3932 }
3933 return excludeList;
3934}
3935
3936void QgsVectorLayer::setExcludeAttributesWfs( const QSet<QString> &att )
3937{
3939
3940 QMap< QString, Qgis::FieldConfigurationFlags >::iterator flagsIt = mFieldConfigurationFlags.begin();
3941 for ( ; flagsIt != mFieldConfigurationFlags.end(); ++flagsIt )
3942 {
3943 flagsIt->setFlag( Qgis::FieldConfigurationFlag::HideFromWfs, att.contains( flagsIt.key() ) );
3944 }
3945 updateFields();
3946}
3947
3949{
3951
3952 if ( index < 0 || index >= fields().count() )
3953 return false;
3954
3955 if ( mFields.fieldOrigin( index ) == Qgis::FieldOrigin::Expression )
3956 {
3957 removeExpressionField( index );
3958 return true;
3959 }
3960
3961 if ( !mEditBuffer || !mDataProvider )
3962 return false;
3963
3964 return mEditBuffer->deleteAttribute( index );
3965}
3966
3967bool QgsVectorLayer::deleteAttributes( const QList<int> &attrs )
3968{
3970
3971 bool deleted = false;
3972
3973 // Remove multiple occurrences of same attribute
3974 QList<int> attrList = qgis::setToList( qgis::listToSet( attrs ) );
3975
3976 std::sort( attrList.begin(), attrList.end(), std::greater<int>() );
3977
3978 for ( int attr : std::as_const( attrList ) )
3979 {
3980 if ( deleteAttribute( attr ) )
3981 {
3982 deleted = true;
3983 }
3984 }
3985
3986 return deleted;
3987}
3988
3989bool QgsVectorLayer::deleteFeatureCascade( QgsFeatureId fid, QgsVectorLayer::DeleteContext *context )
3990{
3992
3993 if ( !mEditBuffer )
3994 return false;
3995
3996 if ( context && context->cascade )
3997 {
3998 const QList<QgsRelation> relations = context->project->relationManager()->referencedRelations( this );
3999 const bool hasRelationsOrJoins = !relations.empty() || mJoinBuffer->containsJoins();
4000 if ( hasRelationsOrJoins )
4001 {
4002 if ( context->mHandledFeatures.contains( this ) )
4003 {
4004 QgsFeatureIds &handledFeatureIds = context->mHandledFeatures[this];
4005 if ( handledFeatureIds.contains( fid ) )
4006 {
4007 // avoid endless recursion
4008 return false;
4009 }
4010 else
4011 {
4012 // add feature id
4013 handledFeatureIds << fid;
4014 }
4015 }
4016 else
4017 {
4018 // add layer and feature id
4019 context->mHandledFeatures.insert( this, QgsFeatureIds() << fid );
4020 }
4021
4022 for ( const QgsRelation &relation : relations )
4023 {
4024 //check if composition (and not association)
4025 switch ( relation.strength() )
4026 {
4028 {
4029 //get features connected over this relation
4030 QgsFeatureIterator relatedFeaturesIt = relation.getRelatedFeatures( getFeature( fid ) );
4031 QgsFeatureIds childFeatureIds;
4032 QgsFeature childFeature;
4033 while ( relatedFeaturesIt.nextFeature( childFeature ) )
4034 {
4035 childFeatureIds.insert( childFeature.id() );
4036 }
4037 if ( childFeatureIds.count() > 0 )
4038 {
4039 relation.referencingLayer()->startEditing();
4040 relation.referencingLayer()->deleteFeatures( childFeatureIds, context );
4041 }
4042 break;
4043 }
4044
4046 break;
4047 }
4048 }
4049 }
4050 }
4051
4052 if ( mJoinBuffer->containsJoins() )
4053 mJoinBuffer->deleteFeature( fid, context );
4054
4055 bool res = mEditBuffer->deleteFeature( fid );
4056
4057 return res;
4058}
4059
4061{
4063
4064 if ( !mEditBuffer )
4065 return false;
4066
4067 return deleteFeatureCascade( fid, context );
4068}
4069
4071{
4073
4074 bool res = true;
4075
4076 if ( ( context && context->cascade ) || mJoinBuffer->containsJoins() )
4077 {
4078 // should ideally be "deleteFeaturesCascade" for performance!
4079 for ( QgsFeatureId fid : fids )
4080 res = deleteFeatureCascade( fid, context ) && res;
4081 }
4082 else
4083 {
4084 res = mEditBuffer && mEditBuffer->deleteFeatures( fids );
4085 }
4086
4087 if ( res )
4088 {
4089 mSelectedFeatureIds.subtract( fids ); // remove it from selection
4090 updateExtents();
4091 }
4092
4093 return res;
4094}
4095
4097{
4098 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4100
4101 return mFields;
4102}
4103
4105{
4107
4108 QgsAttributeList pkAttributesList;
4109 if ( !mDataProvider )
4110 return pkAttributesList;
4111
4112 QgsAttributeList providerIndexes = mDataProvider->pkAttributeIndexes();
4113 for ( int i = 0; i < mFields.count(); ++i )
4114 {
4115 if ( mFields.fieldOrigin( i ) == Qgis::FieldOrigin::Provider && providerIndexes.contains( mFields.fieldOriginIndex( i ) ) )
4116 pkAttributesList << i;
4117 }
4118
4119 return pkAttributesList;
4120}
4121
4123{
4125
4126 if ( !mDataProvider )
4127 return static_cast< long long >( Qgis::FeatureCountState::UnknownCount );
4128 return mDataProvider->featureCount() + ( mEditBuffer && !mDataProvider->transaction() ? mEditBuffer->addedFeatures().size() - mEditBuffer->deletedFeatureIds().size() : 0 );
4129}
4130
4132{
4134
4135 const QgsFeatureIds deletedFeatures( mEditBuffer && !mDataProvider->transaction() ? mEditBuffer->deletedFeatureIds() : QgsFeatureIds() );
4136 const QgsFeatureMap addedFeatures( mEditBuffer && !mDataProvider->transaction() ? mEditBuffer->addedFeatures() : QgsFeatureMap() );
4137
4138 if ( mEditBuffer && !deletedFeatures.empty() )
4139 {
4140 if ( addedFeatures.size() > deletedFeatures.size() )
4142 else
4144 }
4145
4146 if ( ( !mEditBuffer || addedFeatures.empty() ) && mDataProvider && mDataProvider->empty() )
4148 else
4150}
4151
4152bool QgsVectorLayer::commitChanges( bool stopEditing )
4153{
4155
4156 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
4157 return project()->commitChanges( mCommitErrors, stopEditing, this );
4158
4159 mCommitErrors.clear();
4160
4161 if ( !mDataProvider )
4162 {
4163 mCommitErrors << tr( "ERROR: no provider" );
4164 return false;
4165 }
4166
4167 if ( !mEditBuffer )
4168 {
4169 mCommitErrors << tr( "ERROR: layer not editable" );
4170 return false;
4171 }
4172
4173 if ( project() && project()->transactionMode() == Qgis::TransactionMode::AutomaticGroups )
4174 {
4175 QSet<QgsVectorLayer *> otherTransactionLayers;
4176 otherTransactionLayers = transactionLayers();
4177
4178 emit beforeCommitChanges( stopEditing );
4179
4180 if ( !otherTransactionLayers.isEmpty() )
4181 {
4182 // if it's in a transaction group we cannot continue, when one layer does not allow commits (yet)
4183 for ( const QgsVectorLayer *layer : otherTransactionLayers )
4184 {
4185 if ( !layer->allowCommit() )
4186 return false;
4187 }
4188 }
4189 }
4190 else
4191 {
4192 // trigger the checks (on transaction groups they are triggered in the specific functions via beforeCommitChanges)
4193 emit beforeCommitChecks( stopEditing );
4194 // as well as the beforeCommitChanges (for individual provider implementations e.g. grassprovider)
4195 emit beforeCommitChanges( stopEditing );
4196 if ( !mAllowCommit )
4197 return false;
4198 }
4199
4200 mCommitChangesActive = true;
4201
4202 bool success = mEditBuffer->commitChanges( mCommitErrors );
4203
4204 mCommitChangesActive = false;
4205
4206 if ( !mDeletedFids.empty() )
4207 {
4208 emit featuresDeleted( mDeletedFids );
4209 mDeletedFids.clear();
4210 }
4211
4212 if ( success )
4213 {
4214 if ( stopEditing )
4215 {
4216 clearEditBuffer();
4217 }
4218 undoStack()->clear();
4219 emit afterCommitChanges();
4220 if ( stopEditing )
4221 emit editingStopped();
4222 }
4223 else
4224 {
4225 QgsMessageLog::logMessage( tr( "Commit errors:\n %1" ).arg( mCommitErrors.join( "\n "_L1 ) ) );
4226 }
4227
4228 updateFields();
4229
4230 mDataProvider->updateExtents();
4231
4232 if ( stopEditing )
4233 {
4234 mDataProvider->leaveUpdateMode();
4235 }
4236
4237 // This second call is required because OGR provider with JSON
4238 // driver might have changed fields order after the call to
4239 // leaveUpdateMode
4240 if ( mFields.names() != mDataProvider->fields().names() )
4241 {
4242 updateFields();
4243 }
4244
4246
4247 return success;
4248}
4249
4251{
4253
4254 return mCommitErrors;
4255}
4256
4257bool QgsVectorLayer::rollBack( bool deleteBuffer )
4258{
4260
4261 if ( project() && project()->transactionMode() == Qgis::TransactionMode::BufferedGroups )
4262 return project()->rollBack( mCommitErrors, deleteBuffer, this );
4263
4264 if ( !mEditBuffer )
4265 {
4266 return false;
4267 }
4268
4269 if ( !mDataProvider )
4270 {
4271 mCommitErrors << tr( "ERROR: no provider" );
4272 return false;
4273 }
4274
4275 bool rollbackExtent = !mDataProvider->transaction() && ( !mEditBuffer->deletedFeatureIds().isEmpty() || !mEditBuffer->addedFeatures().isEmpty() || !mEditBuffer->changedGeometries().isEmpty() );
4276
4277 emit beforeRollBack();
4278
4279 mEditBuffer->rollBack();
4280
4281 emit afterRollBack();
4282
4283 if ( isModified() )
4284 {
4285 // new undo stack roll back method
4286 // old method of calling every undo could cause many canvas refreshes
4287 undoStack()->setIndex( 0 );
4288 }
4289
4290 updateFields();
4291
4292 if ( deleteBuffer )
4293 {
4294 delete mEditBuffer;
4295 mEditBuffer = nullptr;
4296 undoStack()->clear();
4297 }
4298 emit editingStopped();
4299
4300 if ( rollbackExtent )
4301 updateExtents();
4302
4303 mDataProvider->leaveUpdateMode();
4304
4306 return true;
4307}
4308
4310{
4312
4313 return mSelectedFeatureIds.size();
4314}
4315
4317{
4318 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4320
4321 return mSelectedFeatureIds;
4322}
4323
4325{
4327
4328 QgsFeatureList features;
4329 features.reserve( mSelectedFeatureIds.count() );
4330 QgsFeature f;
4331
4333
4334 while ( it.nextFeature( f ) )
4335 {
4336 features.push_back( f );
4337 }
4338
4339 return features;
4340}
4341
4343{
4345
4346 if ( mSelectedFeatureIds.isEmpty() )
4347 return QgsFeatureIterator();
4348
4351
4352 if ( mSelectedFeatureIds.count() == 1 )
4353 request.setFilterFid( *mSelectedFeatureIds.constBegin() );
4354 else
4355 request.setFilterFids( mSelectedFeatureIds );
4356
4357 return getFeatures( request );
4358}
4359
4361{
4363
4364 if ( !mEditBuffer || !mDataProvider )
4365 return false;
4366
4367 if ( mGeometryOptions->isActive() )
4368 {
4369 for ( auto feature = features.begin(); feature != features.end(); ++feature )
4370 {
4371 QgsGeometry geom = feature->geometry();
4372 mGeometryOptions->apply( geom );
4373 feature->setGeometry( geom );
4374 }
4375 }
4376
4377 bool res = mEditBuffer->addFeatures( features );
4378 updateExtents();
4379
4380 if ( res && mJoinBuffer->containsJoins() )
4381 res = mJoinBuffer->addFeatures( features );
4382
4383 return res;
4384}
4385
4387{
4389
4390 // if layer is not spatial, it has not CRS!
4391 setCrs( ( isSpatial() && mDataProvider ) ? mDataProvider->crs() : QgsCoordinateReferenceSystem() );
4392}
4393
4395{
4397
4399 if ( exp.isField() )
4400 {
4401 return static_cast<const QgsExpressionNodeColumnRef *>( exp.rootNode() )->name();
4402 }
4403
4404 return QString();
4405}
4406
4408{
4410
4411 if ( mDisplayExpression == displayExpression )
4412 return;
4413
4414 mDisplayExpression = displayExpression;
4416}
4417
4419{
4421
4422 if ( !mDisplayExpression.isEmpty() || mFields.isEmpty() )
4423 {
4424 return mDisplayExpression;
4425 }
4426 else
4427 {
4428 const QString candidateName = QgsVectorLayerUtils::guessFriendlyIdentifierField( mFields );
4429 if ( !candidateName.isEmpty() )
4430 {
4431 return QgsExpression::quotedColumnRef( candidateName );
4432 }
4433 else
4434 {
4435 return QString();
4436 }
4437 }
4438}
4439
4441{
4443
4444 // display expressions are used as a fallback when no explicit map tip template is set
4445 return mapTipsEnabled() && ( !mapTipTemplate().isEmpty() || !displayExpression().isEmpty() );
4446}
4447
4449{
4451
4452 return ( mEditBuffer && mDataProvider );
4453}
4454
4456{
4457 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4459
4462}
4463
4464bool QgsVectorLayer::isReadOnly() const
4465{
4467
4468 return mDataSourceReadOnly || mReadOnly;
4469}
4470
4471bool QgsVectorLayer::setReadOnly( bool readonly )
4472{
4474
4475 // exit if the layer is in editing mode
4476 if ( readonly && mEditBuffer )
4477 return false;
4478
4479 // exit if the data source is in read-only mode
4480 if ( !readonly && mDataSourceReadOnly )
4481 return false;
4482
4483 mReadOnly = readonly;
4484 emit readOnlyChanged();
4485 return true;
4486}
4487
4489{
4491
4492 if ( !mDataProvider )
4493 return false;
4494
4495 if ( mDataSourceReadOnly )
4496 return false;
4497
4498 return mDataProvider->capabilities() & QgsVectorDataProvider::EditingCapabilities && !mReadOnly;
4499}
4500
4502{
4504
4505 emit beforeModifiedCheck();
4506 return mEditBuffer && mEditBuffer->isModified();
4507}
4508
4509bool QgsVectorLayer::isAuxiliaryField( int index, int &srcIndex ) const
4510{
4512
4513 bool auxiliaryField = false;
4514 srcIndex = -1;
4515
4516 if ( !auxiliaryLayer() )
4517 return auxiliaryField;
4518
4519 if ( index >= 0 && fields().fieldOrigin( index ) == Qgis::FieldOrigin::Join )
4520 {
4521 const QgsVectorLayerJoinInfo *info = mJoinBuffer->joinForFieldIndex( index, fields(), srcIndex );
4522
4523 if ( info && info->joinLayerId() == auxiliaryLayer()->id() )
4524 auxiliaryField = true;
4525 }
4526
4527 return auxiliaryField;
4528}
4529
4531{
4533
4534 // we must allow setting a renderer if our geometry type is unknown
4535 // as this allows the renderer to be correctly set even for layers
4536 // with broken sources
4537 // (note that we allow REMOVING the renderer for non-spatial layers,
4538 // e.g. to permit removing the renderer when the layer changes from
4539 // a spatial layer to a non-spatial one)
4540 if ( r && !isSpatial() && mWkbType != Qgis::WkbType::Unknown )
4541 return;
4542
4543 if ( r != mRenderer.get() )
4544 {
4545 mRenderer.reset( r );
4546 mSymbolFeatureCounted = false;
4547 mSymbolFeatureCountMap.clear();
4548 mSymbolFeatureIdMap.clear();
4549
4550 if ( mRenderer )
4551 {
4552 const double refreshRate = QgsSymbolLayerUtils::rendererFrameRate( mRenderer.get() );
4553 if ( refreshRate <= 0 )
4554 {
4555 mRefreshRendererTimer->stop();
4556 mRefreshRendererTimer->setInterval( 0 );
4557 }
4558 else
4559 {
4560 mRefreshRendererTimer->setInterval( 1000 / refreshRate );
4561 mRefreshRendererTimer->start();
4562 }
4563 }
4564
4565 emit rendererChanged();
4567 }
4568}
4569
4571{
4573
4574 if ( generator )
4575 {
4576 mRendererGenerators << generator;
4577 }
4578}
4579
4581{
4583
4584 for ( int i = mRendererGenerators.count() - 1; i >= 0; --i )
4585 {
4586 if ( mRendererGenerators.at( i )->id() == id )
4587 {
4588 delete mRendererGenerators.at( i );
4589 mRendererGenerators.removeAt( i );
4590 }
4591 }
4592}
4593
4594QList<const QgsFeatureRendererGenerator *> QgsVectorLayer::featureRendererGenerators() const
4595{
4596 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
4598
4599 QList< const QgsFeatureRendererGenerator * > res;
4600 for ( const QgsFeatureRendererGenerator *generator : mRendererGenerators )
4601 res << generator;
4602 return res;
4603}
4604
4605void QgsVectorLayer::beginEditCommand( const QString &text )
4606{
4608
4609 if ( !mDataProvider )
4610 {
4611 return;
4612 }
4613 if ( mDataProvider->transaction() )
4614 {
4615 QString ignoredError;
4616 mDataProvider->transaction()->createSavepoint( ignoredError );
4617 }
4618 undoStack()->beginMacro( text );
4619 mEditCommandActive = true;
4620 emit editCommandStarted( text );
4621}
4622
4624{
4626
4627 if ( !mDataProvider )
4628 {
4629 return;
4630 }
4631 undoStack()->endMacro();
4632 mEditCommandActive = false;
4633 if ( !mDeletedFids.isEmpty() )
4634 {
4635 if ( selectedFeatureCount() > 0 )
4636 {
4637 mSelectedFeatureIds.subtract( mDeletedFids );
4638 }
4639 emit featuresDeleted( mDeletedFids );
4640 mDeletedFids.clear();
4641 }
4642 emit editCommandEnded();
4643}
4644
4646{
4648
4649 if ( !mDataProvider )
4650 {
4651 return;
4652 }
4653 undoStack()->endMacro();
4654 undoStack()->undo();
4655
4656 // it's not directly possible to pop the last command off the stack (the destroyed one)
4657 // and delete, so we add a dummy obsolete command to force this to occur.
4658 // Pushing the new command deletes the destroyed one, and since the new
4659 // command is obsolete it's automatically deleted by the undo stack.
4660 auto command = std::make_unique< QUndoCommand >();
4661 command->setObsolete( true );
4662 undoStack()->push( command.release() );
4663
4664 mEditCommandActive = false;
4665 mDeletedFids.clear();
4666 emit editCommandDestroyed();
4667}
4668
4670{
4672
4673 return mJoinBuffer->addJoin( joinInfo );
4674}
4675
4676bool QgsVectorLayer::removeJoin( const QString &joinLayerId )
4677{
4679
4680 return mJoinBuffer->removeJoin( joinLayerId );
4681}
4682
4683const QList< QgsVectorLayerJoinInfo > QgsVectorLayer::vectorJoins() const
4684{
4686
4687 return mJoinBuffer->vectorJoins();
4688}
4689
4690int QgsVectorLayer::addExpressionField( const QString &exp, const QgsField &fld )
4691{
4693
4694 emit beforeAddingExpressionField( fld.name() );
4695 mExpressionFieldBuffer->addExpression( exp, fld );
4696 updateFields();
4697 int idx = mFields.indexFromName( fld.name() );
4698 emit attributeAdded( idx );
4699 return idx;
4700}
4701
4703{
4705
4706 if ( mFields.fieldOrigin( index ) != Qgis::FieldOrigin::Expression )
4707 return;
4708
4709 emit beforeRemovingExpressionField( index );
4710 int oi = mFields.fieldOriginIndex( index );
4711 mExpressionFieldBuffer->removeExpression( oi );
4712 updateFields();
4713 emit attributeDeleted( index );
4714}
4715
4716QString QgsVectorLayer::expressionField( int index ) const
4717{
4719
4720 if ( mFields.fieldOrigin( index ) != Qgis::FieldOrigin::Expression )
4721 return QString();
4722
4723 int oi = mFields.fieldOriginIndex( index );
4724 if ( oi < 0 || oi >= mExpressionFieldBuffer->expressions().size() )
4725 return QString();
4726
4727 return mExpressionFieldBuffer->expressions().at( oi ).cachedExpression.expression();
4728}
4729
4730void QgsVectorLayer::updateExpressionField( int index, const QString &exp )
4731{
4733
4734 if ( mFields.fieldOrigin( index ) != Qgis::FieldOrigin::Expression )
4735 return;
4736
4737 int oi = mFields.fieldOriginIndex( index );
4738 mExpressionFieldBuffer->updateExpression( oi, exp );
4739}
4740
4742{
4743 // non fatal for now -- the QgsVirtualLayerTask class is not thread safe and calls this
4745
4746 if ( !mDataProvider )
4747 return;
4748
4749 QgsFields oldFields = mFields;
4750
4751 mFields = mDataProvider->fields();
4752
4753 // added / removed fields
4754 if ( mEditBuffer )
4755 mEditBuffer->updateFields( mFields );
4756
4757 // joined fields
4758 if ( mJoinBuffer->containsJoins() )
4759 mJoinBuffer->updateFields( mFields );
4760
4761 if ( mExpressionFieldBuffer )
4762 mExpressionFieldBuffer->updateFields( mFields );
4763
4764 // set aliases and default values
4765 for ( auto aliasIt = mAttributeAliasMap.constBegin(); aliasIt != mAttributeAliasMap.constEnd(); ++aliasIt )
4766 {
4767 int index = mFields.lookupField( aliasIt.key() );
4768 if ( index < 0 )
4769 continue;
4770
4771 mFields[index].setAlias( aliasIt.value() );
4772 }
4773
4774 // set custom comments
4775 for ( auto customCommentIt = mAttributeCustomCommentMap.constBegin(); customCommentIt != mAttributeCustomCommentMap.constEnd(); ++customCommentIt )
4776 {
4777 int index = mFields.lookupField( customCommentIt.key() );
4778 if ( index < 0 )
4779 continue;
4780
4781 mFields[index].setCustomComment( customCommentIt.value() );
4782 }
4783
4784 for ( auto splitPolicyIt = mAttributeSplitPolicy.constBegin(); splitPolicyIt != mAttributeSplitPolicy.constEnd(); ++splitPolicyIt )
4785 {
4786 int index = mFields.lookupField( splitPolicyIt.key() );
4787 if ( index < 0 )
4788 continue;
4789
4790 mFields[index].setSplitPolicy( splitPolicyIt.value() );
4791 }
4792
4793 for ( auto duplicatePolicyIt = mAttributeDuplicatePolicy.constBegin(); duplicatePolicyIt != mAttributeDuplicatePolicy.constEnd(); ++duplicatePolicyIt )
4794 {
4795 int index = mFields.lookupField( duplicatePolicyIt.key() );
4796 if ( index < 0 )
4797 continue;
4798
4799 mFields[index].setDuplicatePolicy( duplicatePolicyIt.value() );
4800 }
4801
4802 for ( auto mergePolicyIt = mAttributeMergePolicy.constBegin(); mergePolicyIt != mAttributeMergePolicy.constEnd(); ++mergePolicyIt )
4803 {
4804 int index = mFields.lookupField( mergePolicyIt.key() );
4805 if ( index < 0 )
4806 continue;
4807
4808 mFields[index].setMergePolicy( mergePolicyIt.value() );
4809 }
4810
4811 // Update configuration flags
4812 QMap< QString, Qgis::FieldConfigurationFlags >::const_iterator flagsIt = mFieldConfigurationFlags.constBegin();
4813 for ( ; flagsIt != mFieldConfigurationFlags.constEnd(); ++flagsIt )
4814 {
4815 int index = mFields.lookupField( flagsIt.key() );
4816 if ( index < 0 )
4817 continue;
4818
4819 mFields[index].setConfigurationFlags( flagsIt.value() );
4820 }
4821
4822 // Update default values
4823 mDefaultValueOnUpdateFields.clear();
4824 QMap< QString, QgsDefaultValue >::const_iterator defaultIt = mDefaultExpressionMap.constBegin();
4825 for ( ; defaultIt != mDefaultExpressionMap.constEnd(); ++defaultIt )
4826 {
4827 int index = mFields.lookupField( defaultIt.key() );
4828 if ( index < 0 )
4829 continue;
4830
4831 mFields[index].setDefaultValueDefinition( defaultIt.value() );
4832 if ( defaultIt.value().applyOnUpdate() )
4833 mDefaultValueOnUpdateFields.insert( index );
4834 }
4835
4836 QMap< QString, QgsFieldConstraints::Constraints >::const_iterator constraintIt = mFieldConstraints.constBegin();
4837 for ( ; constraintIt != mFieldConstraints.constEnd(); ++constraintIt )
4838 {
4839 int index = mFields.lookupField( constraintIt.key() );
4840 if ( index < 0 )
4841 continue;
4842
4843 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4844
4845 // always keep provider constraints intact
4846 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintNotNull ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintNotNull ) )
4848 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintUnique ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintUnique ) )
4850 if ( !( constraints.constraints() & QgsFieldConstraints::ConstraintExpression ) && ( constraintIt.value() & QgsFieldConstraints::ConstraintExpression ) )
4852 mFields[index].setConstraints( constraints );
4853 }
4854
4855 QMap< QString, QPair< QString, QString > >::const_iterator constraintExpIt = mFieldConstraintExpressions.constBegin();
4856 for ( ; constraintExpIt != mFieldConstraintExpressions.constEnd(); ++constraintExpIt )
4857 {
4858 int index = mFields.lookupField( constraintExpIt.key() );
4859 if ( index < 0 )
4860 continue;
4861
4862 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4863
4864 // always keep provider constraints intact
4866 continue;
4867
4868 constraints.setConstraintExpression( constraintExpIt.value().first, constraintExpIt.value().second );
4869 mFields[index].setConstraints( constraints );
4870 }
4871
4872 QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength >::const_iterator constraintStrengthIt = mFieldConstraintStrength.constBegin();
4873 for ( ; constraintStrengthIt != mFieldConstraintStrength.constEnd(); ++constraintStrengthIt )
4874 {
4875 int index = mFields.lookupField( constraintStrengthIt.key().first );
4876 if ( index < 0 )
4877 continue;
4878
4879 QgsFieldConstraints constraints = mFields.at( index ).constraints();
4880
4881 // always keep provider constraints intact
4883 continue;
4884
4885 constraints.setConstraintStrength( constraintStrengthIt.key().second, constraintStrengthIt.value() );
4886 mFields[index].setConstraints( constraints );
4887 }
4888
4889 auto fieldWidgetIterator = mFieldWidgetSetups.constBegin();
4890 for ( ; fieldWidgetIterator != mFieldWidgetSetups.constEnd(); ++fieldWidgetIterator )
4891 {
4892 int index = mFields.indexOf( fieldWidgetIterator.key() );
4893 if ( index < 0 )
4894 continue;
4895
4896 mFields[index].setEditorWidgetSetup( fieldWidgetIterator.value() );
4897 }
4898
4899 if ( oldFields != mFields )
4900 {
4901 emit updatedFields();
4902 mEditFormConfig.setFields( mFields );
4903 }
4904}
4905
4906QVariant QgsVectorLayer::defaultValue( int index, const QgsFeature &feature, QgsExpressionContext *context ) const
4907{
4909
4910 if ( index < 0 || index >= mFields.count() || !mDataProvider )
4911 return QVariant();
4912
4913 QString expression = mFields.at( index ).defaultValueDefinition().expression();
4914 if ( expression.isEmpty() )
4915 return mDataProvider->defaultValue( index );
4916
4917 QgsExpressionContext *evalContext = context;
4918 std::unique_ptr< QgsExpressionContext > tempContext;
4919 if ( !evalContext )
4920 {
4921 // no context passed, so we create a default one
4922 tempContext = std::make_unique<QgsExpressionContext>( QgsExpressionContextUtils::globalProjectLayerScopes( this ) );
4923 evalContext = tempContext.get();
4924 }
4925
4926 if ( feature.isValid() )
4927 {
4929 featScope->setFeature( feature );
4930 featScope->setFields( feature.fields() );
4931 evalContext->appendScope( featScope );
4932 }
4933
4934 QVariant val;
4935 QgsExpression exp( expression );
4936 exp.prepare( evalContext );
4937 if ( exp.hasEvalError() )
4938 {
4939 QgsLogger::warning( "Error evaluating default value: " + exp.evalErrorString() );
4940 }
4941 else
4942 {
4943 val = exp.evaluate( evalContext );
4944 }
4945
4946 if ( feature.isValid() )
4947 {
4948 delete evalContext->popScope();
4949 }
4950
4951 return val;
4952}
4953
4955{
4957
4958 if ( index < 0 || index >= mFields.count() )
4959 return;
4960
4961 if ( definition.isValid() )
4962 {
4963 mDefaultExpressionMap.insert( mFields.at( index ).name(), definition );
4964 }
4965 else
4966 {
4967 mDefaultExpressionMap.remove( mFields.at( index ).name() );
4968 }
4969 updateFields();
4970}
4971
4973{
4975
4976 if ( index < 0 || index >= mFields.count() )
4977 return QgsDefaultValue();
4978 else
4979 return mFields.at( index ).defaultValueDefinition();
4980}
4981
4982QSet<QVariant> QgsVectorLayer::uniqueValues( int index, int limit ) const
4983{
4985
4986 QSet<QVariant> uniqueValues;
4987 if ( !mDataProvider )
4988 {
4989 return uniqueValues;
4990 }
4991
4992 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
4993 switch ( origin )
4994 {
4996 return uniqueValues;
4997
4998 case Qgis::FieldOrigin::Provider: //a provider field
4999 {
5000 uniqueValues = mDataProvider->uniqueValues( index, limit );
5001
5002 if ( mEditBuffer && !mDataProvider->transaction() )
5003 {
5004 QSet<QString> vals;
5005 const auto constUniqueValues = uniqueValues;
5006 for ( const QVariant &v : constUniqueValues )
5007 {
5008 vals << v.toString();
5009 }
5010
5011 QgsFeatureMap added = mEditBuffer->addedFeatures();
5012 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
5013 while ( addedIt.hasNext() && ( limit < 0 || uniqueValues.count() < limit ) )
5014 {
5015 addedIt.next();
5016 QVariant v = addedIt.value().attribute( index );
5017 if ( v.isValid() )
5018 {
5019 QString vs = v.toString();
5020 if ( !vals.contains( vs ) )
5021 {
5022 vals << vs;
5023 uniqueValues << v;
5024 }
5025 }
5026 }
5027
5028 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
5029 while ( it.hasNext() && ( limit < 0 || uniqueValues.count() < limit ) )
5030 {
5031 it.next();
5032 QVariant v = it.value().value( index );
5033 if ( v.isValid() )
5034 {
5035 QString vs = v.toString();
5036 if ( !vals.contains( vs ) )
5037 {
5038 vals << vs;
5039 uniqueValues << v;
5040 }
5041 }
5042 }
5043 }
5044
5045 return uniqueValues;
5046 }
5047
5049 // the layer is editable, but in certain cases it can still be avoided going through all features
5050 if ( mDataProvider->transaction()
5051 || ( mEditBuffer->deletedFeatureIds().isEmpty() && mEditBuffer->addedFeatures().isEmpty() && !mEditBuffer->deletedAttributeIds().contains( index ) && mEditBuffer->changedAttributeValues().isEmpty() ) )
5052 {
5053 uniqueValues = mDataProvider->uniqueValues( index, limit );
5054 return uniqueValues;
5055 }
5056 [[fallthrough]];
5057 //we need to go through each feature
5060 {
5061 QgsAttributeList attList;
5062 attList << index;
5063
5065
5066 QgsFeature f;
5067 QVariant currentValue;
5068 QHash<QString, QVariant> val;
5069 while ( fit.nextFeature( f ) )
5070 {
5071 currentValue = f.attribute( index );
5072 val.insert( currentValue.toString(), currentValue );
5073 if ( limit >= 0 && val.size() >= limit )
5074 {
5075 break;
5076 }
5077 }
5078
5079 return qgis::listToSet( val.values() );
5080 }
5081 }
5082
5083 Q_ASSERT_X( false, "QgsVectorLayer::uniqueValues()", "Unknown source of the field!" );
5084 return uniqueValues;
5085}
5086
5087QStringList QgsVectorLayer::uniqueStringsMatching( int index, const QString &substring, int limit, QgsFeedback *feedback ) const
5088{
5090
5091 QStringList results;
5092 if ( !mDataProvider )
5093 {
5094 return results;
5095 }
5096
5097 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
5098 switch ( origin )
5099 {
5101 return results;
5102
5103 case Qgis::FieldOrigin::Provider: //a provider field
5104 {
5105 results = mDataProvider->uniqueStringsMatching( index, substring, limit, feedback );
5106
5107 if ( mEditBuffer && !mDataProvider->transaction() )
5108 {
5109 QgsFeatureMap added = mEditBuffer->addedFeatures();
5110 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
5111 while ( addedIt.hasNext() && ( limit < 0 || results.count() < limit ) && ( !feedback || !feedback->isCanceled() ) )
5112 {
5113 addedIt.next();
5114 QVariant v = addedIt.value().attribute( index );
5115 if ( v.isValid() )
5116 {
5117 QString vs = v.toString();
5118 if ( vs.contains( substring, Qt::CaseInsensitive ) && !results.contains( vs ) )
5119 {
5120 results << vs;
5121 }
5122 }
5123 }
5124
5125 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
5126 while ( it.hasNext() && ( limit < 0 || results.count() < limit ) && ( !feedback || !feedback->isCanceled() ) )
5127 {
5128 it.next();
5129 QVariant v = it.value().value( index );
5130 if ( v.isValid() )
5131 {
5132 QString vs = v.toString();
5133 if ( vs.contains( substring, Qt::CaseInsensitive ) && !results.contains( vs ) )
5134 {
5135 results << vs;
5136 }
5137 }
5138 }
5139 }
5140
5141 return results;
5142 }
5143
5145 // the layer is editable, but in certain cases it can still be avoided going through all features
5146 if ( mDataProvider->transaction()
5147 || ( mEditBuffer->deletedFeatureIds().isEmpty() && mEditBuffer->addedFeatures().isEmpty() && !mEditBuffer->deletedAttributeIds().contains( index ) && mEditBuffer->changedAttributeValues().isEmpty() ) )
5148 {
5149 return mDataProvider->uniqueStringsMatching( index, substring, limit, feedback );
5150 }
5151 [[fallthrough]];
5152 //we need to go through each feature
5155 {
5156 QgsAttributeList attList;
5157 attList << index;
5158
5159 QgsFeatureRequest request;
5160 request.setSubsetOfAttributes( attList );
5162 QString fieldName = mFields.at( index ).name();
5163 request.setFilterExpression( u"\"%1\" ILIKE '%%2%'"_s.arg( fieldName, substring ) );
5164 QgsFeatureIterator fit = getFeatures( request );
5165
5166 QgsFeature f;
5167 QString currentValue;
5168 while ( fit.nextFeature( f ) )
5169 {
5170 currentValue = f.attribute( index ).toString();
5171 if ( !results.contains( currentValue ) )
5172 results << currentValue;
5173
5174 if ( ( limit >= 0 && results.size() >= limit ) || ( feedback && feedback->isCanceled() ) )
5175 {
5176 break;
5177 }
5178 }
5179
5180 return results;
5181 }
5182 }
5183
5184 Q_ASSERT_X( false, "QgsVectorLayer::uniqueStringsMatching()", "Unknown source of the field!" );
5185 return results;
5186}
5187
5188QVariant QgsVectorLayer::minimumValue( int index ) const
5189{
5191
5192 QVariant minimum;
5193 minimumOrMaximumValue( index, &minimum, nullptr );
5194 return minimum;
5195}
5196
5197QVariant QgsVectorLayer::maximumValue( int index ) const
5198{
5200
5201 QVariant maximum;
5202 minimumOrMaximumValue( index, nullptr, &maximum );
5203 return maximum;
5204}
5205
5206void QgsVectorLayer::minimumAndMaximumValue( int index, QVariant &minimum, QVariant &maximum ) const
5207{
5209
5210 minimumOrMaximumValue( index, &minimum, &maximum );
5211}
5212
5213void QgsVectorLayer::minimumOrMaximumValue( int index, QVariant *minimum, QVariant *maximum ) const
5214{
5216
5217 if ( minimum )
5218 *minimum = QVariant();
5219 if ( maximum )
5220 *maximum = QVariant();
5221
5222 if ( !mDataProvider )
5223 {
5224 return;
5225 }
5226
5227 Qgis::FieldOrigin origin = mFields.fieldOrigin( index );
5228
5229 switch ( origin )
5230 {
5232 {
5233 return;
5234 }
5235
5236 case Qgis::FieldOrigin::Provider: //a provider field
5237 {
5238 if ( minimum )
5239 *minimum = mDataProvider->minimumValue( index );
5240 if ( maximum )
5241 *maximum = mDataProvider->maximumValue( index );
5242 if ( mEditBuffer && !mDataProvider->transaction() )
5243 {
5244 const QgsFeatureMap added = mEditBuffer->addedFeatures();
5245 QMapIterator< QgsFeatureId, QgsFeature > addedIt( added );
5246 while ( addedIt.hasNext() )
5247 {
5248 addedIt.next();
5249 const QVariant v = addedIt.value().attribute( index );
5250 if ( minimum && v.isValid() && qgsVariantLessThan( v, *minimum ) )
5251 *minimum = v;
5252 if ( maximum && v.isValid() && qgsVariantGreaterThan( v, *maximum ) )
5253 *maximum = v;
5254 }
5255
5256 QMapIterator< QgsFeatureId, QgsAttributeMap > it( mEditBuffer->changedAttributeValues() );
5257 while ( it.hasNext() )
5258 {
5259 it.next();
5260 const QVariant v = it.value().value( index );
5261 if ( minimum && v.isValid() && qgsVariantLessThan( v, *minimum ) )
5262 *minimum = v;
5263 if ( maximum && v.isValid() && qgsVariantGreaterThan( v, *maximum ) )
5264 *maximum = v;
5265 }
5266 }
5267 return;
5268 }
5269
5271 {
5272 // the layer is editable, but in certain cases it can still be avoided going through all features
5273 if ( mDataProvider->transaction()
5274 || ( mEditBuffer->deletedFeatureIds().isEmpty() && mEditBuffer->addedFeatures().isEmpty() && !mEditBuffer->deletedAttributeIds().contains( index ) && mEditBuffer->changedAttributeValues().isEmpty() ) )
5275 {
5276 if ( minimum )
5277 *minimum = mDataProvider->minimumValue( index );
5278 if ( maximum )
5279 *maximum = mDataProvider->maximumValue( index );
5280 return;
5281 }
5282 }
5283 [[fallthrough]];
5284 // no choice but to go through all features
5287 {
5288 // we need to go through each feature
5289 QgsAttributeList attList;
5290 attList << index;
5291
5292 QgsFeatureIterator fit = getFeatures( QgsFeatureRequest().setFlags( Qgis::FeatureRequestFlag::NoGeometry ).setSubsetOfAttributes( attList ) );
5293
5294 QgsFeature f;
5295 bool firstValue = true;
5296 while ( fit.nextFeature( f ) )
5297 {
5298 const QVariant currentValue = f.attribute( index );
5299 if ( QgsVariantUtils::isNull( currentValue ) )
5300 continue;
5301
5302 if ( firstValue )
5303 {
5304 if ( minimum )
5305 *minimum = currentValue;
5306 if ( maximum )
5307 *maximum = currentValue;
5308 firstValue = false;
5309 }
5310 else
5311 {
5312 if ( minimum && currentValue.isValid() && qgsVariantLessThan( currentValue, *minimum ) )
5313 *minimum = currentValue;
5314 if ( maximum && currentValue.isValid() && qgsVariantGreaterThan( currentValue, *maximum ) )
5315 *maximum = currentValue;
5316 }
5317 }
5318 return;
5319 }
5320 }
5321
5322 Q_ASSERT_X( false, "QgsVectorLayer::minimumOrMaximumValue()", "Unknown source of the field!" );
5323}
5324
5325void QgsVectorLayer::createEditBuffer()
5326{
5328
5329 if ( mEditBuffer )
5330 clearEditBuffer();
5331
5332 if ( mDataProvider->transaction() )
5333 {
5334 mEditBuffer = new QgsVectorLayerEditPassthrough( this );
5335 connect( mDataProvider->transaction(), &QgsTransaction::dirtied, this, &QgsVectorLayer::onDirtyTransaction, Qt::UniqueConnection );
5336 }
5337 else
5338 {
5339 mEditBuffer = new QgsVectorLayerEditBuffer( this );
5340 }
5341
5342 mEditBuffer->setParent( this );
5343
5344 // forward signals
5345 connect( mEditBuffer, &QgsVectorLayerEditBuffer::layerModified, this, &QgsVectorLayer::invalidateSymbolCountedFlag );
5346 connect( mEditBuffer, &QgsVectorLayerEditBuffer::layerModified, this, &QgsVectorLayer::layerModified ); // TODO[MD]: necessary?
5347 //connect( mEditBuffer, &QgsVectorLayerEditBuffer::layerModified, this, &QgsVectorLayer::triggerRepaint ); // TODO[MD]: works well?
5348 connect( mEditBuffer, &QgsVectorLayerEditBuffer::featureAdded, this, &QgsVectorLayer::onFeatureAdded );
5349 connect( mEditBuffer, &QgsVectorLayerEditBuffer::featureDeleted, this, &QgsVectorLayer::onFeatureDeleted );
5360}
5361
5362void QgsVectorLayer::clearEditBuffer()
5363{
5365
5366 delete mEditBuffer;
5367 mEditBuffer = nullptr;
5368}
5369
5370void QgsVectorLayer::applyRendererSettings()
5371{
5372 const QgsLayerRenderingSettings *providerRenderingSettings = mDataProvider->renderingSettings();
5373
5374 if ( !providerRenderingSettings )
5375 return;
5376
5377 if ( providerRenderingSettings->hasLayerOpacity() )
5378 setOpacity( providerRenderingSettings->layerOpacity() );
5379 if ( providerRenderingSettings->hasMaximumScale() )
5380 setMaximumScale( providerRenderingSettings->maximumScale() );
5381 if ( providerRenderingSettings->hasMinimumScale() )
5382 setMinimumScale( providerRenderingSettings->minimumScale() );
5383 if ( providerRenderingSettings->hasMaximumScale() || providerRenderingSettings->hasMinimumScale() )
5385 ( providerRenderingSettings->hasMaximumScale() && providerRenderingSettings->maximumScale() != 0 )
5386 || ( providerRenderingSettings->hasMinimumScale() && providerRenderingSettings->minimumScale() != 0 )
5387 );
5388}
5389
5390QSet<QgsVectorLayer *> QgsVectorLayer::transactionLayers()
5391{
5392 QSet<QgsVectorLayer *> transactionLayers;
5393 if ( project() )
5394 {
5395 QString connString = QgsTransaction::connectionString( source() );
5396 QString key = providerType();
5397
5398 QMap<QPair<QString, QString>, QgsTransactionGroup *> transactionGroups = project()->transactionGroups();
5399 QMap<QPair<QString, QString>, QgsTransactionGroup *>::iterator tIt = transactionGroups.find( qMakePair( key, connString ) );
5400 QgsTransactionGroup *tg = ( tIt != transactionGroups.end() ? tIt.value() : nullptr );
5401
5402 if ( tg && tg->layers().contains( this ) )
5403 transactionLayers = tg->layers();
5404 }
5405 return transactionLayers;
5406}
5407
5410 const QString &fieldOrExpression,
5412 QgsExpressionContext *context,
5413 bool *ok,
5414 QgsFeatureIds *fids,
5415 QgsFeedback *feedback,
5416 QString *error
5417) const
5418{
5419 // non fatal for now -- the aggregate expression functions are not thread safe and call this
5421
5422 if ( ok )
5423 *ok = false;
5424 if ( error )
5425 error->clear();
5426
5427 if ( !mDataProvider )
5428 {
5429 if ( error )
5430 *error = tr( "Layer is invalid" );
5431 return QVariant();
5432 }
5433
5434 // test if we are calculating based on a field
5435 const int attrIndex = QgsExpression::expressionToLayerFieldIndex( fieldOrExpression, this );
5436 if ( attrIndex >= 0 )
5437 {
5438 // aggregate is based on a field - if it's a provider field, we could possibly hand over the calculation
5439 // to the provider itself
5440 Qgis::FieldOrigin origin = mFields.fieldOrigin( attrIndex );
5441 if ( origin == Qgis::FieldOrigin::Provider )
5442 {
5443 bool providerOk = false;
5444 QVariant val = mDataProvider->aggregate( aggregate, attrIndex, parameters, context, providerOk, fids );
5445 if ( providerOk )
5446 {
5447 // provider handled calculation
5448 if ( ok )
5449 *ok = true;
5450 return val;
5451 }
5452 }
5453 }
5454
5455 // fallback to using aggregate calculator to determine aggregate
5456 QgsAggregateCalculator c( this );
5457 if ( fids )
5458 c.setFidsFilter( *fids );
5459 c.setParameters( parameters );
5460 bool aggregateOk = false;
5461 const QVariant result = c.calculate( aggregate, fieldOrExpression, context, &aggregateOk, feedback );
5462 if ( ok )
5463 *ok = aggregateOk;
5464 if ( !aggregateOk && error )
5465 *error = c.lastError();
5466
5467 return result;
5468}
5469
5471{
5473
5474 if ( mFeatureBlendMode == featureBlendMode )
5475 return;
5476
5477 mFeatureBlendMode = featureBlendMode;
5480}
5481
5482QPainter::CompositionMode QgsVectorLayer::featureBlendMode() const
5483{
5484 // non fatal for now -- the "rasterize" processing algorithm is not thread safe and calls this
5486
5487 return mFeatureBlendMode;
5488}
5489
5490void QgsVectorLayer::readSldLabeling( const QDomNode &node )
5491{
5493
5494 setLabeling( nullptr ); // start with no labeling
5495 setLabelsEnabled( false );
5496
5497 QDomElement element = node.toElement();
5498 if ( element.isNull() )
5499 return;
5500
5501 QDomElement userStyleElem = element.firstChildElement( u"UserStyle"_s );
5502 if ( userStyleElem.isNull() )
5503 {
5504 QgsDebugMsgLevel( u"Info: UserStyle element not found."_s, 4 );
5505 return;
5506 }
5507
5508 QDomElement featTypeStyleElem = userStyleElem.firstChildElement( u"FeatureTypeStyle"_s );
5509 if ( featTypeStyleElem.isNull() )
5510 {
5511 QgsDebugMsgLevel( u"Info: FeatureTypeStyle element not found."_s, 4 );
5512 return;
5513 }
5514
5515 // create empty FeatureTypeStyle element to merge TextSymbolizer's Rule's from all FeatureTypeStyle's
5516 QDomElement mergedFeatTypeStyle = featTypeStyleElem.cloneNode( false ).toElement();
5517
5518 // use the RuleRenderer when more rules are present or the rule
5519 // has filters or min/max scale denominators set,
5520 // otherwise use the Simple labeling
5521 bool needRuleBasedLabeling = false;
5522 int ruleCount = 0;
5523
5524 while ( !featTypeStyleElem.isNull() )
5525 {
5526 QDomElement ruleElem = featTypeStyleElem.firstChildElement( u"Rule"_s );
5527 while ( !ruleElem.isNull() )
5528 {
5529 // test rule children element to check if we need to create RuleRenderer
5530 // and if the rule has a symbolizer
5531 bool hasTextSymbolizer = false;
5532 bool hasRuleBased = false;
5533 QDomElement ruleChildElem = ruleElem.firstChildElement();
5534 while ( !ruleChildElem.isNull() )
5535 {
5536 // rule has filter or min/max scale denominator, use the RuleRenderer
5537 if ( ruleChildElem.localName() == "Filter"_L1 || ruleChildElem.localName() == "MinScaleDenominator"_L1 || ruleChildElem.localName() == "MaxScaleDenominator"_L1 )
5538 {
5539 hasRuleBased = true;
5540 }
5541 // rule has a renderer symbolizer, not a text symbolizer
5542 else if ( ruleChildElem.localName() == "TextSymbolizer"_L1 )
5543 {
5544 QgsDebugMsgLevel( u"Info: TextSymbolizer element found"_s, 4 );
5545 hasTextSymbolizer = true;
5546 }
5547
5548 ruleChildElem = ruleChildElem.nextSiblingElement();
5549 }
5550
5551 if ( hasTextSymbolizer )
5552 {
5553 ruleCount++;
5554
5555 // append a clone of all Rules to the merged FeatureTypeStyle element
5556 mergedFeatTypeStyle.appendChild( ruleElem.cloneNode().toElement() );
5557
5558 if ( hasRuleBased )
5559 {
5560 QgsDebugMsgLevel( u"Info: Filter or Min/MaxScaleDenominator element found: need a RuleBasedLabeling"_s, 4 );
5561 needRuleBasedLabeling = true;
5562 }
5563 }
5564
5565 // more rules present, use the RuleRenderer
5566 if ( ruleCount > 1 )
5567 {
5568 QgsDebugMsgLevel( u"Info: More Rule elements found: need a RuleBasedLabeling"_s, 4 );
5569 needRuleBasedLabeling = true;
5570 }
5571
5572 // not use the rule based labeling if no rules with textSymbolizer
5573 if ( ruleCount == 0 )
5574 {
5575 needRuleBasedLabeling = false;
5576 }
5577
5578 ruleElem = ruleElem.nextSiblingElement( u"Rule"_s );
5579 }
5580 featTypeStyleElem = featTypeStyleElem.nextSiblingElement( u"FeatureTypeStyle"_s );
5581 }
5582
5583 if ( ruleCount == 0 )
5584 {
5585 QgsDebugMsgLevel( u"Info: No TextSymbolizer element."_s, 4 );
5586 return;
5587 }
5588
5589 QDomElement ruleElem = mergedFeatTypeStyle.firstChildElement( u"Rule"_s );
5590
5591 if ( needRuleBasedLabeling )
5592 {
5593 QgsDebugMsgLevel( u"Info: rule based labeling"_s, 4 );
5594 QgsRuleBasedLabeling::Rule *rootRule = new QgsRuleBasedLabeling::Rule( nullptr );
5595 while ( !ruleElem.isNull() )
5596 {
5597 QString label, description, filterExp;
5598 int scaleMinDenom = 0, scaleMaxDenom = 0;
5599 QgsPalLayerSettings settings;
5600
5601 // retrieve the Rule element child nodes
5602 QDomElement childElem = ruleElem.firstChildElement();
5603 while ( !childElem.isNull() )
5604 {
5605 if ( childElem.localName() == "Name"_L1 )
5606 {
5607 // <se:Name> tag contains the rule identifier,
5608 // so prefer title tag for the label property value
5609 if ( label.isEmpty() )
5610 label = childElem.firstChild().nodeValue();
5611 }
5612 else if ( childElem.localName() == "Description"_L1 )
5613 {
5614 // <se:Description> can contains a title and an abstract
5615 QDomElement titleElem = childElem.firstChildElement( u"Title"_s );
5616 if ( !titleElem.isNull() )
5617 {
5618 label = titleElem.firstChild().nodeValue();
5619 }
5620
5621 QDomElement abstractElem = childElem.firstChildElement( u"Abstract"_s );
5622 if ( !abstractElem.isNull() )
5623 {
5624 description = abstractElem.firstChild().nodeValue();
5625 }
5626 }
5627 else if ( childElem.localName() == "Abstract"_L1 )
5628 {
5629 // <sld:Abstract> (v1.0)
5630 description = childElem.firstChild().nodeValue();
5631 }
5632 else if ( childElem.localName() == "Title"_L1 )
5633 {
5634 // <sld:Title> (v1.0)
5635 label = childElem.firstChild().nodeValue();
5636 }
5637 else if ( childElem.localName() == "Filter"_L1 )
5638 {
5639 std::unique_ptr<QgsExpression> filter = QgsOgcUtils::expressionFromOgcFilter( childElem );
5640 if ( filter )
5641 {
5642 if ( filter->hasParserError() )
5643 {
5644 QgsDebugMsgLevel( u"SLD Filter parsing error: %1"_s.arg( filter->parserErrorString() ), 3 );
5645 }
5646 else
5647 {
5648 filterExp = filter->expression();
5649 }
5650 }
5651 }
5652 else if ( childElem.localName() == "MinScaleDenominator"_L1 )
5653 {
5654 bool ok;
5655 int v = childElem.firstChild().nodeValue().toInt( &ok );
5656 if ( ok )
5657 scaleMinDenom = v;
5658 }
5659 else if ( childElem.localName() == "MaxScaleDenominator"_L1 )
5660 {
5661 bool ok;
5662 int v = childElem.firstChild().nodeValue().toInt( &ok );
5663 if ( ok )
5664 scaleMaxDenom = v;
5665 }
5666 else if ( childElem.localName() == "TextSymbolizer"_L1 )
5667 {
5668 readSldTextSymbolizer( childElem, settings );
5669 }
5670
5671 childElem = childElem.nextSiblingElement();
5672 }
5673
5674 QgsRuleBasedLabeling::Rule *ruleLabeling = new QgsRuleBasedLabeling::Rule( new QgsPalLayerSettings( settings ), scaleMinDenom, scaleMaxDenom, filterExp, label );
5675 rootRule->appendChild( ruleLabeling );
5676
5677 ruleElem = ruleElem.nextSiblingElement();
5678 }
5679
5680 setLabeling( new QgsRuleBasedLabeling( rootRule ) );
5681 setLabelsEnabled( true );
5682 }
5683 else
5684 {
5685 QgsDebugMsgLevel( u"Info: simple labeling"_s, 4 );
5686 // retrieve the TextSymbolizer element child node
5687 QDomElement textSymbolizerElem = ruleElem.firstChildElement( u"TextSymbolizer"_s );
5688 QgsPalLayerSettings s;
5689 if ( readSldTextSymbolizer( textSymbolizerElem, s ) )
5690 {
5691 setLabeling( new QgsVectorLayerSimpleLabeling( s ) );
5692 setLabelsEnabled( true );
5693 }
5694 }
5695}
5696
5697bool QgsVectorLayer::readSldTextSymbolizer( const QDomNode &node, QgsPalLayerSettings &settings ) const
5698{
5700
5701 if ( node.localName() != "TextSymbolizer"_L1 )
5702 {
5703 QgsDebugMsgLevel( u"Not a TextSymbolizer element: %1"_s.arg( node.localName() ), 3 );
5704 return false;
5705 }
5706 QDomElement textSymbolizerElem = node.toElement();
5707 // Label
5708 QDomElement labelElem = textSymbolizerElem.firstChildElement( u"Label"_s );
5709 if ( !labelElem.isNull() )
5710 {
5711 QDomElement propertyNameElem = labelElem.firstChildElement( u"PropertyName"_s );
5712 if ( !propertyNameElem.isNull() )
5713 {
5714 // set labeling defaults
5715
5716 // label attribute
5717 QString labelAttribute = propertyNameElem.text();
5718 settings.fieldName = labelAttribute;
5719 settings.isExpression = false;
5720
5721 int fieldIndex = mFields.lookupField( labelAttribute );
5722 if ( fieldIndex == -1 )
5723 {
5724 // label attribute is not in columns, check if it is an expression
5725 QgsExpression exp( labelAttribute );
5726 if ( !exp.hasEvalError() )
5727 {
5728 settings.isExpression = true;
5729 }
5730 else
5731 {
5732 QgsDebugMsgLevel( u"SLD label attribute error: %1"_s.arg( exp.evalErrorString() ), 3 );
5733 }
5734 }
5735 }
5736 else
5737 {
5738 QgsDebugMsgLevel( u"Info: PropertyName element not found."_s, 4 );
5739 return false;
5740 }
5741 }
5742 else
5743 {
5744 QgsDebugMsgLevel( u"Info: Label element not found."_s, 4 );
5745 return false;
5746 }
5747
5749 if ( textSymbolizerElem.hasAttribute( u"uom"_s ) )
5750 {
5751 sldUnitSize = QgsSymbolLayerUtils::decodeSldUom( textSymbolizerElem.attribute( u"uom"_s ) );
5752 }
5753
5754 QString fontFamily = u"Sans-Serif"_s;
5755 double fontPointSize = 10;
5757 int fontWeight = -1;
5758 bool fontItalic = false;
5759 bool fontUnderline = false;
5760
5761 // Font
5762 QDomElement fontElem = textSymbolizerElem.firstChildElement( u"Font"_s );
5763 if ( !fontElem.isNull() )
5764 {
5765 QgsStringMap fontSvgParams = QgsSymbolLayerUtils::getSvgParameterList( fontElem );
5766 for ( QgsStringMap::iterator it = fontSvgParams.begin(); it != fontSvgParams.end(); ++it )
5767 {
5768 QgsDebugMsgLevel( u"found fontSvgParams %1: %2"_s.arg( it.key(), it.value() ), 4 );
5769
5770 if ( it.key() == "font-family"_L1 )
5771 {
5772 fontFamily = it.value();
5773 }
5774 else if ( it.key() == "font-style"_L1 )
5775 {
5776 fontItalic = ( it.value() == "italic"_L1 ) || ( it.value() == "Italic"_L1 );
5777 }
5778 else if ( it.key() == "font-size"_L1 )
5779 {
5780 bool ok;
5781 double fontSize = it.value().toDouble( &ok );
5782 if ( ok )
5783 {
5784 fontPointSize = fontSize;
5785 fontUnitSize = sldUnitSize;
5786 }
5787 }
5788 else if ( it.key() == "font-weight"_L1 )
5789 {
5790 if ( ( it.value() == "bold"_L1 ) || ( it.value() == "Bold"_L1 ) )
5791 fontWeight = QFont::Bold;
5792 }
5793 else if ( it.key() == "font-underline"_L1 )
5794 {
5795 fontUnderline = ( it.value() == "underline"_L1 ) || ( it.value() == "Underline"_L1 );
5796 }
5797 }
5798 }
5799
5800 QgsTextFormat format;
5801 QFont font( fontFamily, 1, fontWeight, fontItalic );
5802 font.setUnderline( fontUnderline );
5803 format.setFont( font );
5804 format.setSize( fontPointSize );
5805 format.setSizeUnit( fontUnitSize );
5806
5807 // Fill
5808 QDomElement fillElem = textSymbolizerElem.firstChildElement( u"Fill"_s );
5809 QColor textColor;
5810 Qt::BrushStyle textBrush = Qt::SolidPattern;
5811 QgsSymbolLayerUtils::fillFromSld( fillElem, textBrush, textColor );
5812 if ( textColor.isValid() )
5813 {
5814 QgsDebugMsgLevel( u"Info: textColor %1."_s.arg( QVariant( textColor ).toString() ), 4 );
5815 format.setColor( textColor );
5816 }
5817
5818 QgsTextBufferSettings bufferSettings;
5819
5820 // Halo
5821 QDomElement haloElem = textSymbolizerElem.firstChildElement( u"Halo"_s );
5822 if ( !haloElem.isNull() )
5823 {
5824 bufferSettings.setEnabled( true );
5825 bufferSettings.setSize( 1 );
5826
5827 QDomElement radiusElem = haloElem.firstChildElement( u"Radius"_s );
5828 if ( !radiusElem.isNull() )
5829 {
5830 bool ok;
5831 double bufferSize = radiusElem.text().toDouble( &ok );
5832 if ( ok )
5833 {
5834 bufferSettings.setSize( bufferSize );
5835 bufferSettings.setSizeUnit( sldUnitSize );
5836 }
5837 }
5838
5839 QDomElement haloFillElem = haloElem.firstChildElement( u"Fill"_s );
5840 QColor bufferColor;
5841 Qt::BrushStyle bufferBrush = Qt::SolidPattern;
5842 QgsSymbolLayerUtils::fillFromSld( haloFillElem, bufferBrush, bufferColor );
5843 if ( bufferColor.isValid() )
5844 {
5845 QgsDebugMsgLevel( u"Info: bufferColor %1."_s.arg( QVariant( bufferColor ).toString() ), 4 );
5846 bufferSettings.setColor( bufferColor );
5847 }
5848 }
5849
5850 // LabelPlacement
5851 QDomElement labelPlacementElem = textSymbolizerElem.firstChildElement( u"LabelPlacement"_s );
5852 if ( !labelPlacementElem.isNull() )
5853 {
5854 // PointPlacement
5855 QDomElement pointPlacementElem = labelPlacementElem.firstChildElement( u"PointPlacement"_s );
5856 if ( !pointPlacementElem.isNull() )
5857 {
5860 {
5862 }
5863
5864 QDomElement displacementElem = pointPlacementElem.firstChildElement( u"Displacement"_s );
5865 if ( !displacementElem.isNull() )
5866 {
5867 QDomElement displacementXElem = displacementElem.firstChildElement( u"DisplacementX"_s );
5868 if ( !displacementXElem.isNull() )
5869 {
5870 bool ok;
5871 double xOffset = displacementXElem.text().toDouble( &ok );
5872 if ( ok )
5873 {
5874 settings.xOffset = xOffset;
5875 settings.offsetUnits = sldUnitSize;
5876 }
5877 }
5878 QDomElement displacementYElem = displacementElem.firstChildElement( u"DisplacementY"_s );
5879 if ( !displacementYElem.isNull() )
5880 {
5881 bool ok;
5882 double yOffset = displacementYElem.text().toDouble( &ok );
5883 if ( ok )
5884 {
5885 settings.yOffset = yOffset;
5886 settings.offsetUnits = sldUnitSize;
5887 }
5888 }
5889 }
5890 QDomElement anchorPointElem = pointPlacementElem.firstChildElement( u"AnchorPoint"_s );
5891 if ( !anchorPointElem.isNull() )
5892 {
5893 bool xOffsetOk = false;
5894 double xOffset = 0.0;
5895 bool yOffsetOk = false;
5896 double yOffset = 0.0;
5897
5898 QDomElement anchorPointXElem = anchorPointElem.firstChildElement( u"AnchorPointX"_s );
5899 if ( !anchorPointXElem.isNull() )
5900 {
5901 xOffset = anchorPointXElem.text().toDouble( &xOffsetOk );
5902 }
5903 QDomElement anchorPointYElem = anchorPointElem.firstChildElement( u"AnchorPointY"_s );
5904 if ( !anchorPointYElem.isNull() )
5905 {
5906 yOffset = anchorPointYElem.text().toDouble( &yOffsetOk );
5907 }
5908
5909 if ( xOffsetOk & yOffsetOk )
5910 {
5911 // Round values in increments of 0.5
5912 xOffset = std::round( xOffset * 2.0 ) / 2.0;
5913 yOffset = std::round( yOffset * 2.0 ) / 2.0;
5914
5915 if ( xOffset == 1.0 && yOffset == 0.0 )
5916 {
5918 }
5919 else if ( xOffset == 0.5 && yOffset == 0.0 )
5920 {
5922 }
5923 else if ( xOffset == 0.0 && yOffset == 0.0 )
5924 {
5926 }
5927 else if ( xOffset == 1.0 && yOffset == 0.5 )
5928 {
5930 }
5931 else if ( xOffset == 0.5 && yOffset == 0.5 )
5932 {
5934 }
5935 else if ( xOffset == 0.0 && yOffset == 0.5 )
5936 {
5938 }
5939 else if ( xOffset == 1.0 && yOffset == 1.0 )
5940 {
5942 }
5943 else if ( xOffset == 0.5 && yOffset == 1.0 )
5944 {
5946 }
5947 else
5948 {
5950 }
5951 }
5952 }
5953
5954 QDomElement rotationElem = pointPlacementElem.firstChildElement( u"Rotation"_s );
5955 if ( !rotationElem.isNull() )
5956 {
5957 bool ok;
5958 double rotation = rotationElem.text().toDouble( &ok );
5959 if ( ok )
5960 {
5961 settings.angleOffset = 360 - rotation;
5962 }
5963 }
5964 }
5965 else
5966 {
5967 // PointPlacement
5968 QDomElement linePlacementElem = labelPlacementElem.firstChildElement( u"LinePlacement"_s );
5969 if ( !linePlacementElem.isNull() )
5970 {
5972 }
5973 }
5974 }
5975
5976 // read vendor options
5977 QgsStringMap vendorOptions;
5978 QDomElement vendorOptionElem = textSymbolizerElem.firstChildElement( u"VendorOption"_s );
5979 while ( !vendorOptionElem.isNull() && vendorOptionElem.localName() == "VendorOption"_L1 )
5980 {
5981 QString optionName = vendorOptionElem.attribute( u"name"_s );
5982 QString optionValue;
5983 if ( vendorOptionElem.firstChild().nodeType() == QDomNode::TextNode )
5984 {
5985 optionValue = vendorOptionElem.firstChild().nodeValue();
5986 }
5987 else
5988 {
5989 if ( vendorOptionElem.firstChild().nodeType() == QDomNode::ElementNode && vendorOptionElem.firstChild().localName() == "Literal"_L1 )
5990 {
5991 QgsDebugMsgLevel( vendorOptionElem.firstChild().localName(), 2 );
5992 optionValue = vendorOptionElem.firstChild().firstChild().nodeValue();
5993 }
5994 else
5995 {
5996 QgsDebugError( u"unexpected child of %1 named %2"_s.arg( vendorOptionElem.localName(), optionName ) );
5997 }
5998 }
5999
6000 if ( !optionName.isEmpty() && !optionValue.isEmpty() )
6001 {
6002 vendorOptions[optionName] = optionValue;
6003 }
6004
6005 vendorOptionElem = vendorOptionElem.nextSiblingElement();
6006 }
6007 if ( !vendorOptions.isEmpty() )
6008 {
6009 for ( QgsStringMap::iterator it = vendorOptions.begin(); it != vendorOptions.end(); ++it )
6010 {
6011 if ( it.key() == "underlineText"_L1 && it.value() == "true"_L1 )
6012 {
6013 font.setUnderline( true );
6014 format.setFont( font );
6015 }
6016 else if ( it.key() == "strikethroughText"_L1 && it.value() == "true"_L1 )
6017 {
6018 font.setStrikeOut( true );
6019 format.setFont( font );
6020 }
6021 else if ( it.key() == "maxDisplacement"_L1 )
6022 {
6024 }
6025 else if ( it.key() == "followLine"_L1 && it.value() == "true"_L1 )
6026 {
6028 {
6030 }
6031 else
6032 {
6034 }
6035 }
6036 else if ( it.key() == "maxAngleDelta"_L1 )
6037 {
6038 bool ok;
6039 double angle = it.value().toDouble( &ok );
6040 if ( ok )
6041 {
6042 settings.maxCurvedCharAngleIn = angle;
6043 settings.maxCurvedCharAngleOut = angle;
6044 }
6045 }
6046 // miscellaneous options
6047 else if ( it.key() == "conflictResolution"_L1 && it.value() == "false"_L1 )
6048 {
6050 }
6051 else if ( it.key() == "forceLeftToRight"_L1 && it.value() == "false"_L1 )
6052 {
6054 }
6055 else if ( it.key() == "group"_L1 && it.value() == "yes"_L1 )
6056 {
6057 settings.lineSettings().setMergeLines( true );
6058 }
6059 else if ( it.key() == "labelAllGroup"_L1 && it.value() == "true"_L1 )
6060 {
6061 settings.lineSettings().setMergeLines( true );
6062 }
6063 }
6064 }
6065
6066 format.setBuffer( bufferSettings );
6067 settings.setFormat( format );
6068 return true;
6069}
6070
6072{
6074
6075 return mEditFormConfig;
6076}
6077
6079{
6081
6082 if ( mEditFormConfig == editFormConfig )
6083 return;
6084
6085 mEditFormConfig = editFormConfig;
6086 mEditFormConfig.onRelationsLoaded();
6087 emit editFormConfigChanged();
6088}
6089
6091{
6093
6094 QgsAttributeTableConfig config = mAttributeTableConfig;
6095
6096 if ( config.isEmpty() )
6097 config.update( fields() );
6098
6099 return config;
6100}
6101
6103{
6105
6106 if ( mAttributeTableConfig != attributeTableConfig )
6107 {
6108 mAttributeTableConfig = attributeTableConfig;
6109 emit configChanged();
6110 }
6111}
6112
6114{
6115 // called in a non-thread-safe way in some cases when calculating aggregates in a different thread
6117
6119}
6120
6127
6129{
6131
6132 if ( !mDiagramLayerSettings )
6133 mDiagramLayerSettings = std::make_unique<QgsDiagramLayerSettings>();
6134 *mDiagramLayerSettings = s;
6135}
6136
6138{
6140
6141 QgsLayerMetadataFormatter htmlFormatter( metadata() );
6142 QString myMetadata = u"<html><head></head>\n<body>\n"_s;
6143
6144 myMetadata += generalHtmlMetadata();
6145
6146 // Begin Provider section
6147 myMetadata += u"<h1>"_s + tr( "Information from provider" ) + u"</h1>\n<hr>\n"_s;
6148 myMetadata += "<table class=\"list-view\">\n"_L1;
6149
6150 // storage type
6151 if ( !storageType().isEmpty() )
6152 {
6153 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Storage" ) + u"</td><td>"_s + storageType() + u"</td></tr>\n"_s;
6154 }
6155
6156 // comment
6157 if ( !dataComment().isEmpty() )
6158 {
6159 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Comment" ) + u"</td><td>"_s + dataComment() + u"</td></tr>\n"_s;
6160 }
6161
6162 // encoding
6163 if ( const QgsVectorDataProvider *provider = dataProvider() )
6164 {
6165 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Encoding" ) + u"</td><td>"_s + provider->encoding() + u"</td></tr>\n"_s;
6166 myMetadata += provider->htmlMetadata();
6167 }
6168
6169 if ( isSpatial() )
6170 {
6171 // geom type
6173 if ( static_cast<int>( type ) < 0 || static_cast< int >( type ) > static_cast< int >( Qgis::GeometryType::Null ) )
6174 {
6175 QgsDebugMsgLevel( u"Invalid vector type"_s, 2 );
6176 }
6177 else
6178 {
6179 QString typeString( u"%1 (%2)"_s.arg( QgsWkbTypes::geometryDisplayString( geometryType() ), QgsWkbTypes::displayString( wkbType() ) ) );
6180 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Geometry type" ) + u"</td><td>"_s + typeString + u"</td></tr>\n"_s;
6181 }
6182
6183 // geom column name
6184 if ( const QgsVectorDataProvider *provider = dataProvider(); provider && !provider->geometryColumnName().isEmpty() )
6185 {
6186 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Geometry column" ) + u"</td><td>"_s + provider->geometryColumnName() + u"</td></tr>\n"_s;
6187 }
6188
6189 // Extent
6190 // Try to display extent 3D by default. If empty (probably because the data is 2D), fallback to the 2D version
6191 const QgsBox3D extentBox3D = extent3D();
6192 const QString extentAsStr = !extentBox3D.isEmpty() ? extentBox3D.toString() : extent().toString();
6193 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Extent" ) + u"</td><td>"_s + extentAsStr + u"</td></tr>\n"_s;
6194 }
6195
6196 // feature count
6197 QLocale locale = QLocale();
6198 locale.setNumberOptions( locale.numberOptions() &= ~QLocale::NumberOption::OmitGroupSeparator );
6199 myMetadata += u"<tr><td class=\"highlight\">"_s
6200 + tr( "Feature count" )
6201 + u"</td><td>"_s
6202 + ( featureCount() == -1 ? tr( "unknown" ) : locale.toString( static_cast<qlonglong>( featureCount() ) ) )
6203 + u"</td></tr>\n"_s;
6204
6205 // End Provider section
6206 myMetadata += "</table>\n<br><br>"_L1;
6207
6208 if ( isSpatial() )
6209 {
6210 // CRS
6211 myMetadata += crsHtmlMetadata();
6212 }
6213
6214 // identification section
6215 myMetadata += u"<h1>"_s + tr( "Identification" ) + u"</h1>\n<hr>\n"_s;
6216 myMetadata += htmlFormatter.identificationSectionHtml();
6217 myMetadata += "<br><br>\n"_L1;
6218
6219 // extent section
6220 myMetadata += u"<h1>"_s + tr( "Extent" ) + u"</h1>\n<hr>\n"_s;
6221 myMetadata += htmlFormatter.extentSectionHtml( isSpatial() );
6222 myMetadata += "<br><br>\n"_L1;
6223
6224 // Start the Access section
6225 myMetadata += u"<h1>"_s + tr( "Access" ) + u"</h1>\n<hr>\n"_s;
6226 myMetadata += htmlFormatter.accessSectionHtml();
6227 myMetadata += "<br><br>\n"_L1;
6228
6229 // Fields section
6230 myMetadata += u"<h1>"_s + tr( "Fields" ) + u"</h1>\n<hr>\n<table class=\"list-view\">\n"_s;
6231
6232 // primary key
6234 if ( !pkAttrList.isEmpty() )
6235 {
6236 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Primary key attributes" ) + u"</td><td>"_s;
6237 const auto constPkAttrList = pkAttrList;
6238 for ( int idx : constPkAttrList )
6239 {
6240 myMetadata += fields().at( idx ).name() + ' ';
6241 }
6242 myMetadata += "</td></tr>\n"_L1;
6243 }
6244
6245 const QgsFields myFields = fields();
6246
6247 // count fields
6248 myMetadata += u"<tr><td class=\"highlight\">"_s + tr( "Count" ) + u"</td><td>"_s + QString::number( myFields.size() ) + u"</td></tr>\n"_s;
6249
6250 myMetadata += "</table>\n<br><table width=\"100%\" class=\"tabular-view\">\n"_L1;
6251 myMetadata += "<tr><th>"_L1 + tr( "Field" ) + "</th><th>"_L1 + tr( "Type" ) + "</th><th>"_L1 + tr( "Length" ) + "</th><th>"_L1 + tr( "Precision" ) + "</th><th>"_L1 + tr( "Comment" ) + "</th></tr>\n"_L1;
6252
6253 for ( int i = 0; i < myFields.size(); ++i )
6254 {
6255 QgsField myField = myFields.at( i );
6256 QString rowClass;
6257 if ( i % 2 )
6258 rowClass = u"class=\"odd-row\""_s;
6259 myMetadata += "<tr "_L1
6260 + rowClass
6261 + "><td>"_L1
6262 + myField.displayNameWithAlias()
6263 + "</td><td>"_L1
6264 + myField.typeName()
6265 + "</td><td>"_L1
6266 + QString::number( myField.length() )
6267 + "</td><td>"_L1
6268 + QString::number( myField.precision() )
6269 + "</td><td>"_L1
6270 + myField.comment()
6271 + "</td></tr>\n"_L1;
6272 }
6273
6274 //close field list
6275 myMetadata += "</table>\n<br><br>"_L1;
6276
6277 // Start the contacts section
6278 myMetadata += u"<h1>"_s + tr( "Contacts" ) + u"</h1>\n<hr>\n"_s;
6279 myMetadata += htmlFormatter.contactsSectionHtml();
6280 myMetadata += "<br><br>\n"_L1;
6281
6282 // Start the links section
6283 myMetadata += u"<h1>"_s + tr( "Links" ) + u"</h1>\n<hr>\n"_s;
6284 myMetadata += htmlFormatter.linksSectionHtml();
6285 myMetadata += "<br><br>\n"_L1;
6286
6287 // Start the history section
6288 myMetadata += u"<h1>"_s + tr( "History" ) + u"</h1>\n<hr>\n"_s;
6289 myMetadata += htmlFormatter.historySectionHtml();
6290 myMetadata += "<br><br>\n"_L1;
6291
6292 myMetadata += customPropertyHtmlMetadata();
6293
6294 myMetadata += "\n</body>\n</html>\n"_L1;
6295 return myMetadata;
6296}
6297
6298void QgsVectorLayer::invalidateSymbolCountedFlag()
6299{
6301
6302 mSymbolFeatureCounted = false;
6303}
6304
6305void QgsVectorLayer::onFeatureCounterCompleted()
6306{
6308
6309 onSymbolsCounted();
6310 mFeatureCounter = nullptr;
6311}
6312
6313void QgsVectorLayer::onFeatureCounterTerminated()
6314{
6316
6317 mFeatureCounter = nullptr;
6318}
6319
6320void QgsVectorLayer::onJoinedFieldsChanged()
6321{
6323
6324 // some of the fields of joined layers have changed -> we need to update this layer's fields too
6325 updateFields();
6326}
6327
6328void QgsVectorLayer::onFeatureAdded( QgsFeatureId fid )
6329{
6331
6332 updateExtents();
6333
6334 emit featureAdded( fid );
6335}
6336
6337void QgsVectorLayer::onFeatureDeleted( QgsFeatureId fid )
6338{
6340
6341 updateExtents();
6342
6343 if ( mEditCommandActive || mCommitChangesActive )
6344 {
6345 mDeletedFids << fid;
6346 }
6347 else
6348 {
6349 mSelectedFeatureIds.remove( fid );
6350 emit featuresDeleted( QgsFeatureIds() << fid );
6351 }
6352
6353 emit featureDeleted( fid );
6354}
6355
6356void QgsVectorLayer::onRelationsLoaded()
6357{
6359
6360 mEditFormConfig.onRelationsLoaded();
6361}
6362
6363void QgsVectorLayer::onSymbolsCounted()
6364{
6366
6367 if ( mFeatureCounter )
6368 {
6369 mSymbolFeatureCounted = true;
6370 mSymbolFeatureCountMap = mFeatureCounter->symbolFeatureCountMap();
6371 mSymbolFeatureIdMap = mFeatureCounter->symbolFeatureIdMap();
6373 }
6374}
6375
6376QList<QgsRelation> QgsVectorLayer::referencingRelations( int idx ) const
6377{
6379
6380 if ( QgsProject *p = project() )
6381 return p->relationManager()->referencingRelations( this, idx );
6382 else
6383 return {};
6384}
6385
6386QList<QgsWeakRelation> QgsVectorLayer::weakRelations() const
6387{
6389
6390 return mWeakRelations;
6391}
6392
6393void QgsVectorLayer::setWeakRelations( const QList<QgsWeakRelation> &relations )
6394{
6396
6397 mWeakRelations = relations;
6398}
6399
6400bool QgsVectorLayer::loadAuxiliaryLayer( const QgsAuxiliaryStorage &storage, const QString &key )
6401{
6403
6404 bool rc = false;
6405
6406 QString joinKey = mAuxiliaryLayerKey;
6407 if ( !key.isEmpty() )
6408 joinKey = key;
6409
6410 if ( storage.isValid() && !joinKey.isEmpty() )
6411 {
6412 QgsAuxiliaryLayer *alayer = nullptr;
6413
6414 int idx = fields().lookupField( joinKey );
6415
6416 if ( idx >= 0 )
6417 {
6418 alayer = storage.createAuxiliaryLayer( fields().field( idx ), this );
6419
6420 if ( alayer )
6421 {
6422 setAuxiliaryLayer( alayer );
6423 rc = true;
6424 }
6425 }
6426 }
6427
6428 return rc;
6429}
6430
6432{
6434
6435 mAuxiliaryLayerKey.clear();
6436
6437 if ( mAuxiliaryLayer )
6438 removeJoin( mAuxiliaryLayer->id() );
6439
6440 if ( alayer )
6441 {
6442 addJoin( alayer->joinInfo() );
6443
6444 if ( !alayer->isEditable() )
6445 alayer->startEditing();
6446
6447 mAuxiliaryLayerKey = alayer->joinInfo().targetFieldName();
6448 }
6449
6450 mAuxiliaryLayer.reset( alayer );
6451 if ( mAuxiliaryLayer )
6452 mAuxiliaryLayer->setParent( this );
6453 updateFields();
6454}
6455
6457{
6459
6460 return mAuxiliaryLayer.get();
6461}
6462
6464{
6466
6467 return mAuxiliaryLayer.get();
6468}
6469
6470QSet<QgsMapLayerDependency> QgsVectorLayer::dependencies() const
6471{
6473
6474 if ( mDataProvider )
6475 return mDataProvider->dependencies() + mDependencies;
6476 return mDependencies;
6477}
6478
6479void QgsVectorLayer::emitDataChanged()
6480{
6482
6483 if ( mDataChangedFired )
6484 return;
6485
6486 // If we are asked to fire dataChanged from a layer we depend on,
6487 // be sure that this layer is not in the process of committing its changes, because
6488 // we will be asked to fire dataChanged at the end of his commit, and we don't
6489 // want to fire this signal more than necessary.
6490 if ( QgsVectorLayer *layerWeDependUpon = qobject_cast<QgsVectorLayer *>( sender() ); layerWeDependUpon && layerWeDependUpon->mCommitChangesActive )
6491 return;
6492
6493 updateExtents(); // reset cached extent to reflect data changes
6494
6495 mDataChangedFired = true;
6496 emit dataChanged();
6497 mDataChangedFired = false;
6498}
6499
6500void QgsVectorLayer::onDependencyAfterCommitChanges()
6501{
6503
6504 if ( mDataProvider && mDataProvider->capabilities().testFlag( Qgis::VectorProviderCapability::CacheData ) )
6505 mDataProvider->reloadData();
6506 else
6507 emitDataChanged();
6508}
6509
6510bool QgsVectorLayer::setDependencies( const QSet<QgsMapLayerDependency> &oDeps )
6511{
6513
6514 QSet<QgsMapLayerDependency> deps;
6515 const auto constODeps = oDeps;
6516 for ( const QgsMapLayerDependency &dep : constODeps )
6517 {
6518 if ( dep.origin() == QgsMapLayerDependency::FromUser )
6519 deps << dep;
6520 }
6521
6522 QSet<QgsMapLayerDependency> toAdd = deps - dependencies();
6523
6524 // disconnect layers that are not present in the list of dependencies anymore
6525 if ( QgsProject *p = project() )
6526 {
6527 for ( const QgsMapLayerDependency &dep : std::as_const( mDependencies ) )
6528 {
6529 QgsVectorLayer *lyr = static_cast<QgsVectorLayer *>( p->mapLayer( dep.layerId() ) );
6530 if ( !lyr )
6531 continue;
6532 disconnect( lyr, &QgsVectorLayer::featureAdded, this, &QgsVectorLayer::emitDataChanged );
6533 disconnect( lyr, &QgsVectorLayer::featureDeleted, this, &QgsVectorLayer::emitDataChanged );
6534 disconnect( lyr, &QgsVectorLayer::geometryChanged, this, &QgsVectorLayer::emitDataChanged );
6535 disconnect( lyr, &QgsVectorLayer::dataChanged, this, &QgsVectorLayer::emitDataChanged );
6537 disconnect( lyr, &QgsVectorLayer::afterCommitChanges, this, &QgsVectorLayer::onDependencyAfterCommitChanges );
6538 }
6539 }
6540
6541 // assign new dependencies
6542 if ( mDataProvider )
6543 mDependencies = mDataProvider->dependencies() + deps;
6544 else
6545 mDependencies = deps;
6546 emit dependenciesChanged();
6547
6548 // connect to new layers
6549 if ( QgsProject *p = project() )
6550 {
6551 for ( const QgsMapLayerDependency &dep : std::as_const( mDependencies ) )
6552 {
6553 QgsVectorLayer *lyr = static_cast<QgsVectorLayer *>( p->mapLayer( dep.layerId() ) );
6554 if ( !lyr )
6555 continue;
6556 connect( lyr, &QgsVectorLayer::featureAdded, this, &QgsVectorLayer::emitDataChanged );
6557 connect( lyr, &QgsVectorLayer::featureDeleted, this, &QgsVectorLayer::emitDataChanged );
6558 connect( lyr, &QgsVectorLayer::geometryChanged, this, &QgsVectorLayer::emitDataChanged );
6559 connect( lyr, &QgsVectorLayer::dataChanged, this, &QgsVectorLayer::emitDataChanged );
6561 connect( lyr, &QgsVectorLayer::afterCommitChanges, this, &QgsVectorLayer::onDependencyAfterCommitChanges );
6562 }
6563 }
6564
6565 // if new layers are present, emit a data change
6566 if ( !toAdd.isEmpty() )
6567 emitDataChanged();
6568
6569 return true;
6570}
6571
6573{
6575
6576 if ( fieldIndex < 0 || fieldIndex >= mFields.count() || !mDataProvider )
6578
6579 QgsFieldConstraints::Constraints constraints = mFields.at( fieldIndex ).constraints().constraints();
6580
6581 // make sure provider constraints are always present!
6582 if ( mFields.fieldOrigin( fieldIndex ) == Qgis::FieldOrigin::Provider )
6583 {
6584 constraints |= mDataProvider->fieldConstraints( mFields.fieldOriginIndex( fieldIndex ) );
6585 }
6586
6587 return constraints;
6588}
6589
6590QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength> QgsVectorLayer::fieldConstraintsAndStrength( int fieldIndex ) const
6591{
6593
6594 QMap< QgsFieldConstraints::Constraint, QgsFieldConstraints::ConstraintStrength > m;
6595
6596 if ( fieldIndex < 0 || fieldIndex >= mFields.count() )
6597 return m;
6598
6599 QString name = mFields.at( fieldIndex ).name();
6600
6601 QMap< QPair< QString, QgsFieldConstraints::Constraint >, QgsFieldConstraints::ConstraintStrength >::const_iterator conIt = mFieldConstraintStrength.constBegin();
6602 for ( ; conIt != mFieldConstraintStrength.constEnd(); ++conIt )
6603 {
6604 if ( conIt.key().first == name )
6605 {
6606 m[conIt.key().second] = mFieldConstraintStrength.value( conIt.key() );
6607 }
6608 }
6609
6610 return m;
6611}
6612
6614{
6616
6617 if ( index < 0 || index >= mFields.count() )
6618 return;
6619
6620 QString name = mFields.at( index ).name();
6621
6622 // add constraint to existing constraints
6623 QgsFieldConstraints::Constraints constraints = mFieldConstraints.value( name, QgsFieldConstraints::Constraints() );
6624 constraints |= constraint;
6625 mFieldConstraints.insert( name, constraints );
6626
6627 mFieldConstraintStrength.insert( qMakePair( name, constraint ), strength );
6628
6629 updateFields();
6630}
6631
6633{
6635
6636 if ( index < 0 || index >= mFields.count() )
6637 return;
6638
6639 QString name = mFields.at( index ).name();
6640
6641 // remove constraint from existing constraints
6642 QgsFieldConstraints::Constraints constraints = mFieldConstraints.value( name, QgsFieldConstraints::Constraints() );
6643 constraints &= ~constraint;
6644 mFieldConstraints.insert( name, constraints );
6645
6646 mFieldConstraintStrength.remove( qMakePair( name, constraint ) );
6647
6648 updateFields();
6649}
6650
6652{
6654
6655 if ( index < 0 || index >= mFields.count() )
6656 return QString();
6657
6658 return mFields.at( index ).constraints().constraintExpression();
6659}
6660
6662{
6664
6665 if ( index < 0 || index >= mFields.count() )
6666 return QString();
6667
6668 return mFields.at( index ).constraints().constraintDescription();
6669}
6670
6671void QgsVectorLayer::setConstraintExpression( int index, const QString &expression, const QString &description )
6672{
6674
6675 if ( index < 0 || index >= mFields.count() )
6676 return;
6677
6678 if ( expression.isEmpty() )
6679 {
6680 mFieldConstraintExpressions.remove( mFields.at( index ).name() );
6681 }
6682 else
6683 {
6684 mFieldConstraintExpressions.insert( mFields.at( index ).name(), qMakePair( expression, description ) );
6685 }
6686 updateFields();
6687}
6688
6690{
6692
6693 if ( index < 0 || index >= mFields.count() )
6694 return;
6695
6696 mFieldConfigurationFlags.insert( mFields.at( index ).name(), flags );
6697 updateFields();
6698}
6699
6701{
6703
6704 if ( index < 0 || index >= mFields.count() )
6705 return;
6706 Qgis::FieldConfigurationFlags flags = mFields.at( index ).configurationFlags();
6707 flags.setFlag( flag, active );
6709}
6710
6712{
6714
6715 if ( index < 0 || index >= mFields.count() )
6717
6718 return mFields.at( index ).configurationFlags();
6719}
6720
6722{
6724
6725 if ( index < 0 || index >= mFields.count() )
6726 return;
6727
6728 if ( setup.isNull() )
6729 mFieldWidgetSetups.remove( mFields.at( index ).name() );
6730 else
6731 mFieldWidgetSetups.insert( mFields.at( index ).name(), setup );
6732 updateFields();
6733}
6734
6736{
6738
6739 if ( index < 0 || index >= mFields.count() )
6740 return QgsEditorWidgetSetup();
6741
6742 return mFields.at( index ).editorWidgetSetup();
6743}
6744
6745std::unique_ptr<QgsAbstractVectorLayerLabeling> QgsVectorLayer::readLabelingFromCustomProperties()
6746{
6748
6749 std::unique_ptr<QgsAbstractVectorLayerLabeling> labeling;
6750 if ( customProperty( u"labeling"_s ).toString() == "pal"_L1 )
6751 {
6752 if ( customProperty( u"labeling/enabled"_s, QVariant( false ) ).toBool() )
6753 {
6754 // try to load from custom properties
6755 QgsPalLayerSettings settings;
6756 settings.readFromLayerCustomProperties( this );
6757 labeling = std::make_unique<QgsVectorLayerSimpleLabeling>( settings );
6758 }
6759
6760 // also clear old-style labeling config
6761 removeCustomProperty( u"labeling"_s );
6762 const auto constCustomPropertyKeys = customPropertyKeys();
6763 for ( const QString &key : constCustomPropertyKeys )
6764 {
6765 if ( key.startsWith( "labeling/"_L1 ) )
6766 removeCustomProperty( key );
6767 }
6768 }
6769
6770 return labeling;
6771}
6772
6774{
6776
6777 return mAllowCommit;
6778}
6779
6781{
6783
6784 if ( mAllowCommit == allowCommit )
6785 return;
6786
6787 mAllowCommit = allowCommit;
6788 emit allowCommitChanged();
6789}
6790
6792{
6794
6795 return mGeometryOptions.get();
6796}
6797
6804
6806{
6808
6809 return mReadExtentFromXml;
6810}
6811
6812void QgsVectorLayer::onDirtyTransaction( const QString &sql, const QString &name )
6813{
6815
6817 if ( tr && mEditBuffer )
6818 {
6819 qobject_cast<QgsVectorLayerEditPassthrough *>( mEditBuffer )->update( tr, sql, name );
6820 }
6821}
6822
6823QList<QgsVectorLayer *> QgsVectorLayer::DeleteContext::handledLayers( bool includeAuxiliaryLayers ) const
6824{
6825 QList<QgsVectorLayer *> layers;
6826 QMap<QgsVectorLayer *, QgsFeatureIds>::const_iterator i;
6827 for ( i = mHandledFeatures.begin(); i != mHandledFeatures.end(); ++i )
6828 {
6829 if ( includeAuxiliaryLayers || !qobject_cast< QgsAuxiliaryLayer * >( i.key() ) )
6830 layers.append( i.key() );
6831 }
6832 return layers;
6833}
6834
Provides global constants and enumerations for use throughout the application.
Definition qgis.h:62
@ Action
Map layers' action.
Definition qgis.h:486
@ FormInitCode
Attribute forms' initiation code.
Definition qgis.h:487
@ SelectAtId
Fast access to features using their ID.
Definition qgis.h:553
@ CacheData
Provider caches source data and should force provider data reloads when dependent layers are committe...
Definition qgis.h:571
@ CreateRenderer
Provider can create feature renderers using backend-specific formatting information....
Definition qgis.h:567
@ CreateLabeling
Provider can set labeling settings using backend-specific formatting information. Since QGIS 3....
Definition qgis.h:568
@ ReadLayerMetadata
Provider can read layer metadata from data store. Since QGIS 3.0. See QgsDataProvider::layerMetadata(...
Definition qgis.h:564
@ DeleteFeatures
Allows deletion of features.
Definition qgis.h:548
QFlags< VectorRenderingSimplificationFlag > VectorRenderingSimplificationFlags
Simplification flags for vector feature rendering.
Definition qgis.h:3281
@ Composition
Fix relation, related elements are part of the parent and a parent copy will copy any children or del...
Definition qgis.h:4919
@ Association
Loose relation, related elements are not part of the parent and a parent copy will not copy any child...
Definition qgis.h:4918
GeometryOperationResult
Success or failure of a geometry operation.
Definition qgis.h:2212
@ InvalidInputGeometryType
The input geometry (ring, part, split line, etc.) has not the correct geometry type.
Definition qgis.h:2216
@ Success
Operation succeeded.
Definition qgis.h:2213
@ SelectionIsEmpty
No features were selected.
Definition qgis.h:2217
@ AddRingNotInExistingFeature
The input ring doesn't have any existing ring to fit into.
Definition qgis.h:2228
@ AddRingNotClosed
The input ring is not closed.
Definition qgis.h:2225
@ SelectionIsGreaterThanOne
More than one features were selected.
Definition qgis.h:2218
@ LayerNotEditable
Cannot edit layer.
Definition qgis.h:2220
SpatialIndexPresence
Enumeration of spatial index presence states.
Definition qgis.h:619
@ Unknown
Spatial index presence cannot be determined, index may or may not exist.
Definition qgis.h:620
VectorRenderingSimplificationFlag
Simplification flags for vector feature rendering.
Definition qgis.h:3266
@ NoSimplification
No simplification can be applied.
Definition qgis.h:3267
@ OverPoint
Arranges candidates over a point (or centroid of a polygon), or at a preset offset from the point....
Definition qgis.h:1309
@ Curved
Arranges candidates following the curvature of a line feature. Applies to line layers only.
Definition qgis.h:1311
@ AroundPoint
Arranges candidates in a circle around a point (or centroid of a polygon). Applies to point or polygo...
Definition qgis.h:1308
@ Line
Arranges candidates parallel to a generalised line representing the feature or parallel to a polygon'...
Definition qgis.h:1310
@ Horizontal
Arranges horizontal candidates scattered throughout a polygon feature or along a line feature....
Definition qgis.h:1312
@ PerimeterCurved
Arranges candidates following the curvature of a polygon's boundary. Applies to polygon layers only.
Definition qgis.h:1315
QFlags< VectorLayerTypeFlag > VectorLayerTypeFlags
Vector layer type flags.
Definition qgis.h:460
VectorSimplificationAlgorithm
Simplification algorithms for vector features.
Definition qgis.h:3250
@ Distance
The simplification uses the distance between points to remove duplicate points.
Definition qgis.h:3251
@ File
Load the Python code from an external file.
Definition qgis.h:6350
@ Environment
Use the Python code available in the Python environment.
Definition qgis.h:6352
@ NoSource
Do not use Python code at all.
Definition qgis.h:6349
@ Dialog
Use the Python code provided in the dialog.
Definition qgis.h:6351
@ ExactIntersect
Use exact geometry intersection (slower) instead of bounding boxes.
Definition qgis.h:2382
@ SubsetOfAttributes
Fetch only a subset of attributes (setSubsetOfAttributes sets this flag).
Definition qgis.h:2381
@ NoGeometry
Geometry is not required. It may still be returned if e.g. required for a filter condition.
Definition qgis.h:2380
@ FastExtent3D
Provider's 3D extent retrieval via QgsDataProvider::extent3D() is always guaranteed to be trivial/fas...
Definition qgis.h:2497
@ FastExtent2D
Provider's 2D extent retrieval via QgsDataProvider::extent() is always guaranteed to be trivial/fast ...
Definition qgis.h:2496
@ AutomaticGroups
Automatic transactional editing means that on supported datasources (postgres and geopackage database...
Definition qgis.h:4246
@ BufferedGroups
Buffered transactional editing means that all editable layers in the buffered transaction group are t...
Definition qgis.h:4247
@ Mac
MacOS specific.
Definition qgis.h:5230
@ OpenUrl
Open URL action.
Definition qgis.h:5233
@ Unix
Unix specific.
Definition qgis.h:5232
@ SubmitUrlMultipart
POST data to an URL using "multipart/form-data".
Definition qgis.h:5235
@ Windows
Windows specific.
Definition qgis.h:5231
@ SubmitUrlEncoded
POST data to an URL, using "application/x-www-form-urlencoded" or "application/json" if the body is v...
Definition qgis.h:5234
FieldDomainMergePolicy
Merge policy for field domains.
Definition qgis.h:4198
@ UnsetField
Clears the field value so that the data provider backend will populate using any backend triggers or ...
Definition qgis.h:4202
FieldDomainSplitPolicy
Split policy for field domains.
Definition qgis.h:4181
@ Duplicate
Duplicate original value.
Definition qgis.h:4183
BlendMode
Blending modes defining the available composition modes that can be used when painting.
Definition qgis.h:5497
@ AboveRight
Above right.
Definition qgis.h:1398
@ BelowLeft
Below left.
Definition qgis.h:1402
@ Above
Above center.
Definition qgis.h:1397
@ BelowRight
Below right.
Definition qgis.h:1404
@ Right
Right middle.
Definition qgis.h:1401
@ AboveLeft
Above left.
Definition qgis.h:1396
@ Below
Below center.
Definition qgis.h:1403
@ Over
Center middle.
Definition qgis.h:1400
GeometryType
The geometry types are used to group Qgis::WkbType in a coarse way.
Definition qgis.h:399
@ Point
Points.
Definition qgis.h:400
@ Line
Lines.
Definition qgis.h:401
@ Polygon
Polygons.
Definition qgis.h:402
@ Unknown
Unknown types.
Definition qgis.h:403
@ Null
No geometry.
Definition qgis.h:404
@ Generated
A generated relation is a child of a polymorphic relation.
Definition qgis.h:4905
@ Normal
A normal relation.
Definition qgis.h:4904
FieldDuplicatePolicy
Duplicate policy for fields.
Definition qgis.h:4218
@ Duplicate
Duplicate original value.
Definition qgis.h:4220
static const float DEFAULT_MAPTOPIXEL_THRESHOLD
Default threshold between map coordinates and device coordinates for map2pixel simplification.
Definition qgis.h:7360
QFlags< DataProviderReadFlag > DataProviderReadFlags
Flags which control data provider construction.
Definition qgis.h:532
FeatureAvailability
Possible return value for QgsFeatureSource::hasFeatures() to determine if a source is empty.
Definition qgis.h:638
@ FeaturesMaybeAvailable
There may be features available in this source.
Definition qgis.h:641
@ FeaturesAvailable
There is at least one feature available in this source.
Definition qgis.h:640
@ NoFeaturesAvailable
There are certainly no features available in this source.
Definition qgis.h:639
@ Vector
Vector layer.
Definition qgis.h:207
FieldOrigin
Field origin.
Definition qgis.h:1874
@ Provider
Field originates from the underlying data provider of the vector layer.
Definition qgis.h:1876
@ Edit
Field has been temporarily added in editing mode.
Definition qgis.h:1878
@ Unknown
The field origin has not been specified.
Definition qgis.h:1875
@ Expression
Field is calculated from an expression.
Definition qgis.h:1879
@ Join
Field originates from a joined layer.
Definition qgis.h:1877
RenderUnit
Rendering size units.
Definition qgis.h:5770
@ Points
Points (e.g., for font sizes).
Definition qgis.h:5775
@ Pixels
Pixels.
Definition qgis.h:5773
@ LoadDefaultStyle
Reset the layer's style to the default for the datasource.
Definition qgis.h:515
@ ForceReadOnly
Open layer in a read-only mode.
Definition qgis.h:518
Aggregate
Available aggregates to calculate.
Definition qgis.h:6651
VertexMarkerType
Editing vertex markers, used for showing vertices during a edit operation.
Definition qgis.h:2003
@ NoMarker
No marker.
Definition qgis.h:2006
@ SemiTransparentCircle
Semi-transparent circle marker.
Definition qgis.h:2004
@ Cross
Cross marker.
Definition qgis.h:2005
VectorEditResult
Specifies the result of a vector layer edit operation.
Definition qgis.h:1988
@ EmptyGeometry
Edit operation resulted in an empty geometry.
Definition qgis.h:1990
@ Success
Edit operation was successful.
Definition qgis.h:1989
@ InvalidLayer
Edit failed due to invalid layer.
Definition qgis.h:1993
WkbType
The WKB type describes the number of dimensions a geometry has.
Definition qgis.h:314
@ Unknown
Unknown.
Definition qgis.h:315
FieldConfigurationFlag
Configuration flags for fields These flags are meant to be user-configurable and are not describing a...
Definition qgis.h:1891
@ HideFromWfs
Field is not available if layer is served as WFS from QGIS server.
Definition qgis.h:1895
@ NoFlag
No flag is defined.
Definition qgis.h:1892
@ HideFromWms
Field is not available if layer is served as WMS from QGIS server.
Definition qgis.h:1894
@ AllowOverlapIfRequired
Avoids overlapping labels when possible, but permit overlaps if labels for features cannot otherwise ...
Definition qgis.h:1270
QFlags< FieldConfigurationFlag > FieldConfigurationFlags
Configuration flags for fields These flags are meant to be user-configurable and are not describing a...
Definition qgis.h:1906
@ AlwaysAllowUpsideDown
Show upside down for all labels, including dynamic ones.
Definition qgis.h:1466
SelectBehavior
Specifies how a selection should be applied.
Definition qgis.h:1941
@ SetSelection
Set selection, removing any existing selection.
Definition qgis.h:1942
@ AddToSelection
Add selection to current selection.
Definition qgis.h:1943
@ IntersectSelection
Modify current selection to include only select features which match.
Definition qgis.h:1944
@ RemoveFromSelection
Remove from current selection.
Definition qgis.h:1945
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...
static std::unique_ptr< QgsAbstractVectorLayerLabeling > create(const QDomElement &element, const QgsReadWriteContext &context)
Try to create instance of an implementation based on the XML data.
Storage and management of actions associated with a layer.
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.
Utility class that encapsulates an action based on vector attributes.
Definition qgsaction.h:38
Utility class for calculating aggregates for a field (or expression) over the features from a vector ...
static QgsNetworkContentFetcherRegistry * networkContentFetcherRegistry()
Returns the application's network content registry used for fetching temporary files during QGIS sess...
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.
A container for configuration of the attribute table.
void update(const QgsFields &fields)
Update the configuration with the given fields.
A vector of attributes.
Allows managing the auxiliary storage for a vector layer.
QgsVectorLayerJoinInfo joinInfo() const
Returns information to use for joining with primary key and so on.
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:45
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:326
bool isEmpty() const
Returns true if the box is empty, i.e.
Definition qgsbox3d.cpp:321
Holds conditional style information for a layer.
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.
Curve polygon geometry type.
Abstract base class for curved geometry type.
Definition qgscurve.h:36
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 QString dataSourceUri(bool expandAuthConfig=false) const
Gets the data source specification.
Stores the component parts of a data source URI (e.g.
bool useEstimatedMetadata() const
Returns true if estimated metadata should be used for the connection.
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.
Evaluates and returns the diagram settings relating to a diagram for a specific feature.
Contains configuration settings for an editor form.
Holder for the widget type and its configuration for a field.
QVariantMap config() const
Returns the widget configuration.
bool isNull() const
Returns true if there is no widget configured.
A embedded script entity for QgsObjectEntityVisitorInterface.
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 std::unique_ptr< QgsExpressionContextScope > layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
static std::vector< std::unique_ptr< QgsExpressionContextScope > > globalProjectLayerScopes(const QgsMapLayer *layer)
Creates a list of three scopes: global, layer's project and layer.
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 writeXml(QDomNode &layer_node, QDomDocument &document) const
Saves expressions to xml under the layer node.
An expression node which takes its value from a feature's field.
QString name() const
The name of the column.
Handles 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 evalErrorString() const
Returns evaluation 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 std::unique_ptr< QgsFeatureRenderer > load(QDomElement &symbologyElem, const QgsReadWriteContext &context)
create a renderer from XML element
static std::unique_ptr< 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 ...
static std::unique_ptr< QgsFeatureRenderer > defaultRenderer(Qgis::GeometryType geomType)
Returns a new renderer - used by default in vector layers.
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 & setFilterFid(QgsFeatureId fid)
Sets the feature ID that should be fetched.
QFlags< Flag > Flags
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:60
Q_INVOKABLE bool setAttribute(int field, const QVariant &attr)
Sets an attribute's value by field index.
QgsAttributes attributes
Definition qgsfeature.h:64
QgsFields fields
Definition qgsfeature.h:65
QgsFeatureId id
Definition qgsfeature.h:63
QgsGeometry geometry
Definition qgsfeature.h:66
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:56
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 ...
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().
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:56
QString typeName() const
Gets the field type.
Definition qgsfield.cpp:158
QString name
Definition qgsfield.h:65
int precision
Definition qgsfield.h:62
int length
Definition qgsfield.h:61
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 alias
Definition qgsfield.h:66
QString customComment
Definition qgsfield.h:71
QString comment
Definition qgsfield.h:64
Container of fields for a vector layer.
Definition qgsfields.h:45
int count
Definition qgsfields.h:49
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).
Q_INVOKABLE int lookupField(const QString &fieldName) const
Looks up field's index from the field name.
const_iterator constBegin() const noexcept
Returns a const STL-style iterator pointing to the first item in the list.
Contains options to automatically adjust geometries to constraints on a layer.
A geometry is the spatial representation of a feature.
bool isExactlyEqual(const QgsGeometry &geometry, Qgis::GeometryBackend backend=Qgis::GeometryBackend::QGIS) const
Compares the geometry with another geometry using the specified backend.
QgsBox3D boundingBox3D() const
Returns the 3D bounding box of the 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.
void setQuadrant(Qgis::LabelQuadrantPosition quadrant)
Sets the quadrant in which to offset labels from the point.
Formats layer metadata into HTML.
void combine(const QgsAbstractMetadataBase *other) override
Combines the metadata from this object with the metadata from an other object.
bool hasMaximumScale() const
Returns true if maximum scale is set.
double maximumScale() const
Returns maximum scale denominator.
bool hasMinimumScale() const
Returns true if minimum scale is set.
bool hasLayerOpacity() const
Returns true if layer opacity is set.
double layerOpacity() const
Returns layer opacity in the range [0, 1].
double minimumScale() const
Returns minimum scale denominator.
Line string geometry type, with support for z-dimension and m-values.
static void warning(const QString &msg)
Goes to qWarning.
Models dependencies with or between map layers.
@ DataDependency
The layer may be invalidated by data changes on another layer.
@ PresenceDependency
The layer must be already present (in the registry) for this dependency to be resolved.
@ FromUser
Dependency given by the user.
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 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.
QString name
Definition qgsmaplayer.h:88
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 Q_INVOKABLE 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...
void editingStarted()
Emitted when editing on this layer has started.
QgsCoordinateReferenceSystem crs
Definition qgsmaplayer.h:91
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.
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:90
QgsMapLayer(Qgis::LayerType type=Qgis::LayerType::Vector, const QString &name=QString(), const QString &source=QString())
Constructor for QgsMapLayer.
Qgis::LayerType type
Definition qgsmaplayer.h:94
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.
QgsMapLayer::LayerFlags flags
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:98
void setLegend(QgsMapLayerLegend *legend)
Assign a legend controller to the map layer.
double opacity
Definition qgsmaplayer.h:96
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:97
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(), Qgis::StringFormat format=Qgis::StringFormat::PlainText)
Adds a message to the log instance (and creates it if necessary).
QFile * localFile(const QString &filePathOrUrl)
Returns a QFile from a local file or to a temporary file previously fetched by the registry.
An interface for classes which can visit various object entity (e.g.
virtual bool visitEmbeddedScript(const QgsEmbeddedScriptEntity &entity, const QgsObjectVisitorContext &context)
Called when the visitor will visit an embedded script entity.
A QgsObjectEntityVisitorInterface context object.
static std::unique_ptr< 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.
const QgsLabelPointSettings & pointSettings() const
Returns the label point settings, which contain settings related to how the label engine places and f...
Represents a 2D point.
Definition qgspointxy.h:62
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:53
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:114
QgsRelationManager * relationManager
Definition qgsproject.h:125
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< QPair< QString, QString >, QgsTransactionGroup * > transactionGroups()
Map of transaction groups.
A grouped map of multiple QgsProperty objects, each referenced by an 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:47
@ Double
Double value (including negative values).
Definition qgsproperty.h:56
@ Boolean
Boolean value.
Definition qgsproperty.h:52
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.
A container for the context for various read/write operations on objects.
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 rounded to the spec...
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:42
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.
void appendChild(QgsRuleBasedLabeling::Rule *rule)
add child rule, take ownership, sets this as parent
A boolean settings entry.
A double settings entry.
A template class for enum and flag settings entry.
static QgsSettingsTreeNode * sTreeQgis
Holds SLD export options and other information related to SLD export of a QGIS layer style.
void setExtraProperties(const QVariantMap &properties)
Sets the open ended set of properties that can drive/inform the SLD encoding.
QVariantMap extraProperties() const
Returns the open ended set of properties that can drive/inform the SLD encoding.
Manages stored expressions regarding creation, modification and storing in the project.
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....
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.
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.
static QString threadDescription(QThread *thread)
Returns a descriptive identifier for a thread.
QSet< QgsVectorLayer * > layers() const
Gets the set of layers currently managed by this transaction group.
Allows creation of a multi-layer database-side transaction.
QString connectionString() const
Returns the connection string of the transaction.
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.
Base class for vector data providers.
static const int EditingCapabilities
Bitmask of all provider's editing capabilities.
virtual QString geometryColumnName() const
Returns the name of the column storing geometry, if applicable.
void raiseError(const QString &msg) const
Signals an error in this provider.
virtual void handlePostCloneOperations(QgsVectorDataProvider *source)
Handles any post-clone operations required after this vector data provider was cloned from the source...
virtual QgsTransaction * transaction() const
Returns the transaction this data provider is included in, if any.
void committedAttributesDeleted(const QString &layerId, const QgsAttributeList &deletedAttributes)
Emitted after attribute deletion has been committed to the layer.
void committedAttributeValuesChanges(const QString &layerId, const QgsChangedAttributesMap &changedAttributesValues)
Emitted after feature attribute value changes have been committed to the layer.
void geometryChanged(QgsFeatureId fid, const QgsGeometry &geom)
Emitted when a feature's geometry is changed.
void committedAttributesAdded(const QString &layerId, const QList< QgsField > &addedAttributes)
Emitted after attribute addition has been committed to the layer.
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.
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.
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.
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.
Qgis::VectorEditResult deleteVertices(QgsFeatureId featureId, const QSet< int > &vertices)
Deletes a set of vertices from a feature.
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.
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.
QgsVectorLayerElevationProperties * clone() const override
Creates a clone of the properties.
Counts the features in a QgsVectorLayer in task.
A feature iterator which iterates over features from a QgsVectorLayer.
Manages joined fields for a vector layer.
bool containsJoins() const
Quick way to test if there is any join at all.
void joinedFieldsChanged()
Emitted whenever the list of joined fields changes (e.g.
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.
Implementation of map layer temporal properties for vector layers.
Contains settings which reflect the context in which vector layer tool operations should be considere...
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...
static QgsFeatureIds filterValidFeatureIds(const QgsVectorLayer *layer, const QgsFeatureIds &featureIds)
Filters a set of feature IDs to only include those that exist in the layer.
Represents a vector layer which manages a vector based dataset.
void setLabeling(QgsAbstractVectorLayerLabeling *labeling)
Sets labeling configuration.
Q_INVOKABLE QString attributeDisplayName(int index) const
Convenience function that returns the attribute alias if defined or the field name else.
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.
QSet< QgsMapLayerDependency > dependencies() const final
Gets the list of dependencies.
int addExpressionField(const QString &exp, const QgsField &fld)
Add a new field which is calculated by the expression specified.
Q_INVOKABLE void selectByRect(const QgsRectangle &rect, Qgis::SelectBehavior behavior=Qgis::SelectBehavior::SetSelection)
Selects features found within the search rectangle (in layer's coordinates).
void committedFeaturesAdded(const QString &layerId, const QgsFeatureList &addedFeatures)
Emitted when features are added to the provider if not in transaction mode.
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
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 isModified() const override
Returns true if the provider has been modified since the last commit.
bool isEditable() const final
Returns true if the provider is in editing mode.
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 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.
Q_INVOKABLE QVariant minimumValue(int index) const final
Returns the minimum value for an attribute column or an invalid variant in case of error.
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).
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.
Q_INVOKABLE QVariant maximumValue(int index) const final
Returns the maximum value for an attribute column or an invalid variant in case of error.
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.
QgsVectorLayer(const QString &path=QString(), const QString &baseName=QString(), const QString &providerLib="ogr", const QgsVectorLayer::LayerOptions &options=QgsVectorLayer::LayerOptions())
Constructor - creates a vector layer.
QgsMapLayerTemporalProperties * temporalProperties() override
Returns the layer's temporal properties.
QgsExpressionContext createExpressionContext() const final
This method needs to be reimplemented in all classes which implement this interface and return an exp...
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.
QgsVectorLayerFeatureCounter * countSymbolFeatures(bool storeSymbolFids=false)
Count features for symbols.
Q_INVOKABLE QString attributeCustomComment(int index) const
Returns the custom comment for the field.
QPainter::CompositionMode featureBlendMode() const
Returns the current blending mode for features.
QString constraintExpression(int index) const
Returns the constraint expression for for a specified field index, if set.
Q_INVOKABLE 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,...
QgsBox3D extent3D() const final
Returns the 3D extent of the layer.
const QgsDiagramLayerSettings * diagramLayerSettings() const
void setFieldConstraint(int index, QgsFieldConstraints::Constraint constraint, QgsFieldConstraints::ConstraintStrength strength=QgsFieldConstraints::ConstraintStrengthHard)
Sets a constraint for a specified field index.
Q_INVOKABLE void invertSelectionInRectangle(const QgsRectangle &rect)
Inverts selection of features found within the search rectangle (in layer's coordinates).
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...
QgsAbstractProfileGenerator * createProfileGenerator(const QgsProfileRequest &request) override
Given a profile request, returns a new profile generator ready for generating elevation profiles.
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.
Q_INVOKABLE QgsRectangle boundingBoxOfSelected() const
Returns the bounding box of the selected features. If there is no selection, QgsRectangle(0,...
bool isSpatial() const final
Returns true if this is a geometry layer and false in case of NoGeometry (table only) or UnknownGeome...
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.
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.
QgsRectangle sourceExtent() const final
Returns the extent of all geometries from the source.
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.
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.
bool setDependencies(const QSet< QgsMapLayerDependency > &layers) final
Sets the list of dependencies.
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 setFieldMergePolicy(int index, Qgis::FieldDomainMergePolicy policy)
Sets a merge policy for the field with the specified index.
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
void reload() final
Synchronises with changes in the datasource.
long long featureCount() const final
Returns feature count including changes which have not yet been committed If you need only the count ...
~QgsVectorLayer() override
QgsRectangle extent() const final
Returns the extent of the layer.
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.
bool hasMapTips() const final
Returns true if the layer contains map tips.
Q_INVOKABLE Qgis::WkbType wkbType() const final
Returns the WKBType or WKBUnknown in case of error.
void setExtent(const QgsRectangle &rect) final
Sets the extent.
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.
QgsBox3D sourceExtent3D() const final
Returns the 3D extent of all geometries from the source.
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.
Qgis::FeatureAvailability hasFeatures() const final
Determines if this vector layer has features.
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.
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 setProviderEncoding(const QString &encoding)
Sets the text encoding of the data provider.
Q_DECL_DEPRECATED 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 Q_INVOKABLE bool deleteAttribute(int attr)
Deletes an attribute field (but does not commit it).
static const QgsSettingsEntryBool * settingsSimplifyLocal
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...
bool simplifyDrawingCanbeApplied(const QgsRenderContext &renderContext, Qgis::VectorRenderingSimplificationFlag simplifyHint) const
Returns whether the VectorLayer can apply the specified simplification hint.
QString htmlMetadata() const final
Obtain a formatted HTML string containing assorted metadata for this layer.
QgsMapLayerElevationProperties * elevationProperties() override
Returns the layer's elevation properties.
bool removeJoin(const QString &joinLayerId)
Removes a vector layer join.
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.
QStringList commitErrors() const
Returns a list containing any error messages generated when attempting to commit changes to the layer...
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...
QString storageType() const
Returns the permanent storage type for this layer as a friendly name.
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...
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
QgsExpressionContextScope * createExpressionContextScope() const final
This method needs to be reimplemented in all classes which implement this interface and return an exp...
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.
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.
QgsStringMap attributeCustomComments() const
Returns a map of all the custom comments.
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.
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.
QString sourceName() const final
Returns a friendly display name for the source.
Qgis::VectorEditResult deleteVertices(QgsFeatureId featureId, const QSet< int > &vertices)
Deletes a set of vertices from a feature.
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.
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 resolveReferences(QgsProject *project) final
Resolves references to other layers (kept as layer IDs after reading XML) into layer objects.
void reselect()
Reselects the previous set of selected features.
Q_INVOKABLE 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.
bool readSld(const QDomNode &node, QString &errorMessage) final
QgsMapLayerRenderer * createMapRenderer(QgsRenderContext &rendererContext) final
Returns new instance of QgsMapLayerRenderer that will be used for rendering of given context.
Q_INVOKABLE void setFieldCustomComment(int index, const QString &customCommentString)
Sets the custom comment for the field.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const final
Queries the layer for features specified in request.
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.
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.
QgsCoordinateReferenceSystem sourceCrs() const final
Returns the coordinate reference system for features in the source.
void readOnlyChanged()
Emitted when the read only state of this layer is changed.
void removeExpressionField(int index)
Removes an expression field.
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.
Q_INVOKABLE void selectByIds(const QgsFeatureIds &ids, Qgis::SelectBehavior behavior=Qgis::SelectBehavior::SetSelection, bool validateIds=false)
Selects matching features using a list of feature IDs.
Q_INVOKABLE 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.
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.
void afterRollBack()
Emitted after changes are rolled back.
bool writeXml(QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context) const final
Writes vector layer specific state to project file Dom node.
void setDiagramLayerSettings(const QgsDiagramLayerSettings &s)
bool readXml(const QDomNode &layer_node, QgsReadWriteContext &context) final
Reads vector layer specific state from project file Dom node.
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.
Q_INVOKABLE 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.
Q_INVOKABLE 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.
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 setExtent3D(const QgsBox3D &rect) final
Sets the extent.
const QList< QgsVectorLayerJoinInfo > vectorJoins() const
Q_INVOKABLE 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.
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.
bool addFeatures(QgsFeatureList &features, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) final
Adds a list of features to the sink.
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.
Q_INVOKABLE QSet< QVariant > uniqueValues(int fieldIndex, int limit=-1) const final
Calculates a list of unique values contained within an attribute in the layer.
Q_INVOKABLE void removeFieldCustomComment(int index)
Removes the custom comment for the field.
void beforeCommitChecks(bool stopEditing)
Emitted to trigger (geometry) checks to determine whether commits are allowed.
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.
bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags()) final
Adds a single feature to the sink.
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
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.
QgsVectorDataProvider * dataProvider() final
Returns the layer's data provider, it may be nullptr.
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
void setFieldSplitPolicy(int index, Qgis::FieldDomainSplitPolicy policy)
Sets a split policy for the field with the specified index.
@ 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 Q_INVOKABLE 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 Q_INVOKABLE 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.
Definition qgis.h:608
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:657
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:596
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:601
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:8104
QString qgsEnumValueToKey(const T &value, bool *returnOk=nullptr)
Returns the value for the given key of an enum.
Definition qgis.h:8085
QString qgsFlagValueToKeys(const T &value, bool *returnOk=nullptr)
Returns the value for the given keys of a flag.
Definition qgis.h:8143
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:8172
QMap< QString, QString > QgsStringMap
Definition qgis.h:8418
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
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:80
#define QgsDebugError(str)
Definition qgslogger.h:71
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
#define RENDERER_TAG_NAME
Definition qgsrenderer.h:57
#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.