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