Branch data Line data Source code
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 <QDir>
20 : : #include <QDomDocument>
21 : : #include <QDomElement>
22 : : #include <QDomImplementation>
23 : : #include <QDomNode>
24 : : #include <QFile>
25 : : #include <QFileInfo>
26 : : #include <QTextStream>
27 : : #include <QUrl>
28 : : #include <QTimer>
29 : : #include <QStandardPaths>
30 : : #include <QUuid>
31 : :
32 : : #include <sqlite3.h>
33 : :
34 : : #include "qgssqliteutils.h"
35 : :
36 : : #include "qgssqliteutils.h"
37 : : #include "qgs3drendererregistry.h"
38 : : #include "qgsabstract3drenderer.h"
39 : : #include "qgsapplication.h"
40 : : #include "qgscoordinatereferencesystem.h"
41 : : #include "qgsdatasourceuri.h"
42 : : #include "qgslogger.h"
43 : : #include "qgsauthmanager.h"
44 : : #include "qgsmaplayer.h"
45 : : #include "qgsmaplayerlegend.h"
46 : : #include "qgsmaplayerstylemanager.h"
47 : : #include "qgsmeshlayer.h"
48 : : #include "qgspathresolver.h"
49 : : #include "qgsprojectfiletransform.h"
50 : : #include "qgsproject.h"
51 : : #include "qgsproviderregistry.h"
52 : : #include "qgsrasterlayer.h"
53 : : #include "qgsreadwritecontext.h"
54 : : #include "qgsrectangle.h"
55 : : #include "qgsvectorlayer.h"
56 : : #include "qgsvectordataprovider.h"
57 : : #include "qgsxmlutils.h"
58 : : #include "qgsstringutils.h"
59 : : #include "qgsmessagelog.h"
60 : : #include "qgsmaplayertemporalproperties.h"
61 : : #include "qgsmaplayerelevationproperties.h"
62 : :
63 : 64 : QString QgsMapLayer::extensionPropertyType( QgsMapLayer::PropertyType type )
64 : : {
65 : 64 : switch ( type )
66 : : {
67 : : case Metadata:
68 : 0 : return QStringLiteral( ".qmd" );
69 : :
70 : : case Style:
71 : 128 : return QStringLiteral( ".qml" );
72 : : }
73 : 0 : return QString();
74 : 64 : }
75 : :
76 : 249 : QgsMapLayer::QgsMapLayer( QgsMapLayerType type,
77 : : const QString &lyrname,
78 : : const QString &source )
79 : 83 : : mDataSource( source )
80 : 83 : , mLayerName( lyrname )
81 : 83 : , mLayerType( type )
82 : 83 : , mUndoStack( new QUndoStack( this ) )
83 : 83 : , mUndoStackStyles( new QUndoStack( this ) )
84 : 83 : , mStyleManager( new QgsMapLayerStyleManager( this ) )
85 : 83 : , mRefreshTimer( new QTimer( this ) )
86 : 166 : {
87 : 83 : mID = generateId( lyrname );
88 : 83 : connect( this, &QgsMapLayer::crsChanged, this, &QgsMapLayer::configChanged );
89 : 83 : connect( this, &QgsMapLayer::nameChanged, this, &QgsMapLayer::configChanged );
90 : 83 : connect( mRefreshTimer, &QTimer::timeout, this, [ = ] { triggerRepaint( true ); } );
91 : 83 : }
92 : :
93 : 65 : QgsMapLayer::~QgsMapLayer()
94 : 65 : {
95 : 65 : delete m3DRenderer;
96 : 65 : delete mLegend;
97 : 65 : delete mStyleManager;
98 : 65 : }
99 : :
100 : 0 : void QgsMapLayer::clone( QgsMapLayer *layer ) const
101 : : {
102 : 0 : layer->setBlendMode( blendMode() );
103 : :
104 : 0 : const auto constStyles = styleManager()->styles();
105 : 0 : for ( const QString &s : constStyles )
106 : : {
107 : 0 : layer->styleManager()->addStyle( s, styleManager()->style( s ) );
108 : : }
109 : :
110 : 0 : layer->setName( name() );
111 : 0 : layer->setShortName( shortName() );
112 : 0 : layer->setExtent( extent() );
113 : 0 : layer->setMaximumScale( maximumScale() );
114 : 0 : layer->setMinimumScale( minimumScale() );
115 : 0 : layer->setScaleBasedVisibility( hasScaleBasedVisibility() );
116 : 0 : layer->setTitle( title() );
117 : 0 : layer->setAbstract( abstract() );
118 : 0 : layer->setKeywordList( keywordList() );
119 : 0 : layer->setDataUrl( dataUrl() );
120 : 0 : layer->setDataUrlFormat( dataUrlFormat() );
121 : 0 : layer->setAttribution( attribution() );
122 : 0 : layer->setAttributionUrl( attributionUrl() );
123 : 0 : layer->setMetadataUrl( metadataUrl() );
124 : 0 : layer->setMetadataUrlType( metadataUrlType() );
125 : 0 : layer->setMetadataUrlFormat( metadataUrlFormat() );
126 : 0 : layer->setLegendUrl( legendUrl() );
127 : 0 : layer->setLegendUrlFormat( legendUrlFormat() );
128 : 0 : layer->setDependencies( dependencies() );
129 : 0 : layer->mShouldValidateCrs = mShouldValidateCrs;
130 : 0 : layer->setCrs( crs() );
131 : 0 : layer->setCustomProperties( mCustomProperties );
132 : 0 : layer->setOpacity( mLayerOpacity );
133 : 0 : }
134 : :
135 : 64 : QgsMapLayerType QgsMapLayer::type() const
136 : : {
137 : 64 : return mLayerType;
138 : : }
139 : :
140 : 0 : QgsMapLayer::LayerFlags QgsMapLayer::flags() const
141 : : {
142 : 0 : return mFlags;
143 : : }
144 : :
145 : 0 : void QgsMapLayer::setFlags( QgsMapLayer::LayerFlags flags )
146 : : {
147 : 0 : if ( flags == mFlags )
148 : 0 : return;
149 : :
150 : 0 : mFlags = flags;
151 : 0 : emit flagsChanged();
152 : 0 : }
153 : :
154 : 1089 : QString QgsMapLayer::id() const
155 : : {
156 : 1089 : return mID;
157 : : }
158 : :
159 : 78 : void QgsMapLayer::setName( const QString &name )
160 : : {
161 : 78 : if ( name == mLayerName )
162 : 78 : return;
163 : :
164 : 0 : mLayerName = name;
165 : :
166 : 0 : emit nameChanged();
167 : 78 : }
168 : :
169 : 340 : QString QgsMapLayer::name() const
170 : : {
171 : 340 : QgsDebugMsgLevel( "returning name '" + mLayerName + '\'', 4 );
172 : 340 : return mLayerName;
173 : : }
174 : :
175 : 0 : QgsDataProvider *QgsMapLayer::dataProvider()
176 : : {
177 : 0 : return nullptr;
178 : : }
179 : :
180 : 0 : const QgsDataProvider *QgsMapLayer::dataProvider() const
181 : : {
182 : 0 : return nullptr;
183 : : }
184 : :
185 : 0 : QString QgsMapLayer::shortName() const
186 : : {
187 : 0 : return mShortName;
188 : : }
189 : :
190 : 93 : QString QgsMapLayer::publicSource() const
191 : : {
192 : : // Redo this every time we're asked for it, as we don't know if
193 : : // dataSource has changed.
194 : 93 : QString safeName = QgsDataSourceUri::removePassword( mDataSource );
195 : 93 : return safeName;
196 : 93 : }
197 : :
198 : 0 : QString QgsMapLayer::source() const
199 : : {
200 : 0 : return mDataSource;
201 : : }
202 : :
203 : 88 : QgsRectangle QgsMapLayer::extent() const
204 : : {
205 : 88 : return mExtent;
206 : : }
207 : :
208 : 0 : void QgsMapLayer::setBlendMode( const QPainter::CompositionMode blendMode )
209 : : {
210 : 0 : if ( mBlendMode == blendMode )
211 : 0 : return;
212 : :
213 : 0 : mBlendMode = blendMode;
214 : 0 : emit blendModeChanged( blendMode );
215 : 0 : emit styleChanged();
216 : 0 : }
217 : :
218 : 0 : QPainter::CompositionMode QgsMapLayer::blendMode() const
219 : : {
220 : 0 : return mBlendMode;
221 : : }
222 : :
223 : 8 : void QgsMapLayer::setOpacity( double opacity )
224 : : {
225 : 8 : if ( qgsDoubleNear( mLayerOpacity, opacity ) )
226 : 8 : return;
227 : 0 : mLayerOpacity = opacity;
228 : 0 : emit opacityChanged( opacity );
229 : 0 : emit styleChanged();
230 : 8 : }
231 : :
232 : 0 : double QgsMapLayer::opacity() const
233 : : {
234 : 0 : return mLayerOpacity;
235 : : }
236 : :
237 : 0 : bool QgsMapLayer::readLayerXml( const QDomElement &layerElement, QgsReadWriteContext &context, QgsMapLayer::ReadFlags flags )
238 : : {
239 : : bool layerError;
240 : 0 : mReadFlags = flags;
241 : :
242 : 0 : QDomNode mnl;
243 : 0 : QDomElement mne;
244 : :
245 : : // read provider
246 : 0 : QString provider;
247 : 0 : mnl = layerElement.namedItem( QStringLiteral( "provider" ) );
248 : 0 : mne = mnl.toElement();
249 : 0 : provider = mne.text();
250 : :
251 : : // set data source
252 : 0 : mnl = layerElement.namedItem( QStringLiteral( "datasource" ) );
253 : 0 : mne = mnl.toElement();
254 : 0 : mDataSource = mne.text();
255 : :
256 : : // if the layer needs authentication, ensure the master password is set
257 : 0 : QRegExp rx( "authcfg=([a-z]|[A-Z]|[0-9]){7}" );
258 : 0 : if ( ( rx.indexIn( mDataSource ) != -1 )
259 : 0 : && !QgsApplication::authManager()->setMasterPassword( true ) )
260 : : {
261 : 0 : return false;
262 : : }
263 : :
264 : 0 : mDataSource = decodedSource( mDataSource, provider, context );
265 : :
266 : : // Set the CRS from project file, asking the user if necessary.
267 : : // Make it the saved CRS to have WMS layer projected correctly.
268 : : // We will still overwrite whatever GDAL etc picks up anyway
269 : : // further down this function.
270 : 0 : mnl = layerElement.namedItem( QStringLiteral( "layername" ) );
271 : 0 : mne = mnl.toElement();
272 : :
273 : 0 : QgsCoordinateReferenceSystem savedCRS;
274 : : CUSTOM_CRS_VALIDATION savedValidation;
275 : :
276 : 0 : QDomNode srsNode = layerElement.namedItem( QStringLiteral( "srs" ) );
277 : 0 : mCRS.readXml( srsNode );
278 : 0 : mCRS.setValidationHint( tr( "Specify CRS for layer %1" ).arg( mne.text() ) );
279 : 0 : if ( isSpatial() && type() != QgsMapLayerType::AnnotationLayer )
280 : 0 : mCRS.validate();
281 : 0 : savedCRS = mCRS;
282 : :
283 : : // Do not validate any projections in children, they will be overwritten anyway.
284 : : // No need to ask the user for a projections when it is overwritten, is there?
285 : 0 : savedValidation = QgsCoordinateReferenceSystem::customCrsValidation();
286 : 0 : QgsCoordinateReferenceSystem::setCustomCrsValidation( nullptr );
287 : :
288 : 0 : QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Layer" ), mne.text() );
289 : :
290 : : // the internal name is just the data source basename
291 : : //QFileInfo dataSourceFileInfo( mDataSource );
292 : : //internalName = dataSourceFileInfo.baseName();
293 : :
294 : : // set ID
295 : 0 : mnl = layerElement.namedItem( QStringLiteral( "id" ) );
296 : 0 : if ( ! mnl.isNull() )
297 : : {
298 : 0 : mne = mnl.toElement();
299 : 0 : if ( ! mne.isNull() && mne.text().length() > 10 ) // should be at least 17 (yyyyMMddhhmmsszzz)
300 : : {
301 : 0 : mID = mne.text();
302 : 0 : }
303 : 0 : }
304 : :
305 : : // set name
306 : 0 : mnl = layerElement.namedItem( QStringLiteral( "layername" ) );
307 : 0 : mne = mnl.toElement();
308 : :
309 : : //name can be translated
310 : 0 : setName( context.projectTranslator()->translate( QStringLiteral( "project:layers:%1" ).arg( layerElement.namedItem( QStringLiteral( "id" ) ).toElement().text() ), mne.text() ) );
311 : :
312 : : // now let the children grab what they need from the Dom node.
313 : 0 : layerError = !readXml( layerElement, context );
314 : :
315 : : // overwrite CRS with what we read from project file before the raster/vector
316 : : // file reading functions changed it. They will if projections is specified in the file.
317 : : // FIXME: is this necessary? Yes, it is (autumn 2019)
318 : 0 : QgsCoordinateReferenceSystem::setCustomCrsValidation( savedValidation );
319 : 0 : mCRS = savedCRS;
320 : :
321 : : //short name
322 : 0 : QDomElement shortNameElem = layerElement.firstChildElement( QStringLiteral( "shortname" ) );
323 : 0 : if ( !shortNameElem.isNull() )
324 : : {
325 : 0 : mShortName = shortNameElem.text();
326 : 0 : }
327 : :
328 : : //title
329 : 0 : QDomElement titleElem = layerElement.firstChildElement( QStringLiteral( "title" ) );
330 : 0 : if ( !titleElem.isNull() )
331 : : {
332 : 0 : mTitle = titleElem.text();
333 : 0 : }
334 : :
335 : : //abstract
336 : 0 : QDomElement abstractElem = layerElement.firstChildElement( QStringLiteral( "abstract" ) );
337 : 0 : if ( !abstractElem.isNull() )
338 : : {
339 : 0 : mAbstract = abstractElem.text();
340 : 0 : }
341 : :
342 : : //keywordList
343 : 0 : QDomElement keywordListElem = layerElement.firstChildElement( QStringLiteral( "keywordList" ) );
344 : 0 : if ( !keywordListElem.isNull() )
345 : : {
346 : 0 : QStringList kwdList;
347 : 0 : for ( QDomNode n = keywordListElem.firstChild(); !n.isNull(); n = n.nextSibling() )
348 : : {
349 : 0 : kwdList << n.toElement().text();
350 : 0 : }
351 : 0 : mKeywordList = kwdList.join( QLatin1String( ", " ) );
352 : 0 : }
353 : :
354 : : //metadataUrl
355 : 0 : QDomElement dataUrlElem = layerElement.firstChildElement( QStringLiteral( "dataUrl" ) );
356 : 0 : if ( !dataUrlElem.isNull() )
357 : : {
358 : 0 : mDataUrl = dataUrlElem.text();
359 : 0 : mDataUrlFormat = dataUrlElem.attribute( QStringLiteral( "format" ), QString() );
360 : 0 : }
361 : :
362 : : //legendUrl
363 : 0 : QDomElement legendUrlElem = layerElement.firstChildElement( QStringLiteral( "legendUrl" ) );
364 : 0 : if ( !legendUrlElem.isNull() )
365 : : {
366 : 0 : mLegendUrl = legendUrlElem.text();
367 : 0 : mLegendUrlFormat = legendUrlElem.attribute( QStringLiteral( "format" ), QString() );
368 : 0 : }
369 : :
370 : : //attribution
371 : 0 : QDomElement attribElem = layerElement.firstChildElement( QStringLiteral( "attribution" ) );
372 : 0 : if ( !attribElem.isNull() )
373 : : {
374 : 0 : mAttribution = attribElem.text();
375 : 0 : mAttributionUrl = attribElem.attribute( QStringLiteral( "href" ), QString() );
376 : 0 : }
377 : :
378 : : //metadataUrl
379 : 0 : QDomElement metaUrlElem = layerElement.firstChildElement( QStringLiteral( "metadataUrl" ) );
380 : 0 : if ( !metaUrlElem.isNull() )
381 : : {
382 : 0 : mMetadataUrl = metaUrlElem.text();
383 : 0 : mMetadataUrlType = metaUrlElem.attribute( QStringLiteral( "type" ), QString() );
384 : 0 : mMetadataUrlFormat = metaUrlElem.attribute( QStringLiteral( "format" ), QString() );
385 : 0 : }
386 : :
387 : : // mMetadata.readFromLayer( this );
388 : 0 : QDomElement metadataElem = layerElement.firstChildElement( QStringLiteral( "resourceMetadata" ) );
389 : 0 : mMetadata.readMetadataXml( metadataElem );
390 : :
391 : 0 : setAutoRefreshInterval( layerElement.attribute( QStringLiteral( "autoRefreshTime" ), QStringLiteral( "0" ) ).toInt() );
392 : 0 : setAutoRefreshEnabled( layerElement.attribute( QStringLiteral( "autoRefreshEnabled" ), QStringLiteral( "0" ) ).toInt() );
393 : 0 : setRefreshOnNofifyMessage( layerElement.attribute( QStringLiteral( "refreshOnNotifyMessage" ), QString() ) );
394 : 0 : setRefreshOnNotifyEnabled( layerElement.attribute( QStringLiteral( "refreshOnNotifyEnabled" ), QStringLiteral( "0" ) ).toInt() );
395 : :
396 : : // geographic extent is read only if necessary
397 : 0 : if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
398 : : {
399 : 0 : const QDomNode wgs84ExtentNode = layerElement.namedItem( QStringLiteral( "wgs84extent" ) );
400 : 0 : if ( !wgs84ExtentNode.isNull() )
401 : 0 : mWgs84Extent = QgsXmlUtils::readRectangle( wgs84ExtentNode.toElement() );
402 : 0 : }
403 : :
404 : 0 : return ! layerError;
405 : 0 : } // bool QgsMapLayer::readLayerXML
406 : :
407 : :
408 : 0 : bool QgsMapLayer::readXml( const QDomNode &layer_node, QgsReadWriteContext &context )
409 : : {
410 : 0 : Q_UNUSED( layer_node )
411 : 0 : Q_UNUSED( context )
412 : : // NOP by default; children will over-ride with behavior specific to them
413 : :
414 : 0 : return true;
415 : : } // void QgsMapLayer::readXml
416 : :
417 : :
418 : 0 : bool QgsMapLayer::writeLayerXml( QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context ) const
419 : : {
420 : 0 : if ( !extent().isNull() )
421 : : {
422 : 0 : layerElement.appendChild( QgsXmlUtils::writeRectangle( mExtent, document ) );
423 : 0 : layerElement.appendChild( QgsXmlUtils::writeRectangle( wgs84Extent( true ), document, QStringLiteral( "wgs84extent" ) ) );
424 : 0 : }
425 : :
426 : 0 : layerElement.setAttribute( QStringLiteral( "autoRefreshTime" ), QString::number( mRefreshTimer->interval() ) );
427 : 0 : layerElement.setAttribute( QStringLiteral( "autoRefreshEnabled" ), mRefreshTimer->isActive() ? 1 : 0 );
428 : 0 : layerElement.setAttribute( QStringLiteral( "refreshOnNotifyEnabled" ), mIsRefreshOnNofifyEnabled ? 1 : 0 );
429 : 0 : layerElement.setAttribute( QStringLiteral( "refreshOnNotifyMessage" ), mRefreshOnNofifyMessage );
430 : :
431 : :
432 : : // ID
433 : 0 : QDomElement layerId = document.createElement( QStringLiteral( "id" ) );
434 : 0 : QDomText layerIdText = document.createTextNode( id() );
435 : 0 : layerId.appendChild( layerIdText );
436 : :
437 : 0 : layerElement.appendChild( layerId );
438 : :
439 : : // data source
440 : 0 : QDomElement dataSource = document.createElement( QStringLiteral( "datasource" ) );
441 : 0 : QString src = encodedSource( source(), context );
442 : 0 : QDomText dataSourceText = document.createTextNode( src );
443 : 0 : dataSource.appendChild( dataSourceText );
444 : 0 : layerElement.appendChild( dataSource );
445 : :
446 : : // layer name
447 : 0 : QDomElement layerName = document.createElement( QStringLiteral( "layername" ) );
448 : 0 : QDomText layerNameText = document.createTextNode( name() );
449 : 0 : layerName.appendChild( layerNameText );
450 : 0 : layerElement.appendChild( layerName );
451 : :
452 : : // layer short name
453 : 0 : if ( !mShortName.isEmpty() )
454 : : {
455 : 0 : QDomElement layerShortName = document.createElement( QStringLiteral( "shortname" ) );
456 : 0 : QDomText layerShortNameText = document.createTextNode( mShortName );
457 : 0 : layerShortName.appendChild( layerShortNameText );
458 : 0 : layerElement.appendChild( layerShortName );
459 : 0 : }
460 : :
461 : : // layer title
462 : 0 : if ( !mTitle.isEmpty() )
463 : : {
464 : 0 : QDomElement layerTitle = document.createElement( QStringLiteral( "title" ) );
465 : 0 : QDomText layerTitleText = document.createTextNode( mTitle );
466 : 0 : layerTitle.appendChild( layerTitleText );
467 : 0 : layerElement.appendChild( layerTitle );
468 : 0 : }
469 : :
470 : : // layer abstract
471 : 0 : if ( !mAbstract.isEmpty() )
472 : : {
473 : 0 : QDomElement layerAbstract = document.createElement( QStringLiteral( "abstract" ) );
474 : 0 : QDomText layerAbstractText = document.createTextNode( mAbstract );
475 : 0 : layerAbstract.appendChild( layerAbstractText );
476 : 0 : layerElement.appendChild( layerAbstract );
477 : 0 : }
478 : :
479 : : // layer keyword list
480 : 0 : QStringList keywordStringList = keywordList().split( ',' );
481 : 0 : if ( !keywordStringList.isEmpty() )
482 : : {
483 : 0 : QDomElement layerKeywordList = document.createElement( QStringLiteral( "keywordList" ) );
484 : 0 : for ( int i = 0; i < keywordStringList.size(); ++i )
485 : : {
486 : 0 : QDomElement layerKeywordValue = document.createElement( QStringLiteral( "value" ) );
487 : 0 : QDomText layerKeywordText = document.createTextNode( keywordStringList.at( i ).trimmed() );
488 : 0 : layerKeywordValue.appendChild( layerKeywordText );
489 : 0 : layerKeywordList.appendChild( layerKeywordValue );
490 : 0 : }
491 : 0 : layerElement.appendChild( layerKeywordList );
492 : 0 : }
493 : :
494 : : // layer metadataUrl
495 : 0 : QString aDataUrl = dataUrl();
496 : 0 : if ( !aDataUrl.isEmpty() )
497 : : {
498 : 0 : QDomElement layerDataUrl = document.createElement( QStringLiteral( "dataUrl" ) );
499 : 0 : QDomText layerDataUrlText = document.createTextNode( aDataUrl );
500 : 0 : layerDataUrl.appendChild( layerDataUrlText );
501 : 0 : layerDataUrl.setAttribute( QStringLiteral( "format" ), dataUrlFormat() );
502 : 0 : layerElement.appendChild( layerDataUrl );
503 : 0 : }
504 : :
505 : : // layer legendUrl
506 : 0 : QString aLegendUrl = legendUrl();
507 : 0 : if ( !aLegendUrl.isEmpty() )
508 : : {
509 : 0 : QDomElement layerLegendUrl = document.createElement( QStringLiteral( "legendUrl" ) );
510 : 0 : QDomText layerLegendUrlText = document.createTextNode( aLegendUrl );
511 : 0 : layerLegendUrl.appendChild( layerLegendUrlText );
512 : 0 : layerLegendUrl.setAttribute( QStringLiteral( "format" ), legendUrlFormat() );
513 : 0 : layerElement.appendChild( layerLegendUrl );
514 : 0 : }
515 : :
516 : : // layer attribution
517 : 0 : QString aAttribution = attribution();
518 : 0 : if ( !aAttribution.isEmpty() )
519 : : {
520 : 0 : QDomElement layerAttribution = document.createElement( QStringLiteral( "attribution" ) );
521 : 0 : QDomText layerAttributionText = document.createTextNode( aAttribution );
522 : 0 : layerAttribution.appendChild( layerAttributionText );
523 : 0 : layerAttribution.setAttribute( QStringLiteral( "href" ), attributionUrl() );
524 : 0 : layerElement.appendChild( layerAttribution );
525 : 0 : }
526 : :
527 : : // layer metadataUrl
528 : 0 : QString aMetadataUrl = metadataUrl();
529 : 0 : if ( !aMetadataUrl.isEmpty() )
530 : : {
531 : 0 : QDomElement layerMetadataUrl = document.createElement( QStringLiteral( "metadataUrl" ) );
532 : 0 : QDomText layerMetadataUrlText = document.createTextNode( aMetadataUrl );
533 : 0 : layerMetadataUrl.appendChild( layerMetadataUrlText );
534 : 0 : layerMetadataUrl.setAttribute( QStringLiteral( "type" ), metadataUrlType() );
535 : 0 : layerMetadataUrl.setAttribute( QStringLiteral( "format" ), metadataUrlFormat() );
536 : 0 : layerElement.appendChild( layerMetadataUrl );
537 : 0 : }
538 : :
539 : : // timestamp if supported
540 : 0 : if ( timestamp() > QDateTime() )
541 : : {
542 : 0 : QDomElement stamp = document.createElement( QStringLiteral( "timestamp" ) );
543 : 0 : QDomText stampText = document.createTextNode( timestamp().toString( Qt::ISODate ) );
544 : 0 : stamp.appendChild( stampText );
545 : 0 : layerElement.appendChild( stamp );
546 : 0 : }
547 : :
548 : 0 : layerElement.appendChild( layerName );
549 : :
550 : : // zorder
551 : : // This is no longer stored in the project file. It is superfluous since the layers
552 : : // are written and read in the proper order.
553 : :
554 : : // spatial reference system id
555 : 0 : QDomElement mySrsElement = document.createElement( QStringLiteral( "srs" ) );
556 : 0 : mCRS.writeXml( mySrsElement, document );
557 : 0 : layerElement.appendChild( mySrsElement );
558 : :
559 : : // layer metadata
560 : 0 : QDomElement myMetadataElem = document.createElement( QStringLiteral( "resourceMetadata" ) );
561 : 0 : mMetadata.writeMetadataXml( myMetadataElem, document );
562 : 0 : layerElement.appendChild( myMetadataElem );
563 : :
564 : : // now append layer node to map layer node
565 : 0 : return writeXml( layerElement, document, context );
566 : 0 : }
567 : :
568 : 0 : void QgsMapLayer::writeCommonStyle( QDomElement &layerElement, QDomDocument &document,
569 : : const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
570 : : {
571 : : // save categories
572 : 0 : QMetaEnum metaEnum = QMetaEnum::fromType<QgsMapLayer::StyleCategories>();
573 : 0 : QString categoriesKeys( metaEnum.valueToKeys( static_cast<int>( categories ) ) );
574 : 0 : layerElement.setAttribute( QStringLiteral( "styleCategories" ), categoriesKeys );
575 : :
576 : 0 : if ( categories.testFlag( Rendering ) )
577 : : {
578 : : // use scale dependent visibility flag
579 : 0 : layerElement.setAttribute( QStringLiteral( "hasScaleBasedVisibilityFlag" ), hasScaleBasedVisibility() ? 1 : 0 );
580 : 0 : layerElement.setAttribute( QStringLiteral( "maxScale" ), QString::number( maximumScale() ) );
581 : 0 : layerElement.setAttribute( QStringLiteral( "minScale" ), QString::number( minimumScale() ) );
582 : 0 : }
583 : :
584 : 0 : if ( categories.testFlag( Symbology3D ) )
585 : : {
586 : 0 : if ( m3DRenderer )
587 : : {
588 : 0 : QDomElement renderer3DElem = document.createElement( QStringLiteral( "renderer-3d" ) );
589 : 0 : renderer3DElem.setAttribute( QStringLiteral( "type" ), m3DRenderer->type() );
590 : 0 : m3DRenderer->writeXml( renderer3DElem, context );
591 : 0 : layerElement.appendChild( renderer3DElem );
592 : 0 : }
593 : 0 : }
594 : :
595 : 0 : if ( categories.testFlag( LayerConfiguration ) )
596 : : {
597 : : // flags
598 : : // this code is saving automatically all the flags entries
599 : 0 : QDomElement layerFlagsElem = document.createElement( QStringLiteral( "flags" ) );
600 : 0 : auto enumMap = qgsEnumMap<QgsMapLayer::LayerFlag>();
601 : 0 : for ( auto it = enumMap.constBegin(); it != enumMap.constEnd(); ++it )
602 : : {
603 : 0 : bool flagValue = mFlags.testFlag( it.key() );
604 : 0 : QDomElement flagElem = document.createElement( it.value() );
605 : 0 : flagElem.appendChild( document.createTextNode( QString::number( flagValue ) ) );
606 : 0 : layerFlagsElem.appendChild( flagElem );
607 : 0 : }
608 : 0 : layerElement.appendChild( layerFlagsElem );
609 : 0 : }
610 : :
611 : 0 : if ( categories.testFlag( Temporal ) )
612 : : {
613 : 0 : if ( QgsMapLayerTemporalProperties *properties = const_cast< QgsMapLayer * >( this )->temporalProperties() )
614 : 0 : properties->writeXml( layerElement, document, context );
615 : 0 : }
616 : :
617 : 0 : if ( categories.testFlag( Elevation ) )
618 : : {
619 : 0 : if ( QgsMapLayerElevationProperties *properties = const_cast< QgsMapLayer * >( this )->elevationProperties() )
620 : 0 : properties->writeXml( layerElement, document, context );
621 : 0 : }
622 : :
623 : :
624 : : // custom properties
625 : 0 : if ( categories.testFlag( CustomProperties ) )
626 : : {
627 : 0 : writeCustomProperties( layerElement, document );
628 : 0 : }
629 : 0 : }
630 : :
631 : :
632 : 0 : bool QgsMapLayer::writeXml( QDomNode &layer_node, QDomDocument &document, const QgsReadWriteContext &context ) const
633 : : {
634 : 0 : Q_UNUSED( layer_node )
635 : 0 : Q_UNUSED( document )
636 : 0 : Q_UNUSED( context )
637 : : // NOP by default; children will over-ride with behavior specific to them
638 : :
639 : 0 : return true;
640 : : }
641 : :
642 : 0 : QString QgsMapLayer::encodedSource( const QString &source, const QgsReadWriteContext &context ) const
643 : : {
644 : 0 : Q_UNUSED( context )
645 : 0 : return source;
646 : : }
647 : :
648 : 0 : QString QgsMapLayer::decodedSource( const QString &source, const QString &dataProvider, const QgsReadWriteContext &context ) const
649 : : {
650 : 0 : Q_UNUSED( context )
651 : 0 : Q_UNUSED( dataProvider )
652 : 0 : return source;
653 : : }
654 : :
655 : 0 : void QgsMapLayer::resolveReferences( QgsProject *project )
656 : : {
657 : 0 : emit beforeResolveReferences( project );
658 : 0 : if ( m3DRenderer )
659 : 0 : m3DRenderer->resolveReferences( *project );
660 : 0 : }
661 : :
662 : :
663 : 0 : void QgsMapLayer::readCustomProperties( const QDomNode &layerNode, const QString &keyStartsWith )
664 : : {
665 : 0 : mCustomProperties.readXml( layerNode, keyStartsWith );
666 : 0 : }
667 : :
668 : 0 : void QgsMapLayer::writeCustomProperties( QDomNode &layerNode, QDomDocument &doc ) const
669 : : {
670 : 0 : mCustomProperties.writeXml( layerNode, doc );
671 : 0 : }
672 : :
673 : 0 : void QgsMapLayer::readStyleManager( const QDomNode &layerNode )
674 : : {
675 : 0 : QDomElement styleMgrElem = layerNode.firstChildElement( QStringLiteral( "map-layer-style-manager" ) );
676 : 0 : if ( !styleMgrElem.isNull() )
677 : 0 : mStyleManager->readXml( styleMgrElem );
678 : : else
679 : 0 : mStyleManager->reset();
680 : 0 : }
681 : :
682 : 0 : void QgsMapLayer::writeStyleManager( QDomNode &layerNode, QDomDocument &doc ) const
683 : : {
684 : 0 : if ( mStyleManager )
685 : : {
686 : 0 : QDomElement styleMgrElem = doc.createElement( QStringLiteral( "map-layer-style-manager" ) );
687 : 0 : mStyleManager->writeXml( styleMgrElem );
688 : 0 : layerNode.appendChild( styleMgrElem );
689 : 0 : }
690 : 0 : }
691 : :
692 : 369 : bool QgsMapLayer::isValid() const
693 : : {
694 : 369 : return mValid;
695 : : }
696 : :
697 : : #if 0
698 : : void QgsMapLayer::connectNotify( const char *signal )
699 : : {
700 : : Q_UNUSED( signal )
701 : : QgsDebugMsgLevel( "QgsMapLayer connected to " + QString( signal ), 3 );
702 : : } // QgsMapLayer::connectNotify
703 : : #endif
704 : :
705 : 0 : bool QgsMapLayer::isInScaleRange( double scale ) const
706 : : {
707 : 0 : return !mScaleBasedVisibility ||
708 : 0 : ( ( mMinScale == 0 || mMinScale * Qgis::SCALE_PRECISION < scale )
709 : 0 : && ( mMaxScale == 0 || scale < mMaxScale ) );
710 : : }
711 : :
712 : 0 : bool QgsMapLayer::hasScaleBasedVisibility() const
713 : : {
714 : 0 : return mScaleBasedVisibility;
715 : : }
716 : :
717 : 0 : bool QgsMapLayer::hasAutoRefreshEnabled() const
718 : : {
719 : 0 : return mRefreshTimer->isActive();
720 : : }
721 : :
722 : 0 : int QgsMapLayer::autoRefreshInterval() const
723 : : {
724 : 0 : return mRefreshTimer->interval();
725 : : }
726 : :
727 : 0 : void QgsMapLayer::setAutoRefreshInterval( int interval )
728 : : {
729 : 0 : if ( interval <= 0 )
730 : : {
731 : 0 : mRefreshTimer->stop();
732 : 0 : mRefreshTimer->setInterval( 0 );
733 : 0 : }
734 : : else
735 : : {
736 : 0 : mRefreshTimer->setInterval( interval );
737 : : }
738 : 0 : emit autoRefreshIntervalChanged( mRefreshTimer->isActive() ? mRefreshTimer->interval() : 0 );
739 : 0 : }
740 : :
741 : 0 : void QgsMapLayer::setAutoRefreshEnabled( bool enabled )
742 : : {
743 : 0 : if ( !enabled )
744 : 0 : mRefreshTimer->stop();
745 : 0 : else if ( mRefreshTimer->interval() > 0 )
746 : 0 : mRefreshTimer->start();
747 : :
748 : 0 : emit autoRefreshIntervalChanged( mRefreshTimer->isActive() ? mRefreshTimer->interval() : 0 );
749 : 0 : }
750 : :
751 : 0 : const QgsLayerMetadata &QgsMapLayer::metadata() const
752 : : {
753 : 0 : return mMetadata;
754 : : }
755 : :
756 : 0 : void QgsMapLayer::setMaximumScale( double scale )
757 : : {
758 : 0 : mMinScale = scale;
759 : 0 : }
760 : :
761 : 0 : double QgsMapLayer::maximumScale() const
762 : : {
763 : 0 : return mMinScale;
764 : : }
765 : :
766 : :
767 : 0 : void QgsMapLayer::setMinimumScale( double scale )
768 : : {
769 : 0 : mMaxScale = scale;
770 : 0 : }
771 : :
772 : 0 : void QgsMapLayer::setScaleBasedVisibility( const bool enabled )
773 : : {
774 : 0 : mScaleBasedVisibility = enabled;
775 : 0 : }
776 : :
777 : 0 : double QgsMapLayer::minimumScale() const
778 : : {
779 : 0 : return mMaxScale;
780 : : }
781 : :
782 : 0 : QStringList QgsMapLayer::subLayers() const
783 : : {
784 : 0 : return QStringList(); // Empty
785 : : }
786 : :
787 : 0 : void QgsMapLayer::setLayerOrder( const QStringList &layers )
788 : : {
789 : 0 : Q_UNUSED( layers )
790 : : // NOOP
791 : 0 : }
792 : :
793 : 0 : void QgsMapLayer::setSubLayerVisibility( const QString &name, bool vis )
794 : : {
795 : 0 : Q_UNUSED( name )
796 : : Q_UNUSED( vis )
797 : : // NOOP
798 : 0 : }
799 : :
800 : 775 : QgsCoordinateReferenceSystem QgsMapLayer::crs() const
801 : : {
802 : 775 : return mCRS;
803 : : }
804 : :
805 : 86 : void QgsMapLayer::setCrs( const QgsCoordinateReferenceSystem &srs, bool emitSignal )
806 : : {
807 : 86 : mCRS = srs;
808 : :
809 : 86 : if ( mShouldValidateCrs && isSpatial() && !mCRS.isValid() && type() != QgsMapLayerType::AnnotationLayer )
810 : : {
811 : 63 : mCRS.setValidationHint( tr( "Specify CRS for layer %1" ).arg( name() ) );
812 : 63 : mCRS.validate();
813 : 63 : }
814 : :
815 : 86 : if ( emitSignal )
816 : 86 : emit crsChanged();
817 : 86 : }
818 : :
819 : 4 : QgsCoordinateTransformContext QgsMapLayer::transformContext() const
820 : : {
821 : 4 : const QgsDataProvider *lDataProvider = dataProvider();
822 : 4 : return lDataProvider ? lDataProvider->transformContext() : QgsCoordinateTransformContext();
823 : : }
824 : :
825 : 0 : QString QgsMapLayer::formatLayerName( const QString &name )
826 : : {
827 : 0 : QString layerName( name );
828 : 0 : layerName.replace( '_', ' ' );
829 : 0 : layerName = QgsStringUtils::capitalize( layerName, QgsStringUtils::ForceFirstLetterToCapital );
830 : 0 : return layerName;
831 : 0 : }
832 : :
833 : 78 : QString QgsMapLayer::baseURI( PropertyType type ) const
834 : : {
835 : 78 : QString myURI = publicSource();
836 : :
837 : : // first get base path for delimited text, spatialite and OGR layers,
838 : : // as in these cases URI may contain layer name and/or additional
839 : : // information. This also strips prefix in case if VSIFILE mechanism
840 : : // is used
841 : 92 : if ( providerType() == QLatin1String( "ogr" ) || providerType() == QLatin1String( "delimitedtext" ) ||
842 : 14 : providerType() == QLatin1String( "spatialite" ) )
843 : : {
844 : 64 : QVariantMap components = QgsProviderRegistry::instance()->decodeUri( providerType(), myURI );
845 : 64 : myURI = components["path"].toString();
846 : 64 : }
847 : :
848 : 78 : QFileInfo myFileInfo( myURI );
849 : 78 : QString key;
850 : :
851 : 78 : if ( myFileInfo.exists() )
852 : : {
853 : : // if file is using the /vsizip/ or /vsigzip/ mechanism, cleanup the name
854 : 64 : if ( myURI.endsWith( QLatin1String( ".gz" ), Qt::CaseInsensitive ) )
855 : 0 : myURI.chop( 3 );
856 : 64 : else if ( myURI.endsWith( QLatin1String( ".zip" ), Qt::CaseInsensitive ) )
857 : 0 : myURI.chop( 4 );
858 : 64 : else if ( myURI.endsWith( QLatin1String( ".tar" ), Qt::CaseInsensitive ) )
859 : 0 : myURI.chop( 4 );
860 : 64 : else if ( myURI.endsWith( QLatin1String( ".tar.gz" ), Qt::CaseInsensitive ) )
861 : 0 : myURI.chop( 7 );
862 : 64 : else if ( myURI.endsWith( QLatin1String( ".tgz" ), Qt::CaseInsensitive ) )
863 : 0 : myURI.chop( 4 );
864 : 64 : myFileInfo.setFile( myURI );
865 : : // get the file name for our .qml style file
866 : 64 : key = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + QgsMapLayer::extensionPropertyType( type );
867 : 64 : }
868 : : else
869 : : {
870 : 14 : key = publicSource();
871 : : }
872 : :
873 : 78 : return key;
874 : 78 : }
875 : :
876 : 0 : QString QgsMapLayer::metadataUri() const
877 : : {
878 : 0 : return baseURI( PropertyType::Metadata );
879 : : }
880 : :
881 : 0 : QString QgsMapLayer::saveDefaultMetadata( bool &resultFlag )
882 : : {
883 : 0 : return saveNamedMetadata( metadataUri(), resultFlag );
884 : 0 : }
885 : :
886 : 0 : QString QgsMapLayer::loadDefaultMetadata( bool &resultFlag )
887 : : {
888 : 0 : return loadNamedMetadata( metadataUri(), resultFlag );
889 : 0 : }
890 : :
891 : 78 : QString QgsMapLayer::styleURI() const
892 : : {
893 : 78 : return baseURI( PropertyType::Style );
894 : : }
895 : :
896 : 78 : QString QgsMapLayer::loadDefaultStyle( bool &resultFlag )
897 : : {
898 : 78 : return loadNamedStyle( styleURI(), resultFlag );
899 : 0 : }
900 : :
901 : 0 : bool QgsMapLayer::loadNamedMetadataFromDatabase( const QString &db, const QString &uri, QString &qmd )
902 : : {
903 : 0 : return loadNamedPropertyFromDatabase( db, uri, qmd, PropertyType::Metadata );
904 : : }
905 : :
906 : 156 : bool QgsMapLayer::loadNamedStyleFromDatabase( const QString &db, const QString &uri, QString &qml )
907 : : {
908 : 156 : return loadNamedPropertyFromDatabase( db, uri, qml, PropertyType::Style );
909 : : }
910 : :
911 : 156 : bool QgsMapLayer::loadNamedPropertyFromDatabase( const QString &db, const QString &uri, QString &xml, QgsMapLayer::PropertyType type )
912 : : {
913 : 156 : QgsDebugMsgLevel( QStringLiteral( "db = %1 uri = %2" ).arg( db, uri ), 4 );
914 : :
915 : 156 : bool resultFlag = false;
916 : :
917 : : // read from database
918 : 156 : sqlite3_database_unique_ptr database;
919 : 156 : sqlite3_statement_unique_ptr statement;
920 : :
921 : : int myResult;
922 : :
923 : 156 : QgsDebugMsgLevel( QStringLiteral( "Trying to load style or metadata for \"%1\" from \"%2\"" ).arg( uri, db ), 4 );
924 : :
925 : 156 : if ( db.isEmpty() || !QFile( db ).exists() )
926 : 156 : return false;
927 : :
928 : 0 : myResult = database.open_v2( db, SQLITE_OPEN_READONLY, nullptr );
929 : 0 : if ( myResult != SQLITE_OK )
930 : : {
931 : 0 : return false;
932 : : }
933 : :
934 : 0 : QString mySql;
935 : 0 : switch ( type )
936 : : {
937 : : case Metadata:
938 : 0 : mySql = QStringLiteral( "select qmd from tbl_metadata where metadata=?" );
939 : 0 : break;
940 : :
941 : : case Style:
942 : 0 : mySql = QStringLiteral( "select qml from tbl_styles where style=?" );
943 : 0 : break;
944 : : }
945 : :
946 : 0 : statement = database.prepare( mySql, myResult );
947 : 0 : if ( myResult == SQLITE_OK )
948 : : {
949 : 0 : QByteArray param = uri.toUtf8();
950 : :
951 : 0 : if ( sqlite3_bind_text( statement.get(), 1, param.data(), param.length(), SQLITE_STATIC ) == SQLITE_OK &&
952 : 0 : sqlite3_step( statement.get() ) == SQLITE_ROW )
953 : : {
954 : 0 : xml = QString::fromUtf8( reinterpret_cast< const char * >( sqlite3_column_text( statement.get(), 0 ) ) );
955 : 0 : resultFlag = true;
956 : 0 : }
957 : 0 : }
958 : 0 : return resultFlag;
959 : 156 : }
960 : :
961 : :
962 : 78 : QString QgsMapLayer::loadNamedStyle( const QString &uri, bool &resultFlag, QgsMapLayer::StyleCategories categories )
963 : : {
964 : 78 : return loadNamedProperty( uri, PropertyType::Style, resultFlag, categories );
965 : : }
966 : :
967 : 78 : QString QgsMapLayer::loadNamedProperty( const QString &uri, QgsMapLayer::PropertyType type, bool &resultFlag, StyleCategories categories )
968 : : {
969 : 78 : QgsDebugMsgLevel( QStringLiteral( "uri = %1 myURI = %2" ).arg( uri, publicSource() ), 4 );
970 : :
971 : 78 : resultFlag = false;
972 : :
973 : 156 : QDomDocument myDocument( QStringLiteral( "qgis" ) );
974 : :
975 : : // location of problem associated with errorMsg
976 : : int line, column;
977 : 78 : QString myErrorMessage;
978 : :
979 : 78 : QFile myFile( uri );
980 : 78 : if ( myFile.open( QFile::ReadOnly ) )
981 : : {
982 : 0 : QgsDebugMsgLevel( QStringLiteral( "file found %1" ).arg( uri ), 2 );
983 : : // read file
984 : 0 : resultFlag = myDocument.setContent( &myFile, &myErrorMessage, &line, &column );
985 : 0 : if ( !resultFlag )
986 : 0 : myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
987 : 0 : myFile.close();
988 : 0 : }
989 : : else
990 : : {
991 : 78 : QFileInfo project( QgsProject::instance()->fileName() );
992 : 78 : QgsDebugMsgLevel( QStringLiteral( "project fileName: %1" ).arg( project.absoluteFilePath() ), 4 );
993 : :
994 : 78 : QString xml;
995 : 78 : switch ( type )
996 : : {
997 : : case QgsMapLayer::Style:
998 : : {
999 : 234 : if ( loadNamedStyleFromDatabase( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( QStringLiteral( "qgis.qmldb" ) ), uri, xml ) ||
1000 : 156 : ( project.exists() && loadNamedStyleFromDatabase( project.absoluteDir().absoluteFilePath( project.baseName() + ".qmldb" ), uri, xml ) ) ||
1001 : 156 : loadNamedStyleFromDatabase( QDir( QgsApplication::pkgDataPath() ).absoluteFilePath( QStringLiteral( "resources/qgis.qmldb" ) ), uri, xml ) )
1002 : : {
1003 : 0 : resultFlag = myDocument.setContent( xml, &myErrorMessage, &line, &column );
1004 : 0 : if ( !resultFlag )
1005 : : {
1006 : 0 : myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1007 : 0 : }
1008 : 0 : }
1009 : : else
1010 : : {
1011 : 78 : myErrorMessage = tr( "Style not found in database" );
1012 : 78 : resultFlag = false;
1013 : : }
1014 : 78 : break;
1015 : : }
1016 : : case QgsMapLayer::Metadata:
1017 : : {
1018 : 0 : if ( loadNamedMetadataFromDatabase( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( QStringLiteral( "qgis.qmldb" ) ), uri, xml ) ||
1019 : 0 : ( project.exists() && loadNamedMetadataFromDatabase( project.absoluteDir().absoluteFilePath( project.baseName() + ".qmldb" ), uri, xml ) ) ||
1020 : 0 : loadNamedMetadataFromDatabase( QDir( QgsApplication::pkgDataPath() ).absoluteFilePath( QStringLiteral( "resources/qgis.qmldb" ) ), uri, xml ) )
1021 : : {
1022 : 0 : resultFlag = myDocument.setContent( xml, &myErrorMessage, &line, &column );
1023 : 0 : if ( !resultFlag )
1024 : : {
1025 : 0 : myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1026 : 0 : }
1027 : 0 : }
1028 : : else
1029 : : {
1030 : 0 : myErrorMessage = tr( "Metadata not found in database" );
1031 : 0 : resultFlag = false;
1032 : : }
1033 : 0 : break;
1034 : : }
1035 : : }
1036 : 78 : }
1037 : :
1038 : 78 : if ( !resultFlag )
1039 : : {
1040 : 78 : return myErrorMessage;
1041 : : }
1042 : :
1043 : 0 : switch ( type )
1044 : : {
1045 : : case QgsMapLayer::Style:
1046 : 0 : resultFlag = importNamedStyle( myDocument, myErrorMessage, categories );
1047 : 0 : if ( !resultFlag )
1048 : 0 : myErrorMessage = tr( "Loading style file %1 failed because:\n%2" ).arg( uri, myErrorMessage );
1049 : 0 : break;
1050 : : case QgsMapLayer::Metadata:
1051 : 0 : resultFlag = importNamedMetadata( myDocument, myErrorMessage );
1052 : 0 : if ( !resultFlag )
1053 : 0 : myErrorMessage = tr( "Loading metadata file %1 failed because:\n%2" ).arg( uri, myErrorMessage );
1054 : 0 : break;
1055 : : }
1056 : 0 : return myErrorMessage;
1057 : 78 : }
1058 : :
1059 : 0 : bool QgsMapLayer::importNamedMetadata( QDomDocument &document, QString &errorMessage )
1060 : : {
1061 : 0 : QDomElement myRoot = document.firstChildElement( QStringLiteral( "qgis" ) );
1062 : 0 : if ( myRoot.isNull() )
1063 : : {
1064 : 0 : errorMessage = tr( "Root <qgis> element could not be found" );
1065 : 0 : return false;
1066 : : }
1067 : :
1068 : 0 : return mMetadata.readMetadataXml( myRoot );
1069 : 0 : }
1070 : :
1071 : 0 : bool QgsMapLayer::importNamedStyle( QDomDocument &myDocument, QString &myErrorMessage, QgsMapLayer::StyleCategories categories )
1072 : : {
1073 : 0 : QDomElement myRoot = myDocument.firstChildElement( QStringLiteral( "qgis" ) );
1074 : 0 : if ( myRoot.isNull() )
1075 : : {
1076 : 0 : myErrorMessage = tr( "Root <qgis> element could not be found" );
1077 : 0 : return false;
1078 : : }
1079 : :
1080 : : // get style file version string, if any
1081 : 0 : QgsProjectVersion fileVersion( myRoot.attribute( QStringLiteral( "version" ) ) );
1082 : 0 : QgsProjectVersion thisVersion( Qgis::version() );
1083 : :
1084 : 0 : if ( thisVersion > fileVersion )
1085 : : {
1086 : 0 : QgsProjectFileTransform styleFile( myDocument, fileVersion );
1087 : 0 : styleFile.updateRevision( thisVersion );
1088 : 0 : }
1089 : :
1090 : : // Get source categories
1091 : 0 : QgsMapLayer::StyleCategories sourceCategories = QgsXmlUtils::readFlagAttribute( myRoot, QStringLiteral( "styleCategories" ), QgsMapLayer::AllStyleCategories );
1092 : :
1093 : : //Test for matching geometry type on vector layers when applying, if geometry type is given in the style
1094 : 0 : if ( ( sourceCategories.testFlag( QgsMapLayer::Symbology ) || sourceCategories.testFlag( QgsMapLayer::Symbology3D ) ) &&
1095 : 0 : ( categories.testFlag( QgsMapLayer::Symbology ) || categories.testFlag( QgsMapLayer::Symbology3D ) ) )
1096 : : {
1097 : 0 : if ( type() == QgsMapLayerType::VectorLayer && !myRoot.firstChildElement( QStringLiteral( "layerGeometryType" ) ).isNull() )
1098 : : {
1099 : 0 : QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( this );
1100 : 0 : QgsWkbTypes::GeometryType importLayerGeometryType = static_cast<QgsWkbTypes::GeometryType>( myRoot.firstChildElement( QStringLiteral( "layerGeometryType" ) ).text().toInt() );
1101 : 0 : if ( importLayerGeometryType != QgsWkbTypes::GeometryType::UnknownGeometry && vl->geometryType() != importLayerGeometryType )
1102 : : {
1103 : 0 : myErrorMessage = tr( "Cannot apply style with symbology to layer with a different geometry type" );
1104 : 0 : return false;
1105 : : }
1106 : 0 : }
1107 : 0 : }
1108 : :
1109 : 0 : QgsReadWriteContext context = QgsReadWriteContext();
1110 : 0 : return readSymbology( myRoot, myErrorMessage, context, categories ); // TODO: support relative paths in QML?
1111 : 0 : }
1112 : :
1113 : 0 : void QgsMapLayer::exportNamedMetadata( QDomDocument &doc, QString &errorMsg ) const
1114 : : {
1115 : 0 : QDomImplementation DomImplementation;
1116 : 0 : QDomDocumentType documentType = DomImplementation.createDocumentType( QStringLiteral( "qgis" ), QStringLiteral( "http://mrcc.com/qgis.dtd" ), QStringLiteral( "SYSTEM" ) );
1117 : 0 : QDomDocument myDocument( documentType );
1118 : :
1119 : 0 : QDomElement myRootNode = myDocument.createElement( QStringLiteral( "qgis" ) );
1120 : 0 : myRootNode.setAttribute( QStringLiteral( "version" ), Qgis::version() );
1121 : 0 : myDocument.appendChild( myRootNode );
1122 : :
1123 : 0 : if ( !mMetadata.writeMetadataXml( myRootNode, myDocument ) )
1124 : : {
1125 : 0 : errorMsg = QObject::tr( "Could not save metadata" );
1126 : 0 : return;
1127 : : }
1128 : :
1129 : 0 : doc = myDocument;
1130 : 0 : }
1131 : :
1132 : 0 : void QgsMapLayer::exportNamedStyle( QDomDocument &doc, QString &errorMsg, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
1133 : : {
1134 : 0 : QDomImplementation DomImplementation;
1135 : 0 : QDomDocumentType documentType = DomImplementation.createDocumentType( QStringLiteral( "qgis" ), QStringLiteral( "http://mrcc.com/qgis.dtd" ), QStringLiteral( "SYSTEM" ) );
1136 : 0 : QDomDocument myDocument( documentType );
1137 : :
1138 : 0 : QDomElement myRootNode = myDocument.createElement( QStringLiteral( "qgis" ) );
1139 : 0 : myRootNode.setAttribute( QStringLiteral( "version" ), Qgis::version() );
1140 : 0 : myDocument.appendChild( myRootNode );
1141 : :
1142 : 0 : if ( !writeSymbology( myRootNode, myDocument, errorMsg, context, categories ) ) // TODO: support relative paths in QML?
1143 : : {
1144 : 0 : errorMsg = QObject::tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1145 : 0 : return;
1146 : : }
1147 : :
1148 : : /*
1149 : : * Check to see if the layer is vector - in which case we should also export its geometryType
1150 : : * to avoid eventually pasting to a layer with a different geometry
1151 : : */
1152 : 0 : if ( type() == QgsMapLayerType::VectorLayer )
1153 : : {
1154 : : //Getting the selectionLayer geometry
1155 : 0 : const QgsVectorLayer *vl = qobject_cast<const QgsVectorLayer *>( this );
1156 : 0 : QString geoType = QString::number( vl->geometryType() );
1157 : :
1158 : : //Adding geometryinformation
1159 : 0 : QDomElement layerGeometryType = myDocument.createElement( QStringLiteral( "layerGeometryType" ) );
1160 : 0 : QDomText type = myDocument.createTextNode( geoType );
1161 : :
1162 : 0 : layerGeometryType.appendChild( type );
1163 : 0 : myRootNode.appendChild( layerGeometryType );
1164 : 0 : }
1165 : :
1166 : 0 : doc = myDocument;
1167 : 0 : }
1168 : :
1169 : 0 : QString QgsMapLayer::saveDefaultStyle( bool &resultFlag )
1170 : : {
1171 : 0 : return saveNamedStyle( styleURI(), resultFlag );
1172 : 0 : }
1173 : :
1174 : 0 : QString QgsMapLayer::saveNamedMetadata( const QString &uri, bool &resultFlag )
1175 : : {
1176 : 0 : return saveNamedProperty( uri, QgsMapLayer::Metadata, resultFlag );
1177 : : }
1178 : :
1179 : 0 : QString QgsMapLayer::loadNamedMetadata( const QString &uri, bool &resultFlag )
1180 : : {
1181 : 0 : return loadNamedProperty( uri, QgsMapLayer::Metadata, resultFlag );
1182 : : }
1183 : :
1184 : 0 : QString QgsMapLayer::saveNamedProperty( const QString &uri, QgsMapLayer::PropertyType type, bool &resultFlag, StyleCategories categories )
1185 : : {
1186 : : // check if the uri is a file or ends with .qml/.qmd,
1187 : : // which indicates that it should become one
1188 : : // everything else goes to the database
1189 : 0 : QString filename;
1190 : :
1191 : 0 : QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( this );
1192 : 0 : if ( vlayer && vlayer->providerType() == QLatin1String( "ogr" ) )
1193 : : {
1194 : 0 : QStringList theURIParts = uri.split( '|' );
1195 : 0 : filename = theURIParts[0];
1196 : 0 : }
1197 : 0 : else if ( vlayer && vlayer->providerType() == QLatin1String( "gpx" ) )
1198 : : {
1199 : 0 : QStringList theURIParts = uri.split( '?' );
1200 : 0 : filename = theURIParts[0];
1201 : 0 : }
1202 : 0 : else if ( vlayer && vlayer->providerType() == QLatin1String( "delimitedtext" ) )
1203 : : {
1204 : 0 : filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1205 : : // toLocalFile() returns an empty string if theURI is a plain Windows-path, e.g. "C:/style.qml"
1206 : 0 : if ( filename.isEmpty() )
1207 : 0 : filename = uri;
1208 : 0 : }
1209 : : else
1210 : : {
1211 : 0 : filename = uri;
1212 : : }
1213 : :
1214 : 0 : QString myErrorMessage;
1215 : 0 : QDomDocument myDocument;
1216 : 0 : switch ( type )
1217 : : {
1218 : : case Metadata:
1219 : 0 : exportNamedMetadata( myDocument, myErrorMessage );
1220 : 0 : break;
1221 : :
1222 : : case Style:
1223 : 0 : QgsReadWriteContext context;
1224 : 0 : exportNamedStyle( myDocument, myErrorMessage, context, categories );
1225 : : break;
1226 : 0 : }
1227 : :
1228 : 0 : QFileInfo myFileInfo( filename );
1229 : 0 : if ( myFileInfo.exists() || filename.endsWith( QgsMapLayer::extensionPropertyType( type ), Qt::CaseInsensitive ) )
1230 : : {
1231 : 0 : QFileInfo myDirInfo( myFileInfo.path() ); //excludes file name
1232 : 0 : if ( !myDirInfo.isWritable() )
1233 : : {
1234 : 0 : return tr( "The directory containing your dataset needs to be writable!" );
1235 : : }
1236 : :
1237 : : // now construct the file name for our .qml or .qmd file
1238 : 0 : QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + QgsMapLayer::extensionPropertyType( type );
1239 : :
1240 : 0 : QFile myFile( myFileName );
1241 : 0 : if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1242 : : {
1243 : 0 : QTextStream myFileStream( &myFile );
1244 : : // save as utf-8 with 2 spaces for indents
1245 : 0 : myDocument.save( myFileStream, 2 );
1246 : 0 : myFile.close();
1247 : 0 : resultFlag = true;
1248 : 0 : switch ( type )
1249 : : {
1250 : : case Metadata:
1251 : 0 : return tr( "Created default metadata file as %1" ).arg( myFileName );
1252 : :
1253 : : case Style:
1254 : 0 : return tr( "Created default style file as %1" ).arg( myFileName );
1255 : : }
1256 : :
1257 : 0 : }
1258 : : else
1259 : : {
1260 : 0 : resultFlag = false;
1261 : 0 : switch ( type )
1262 : : {
1263 : : case Metadata:
1264 : 0 : return tr( "ERROR: Failed to created default metadata file as %1. Check file permissions and retry." ).arg( myFileName );
1265 : :
1266 : : case Style:
1267 : 0 : return tr( "ERROR: Failed to created default style file as %1. Check file permissions and retry." ).arg( myFileName );
1268 : : }
1269 : : }
1270 : 0 : }
1271 : : else
1272 : : {
1273 : 0 : QString qml = myDocument.toString();
1274 : :
1275 : : // read from database
1276 : 0 : sqlite3_database_unique_ptr database;
1277 : 0 : sqlite3_statement_unique_ptr statement;
1278 : :
1279 : 0 : int myResult = database.open( QDir( QgsApplication::qgisSettingsDirPath() ).absoluteFilePath( QStringLiteral( "qgis.qmldb" ) ) );
1280 : 0 : if ( myResult != SQLITE_OK )
1281 : : {
1282 : 0 : return tr( "User database could not be opened." );
1283 : : }
1284 : :
1285 : 0 : QByteArray param0 = uri.toUtf8();
1286 : 0 : QByteArray param1 = qml.toUtf8();
1287 : :
1288 : 0 : QString mySql;
1289 : 0 : switch ( type )
1290 : : {
1291 : : case Metadata:
1292 : 0 : mySql = QStringLiteral( "create table if not exists tbl_metadata(metadata varchar primary key,qmd varchar)" );
1293 : 0 : break;
1294 : :
1295 : : case Style:
1296 : 0 : mySql = QStringLiteral( "create table if not exists tbl_styles(style varchar primary key,qml varchar)" );
1297 : 0 : break;
1298 : : }
1299 : :
1300 : 0 : statement = database.prepare( mySql, myResult );
1301 : 0 : if ( myResult == SQLITE_OK )
1302 : : {
1303 : 0 : if ( sqlite3_step( statement.get() ) != SQLITE_DONE )
1304 : : {
1305 : 0 : resultFlag = false;
1306 : 0 : switch ( type )
1307 : : {
1308 : : case Metadata:
1309 : 0 : return tr( "The metadata table could not be created." );
1310 : :
1311 : : case Style:
1312 : 0 : return tr( "The style table could not be created." );
1313 : : }
1314 : 0 : }
1315 : 0 : }
1316 : :
1317 : 0 : switch ( type )
1318 : : {
1319 : : case Metadata:
1320 : 0 : mySql = QStringLiteral( "insert into tbl_metadata(metadata,qmd) values (?,?)" );
1321 : 0 : break;
1322 : :
1323 : : case Style:
1324 : 0 : mySql = QStringLiteral( "insert into tbl_styles(style,qml) values (?,?)" );
1325 : 0 : break;
1326 : : }
1327 : 0 : statement = database.prepare( mySql, myResult );
1328 : 0 : if ( myResult == SQLITE_OK )
1329 : : {
1330 : 0 : if ( sqlite3_bind_text( statement.get(), 1, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&
1331 : 0 : sqlite3_bind_text( statement.get(), 2, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&
1332 : 0 : sqlite3_step( statement.get() ) == SQLITE_DONE )
1333 : : {
1334 : 0 : resultFlag = true;
1335 : 0 : switch ( type )
1336 : : {
1337 : : case Metadata:
1338 : 0 : myErrorMessage = tr( "The metadata %1 was saved to database" ).arg( uri );
1339 : 0 : break;
1340 : :
1341 : : case Style:
1342 : 0 : myErrorMessage = tr( "The style %1 was saved to database" ).arg( uri );
1343 : 0 : break;
1344 : : }
1345 : 0 : }
1346 : 0 : }
1347 : :
1348 : 0 : if ( !resultFlag )
1349 : : {
1350 : 0 : QString mySql;
1351 : 0 : switch ( type )
1352 : : {
1353 : : case Metadata:
1354 : 0 : mySql = QStringLiteral( "update tbl_metadata set qmd=? where metadata=?" );
1355 : 0 : break;
1356 : :
1357 : : case Style:
1358 : 0 : mySql = QStringLiteral( "update tbl_styles set qml=? where style=?" );
1359 : 0 : break;
1360 : : }
1361 : 0 : statement = database.prepare( mySql, myResult );
1362 : 0 : if ( myResult == SQLITE_OK )
1363 : : {
1364 : 0 : if ( sqlite3_bind_text( statement.get(), 2, param0.data(), param0.length(), SQLITE_STATIC ) == SQLITE_OK &&
1365 : 0 : sqlite3_bind_text( statement.get(), 1, param1.data(), param1.length(), SQLITE_STATIC ) == SQLITE_OK &&
1366 : 0 : sqlite3_step( statement.get() ) == SQLITE_DONE )
1367 : : {
1368 : 0 : resultFlag = true;
1369 : 0 : switch ( type )
1370 : : {
1371 : : case Metadata:
1372 : 0 : myErrorMessage = tr( "The metadata %1 was updated in the database." ).arg( uri );
1373 : 0 : break;
1374 : :
1375 : : case Style:
1376 : 0 : myErrorMessage = tr( "The style %1 was updated in the database." ).arg( uri );
1377 : 0 : break;
1378 : : }
1379 : 0 : }
1380 : : else
1381 : : {
1382 : 0 : resultFlag = false;
1383 : 0 : switch ( type )
1384 : : {
1385 : : case Metadata:
1386 : 0 : myErrorMessage = tr( "The metadata %1 could not be updated in the database." ).arg( uri );
1387 : 0 : break;
1388 : :
1389 : : case Style:
1390 : 0 : myErrorMessage = tr( "The style %1 could not be updated in the database." ).arg( uri );
1391 : 0 : break;
1392 : : }
1393 : : }
1394 : 0 : }
1395 : : else
1396 : : {
1397 : 0 : resultFlag = false;
1398 : 0 : switch ( type )
1399 : : {
1400 : : case Metadata:
1401 : 0 : myErrorMessage = tr( "The metadata %1 could not be inserted into database." ).arg( uri );
1402 : 0 : break;
1403 : :
1404 : : case Style:
1405 : 0 : myErrorMessage = tr( "The style %1 could not be inserted into database." ).arg( uri );
1406 : 0 : break;
1407 : : }
1408 : : }
1409 : 0 : }
1410 : 0 : }
1411 : :
1412 : 0 : return myErrorMessage;
1413 : 0 : }
1414 : :
1415 : 0 : QString QgsMapLayer::saveNamedStyle( const QString &uri, bool &resultFlag, StyleCategories categories )
1416 : : {
1417 : 0 : return saveNamedProperty( uri, QgsMapLayer::Style, resultFlag, categories );
1418 : : }
1419 : :
1420 : 0 : void QgsMapLayer::exportSldStyle( QDomDocument &doc, QString &errorMsg ) const
1421 : : {
1422 : 0 : QDomDocument myDocument = QDomDocument();
1423 : :
1424 : 0 : QDomNode header = myDocument.createProcessingInstruction( QStringLiteral( "xml" ), QStringLiteral( "version=\"1.0\" encoding=\"UTF-8\"" ) );
1425 : 0 : myDocument.appendChild( header );
1426 : :
1427 : 0 : const QgsVectorLayer *vlayer = qobject_cast<const QgsVectorLayer *>( this );
1428 : 0 : const QgsRasterLayer *rlayer = qobject_cast<const QgsRasterLayer *>( this );
1429 : 0 : if ( !vlayer && !rlayer )
1430 : : {
1431 : 0 : errorMsg = tr( "Could not save symbology because:\n%1" )
1432 : 0 : .arg( tr( "Only vector and raster layers are supported" ) );
1433 : 0 : return;
1434 : : }
1435 : :
1436 : : // Create the root element
1437 : 0 : QDomElement root = myDocument.createElementNS( QStringLiteral( "http://www.opengis.net/sld" ), QStringLiteral( "StyledLayerDescriptor" ) );
1438 : 0 : QDomElement layerNode;
1439 : 0 : if ( vlayer )
1440 : : {
1441 : 0 : root.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.1.0" ) );
1442 : 0 : root.setAttribute( QStringLiteral( "xsi:schemaLocation" ), QStringLiteral( "http://www.opengis.net/sld http://schemas.opengis.net/sld/1.1.0/StyledLayerDescriptor.xsd" ) );
1443 : 0 : root.setAttribute( QStringLiteral( "xmlns:ogc" ), QStringLiteral( "http://www.opengis.net/ogc" ) );
1444 : 0 : root.setAttribute( QStringLiteral( "xmlns:se" ), QStringLiteral( "http://www.opengis.net/se" ) );
1445 : 0 : root.setAttribute( QStringLiteral( "xmlns:xlink" ), QStringLiteral( "http://www.w3.org/1999/xlink" ) );
1446 : 0 : root.setAttribute( QStringLiteral( "xmlns:xsi" ), QStringLiteral( "http://www.w3.org/2001/XMLSchema-instance" ) );
1447 : 0 : myDocument.appendChild( root );
1448 : :
1449 : : // Create the NamedLayer element
1450 : 0 : layerNode = myDocument.createElement( QStringLiteral( "NamedLayer" ) );
1451 : 0 : root.appendChild( layerNode );
1452 : 0 : }
1453 : :
1454 : : // note: Only SLD 1.0 version is generated because seems none is using SE1.1.0 at least for rasters
1455 : 0 : if ( rlayer )
1456 : : {
1457 : : // Create the root element
1458 : 0 : root.setAttribute( QStringLiteral( "version" ), QStringLiteral( "1.0.0" ) );
1459 : 0 : root.setAttribute( QStringLiteral( "xmlns:gml" ), QStringLiteral( "http://www.opengis.net/gml" ) );
1460 : 0 : root.setAttribute( QStringLiteral( "xmlns:ogc" ), QStringLiteral( "http://www.opengis.net/ogc" ) );
1461 : 0 : root.setAttribute( QStringLiteral( "xmlns:sld" ), QStringLiteral( "http://www.opengis.net/sld" ) );
1462 : 0 : myDocument.appendChild( root );
1463 : :
1464 : : // Create the NamedLayer element
1465 : 0 : layerNode = myDocument.createElement( QStringLiteral( "UserLayer" ) );
1466 : 0 : root.appendChild( layerNode );
1467 : 0 : }
1468 : :
1469 : 0 : QVariantMap props;
1470 : 0 : if ( hasScaleBasedVisibility() )
1471 : : {
1472 : 0 : props[ QStringLiteral( "scaleMinDenom" ) ] = QString::number( mMinScale );
1473 : 0 : props[ QStringLiteral( "scaleMaxDenom" ) ] = QString::number( mMaxScale );
1474 : 0 : }
1475 : :
1476 : 0 : if ( vlayer )
1477 : : {
1478 : 0 : if ( !vlayer->writeSld( layerNode, myDocument, errorMsg, props ) )
1479 : : {
1480 : 0 : errorMsg = tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1481 : 0 : return;
1482 : : }
1483 : 0 : }
1484 : :
1485 : 0 : if ( rlayer )
1486 : : {
1487 : 0 : if ( !rlayer->writeSld( layerNode, myDocument, errorMsg, props ) )
1488 : : {
1489 : 0 : errorMsg = tr( "Could not save symbology because:\n%1" ).arg( errorMsg );
1490 : 0 : return;
1491 : : }
1492 : 0 : }
1493 : :
1494 : 0 : doc = myDocument;
1495 : 0 : }
1496 : :
1497 : 0 : QString QgsMapLayer::saveSldStyle( const QString &uri, bool &resultFlag ) const
1498 : : {
1499 : 0 : const QgsMapLayer *mlayer = qobject_cast<const QgsMapLayer *>( this );
1500 : :
1501 : 0 : QString errorMsg;
1502 : 0 : QDomDocument myDocument;
1503 : 0 : mlayer->exportSldStyle( myDocument, errorMsg );
1504 : 0 : if ( !errorMsg.isNull() )
1505 : : {
1506 : 0 : resultFlag = false;
1507 : 0 : return errorMsg;
1508 : : }
1509 : : // check if the uri is a file or ends with .sld,
1510 : : // which indicates that it should become one
1511 : 0 : QString filename;
1512 : 0 : if ( mlayer->providerType() == QLatin1String( "ogr" ) )
1513 : : {
1514 : 0 : QStringList theURIParts = uri.split( '|' );
1515 : 0 : filename = theURIParts[0];
1516 : 0 : }
1517 : 0 : else if ( mlayer->providerType() == QLatin1String( "gpx" ) )
1518 : : {
1519 : 0 : QStringList theURIParts = uri.split( '?' );
1520 : 0 : filename = theURIParts[0];
1521 : 0 : }
1522 : 0 : else if ( mlayer->providerType() == QLatin1String( "delimitedtext" ) )
1523 : : {
1524 : 0 : filename = QUrl::fromEncoded( uri.toLatin1() ).toLocalFile();
1525 : : // toLocalFile() returns an empty string if theURI is a plain Windows-path, e.g. "C:/style.qml"
1526 : 0 : if ( filename.isEmpty() )
1527 : 0 : filename = uri;
1528 : 0 : }
1529 : : else
1530 : : {
1531 : 0 : filename = uri;
1532 : : }
1533 : :
1534 : 0 : QFileInfo myFileInfo( filename );
1535 : 0 : if ( myFileInfo.exists() || filename.endsWith( QLatin1String( ".sld" ), Qt::CaseInsensitive ) )
1536 : : {
1537 : 0 : QFileInfo myDirInfo( myFileInfo.path() ); //excludes file name
1538 : 0 : if ( !myDirInfo.isWritable() )
1539 : : {
1540 : 0 : return tr( "The directory containing your dataset needs to be writable!" );
1541 : : }
1542 : :
1543 : : // now construct the file name for our .sld style file
1544 : 0 : QString myFileName = myFileInfo.path() + QDir::separator() + myFileInfo.completeBaseName() + ".sld";
1545 : :
1546 : 0 : QFile myFile( myFileName );
1547 : 0 : if ( myFile.open( QFile::WriteOnly | QFile::Truncate ) )
1548 : : {
1549 : 0 : QTextStream myFileStream( &myFile );
1550 : : // save as utf-8 with 2 spaces for indents
1551 : 0 : myDocument.save( myFileStream, 2 );
1552 : 0 : myFile.close();
1553 : 0 : resultFlag = true;
1554 : 0 : return tr( "Created default style file as %1" ).arg( myFileName );
1555 : 0 : }
1556 : 0 : }
1557 : :
1558 : 0 : resultFlag = false;
1559 : 0 : return tr( "ERROR: Failed to created SLD style file as %1. Check file permissions and retry." ).arg( filename );
1560 : 0 : }
1561 : :
1562 : 0 : QString QgsMapLayer::loadSldStyle( const QString &uri, bool &resultFlag )
1563 : : {
1564 : 0 : resultFlag = false;
1565 : :
1566 : 0 : QDomDocument myDocument;
1567 : :
1568 : : // location of problem associated with errorMsg
1569 : : int line, column;
1570 : 0 : QString myErrorMessage;
1571 : :
1572 : 0 : QFile myFile( uri );
1573 : 0 : if ( myFile.open( QFile::ReadOnly ) )
1574 : : {
1575 : : // read file
1576 : 0 : resultFlag = myDocument.setContent( &myFile, true, &myErrorMessage, &line, &column );
1577 : 0 : if ( !resultFlag )
1578 : 0 : myErrorMessage = tr( "%1 at line %2 column %3" ).arg( myErrorMessage ).arg( line ).arg( column );
1579 : 0 : myFile.close();
1580 : 0 : }
1581 : : else
1582 : : {
1583 : 0 : myErrorMessage = tr( "Unable to open file %1" ).arg( uri );
1584 : : }
1585 : :
1586 : 0 : if ( !resultFlag )
1587 : : {
1588 : 0 : return myErrorMessage;
1589 : : }
1590 : :
1591 : : // check for root SLD element
1592 : 0 : QDomElement myRoot = myDocument.firstChildElement( QStringLiteral( "StyledLayerDescriptor" ) );
1593 : 0 : if ( myRoot.isNull() )
1594 : : {
1595 : 0 : myErrorMessage = QStringLiteral( "Error: StyledLayerDescriptor element not found in %1" ).arg( uri );
1596 : 0 : resultFlag = false;
1597 : 0 : return myErrorMessage;
1598 : : }
1599 : :
1600 : : // now get the style node out and pass it over to the layer
1601 : : // to deserialise...
1602 : 0 : QDomElement namedLayerElem = myRoot.firstChildElement( QStringLiteral( "NamedLayer" ) );
1603 : 0 : if ( namedLayerElem.isNull() )
1604 : : {
1605 : 0 : myErrorMessage = QStringLiteral( "Info: NamedLayer element not found." );
1606 : 0 : resultFlag = false;
1607 : 0 : return myErrorMessage;
1608 : : }
1609 : :
1610 : 0 : QString errorMsg;
1611 : 0 : resultFlag = readSld( namedLayerElem, errorMsg );
1612 : 0 : if ( !resultFlag )
1613 : : {
1614 : 0 : myErrorMessage = tr( "Loading style file %1 failed because:\n%2" ).arg( uri, errorMsg );
1615 : 0 : return myErrorMessage;
1616 : : }
1617 : :
1618 : 0 : return QString();
1619 : 0 : }
1620 : :
1621 : 0 : bool QgsMapLayer::readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
1622 : : {
1623 : 0 : Q_UNUSED( node )
1624 : 83 : Q_UNUSED( errorMessage )
1625 : 0 : Q_UNUSED( context )
1626 : : Q_UNUSED( categories )
1627 : 0 : return false;
1628 : : }
1629 : :
1630 : 0 : bool QgsMapLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage,
1631 : : const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
1632 : : {
1633 : 0 : Q_UNUSED( node )
1634 : 0 : Q_UNUSED( doc )
1635 : 0 : Q_UNUSED( errorMessage )
1636 : 0 : Q_UNUSED( context )
1637 : : Q_UNUSED( categories )
1638 : 0 : return false;
1639 : : }
1640 : :
1641 : 0 : void QgsMapLayer::setDataSource( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, bool loadDefaultStyleFlag )
1642 : : {
1643 : 0 : Q_UNUSED( dataSource )
1644 : 0 : Q_UNUSED( baseName )
1645 : 0 : Q_UNUSED( provider )
1646 : 0 : Q_UNUSED( options )
1647 : : Q_UNUSED( loadDefaultStyleFlag )
1648 : 0 : }
1649 : :
1650 : :
1651 : 170 : QString QgsMapLayer::providerType() const
1652 : : {
1653 : 170 : return mProviderKey;
1654 : : }
1655 : :
1656 : 0 : void QgsMapLayer::readCommonStyle( const QDomElement &layerElement, const QgsReadWriteContext &context,
1657 : : QgsMapLayer::StyleCategories categories )
1658 : : {
1659 : 0 : if ( categories.testFlag( Symbology3D ) )
1660 : : {
1661 : 0 : QgsAbstract3DRenderer *r3D = nullptr;
1662 : 0 : QDomElement renderer3DElem = layerElement.firstChildElement( QStringLiteral( "renderer-3d" ) );
1663 : 0 : if ( !renderer3DElem.isNull() )
1664 : : {
1665 : 0 : QString type3D = renderer3DElem.attribute( QStringLiteral( "type" ) );
1666 : 0 : Qgs3DRendererAbstractMetadata *meta3D = QgsApplication::renderer3DRegistry()->rendererMetadata( type3D );
1667 : 0 : if ( meta3D )
1668 : : {
1669 : 83 : r3D = meta3D->createRenderer( renderer3DElem, context );
1670 : 0 : }
1671 : 0 : }
1672 : 0 : setRenderer3D( r3D );
1673 : 0 : }
1674 : :
1675 : 0 : if ( categories.testFlag( CustomProperties ) )
1676 : : {
1677 : : // read custom properties before passing reading further to a subclass, so that
1678 : 83 : // the subclass can also read custom properties
1679 : 0 : readCustomProperties( layerElement );
1680 : 0 : }
1681 : :
1682 : : // use scale dependent visibility flag
1683 : 0 : if ( categories.testFlag( Rendering ) )
1684 : : {
1685 : 83 : setScaleBasedVisibility( layerElement.attribute( QStringLiteral( "hasScaleBasedVisibilityFlag" ) ).toInt() == 1 );
1686 : 0 : if ( layerElement.hasAttribute( QStringLiteral( "minimumScale" ) ) )
1687 : : {
1688 : : // older element, when scales were reversed
1689 : 0 : setMaximumScale( layerElement.attribute( QStringLiteral( "minimumScale" ) ).toDouble() );
1690 : 0 : setMinimumScale( layerElement.attribute( QStringLiteral( "maximumScale" ) ).toDouble() );
1691 : 0 : }
1692 : 83 : else
1693 : : {
1694 : 0 : setMaximumScale( layerElement.attribute( QStringLiteral( "maxScale" ) ).toDouble() );
1695 : 0 : setMinimumScale( layerElement.attribute( QStringLiteral( "minScale" ) ).toDouble() );
1696 : : }
1697 : 0 : }
1698 : :
1699 : 0 : if ( categories.testFlag( LayerConfiguration ) )
1700 : : {
1701 : : // flags
1702 : 0 : QDomElement flagsElem = layerElement.firstChildElement( QStringLiteral( "flags" ) );
1703 : 0 : LayerFlags flags = mFlags;
1704 : 0 : auto enumMap = qgsEnumMap<QgsMapLayer::LayerFlag>();
1705 : 0 : for ( auto it = enumMap.constBegin(); it != enumMap.constEnd(); ++it )
1706 : : {
1707 : 0 : QDomNode flagNode = flagsElem.namedItem( it.value() );
1708 : 0 : if ( flagNode.isNull() )
1709 : 0 : continue;
1710 : 0 : bool flagValue = flagNode.toElement().text() == "1" ? true : false;
1711 : 0 : if ( flags.testFlag( it.key() ) && !flagValue )
1712 : 0 : flags &= ~it.key();
1713 : 0 : else if ( !flags.testFlag( it.key() ) && flagValue )
1714 : 0 : flags |= it.key();
1715 : 0 : }
1716 : 0 : setFlags( flags );
1717 : 0 : }
1718 : :
1719 : 0 : if ( categories.testFlag( Temporal ) )
1720 : : {
1721 : 0 : if ( QgsMapLayerTemporalProperties *properties = temporalProperties() )
1722 : 0 : properties->readXml( layerElement.toElement(), context );
1723 : 0 : }
1724 : 83 :
1725 : 0 : if ( categories.testFlag( Elevation ) )
1726 : : {
1727 : 83 : if ( QgsMapLayerElevationProperties *properties = elevationProperties() )
1728 : 0 : properties->readXml( layerElement.toElement(), context );
1729 : 0 : }
1730 : 0 : }
1731 : :
1732 : 3 : QUndoStack *QgsMapLayer::undoStack()
1733 : : {
1734 : 3 : return mUndoStack;
1735 : 83 : }
1736 : :
1737 : 83 : QUndoStack *QgsMapLayer::undoStackStyles()
1738 : : {
1739 : 83 : return mUndoStackStyles;
1740 : : }
1741 : :
1742 : 0 : QStringList QgsMapLayer::customPropertyKeys() const
1743 : : {
1744 : 0 : return mCustomProperties.keys();
1745 : : }
1746 : :
1747 : 0 : void QgsMapLayer::setCustomProperty( const QString &key, const QVariant &value )
1748 : : {
1749 : 0 : if ( !mCustomProperties.contains( key ) || mCustomProperties.value( key ) != value )
1750 : 83 : {
1751 : 0 : mCustomProperties.setValue( key, value );
1752 : 0 : emit customPropertyChanged( key );
1753 : 0 : }
1754 : 0 : }
1755 : :
1756 : 0 : void QgsMapLayer::setCustomProperties( const QgsObjectCustomProperties &properties )
1757 : : {
1758 : 0 : mCustomProperties = properties;
1759 : 0 : }
1760 : :
1761 : 83 : const QgsObjectCustomProperties &QgsMapLayer::customProperties() const
1762 : : {
1763 : 0 : return mCustomProperties;
1764 : : }
1765 : :
1766 : 400 : QVariant QgsMapLayer::customProperty( const QString &value, const QVariant &defaultValue ) const
1767 : : {
1768 : 400 : return mCustomProperties.value( value, defaultValue );
1769 : : }
1770 : :
1771 : 0 : void QgsMapLayer::removeCustomProperty( const QString &key )
1772 : : {
1773 : :
1774 : 0 : if ( mCustomProperties.contains( key ) )
1775 : : {
1776 : 0 : mCustomProperties.remove( key );
1777 : 83 : emit customPropertyChanged( key );
1778 : 0 : }
1779 : 0 : }
1780 : :
1781 : 0 : QgsError QgsMapLayer::error() const
1782 : : {
1783 : 0 : return mError;
1784 : : }
1785 : :
1786 : :
1787 : :
1788 : 0 : bool QgsMapLayer::isEditable() const
1789 : : {
1790 : 0 : return false;
1791 : : }
1792 : :
1793 : 0 : bool QgsMapLayer::isSpatial() const
1794 : : {
1795 : 0 : return true;
1796 : : }
1797 : :
1798 : 0 : bool QgsMapLayer::isTemporary() const
1799 : : {
1800 : : // invalid layers are temporary? -- who knows?!
1801 : 0 : if ( !isValid() )
1802 : 0 : return false;
1803 : :
1804 : 0 : if ( mProviderKey == QLatin1String( "memory" ) )
1805 : 0 : return true;
1806 : :
1807 : 0 : const QVariantMap sourceParts = QgsProviderRegistry::instance()->decodeUri( mProviderKey, mDataSource );
1808 : 0 : const QString path = sourceParts.value( QStringLiteral( "path" ) ).toString();
1809 : 0 : if ( path.isEmpty() )
1810 : 0 : return false;
1811 : :
1812 : : // check if layer path is inside one of the standard temporary file locations for this platform
1813 : 0 : const QStringList tempPaths = QStandardPaths::standardLocations( QStandardPaths::TempLocation );
1814 : 0 : for ( const QString &tempPath : tempPaths )
1815 : : {
1816 : 0 : if ( path.startsWith( tempPath ) )
1817 : 0 : return true;
1818 : : }
1819 : :
1820 : 0 : return false;
1821 : 0 : }
1822 : :
1823 : 140 : void QgsMapLayer::setValid( bool valid )
1824 : : {
1825 : 140 : if ( mValid == valid )
1826 : 0 : return;
1827 : :
1828 : 140 : mValid = valid;
1829 : 140 : emit isValidChanged();
1830 : 140 : }
1831 : :
1832 : 78 : void QgsMapLayer::setLegend( QgsMapLayerLegend *legend )
1833 : : {
1834 : 78 : if ( legend == mLegend )
1835 : 0 : return;
1836 : :
1837 : 78 : delete mLegend;
1838 : 78 : mLegend = legend;
1839 : :
1840 : 78 : if ( mLegend )
1841 : : {
1842 : 78 : mLegend->setParent( this );
1843 : 78 : connect( mLegend, &QgsMapLayerLegend::itemsChanged, this, &QgsMapLayer::legendChanged );
1844 : 78 : }
1845 : :
1846 : 78 : emit legendChanged();
1847 : 78 : }
1848 : :
1849 : 0 : QgsMapLayerLegend *QgsMapLayer::legend() const
1850 : : {
1851 : 0 : return mLegend;
1852 : : }
1853 : :
1854 : 0 : QgsMapLayerStyleManager *QgsMapLayer::styleManager() const
1855 : : {
1856 : 0 : return mStyleManager;
1857 : : }
1858 : :
1859 : 0 : void QgsMapLayer::setRenderer3D( QgsAbstract3DRenderer *renderer )
1860 : : {
1861 : 0 : if ( renderer == m3DRenderer )
1862 : 0 : return;
1863 : :
1864 : 0 : delete m3DRenderer;
1865 : 0 : m3DRenderer = renderer;
1866 : 0 : emit renderer3DChanged();
1867 : 0 : trigger3DUpdate();
1868 : 0 : }
1869 : :
1870 : 0 : QgsAbstract3DRenderer *QgsMapLayer::renderer3D() const
1871 : : {
1872 : 0 : return m3DRenderer;
1873 : : }
1874 : :
1875 : 86 : void QgsMapLayer::triggerRepaint( bool deferredUpdate )
1876 : : {
1877 : 86 : if ( mRepaintRequestedFired )
1878 : 0 : return;
1879 : :
1880 : 86 : mRepaintRequestedFired = true;
1881 : 86 : emit repaintRequested( deferredUpdate );
1882 : 86 : mRepaintRequestedFired = false;
1883 : 86 : }
1884 : :
1885 : 0 : void QgsMapLayer::trigger3DUpdate()
1886 : : {
1887 : 0 : emit request3DUpdate();
1888 : 0 : }
1889 : :
1890 : 64 : void QgsMapLayer::setMetadata( const QgsLayerMetadata &metadata )
1891 : : {
1892 : 64 : mMetadata = metadata;
1893 : : // mMetadata.saveToLayer( this );
1894 : 64 : emit metadataChanged();
1895 : 64 : }
1896 : :
1897 : 0 : QString QgsMapLayer::htmlMetadata() const
1898 : : {
1899 : 0 : return QString();
1900 : : }
1901 : :
1902 : 0 : QDateTime QgsMapLayer::timestamp() const
1903 : : {
1904 : 0 : return QDateTime();
1905 : : }
1906 : :
1907 : 0 : void QgsMapLayer::emitStyleChanged()
1908 : : {
1909 : 0 : emit styleChanged();
1910 : 0 : }
1911 : :
1912 : 0 : void QgsMapLayer::setExtent( const QgsRectangle &extent )
1913 : : {
1914 : 0 : updateExtent( extent );
1915 : 0 : }
1916 : :
1917 : 0 : bool QgsMapLayer::isReadOnly() const
1918 : : {
1919 : 0 : return true;
1920 : : }
1921 : :
1922 : 0 : QString QgsMapLayer::originalXmlProperties() const
1923 : : {
1924 : 0 : return mOriginalXmlProperties;
1925 : : }
1926 : :
1927 : 0 : void QgsMapLayer::setOriginalXmlProperties( const QString &originalXmlProperties )
1928 : : {
1929 : 0 : mOriginalXmlProperties = originalXmlProperties;
1930 : 0 : }
1931 : :
1932 : 83 : QString QgsMapLayer::generateId( const QString &layerName )
1933 : : {
1934 : : // Generate the unique ID of this layer
1935 : 83 : QString uuid = QUuid::createUuid().toString();
1936 : : // trim { } from uuid
1937 : 83 : QString id = layerName + '_' + uuid.mid( 1, uuid.length() - 2 );
1938 : : // Tidy the ID up to avoid characters that may cause problems
1939 : : // elsewhere (e.g in some parts of XML). Replaces every non-word
1940 : : // character (word characters are the alphabet, numbers and
1941 : : // underscore) with an underscore.
1942 : : // Note that the first backslash in the regular expression is
1943 : : // there for the compiler, so the pattern is actually \W
1944 : 166 : id.replace( QRegExp( "[\\W]" ), QStringLiteral( "_" ) );
1945 : 83 : return id;
1946 : 83 : }
1947 : :
1948 : 0 : bool QgsMapLayer::accept( QgsStyleEntityVisitorInterface * ) const
1949 : : {
1950 : 0 : return true;
1951 : : }
1952 : :
1953 : 78 : void QgsMapLayer::setProviderType( const QString &providerType )
1954 : : {
1955 : 78 : mProviderKey = providerType;
1956 : 78 : }
1957 : :
1958 : 0 : QSet<QgsMapLayerDependency> QgsMapLayer::dependencies() const
1959 : : {
1960 : 0 : return mDependencies;
1961 : : }
1962 : :
1963 : 0 : bool QgsMapLayer::setDependencies( const QSet<QgsMapLayerDependency> &oDeps )
1964 : : {
1965 : 0 : QSet<QgsMapLayerDependency> deps;
1966 : 0 : const auto constODeps = oDeps;
1967 : 0 : for ( const QgsMapLayerDependency &dep : constODeps )
1968 : : {
1969 : 0 : if ( dep.origin() == QgsMapLayerDependency::FromUser )
1970 : 0 : deps << dep;
1971 : : }
1972 : :
1973 : 0 : mDependencies = deps;
1974 : 0 : emit dependenciesChanged();
1975 : : return true;
1976 : 0 : }
1977 : :
1978 : 0 : void QgsMapLayer::setRefreshOnNotifyEnabled( bool enabled )
1979 : : {
1980 : 0 : QgsDataProvider *lDataProvider = dataProvider();
1981 : 0 : if ( !lDataProvider )
1982 : 0 : return;
1983 : :
1984 : 0 : if ( enabled && !isRefreshOnNotifyEnabled() )
1985 : : {
1986 : 0 : lDataProvider->setListening( enabled );
1987 : 0 : connect( lDataProvider, &QgsVectorDataProvider::notify, this, &QgsMapLayer::onNotified );
1988 : 0 : }
1989 : 0 : else if ( !enabled && isRefreshOnNotifyEnabled() )
1990 : : {
1991 : : // we don't want to disable provider listening because someone else could need it (e.g. actions)
1992 : 0 : disconnect( lDataProvider, &QgsVectorDataProvider::notify, this, &QgsMapLayer::onNotified );
1993 : 0 : }
1994 : 0 : mIsRefreshOnNofifyEnabled = enabled;
1995 : 0 : }
1996 : :
1997 : 0 : QgsProject *QgsMapLayer::project() const
1998 : : {
1999 : 0 : if ( QgsMapLayerStore *store = qobject_cast<QgsMapLayerStore *>( parent() ) )
2000 : : {
2001 : 0 : return qobject_cast<QgsProject *>( store->parent() );
2002 : : }
2003 : 0 : return nullptr;
2004 : 0 : }
2005 : :
2006 : 0 : void QgsMapLayer::onNotified( const QString &message )
2007 : : {
2008 : 0 : if ( refreshOnNotifyMessage().isEmpty() || refreshOnNotifyMessage() == message )
2009 : : {
2010 : 0 : triggerRepaint();
2011 : 0 : emit dataChanged();
2012 : 0 : }
2013 : 0 : }
2014 : :
2015 : 4 : QgsRectangle QgsMapLayer::wgs84Extent( bool forceRecalculate ) const
2016 : : {
2017 : 4 : QgsRectangle wgs84Extent;
2018 : :
2019 : 4 : if ( ! forceRecalculate && ! mWgs84Extent.isNull() )
2020 : : {
2021 : 0 : wgs84Extent = mWgs84Extent;
2022 : 0 : }
2023 : 4 : else if ( ! mExtent.isNull() )
2024 : : {
2025 : 4 : const QgsCoordinateTransform transformer { crs(), QgsCoordinateReferenceSystem::fromOgcWmsCrs( geoEpsgCrsAuthId() ), transformContext() };
2026 : : try
2027 : : {
2028 : 4 : wgs84Extent = transformer.transformBoundingBox( mExtent );
2029 : 4 : }
2030 : : catch ( const QgsCsException &cse )
2031 : : {
2032 : 0 : QgsMessageLog::logMessage( tr( "Error transforming extent: %1" ).arg( cse.what() ) );
2033 : 0 : wgs84Extent = QgsRectangle();
2034 : 0 : }
2035 : 4 : }
2036 : 4 : return wgs84Extent;
2037 : 0 : }
2038 : :
2039 : 4 : void QgsMapLayer::updateExtent( const QgsRectangle &extent ) const
2040 : : {
2041 : 4 : if ( extent == mExtent )
2042 : 0 : return;
2043 : :
2044 : 4 : mExtent = extent;
2045 : :
2046 : : // do not update the wgs84 extent if we trust layer metadata
2047 : 4 : if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2048 : 0 : return;
2049 : :
2050 : 4 : mWgs84Extent = wgs84Extent( true );
2051 : 4 : }
2052 : :
2053 : 8 : void QgsMapLayer::invalidateWgs84Extent()
2054 : : {
2055 : : // do not update the wgs84 extent if we trust layer metadata
2056 : 8 : if ( mReadFlags & QgsMapLayer::ReadFlag::FlagTrustLayerMetadata )
2057 : 0 : return;
2058 : :
2059 : 8 : mWgs84Extent = QgsRectangle();
2060 : 8 : }
|
