QGIS API Documentation  3.23.0-Master (4fd2f04bd0)
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 saveNamedStyle( styleURI(), resultFlag );
1326 }
1327 
1328 QString QgsMapLayer::saveNamedMetadata( const QString &uri, bool &resultFlag )
1329 {
1330  return saveNamedProperty( uri, QgsMapLayer::Metadata, resultFlag );
1331 }
1332 
1333 QString QgsMapLayer::loadNamedMetadata( const QString &uri, bool &resultFlag )
1334 {
1335  return loadNamedProperty( uri, QgsMapLayer::Metadata, resultFlag );
1336 }
1337 
1338 QString QgsMapLayer::saveNamedProperty( const QString &uri, QgsMapLayer::PropertyType type, bool &resultFlag, StyleCategories categories )
1339 {
1340  // check if the uri is a file or ends with .qml/.qmd,
1341  // which indicates that it should become one
1342  // everything else goes to the database
1343  QString filename;
1344 
1345  QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( this );
1346  if ( vlayer && vlayer->providerType() == QLatin1String( "ogr" ) )
1347  {
1348  QStringList theURIParts = uri.split( '|' );
1349  filename = theURIParts[0];
1350  }
1351  else if ( vlayer && vlayer->providerType() == QLatin1String( "gpx" ) )
1352  {
1353  QStringList theURIParts = uri.split( '?' );
1354  filename = theURIParts[0];
1355  }
1356  else if ( vlayer && vlayer->providerType() == QLatin1String( "delimitedtext" ) )
1357  {
1358  filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1359  // toLocalFile() returns an empty string if theURI is a plain Windows-path, e.g. "C:/style.qml"
1360  if ( filename.isEmpty() )
1361  filename = uri;
1362  }
1363  else
1364  {
1365  filename = uri;
1366  }
1367 
1368  QString myErrorMessage;
1369  QDomDocument myDocument;
1370  switch ( type )
1371  {
1372  case Metadata:
1373  exportNamedMetadata( myDocument, myErrorMessage );
1374  break;
1375 
1376  case Style:
1377  const QgsReadWriteContext context;
1378  exportNamedStyle( myDocument, myErrorMessage, context, categories );
1379  break;
1380  }
1381 
1382  const QFileInfo myFileInfo( filename );
1383  if ( myFileInfo.exists() || filename.endsWith( QgsMapLayer::extensionPropertyType( type ), Qt::CaseInsensitive ) )
1384  {
1385  const QFileInfo myDirInfo( myFileInfo.path() ); //excludes file name
1386  if ( !myDirInfo.isWritable() )
1387  {
1388  return tr( "The directory containing your dataset needs to be writable!" );
1389  }
1390 
1391  // now construct the file name for our .qml or .qmd file
1392  const QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + QgsMapLayer::extensionPropertyType( type );
1393 
1394  QFile myFile( myFileName );
1395  if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1396  {
1397  QTextStream myFileStream( &myFile );
1398  // save as utf-8 with 2 spaces for indents
1399  myDocument.save( myFileStream, 2 );
1400  myFile.close();
1401  resultFlag = true;
1402  switch ( type )
1403  {
1404  case Metadata:
1405  return tr( "Created default metadata file as %1" ).arg( myFileName );
1406 
1407  case Style:
1408  return tr( "Created default style file as %1" ).arg( myFileName );
1409  }
1410 
1411  }
1412  else
1413  {
1414  resultFlag = false;
1415  switch ( type )
1416  {
1417  case Metadata:
1418  return tr( "ERROR: Failed to created default metadata file as %1. Check file permissions and retry." ).arg( myFileName );
1419 
1420  case Style:
1421  return tr( "ERROR: Failed to created default style file as %1. Check file permissions and retry." ).arg( myFileName );
1422  }
1423  }
1424  }
1425  else
1426  {
1427  const QString qml = myDocument.toString();
1428 
1429  // read from database
1430  sqlite3_database_unique_ptr database;
1431  sqlite3_statement_unique_ptr statement;
1432 
1433  int myResult = database.open( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( QStringLiteral( "qgis.qmldb" ) ) );
1434  if ( myResult != SQLITE_OK )
1435  {
1436  return tr( "User database could not be opened." );
1437  }
1438 
1439  QByteArray param0 = uri.toUtf8();
1440  QByteArray param1 = qml.toUtf8();
1441 
1442  QString mySql;
1443  switch ( type )
1444  {
1445  case Metadata:
1446  mySql = QStringLiteral( "create table if not exists tbl_metadata(metadata varchar primary key,qmd varchar)" );
1447  break;
1448 
1449  case Style:
1450  mySql = QStringLiteral( "create table if not exists tbl_styles(style varchar primary key,qml varchar)" );
1451  break;
1452  }
1453 
1454  statement = database.prepare( mySql, myResult );
1455  if ( myResult == SQLITE_OK )
1456  {
1457  if ( sqlite3_step( statement.get() ) != SQLITE_DONE )
1458  {
1459  resultFlag = false;
1460  switch ( type )
1461  {
1462  case Metadata:
1463  return tr( "The metadata table could not be created." );
1464 
1465  case Style:
1466  return tr( "The style table could not be created." );
1467  }
1468  }
1469  }
1470 
1471  switch ( type )
1472  {
1473  case Metadata:
1474  mySql = QStringLiteral( "insert into tbl_metadata(metadata,qmd) values (?,?)" );
1475  break;
1476 
1477  case Style:
1478  mySql = QStringLiteral( "insert into tbl_styles(style,qml) values (?,?)" );
1479  break;
1480  }
1481  statement = database.prepare( mySql, myResult );
1482  if ( myResult == SQLITE_OK )
1483  {
1484  if ( sqlite3_bind_text( statement.get(), 1, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&
1485  sqlite3_bind_text( statement.get(), 2, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&
1486  sqlite3_step( statement.get() ) == SQLITE_DONE )
1487  {
1488  resultFlag = true;
1489  switch ( type )
1490  {
1491  case Metadata:
1492  myErrorMessage = tr( "The metadata %1 was saved to database" ).arg( uri );
1493  break;
1494 
1495  case Style:
1496  myErrorMessage = tr( "The style %1 was saved to database" ).arg( uri );
1497  break;
1498  }
1499  }
1500  }
1501 
1502  if ( !resultFlag )
1503  {
1504  QString mySql;
1505  switch ( type )
1506  {
1507  case Metadata:
1508  mySql = QStringLiteral( "update tbl_metadata set qmd=? where metadata=?" );
1509  break;
1510 
1511  case Style:
1512  mySql = QStringLiteral( "update tbl_styles set qml=? where style=?" );
1513  break;
1514  }
1515  statement = database.prepare( mySql, myResult );
1516  if ( myResult == SQLITE_OK )
1517  {
1518  if ( sqlite3_bind_text( statement.get(), 2, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&
1519  sqlite3_bind_text( statement.get(), 1, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&
1520  sqlite3_step( statement.get() ) == SQLITE_DONE )
1521  {
1522  resultFlag = true;
1523  switch ( type )
1524  {
1525  case Metadata:
1526  myErrorMessage = tr( "The metadata %1 was updated in the database." ).arg( uri );
1527  break;
1528 
1529  case Style:
1530  myErrorMessage = tr( "The style %1 was updated in the database." ).arg( uri );
1531  break;
1532  }
1533  }
1534  else
1535  {
1536  resultFlag = false;
1537  switch ( type )
1538  {
1539  case Metadata:
1540  myErrorMessage = tr( "The metadata %1 could not be updated in the database." ).arg( uri );
1541  break;
1542 
1543  case Style:
1544  myErrorMessage = tr( "The style %1 could not be updated in the database." ).arg( uri );
1545  break;
1546  }
1547  }
1548  }
1549  else
1550  {
1551  resultFlag = false;
1552  switch ( type )
1553  {
1554  case Metadata:
1555  myErrorMessage = tr( "The metadata %1 could not be inserted into database." ).arg( uri );
1556  break;
1557 
1558  case Style:
1559  myErrorMessage = tr( "The style %1 could not be inserted into database." ).arg( uri );
1560  break;
1561  }
1562  }
1563  }
1564  }
1565 
1566  return myErrorMessage;
1567 }
1568 
1569 QString QgsMapLayer::saveNamedStyle( const QString &uri, bool &resultFlag, StyleCategories categories )
1570 {
1571  return saveNamedProperty( uri, QgsMapLayer::Style, resultFlag, categories );
1572 }
1573 
1574 void QgsMapLayer::exportSldStyle( QDomDocument &doc, QString &errorMsg ) const
1575 {
1576  QDomDocument myDocument = QDomDocument();
1577 
1578  const QDomNode header = myDocument.createProcessingInstruction( QStringLiteral( "xml" ), QStringLiteral( "version=\"1.0\" encoding=\"UTF-8\"" ) );
1579  myDocument.appendChild( header );
1580 
1581  const QgsVectorLayer *vlayer = qobject_cast<const QgsVectorLayer *>( this );
1582  const QgsRasterLayer *rlayer = qobject_cast<const QgsRasterLayer *>( this );
1583  if ( !vlayer && !rlayer )
1584  {
1585  errorMsg = tr( "Could not save symbology because:\n%1" )
1586  .arg( tr( "Only vector and raster layers are supported" ) );
1587  return;
1588  }
1589 
1590  // Create the root element
1591  QDomElement root = myDocument.createElementNS( QStringLiteral( "http://www.opengis.net/sld" ), QStringLiteral( "StyledLayerDescriptor" ) );
1592  QDomElement layerNode;
1593  if ( vlayer )
1594  {
1595  root.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.1.0" ) );
1596  root.setAttribute( QStringLiteral( "xsi:schemaLocation" ), QStringLiteral( "http://www.opengis.net/sld http://schemas.opengis.net/sld/1.1.0/StyledLayerDescriptor.xsd" ) );
1597  root.setAttribute( QStringLiteral( "xmlns:ogc" ), QStringLiteral( "http://www.opengis.net/ogc" ) );
1598  root.setAttribute( QStringLiteral( "xmlns:se" ), QStringLiteral( "http://www.opengis.net/se" ) );
1599  root.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
1600  root.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
1601  myDocument.appendChild( root );
1602 
1603  // Create the NamedLayer element
1604  layerNode = myDocument.createElement( QStringLiteral( "NamedLayer" ) );
1605  root.appendChild( layerNode );
1606  }
1607 
1608  // note: Only SLD 1.0 version is generated because seems none is using SE1.1.0 at least for rasters
1609  if ( rlayer )
1610  {
1611  // Create the root element
1612  root.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.0.0" ) );
1613  root.setAttribute( QStringLiteral( "xmlns:gml" ), QStringLiteral( "http://www.opengis.net/gml" ) );
1614  root.setAttribute( QStringLiteral( "xmlns:ogc" ), QStringLiteral( "http://www.opengis.net/ogc" ) );
1615  root.setAttribute( QStringLiteral( "xmlns:sld" ), QStringLiteral( "http://www.opengis.net/sld" ) );
1616  myDocument.appendChild( root );
1617 
1618  // Create the NamedLayer element
1619  layerNode = myDocument.createElement( QStringLiteral( "UserLayer" ) );
1620  root.appendChild( layerNode );
1621  }
1622 
1623  QVariantMap props;
1624  if ( hasScaleBasedVisibility() )
1625  {
1626  props[ QStringLiteral( "scaleMinDenom" ) ] = QString::number( mMinScale );
1627  props[ QStringLiteral( "scaleMaxDenom" ) ] = QString::number( mMaxScale );
1628  }
1629 
1630  if ( vlayer )
1631  {
1632  if ( !vlayer->writeSld( layerNode, myDocument, errorMsg, props ) )
1633  {
1634  errorMsg = tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1635  return;
1636  }
1637  }
1638 
1639  if ( rlayer )
1640  {
1641  if ( !rlayer->writeSld( layerNode, myDocument, errorMsg, props ) )
1642  {
1643  errorMsg = tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1644  return;
1645  }
1646  }
1647 
1648  doc = myDocument;
1649 }
1650 
1651 QString QgsMapLayer::saveSldStyle( const QString &uri, bool &resultFlag ) const
1652 {
1653  const QgsMapLayer *mlayer = qobject_cast<const QgsMapLayer *>( this );
1654 
1655  QString errorMsg;
1656  QDomDocument myDocument;
1657  mlayer->exportSldStyle( myDocument, errorMsg );
1658  if ( !errorMsg.isNull() )
1659  {
1660  resultFlag = false;
1661  return errorMsg;
1662  }
1663  // check if the uri is a file or ends with .sld,
1664  // which indicates that it should become one
1665  QString filename;
1666  if ( mlayer->providerType() == QLatin1String( "ogr" ) )
1667  {
1668  QStringList theURIParts = uri.split( '|' );
1669  filename = theURIParts[0];
1670  }
1671  else if ( mlayer->providerType() == QLatin1String( "gpx" ) )
1672  {
1673  QStringList theURIParts = uri.split( '?' );
1674  filename = theURIParts[0];
1675  }
1676  else if ( mlayer->providerType() == QLatin1String( "delimitedtext" ) )
1677  {
1678  filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1679  // toLocalFile() returns an empty string if theURI is a plain Windows-path, e.g. "C:/style.qml"
1680  if ( filename.isEmpty() )
1681  filename = uri;
1682  }
1683  else
1684  {
1685  filename = uri;
1686  }
1687 
1688  const QFileInfo myFileInfo( filename );
1689  if ( myFileInfo.exists() || filename.endsWith( QLatin1String( ".sld" ), Qt::CaseInsensitive ) )
1690  {
1691  const QFileInfo myDirInfo( myFileInfo.path() ); //excludes file name
1692  if ( !myDirInfo.isWritable() )
1693  {
1694  return tr( "The directory containing your dataset needs to be writable!" );
1695  }
1696 
1697  // now construct the file name for our .sld style file
1698  const QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + ".sld";
1699 
1700  QFile myFile( myFileName );
1701  if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1702  {
1703  QTextStream myFileStream( &myFile );
1704  // save as utf-8 with 2 spaces for indents
1705  myDocument.save( myFileStream, 2 );
1706  myFile.close();
1707  resultFlag = true;
1708  return tr( "Created default style file as %1" ).arg( myFileName );
1709  }
1710  }
1711 
1712  resultFlag = false;
1713  return tr( "ERROR: Failed to created SLD style file as %1. Check file permissions and retry." ).arg( filename );
1714 }
1715 
1716 QString QgsMapLayer::loadSldStyle( const QString &uri, bool &resultFlag )
1717 {
1718  resultFlag = false;
1719 
1720  QDomDocument myDocument;
1721 
1722  // location of problem associated with errorMsg
1723  int line, column;
1724  QString myErrorMessage;
1725 
1726  QFile myFile( uri );
1727  if ( myFile.open( QFile::ReadOnly ) )
1728  {
1729  // read file
1730  resultFlag = myDocument.setContent( &myFile, true, &myErrorMessage, &line, &column );
1731  if ( !resultFlag )
1732  myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1733  myFile.close();
1734  }
1735  else
1736  {
1737  myErrorMessage = tr( "Unable to open file %1" ).arg( uri );
1738  }
1739 
1740  if ( !resultFlag )
1741  {
1742  return myErrorMessage;
1743  }
1744 
1745  // check for root SLD element
1746  const QDomElement myRoot = myDocument.firstChildElement( QStringLiteral( "StyledLayerDescriptor" ) );
1747  if ( myRoot.isNull() )
1748  {
1749  myErrorMessage = QStringLiteral( "Error: StyledLayerDescriptor element not found in %1" ).arg( uri );
1750  resultFlag = false;
1751  return myErrorMessage;
1752  }
1753 
1754  // now get the style node out and pass it over to the layer
1755  // to deserialise...
1756  const QDomElement namedLayerElem = myRoot.firstChildElement( QStringLiteral( "NamedLayer" ) );
1757  if ( namedLayerElem.isNull() )
1758  {
1759  myErrorMessage = QStringLiteral( "Info: NamedLayer element not found." );
1760  resultFlag = false;
1761  return myErrorMessage;
1762  }
1763 
1764  QString errorMsg;
1765  resultFlag = readSld( namedLayerElem, errorMsg );
1766  if ( !resultFlag )
1767  {
1768  myErrorMessage = tr( "Loading style file %1 failed because:\n%2" ).arg( uri, errorMsg );
1769  return myErrorMessage;
1770  }
1771 
1772  return QString();
1773 }
1774 
1775 bool QgsMapLayer::readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
1776 {
1777  Q_UNUSED( node )
1778  Q_UNUSED( errorMessage )
1779  Q_UNUSED( context )
1780  Q_UNUSED( categories )
1781  return false;
1782 }
1783 
1784 bool QgsMapLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage,
1785  const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
1786 {
1787  Q_UNUSED( node )
1788  Q_UNUSED( doc )
1789  Q_UNUSED( errorMessage )
1790  Q_UNUSED( context )
1791  Q_UNUSED( categories )
1792  return false;
1793 }
1794 
1795 
1796 void QgsMapLayer::setDataSource( const QString &dataSource, const QString &baseName, const QString &provider,
1797  bool loadDefaultStyleFlag )
1798 {
1799  const QgsDataProvider::ProviderOptions options;
1800 
1801  QgsDataProvider::ReadFlags flags = QgsDataProvider::ReadFlags();
1802  if ( loadDefaultStyleFlag )
1803  {
1805  }
1806 
1808  {
1810  }
1811  setDataSource( dataSource, baseName, provider, options, flags );
1812 }
1813 
1814 void QgsMapLayer::setDataSource( const QString &dataSource, const QString &baseName, const QString &provider,
1815  const QgsDataProvider::ProviderOptions &options, bool loadDefaultStyleFlag )
1816 {
1817  QgsDataProvider::ReadFlags flags = QgsDataProvider::ReadFlags();
1818  if ( loadDefaultStyleFlag )
1819  {
1821  }
1822 
1824  {
1826  }
1827  setDataSource( dataSource, baseName, provider, options, flags );
1828 }
1829 
1830 void QgsMapLayer::setDataSource( const QString &dataSource, const QString &baseName, const QString &provider,
1831  const QgsDataProvider::ProviderOptions &options, QgsDataProvider::ReadFlags flags )
1832 {
1833 
1836  {
1838  }
1839  setDataSourcePrivate( dataSource, baseName, provider, options, flags );
1840  emit dataSourceChanged();
1841  emit dataChanged();
1842  triggerRepaint();
1843 }
1844 
1845 
1846 void QgsMapLayer::setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider,
1847  const QgsDataProvider::ProviderOptions &options, QgsDataProvider::ReadFlags flags )
1848 {
1849  Q_UNUSED( dataSource )
1850  Q_UNUSED( baseName )
1851  Q_UNUSED( provider )
1852  Q_UNUSED( options )
1853  Q_UNUSED( flags )
1854 }
1855 
1856 
1858 {
1859  return mProviderKey;
1860 }
1861 
1862 void QgsMapLayer::readCommonStyle( const QDomElement &layerElement, const QgsReadWriteContext &context,
1863  QgsMapLayer::StyleCategories categories )
1864 {
1865  if ( categories.testFlag( Symbology3D ) )
1866  {
1867  const QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "3D Symbology" ) );
1868 
1869  QgsAbstract3DRenderer *r3D = nullptr;
1870  QDomElement renderer3DElem = layerElement.firstChildElement( QStringLiteral( "renderer-3d" ) );
1871  if ( !renderer3DElem.isNull() )
1872  {
1873  const QString type3D = renderer3DElem.attribute( QStringLiteral( "type" ) );
1875  if ( meta3D )
1876  {
1877  r3D = meta3D->createRenderer( renderer3DElem, context );
1878  }
1879  }
1880  setRenderer3D( r3D );
1881  }
1882 
1883  if ( categories.testFlag( CustomProperties ) )
1884  {
1885  // read custom properties before passing reading further to a subclass, so that
1886  // the subclass can also read custom properties
1887  readCustomProperties( layerElement );
1888  }
1889 
1890  // use scale dependent visibility flag
1891  if ( categories.testFlag( Rendering ) )
1892  {
1893  setScaleBasedVisibility( layerElement.attribute( QStringLiteral( "hasScaleBasedVisibilityFlag" ) ).toInt() == 1 );
1894  if ( layerElement.hasAttribute( QStringLiteral( "minimumScale" ) ) )
1895  {
1896  // older element, when scales were reversed
1897  setMaximumScale( layerElement.attribute( QStringLiteral( "minimumScale" ) ).toDouble() );
1898  setMinimumScale( layerElement.attribute( QStringLiteral( "maximumScale" ) ).toDouble() );
1899  }
1900  else
1901  {
1902  setMaximumScale( layerElement.attribute( QStringLiteral( "maxScale" ) ).toDouble() );
1903  setMinimumScale( layerElement.attribute( QStringLiteral( "minScale" ) ).toDouble() );
1904  }
1905  }
1906 
1907  if ( categories.testFlag( LayerConfiguration ) )
1908  {
1909  // flags
1910  const QDomElement flagsElem = layerElement.firstChildElement( QStringLiteral( "flags" ) );
1911  LayerFlags flags = mFlags;
1912  const auto enumMap = qgsEnumMap<QgsMapLayer::LayerFlag>();
1913  for ( auto it = enumMap.constBegin(); it != enumMap.constEnd(); ++it )
1914  {
1915  const QDomNode flagNode = flagsElem.namedItem( it.value() );
1916  if ( flagNode.isNull() )
1917  continue;
1918  const bool flagValue = flagNode.toElement().text() == "1" ? true : false;
1919  if ( flags.testFlag( it.key() ) && !flagValue )
1920  flags &= ~it.key();
1921  else if ( !flags.testFlag( it.key() ) && flagValue )
1922  flags |= it.key();
1923  }
1924  setFlags( flags );
1925  }
1926 
1927  if ( categories.testFlag( Temporal ) )
1928  {
1929  const QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Temporal" ) );
1930 
1932  properties->readXml( layerElement.toElement(), context );
1933  }
1934 
1935  if ( categories.testFlag( Elevation ) )
1936  {
1937  const QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Elevation" ) );
1938 
1940  properties->readXml( layerElement.toElement(), context );
1941  }
1942 
1943  if ( categories.testFlag( Notes ) )
1944  {
1945  const QDomElement notesElem = layerElement.firstChildElement( QStringLiteral( "userNotes" ) );
1946  if ( !notesElem.isNull() )
1947  {
1948  const QString notes = notesElem.attribute( QStringLiteral( "value" ) );
1949  QgsLayerNotesUtils::setLayerNotes( this, notes );
1950  }
1951  }
1952 }
1953 
1955 {
1956  return mUndoStack;
1957 }
1958 
1960 {
1961  return mUndoStackStyles;
1962 }
1963 
1965 {
1966  return mCustomProperties.keys();
1967 }
1968 
1969 void QgsMapLayer::setCustomProperty( const QString &key, const QVariant &value )
1970 {
1971  if ( !mCustomProperties.contains( key ) || mCustomProperties.value( key ) != value )
1972  {
1973  mCustomProperties.setValue( key, value );
1974  emit customPropertyChanged( key );
1975  }
1976 }
1977 
1979 {
1980  mCustomProperties = properties;
1981  for ( const QString &key : mCustomProperties.keys() )
1982  {
1983  emit customPropertyChanged( key );
1984  }
1985 }
1986 
1988 {
1989  return mCustomProperties;
1990 }
1991 
1992 QVariant QgsMapLayer::customProperty( const QString &value, const QVariant &defaultValue ) const
1993 {
1994  return mCustomProperties.value( value, defaultValue );
1995 }
1996 
1997 void QgsMapLayer::removeCustomProperty( const QString &key )
1998 {
1999 
2000  if ( mCustomProperties.contains( key ) )
2001  {
2002  mCustomProperties.remove( key );
2003  emit customPropertyChanged( key );
2004  }
2005 }
2006 
2008 {
2009  return mError;
2010 }
2011 
2012 
2013 
2015 {
2016  return false;
2017 }
2018 
2020 {
2021  return false;
2022 }
2023 
2025 {
2026  return true;
2027 }
2028 
2030 {
2031  // invalid layers are temporary? -- who knows?!
2032  if ( !isValid() )
2033  return false;
2034 
2035  if ( mProviderKey == QLatin1String( "memory" ) )
2036  return true;
2037 
2038  const QVariantMap sourceParts = QgsProviderRegistry::instance()->decodeUri( mProviderKey, mDataSource );
2039  const QString path = sourceParts.value( QStringLiteral( "path" ) ).toString();
2040  if ( path.isEmpty() )
2041  return false;
2042 
2043  // check if layer path is inside one of the standard temporary file locations for this platform
2044  const QStringList tempPaths = QStandardPaths::standardLocations( QStandardPaths::TempLocation );
2045  for ( const QString &tempPath : tempPaths )
2046  {
2047  if ( path.startsWith( tempPath ) )
2048  return true;
2049  }
2050 
2051  return false;
2052 }
2053 
2054 void QgsMapLayer::setValid( bool valid )
2055 {
2056  if ( mValid == valid )
2057  return;
2058 
2059  mValid = valid;
2060  emit isValidChanged();
2061 }
2062 
2064 {
2065  if ( legend == mLegend )
2066  return;
2067 
2068  delete mLegend;
2069  mLegend = legend;
2070 
2071  if ( mLegend )
2072  {
2073  mLegend->setParent( this );
2074  connect( mLegend, &QgsMapLayerLegend::itemsChanged, this, &QgsMapLayer::legendChanged, Qt::UniqueConnection );
2075  }
2076 
2077  emit legendChanged();
2078 }
2079 
2081 {
2082  return mLegend;
2083 }
2084 
2086 {
2087  return mStyleManager;
2088 }
2089 
2091 {
2092  if ( renderer == m3DRenderer )
2093  return;
2094 
2095  delete m3DRenderer;
2096  m3DRenderer = renderer;
2097  emit renderer3DChanged();
2098  emit repaintRequested();
2099  trigger3DUpdate();
2100 }
2101 
2103 {
2104  return m3DRenderer;
2105 }
2106 
2107 void QgsMapLayer::triggerRepaint( bool deferredUpdate )
2108 {
2109  if ( mRepaintRequestedFired )
2110  return;
2111  mRepaintRequestedFired = true;
2112  emit repaintRequested( deferredUpdate );
2113  mRepaintRequestedFired = false;
2114 }
2115 
2117 {
2118  emit request3DUpdate();
2119 }
2120 
2122 {
2123  mMetadata = metadata;
2124 // mMetadata.saveToLayer( this );
2125  emit metadataChanged();
2126 }
2127 
2129 {
2130  return QString();
2131 }
2132 
2133 QDateTime QgsMapLayer::timestamp() const
2134 {
2135  return QDateTime();
2136 }
2137 
2139 {
2140  if ( !mBlockStyleChangedSignal )
2141  emit styleChanged();
2142 }
2143 
2145 {
2146  updateExtent( extent );
2147 }
2148 
2149 bool QgsMapLayer::isReadOnly() const
2150 {
2151  return true;
2152 }
2153 
2155 {
2156  return mOriginalXmlProperties;
2157 }
2158 
2159 void QgsMapLayer::setOriginalXmlProperties( const QString &originalXmlProperties )
2160 {
2161  mOriginalXmlProperties = originalXmlProperties;
2162 }
2163 
2164 QString QgsMapLayer::generateId( const QString &layerName )
2165 {
2166  // Generate the unique ID of this layer
2167  const QString uuid = QUuid::createUuid().toString();
2168  // trim { } from uuid
2169  QString id = layerName + '_' + uuid.mid( 1, uuid.length() - 2 );
2170  // Tidy the ID up to avoid characters that may cause problems
2171  // elsewhere (e.g in some parts of XML). Replaces every non-word
2172  // character (word characters are the alphabet, numbers and
2173  // underscore) with an underscore.
2174  // Note that the first backslash in the regular expression is
2175  // there for the compiler, so the pattern is actually \W
2176  id.replace( QRegularExpression( "[\\W]" ), QStringLiteral( "_" ) );
2177  return id;
2178 }
2179 
2181 {
2182  return true;
2183 }
2184 
2185 void QgsMapLayer::setProviderType( const QString &providerType )
2186 {
2188 }
2189 
2190 QSet<QgsMapLayerDependency> QgsMapLayer::dependencies() const
2191 {
2192  return mDependencies;
2193 }
2194 
2195 bool QgsMapLayer::setDependencies( const QSet<QgsMapLayerDependency> &oDeps )
2196 {
2197  QSet<QgsMapLayerDependency> deps;
2198  const auto constODeps = oDeps;
2199  for ( const QgsMapLayerDependency &dep : constODeps )
2200  {
2201  if ( dep.origin() == QgsMapLayerDependency::FromUser )
2202  deps << dep;
2203  }
2204 
2205  mDependencies = deps;
2206  emit dependenciesChanged();
2207  return true;
2208 }
2209 
2211 {
2212  QgsDataProvider *lDataProvider = dataProvider();
2213 
2214  if ( !lDataProvider )
2215  return;
2216 
2217  if ( enabled && !isRefreshOnNotifyEnabled() )
2218  {
2219  lDataProvider->setListening( enabled );
2220  connect( lDataProvider, &QgsDataProvider::notify, this, &QgsMapLayer::onNotified );
2221  }
2222  else if ( !enabled && isRefreshOnNotifyEnabled() )
2223  {
2224  // we don't want to disable provider listening because someone else could need it (e.g. actions)
2225  disconnect( lDataProvider, &QgsDataProvider::notify, this, &QgsMapLayer::onNotified );
2226  }
2227  mIsRefreshOnNofifyEnabled = enabled;
2228 }
2229 
2231 {
2232  if ( QgsMapLayerStore *store = qobject_cast<QgsMapLayerStore *>( parent() ) )
2233  {
2234  return qobject_cast<QgsProject *>( store->parent() );
2235  }
2236  return nullptr;
2237 }
2238 
2239 void QgsMapLayer::onNotified( const QString &message )
2240 {
2241  if ( refreshOnNotifyMessage().isEmpty() || refreshOnNotifyMessage() == message )
2242  {
2243  triggerRepaint();
2244  emit dataChanged();
2245  }
2246 }
2247 
2248 QgsRectangle QgsMapLayer::wgs84Extent( bool forceRecalculate ) const
2249 {
2251 
2252  if ( ! forceRecalculate && ! mWgs84Extent.isNull() )
2253  {
2254  wgs84Extent = mWgs84Extent;
2255  }
2256  else if ( ! mExtent.isNull() )
2257  {
2259  transformer.setBallparkTransformsAreAppropriate( true );
2260  try
2261  {
2262  wgs84Extent = transformer.transformBoundingBox( mExtent );
2263  }
2264  catch ( const QgsCsException &cse )
2265  {
2266  QgsMessageLog::logMessage( tr( "Error transforming extent: %1" ).arg( cse.what() ) );
2268  }
2269  }
2270  return wgs84Extent;
2271 }
2272 
2273 void QgsMapLayer::updateExtent( const QgsRectangle &extent ) const
2274 {
2275  if ( extent == mExtent )
2276  return;
2277 
2278  mExtent = extent;
2279 
2280  // do not update the wgs84 extent if we trust layer metadata
2281  if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2282  return;
2283 
2284  mWgs84Extent = wgs84Extent( true );
2285 }
2286 
2288 {
2289  // do not update the wgs84 extent if we trust layer metadata
2290  if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2291  return;
2292 
2293  mWgs84Extent = QgsRectangle();
2294 }
2295 
2297 {
2298  QString metadata = QStringLiteral( "<h1>" ) + tr( "General" ) + QStringLiteral( "</h1>\n<hr>\n" ) + QStringLiteral( "<table class=\"list-view\">\n" );
2299 
2300  // name
2301  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Name" ) + QStringLiteral( "</td><td>" ) + name() + QStringLiteral( "</td></tr>\n" );
2302 
2303  QString path;
2304  bool isLocalPath = false;
2305  if ( dataProvider() )
2306  {
2307  // local path
2308  QVariantMap uriComponents = QgsProviderRegistry::instance()->decodeUri( dataProvider()->name(), publicSource() );
2309  if ( uriComponents.contains( QStringLiteral( "path" ) ) )
2310  {
2311  path = uriComponents[QStringLiteral( "path" )].toString();
2312  QFileInfo fi( path );
2313  if ( fi.exists() )
2314  {
2315  isLocalPath = true;
2316  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" );
2317 
2318  QDateTime lastModified = fi.lastModified();
2319  QString lastModifiedFileName;
2320  QSet<QString> sidecarFiles = QgsFileUtils::sidecarFilesForPath( path );
2321  if ( fi.isFile() )
2322  {
2323  qint64 fileSize = fi.size();
2324  if ( !sidecarFiles.isEmpty() )
2325  {
2326  lastModifiedFileName = fi.fileName();
2327  QStringList sidecarFileNames;
2328  for ( const QString &sidecarFile : sidecarFiles )
2329  {
2330  QFileInfo sidecarFi( sidecarFile );
2331  fileSize += sidecarFi.size();
2332  if ( sidecarFi.lastModified() > lastModified )
2333  {
2334  lastModified = sidecarFi.lastModified();
2335  lastModifiedFileName = sidecarFi.fileName();
2336  }
2337  sidecarFileNames << sidecarFi.fileName();
2338  }
2339  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" );
2340  }
2341  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" );
2342  }
2343  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" );
2344  }
2345  }
2346  if ( uriComponents.contains( QStringLiteral( "url" ) ) )
2347  {
2348  const QString url = uriComponents[QStringLiteral( "url" )].toString();
2349  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" );
2350  }
2351  }
2352 
2353  // data source
2354  if ( publicSource() != path || !isLocalPath )
2355  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Source" ) + QStringLiteral( "</td><td>%1" ).arg( publicSource() != path ? publicSource() : path ) + QStringLiteral( "</td></tr>\n" );
2356 
2357  // provider
2358  if ( dataProvider() )
2359  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Provider" ) + QStringLiteral( "</td><td>%1" ).arg( dataProvider()->name() ) + QStringLiteral( "</td></tr>\n" );
2360 
2361  metadata += QLatin1String( "</table>\n<br><br>" );
2362  return metadata;
2363 }
2364 
2366 {
2367  QString metadata = QStringLiteral( "<h1>" ) + tr( "Coordinate Reference System (CRS)" ) + QStringLiteral( "</h1>\n<hr>\n" );
2368  metadata += QLatin1String( "<table class=\"list-view\">\n" );
2369 
2370  // Identifier
2372  if ( !c.isValid() )
2373  metadata += QStringLiteral( "<tr><td colspan=\"2\" class=\"highlight\">" ) + tr( "Unknown" ) + QStringLiteral( "</td></tr>\n" );
2374  else
2375  {
2376  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Name" ) + QStringLiteral( "</td><td>" ) + c.userFriendlyIdentifier( QgsCoordinateReferenceSystem::FullString ) + QStringLiteral( "</td></tr>\n" );
2377 
2378  // map units
2379  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Units" ) + QStringLiteral( "</td><td>" )
2380  + ( c.isGeographic() ? tr( "Geographic (uses latitude and longitude for coordinates)" ) : QgsUnitTypes::toString( c.mapUnits() ) )
2381  + QStringLiteral( "</td></tr>\n" );
2382 
2383 
2384  // operation
2385  const QgsProjOperation operation = c.operation();
2386  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Method" ) + QStringLiteral( "</td><td>" ) + operation.description() + QStringLiteral( "</td></tr>\n" );
2387 
2388  // celestial body
2389  try
2390  {
2391  const QString celestialBody = c.celestialBodyName();
2392  if ( !celestialBody.isEmpty() )
2393  {
2394  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Celestial body" ) + QStringLiteral( "</td><td>" ) + celestialBody + QStringLiteral( "</td></tr>\n" );
2395  }
2396  }
2397  catch ( QgsNotSupportedException & )
2398  {
2399 
2400  }
2401 
2402  QString accuracyString;
2403  // dynamic crs with no epoch?
2404  if ( c.isDynamic() && std::isnan( c.coordinateEpoch() ) )
2405  {
2406  accuracyString = tr( "Based on a dynamic CRS, but no coordinate epoch is set. Coordinates are ambiguous and of limited accuracy." );
2407  }
2408 
2409  // based on datum ensemble?
2410  try
2411  {
2412  const QgsDatumEnsemble ensemble = c.datumEnsemble();
2413  if ( ensemble.isValid() )
2414  {
2415  QString id;
2416  if ( !ensemble.code().isEmpty() )
2417  id = QStringLiteral( "<i>%1</i> (%2:%3)" ).arg( ensemble.name(), ensemble.authority(), ensemble.code() );
2418  else
2419  id = QStringLiteral( "<i>%</i>”" ).arg( ensemble.name() );
2420 
2421  if ( ensemble.accuracy() > 0 )
2422  {
2423  accuracyString = tr( "Based on %1, which has a limited accuracy of <b>at best %2 meters</b>." ).arg( id ).arg( ensemble.accuracy() );
2424  }
2425  else
2426  {
2427  accuracyString = tr( "Based on %1, which has a limited accuracy." ).arg( id );
2428  }
2429  }
2430  }
2431  catch ( QgsNotSupportedException & )
2432  {
2433 
2434  }
2435 
2436  if ( !accuracyString.isEmpty() )
2437  {
2438  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Accuracy" ) + QStringLiteral( "</td><td>" ) + accuracyString + QStringLiteral( "</td></tr>\n" );
2439  }
2440 
2441  // static/dynamic
2442  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)" ) );
2443 
2444  // coordinate epoch
2445  if ( !std::isnan( c.coordinateEpoch() ) )
2446  {
2447  metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Coordinate epoch" ) + QStringLiteral( "</td><td>%1</td></tr>\n" ).arg( c.coordinateEpoch() );
2448  }
2449  }
2450 
2451  metadata += QLatin1String( "</table>\n<br><br>\n" );
2452  return metadata;
2453 }
static QString version()
Version string.
Definition: qgis.cpp:285
static const double SCALE_PRECISION
Fudge factor used to compare two scales.
Definition: qgis.h:1327
@ 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:1938
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:1284
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:1269
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:1953
int mBlockStyleChangedSignal
If non-zero, the styleChanged signal should not be emitted.
Definition: qgsmaplayer.h:1995
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:1966
QString mLegendUrl
WMS legend.
Definition: qgsmaplayer.h:1949
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:1931
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:1934
void setDataUrl(const QString &dataUrl)
Sets the DataUrl of the layer used by QGIS Server in GetCapabilities request.
Definition: qgsmaplayer.h:353
virtual QString saveDefaultStyle(bool &resultFlag)
Save the properties of this layer as the default style (either as a .qml file on disk or as a record ...
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:1446
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:1956
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:1950
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:1969
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:1946
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:1593
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:1933
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:1928
QString refreshOnNotifyMessage() const
Returns the message that should be notified by the provider to triggerRepaint.
Definition: qgsmaplayer.h:1439
virtual bool readSld(const QDomNode &node, QString &errorMessage)
Definition: qgsmaplayer.h:1147
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:1937
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:1974
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:1274
QString mDataUrlFormat
Definition: qgsmaplayer.h:1942
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:1279
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:1496
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:1965
QString mDataUrl
DataUrl of the layer.
Definition: qgsmaplayer.h:1941
virtual Q_INVOKABLE QgsDataProvider * dataProvider()
Returns the layer's data provider, it may be nullptr.
double mLayerOpacity
Layer opacity.
Definition: qgsmaplayer.h:1988
bool mValid
Indicates if the layer is valid and can be drawn.
Definition: qgsmaplayer.h:1925
@ 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:1489
void setRenderer3D(QgsAbstract3DRenderer *renderer)
Sets 3D renderer for the layer.
QString mAttribution
Attribution of the layer.
Definition: qgsmaplayer.h:1945
~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:1981
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:101
bool removeAttachedFile(const QString &path)
Removes the attached file.
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:470
QString baseName() const
Returns the base name of the project file without the path and without extension - derived from fileN...
Definition: qgsproject.cpp:712
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:701
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:1546
CONSTLATIN1STRING geoEpsgCrsAuthId()
Geographic coord sys from EPSG authority.
Definition: qgis.h:1954
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.