52 #include <QDomDocument>
53 #include <QDomElement>
54 #include <QDomImplementation>
59 #include <QTextStream>
62 #include <QStandardPaths>
64 #include <QRegularExpression>
73 return QStringLiteral(
".qmd" );
76 return QStringLiteral(
".qml" );
82 const QString &lyrname,
83 const QString &source )
84 : mDataSource( source )
85 , mLayerName( lyrname )
88 , mUndoStack( new QUndoStack( this ) )
89 , mUndoStackStyles( new QUndoStack( this ) )
91 , mRefreshTimer( new QTimer( this ) )
96 connect( mRefreshTimer, &QTimer::timeout,
this, [ = ] {
triggerRepaint(
true ); } );
108 delete mStyleManager;
116 for (
const QString &s : constStyles )
157 if (
flags == mFlags )
166 return Qgis::MapLayerProperties();
208 if ( urls.isEmpty() )
211 urls.prepend( newItem );
217 urls.prepend( newItem );
224 if ( mServerProperties->metadataUrls().isEmpty() )
226 return QLatin1String();
230 return mServerProperties->metadataUrls().first().url;
236 QList<QgsMapLayerServerProperties::MetadataUrl> urls = mServerProperties->metadataUrls();
237 if ( urls.isEmpty() )
240 urls.prepend( newItem );
246 urls.prepend( newItem );
248 mServerProperties->setMetadataUrls( urls );
253 if ( mServerProperties->metadataUrls().isEmpty() )
255 return QLatin1String();
259 return mServerProperties->metadataUrls().first().type;
265 QList<QgsMapLayerServerProperties::MetadataUrl> urls = mServerProperties->metadataUrls();
266 if ( urls.isEmpty() )
269 urls.prepend( newItem );
275 urls.prepend( newItem );
277 mServerProperties->setMetadataUrls( urls );
282 if ( mServerProperties->metadataUrls().isEmpty() )
288 return mServerProperties->metadataUrls().first().format;
349 mnl = layerElement.namedItem( QStringLiteral(
"provider" ) );
350 mne = mnl.toElement();
351 provider = mne.text();
354 mnl = layerElement.namedItem( QStringLiteral(
"datasource" ) );
355 mne = mnl.toElement();
359 const thread_local QRegularExpression rx(
"authcfg=([a-z]|[A-Z]|[0-9]){7}" );
372 mnl = layerElement.namedItem( QStringLiteral(
"layername" ) );
373 mne = mnl.toElement();
378 const QDomNode srsNode = layerElement.namedItem( QStringLiteral(
"srs" ) );
397 mnl = layerElement.namedItem( QStringLiteral(
"id" ) );
398 if ( ! mnl.isNull() )
400 mne = mnl.toElement();
401 if ( ! mne.isNull() && mne.text().length() > 10 )
408 mnl = layerElement.namedItem( QStringLiteral(
"layername" ) );
409 mne = mnl.toElement();
412 setName( context.
projectTranslator()->
translate( QStringLiteral(
"project:layers:%1" ).arg( layerElement.namedItem( QStringLiteral(
"id" ) ).toElement().text() ), mne.text() ) );
415 layerError = !
readXml( layerElement, context );
424 const QDomElement shortNameElem = layerElement.firstChildElement( QStringLiteral(
"shortname" ) );
425 if ( !shortNameElem.isNull() )
431 const QDomElement titleElem = layerElement.firstChildElement( QStringLiteral(
"title" ) );
432 if ( !titleElem.isNull() )
434 mTitle = titleElem.text();
438 const QDomElement abstractElem = layerElement.firstChildElement( QStringLiteral(
"abstract" ) );
439 if ( !abstractElem.isNull() )
445 const QDomElement keywordListElem = layerElement.firstChildElement( QStringLiteral(
"keywordList" ) );
446 if ( !keywordListElem.isNull() )
449 for ( QDomNode n = keywordListElem.firstChild(); !n.isNull(); n = n.nextSibling() )
451 kwdList << n.toElement().text();
457 const QDomElement dataUrlElem = layerElement.firstChildElement( QStringLiteral(
"dataUrl" ) );
458 if ( !dataUrlElem.isNull() )
461 mDataUrlFormat = dataUrlElem.attribute( QStringLiteral(
"format" ), QString() );
465 const QDomElement legendUrlElem = layerElement.firstChildElement( QStringLiteral(
"legendUrl" ) );
466 if ( !legendUrlElem.isNull() )
469 mLegendUrlFormat = legendUrlElem.attribute( QStringLiteral(
"format" ), QString() );
473 const QDomElement attribElem = layerElement.firstChildElement( QStringLiteral(
"attribution" ) );
474 if ( !attribElem.isNull() )
477 mAttributionUrl = attribElem.attribute( QStringLiteral(
"href" ), QString() );
486 const QDomElement metaUrlElem = layerElement.firstChildElement( QStringLiteral(
"metadataUrl" ) );
487 if ( !metaUrlElem.isNull() )
489 const QString url = metaUrlElem.text();
490 const QString
type = metaUrlElem.attribute( QStringLiteral(
"type" ), QString() );
491 const QString format = metaUrlElem.attribute( QStringLiteral(
"format" ), QString() );
493 mServerProperties->setMetadataUrls( QList<QgsMapLayerServerProperties::MetadataUrl>() << newItem );
498 const QDomElement metadataElem = layerElement.firstChildElement( QStringLiteral(
"resourceMetadata" ) );
501 setAutoRefreshInterval( layerElement.attribute( QStringLiteral(
"autoRefreshTime" ), QStringLiteral(
"0" ) ).toInt() );
502 setAutoRefreshEnabled( layerElement.attribute( QStringLiteral(
"autoRefreshEnabled" ), QStringLiteral(
"0" ) ).toInt() );
504 setRefreshOnNotifyEnabled( layerElement.attribute( QStringLiteral(
"refreshOnNotifyEnabled" ), QStringLiteral(
"0" ) ).toInt() );
507 if (
mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
509 const QDomNode wgs84ExtentNode = layerElement.namedItem( QStringLiteral(
"wgs84extent" ) );
510 if ( !wgs84ExtentNode.isNull() )
514 mLegendPlaceholderImage = layerElement.attribute( QStringLiteral(
"legendPlaceholderImage" ) );
522 Q_UNUSED( layer_node )
529 const QDomNode extentNode = layer_node.namedItem( QStringLiteral(
"extent" ) );
530 if ( !extentNode.isNull() )
548 layerElement.setAttribute( QStringLiteral(
"autoRefreshTime" ), QString::number( mRefreshTimer->interval() ) );
549 layerElement.setAttribute( QStringLiteral(
"autoRefreshEnabled" ), mRefreshTimer->isActive() ? 1 : 0 );
554 QDomElement layerId = document.createElement( QStringLiteral(
"id" ) );
555 const QDomText layerIdText = document.createTextNode(
id() );
556 layerId.appendChild( layerIdText );
558 layerElement.appendChild( layerId );
561 QDomElement dataSource = document.createElement( QStringLiteral(
"datasource" ) );
563 const QDomText dataSourceText = document.createTextNode( src );
564 dataSource.appendChild( dataSourceText );
565 layerElement.appendChild( dataSource );
568 QDomElement layerName = document.createElement( QStringLiteral(
"layername" ) );
569 const QDomText layerNameText = document.createTextNode(
name() );
570 layerName.appendChild( layerNameText );
571 layerElement.appendChild( layerName );
576 QDomElement layerShortName = document.createElement( QStringLiteral(
"shortname" ) );
577 const QDomText layerShortNameText = document.createTextNode(
mShortName );
578 layerShortName.appendChild( layerShortNameText );
579 layerElement.appendChild( layerShortName );
585 QDomElement layerTitle = document.createElement( QStringLiteral(
"title" ) );
586 const QDomText layerTitleText = document.createTextNode(
mTitle );
587 layerTitle.appendChild( layerTitleText );
588 layerElement.appendChild( layerTitle );
594 QDomElement layerAbstract = document.createElement( QStringLiteral(
"abstract" ) );
595 const QDomText layerAbstractText = document.createTextNode(
mAbstract );
596 layerAbstract.appendChild( layerAbstractText );
597 layerElement.appendChild( layerAbstract );
601 const QStringList keywordStringList =
keywordList().split(
',' );
602 if ( !keywordStringList.isEmpty() )
604 QDomElement layerKeywordList = document.createElement( QStringLiteral(
"keywordList" ) );
605 for (
int i = 0; i < keywordStringList.size(); ++i )
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 );
612 layerElement.appendChild( layerKeywordList );
616 const QString aDataUrl =
dataUrl();
617 if ( !aDataUrl.isEmpty() )
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 );
628 if ( !aLegendUrl.isEmpty() )
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 );
639 if ( !aAttribution.isEmpty() )
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 );
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 );
657 layerElement.appendChild( layerName );
664 QDomElement mySrsElement = document.createElement( QStringLiteral(
"srs" ) );
665 mCRS.
writeXml( mySrsElement, document );
666 layerElement.appendChild( mySrsElement );
669 QDomElement myMetadataElem = document.createElement( QStringLiteral(
"resourceMetadata" ) );
671 layerElement.appendChild( myMetadataElem );
673 layerElement.setAttribute( QStringLiteral(
"legendPlaceholderImage" ), mLegendPlaceholderImage );
676 return writeXml( layerElement, document, context );
683 const QMetaEnum metaEnum = QMetaEnum::fromType<QgsMapLayer::StyleCategories>();
684 const QString categoriesKeys( metaEnum.valueToKeys(
static_cast<int>( categories ) ) );
685 layerElement.setAttribute( QStringLiteral(
"styleCategories" ), categoriesKeys );
690 layerElement.setAttribute( QStringLiteral(
"hasScaleBasedVisibilityFlag" ),
hasScaleBasedVisibility() ? 1 : 0 );
691 layerElement.setAttribute( QStringLiteral(
"maxScale" ), QString::number(
maximumScale() ) );
692 layerElement.setAttribute( QStringLiteral(
"minScale" ), QString::number(
minimumScale() ) );
699 QDomElement renderer3DElem = document.createElement( QStringLiteral(
"renderer-3d" ) );
700 renderer3DElem.setAttribute( QStringLiteral(
"type" ), m3DRenderer->
type() );
701 m3DRenderer->
writeXml( renderer3DElem, context );
702 layerElement.appendChild( renderer3DElem );
710 QDomElement layerFlagsElem = document.createElement( QStringLiteral(
"flags" ) );
711 const auto enumMap = qgsEnumMap<QgsMapLayer::LayerFlag>();
712 for (
auto it = enumMap.constBegin(); it != enumMap.constEnd(); ++it )
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 );
719 layerElement.appendChild( layerFlagsElem );
722 if ( categories.testFlag(
Temporal ) )
725 properties->writeXml( layerElement, document, context );
731 properties->writeXml( layerElement, document, context );
736 QDomElement notesElem = document.createElement( QStringLiteral(
"userNotes" ) );
738 layerElement.appendChild( notesElem );
751 Q_UNUSED( layer_node )
784 mCustomProperties.
readXml( layerNode, keyStartsWith );
786 for (
const QString &key : mCustomProperties.
keys() )
788 if ( !oldKeys.
contains( key ) || mCustomProperties.
value( key ) != oldKeys.
value( key ) )
797 mCustomProperties.
writeXml( layerNode, doc );
802 const QDomElement styleMgrElem = layerNode.firstChildElement( QStringLiteral(
"map-layer-style-manager" ) );
803 if ( !styleMgrElem.isNull() )
804 mStyleManager->
readXml( styleMgrElem );
806 mStyleManager->
reset();
813 QDomElement styleMgrElem = doc.createElement( QStringLiteral(
"map-layer-style-manager" ) );
814 mStyleManager->
writeXml( styleMgrElem );
815 layerNode.appendChild( styleMgrElem );
825 void QgsMapLayer::connectNotify(
const char *signal )
834 return !mScaleBasedVisibility ||
836 && ( mMaxScale == 0 || scale < mMaxScale ) );
841 return mScaleBasedVisibility;
846 return mRefreshTimer->isActive();
851 return mRefreshTimer->interval();
858 mRefreshTimer->stop();
859 mRefreshTimer->setInterval( 0 );
863 mRefreshTimer->setInterval( interval );
871 mRefreshTimer->stop();
872 else if ( mRefreshTimer->interval() > 0 )
873 mRefreshTimer->start();
901 mScaleBasedVisibility = enabled;
911 return QStringList();
959 QString layerName(
name );
960 layerName.replace(
'_',
' ' );
965 QString QgsMapLayer::baseURI( PropertyType type )
const
977 myURI = components[
"path"].toString();
980 QFileInfo myFileInfo( myURI );
983 if ( myFileInfo.exists() )
986 if ( myURI.endsWith( QLatin1String(
".gz" ), Qt::CaseInsensitive ) )
988 else if ( myURI.endsWith( QLatin1String(
".zip" ), Qt::CaseInsensitive ) )
990 else if ( myURI.endsWith( QLatin1String(
".tar" ), Qt::CaseInsensitive ) )
992 else if ( myURI.endsWith( QLatin1String(
".tar.gz" ), Qt::CaseInsensitive ) )
994 else if ( myURI.endsWith( QLatin1String(
".tgz" ), Qt::CaseInsensitive ) )
996 myFileInfo.setFile( myURI );
1010 return baseURI( PropertyType::Metadata );
1021 QString errorMessage;
1024 return tr(
"Successfully saved default layer metadata" );
1026 return errorMessage;
1047 return baseURI( PropertyType::Style );
1057 return loadNamedPropertyFromDatabase( db, uri, qmd, PropertyType::Metadata );
1062 return loadNamedPropertyFromDatabase( db, uri, qml, PropertyType::Style );
1065 bool QgsMapLayer::loadNamedPropertyFromDatabase(
const QString &db,
const QString &uri, QString &xml,
QgsMapLayer::PropertyType type )
1067 QgsDebugMsgLevel( QStringLiteral(
"db = %1 uri = %2" ).arg( db, uri ), 4 );
1069 bool resultFlag =
false;
1077 QgsDebugMsgLevel( QStringLiteral(
"Trying to load style or metadata for \"%1\" from \"%2\"" ).arg( uri, db ), 4 );
1079 if ( db.isEmpty() || !QFile( db ).exists() )
1082 myResult = database.
open_v2( db, SQLITE_OPEN_READONLY,
nullptr );
1083 if ( myResult != SQLITE_OK )
1092 mySql = QStringLiteral(
"select qmd from tbl_metadata where metadata=?" );
1096 mySql = QStringLiteral(
"select qml from tbl_styles where style=?" );
1100 statement = database.
prepare( mySql, myResult );
1101 if ( myResult == SQLITE_OK )
1103 QByteArray param = uri.toUtf8();
1105 if ( sqlite3_bind_text( statement.get(), 1, param.data(), param.length(), SQLITE_STATIC ) == SQLITE_OK &&
1106 sqlite3_step( statement.get() ) == SQLITE_ROW )
1108 xml = QString::fromUtf8(
reinterpret_cast< const char *
>( sqlite3_column_text( statement.get(), 0 ) ) );
1118 return loadNamedProperty( uri, PropertyType::Style, resultFlag, categories );
1121 QString QgsMapLayer::loadNamedProperty(
const QString &uri,
QgsMapLayer::PropertyType type,
bool &resultFlag, StyleCategories categories )
1127 QDomDocument myDocument( QStringLiteral(
"qgis" ) );
1131 QString myErrorMessage;
1133 QFile myFile( uri );
1134 if ( myFile.open( QFile::ReadOnly ) )
1138 resultFlag = myDocument.setContent( &myFile, &myErrorMessage, &line, &column );
1140 myErrorMessage = tr(
"%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1157 resultFlag = myDocument.setContent( xml, &myErrorMessage, &line, &column );
1160 myErrorMessage = tr(
"%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1165 myErrorMessage = tr(
"Style not found in database" );
1176 resultFlag = myDocument.setContent( xml, &myErrorMessage, &line, &column );
1179 myErrorMessage = tr(
"%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1184 myErrorMessage = tr(
"Metadata not found in database" );
1194 return myErrorMessage;
1202 myErrorMessage = tr(
"Loading style file %1 failed because:\n%2" ).arg( uri, myErrorMessage );
1207 myErrorMessage = tr(
"Loading metadata file %1 failed because:\n%2" ).arg( uri, myErrorMessage );
1210 return myErrorMessage;
1215 const QDomElement myRoot = document.firstChildElement( QStringLiteral(
"qgis" ) );
1216 if ( myRoot.isNull() )
1218 errorMessage = tr(
"Root <qgis> element could not be found" );
1227 const QDomElement myRoot = myDocument.firstChildElement( QStringLiteral(
"qgis" ) );
1228 if ( myRoot.isNull() )
1230 myErrorMessage = tr(
"Root <qgis> element could not be found" );
1235 const QgsProjectVersion fileVersion( myRoot.attribute( QStringLiteral(
"version" ) ) );
1238 if ( thisVersion > fileVersion )
1255 if ( importLayerGeometryType != QgsWkbTypes::GeometryType::UnknownGeometry && vl->
geometryType() != importLayerGeometryType )
1257 myErrorMessage = tr(
"Cannot apply style with symbology to layer with a different geometry type" );
1264 return readSymbology( myRoot, myErrorMessage, context, categories );
1269 QDomImplementation DomImplementation;
1270 const QDomDocumentType documentType = DomImplementation.createDocumentType( QStringLiteral(
"qgis" ), QStringLiteral(
"http://mrcc.com/qgis.dtd" ), QStringLiteral(
"SYSTEM" ) );
1271 QDomDocument myDocument( documentType );
1273 QDomElement myRootNode = myDocument.createElement( QStringLiteral(
"qgis" ) );
1274 myRootNode.setAttribute( QStringLiteral(
"version" ),
Qgis::version() );
1275 myDocument.appendChild( myRootNode );
1279 errorMsg = QObject::tr(
"Could not save metadata" );
1288 QDomImplementation DomImplementation;
1289 const QDomDocumentType documentType = DomImplementation.createDocumentType( QStringLiteral(
"qgis" ), QStringLiteral(
"http://mrcc.com/qgis.dtd" ), QStringLiteral(
"SYSTEM" ) );
1290 QDomDocument myDocument( documentType );
1292 QDomElement myRootNode = myDocument.createElement( QStringLiteral(
"qgis" ) );
1293 myRootNode.setAttribute( QStringLiteral(
"version" ),
Qgis::version() );
1294 myDocument.appendChild( myRootNode );
1296 if ( !
writeSymbology( myRootNode, myDocument, errorMsg, context, categories ) )
1298 errorMsg = QObject::tr(
"Could not save symbology because:\n%1" ).arg( errorMsg );
1309 const QgsVectorLayer *vl = qobject_cast<const QgsVectorLayer *>(
this );
1310 const QString geoType = QString::number( vl->
geometryType() );
1313 QDomElement layerGeometryType = myDocument.createElement( QStringLiteral(
"layerGeometryType" ) );
1314 const QDomText
type = myDocument.createTextNode( geoType );
1316 layerGeometryType.appendChild(
type );
1317 myRootNode.appendChild( layerGeometryType );
1338 QString QgsMapLayer::saveNamedProperty(
const QString &uri,
QgsMapLayer::PropertyType type,
bool &resultFlag, StyleCategories categories )
1346 if ( vlayer && vlayer->
providerType() == QLatin1String(
"ogr" ) )
1348 QStringList theURIParts = uri.split(
'|' );
1349 filename = theURIParts[0];
1351 else if ( vlayer && vlayer->
providerType() == QLatin1String(
"gpx" ) )
1353 QStringList theURIParts = uri.split(
'?' );
1354 filename = theURIParts[0];
1356 else if ( vlayer && vlayer->
providerType() == QLatin1String(
"delimitedtext" ) )
1358 filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1360 if ( filename.isEmpty() )
1368 QString myErrorMessage;
1369 QDomDocument myDocument;
1382 const QFileInfo myFileInfo( filename );
1385 const QFileInfo myDirInfo( myFileInfo.path() );
1386 if ( !myDirInfo.isWritable() )
1388 return tr(
"The directory containing your dataset needs to be writable!" );
1394 QFile myFile( myFileName );
1395 if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1397 QTextStream myFileStream( &myFile );
1399 myDocument.save( myFileStream, 2 );
1405 return tr(
"Created default metadata file as %1" ).arg( myFileName );
1408 return tr(
"Created default style file as %1" ).arg( myFileName );
1418 return tr(
"ERROR: Failed to created default metadata file as %1. Check file permissions and retry." ).arg( myFileName );
1421 return tr(
"ERROR: Failed to created default style file as %1. Check file permissions and retry." ).arg( myFileName );
1427 const QString qml = myDocument.toString();
1434 if ( myResult != SQLITE_OK )
1436 return tr(
"User database could not be opened." );
1439 QByteArray param0 = uri.toUtf8();
1440 QByteArray param1 = qml.toUtf8();
1446 mySql = QStringLiteral(
"create table if not exists tbl_metadata(metadata varchar primary key,qmd varchar)" );
1450 mySql = QStringLiteral(
"create table if not exists tbl_styles(style varchar primary key,qml varchar)" );
1454 statement = database.
prepare( mySql, myResult );
1455 if ( myResult == SQLITE_OK )
1457 if ( sqlite3_step( statement.get() ) != SQLITE_DONE )
1463 return tr(
"The metadata table could not be created." );
1466 return tr(
"The style table could not be created." );
1474 mySql = QStringLiteral(
"insert into tbl_metadata(metadata,qmd) values (?,?)" );
1478 mySql = QStringLiteral(
"insert into tbl_styles(style,qml) values (?,?)" );
1481 statement = database.
prepare( mySql, myResult );
1482 if ( myResult == SQLITE_OK )
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 )
1492 myErrorMessage = tr(
"The metadata %1 was saved to database" ).arg( uri );
1496 myErrorMessage = tr(
"The style %1 was saved to database" ).arg( uri );
1508 mySql = QStringLiteral(
"update tbl_metadata set qmd=? where metadata=?" );
1512 mySql = QStringLiteral(
"update tbl_styles set qml=? where style=?" );
1515 statement = database.
prepare( mySql, myResult );
1516 if ( myResult == SQLITE_OK )
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 )
1526 myErrorMessage = tr(
"The metadata %1 was updated in the database." ).arg( uri );
1530 myErrorMessage = tr(
"The style %1 was updated in the database." ).arg( uri );
1540 myErrorMessage = tr(
"The metadata %1 could not be updated in the database." ).arg( uri );
1544 myErrorMessage = tr(
"The style %1 could not be updated in the database." ).arg( uri );
1555 myErrorMessage = tr(
"The metadata %1 could not be inserted into database." ).arg( uri );
1559 myErrorMessage = tr(
"The style %1 could not be inserted into database." ).arg( uri );
1566 return myErrorMessage;
1576 QDomDocument myDocument = QDomDocument();
1578 const QDomNode header = myDocument.createProcessingInstruction( QStringLiteral(
"xml" ), QStringLiteral(
"version=\"1.0\" encoding=\"UTF-8\"" ) );
1579 myDocument.appendChild( header );
1581 const QgsVectorLayer *vlayer = qobject_cast<const QgsVectorLayer *>(
this );
1582 const QgsRasterLayer *rlayer = qobject_cast<const QgsRasterLayer *>(
this );
1583 if ( !vlayer && !rlayer )
1585 errorMsg = tr(
"Could not save symbology because:\n%1" )
1586 .arg( tr(
"Only vector and raster layers are supported" ) );
1591 QDomElement root = myDocument.createElementNS( QStringLiteral(
"http://www.opengis.net/sld" ), QStringLiteral(
"StyledLayerDescriptor" ) );
1592 QDomElement layerNode;
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 );
1604 layerNode = myDocument.createElement( QStringLiteral(
"NamedLayer" ) );
1605 root.appendChild( layerNode );
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 );
1619 layerNode = myDocument.createElement( QStringLiteral(
"UserLayer" ) );
1620 root.appendChild( layerNode );
1626 props[ QStringLiteral(
"scaleMinDenom" ) ] = QString::number( mMinScale );
1627 props[ QStringLiteral(
"scaleMaxDenom" ) ] = QString::number( mMaxScale );
1632 if ( !vlayer->
writeSld( layerNode, myDocument, errorMsg, props ) )
1634 errorMsg = tr(
"Could not save symbology because:\n%1" ).arg( errorMsg );
1641 if ( !rlayer->
writeSld( layerNode, myDocument, errorMsg, props ) )
1643 errorMsg = tr(
"Could not save symbology because:\n%1" ).arg( errorMsg );
1653 const QgsMapLayer *mlayer = qobject_cast<const QgsMapLayer *>(
this );
1656 QDomDocument myDocument;
1658 if ( !errorMsg.isNull() )
1666 if ( mlayer->
providerType() == QLatin1String(
"ogr" ) )
1668 QStringList theURIParts = uri.split(
'|' );
1669 filename = theURIParts[0];
1671 else if ( mlayer->
providerType() == QLatin1String(
"gpx" ) )
1673 QStringList theURIParts = uri.split(
'?' );
1674 filename = theURIParts[0];
1676 else if ( mlayer->
providerType() == QLatin1String(
"delimitedtext" ) )
1678 filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1680 if ( filename.isEmpty() )
1688 const QFileInfo myFileInfo( filename );
1689 if ( myFileInfo.exists() || filename.endsWith( QLatin1String(
".sld" ), Qt::CaseInsensitive ) )
1691 const QFileInfo myDirInfo( myFileInfo.path() );
1692 if ( !myDirInfo.isWritable() )
1694 return tr(
"The directory containing your dataset needs to be writable!" );
1698 const QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() +
".sld";
1700 QFile myFile( myFileName );
1701 if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1703 QTextStream myFileStream( &myFile );
1705 myDocument.save( myFileStream, 2 );
1708 return tr(
"Created default style file as %1" ).arg( myFileName );
1713 return tr(
"ERROR: Failed to created SLD style file as %1. Check file permissions and retry." ).arg( filename );
1720 QDomDocument myDocument;
1724 QString myErrorMessage;
1726 QFile myFile( uri );
1727 if ( myFile.open( QFile::ReadOnly ) )
1730 resultFlag = myDocument.setContent( &myFile,
true, &myErrorMessage, &line, &column );
1732 myErrorMessage = tr(
"%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1737 myErrorMessage = tr(
"Unable to open file %1" ).arg( uri );
1742 return myErrorMessage;
1746 const QDomElement myRoot = myDocument.firstChildElement( QStringLiteral(
"StyledLayerDescriptor" ) );
1747 if ( myRoot.isNull() )
1749 myErrorMessage = QStringLiteral(
"Error: StyledLayerDescriptor element not found in %1" ).arg( uri );
1751 return myErrorMessage;
1756 const QDomElement namedLayerElem = myRoot.firstChildElement( QStringLiteral(
"NamedLayer" ) );
1757 if ( namedLayerElem.isNull() )
1759 myErrorMessage = QStringLiteral(
"Info: NamedLayer element not found." );
1761 return myErrorMessage;
1765 resultFlag =
readSld( namedLayerElem, errorMsg );
1768 myErrorMessage = tr(
"Loading style file %1 failed because:\n%2" ).arg( uri, errorMsg );
1769 return myErrorMessage;
1778 Q_UNUSED( errorMessage )
1780 Q_UNUSED( categories )
1789 Q_UNUSED( errorMessage )
1791 Q_UNUSED( categories )
1797 bool loadDefaultStyleFlag )
1801 QgsDataProvider::ReadFlags
flags = QgsDataProvider::ReadFlags();
1802 if ( loadDefaultStyleFlag )
1817 QgsDataProvider::ReadFlags
flags = QgsDataProvider::ReadFlags();
1818 if ( loadDefaultStyleFlag )
1839 setDataSourcePrivate( dataSource, baseName, provider, options,
flags );
1846 void QgsMapLayer::setDataSourcePrivate(
const QString &dataSource,
const QString &baseName,
const QString &provider,
1849 Q_UNUSED( dataSource )
1850 Q_UNUSED( baseName )
1851 Q_UNUSED( provider )
1863 QgsMapLayer::StyleCategories categories )
1870 QDomElement renderer3DElem = layerElement.firstChildElement( QStringLiteral(
"renderer-3d" ) );
1871 if ( !renderer3DElem.isNull() )
1873 const QString type3D = renderer3DElem.attribute( QStringLiteral(
"type" ) );
1893 setScaleBasedVisibility( layerElement.attribute( QStringLiteral(
"hasScaleBasedVisibilityFlag" ) ).toInt() == 1 );
1894 if ( layerElement.hasAttribute( QStringLiteral(
"minimumScale" ) ) )
1897 setMaximumScale( layerElement.attribute( QStringLiteral(
"minimumScale" ) ).toDouble() );
1898 setMinimumScale( layerElement.attribute( QStringLiteral(
"maximumScale" ) ).toDouble() );
1902 setMaximumScale( layerElement.attribute( QStringLiteral(
"maxScale" ) ).toDouble() );
1903 setMinimumScale( layerElement.attribute( QStringLiteral(
"minScale" ) ).toDouble() );
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 )
1915 const QDomNode flagNode = flagsElem.namedItem( it.value() );
1916 if ( flagNode.isNull() )
1918 const bool flagValue = flagNode.toElement().text() ==
"1" ? true :
false;
1919 if (
flags.testFlag( it.key() ) && !flagValue )
1921 else if ( !
flags.testFlag( it.key() ) && flagValue )
1927 if ( categories.testFlag(
Temporal ) )
1932 properties->readXml( layerElement.toElement(), context );
1940 properties->readXml( layerElement.toElement(), context );
1943 if ( categories.testFlag(
Notes ) )
1945 const QDomElement notesElem = layerElement.firstChildElement( QStringLiteral(
"userNotes" ) );
1946 if ( !notesElem.isNull() )
1948 const QString notes = notesElem.attribute( QStringLiteral(
"value" ) );
1961 return mUndoStackStyles;
1966 return mCustomProperties.
keys();
1971 if ( !mCustomProperties.
contains( key ) || mCustomProperties.
value( key ) != value )
1973 mCustomProperties.
setValue( key, value );
1981 for (
const QString &key : mCustomProperties.
keys() )
1989 return mCustomProperties;
1994 return mCustomProperties.
value( value, defaultValue );
2000 if ( mCustomProperties.
contains( key ) )
2002 mCustomProperties.
remove( key );
2039 const QString path = sourceParts.value( QStringLiteral(
"path" ) ).toString();
2040 if ( path.isEmpty() )
2044 const QStringList tempPaths = QStandardPaths::standardLocations( QStandardPaths::TempLocation );
2045 for (
const QString &tempPath : tempPaths )
2047 if ( path.startsWith( tempPath ) )
2073 mLegend->setParent(
this );
2087 return mStyleManager;
2092 if ( renderer == m3DRenderer )
2096 m3DRenderer = renderer;
2109 if ( mRepaintRequestedFired )
2111 mRepaintRequestedFired =
true;
2113 mRepaintRequestedFired =
false;
2149 bool QgsMapLayer::isReadOnly()
const
2156 return mOriginalXmlProperties;
2167 const QString uuid = QUuid::createUuid().toString();
2169 QString
id = layerName +
'_' + uuid.mid( 1, uuid.length() - 2 );
2176 id.replace( QRegularExpression(
"[\\W]" ), QStringLiteral(
"_" ) );
2197 QSet<QgsMapLayerDependency> deps;
2198 const auto constODeps = oDeps;
2214 if ( !lDataProvider )
2232 if (
QgsMapLayerStore *store = qobject_cast<QgsMapLayerStore *>( parent() ) )
2234 return qobject_cast<QgsProject *>( store->parent() );
2239 void QgsMapLayer::onNotified(
const QString &message )
2252 if ( ! forceRecalculate && ! mWgs84Extent.
isNull() )
2256 else if ( ! mExtent.
isNull() )
2259 transformer.setBallparkTransformsAreAppropriate(
true );
2262 wgs84Extent = transformer.transformBoundingBox( mExtent );
2273 void QgsMapLayer::updateExtent(
const QgsRectangle &extent )
const
2281 if (
mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2290 if (
mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2298 QString
metadata = QStringLiteral(
"<h1>" ) + tr(
"General" ) + QStringLiteral(
"</h1>\n<hr>\n" ) + QStringLiteral(
"<table class=\"list-view\">\n" );
2301 metadata += QStringLiteral(
"<tr><td class=\"highlight\">" ) + tr(
"Name" ) + QStringLiteral(
"</td><td>" ) +
name() + QStringLiteral(
"</td></tr>\n" );
2304 bool isLocalPath =
false;
2309 if ( uriComponents.contains( QStringLiteral(
"path" ) ) )
2311 path = uriComponents[QStringLiteral(
"path" )].toString();
2312 QFileInfo fi( path );
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" );
2318 QDateTime lastModified = fi.lastModified();
2319 QString lastModifiedFileName;
2323 qint64 fileSize = fi.size();
2324 if ( !sidecarFiles.isEmpty() )
2326 lastModifiedFileName = fi.fileName();
2327 QStringList sidecarFileNames;
2328 for (
const QString &sidecarFile : sidecarFiles )
2330 QFileInfo sidecarFi( sidecarFile );
2331 fileSize += sidecarFi.size();
2332 if ( sidecarFi.lastModified() > lastModified )
2334 lastModified = sidecarFi.lastModified();
2335 lastModifiedFileName = sidecarFi.fileName();
2337 sidecarFileNames << sidecarFi.fileName();
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" );
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" );
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" );
2346 if ( uriComponents.contains( QStringLiteral(
"url" ) ) )
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" );
2355 metadata += QStringLiteral(
"<tr><td class=\"highlight\">" ) + tr(
"Source" ) + QStringLiteral(
"</td><td>%1" ).arg(
publicSource() != path ?
publicSource() : path ) + QStringLiteral(
"</td></tr>\n" );
2359 metadata += QStringLiteral(
"<tr><td class=\"highlight\">" ) + tr(
"Provider" ) + QStringLiteral(
"</td><td>%1" ).arg(
dataProvider()->
name() ) + QStringLiteral(
"</td></tr>\n" );
2361 metadata += QLatin1String(
"</table>\n<br><br>" );
2367 QString
metadata = QStringLiteral(
"<h1>" ) + tr(
"Coordinate Reference System (CRS)" ) + QStringLiteral(
"</h1>\n<hr>\n" );
2368 metadata += QLatin1String(
"<table class=\"list-view\">\n" );
2373 metadata += QStringLiteral(
"<tr><td colspan=\"2\" class=\"highlight\">" ) + tr(
"Unknown" ) + QStringLiteral(
"</td></tr>\n" );
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" );
2386 metadata += QStringLiteral(
"<tr><td class=\"highlight\">" ) + tr(
"Method" ) + QStringLiteral(
"</td><td>" ) + operation.
description() + QStringLiteral(
"</td></tr>\n" );
2391 const QString celestialBody =
c.celestialBodyName();
2392 if ( !celestialBody.isEmpty() )
2394 metadata += QStringLiteral(
"<tr><td class=\"highlight\">" ) + tr(
"Celestial body" ) + QStringLiteral(
"</td><td>" ) + celestialBody + QStringLiteral(
"</td></tr>\n" );
2402 QString accuracyString;
2404 if (
c.isDynamic() && std::isnan(
c.coordinateEpoch() ) )
2406 accuracyString = tr(
"Based on a dynamic CRS, but no coordinate epoch is set. Coordinates are ambiguous and of limited accuracy." );
2416 if ( !ensemble.
code().isEmpty() )
2417 id = QStringLiteral(
"<i>%1</i> (%2:%3)" ).arg( ensemble.
name(), ensemble.
authority(), ensemble.
code() );
2419 id = QStringLiteral(
"<i>%</i>”" ).arg( ensemble.
name() );
2423 accuracyString = tr(
"Based on %1, which has a limited accuracy of <b>at best %2 meters</b>." ).arg(
id ).arg( ensemble.
accuracy() );
2427 accuracyString = tr(
"Based on %1, which has a limited accuracy." ).arg(
id );
2436 if ( !accuracyString.isEmpty() )
2438 metadata += QStringLiteral(
"<tr><td class=\"highlight\">" ) + tr(
"Accuracy" ) + QStringLiteral(
"</td><td>" ) + accuracyString + QStringLiteral(
"</td></tr>\n" );
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)" ) );
2445 if ( !std::isnan(
c.coordinateEpoch() ) )
2447 metadata += QStringLiteral(
"<tr><td class=\"highlight\">" ) + tr(
"Coordinate epoch" ) + QStringLiteral(
"</td><td>%1</td></tr>\n" ).arg(
c.coordinateEpoch() );
2451 metadata += QLatin1String(
"</table>\n<br><br>\n" );
static QString version()
Version string.
static const double SCALE_PRECISION
Fudge factor used to compare two scales.
@ ForceFirstLetterToCapital
Convert just the first letter of each word to uppercase, leave the rest untouched.
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.
Custom exception class for Coordinate Reference System related exceptions.
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.
QString code() const
Identification code, e.g.
QString authority() const
Authority name, e.g.
bool isValid() const
Returns true if the datum ensemble is a valid object, or false if it is a null/invalid object.
QString name() const
Display name of datum ensemble.
double accuracy() const
Positional accuracy (in meters).
QgsError is container for error messages (report).
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.
static void setLayerNotes(QgsMapLayer *layer, const QString ¬es)
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.
void setShortName(const QString &shortName)
Sets the short name of the layer used by QGIS Server to identify the layer.
bool importNamedMetadata(QDomDocument &document, QString &errorMessage)
Import the metadata of this layer from a QDomDocument.
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.
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.
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.
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.
int mBlockStyleChangedSignal
If non-zero, the styleChanged signal should not be emitted.
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.
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.
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
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.
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
QString mLegendUrl
WMS legend.
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.
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.
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
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.
QgsMapLayerServerProperties * serverProperties()
Returns QGIS Server Properties for the map layer.
QPainter::CompositionMode blendMode() const
Returns the current blending mode for a layer.
void setDataUrl(const QString &dataUrl)
Sets the DataUrl of the layer used by QGIS Server in GetCapabilities request.
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.
void setAttribution(const QString &attrib)
Sets the attribution of the layer used by QGIS Server in GetCapabilities request.
void setFlags(QgsMapLayer::LayerFlags flags)
Returns the flags for this layer.
bool isRefreshOnNotifyEnabled() const
Returns true if the refresh on provider nofification is enabled.
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.
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.
Q_INVOKABLE void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for layer.
QString mProviderKey
Data provider key (name of the data provider)
QgsCoordinateTransformContext transformContext() const
Returns the layer data provider coordinate transform context or a default transform context if the la...
void styleChanged()
Signal emitted whenever a change affects the layer's style.
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.
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...
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.
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,...
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.
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.
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...
QString mDataSource
Data source description string, varies by layer type.
QString refreshOnNotifyMessage() const
Returns the message that should be notified by the provider to triggerRepaint.
virtual bool readSld(const QDomNode &node, QString &errorMessage)
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.
@ FlagTrustLayerMetadata
Trust layer metadata. Improves layer load time by skipping expensive checks like primary key unicity,...
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.
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.
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.
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.
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.
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.
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...
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
QString mDataUrl
DataUrl of the layer.
virtual Q_INVOKABLE QgsDataProvider * dataProvider()
Returns the layer's data provider, it may be nullptr.
double mLayerOpacity
Layer opacity.
bool mValid
Indicates if the layer is valid and can be drawn.
@ LayerConfiguration
General configuration: identifiable, removable, searchable, display expression, read-only.
@ Notes
Layer user notes (since QGIS 3.20)
@ Temporal
Temporal properties (since QGIS 3.14)
@ Rendering
Rendering: scale visibility, simplify method, opacity.
@ Elevation
Elevation settings (since QGIS 3.18)
@ Symbology3D
3D symbology
@ CustomProperties
Custom properties (by plugins for instance)
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.
void setRenderer3D(QgsAbstract3DRenderer *renderer)
Sets 3D renderer for the layer.
QString mAttribution
Attribution of the layer.
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.
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.
PropertyType
Maplayer has a style and a metadata property.
bool mShouldValidateCrs
true if the layer's CRS should be validated and invalid CRSes are not permitted.
void setCrs(const QgsCoordinateReferenceSystem &srs, bool emitSignal=true)
Sets layer's spatial reference system.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true)
Adds a message to the log instance (and creates it if necessary).
Custom exception class which is raised when an operation is not supported.
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.
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,...
bool removeAttachedFile(const QString &path)
Removes the attached file.
static QgsProject * instance()
Returns the QgsProject singleton instance.
QString baseName() const
Returns the base name of the project file without the path and without extension - derived from fileN...
QString absoluteFilePath() const
Returns full absolute path to the project file if the project is stored in a file system - derived fr...
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.
bool isNull() const
Test if the rectangle is null (all coordinates zero or after call to setMinimal()).
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.
static T readFlagAttribute(const QDomElement &element, const QString &attributeName, T defaultValue)
Read a flag value from an attribute of the element.
static QDomElement writeRectangle(const QgsRectangle &rect, QDomDocument &doc, const QString &elementName=QStringLiteral("extent"))
Encodes a rectangle to a DOM element.
static QgsRectangle readRectangle(const QDomElement &element)
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.
@ 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)
CONSTLATIN1STRING geoEpsgCrsAuthId()
Geographic coord sys from EPSG authority.
void(* CUSTOM_CRS_VALIDATION)(QgsCoordinateReferenceSystem &)
#define QgsDebugMsgLevel(str, level)
Setting options for creating vector data providers.