QGIS API Documentation  3.27.0-Master (bef583a8ef)
qgsmaplayer.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgsmaplayer.cpp - description
3  -------------------
4  begin : Fri Jun 28 2002
5  copyright : (C) 2002 by Gary E.Sherman
6  email : sherman at mrcc.com
7 ***************************************************************************/
8 
9 /***************************************************************************
10  * *
11  * This program is free software; you can redistribute it and/or modify *
12  * it under the terms of the GNU General Public License as published by *
13  * the Free Software Foundation; either version 2 of the License, or *
14  * (at your option) any later version. *
15  * *
16  ***************************************************************************/
17 
18 
19 #include "qgssqliteutils.h"
20 #include "qgs3drendererregistry.h"
21 #include "qgsabstract3drenderer.h"
22 #include "qgsapplication.h"
24 #include "qgsdatasourceuri.h"
25 #include "qgsfileutils.h"
26 #include "qgslogger.h"
27 #include "qgsauthmanager.h"
28 #include "qgsmaplayer.h"
29 #include "qgsmaplayerlegend.h"
31 #include "qgsmeshlayer.h"
32 #include "qgspathresolver.h"
34 #include "qgsproject.h"
35 #include "qgsproviderregistry.h"
36 #include "qgsrasterlayer.h"
37 #include "qgsreadwritecontext.h"
38 #include "qgsrectangle.h"
39 #include "qgsvectorlayer.h"
40 #include "qgsvectordataprovider.h"
41 #include "qgsxmlutils.h"
42 #include "qgsstringutils.h"
43 #include "qgsmessagelog.h"
46 #include "qgsprovidermetadata.h"
47 #include "qgslayernotesutils.h"
48 #include "qgsdatums.h"
49 #include "qgsprojoperation.h"
50 
51 #include <QDir>
52 #include <QDomDocument>
53 #include <QDomElement>
54 #include <QDomImplementation>
55 #include <QDomNode>
56 #include <QFile>
57 #include <QFileInfo>
58 #include <QLocale>
59 #include <QTextStream>
60 #include <QUrl>
61 #include <QTimer>
62 #include <QStandardPaths>
63 #include <QUuid>
64 #include <QRegularExpression>
65 
66 #include <sqlite3.h>
67 
69 {
70  switch ( type )
71  {
72  case Metadata:
73  return QStringLiteral( ".qmd" );
74 
75  case Style:
76  return QStringLiteral( ".qml" );
77  }
78  return QString();
79 }
80 
82  const QString &lyrname,
83  const QString &source )
84  : mDataSource( source )
85  , mLayerName( lyrname )
86  , mLayerType( type )
87  , mServerProperties( std::make_unique<QgsMapLayerServerProperties>( this ) )
88  , mUndoStack( new QUndoStack( this ) )
89  , mUndoStackStyles( new QUndoStack( this ) )
90  , mStyleManager( new QgsMapLayerStyleManager( this ) )
91  , mRefreshTimer( new QTimer( this ) )
92 {
93  mID = generateId( lyrname );
94  connect( this, &QgsMapLayer::crsChanged, this, &QgsMapLayer::configChanged );
95  connect( this, &QgsMapLayer::nameChanged, this, &QgsMapLayer::configChanged );
96  connect( mRefreshTimer, &QTimer::timeout, this, [ = ] { triggerRepaint( true ); } );
97 }
98 
100 {
101  if ( project() && project()->pathResolver().writePath( mDataSource ).startsWith( "attachment:" ) )
102  {
104  }
105 
106  delete m3DRenderer;
107  delete mLegend;
108  delete mStyleManager;
109 }
110 
111 void QgsMapLayer::clone( QgsMapLayer *layer ) const
112 {
113  layer->setBlendMode( blendMode() );
114 
115  const auto constStyles = styleManager()->styles();
116  for ( const QString &s : constStyles )
117  {
118  layer->styleManager()->addStyle( s, styleManager()->style( s ) );
119  }
120 
121  layer->setName( name() );
122  layer->setShortName( shortName() );
123  layer->setExtent( extent() );
124  layer->setMaximumScale( maximumScale() );
125  layer->setMinimumScale( minimumScale() );
127  layer->setTitle( title() );
128  layer->setAbstract( abstract() );
129  layer->setKeywordList( keywordList() );
130  layer->setDataUrl( dataUrl() );
131  layer->setDataUrlFormat( dataUrlFormat() );
132  layer->setAttribution( attribution() );
133  layer->setAttributionUrl( attributionUrl() );
134  layer->setLegendUrl( legendUrl() );
136  layer->setDependencies( dependencies() );
138  layer->setCrs( crs() );
139  layer->setCustomProperties( mCustomProperties );
140  layer->setOpacity( mLayerOpacity );
141  layer->setMetadata( mMetadata );
142  layer->serverProperties()->copyTo( mServerProperties.get() );
143 }
144 
146 {
147  return mLayerType;
148 }
149 
150 QgsMapLayer::LayerFlags QgsMapLayer::flags() const
151 {
152  return mFlags;
153 }
154 
155 void QgsMapLayer::setFlags( QgsMapLayer::LayerFlags flags )
156 {
157  if ( flags == mFlags )
158  return;
159 
160  mFlags = flags;
161  emit flagsChanged();
162 }
163 
164 Qgis::MapLayerProperties QgsMapLayer::properties() const
165 {
166  return Qgis::MapLayerProperties();
167 }
168 
169 QString QgsMapLayer::id() const
170 {
171  return mID;
172 }
173 
174 void QgsMapLayer::setName( const QString &name )
175 {
176  if ( name == mLayerName )
177  return;
178 
179  mLayerName = name;
180 
181  emit nameChanged();
182 }
183 
184 QString QgsMapLayer::name() const
185 {
186  QgsDebugMsgLevel( "returning name '" + mLayerName + '\'', 4 );
187  return mLayerName;
188 }
189 
191 {
192  return nullptr;
193 }
194 
196 {
197  return nullptr;
198 }
199 
200 QString QgsMapLayer::shortName() const
201 {
202  return mShortName;
203 }
204 
205 void QgsMapLayer::setMetadataUrl( const QString &metaUrl )
206 {
207  QList<QgsMapLayerServerProperties::MetadataUrl> urls = serverProperties()->metadataUrls();
208  if ( urls.isEmpty() )
209  {
210  const QgsMapLayerServerProperties::MetadataUrl newItem = QgsMapLayerServerProperties::MetadataUrl( metaUrl, QLatin1String(), QLatin1String() );
211  urls.prepend( newItem );
212  }
213  else
214  {
215  const QgsMapLayerServerProperties::MetadataUrl old = urls.takeFirst();
216  const QgsMapLayerServerProperties::MetadataUrl newItem( metaUrl, old.type, old.format );
217  urls.prepend( newItem );
218  }
220 }
221 
223 {
224  if ( mServerProperties->metadataUrls().isEmpty() )
225  {
226  return QLatin1String();
227  }
228  else
229  {
230  return mServerProperties->metadataUrls().first().url;
231  }
232 }
233 
234 void QgsMapLayer::setMetadataUrlType( const QString &metaUrlType )
235 {
236  QList<QgsMapLayerServerProperties::MetadataUrl> urls = mServerProperties->metadataUrls();
237  if ( urls.isEmpty() )
238  {
239  const QgsMapLayerServerProperties::MetadataUrl newItem( QLatin1String(), metaUrlType, QLatin1String() );
240  urls.prepend( newItem );
241  }
242  else
243  {
244  const QgsMapLayerServerProperties::MetadataUrl old = urls.takeFirst();
245  const QgsMapLayerServerProperties::MetadataUrl newItem( old.url, metaUrlType, old.format );
246  urls.prepend( newItem );
247  }
248  mServerProperties->setMetadataUrls( urls );
249 }
250 
252 {
253  if ( mServerProperties->metadataUrls().isEmpty() )
254  {
255  return QLatin1String();
256  }
257  else
258  {
259  return mServerProperties->metadataUrls().first().type;
260  }
261 }
262 
263 void QgsMapLayer::setMetadataUrlFormat( const QString &metaUrlFormat )
264 {
265  QList<QgsMapLayerServerProperties::MetadataUrl> urls = mServerProperties->metadataUrls();
266  if ( urls.isEmpty() )
267  {
268  const QgsMapLayerServerProperties::MetadataUrl newItem( QLatin1String(), QLatin1String(), metaUrlFormat );
269  urls.prepend( newItem );
270  }
271  else
272  {
273  const QgsMapLayerServerProperties::MetadataUrl old = urls.takeFirst( );
274  const QgsMapLayerServerProperties::MetadataUrl newItem( old.url, old.type, metaUrlFormat );
275  urls.prepend( newItem );
276  }
277  mServerProperties->setMetadataUrls( urls );
278 }
279 
281 {
282  if ( mServerProperties->metadataUrls().isEmpty() )
283  {
284  return QString();
285  }
286  else
287  {
288  return mServerProperties->metadataUrls().first().format;
289  }
290 }
291 
293 {
294  // Redo this every time we're asked for it, as we don't know if
295  // dataSource has changed.
296  QString safeName = QgsDataSourceUri::removePassword( mDataSource );
297  return safeName;
298 }
299 
300 QString QgsMapLayer::source() const
301 {
302  return mDataSource;
303 }
304 
306 {
307  return mExtent;
308 }
309 
310 void QgsMapLayer::setBlendMode( const QPainter::CompositionMode blendMode )
311 {
312  if ( mBlendMode == blendMode )
313  return;
314 
315  mBlendMode = blendMode;
316  emit blendModeChanged( blendMode );
318 }
319 
320 QPainter::CompositionMode QgsMapLayer::blendMode() const
321 {
322  return mBlendMode;
323 }
324 
325 void QgsMapLayer::setOpacity( double opacity )
326 {
328  return;
330  emit opacityChanged( opacity );
332 }
333 
334 double QgsMapLayer::opacity() const
335 {
336  return mLayerOpacity;
337 }
338 
339 bool QgsMapLayer::readLayerXml( const QDomElement &layerElement, QgsReadWriteContext &context, QgsMapLayer::ReadFlags flags )
340 {
341  bool layerError;
342  mReadFlags = flags;
343 
344  QDomNode mnl;
345  QDomElement mne;
346 
347  // read provider
348  QString provider;
349  mnl = layerElement.namedItem( QStringLiteral( "provider" ) );
350  mne = mnl.toElement();
351  provider = mne.text();
352 
353  // set data source
354  mnl = layerElement.namedItem( QStringLiteral( "datasource" ) );
355  mne = mnl.toElement();
356  mDataSource = context.pathResolver().readPath( mne.text() );
357 
358  // if the layer needs authentication, ensure the master password is set
359  const thread_local QRegularExpression rx( "authcfg=([a-z]|[A-Z]|[0-9]){7}" );
360  if ( rx.match( mDataSource ).hasMatch()
362  {
363  return false;
364  }
365 
366  mDataSource = decodedSource( mDataSource, provider, context );
367 
368  // Set the CRS from project file, asking the user if necessary.
369  // Make it the saved CRS to have WMS layer projected correctly.
370  // We will still overwrite whatever GDAL etc picks up anyway
371  // further down this function.
372  mnl = layerElement.namedItem( QStringLiteral( "layername" ) );
373  mne = mnl.toElement();
374 
376  CUSTOM_CRS_VALIDATION savedValidation;
377 
378  const QDomNode srsNode = layerElement.namedItem( QStringLiteral( "srs" ) );
379  mCRS.readXml( srsNode );
380  mCRS.setValidationHint( tr( "Specify CRS for layer %1" ).arg( mne.text() ) );
382  mCRS.validate();
383  savedCRS = mCRS;
384 
385  // Do not validate any projections in children, they will be overwritten anyway.
386  // No need to ask the user for a projections when it is overwritten, is there?
389 
390  const QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Layer" ), mne.text() );
391 
392  // the internal name is just the data source basename
393  //QFileInfo dataSourceFileInfo( mDataSource );
394  //internalName = dataSourceFileInfo.baseName();
395 
396  // set ID
397  mnl = layerElement.namedItem( QStringLiteral( "id" ) );
398  if ( ! mnl.isNull() )
399  {
400  mne = mnl.toElement();
401  if ( ! mne.isNull() && mne.text().length() > 10 ) // should be at least 17 (yyyyMMddhhmmsszzz)
402  {
403  mID = mne.text();
404  }
405  }
406 
407  // set name
408  mnl = layerElement.namedItem( QStringLiteral( "layername" ) );
409  mne = mnl.toElement();
410 
411  //name can be translated
412  setName( context.projectTranslator()->translate( QStringLiteral( "project:layers:%1" ).arg( layerElement.namedItem( QStringLiteral( "id" ) ).toElement().text() ), mne.text() ) );
413 
414  // now let the children grab what they need from the Dom node.
415  layerError = !readXml( layerElement, context );
416 
417  // overwrite CRS with what we read from project file before the raster/vector
418  // file reading functions changed it. They will if projections is specified in the file.
419  // FIXME: is this necessary? Yes, it is (autumn 2019)
421  mCRS = savedCRS;
422 
423  //short name
424  const QDomElement shortNameElem = layerElement.firstChildElement( QStringLiteral( "shortname" ) );
425  if ( !shortNameElem.isNull() )
426  {
427  mShortName = shortNameElem.text();
428  }
429 
430  //title
431  const QDomElement titleElem = layerElement.firstChildElement( QStringLiteral( "title" ) );
432  if ( !titleElem.isNull() )
433  {
434  mTitle = titleElem.text();
435  }
436 
437  //abstract
438  const QDomElement abstractElem = layerElement.firstChildElement( QStringLiteral( "abstract" ) );
439  if ( !abstractElem.isNull() )
440  {
441  mAbstract = abstractElem.text();
442  }
443 
444  //keywordList
445  const QDomElement keywordListElem = layerElement.firstChildElement( QStringLiteral( "keywordList" ) );
446  if ( !keywordListElem.isNull() )
447  {
448  QStringList kwdList;
449  for ( QDomNode n = keywordListElem.firstChild(); !n.isNull(); n = n.nextSibling() )
450  {
451  kwdList << n.toElement().text();
452  }
453  mKeywordList = kwdList.join( QLatin1String( ", " ) );
454  }
455 
456  //dataUrl
457  const QDomElement dataUrlElem = layerElement.firstChildElement( QStringLiteral( "dataUrl" ) );
458  if ( !dataUrlElem.isNull() )
459  {
460  mDataUrl = dataUrlElem.text();
461  mDataUrlFormat = dataUrlElem.attribute( QStringLiteral( "format" ), QString() );
462  }
463 
464  //legendUrl
465  const QDomElement legendUrlElem = layerElement.firstChildElement( QStringLiteral( "legendUrl" ) );
466  if ( !legendUrlElem.isNull() )
467  {
468  mLegendUrl = legendUrlElem.text();
469  mLegendUrlFormat = legendUrlElem.attribute( QStringLiteral( "format" ), QString() );
470  }
471 
472  //attribution
473  const QDomElement attribElem = layerElement.firstChildElement( QStringLiteral( "attribution" ) );
474  if ( !attribElem.isNull() )
475  {
476  mAttribution = attribElem.text();
477  mAttributionUrl = attribElem.attribute( QStringLiteral( "href" ), QString() );
478  }
479 
480  serverProperties()->readXml( layerElement );
481 
482  if ( serverProperties()->metadataUrls().isEmpty() )
483  {
484  // metadataUrl is still empty, maybe it's a QGIS Project < 3.22
485  // keep for legacy
486  const QDomElement metaUrlElem = layerElement.firstChildElement( QStringLiteral( "metadataUrl" ) );
487  if ( !metaUrlElem.isNull() )
488  {
489  const QString url = metaUrlElem.text();
490  const QString type = metaUrlElem.attribute( QStringLiteral( "type" ), QString() );
491  const QString format = metaUrlElem.attribute( QStringLiteral( "format" ), QString() );
492  const QgsMapLayerServerProperties::MetadataUrl newItem( url, type, format );
493  mServerProperties->setMetadataUrls( QList<QgsMapLayerServerProperties::MetadataUrl>() << newItem );
494  }
495  }
496 
497  // mMetadata.readFromLayer( this );
498  const QDomElement metadataElem = layerElement.firstChildElement( QStringLiteral( "resourceMetadata" ) );
499  mMetadata.readMetadataXml( metadataElem );
500 
501  setAutoRefreshInterval( layerElement.attribute( QStringLiteral( "autoRefreshTime" ), QStringLiteral( "0" ) ).toInt() );
502  setAutoRefreshEnabled( layerElement.attribute( QStringLiteral( "autoRefreshEnabled" ), QStringLiteral( "0" ) ).toInt() );
503  setRefreshOnNofifyMessage( layerElement.attribute( QStringLiteral( "refreshOnNotifyMessage" ), QString() ) );
504  setRefreshOnNotifyEnabled( layerElement.attribute( QStringLiteral( "refreshOnNotifyEnabled" ), QStringLiteral( "0" ) ).toInt() );
505 
506  // geographic extent is read only if necessary
507  if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
508  {
509  const QDomNode wgs84ExtentNode = layerElement.namedItem( QStringLiteral( "wgs84extent" ) );
510  if ( !wgs84ExtentNode.isNull() )
511  mWgs84Extent = QgsXmlUtils::readRectangle( wgs84ExtentNode.toElement() );
512  }
513 
514  mLegendPlaceholderImage = layerElement.attribute( QStringLiteral( "legendPlaceholderImage" ) );
515 
516  return ! layerError;
517 } // bool QgsMapLayer::readLayerXML
518 
519 
520 bool QgsMapLayer::readXml( const QDomNode &layer_node, QgsReadWriteContext &context )
521 {
522  Q_UNUSED( layer_node )
523  Q_UNUSED( context )
524  // NOP by default; children will over-ride with behavior specific to them
525 
526  // read Extent
528  {
529  const QDomNode extentNode = layer_node.namedItem( QStringLiteral( "extent" ) );
530  if ( !extentNode.isNull() )
531  {
532  mExtent = QgsXmlUtils::readRectangle( extentNode.toElement() );
533  }
534  }
535 
536  return true;
537 } // void QgsMapLayer::readXml
538 
539 
540 bool QgsMapLayer::writeLayerXml( QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context ) const
541 {
542  if ( !extent().isNull() )
543  {
544  layerElement.appendChild( QgsXmlUtils::writeRectangle( mExtent, document ) );
545  layerElement.appendChild( QgsXmlUtils::writeRectangle( wgs84Extent( true ), document, QStringLiteral( "wgs84extent" ) ) );
546  }
547 
548  layerElement.setAttribute( QStringLiteral( "autoRefreshTime" ), QString::number( mRefreshTimer->interval() ) );
549  layerElement.setAttribute( QStringLiteral( "autoRefreshEnabled" ), mRefreshTimer->isActive() ? 1 : 0 );
550  layerElement.setAttribute( QStringLiteral( "refreshOnNotifyEnabled" ), mIsRefreshOnNofifyEnabled ? 1 : 0 );
551  layerElement.setAttribute( QStringLiteral( "refreshOnNotifyMessage" ), mRefreshOnNofifyMessage );
552 
553  // ID
554  QDomElement layerId = document.createElement( QStringLiteral( "id" ) );
555  const QDomText layerIdText = document.createTextNode( id() );
556  layerId.appendChild( layerIdText );
557 
558  layerElement.appendChild( layerId );
559 
560  // data source
561  QDomElement dataSource = document.createElement( QStringLiteral( "datasource" ) );
562  const QString src = context.pathResolver().writePath( encodedSource( source(), context ) );
563  const QDomText dataSourceText = document.createTextNode( src );
564  dataSource.appendChild( dataSourceText );
565  layerElement.appendChild( dataSource );
566 
567  // layer name
568  QDomElement layerName = document.createElement( QStringLiteral( "layername" ) );
569  const QDomText layerNameText = document.createTextNode( name() );
570  layerName.appendChild( layerNameText );
571  layerElement.appendChild( layerName );
572 
573  // layer short name
574  if ( !mShortName.isEmpty() )
575  {
576  QDomElement layerShortName = document.createElement( QStringLiteral( "shortname" ) );
577  const QDomText layerShortNameText = document.createTextNode( mShortName );
578  layerShortName.appendChild( layerShortNameText );
579  layerElement.appendChild( layerShortName );
580  }
581 
582  // layer title
583  if ( !mTitle.isEmpty() )
584  {
585  QDomElement layerTitle = document.createElement( QStringLiteral( "title" ) );
586  const QDomText layerTitleText = document.createTextNode( mTitle );
587  layerTitle.appendChild( layerTitleText );
588  layerElement.appendChild( layerTitle );
589  }
590 
591  // layer abstract
592  if ( !mAbstract.isEmpty() )
593  {
594  QDomElement layerAbstract = document.createElement( QStringLiteral( "abstract" ) );
595  const QDomText layerAbstractText = document.createTextNode( mAbstract );
596  layerAbstract.appendChild( layerAbstractText );
597  layerElement.appendChild( layerAbstract );
598  }
599 
600  // layer keyword list
601  const QStringList keywordStringList = keywordList().split( ',' );
602  if ( !keywordStringList.isEmpty() )
603  {
604  QDomElement layerKeywordList = document.createElement( QStringLiteral( "keywordList" ) );
605  for ( int i = 0; i < keywordStringList.size(); ++i )
606  {
607  QDomElement layerKeywordValue = document.createElement( QStringLiteral( "value" ) );
608  const QDomText layerKeywordText = document.createTextNode( keywordStringList.at( i ).trimmed() );
609  layerKeywordValue.appendChild( layerKeywordText );
610  layerKeywordList.appendChild( layerKeywordValue );
611  }
612  layerElement.appendChild( layerKeywordList );
613  }
614 
615  // layer dataUrl
616  const QString aDataUrl = dataUrl();
617  if ( !aDataUrl.isEmpty() )
618  {
619  QDomElement layerDataUrl = document.createElement( QStringLiteral( "dataUrl" ) );
620  const QDomText layerDataUrlText = document.createTextNode( aDataUrl );
621  layerDataUrl.appendChild( layerDataUrlText );
622  layerDataUrl.setAttribute( QStringLiteral( "format" ), dataUrlFormat() );
623  layerElement.appendChild( layerDataUrl );
624  }
625 
626  // layer legendUrl
627  const QString aLegendUrl = legendUrl();
628  if ( !aLegendUrl.isEmpty() )
629  {
630  QDomElement layerLegendUrl = document.createElement( QStringLiteral( "legendUrl" ) );
631  const QDomText layerLegendUrlText = document.createTextNode( aLegendUrl );
632  layerLegendUrl.appendChild( layerLegendUrlText );
633  layerLegendUrl.setAttribute( QStringLiteral( "format" ), legendUrlFormat() );
634  layerElement.appendChild( layerLegendUrl );
635  }
636 
637  // layer attribution
638  const QString aAttribution = attribution();
639  if ( !aAttribution.isEmpty() )
640  {
641  QDomElement layerAttribution = document.createElement( QStringLiteral( "attribution" ) );
642  const QDomText layerAttributionText = document.createTextNode( aAttribution );
643  layerAttribution.appendChild( layerAttributionText );
644  layerAttribution.setAttribute( QStringLiteral( "href" ), attributionUrl() );
645  layerElement.appendChild( layerAttribution );
646  }
647 
648  // timestamp if supported
649  if ( timestamp() > QDateTime() )
650  {
651  QDomElement stamp = document.createElement( QStringLiteral( "timestamp" ) );
652  const QDomText stampText = document.createTextNode( timestamp().toString( Qt::ISODate ) );
653  stamp.appendChild( stampText );
654  layerElement.appendChild( stamp );
655  }
656 
657  layerElement.appendChild( layerName );
658 
659  // zorder
660  // This is no longer stored in the project file. It is superfluous since the layers
661  // are written and read in the proper order.
662 
663  // spatial reference system id
664  QDomElement mySrsElement = document.createElement( QStringLiteral( "srs" ) );
665  mCRS.writeXml( mySrsElement, document );
666  layerElement.appendChild( mySrsElement );
667 
668  // layer metadata
669  QDomElement myMetadataElem = document.createElement( QStringLiteral( "resourceMetadata" ) );
670  mMetadata.writeMetadataXml( myMetadataElem, document );
671  layerElement.appendChild( myMetadataElem );
672 
673  layerElement.setAttribute( QStringLiteral( "legendPlaceholderImage" ), mLegendPlaceholderImage );
674 
675  // now append layer node to map layer node
676  return writeXml( layerElement, document, context );
677 }
678 
679 void QgsMapLayer::writeCommonStyle( QDomElement &layerElement, QDomDocument &document,
680  const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
681 {
682  // save categories
683  const QMetaEnum metaEnum = QMetaEnum::fromType<QgsMapLayer::StyleCategories>();
684  const QString categoriesKeys( metaEnum.valueToKeys( static_cast<int>( categories ) ) );
685  layerElement.setAttribute( QStringLiteral( "styleCategories" ), categoriesKeys );
686 
687  if ( categories.testFlag( Rendering ) )
688  {
689  // use scale dependent visibility flag
690  layerElement.setAttribute( QStringLiteral( "hasScaleBasedVisibilityFlag" ), hasScaleBasedVisibility() ? 1 : 0 );
691  layerElement.setAttribute( QStringLiteral( "maxScale" ), QString::number( maximumScale() ) );
692  layerElement.setAttribute( QStringLiteral( "minScale" ), QString::number( minimumScale() ) );
693  }
694 
695  if ( categories.testFlag( Symbology3D ) )
696  {
697  if ( m3DRenderer )
698  {
699  QDomElement renderer3DElem = document.createElement( QStringLiteral( "renderer-3d" ) );
700  renderer3DElem.setAttribute( QStringLiteral( "type" ), m3DRenderer->type() );
701  m3DRenderer->writeXml( renderer3DElem, context );
702  layerElement.appendChild( renderer3DElem );
703  }
704  }
705 
706  if ( categories.testFlag( LayerConfiguration ) )
707  {
708  // flags
709  // this code is saving automatically all the flags entries
710  QDomElement layerFlagsElem = document.createElement( QStringLiteral( "flags" ) );
711  const auto enumMap = qgsEnumMap<QgsMapLayer::LayerFlag>();
712  for ( auto it = enumMap.constBegin(); it != enumMap.constEnd(); ++it )
713  {
714  const bool flagValue = mFlags.testFlag( it.key() );
715  QDomElement flagElem = document.createElement( it.value() );
716  flagElem.appendChild( document.createTextNode( QString::number( flagValue ) ) );
717  layerFlagsElem.appendChild( flagElem );
718  }
719  layerElement.appendChild( layerFlagsElem );
720  }
721 
722  if ( categories.testFlag( Temporal ) )
723  {
724  if ( QgsMapLayerTemporalProperties *properties = const_cast< QgsMapLayer * >( this )->temporalProperties() )
725  properties->writeXml( layerElement, document, context );
726  }
727 
728  if ( categories.testFlag( Elevation ) )
729  {
730  if ( QgsMapLayerElevationProperties *properties = const_cast< QgsMapLayer * >( this )->elevationProperties() )
731  properties->writeXml( layerElement, document, context );
732  }
733 
734  if ( categories.testFlag( Notes ) && QgsLayerNotesUtils::layerHasNotes( this ) )
735  {
736  QDomElement notesElem = document.createElement( QStringLiteral( "userNotes" ) );
737  notesElem.setAttribute( QStringLiteral( "value" ), QgsLayerNotesUtils::layerNotes( this ) );
738  layerElement.appendChild( notesElem );
739  }
740 
741  // custom properties
742  if ( categories.testFlag( CustomProperties ) )
743  {
744  writeCustomProperties( layerElement, document );
745  }
746 }
747 
748 
749 bool QgsMapLayer::writeXml( QDomNode &layer_node, QDomDocument &document, const QgsReadWriteContext &context ) const
750 {
751  Q_UNUSED( layer_node )
752  Q_UNUSED( document )
753  Q_UNUSED( context )
754  // NOP by default; children will over-ride with behavior specific to them
755 
756  return true;
757 }
758 
759 QString QgsMapLayer::encodedSource( const QString &source, const QgsReadWriteContext &context ) const
760 {
761  Q_UNUSED( context )
762  return source;
763 }
764 
765 QString QgsMapLayer::decodedSource( const QString &source, const QString &dataProvider, const QgsReadWriteContext &context ) const
766 {
767  Q_UNUSED( context )
768  Q_UNUSED( dataProvider )
769  return source;
770 }
771 
773 {
775  if ( m3DRenderer )
776  m3DRenderer->resolveReferences( *project );
777 }
778 
779 
780 void QgsMapLayer::readCustomProperties( const QDomNode &layerNode, const QString &keyStartsWith )
781 {
782  const QgsObjectCustomProperties oldKeys = mCustomProperties;
783 
784  mCustomProperties.readXml( layerNode, keyStartsWith );
785 
786  for ( const QString &key : mCustomProperties.keys() )
787  {
788  if ( !oldKeys.contains( key ) || mCustomProperties.value( key ) != oldKeys.value( key ) )
789  {
790  emit customPropertyChanged( key );
791  }
792  }
793 }
794 
795 void QgsMapLayer::writeCustomProperties( QDomNode &layerNode, QDomDocument &doc ) const
796 {
797  mCustomProperties.writeXml( layerNode, doc );
798 }
799 
800 void QgsMapLayer::readStyleManager( const QDomNode &layerNode )
801 {
802  const QDomElement styleMgrElem = layerNode.firstChildElement( QStringLiteral( "map-layer-style-manager" ) );
803  if ( !styleMgrElem.isNull() )
804  mStyleManager->readXml( styleMgrElem );
805  else
806  mStyleManager->reset();
807 }
808 
809 void QgsMapLayer::writeStyleManager( QDomNode &layerNode, QDomDocument &doc ) const
810 {
811  if ( mStyleManager )
812  {
813  QDomElement styleMgrElem = doc.createElement( QStringLiteral( "map-layer-style-manager" ) );
814  mStyleManager->writeXml( styleMgrElem );
815  layerNode.appendChild( styleMgrElem );
816  }
817 }
818 
820 {
821  return mValid;
822 }
823 
824 #if 0
825 void QgsMapLayer::connectNotify( const char *signal )
826 {
827  Q_UNUSED( signal )
828  QgsDebugMsgLevel( "QgsMapLayer connected to " + QString( signal ), 3 );
829 } // QgsMapLayer::connectNotify
830 #endif
831 
832 bool QgsMapLayer::isInScaleRange( double scale ) const
833 {
834  return !mScaleBasedVisibility ||
835  ( ( mMinScale == 0 || mMinScale * Qgis::SCALE_PRECISION < scale )
836  && ( mMaxScale == 0 || scale < mMaxScale ) );
837 }
838 
840 {
841  return mScaleBasedVisibility;
842 }
843 
845 {
846  return mRefreshTimer->isActive();
847 }
848 
850 {
851  return mRefreshTimer->interval();
852 }
853 
855 {
856  if ( interval <= 0 )
857  {
858  mRefreshTimer->stop();
859  mRefreshTimer->setInterval( 0 );
860  }
861  else
862  {
863  mRefreshTimer->setInterval( interval );
864  }
865  emit autoRefreshIntervalChanged( mRefreshTimer->isActive() ? mRefreshTimer->interval() : 0 );
866 }
867 
869 {
870  if ( !enabled )
871  mRefreshTimer->stop();
872  else if ( mRefreshTimer->interval() > 0 )
873  mRefreshTimer->start();
874 
875  emit autoRefreshIntervalChanged( mRefreshTimer->isActive() ? mRefreshTimer->interval() : 0 );
876 }
877 
879 {
880  return mMetadata;
881 }
882 
883 void QgsMapLayer::setMaximumScale( double scale )
884 {
885  mMinScale = scale;
886 }
887 
889 {
890  return mMinScale;
891 }
892 
893 
894 void QgsMapLayer::setMinimumScale( double scale )
895 {
896  mMaxScale = scale;
897 }
898 
899 void QgsMapLayer::setScaleBasedVisibility( const bool enabled )
900 {
901  mScaleBasedVisibility = enabled;
902 }
903 
905 {
906  return mMaxScale;
907 }
908 
909 QStringList QgsMapLayer::subLayers() const
910 {
911  return QStringList(); // Empty
912 }
913 
914 void QgsMapLayer::setLayerOrder( const QStringList &layers )
915 {
916  Q_UNUSED( layers )
917  // NOOP
918 }
919 
920 void QgsMapLayer::setSubLayerVisibility( const QString &name, bool vis )
921 {
922  Q_UNUSED( name )
923  Q_UNUSED( vis )
924  // NOOP
925 }
926 
928 {
929  return false;
930 }
931 
933 {
934  return mCRS;
935 }
936 
937 void QgsMapLayer::setCrs( const QgsCoordinateReferenceSystem &srs, bool emitSignal )
938 {
939  mCRS = srs;
940 
942  {
943  mCRS.setValidationHint( tr( "Specify CRS for layer %1" ).arg( name() ) );
944  mCRS.validate();
945  }
946 
947  if ( emitSignal )
948  emit crsChanged();
949 }
950 
952 {
953  const QgsDataProvider *lDataProvider = dataProvider();
954  return lDataProvider ? lDataProvider->transformContext() : QgsCoordinateTransformContext();
955 }
956 
957 QString QgsMapLayer::formatLayerName( const QString &name )
958 {
959  QString layerName( name );
960  layerName.replace( '_', ' ' );
962  return layerName;
963 }
964 
965 QString QgsMapLayer::baseURI( PropertyType type ) const
966 {
967  QString myURI = publicSource();
968 
969  // first get base path for delimited text, spatialite and OGR layers,
970  // as in these cases URI may contain layer name and/or additional
971  // information. This also strips prefix in case if VSIFILE mechanism
972  // is used
973  if ( providerType() == QLatin1String( "ogr" ) || providerType() == QLatin1String( "delimitedtext" ) ||
974  providerType() == QLatin1String( "spatialite" ) )
975  {
976  QVariantMap components = QgsProviderRegistry::instance()->decodeUri( providerType(), myURI );
977  myURI = components["path"].toString();
978  }
979 
980  QFileInfo myFileInfo( myURI );
981  QString key;
982 
983  if ( myFileInfo.exists() )
984  {
985  // if file is using the /vsizip/ or /vsigzip/ mechanism, cleanup the name
986  if ( myURI.endsWith( QLatin1String( ".gz" ), Qt::CaseInsensitive ) )
987  myURI.chop( 3 );
988  else if ( myURI.endsWith( QLatin1String( ".zip" ), Qt::CaseInsensitive ) )
989  myURI.chop( 4 );
990  else if ( myURI.endsWith( QLatin1String( ".tar" ), Qt::CaseInsensitive ) )
991  myURI.chop( 4 );
992  else if ( myURI.endsWith( QLatin1String( ".tar.gz" ), Qt::CaseInsensitive ) )
993  myURI.chop( 7 );
994  else if ( myURI.endsWith( QLatin1String( ".tgz" ), Qt::CaseInsensitive ) )
995  myURI.chop( 4 );
996  myFileInfo.setFile( myURI );
997  // get the file name for our .qml style file
998  key = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + QgsMapLayer::extensionPropertyType( type );
999  }
1000  else
1001  {
1002  key = publicSource();
1003  }
1004 
1005  return key;
1006 }
1007 
1009 {
1010  return baseURI( PropertyType::Metadata );
1011 }
1012 
1013 QString QgsMapLayer::saveDefaultMetadata( bool &resultFlag )
1014 {
1015  if ( const QgsProviderMetadata *metadata = QgsProviderRegistry::instance()->providerMetadata( providerType() ) )
1016  {
1017  if ( metadata->providerCapabilities() & QgsProviderMetadata::SaveLayerMetadata )
1018  {
1019  try
1020  {
1021  QString errorMessage;
1022  resultFlag = QgsProviderRegistry::instance()->saveLayerMetadata( providerType(), mDataSource, mMetadata, errorMessage );
1023  if ( resultFlag )
1024  return tr( "Successfully saved default layer metadata" );
1025  else
1026  return errorMessage;
1027  }
1028  catch ( QgsNotSupportedException &e )
1029  {
1030  resultFlag = false;
1031  return e.what();
1032  }
1033  }
1034  }
1035 
1036  // fallback default metadata saving method, for providers which don't support (or implement) saveLayerMetadata
1037  return saveNamedMetadata( metadataUri(), resultFlag );
1038 }
1039 
1040 QString QgsMapLayer::loadDefaultMetadata( bool &resultFlag )
1041 {
1042  return loadNamedMetadata( metadataUri(), resultFlag );
1043 }
1044 
1045 QString QgsMapLayer::styleURI() const
1046 {
1047  return baseURI( PropertyType::Style );
1048 }
1049 
1050 QString QgsMapLayer::loadDefaultStyle( bool &resultFlag )
1051 {
1052  return loadNamedStyle( styleURI(), resultFlag );
1053 }
1054 
1055 bool QgsMapLayer::loadNamedMetadataFromDatabase( const QString &db, const QString &uri, QString &qmd )
1056 {
1057  return loadNamedPropertyFromDatabase( db, uri, qmd, PropertyType::Metadata );
1058 }
1059 
1060 bool QgsMapLayer::loadNamedStyleFromDatabase( const QString &db, const QString &uri, QString &qml )
1061 {
1062  return loadNamedPropertyFromDatabase( db, uri, qml, PropertyType::Style );
1063 }
1064 
1065 bool QgsMapLayer::loadNamedPropertyFromDatabase( const QString &db, const QString &uri, QString &xml, QgsMapLayer::PropertyType type )
1066 {
1067  QgsDebugMsgLevel( QStringLiteral( "db = %1 uri = %2" ).arg( db, uri ), 4 );
1068 
1069  bool resultFlag = false;
1070 
1071  // read from database
1072  sqlite3_database_unique_ptr database;
1073  sqlite3_statement_unique_ptr statement;
1074 
1075  int myResult;
1076 
1077  QgsDebugMsgLevel( QStringLiteral( "Trying to load style or metadata for \"%1\" from \"%2\"" ).arg( uri, db ), 4 );
1078 
1079  if ( db.isEmpty() || !QFile( db ).exists() )
1080  return false;
1081 
1082  myResult = database.open_v2( db, SQLITE_OPEN_READONLY, nullptr );
1083  if ( myResult != SQLITE_OK )
1084  {
1085  return false;
1086  }
1087 
1088  QString mySql;
1089  switch ( type )
1090  {
1091  case Metadata:
1092  mySql = QStringLiteral( "select qmd from tbl_metadata where metadata=?" );
1093  break;
1094 
1095  case Style:
1096  mySql = QStringLiteral( "select qml from tbl_styles where style=?" );
1097  break;
1098  }
1099 
1100  statement = database.prepare( mySql, myResult );
1101  if ( myResult == SQLITE_OK )
1102  {
1103  QByteArray param = uri.toUtf8();
1104 
1105  if ( sqlite3_bind_text( statement.get(), 1, param.data(), param.length(), SQLITE_STATIC ) == SQLITE_OK &&
1106  sqlite3_step( statement.get() ) == SQLITE_ROW )
1107  {
1108  xml = QString::fromUtf8( reinterpret_cast< const char * >( sqlite3_column_text( statement.get(), 0 ) ) );
1109  resultFlag = true;
1110  }
1111  }
1112  return resultFlag;
1113 }
1114 
1115 
1116 QString QgsMapLayer::loadNamedStyle( const QString &uri, bool &resultFlag, QgsMapLayer::StyleCategories categories )
1117 {
1118  return loadNamedProperty( uri, PropertyType::Style, resultFlag, categories );
1119 }
1120 
1121 QString QgsMapLayer::loadNamedProperty( const QString &uri, QgsMapLayer::PropertyType type, bool &resultFlag, StyleCategories categories )
1122 {
1123  QgsDebugMsgLevel( QStringLiteral( "uri = %1 myURI = %2" ).arg( uri, publicSource() ), 4 );
1124 
1125  resultFlag = false;
1126 
1127  QDomDocument myDocument( QStringLiteral( "qgis" ) );
1128 
1129  // location of problem associated with errorMsg
1130  int line, column;
1131  QString myErrorMessage;
1132 
1133  QFile myFile( uri );
1134  if ( myFile.open( QFile::ReadOnly ) )
1135  {
1136  QgsDebugMsgLevel( QStringLiteral( "file found %1" ).arg( uri ), 2 );
1137  // read file
1138  resultFlag = myDocument.setContent( &myFile, &myErrorMessage, &line, &column );
1139  if ( !resultFlag )
1140  myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1141  myFile.close();
1142  }
1143  else
1144  {
1145  const QFileInfo project( QgsProject::instance()->fileName() );
1146  QgsDebugMsgLevel( QStringLiteral( "project fileName: %1" ).arg( project.absoluteFilePath() ), 4 );
1147 
1148  QString xml;
1149  switch ( type )
1150  {
1151  case QgsMapLayer::Style:
1152  {
1153  if ( loadNamedStyleFromDatabase( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( QStringLiteral( "qgis.qmldb" ) ), uri, xml ) ||
1154  ( project.exists() && loadNamedStyleFromDatabase( project.absoluteDir().absoluteFilePath( project.baseName() + ".qmldb" ), uri, xml ) ) ||
1155  loadNamedStyleFromDatabase( QDir( QgsApplication::pkgDataPath() ).absoluteFilePath( QStringLiteral( "resources/qgis.qmldb" ) ), uri, xml ) )
1156  {
1157  resultFlag = myDocument.setContent( xml, &myErrorMessage, &line, &column );
1158  if ( !resultFlag )
1159  {
1160  myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1161  }
1162  }
1163  else
1164  {
1165  myErrorMessage = tr( "Style not found in database" );
1166  resultFlag = false;
1167  }
1168  break;
1169  }
1170  case QgsMapLayer::Metadata:
1171  {
1172  if ( loadNamedMetadataFromDatabase( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( QStringLiteral( "qgis.qmldb" ) ), uri, xml ) ||
1173  ( project.exists() && loadNamedMetadataFromDatabase( project.absoluteDir().absoluteFilePath( project.baseName() + ".qmldb" ), uri, xml ) ) ||
1174  loadNamedMetadataFromDatabase( QDir( QgsApplication::pkgDataPath() ).absoluteFilePath( QStringLiteral( "resources/qgis.qmldb" ) ), uri, xml ) )
1175  {
1176  resultFlag = myDocument.setContent( xml, &myErrorMessage, &line, &column );
1177  if ( !resultFlag )
1178  {
1179  myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1180  }
1181  }
1182  else
1183  {
1184  myErrorMessage = tr( "Metadata not found in database" );
1185  resultFlag = false;
1186  }
1187  break;
1188  }
1189  }
1190  }
1191 
1192  if ( !resultFlag )
1193  {
1194  return myErrorMessage;
1195  }
1196 
1197  switch ( type )
1198  {
1199  case QgsMapLayer::Style:
1200  resultFlag = importNamedStyle( myDocument, myErrorMessage, categories );
1201  if ( !resultFlag )
1202  myErrorMessage = tr( "Loading style file %1 failed because:\n%2" ).arg( uri, myErrorMessage );
1203  break;
1204  case QgsMapLayer::Metadata:
1205  resultFlag = importNamedMetadata( myDocument, myErrorMessage );
1206  if ( !resultFlag )
1207  myErrorMessage = tr( "Loading metadata file %1 failed because:\n%2" ).arg( uri, myErrorMessage );
1208  break;
1209  }
1210  return myErrorMessage;
1211 }
1212 
1213 bool QgsMapLayer::importNamedMetadata( QDomDocument &document, QString &errorMessage )
1214 {
1215  const QDomElement myRoot = document.firstChildElement( QStringLiteral( "qgis" ) );
1216  if ( myRoot.isNull() )
1217  {
1218  errorMessage = tr( "Root <qgis> element could not be found" );
1219  return false;
1220  }
1221 
1222  return mMetadata.readMetadataXml( myRoot );
1223 }
1224 
1225 bool QgsMapLayer::importNamedStyle( QDomDocument &myDocument, QString &myErrorMessage, QgsMapLayer::StyleCategories categories )
1226 {
1227  const QDomElement myRoot = myDocument.firstChildElement( QStringLiteral( "qgis" ) );
1228  if ( myRoot.isNull() )
1229  {
1230  myErrorMessage = tr( "Root <qgis> element could not be found" );
1231  return false;
1232  }
1233 
1234  // get style file version string, if any
1235  const QgsProjectVersion fileVersion( myRoot.attribute( QStringLiteral( "version" ) ) );
1236  const QgsProjectVersion thisVersion( Qgis::version() );
1237 
1238  if ( thisVersion > fileVersion )
1239  {
1240  QgsProjectFileTransform styleFile( myDocument, fileVersion );
1241  styleFile.updateRevision( thisVersion );
1242  }
1243 
1244  // Get source categories
1245  const QgsMapLayer::StyleCategories sourceCategories = QgsXmlUtils::readFlagAttribute( myRoot, QStringLiteral( "styleCategories" ), QgsMapLayer::AllStyleCategories );
1246 
1247  //Test for matching geometry type on vector layers when applying, if geometry type is given in the style
1248  if ( ( sourceCategories.testFlag( QgsMapLayer::Symbology ) || sourceCategories.testFlag( QgsMapLayer::Symbology3D ) ) &&
1249  ( categories.testFlag( QgsMapLayer::Symbology ) || categories.testFlag( QgsMapLayer::Symbology3D ) ) )
1250  {
1251  if ( type() == QgsMapLayerType::VectorLayer && !myRoot.firstChildElement( QStringLiteral( "layerGeometryType" ) ).isNull() )
1252  {
1253  QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( this );
1254  const QgsWkbTypes::GeometryType importLayerGeometryType = static_cast<QgsWkbTypes::GeometryType>( myRoot.firstChildElement( QStringLiteral( "layerGeometryType" ) ).text().toInt() );
1255  if ( importLayerGeometryType != QgsWkbTypes::GeometryType::UnknownGeometry && vl->geometryType() != importLayerGeometryType )
1256  {
1257  myErrorMessage = tr( "Cannot apply style with symbology to layer with a different geometry type" );
1258  return false;
1259  }
1260  }
1261  }
1262 
1264  return readSymbology( myRoot, myErrorMessage, context, categories ); // TODO: support relative paths in QML?
1265 }
1266 
1267 void QgsMapLayer::exportNamedMetadata( QDomDocument &doc, QString &errorMsg ) const
1268 {
1269  QDomImplementation DomImplementation;
1270  const QDomDocumentType documentType = DomImplementation.createDocumentType( QStringLiteral( "qgis" ), QStringLiteral( "http://mrcc.com/qgis.dtd" ), QStringLiteral( "SYSTEM" ) );
1271  QDomDocument myDocument( documentType );
1272 
1273  QDomElement myRootNode = myDocument.createElement( QStringLiteral( "qgis" ) );
1274  myRootNode.setAttribute( QStringLiteral( "version" ), Qgis::version() );
1275  myDocument.appendChild( myRootNode );
1276 
1277  if ( !mMetadata.writeMetadataXml( myRootNode, myDocument ) )
1278  {
1279  errorMsg = QObject::tr( "Could not save metadata" );
1280  return;
1281  }
1282 
1283  doc = myDocument;
1284 }
1285 
1286 void QgsMapLayer::exportNamedStyle( QDomDocument &doc, QString &errorMsg, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
1287 {
1288  QDomImplementation DomImplementation;
1289  const QDomDocumentType documentType = DomImplementation.createDocumentType( QStringLiteral( "qgis" ), QStringLiteral( "http://mrcc.com/qgis.dtd" ), QStringLiteral( "SYSTEM" ) );
1290  QDomDocument myDocument( documentType );
1291 
1292  QDomElement myRootNode = myDocument.createElement( QStringLiteral( "qgis" ) );
1293  myRootNode.setAttribute( QStringLiteral( "version" ), Qgis::version() );
1294  myDocument.appendChild( myRootNode );
1295 
1296  if ( !writeSymbology( myRootNode, myDocument, errorMsg, context, categories ) ) // TODO: support relative paths in QML?
1297  {
1298  errorMsg = QObject::tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1299  return;
1300  }
1301 
1302  /*
1303  * Check to see if the layer is vector - in which case we should also export its geometryType
1304  * to avoid eventually pasting to a layer with a different geometry
1305  */
1307  {
1308  //Getting the selectionLayer geometry
1309  const QgsVectorLayer *vl = qobject_cast<const QgsVectorLayer *>( this );
1310  const QString geoType = QString::number( vl->geometryType() );
1311 
1312  //Adding geometryinformation
1313  QDomElement layerGeometryType = myDocument.createElement( QStringLiteral( "layerGeometryType" ) );
1314  const QDomText type = myDocument.createTextNode( geoType );
1315 
1316  layerGeometryType.appendChild( type );
1317  myRootNode.appendChild( layerGeometryType );
1318  }
1319 
1320  doc = myDocument;
1321 }
1322 
1323 QString QgsMapLayer::saveDefaultStyle( bool &resultFlag )
1324 {
1325  return saveDefaultStyle( resultFlag, AllStyleCategories );
1326 }
1327 
1328 QString QgsMapLayer::saveDefaultStyle( bool &resultFlag, StyleCategories categories )
1329 {
1330  return saveNamedStyle( styleURI(), resultFlag, categories );
1331 }
1332 
1333 QString QgsMapLayer::saveNamedMetadata( const QString &uri, bool &resultFlag )
1334 {
1335  return saveNamedProperty( uri, QgsMapLayer::Metadata, resultFlag );
1336 }
1337 
1338 QString QgsMapLayer::loadNamedMetadata( const QString &uri, bool &resultFlag )
1339 {
1340  return loadNamedProperty( uri, QgsMapLayer::Metadata, resultFlag );
1341 }
1342 
1343 QString QgsMapLayer::saveNamedProperty( const QString &uri, QgsMapLayer::PropertyType type, bool &resultFlag, StyleCategories categories )
1344 {
1345  // check if the uri is a file or ends with .qml/.qmd,
1346  // which indicates that it should become one
1347  // everything else goes to the database
1348  QString filename;
1349 
1350  QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( this );
1351  if ( vlayer && vlayer->providerType() == QLatin1String( "ogr" ) )
1352  {
1353  QStringList theURIParts = uri.split( '|' );
1354  filename = theURIParts[0];
1355  }
1356  else if ( vlayer && vlayer->providerType() == QLatin1String( "gpx" ) )
1357  {
1358  QStringList theURIParts = uri.split( '?' );
1359  filename = theURIParts[0];
1360  }
1361  else if ( vlayer && vlayer->providerType() == QLatin1String( "delimitedtext" ) )
1362  {
1363  filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1364  // toLocalFile() returns an empty string if theURI is a plain Windows-path, e.g. "C:/style.qml"
1365  if ( filename.isEmpty() )
1366  filename = uri;
1367  }
1368  else
1369  {
1370  filename = uri;
1371  }
1372 
1373  QString myErrorMessage;
1374  QDomDocument myDocument;
1375  switch ( type )
1376  {
1377  case Metadata:
1378  exportNamedMetadata( myDocument, myErrorMessage );
1379  break;
1380 
1381  case Style:
1382  const QgsReadWriteContext context;
1383  exportNamedStyle( myDocument, myErrorMessage, context, categories );
1384  break;
1385  }
1386 
1387  const QFileInfo myFileInfo( filename );
1388  if ( myFileInfo.exists() || filename.endsWith( QgsMapLayer::extensionPropertyType( type ), Qt::CaseInsensitive ) )
1389  {
1390  const QFileInfo myDirInfo( myFileInfo.path() ); //excludes file name
1391  if ( !myDirInfo.isWritable() )
1392  {
1393  return tr( "The directory containing your dataset needs to be writable!" );
1394  }
1395 
1396  // now construct the file name for our .qml or .qmd file
1397  const QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + QgsMapLayer::extensionPropertyType( type );
1398 
1399  QFile myFile( myFileName );
1400  if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1401  {
1402  QTextStream myFileStream( &myFile );
1403  // save as utf-8 with 2 spaces for indents
1404  myDocument.save( myFileStream, 2 );
1405  myFile.close();
1406  resultFlag = true;
1407  switch ( type )
1408  {
1409  case Metadata:
1410  return tr( "Created default metadata file as %1" ).arg( myFileName );
1411 
1412  case Style:
1413  return tr( "Created default style file as %1" ).arg( myFileName );
1414  }
1415 
1416  }
1417  else
1418  {
1419  resultFlag = false;
1420  switch ( type )
1421  {
1422  case Metadata:
1423  return tr( "ERROR: Failed to created default metadata file as %1. Check file permissions and retry." ).arg( myFileName );
1424 
1425  case Style:
1426  return tr( "ERROR: Failed to created default style file as %1. Check file permissions and retry." ).arg( myFileName );
1427  }
1428  }
1429  }
1430  else
1431  {
1432  const QString qml = myDocument.toString();
1433 
1434  // read from database
1435  sqlite3_database_unique_ptr database;
1436  sqlite3_statement_unique_ptr statement;
1437 
1438  int myResult = database.open( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( QStringLiteral( "qgis.qmldb" ) ) );
1439  if ( myResult != SQLITE_OK )
1440  {
1441  return tr( "User database could not be opened." );
1442  }
1443 
1444  QByteArray param0 = uri.toUtf8();
1445  QByteArray param1 = qml.toUtf8();
1446 
1447  QString mySql;
1448  switch ( type )
1449  {
1450  case Metadata:
1451  mySql = QStringLiteral( "create table if not exists tbl_metadata(metadata varchar primary key,qmd varchar)" );
1452  break;
1453 
1454  case Style:
1455  mySql = QStringLiteral( "create table if not exists tbl_styles(style varchar primary key,qml varchar)" );
1456  break;
1457  }
1458 
1459  statement = database.prepare( mySql, myResult );
1460  if ( myResult == SQLITE_OK )
1461  {
1462  if ( sqlite3_step( statement.get() ) != SQLITE_DONE )
1463  {
1464  resultFlag = false;
1465  switch ( type )
1466  {
1467  case Metadata:
1468  return tr( "The metadata table could not be created." );
1469 
1470  case Style:
1471  return tr( "The style table could not be created." );
1472  }
1473  }
1474  }
1475 
1476  switch ( type )
1477  {
1478  case Metadata:
1479  mySql = QStringLiteral( "insert into tbl_metadata(metadata,qmd) values (?,?)" );
1480  break;
1481 
1482  case Style:
1483  mySql = QStringLiteral( "insert into tbl_styles(style,qml) values (?,?)" );
1484  break;
1485  }
1486  statement = database.prepare( mySql, myResult );
1487  if ( myResult == SQLITE_OK )
1488  {
1489  if ( sqlite3_bind_text( statement.get(), 1, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&
1490  sqlite3_bind_text( statement.get(), 2, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&
1491  sqlite3_step( statement.get() ) == SQLITE_DONE )
1492  {
1493  resultFlag = true;
1494  switch ( type )
1495  {
1496  case Metadata:
1497  myErrorMessage = tr( "The metadata %1 was saved to database" ).arg( uri );
1498  break;
1499 
1500  case Style:
1501  myErrorMessage = tr( "The style %1 was saved to database" ).arg( uri );
1502  break;
1503  }
1504  }
1505  }
1506 
1507  if ( !resultFlag )
1508  {
1509  QString mySql;
1510  switch ( type )
1511  {
1512  case Metadata:
1513  mySql = QStringLiteral( "update tbl_metadata set qmd=? where metadata=?" );
1514  break;
1515 
1516  case Style:
1517  mySql = QStringLiteral( "update tbl_styles set qml=? where style=?" );
1518  break;
1519  }
1520  statement = database.prepare( mySql, myResult );
1521  if ( myResult == SQLITE_OK )
1522  {
1523  if ( sqlite3_bind_text( statement.get(), 2, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&
1524  sqlite3_bind_text( statement.get(), 1, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&
1525  sqlite3_step( statement.get() ) == SQLITE_DONE )
1526  {
1527  resultFlag = true;
1528  switch ( type )
1529  {
1530  case Metadata:
1531  myErrorMessage = tr( "The metadata %1 was updated in the database." ).arg( uri );
1532  break;
1533 
1534  case Style:
1535  myErrorMessage = tr( "The style %1 was updated in the database." ).arg( uri );
1536  break;
1537  }
1538  }
1539  else
1540  {
1541  resultFlag = false;
1542  switch ( type )
1543  {
1544  case Metadata:
1545  myErrorMessage = tr( "The metadata %1 could not be updated in the database." ).arg( uri );
1546  break;
1547 
1548  case Style:
1549  myErrorMessage = tr( "The style %1 could not be updated in the database." ).arg( uri );
1550  break;
1551  }
1552  }
1553  }
1554  else
1555  {
1556  resultFlag = false;
1557  switch ( type )
1558  {
1559  case Metadata:
1560  myErrorMessage = tr( "The metadata %1 could not be inserted into database." ).arg( uri );
1561  break;
1562 
1563  case Style:
1564  myErrorMessage = tr( "The style %1 could not be inserted into database." ).arg( uri );
1565  break;
1566  }
1567  }
1568  }
1569  }
1570 
1571  return myErrorMessage;
1572 }
1573 
1574 QString QgsMapLayer::saveNamedStyle( const QString &uri, bool &resultFlag, StyleCategories categories )
1575 {
1576  return saveNamedProperty( uri, QgsMapLayer::Style, resultFlag, categories );
1577 }
1578 
1579 void QgsMapLayer::exportSldStyle( QDomDocument &doc, QString &errorMsg ) const
1580 {
1581  QDomDocument myDocument = QDomDocument();
1582 
1583  const QDomNode header = myDocument.createProcessingInstruction( QStringLiteral( "xml" ), QStringLiteral( "version=\"1.0\" encoding=\"UTF-8\"" ) );
1584  myDocument.appendChild( header );
1585 
1586  const QgsVectorLayer *vlayer = qobject_cast<const QgsVectorLayer *>( this );
1587  const QgsRasterLayer *rlayer = qobject_cast<const QgsRasterLayer *>( this );
1588  if ( !vlayer && !rlayer )
1589  {
1590  errorMsg = tr( "Could not save symbology because:\n%1" )
1591  .arg( tr( "Only vector and raster layers are supported" ) );
1592  return;
1593  }
1594 
1595  // Create the root element
1596  QDomElement root = myDocument.createElementNS( QStringLiteral( "http://www.opengis.net/sld" ), QStringLiteral( "StyledLayerDescriptor" ) );
1597  QDomElement layerNode;
1598  if ( vlayer )
1599  {
1600  root.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.1.0" ) );
1601  root.setAttribute( QStringLiteral( "xsi:schemaLocation" ), QStringLiteral( "http://www.opengis.net/sld http://schemas.opengis.net/sld/1.1.0/StyledLayerDescriptor.xsd" ) );
1602  root.setAttribute( QStringLiteral( "xmlns:ogc" ), QStringLiteral( "http://www.opengis.net/ogc" ) );
1603  root.setAttribute( QStringLiteral( "xmlns:se" ), QStringLiteral( "http://www.opengis.net/se" ) );
1604  root.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
1605  root.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
1606  myDocument.appendChild( root );
1607 
1608  // Create the NamedLayer element
1609  layerNode = myDocument.createElement( QStringLiteral( "NamedLayer" ) );
1610  root.appendChild( layerNode );
1611  }
1612 
1613  // note: Only SLD 1.0 version is generated because seems none is using SE1.1.0 at least for rasters
1614  if ( rlayer )
1615  {
1616  // Create the root element
1617  root.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.0.0" ) );
1618  root.setAttribute( QStringLiteral( "xmlns:gml" ), QStringLiteral( "http://www.opengis.net/gml" ) );
1619  root.setAttribute( QStringLiteral( "xmlns:ogc" ), QStringLiteral( "http://www.opengis.net/ogc" ) );
1620  root.setAttribute( QStringLiteral( "xmlns:sld" ), QStringLiteral( "http://www.opengis.net/sld" ) );
1621  myDocument.appendChild( root );
1622 
1623  // Create the NamedLayer element
1624  layerNode = myDocument.createElement( QStringLiteral( "UserLayer" ) );
1625  root.appendChild( layerNode );
1626  }
1627 
1628  QVariantMap props;
1629  if ( hasScaleBasedVisibility() )
1630  {
1631  props[ QStringLiteral( "scaleMinDenom" ) ] = QString::number( mMinScale );
1632  props[ QStringLiteral( "scaleMaxDenom" ) ] = QString::number( mMaxScale );
1633  }
1634 
1635  if ( vlayer )
1636  {
1637  if ( !vlayer->writeSld( layerNode, myDocument, errorMsg, props ) )
1638  {
1639  errorMsg = tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1640  return;
1641  }
1642  }
1643 
1644  if ( rlayer )
1645  {
1646  if ( !rlayer->writeSld( layerNode, myDocument, errorMsg, props ) )
1647  {
1648  errorMsg = tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1649  return;
1650  }
1651  }
1652 
1653  doc = myDocument;
1654 }
1655 
1656 QString QgsMapLayer::saveSldStyle( const QString &uri, bool &resultFlag ) const
1657 {
1658  const QgsMapLayer *mlayer = qobject_cast<const QgsMapLayer *>( this );
1659 
1660  QString errorMsg;
1661  QDomDocument myDocument;
1662  mlayer->exportSldStyle( myDocument, errorMsg );
1663  if ( !errorMsg.isNull() )
1664  {
1665  resultFlag = false;
1666  return errorMsg;
1667  }
1668  // check if the uri is a file or ends with .sld,
1669  // which indicates that it should become one
1670  QString filename;
1671  if ( mlayer->providerType() == QLatin1String( "ogr" ) )
1672  {
1673  QStringList theURIParts = uri.split( '|' );
1674  filename = theURIParts[0];
1675  }
1676  else if ( mlayer->providerType() == QLatin1String( "gpx" ) )
1677  {
1678  QStringList theURIParts = uri.split( '?' );
1679  filename = theURIParts[0];
1680  }
1681  else if ( mlayer->providerType() == QLatin1String( "delimitedtext" ) )
1682  {
1683  filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1684  // toLocalFile() returns an empty string if theURI is a plain Windows-path, e.g. "C:/style.qml"
1685  if ( filename.isEmpty() )
1686  filename = uri;
1687  }
1688  else
1689  {
1690  filename = uri;
1691  }
1692 
1693  const QFileInfo myFileInfo( filename );
1694  if ( myFileInfo.exists() || filename.endsWith( QLatin1String( ".sld" ), Qt::CaseInsensitive ) )
1695  {
1696  const QFileInfo myDirInfo( myFileInfo.path() ); //excludes file name
1697  if ( !myDirInfo.isWritable() )
1698  {
1699  return tr( "The directory containing your dataset needs to be writable!" );
1700  }
1701 
1702  // now construct the file name for our .sld style file
1703  const QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + ".sld";
1704 
1705  QFile myFile( myFileName );
1706  if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1707  {
1708  QTextStream myFileStream( &myFile );
1709  // save as utf-8 with 2 spaces for indents
1710  myDocument.save( myFileStream, 2 );
1711  myFile.close();
1712  resultFlag = true;
1713  return tr( "Created default style file as %1" ).arg( myFileName );
1714  }
1715  }
1716 
1717  resultFlag = false;
1718  return tr( "ERROR: Failed to created SLD style file as %1. Check file permissions and retry." ).arg( filename );
1719 }
1720 
1721 QString QgsMapLayer::loadSldStyle( const QString &uri, bool &resultFlag )
1722 {
1723  resultFlag = false;
1724 
1725  QDomDocument myDocument;
1726 
1727  // location of problem associated with errorMsg
1728  int line, column;
1729  QString myErrorMessage;
1730 
1731  QFile myFile( uri );
1732  if ( myFile.open( QFile::ReadOnly ) )
1733  {
1734  // read file
1735  resultFlag = myDocument.setContent( &myFile, true, &myErrorMessage, &line, &column );
1736  if ( !resultFlag )
1737  myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1738  myFile.close();
1739  }
1740  else
1741  {
1742  myErrorMessage = tr( "Unable to open file %1" ).arg( uri );
1743  }
1744 
1745  if ( !resultFlag )
1746  {
1747  return myErrorMessage;
1748  }
1749 
1750  // check for root SLD element
1751  const QDomElement myRoot = myDocument.firstChildElement( QStringLiteral( "StyledLayerDescriptor" ) );
1752  if ( myRoot.isNull() )
1753  {
1754  myErrorMessage = QStringLiteral( "Error: StyledLayerDescriptor element not found in %1" ).arg( uri );
1755  resultFlag = false;
1756  return myErrorMessage;
1757  }
1758 
1759  // now get the style node out and pass it over to the layer
1760  // to deserialise...
1761  const QDomElement namedLayerElem = myRoot.firstChildElement( QStringLiteral( "NamedLayer" ) );
1762  if ( namedLayerElem.isNull() )
1763  {
1764  myErrorMessage = QStringLiteral( "Info: NamedLayer element not found." );
1765  resultFlag = false;
1766  return myErrorMessage;
1767  }
1768 
1769  QString errorMsg;
1770  resultFlag = readSld( namedLayerElem, errorMsg );
1771  if ( !resultFlag )
1772  {
1773  myErrorMessage = tr( "Loading style file %1 failed because:\n%2" ).arg( uri, errorMsg );
1774  return myErrorMessage;
1775  }
1776 
1777  return QString();
1778 }
1779 
1780 bool QgsMapLayer::readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
1781 {
1782  Q_UNUSED( node )
1783  Q_UNUSED( errorMessage )
1784  Q_UNUSED( context )
1785  Q_UNUSED( categories )
1786  return false;
1787 }
1788 
1789 bool QgsMapLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage,
1790  const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
1791 {
1792  Q_UNUSED( node )
1793  Q_UNUSED( doc )
1794  Q_UNUSED( errorMessage )
1795  Q_UNUSED( context )
1796  Q_UNUSED( categories )
1797  return false;
1798 }
1799 
1800 
1801 void QgsMapLayer::setDataSource( const QString &dataSource, const QString &baseName, const QString &provider,
1802  bool loadDefaultStyleFlag )
1803 {
1804  const QgsDataProvider::ProviderOptions options;
1805 
1806  QgsDataProvider::ReadFlags flags = QgsDataProvider::ReadFlags();
1807  if ( loadDefaultStyleFlag )
1808  {
1810  }
1811 
1813  {
1815  }
1816  setDataSource( dataSource, baseName, provider, options, flags );
1817 }
1818 
1819 void QgsMapLayer::setDataSource( const QString &dataSource, const QString &baseName, const QString &provider,
1820  const QgsDataProvider::ProviderOptions &options, bool loadDefaultStyleFlag )
1821 {
1822  QgsDataProvider::ReadFlags flags = QgsDataProvider::ReadFlags();
1823  if ( loadDefaultStyleFlag )
1824  {
1826  }
1827 
1829  {
1831  }
1832  setDataSource( dataSource, baseName, provider, options, flags );
1833 }
1834 
1835 void QgsMapLayer::setDataSource( const QString &dataSource, const QString &baseName, const QString &provider,
1836  const QgsDataProvider::ProviderOptions &options, QgsDataProvider::ReadFlags flags )
1837 {
1838 
1841  {
1843  }
1844  setDataSourcePrivate( dataSource, baseName, provider, options, flags );
1845  emit dataSourceChanged();
1846  emit dataChanged();
1847  triggerRepaint();
1848 }
1849 
1850 
1851 void QgsMapLayer::setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider,
1852  const QgsDataProvider::ProviderOptions &options, QgsDataProvider::ReadFlags flags )
1853 {
1854  Q_UNUSED( dataSource )
1855  Q_UNUSED( baseName )
1856  Q_UNUSED( provider )
1857  Q_UNUSED( options )
1858  Q_UNUSED( flags )
1859 }
1860 
1861 
1863 {
1864  return mProviderKey;
1865 }
1866 
1867 void QgsMapLayer::readCommonStyle( const QDomElement &layerElement, const QgsReadWriteContext &context,
1868  QgsMapLayer::StyleCategories categories )
1869 {
1870  if ( categories.testFlag( Symbology3D ) )
1871  {
1872  const QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "3D Symbology" ) );
1873 
1874  QgsAbstract3DRenderer *r3D = nullptr;
1875  QDomElement renderer3DElem = layerElement.firstChildElement( QStringLiteral( "renderer-3d" ) );
1876  if ( !renderer3DElem.isNull() )
1877  {
1878  const QString type3D = renderer3DElem.attribute( QStringLiteral( "type" ) );
1880  if ( meta3D )
1881  {
1882  r3D = meta3D->createRenderer( renderer3DElem, context );
1883  }
1884  }
1885  setRenderer3D( r3D );
1886  }
1887 
1888  if ( categories.testFlag( CustomProperties ) )
1889  {
1890  // read custom properties before passing reading further to a subclass, so that
1891  // the subclass can also read custom properties
1892  readCustomProperties( layerElement );
1893  }
1894 
1895  // use scale dependent visibility flag
1896  if ( categories.testFlag( Rendering ) )
1897  {
1898  setScaleBasedVisibility( layerElement.attribute( QStringLiteral( "hasScaleBasedVisibilityFlag" ) ).toInt() == 1 );
1899  if ( layerElement.hasAttribute( QStringLiteral( "minimumScale" ) ) )
1900  {
1901  // older element, when scales were reversed
1902  setMaximumScale( layerElement.attribute( QStringLiteral( "minimumScale" ) ).toDouble() );
1903  setMinimumScale( layerElement.attribute( QStringLiteral( "maximumScale" ) ).toDouble() );
1904  }
1905  else
1906  {
1907  setMaximumScale( layerElement.attribute( QStringLiteral( "maxScale" ) ).toDouble() );
1908  setMinimumScale( layerElement.attribute( QStringLiteral( "minScale" ) ).toDouble() );
1909  }
1910  }
1911 
1912  if ( categories.testFlag( LayerConfiguration ) )
1913  {
1914  // flags
1915  const QDomElement flagsElem = layerElement.firstChildElement( QStringLiteral( "flags" ) );
1916  LayerFlags flags = mFlags;
1917  const auto enumMap = qgsEnumMap<QgsMapLayer::LayerFlag>();
1918  for ( auto it = enumMap.constBegin(); it != enumMap.constEnd(); ++it )
1919  {
1920  const QDomNode flagNode = flagsElem.namedItem( it.value() );
1921  if ( flagNode.isNull() )
1922  continue;
1923  const bool flagValue = flagNode.toElement().text() == "1" ? true : false;
1924  if ( flags.testFlag( it.key() ) && !flagValue )
1925  flags &= ~it.key();
1926  else if ( !flags.testFlag( it.key() ) && flagValue )
1927  flags |= it.key();
1928  }
1929  setFlags( flags );
1930  }
1931 
1932  if ( categories.testFlag( Temporal ) )
1933  {
1934  const QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Temporal" ) );
1935 
1937  properties->readXml( layerElement.toElement(), context );
1938  }
1939 
1940  if ( categories.testFlag( Elevation ) )
1941  {
1942  const QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Elevation" ) );
1943 
1945  properties->readXml( layerElement.toElement(), context );
1946  }
1947 
1948  if ( categories.testFlag( Notes ) )
1949  {
1950  const QDomElement notesElem = layerElement.firstChildElement( QStringLiteral( "userNotes" ) );
1951  if ( !notesElem.isNull() )
1952  {
1953  const QString notes = notesElem.attribute( QStringLiteral( "value" ) );
1954  QgsLayerNotesUtils::setLayerNotes( this, notes );
1955  }
1956  }
1957 }
1958 
1960 {
1961  return mUndoStack;
1962 }
1963 
1965 {
1966  return mUndoStackStyles;
1967 }
1968 
1970 {
1971  return mCustomProperties.keys();
1972 }
1973 
1974 void QgsMapLayer::setCustomProperty( const QString &key, const QVariant &value )
1975 {
1976  if ( !mCustomProperties.contains( key ) || mCustomProperties.value( key ) != value )
1977  {
1978  mCustomProperties.setValue( key, value );
1979  emit customPropertyChanged( key );
1980  }
1981 }
1982 
1984 {
1985  mCustomProperties = properties;
1986  for ( const QString &key : mCustomProperties.keys() )
1987  {
1988  emit customPropertyChanged( key );
1989  }
1990 }
1991 
1993 {
1994  return mCustomProperties;
1995 }
1996 
1997 QVariant QgsMapLayer::customProperty( const QString &value, const QVariant &defaultValue ) const
1998 {
1999  return mCustomProperties.value( value, defaultValue );
2000 }
2001 
2002 void QgsMapLayer::removeCustomProperty( const QString &key )
2003 {
2004 
2005  if ( mCustomProperties.contains( key ) )
2006  {
2007  mCustomProperties.remove( key );
2008  emit customPropertyChanged( key );
2009  }
2010 }
2011 
2013 {
2014  return mError;
2015 }
2016 
2017 
2018 
2020 {
2021  return false;
2022 }
2023 
2025 {
2026  return false;
2027 }
2028 
2030 {
2031  return true;
2032 }
2033 
2035 {
2036  // invalid layers are temporary? -- who knows?!
2037  if ( !isValid() )
2038  return false;
2039 
2040  if ( mProviderKey == QLatin1String( "memory" ) )
2041  return true;
2042 
2043  const QVariantMap sourceParts = QgsProviderRegistry::instance()->decodeUri( mProviderKey, mDataSource );
2044  const QString path = sourceParts.value( QStringLiteral( "path" ) ).toString();
2045  if ( path.isEmpty() )
2046  return false;
2047 
2048  // check if layer path is inside one of the standard temporary file locations for this platform
2049  const QStringList tempPaths = QStandardPaths::standardLocations( QStandardPaths::TempLocation );
2050  for ( const QString &tempPath : tempPaths )
2051  {
2052  if ( path.startsWith( tempPath ) )
2053  return true;
2054  }
2055 
2056  return false;
2057 }
2058 
2059 void QgsMapLayer::setValid( bool valid )
2060 {
2061  if ( mValid == valid )
2062  return;
2063 
2064  mValid = valid;
2065  emit isValidChanged();
2066 }
2067 
2069 {
2070  if ( legend == mLegend )
2071  return;
2072 
2073  delete mLegend;
2074  mLegend = legend;
2075 
2076  if ( mLegend )
2077  {
2078  mLegend->setParent( this );
2079  connect( mLegend, &QgsMapLayerLegend::itemsChanged, this, &QgsMapLayer::legendChanged, Qt::UniqueConnection );
2080  }
2081 
2082  emit legendChanged();
2083 }
2084 
2086 {
2087  return mLegend;
2088 }
2089 
2091 {
2092  return mStyleManager;
2093 }
2094 
2096 {
2097  if ( renderer == m3DRenderer )
2098  return;
2099 
2100  delete m3DRenderer;
2101  m3DRenderer = renderer;
2102  emit renderer3DChanged();
2103  emit repaintRequested();
2104  trigger3DUpdate();
2105 }
2106 
2108 {
2109  return m3DRenderer;
2110 }
2111 
2112 void QgsMapLayer::triggerRepaint( bool deferredUpdate )
2113 {
2114  if ( mRepaintRequestedFired )
2115  return;
2116  mRepaintRequestedFired = true;
2117  emit repaintRequested( deferredUpdate );
2118  mRepaintRequestedFired = false;
2119 }
2120 
2122 {
2123  emit request3DUpdate();
2124 }
2125 
2127 {
2128  mMetadata = metadata;
2129 // mMetadata.saveToLayer( this );
2130  emit metadataChanged();
2131 }
2132 
2134 {
2135  return QString();
2136 }
2137 
2138 QDateTime QgsMapLayer::timestamp() const
2139 {
2140  return QDateTime();
2141 }
2142 
2144 {
2145  if ( !mBlockStyleChangedSignal )
2146  emit styleChanged();
2147 }
2148 
2150 {
2151  updateExtent( extent );
2152 }
2153 
2154 bool QgsMapLayer::isReadOnly() const
2155 {
2156  return true;
2157 }
2158 
2160 {
2161  return mOriginalXmlProperties;
2162 }
2163 
2164 void QgsMapLayer::setOriginalXmlProperties( const QString &originalXmlProperties )
2165 {
2166  mOriginalXmlProperties = originalXmlProperties;
2167 }
2168 
2169 QString QgsMapLayer::generateId( const QString &layerName )
2170 {
2171  // Generate the unique ID of this layer
2172  const QString uuid = QUuid::createUuid().toString();
2173  // trim { } from uuid
2174  QString id = layerName + '_' + uuid.mid( 1, uuid.length() - 2 );
2175  // Tidy the ID up to avoid characters that may cause problems
2176  // elsewhere (e.g in some parts of XML). Replaces every non-word
2177  // character (word characters are the alphabet, numbers and
2178  // underscore) with an underscore.
2179  // Note that the first backslash in the regular expression is
2180  // there for the compiler, so the pattern is actually \W
2181  id.replace( QRegularExpression( "[\\W]" ), QStringLiteral( "_" ) );
2182  return id;
2183 }
2184 
2186 {
2187  return true;
2188 }
2189 
2190 void QgsMapLayer::setProviderType( const QString &providerType )
2191 {
2193 }
2194 
2195 QSet<QgsMapLayerDependency> QgsMapLayer::dependencies() const
2196 {
2197  return mDependencies;
2198 }
2199 
2200 bool QgsMapLayer::setDependencies( const QSet<QgsMapLayerDependency> &oDeps )
2201 {
2202  QSet<QgsMapLayerDependency> deps;
2203  const auto constODeps = oDeps;
2204  for ( const QgsMapLayerDependency &dep : constODeps )
2205  {
2206  if ( dep.origin() == QgsMapLayerDependency::FromUser )
2207  deps << dep;
2208  }
2209 
2210  mDependencies = deps;
2211  emit dependenciesChanged();
2212  return true;
2213 }
2214 
2216 {
2217  QgsDataProvider *lDataProvider = dataProvider();
2218 
2219  if ( !lDataProvider )
2220  return;
2221 
2222  if ( enabled && !isRefreshOnNotifyEnabled() )
2223  {
2224  lDataProvider->setListening( enabled );
2225  connect( lDataProvider, &QgsDataProvider::notify, this, &QgsMapLayer::onNotified );
2226  }
2227  else if ( !enabled && isRefreshOnNotifyEnabled() )
2228  {
2229  // we don't want to disable provider listening because someone else could need it (e.g. actions)
2230  disconnect( lDataProvider, &QgsDataProvider::notify, this, &QgsMapLayer::onNotified );
2231  }
2232  mIsRefreshOnNofifyEnabled = enabled;
2233 }
2234 
2236 {
2237  if ( QgsMapLayerStore *store = qobject_cast<QgsMapLayerStore *>( parent() ) )
2238  {
2239  return qobject_cast<QgsProject *>( store->parent() );
2240  }
2241  return nullptr;
2242 }
2243 
2244 void QgsMapLayer::onNotified( const QString &message )
2245 {
2246  if ( refreshOnNotifyMessage().isEmpty() || refreshOnNotifyMessage() == message )
2247  {
2248  triggerRepaint();
2249  emit dataChanged();
2250  }
2251 }
2252 
2253 QgsRectangle QgsMapLayer::wgs84Extent( bool forceRecalculate ) const
2254 {
2256 
2257  if ( ! forceRecalculate && ! mWgs84Extent.isNull() )
2258  {
2259  wgs84Extent = mWgs84Extent;
2260  }
2261  else if ( ! mExtent.isNull() )
2262  {
2264  transformer.setBallparkTransformsAreAppropriate( true );
2265  try
2266  {
2267  wgs84Extent = transformer.transformBoundingBox( mExtent );
2268  }
2269  catch ( const QgsCsException &cse )
2270  {
2271  QgsMessageLog::logMessage( tr( "Error transforming extent: %1" ).arg( cse.what() ) );
2273  }
2274  }
2275  return wgs84Extent;
2276 }
2277 
2278 void QgsMapLayer::updateExtent( const QgsRectangle &extent ) const
2279 {
2280  if ( extent == mExtent )
2281  return;
2282 
2283  mExtent = extent;
2284 
2285  // do not update the wgs84 extent if we trust layer metadata
2286  if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2287  return;
2288 
2289  mWgs84Extent = wgs84Extent( true );
2290 }
2291 
2293 {
2294  // do not update the wgs84 extent if we trust layer metadata
2295  if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2296  return;
2297 
2298  mWgs84Extent = QgsRectangle();
2299 }
2300 
2302 {
2303  QString metadata = QStringLiteral( "<h1>" ) + tr( "General" ) + QStringLiteral( "</h1>\n<hr>\n" ) + QStringLiteral( "<table class=\"list-view\">\n" );
2304 
2305  // name
2306  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Name" ) + QStringLiteral( "</td><td>" ) + name() + QStringLiteral( "</td></tr>\n" );
2307 
2308  QString path;
2309  bool isLocalPath = false;
2310  if ( dataProvider() )
2311  {
2312  // local path
2313  QVariantMap uriComponents = QgsProviderRegistry::instance()->decodeUri( dataProvider()->name(), publicSource() );
2314  if ( uriComponents.contains( QStringLiteral( "path" ) ) )
2315  {
2316  path = uriComponents[QStringLiteral( "path" )].toString();
2317  QFileInfo fi( path );
2318  if ( fi.exists() )
2319  {
2320  isLocalPath = true;
2321  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Path" ) + QStringLiteral( "</td><td>%1" ).arg( QStringLiteral( "<a href=\"%1\">%2</a>" ).arg( QUrl::fromLocalFile( path ).toString(), QDir::toNativeSeparators( path ) ) ) + QStringLiteral( "</td></tr>\n" );
2322 
2323  QDateTime lastModified = fi.lastModified();
2324  QString lastModifiedFileName;
2325  QSet<QString> sidecarFiles = QgsFileUtils::sidecarFilesForPath( path );
2326  if ( fi.isFile() )
2327  {
2328  qint64 fileSize = fi.size();
2329  if ( !sidecarFiles.isEmpty() )
2330  {
2331  lastModifiedFileName = fi.fileName();
2332  QStringList sidecarFileNames;
2333  for ( const QString &sidecarFile : sidecarFiles )
2334  {
2335  QFileInfo sidecarFi( sidecarFile );
2336  fileSize += sidecarFi.size();
2337  if ( sidecarFi.lastModified() > lastModified )
2338  {
2339  lastModified = sidecarFi.lastModified();
2340  lastModifiedFileName = sidecarFi.fileName();
2341  }
2342  sidecarFileNames << sidecarFi.fileName();
2343  }
2344  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + ( sidecarFiles.size() > 1 ? tr( "Sidecar files" ) : tr( "Sidecar file" ) ) + QStringLiteral( "</td><td>%1" ).arg( sidecarFileNames.join( QLatin1String( ", " ) ) ) + QStringLiteral( "</td></tr>\n" );
2345  }
2346  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + ( !sidecarFiles.isEmpty() ? tr( "Total size" ) : tr( "Size" ) ) + QStringLiteral( "</td><td>%1" ).arg( QgsFileUtils::representFileSize( fileSize ) ) + QStringLiteral( "</td></tr>\n" );
2347  }
2348  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Last modified" ) + QStringLiteral( "</td><td>%1" ).arg( QLocale().toString( fi.lastModified() ) ) + ( !lastModifiedFileName.isEmpty() ? QStringLiteral( " (%1)" ).arg( lastModifiedFileName ) : QString() ) + QStringLiteral( "</td></tr>\n" );
2349  }
2350  }
2351  if ( uriComponents.contains( QStringLiteral( "url" ) ) )
2352  {
2353  const QString url = uriComponents[QStringLiteral( "url" )].toString();
2354  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "URL" ) + QStringLiteral( "</td><td>%1" ).arg( QStringLiteral( "<a href=\"%1\">%2</a>" ).arg( QUrl( url ).toString(), url ) ) + QStringLiteral( "</td></tr>\n" );
2355  }
2356  }
2357 
2358  // data source
2359  if ( publicSource() != path || !isLocalPath )
2360  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Source" ) + QStringLiteral( "</td><td>%1" ).arg( publicSource() != path ? publicSource() : path ) + QStringLiteral( "</td></tr>\n" );
2361 
2362  // provider
2363  if ( dataProvider() )
2364  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Provider" ) + QStringLiteral( "</td><td>%1" ).arg( dataProvider()->name() ) + QStringLiteral( "</td></tr>\n" );
2365 
2366  metadata += QLatin1String( "</table>\n<br><br>" );
2367  return metadata;
2368 }
2369 
2371 {
2372  QString metadata = QStringLiteral( "<h1>" ) + tr( "Coordinate Reference System (CRS)" ) + QStringLiteral( "</h1>\n<hr>\n" );
2373  metadata += QLatin1String( "<table class=\"list-view\">\n" );
2374 
2375  // Identifier
2377  if ( !c.isValid() )
2378  metadata += QStringLiteral( "<tr><td colspan=\"2\" class=\"highlight\">" ) + tr( "Unknown" ) + QStringLiteral( "</td></tr>\n" );
2379  else
2380  {
2381  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Name" ) + QStringLiteral( "</td><td>" ) + c.userFriendlyIdentifier( QgsCoordinateReferenceSystem::FullString ) + QStringLiteral( "</td></tr>\n" );
2382 
2383  // map units
2384  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Units" ) + QStringLiteral( "</td><td>" )
2385  + ( c.isGeographic() ? tr( "Geographic (uses latitude and longitude for coordinates)" ) : QgsUnitTypes::toString( c.mapUnits() ) )
2386  + QStringLiteral( "</td></tr>\n" );
2387 
2388 
2389  // operation
2390  const QgsProjOperation operation = c.operation();
2391  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Method" ) + QStringLiteral( "</td><td>" ) + operation.description() + QStringLiteral( "</td></tr>\n" );
2392 
2393  // celestial body
2394  try
2395  {
2396  const QString celestialBody = c.celestialBodyName();
2397  if ( !celestialBody.isEmpty() )
2398  {
2399  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Celestial body" ) + QStringLiteral( "</td><td>" ) + celestialBody + QStringLiteral( "</td></tr>\n" );
2400  }
2401  }
2402  catch ( QgsNotSupportedException & )
2403  {
2404 
2405  }
2406 
2407  QString accuracyString;
2408  // dynamic crs with no epoch?
2409  if ( c.isDynamic() && std::isnan( c.coordinateEpoch() ) )
2410  {
2411  accuracyString = tr( "Based on a dynamic CRS, but no coordinate epoch is set. Coordinates are ambiguous and of limited accuracy." );
2412  }
2413 
2414  // based on datum ensemble?
2415  try
2416  {
2417  const QgsDatumEnsemble ensemble = c.datumEnsemble();
2418  if ( ensemble.isValid() )
2419  {
2420  QString id;
2421  if ( !ensemble.code().isEmpty() )
2422  id = QStringLiteral( "<i>%1</i> (%2:%3)" ).arg( ensemble.name(), ensemble.authority(), ensemble.code() );
2423  else
2424  id = QStringLiteral( "<i>%</i>”" ).arg( ensemble.name() );
2425 
2426  if ( ensemble.accuracy() > 0 )
2427  {
2428  accuracyString = tr( "Based on %1, which has a limited accuracy of <b>at best %2 meters</b>." ).arg( id ).arg( ensemble.accuracy() );
2429  }
2430  else
2431  {
2432  accuracyString = tr( "Based on %1, which has a limited accuracy." ).arg( id );
2433  }
2434  }
2435  }
2436  catch ( QgsNotSupportedException & )
2437  {
2438 
2439  }
2440 
2441  if ( !accuracyString.isEmpty() )
2442  {
2443  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Accuracy" ) + QStringLiteral( "</td><td>" ) + accuracyString + QStringLiteral( "</td></tr>\n" );
2444  }
2445 
2446  // static/dynamic
2447  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Reference" ) + QStringLiteral( "</td><td>%1</td></tr>\n" ).arg( c.isDynamic() ? tr( "Dynamic (relies on a datum which is not plate-fixed)" ) : tr( "Static (relies on a datum which is plate-fixed)" ) );
2448 
2449  // coordinate epoch
2450  if ( !std::isnan( c.coordinateEpoch() ) )
2451  {
2452  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Coordinate epoch" ) + QStringLiteral( "</td><td>%1</td></tr>\n" ).arg( c.coordinateEpoch() );
2453  }
2454  }
2455 
2456  metadata += QLatin1String( "</table>\n<br><br>\n" );
2457  return metadata;
2458 }
static QString version()
Version string.
Definition: qgis.cpp:277
static const double SCALE_PRECISION
Fudge factor used to compare two scales.
Definition: qgis.h:2018
@ ForceFirstLetterToCapital
Convert just the first letter of each word to uppercase, leave the rest untouched.
Base metadata class for 3D renderers.
virtual QgsAbstract3DRenderer * createRenderer(QDomElement &elem, const QgsReadWriteContext &context)=0
Returns new instance of the renderer given the DOM element.
Qgs3DRendererAbstractMetadata * rendererMetadata(const QString &type) const
Returns metadata for a 3D renderer type (may be used to create a new instance of the type)
Base class for all renderers that may to participate in 3D view.
virtual QString type() const =0
Returns unique identifier of the renderer class (used to identify subclass)
virtual void writeXml(QDomElement &elem, const QgsReadWriteContext &context) const =0
Writes renderer's properties to given XML element.
virtual void resolveReferences(const QgsProject &project)
Resolves references to other objects - second phase of loading - after readXml()
static QString pkgDataPath()
Returns the common root path of all application data directories.
static QString qgisSettingsDirPath()
Returns the path to the settings directory in user's home dir.
static QgsAuthManager * authManager()
Returns the application's authentication manager instance.
static Qgs3DRendererRegistry * renderer3DRegistry()
Returns registry of available 3D renderers.
bool setMasterPassword(bool verify=false)
Main call to initially set or continually check master password is set.
This class represents a coordinate reference system (CRS).
static QgsCoordinateReferenceSystem fromOgcWmsCrs(const QString &ogcCrs)
Creates a CRS from a given OGC WMS-format Coordinate Reference System string.
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
void validate()
Perform some validation on this CRS.
static CUSTOM_CRS_VALIDATION customCrsValidation()
Gets custom function.
bool readXml(const QDomNode &node)
Restores state from the given DOM node.
static void setCustomCrsValidation(CUSTOM_CRS_VALIDATION f)
Sets custom function to force valid CRS.
void setValidationHint(const QString &html)
Set user hint for validation.
@ FullString
Full definition – possibly a very lengthy string, e.g. with no truncation of custom WKT definitions.
bool writeXml(QDomNode &node, QDomDocument &doc) const
Stores state to the given Dom node in the given document.
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
Abstract base class for spatial data provider implementations.
@ FlagLoadDefaultStyle
Reset the layer's style to the default for the datasource.
@ FlagTrustDataSource
Trust datasource config (primary key unicity, geometry type and srid, etc). Improves provider load ti...
QgsCoordinateTransformContext transformContext() const
Returns data provider coordinate transform context.
virtual void setListening(bool isListening)
Set whether the provider will listen to datasource notifications If set, the provider will issue noti...
void notify(const QString &msg)
Emitted when the datasource issues a notification.
static QString removePassword(const QString &aUri)
Removes the password element from a URI.
Contains information about a datum ensemble.
Definition: qgsdatums.h:95
QString code() const
Identification code, e.g.
Definition: qgsdatums.h:122
QString authority() const
Authority name, e.g.
Definition: qgsdatums.h:117
bool isValid() const
Returns true if the datum ensemble is a valid object, or false if it is a null/invalid object.
Definition: qgsdatums.h:102
QString name() const
Display name of datum ensemble.
Definition: qgsdatums.h:107
double accuracy() const
Positional accuracy (in meters).
Definition: qgsdatums.h:112
QgsError is container for error messages (report).
Definition: qgserror.h:81
QString what() const
Definition: qgsexception.h:48
static QSet< QString > sidecarFilesForPath(const QString &path)
Returns a list of the sidecar files which exist for the dataset a the specified path.
static QString representFileSize(qint64 bytes)
Returns the human size from bytes.
A structured metadata store for a map layer.
bool readMetadataXml(const QDomElement &metadataElement) override
Sets state from DOM document.
bool writeMetadataXml(QDomElement &metadataElement, QDomDocument &document) const override
Stores state in a DOM node.
static void setLayerNotes(QgsMapLayer *layer, const QString &notes)
Sets the notes for the specified layer, where notes is a HTML formatted string.
static bool layerHasNotes(const QgsMapLayer *layer)
Returns true if the specified layer has notes available.
static QString layerNotes(const QgsMapLayer *layer)
Returns the notes for the specified layer.
This class models dependencies with or between map layers.
Base class for storage of map layer elevation properties.
The QgsMapLayerLegend class is abstract interface for implementations of legends for one map layer.
void itemsChanged()
Emitted when existing items/nodes got invalid and should be replaced by new ones.
Manages QGIS Server properties for a map layer.
void readXml(const QDomNode &layer_node)
Reads server properties from project file.
void copyTo(QgsMapLayerServerProperties *properties) const
Copy properties to another instance.
A storage object for map layers, in which the layers are owned by the store and have their lifetime b...
Management of styles for use with one map layer.
bool addStyle(const QString &name, const QgsMapLayerStyle &style)
Add a style with given name and data.
QStringList styles() const
Returns list of all defined style names.
void writeXml(QDomElement &mgrElement) const
Write configuration (for project saving)
void reset()
Reset the style manager to a basic state - with one default style which is set as current.
void readXml(const QDomElement &mgrElement)
Read configuration (for project loading)
Base class for storage of map layer temporal properties.
Base class for all map layer types.
Definition: qgsmaplayer.h:73
QString mKeywordList
Definition: qgsmaplayer.h:1951
void setShortName(const QString &shortName)
Sets the short name of the layer used by QGIS Server to identify the layer.
Definition: qgsmaplayer.h:288
bool importNamedMetadata(QDomDocument &document, QString &errorMessage)
Import the metadata of this layer from a QDomDocument.
QString name
Definition: qgsmaplayer.h:76
void readStyleManager(const QDomNode &layerNode)
Read style manager's configuration (if any). To be called by subclasses.
virtual bool writeSymbology(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) const =0
Write the style for the layer into the document provided.
QString legendUrlFormat() const
Returns the format for a URL based layer legend.
Definition: qgsmaplayer.h:1297
QgsRectangle wgs84Extent(bool forceRecalculate=false) const
Returns the WGS84 extent (EPSG:4326) of the layer according to ReadFlag::FlagTrustLayerMetadata.
void setRefreshOnNotifyEnabled(bool enabled)
Set whether provider notification is connected to triggerRepaint.
virtual bool isSpatial() const
Returns true if the layer is considered a spatial layer, ie it has some form of geometry associated w...
QgsAbstract3DRenderer * renderer3D() const
Returns 3D renderer associated with the layer.
virtual bool isTemporary() const
Returns true if the layer is considered a temporary layer.
virtual void exportNamedStyle(QDomDocument &doc, QString &errorMsg, const QgsReadWriteContext &context=QgsReadWriteContext(), QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) const
Export the properties of this layer as named style in a QDomDocument.
virtual bool accept(QgsStyleEntityVisitorInterface *visitor) const
Accepts the specified symbology visitor, causing it to visit all symbols associated with the layer.
void dependenciesChanged()
Emitted when dependencies are changed.
bool isInScaleRange(double scale) const
Tests whether the layer should be visible at the specified scale.
void legendChanged()
Signal emitted when legend of the layer has 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.
virtual bool importNamedStyle(QDomDocument &doc, QString &errorMsg, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories)
Import the properties of this layer from a QDomDocument.
void setAbstract(const QString &abstract)
Sets the abstract of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:318
void metadataChanged()
Emitted when the layer's metadata is changed.
virtual QgsRectangle extent() const
Returns the extent of the layer.
virtual QString saveSldStyle(const QString &uri, bool &resultFlag) const
Saves the properties of this layer to an SLD format file.
QString source() const
Returns the source for the layer.
void setLegendUrl(const QString &legendUrl)
Sets the URL for the layer's legend.
Definition: qgsmaplayer.h:1282
virtual bool setDependencies(const QSet< QgsMapLayerDependency > &layers)
Sets the list of dependencies.
void request3DUpdate()
Signal emitted when a layer requires an update in any 3D maps.
Q_INVOKABLE QVariant customProperty(const QString &value, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer.
QgsError mError
Error.
Definition: qgsmaplayer.h:1966
int mBlockStyleChangedSignal
If non-zero, the styleChanged signal should not be emitted.
Definition: qgsmaplayer.h:2008
QString providerType() const
Returns the provider type (provider key) for this layer.
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.
QgsMapLayerType type
Definition: qgsmaplayer.h:80
void configChanged()
Emitted whenever the configuration is changed.
void trigger3DUpdate()
Will advise any 3D maps that this layer requires to be updated in the scene.
void autoRefreshIntervalChanged(int interval)
Emitted when the auto refresh interval changes.
void setMinimumScale(double scale)
Sets the minimum map scale (i.e.
virtual QSet< QgsMapLayerDependency > dependencies() const
Gets the list of dependencies.
void setCustomProperties(const QgsObjectCustomProperties &properties)
Set custom properties for layer.
virtual QString encodedSource(const QString &source, const QgsReadWriteContext &context) const
Called by writeLayerXML(), used by derived classes to encode provider's specific data source to proje...
QgsMapLayer(QgsMapLayerType type=QgsMapLayerType::VectorLayer, const QString &name=QString(), const QString &source=QString())
Constructor for QgsMapLayer.
Definition: qgsmaplayer.cpp:81
QString publicSource() const
Gets a version of the internal layer definition that has sensitive bits removed (for example,...
QgsMapLayer::LayerFlags flags() const
Returns the flags for this layer.
virtual void setSubLayerVisibility(const QString &name, bool visible)
Set the visibility of the given sublayer name.
void isValidChanged()
Emitted when the validity of this layer changed.
QgsCoordinateReferenceSystem crs
Definition: qgsmaplayer.h:79
bool loadNamedMetadataFromDatabase(const QString &db, const QString &uri, QString &qmd)
Retrieve a named metadata for this layer from a sqlite database.
virtual bool readXml(const QDomNode &layer_node, QgsReadWriteContext &context)
Called by readLayerXML(), used by children to read state specific to them from project files.
QString attribution() const
Returns the attribution of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:400
void setOriginalXmlProperties(const QString &originalXmlProperties)
Sets the original XML properties for the layer to originalXmlProperties.
void writeCustomProperties(QDomNode &layerNode, QDomDocument &doc) const
Write custom properties to project file.
QString mRefreshOnNofifyMessage
Definition: qgsmaplayer.h:1979
QString mLegendUrl
WMS legend.
Definition: qgsmaplayer.h:1962
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
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...
QString mLayerName
Name of the layer - used for display.
Definition: qgsmaplayer.h:1944
virtual QString loadNamedMetadata(const QString &uri, bool &resultFlag)
Retrieve a named metadata for this layer if one exists (either as a .qmd file on disk or as a record ...
virtual bool writeXml(QDomNode &layer_node, QDomDocument &document, const QgsReadWriteContext &context) const
Called by writeLayerXML(), used by children to write state specific to them to project files.
bool hasAutoRefreshEnabled() const
Returns true if auto refresh is enabled for the layer.
void triggerRepaint(bool deferredUpdate=false)
Will advise the map canvas (and any other interested party) that this layer requires to be repainted.
QString crsHtmlMetadata() const
Returns a HTML fragment containing the layer's CRS metadata, for use in the htmlMetadata() method.
void setAttributionUrl(const QString &attribUrl)
Sets the attribution URL of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:409
void setAutoRefreshEnabled(bool enabled)
Sets whether auto refresh is enabled for the layer.
void setMaximumScale(double scale)
Sets the maximum map scale (i.e.
QgsLayerMetadata metadata
Definition: qgsmaplayer.h:78
static QString formatLayerName(const QString &name)
A convenience function to capitalize and format a layer name.
void renderer3DChanged()
Signal emitted when 3D renderer associated with the layer has changed.
QString originalXmlProperties() const
Returns the XML properties of the original layer as they were when the layer was first read from the ...
QString dataUrlFormat() const
Returns the DataUrl format of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:380
QgsMapLayerServerProperties * serverProperties()
Returns QGIS Server Properties for the map layer.
Definition: qgsmaplayer.h:426
QPainter::CompositionMode blendMode() const
Returns the current blending mode for a layer.
QString mTitle
Definition: qgsmaplayer.h:1947
void setDataUrl(const QString &dataUrl)
Sets the DataUrl of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:353
virtual void setOpacity(double opacity)
Sets the opacity for the layer, where opacity is a value between 0 (totally transparent) and 1....
void setKeywordList(const QString &keywords)
Sets the keyword list of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:334
void setAttribution(const QString &attrib)
Sets the attribution of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:391
void setFlags(QgsMapLayer::LayerFlags flags)
Returns the flags for this layer.
bool isRefreshOnNotifyEnabled() const
Returns true if the refresh on provider nofification is enabled.
Definition: qgsmaplayer.h:1459
QString shortName() const
Returns the short name of the layer used by QGIS Server to identify the layer.
QSet< QgsMapLayerDependency > mDependencies
List of layers that may modify this layer on modification.
Definition: qgsmaplayer.h:1969
void readCustomProperties(const QDomNode &layerNode, const QString &keyStartsWith=QString())
Read custom properties from project file.
virtual Qgis::MapLayerProperties properties() const
Returns the map layer properties of this layer.
virtual QString loadSldStyle(const QString &uri, bool &resultFlag)
Attempts to style the layer using the formatting from an SLD type file.
virtual void setMetadata(const QgsLayerMetadata &metadata)
Sets the layer's metadata store.
virtual bool readStyle(const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories)
Read the style for the current layer from the DOM node supplied.
virtual QString saveDefaultMetadata(bool &resultFlag)
Save the current metadata of this layer as the default metadata (either as a .qmd file on disk or as ...
virtual bool supportsEditing() const
Returns whether the layer supports editing or not.
void setDataUrlFormat(const QString &dataUrlFormat)
Sets the DataUrl format of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:371
QString mLegendUrlFormat
Definition: qgsmaplayer.h:1963
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:1982
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.
virtual bool isEditable() const
Returns true if the layer can be edited.
QUndoStack * undoStack()
Returns pointer to layer's undo stack.
QString title() const
Returns the title of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:310
void crsChanged()
Emit a signal that layer's CRS has been reset.
virtual QgsError error() const
Gets current status error.
bool writeLayerXml(QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context) const
Stores state in DOM node.
virtual QString styleURI() const
Retrieve the style URI for this layer (either as a .qml file on disk or as a record in the users styl...
QString mAttributionUrl
Definition: qgsmaplayer.h:1959
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.
QString dataUrl() const
Returns the DataUrl of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:362
bool readLayerXml(const QDomElement &layerElement, QgsReadWriteContext &context, QgsMapLayer::ReadFlags flags=QgsMapLayer::ReadFlags())
Sets state from DOM document.
bool hasScaleBasedVisibility() const
Returns whether scale based visibility is enabled for the layer.
virtual QString loadNamedStyle(const QString &uri, bool &resultFlag, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories)
Retrieve a named style for this layer if one exists (either as a .qml file on disk or as a record in ...
virtual QgsMapLayer * clone() const =0
Returns a new instance equivalent to this one except for the id which is still unique.
Q_DECL_DEPRECATED QString metadataUrlFormat() const
Returns the metadata format of the layer used by QGIS Server in GetCapabilities request.
void setRefreshOnNofifyMessage(const QString &message)
Set the notification message that triggers repaint If refresh on notification is enabled,...
Definition: qgsmaplayer.h:1606
static QString generateId(const QString &layerName)
Generates an unique identifier for this layer, the generate ID is prefixed by layerName.
void opacityChanged(double opacity)
Emitted when the layer's opacity is changed, where opacity is a value between 0 (transparent) and 1 (...
virtual bool isModified() const
Returns true if the layer has been modified since last commit/save.
void emitStyleChanged()
Triggers an emission of the styleChanged() signal.
QString mShortName
Definition: qgsmaplayer.h:1946
QUndoStack * undoStackStyles()
Returns pointer to layer's style undo stack.
void dataChanged()
Data of layer changed.
virtual QStringList subLayers() const
Returns the sublayers of this layer.
virtual QString htmlMetadata() const
Obtain a formatted HTML string containing assorted metadata for this layer.
Q_DECL_DEPRECATED void setMetadataUrlFormat(const QString &metaUrlFormat)
Sets the metadata format of the layer used by QGIS Server in GetCapabilities request.
virtual bool loadNamedStyleFromDatabase(const QString &db, const QString &uri, QString &qml)
Retrieve a named style for this layer from a sqlite database.
static QString extensionPropertyType(PropertyType type)
Returns the extension of a Property.
Definition: qgsmaplayer.cpp:68
void blendModeChanged(QPainter::CompositionMode blendMode)
Signal emitted when the blend mode is changed, through QgsMapLayer::setBlendMode()
void setName(const QString &name)
Set the display name of the layer.
void setAutoRefreshInterval(int interval)
Sets the auto refresh interval (in milliseconds) for the layer.
virtual bool readSymbology(const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories)=0
Read the symbology for the current layer from the DOM node supplied.
Q_DECL_DEPRECATED QString metadataUrl() const
Returns the metadata URL of the layer used by QGIS Server in GetCapabilities request.
virtual void setExtent(const QgsRectangle &rect)
Sets the extent.
virtual void resolveReferences(QgsProject *project)
Resolve references to other layers (kept as layer IDs after reading XML) into layer objects.
QString saveNamedMetadata(const QString &uri, bool &resultFlag)
Save the current metadata of this layer as a named metadata (either as a .qmd file on disk or as a re...
bool isValid
Definition: qgsmaplayer.h:81
QString mDataSource
Data source description string, varies by layer type.
Definition: qgsmaplayer.h:1941
QString refreshOnNotifyMessage() const
Returns the message that should be notified by the provider to triggerRepaint.
Definition: qgsmaplayer.h:1452
virtual bool readSld(const QDomNode &node, QString &errorMessage)
Definition: qgsmaplayer.h:1160
virtual QString loadDefaultMetadata(bool &resultFlag)
Retrieve the default metadata for this layer if one exists (either as a .qmd file on disk or as a rec...
@ FlagReadExtentFromXml
Read extent from xml and skip get extent from provider.
Definition: qgsmaplayer.h:642
@ FlagTrustLayerMetadata
Trust layer metadata. Improves layer load time by skipping expensive checks like primary key unicity,...
Definition: qgsmaplayer.h:641
void setValid(bool valid)
Sets whether layer is valid or not.
QString attributionUrl() const
Returns the attribution URL of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:418
void readCommonStyle(const QDomElement &layerElement, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories)
Read style data common to all layer types.
QString mAbstract
Description of the layer.
Definition: qgsmaplayer.h:1950
void customPropertyChanged(const QString &key)
Emitted when a custom property of the layer has been changed or removed.
QgsMapLayer::ReadFlags mReadFlags
Read flags. It's up to the subclass to respect these when restoring state from XML.
Definition: qgsmaplayer.h:1987
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.
QgsMapLayerStyleManager * styleManager() const
Gets access to the layer's style manager.
QString legendUrl() const
Returns the URL for the layer's legend.
Definition: qgsmaplayer.h:1287
QString mDataUrlFormat
Definition: qgsmaplayer.h:1955
void flagsChanged()
Emitted when layer's flags have been modified.
void repaintRequested(bool deferredUpdate=false)
By emitting this signal the layer tells that either appearance or content have been changed and any v...
void setLegendUrlFormat(const QString &legendUrlFormat)
Sets the format for a URL based layer legend.
Definition: qgsmaplayer.h:1292
void exportNamedMetadata(QDomDocument &doc, QString &errorMsg) const
Export the current metadata of this layer as named metadata in a QDomDocument.
virtual QString saveNamedStyle(const QString &uri, bool &resultFlag, StyleCategories categories=AllStyleCategories)
Save the properties of this layer as a named style (either as a .qml file on disk or as a record in t...
virtual void exportSldStyle(QDomDocument &doc, QString &errorMsg) const
Export the properties of this layer as SLD style in a QDomDocument.
void beforeResolveReferences(QgsProject *project)
Emitted when all layers are loaded and references can be resolved, just before the references of this...
Q_DECL_DEPRECATED void setMetadataUrl(const QString &metaUrl)
Sets the metadata URL of the layer used by QGIS Server in GetCapabilities request.
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.
Q_DECL_DEPRECATED void setMetadataUrlType(const QString &metaUrlType)
Set the metadata type of the layer used by QGIS Server in GetCapabilities request MetadataUrlType ind...
void setLegend(QgsMapLayerLegend *legend)
Assign a legend controller to the map layer.
virtual QgsMapLayerElevationProperties * elevationProperties()
Returns the layer's elevation properties.
Definition: qgsmaplayer.h:1509
double opacity
Definition: qgsmaplayer.h:82
virtual QString decodedSource(const QString &source, const QString &dataProvider, const QgsReadWriteContext &context) const
Called by readLayerXML(), used by derived classes to decode provider's specific data source from proj...
void nameChanged()
Emitted when the name has been changed.
virtual QString metadataUri() const
Retrieve the metadata URI for this layer (either as a .qmd file on disk or as a record in the users s...
int autoRefreshInterval
Definition: qgsmaplayer.h:77
virtual bool writeStyle(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) const
Write just the symbology information for the layer into the document.
bool mIsRefreshOnNofifyEnabled
Definition: qgsmaplayer.h:1978
QString mDataUrl
DataUrl of the layer.
Definition: qgsmaplayer.h:1954
virtual Q_INVOKABLE QgsDataProvider * dataProvider()
Returns the layer's data provider, it may be nullptr.
double mLayerOpacity
Layer opacity.
Definition: qgsmaplayer.h:2001
bool mValid
Indicates if the layer is valid and can be drawn.
Definition: qgsmaplayer.h:1938
@ AllStyleCategories
Definition: qgsmaplayer.h:178
@ LayerConfiguration
General configuration: identifiable, removable, searchable, display expression, read-only.
Definition: qgsmaplayer.h:160
@ Symbology
Symbology.
Definition: qgsmaplayer.h:161
@ Notes
Layer user notes (since QGIS 3.20)
Definition: qgsmaplayer.h:177
@ Temporal
Temporal properties (since QGIS 3.14)
Definition: qgsmaplayer.h:174
@ Rendering
Rendering: scale visibility, simplify method, opacity.
Definition: qgsmaplayer.h:170
@ Elevation
Elevation settings (since QGIS 3.18)
Definition: qgsmaplayer.h:176
@ Symbology3D
3D symbology
Definition: qgsmaplayer.h:162
@ CustomProperties
Custom properties (by plugins for instance)
Definition: qgsmaplayer.h:171
virtual QDateTime timestamp() const
Time stamp of data source in the moment when data/metadata were loaded by provider.
void setProviderType(const QString &providerType)
Sets the providerType (provider key)
virtual QgsMapLayerTemporalProperties * temporalProperties()
Returns the layer's temporal properties.
Definition: qgsmaplayer.h:1502
virtual QString saveDefaultStyle(bool &resultFlag, StyleCategories categories)
Save the properties of this layer as the default style (either as a .qml file on disk or as a record ...
void setRenderer3D(QgsAbstract3DRenderer *renderer)
Sets 3D renderer for the layer.
QString mAttribution
Attribution of the layer.
Definition: qgsmaplayer.h:1958
~QgsMapLayer() override
Definition: qgsmaplayer.cpp:99
const QgsObjectCustomProperties & customProperties() const
Read all custom properties from layer.
QString generalHtmlMetadata() const
Returns an HTML fragment containing general metadata information, for use in the htmlMetadata() metho...
Q_DECL_DEPRECATED QString metadataUrlType() const
Returns the metadata type of the layer used by QGIS Server in GetCapabilities request.
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 keywordList() const
Returns the keyword list of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:342
virtual void setLayerOrder(const QStringList &layers)
Reorders the previously selected sublayers of this layer from bottom to top.
void invalidateWgs84Extent()
Invalidates the WGS84 extent.
void setTitle(const QString &title)
Sets the title of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:302
PropertyType
Maplayer has a style and a metadata property.
Definition: qgsmaplayer.h:133
bool mShouldValidateCrs
true if the layer's CRS should be validated and invalid CRSes are not permitted.
Definition: qgsmaplayer.h:1994
void setCrs(const QgsCoordinateReferenceSystem &srs, bool emitSignal=true)
Sets layer's spatial reference system.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
Custom exception class which is raised when an operation is not supported.
Definition: qgsexception.h:118
Simple key-value store (keys = strings, values = variants) that supports loading/saving to/from XML i...
void setValue(const QString &key, const QVariant &value)
Add an entry to the store with the specified key.
QStringList keys() const
Returns a list of all stored keys.
void writeXml(QDomNode &parentNode, QDomDocument &doc) const
Writes the store contents to an XML node.
void remove(const QString &key)
Removes a key (entry) from the store.
QVariant value(const QString &key, const QVariant &defaultValue=QVariant()) const
Returns the value for the given key.
void readXml(const QDomNode &parentNode, const QString &keyStartsWith=QString())
Read store contents from an XML node.
bool contains(const QString &key) const
Returns true if the properties contains a key with the specified name.
QString writePath(const QString &filename) const
Prepare a filename to save it to the project file.
QString readPath(const QString &filename) const
Turn filename read from the project file to an absolute path.
Contains information about a PROJ operation.
QString description() const
Description.
Class to convert from older project file versions to newer.
bool updateRevision(const QgsProjectVersion &version)
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.
A class to describe the version of a project.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition: qgsproject.h:104
bool removeAttachedFile(const QString &path)
Removes the attached file.
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:479
QString baseName() const
Returns the base name of the project file without the path and without extension - derived from fileN...
Definition: qgsproject.cpp:833
QString absoluteFilePath() const
Returns full absolute path to the project file if the project is stored in a file system - derived fr...
Definition: qgsproject.cpp:822
Holds data provider key, description, and associated shared library file or function pointer informat...
@ SaveLayerMetadata
Indicates that the provider supports saving native layer metadata (since QGIS 3.20)
QVariantMap decodeUri(const QString &providerKey, const QString &uri)
Breaks a provider data source URI into its component paths (e.g.
static QgsProviderRegistry * instance(const QString &pluginPath=QString())
Means of accessing canonical single instance.
bool saveLayerMetadata(const QString &providerKey, const QString &uri, const QgsLayerMetadata &metadata, QString &errorMessage) SIP_THROW(QgsNotSupportedException)
Saves metadata to the layer corresponding to the specified uri.
Represents a raster layer.
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.0.0 format.
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.
const QgsPathResolver & pathResolver() const
Returns path resolver for conversion between relative and absolute paths.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
bool isNull() const
Test if the rectangle is null (all coordinates zero or after call to setMinimal()).
Definition: qgsrectangle.h:479
void setMetadataUrls(const QList< QgsServerMetadataUrlProperties::MetadataUrl > &metaUrls)
Sets a the list of metadata URL for the layer.
QList< QgsServerMetadataUrlProperties::MetadataUrl > metadataUrls() const
Returns a list of metadataUrl resources associated for the layer.
static QString capitalize(const QString &string, Qgis::Capitalization capitalization)
Converts a string by applying capitalization rules to the string.
An interface for classes which can visit style entity (e.g.
static Q_INVOKABLE QString toString(QgsUnitTypes::DistanceUnit unit)
Returns a translated string representing a distance unit.
Represents a vector layer which manages a vector based data sets.
Q_INVOKABLE QgsWkbTypes::GeometryType geometryType() const
Returns point, line or polygon.
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.
GeometryType
The geometry types are used to group QgsWkbTypes::Type in a coarse way.
Definition: qgswkbtypes.h:141
static T readFlagAttribute(const QDomElement &element, const QString &attributeName, T defaultValue)
Read a flag value from an attribute of the element.
Definition: qgsxmlutils.h:99
static QDomElement writeRectangle(const QgsRectangle &rect, QDomDocument &doc, const QString &elementName=QStringLiteral("extent"))
Encodes a rectangle to a DOM element.
Definition: qgsxmlutils.cpp:81
static QgsRectangle readRectangle(const QDomElement &element)
Definition: qgsxmlutils.cpp:39
Unique pointer for sqlite3 databases, which automatically closes the database when the pointer goes o...
sqlite3_statement_unique_ptr prepare(const QString &sql, int &resultCode) const
Prepares a sql statement, returning the result.
int open(const QString &path)
Opens the database at the specified file path.
int open_v2(const QString &path, int flags, const char *zVfs)
Opens the database at the specified file path.
Unique pointer for sqlite3 prepared statements, which automatically finalizes the statement when the ...
QgsMapLayerType
Types of layers that can be added to a map.
Definition: qgis.h:47
@ VectorLayer
Vector layer.
@ AnnotationLayer
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
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 qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
Definition: qgis.h:2260
CONSTLATIN1STRING geoEpsgCrsAuthId()
Geographic coord sys from EPSG authority.
Definition: qgis.h:2727
void(* CUSTOM_CRS_VALIDATION)(QgsCoordinateReferenceSystem &)
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
Setting options for creating vector data providers.
QString format
Format specification of online resource.