QGIS API Documentation 3.39.0-Master (67e056379ed)
Loading...
Searching...
No Matches
qgsannotationlayer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsannotationlayer.cpp
3 ------------------
4 copyright : (C) 2019 by Sandro Mani
5 email : smani at sourcepole dot ch
6 ***************************************************************************/
7
8/***************************************************************************
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 ***************************************************************************/
16
17#include "qgsannotationlayer.h"
19#include "qgsannotationitem.h"
21#include "qgsapplication.h"
22#include "qgslogger.h"
23#include "qgspainting.h"
24#include "qgsmaplayerfactory.h"
25#include "qgsfeedback.h"
27#include "qgspainteffect.h"
29#include "qgsthreadingutils.h"
30#include <QUuid>
31#include "RTree.h"
32
34class QgsAnnotationLayerSpatialIndex : public RTree<QString, float, 2, float>
35{
36 public:
37
38 void insert( const QString &uuid, const QgsRectangle &bounds )
39 {
40 std::array< float, 4 > scaledBounds = scaleBounds( bounds );
41 this->Insert(
42 {
43 scaledBounds[0], scaledBounds[ 1]
44 },
45 {
46 scaledBounds[2], scaledBounds[3]
47 },
48 uuid );
49 }
50
57 void remove( const QString &uuid, const QgsRectangle &bounds )
58 {
59 std::array< float, 4 > scaledBounds = scaleBounds( bounds );
60 this->Remove(
61 {
62 scaledBounds[0], scaledBounds[ 1]
63 },
64 {
65 scaledBounds[2], scaledBounds[3]
66 },
67 uuid );
68 }
69
75 bool intersects( const QgsRectangle &bounds, const std::function< bool( const QString &uuid )> &callback ) const
76 {
77 std::array< float, 4 > scaledBounds = scaleBounds( bounds );
78 this->Search(
79 {
80 scaledBounds[0], scaledBounds[ 1]
81 },
82 {
83 scaledBounds[2], scaledBounds[3]
84 },
85 callback );
86 return true;
87 }
88
89 private:
90 std::array<float, 4> scaleBounds( const QgsRectangle &bounds ) const
91 {
92 return
93 {
94 static_cast< float >( bounds.xMinimum() ),
95 static_cast< float >( bounds.yMinimum() ),
96 static_cast< float >( bounds.xMaximum() ),
97 static_cast< float >( bounds.yMaximum() )
98 };
99 }
100};
102
103QgsAnnotationLayer::QgsAnnotationLayer( const QString &name, const LayerOptions &options )
104 : QgsMapLayer( Qgis::LayerType::Annotation, name )
105 , mTransformContext( options.transformContext )
106 , mSpatialIndex( std::make_unique< QgsAnnotationLayerSpatialIndex >() )
107{
108 mShouldValidateCrs = false;
109 mValid = true;
110
111 QgsDataProvider::ProviderOptions providerOptions;
112 providerOptions.transformContext = options.transformContext;
113 mDataProvider = new QgsAnnotationLayerDataProvider( providerOptions, QgsDataProvider::ReadFlags() );
114
115 mPaintEffect.reset( QgsPaintEffectRegistry::defaultStack() );
116 mPaintEffect->setEnabled( false );
117}
118
120{
121 emit willBeDeleted();
122 qDeleteAll( mItems );
123 delete mDataProvider;
124}
125
138
140{
142
143 const QString uuid = QUuid::createUuid().toString();
144 mItems.insert( uuid, item );
146 mNonIndexedItems.insert( uuid );
147 else
148 mSpatialIndex->insert( uuid, item->boundingBox() );
149
151
152 return uuid;
153}
154
156{
158
159 std::unique_ptr< QgsAnnotationItem> prevItem( mItems.take( id ) );
160
161 if ( prevItem )
162 {
163 auto it = mNonIndexedItems.find( id );
164 if ( it == mNonIndexedItems.end() )
165 {
166 mSpatialIndex->remove( id, prevItem->boundingBox() );
167 }
168 else
169 {
170 mNonIndexedItems.erase( it );
171 }
172 }
173
174 mItems.insert( id, item );
176 mNonIndexedItems.insert( id );
177 else
178 mSpatialIndex->insert( id, item->boundingBox() );
179
181}
182
183bool QgsAnnotationLayer::removeItem( const QString &id )
184{
186
187 if ( !mItems.contains( id ) )
188 return false;
189
190 std::unique_ptr< QgsAnnotationItem> item( mItems.take( id ) );
191
192 auto it = mNonIndexedItems.find( id );
193 if ( it == mNonIndexedItems.end() )
194 {
195 mSpatialIndex->remove( id, item->boundingBox() );
196 }
197 else
198 {
199 mNonIndexedItems.erase( it );
200 }
201
202 item.reset();
203
205
206 return true;
207}
208
210{
212
213 qDeleteAll( mItems );
214 mItems.clear();
215 mSpatialIndex = std::make_unique< QgsAnnotationLayerSpatialIndex >();
216 mNonIndexedItems.clear();
217
219}
220
222{
224
225 return mItems.empty();
226}
227
229{
231
232 return mItems.value( id );
233}
234
235QStringList QgsAnnotationLayer::queryIndex( const QgsRectangle &bounds, QgsFeedback *feedback ) const
236{
238
239 QStringList res;
240
241 mSpatialIndex->intersects( bounds, [&res, feedback]( const QString & uuid )->bool
242 {
243 res << uuid;
244 return !feedback || !feedback->isCanceled();
245 } );
246 return res;
247}
248
249QStringList QgsAnnotationLayer::itemsInBounds( const QgsRectangle &bounds, QgsRenderContext &context, QgsFeedback *feedback ) const
250{
252
253 QStringList res = queryIndex( bounds, feedback );
254 // we also have to search through any non-indexed items
255 for ( const QString &uuid : mNonIndexedItems )
256 {
257 if ( mItems.value( uuid )->boundingBox( context ).intersects( bounds ) )
258 res << uuid;
259 }
260
261 return res;
262}
263
265{
267
269 if ( QgsAnnotationItem *targetItem = item( operation->itemId() ) )
270 {
271 // remove item from index if present
272 auto it = mNonIndexedItems.find( operation->itemId() );
273 if ( it == mNonIndexedItems.end() )
274 {
275 mSpatialIndex->remove( operation->itemId(), targetItem->boundingBox() );
276 }
277 res = targetItem->applyEdit( operation );
278
279 switch ( res )
280 {
283 // re-add to index if possible
284 if ( !( targetItem->flags() & Qgis::AnnotationItemFlag::ScaleDependentBoundingBox ) )
285 mSpatialIndex->insert( operation->itemId(), targetItem->boundingBox() );
286 break;
287
289 // item needs removing from layer
290 delete mItems.take( operation->itemId() );
291 mNonIndexedItems.remove( operation->itemId() );
292 break;
293 }
294 }
295
298
299 return res;
300}
301
309
311{
313
314 const QgsAnnotationLayer::LayerOptions options( mTransformContext );
315 std::unique_ptr< QgsAnnotationLayer > layer = std::make_unique< QgsAnnotationLayer >( name(), options );
316 QgsMapLayer::clone( layer.get() );
317
318 for ( auto it = mItems.constBegin(); it != mItems.constEnd(); ++it )
319 {
320 layer->mItems.insert( it.key(), ( *it )->clone() );
322 layer->mNonIndexedItems.insert( it.key() );
323 else
324 layer->mSpatialIndex->insert( it.key(), ( *it )->boundingBox() );
325 }
326
327 if ( mPaintEffect )
328 layer->setPaintEffect( mPaintEffect->clone() );
329
330 return layer.release();
331}
332
339
341{
343
344 QgsRectangle rect;
345 for ( auto it = mItems.constBegin(); it != mItems.constEnd(); ++it )
346 {
347 if ( rect.isNull() )
348 {
349 rect = it.value()->boundingBox();
350 }
351 else
352 {
353 rect.combineExtentWith( it.value()->boundingBox() );
354 }
355 }
356 return rect;
357}
358
360{
362
363 if ( mDataProvider )
364 mDataProvider->setTransformContext( context );
365
366 mTransformContext = context;
368}
369
370bool QgsAnnotationLayer::readXml( const QDomNode &layerNode, QgsReadWriteContext &context )
371{
373
375 {
376 return false;
377 }
378
379 QString errorMsg;
380 readItems( layerNode, errorMsg, context );
381 readSymbology( layerNode, errorMsg, context );
382
384
385 return mValid;
386}
387
388bool QgsAnnotationLayer::writeXml( QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context ) const
389{
391
392 // first get the layer element so that we can append the type attribute
393 QDomElement mapLayerNode = layer_node.toElement();
394
395 if ( mapLayerNode.isNull() )
396 {
397 QgsDebugMsgLevel( QStringLiteral( "can't find maplayer node" ), 2 );
398 return false;
399 }
400
401 mapLayerNode.setAttribute( QStringLiteral( "type" ), QgsMapLayerFactory::typeToString( Qgis::LayerType::Annotation ) );
402
403 QString errorMsg;
404 writeItems( layer_node, doc, errorMsg, context );
405
406 // renderer specific settings
407 return writeSymbology( layer_node, doc, errorMsg, context );
408}
409
410bool QgsAnnotationLayer::writeSymbology( QDomNode &node, QDomDocument &doc, QString &, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
411{
413
414 QDomElement layerElement = node.toElement();
415 writeCommonStyle( layerElement, doc, context, categories );
416
417 // add the layer opacity
418 if ( categories.testFlag( Rendering ) )
419 {
420 QDomElement layerOpacityElem = doc.createElement( QStringLiteral( "layerOpacity" ) );
421 const QDomText layerOpacityText = doc.createTextNode( QString::number( opacity() ) );
422 layerOpacityElem.appendChild( layerOpacityText );
423 node.appendChild( layerOpacityElem );
424 }
425
426 if ( categories.testFlag( Symbology ) )
427 {
428 // add the blend mode field
429 QDomElement blendModeElem = doc.createElement( QStringLiteral( "blendMode" ) );
430 const QDomText blendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( blendMode() ) ) ) );
431 blendModeElem.appendChild( blendModeText );
432 node.appendChild( blendModeElem );
433
434 QDomElement paintEffectElem = doc.createElement( QStringLiteral( "paintEffect" ) );
435 if ( mPaintEffect && !QgsPaintEffectRegistry::isDefaultStack( mPaintEffect.get() ) )
436 mPaintEffect->saveProperties( doc, paintEffectElem );
437 node.appendChild( paintEffectElem );
438 }
439
440 return true;
441}
442
443bool QgsAnnotationLayer::readSymbology( const QDomNode &node, QString &, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
444{
446
447 const QDomElement layerElement = node.toElement();
448 readCommonStyle( layerElement, context, categories );
449
450 if ( categories.testFlag( Rendering ) )
451 {
452 const QDomNode layerOpacityNode = node.namedItem( QStringLiteral( "layerOpacity" ) );
453 if ( !layerOpacityNode.isNull() )
454 {
455 const QDomElement e = layerOpacityNode.toElement();
456 setOpacity( e.text().toDouble() );
457 }
458 }
459
460 if ( categories.testFlag( Symbology ) )
461 {
462 // get and set the blend mode if it exists
463 const QDomNode blendModeNode = node.namedItem( QStringLiteral( "blendMode" ) );
464 if ( !blendModeNode.isNull() )
465 {
466 const QDomElement e = blendModeNode.toElement();
467 setBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
468 }
469
470 //restore layer effect
471 const QDomNode paintEffectNode = node.namedItem( QStringLiteral( "paintEffect" ) );
472 if ( !paintEffectNode.isNull() )
473 {
474 const QDomElement effectElem = paintEffectNode.firstChildElement( QStringLiteral( "effect" ) );
475 if ( !effectElem.isNull() )
476 {
477 setPaintEffect( QgsApplication::paintEffectRegistry()->createEffect( effectElem ) );
478 }
479 }
480 }
481
482 return true;
483}
484
485bool QgsAnnotationLayer::writeItems( QDomNode &node, QDomDocument &doc, QString &, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories ) const
486{
488
489 QDomElement itemsElement = doc.createElement( QStringLiteral( "items" ) );
490
491 for ( auto it = mItems.constBegin(); it != mItems.constEnd(); ++it )
492 {
493 QDomElement itemElement = doc.createElement( QStringLiteral( "item" ) );
494 itemElement.setAttribute( QStringLiteral( "type" ), ( *it )->type() );
495 itemElement.setAttribute( QStringLiteral( "id" ), it.key() );
496 ( *it )->writeXml( itemElement, doc, context );
497 itemsElement.appendChild( itemElement );
498 }
499 node.appendChild( itemsElement );
500
501 return true;
502}
503
504bool QgsAnnotationLayer::readItems( const QDomNode &node, QString &, QgsReadWriteContext &context, QgsMapLayer::StyleCategories )
505{
507
508 qDeleteAll( mItems );
509 mItems.clear();
510 mSpatialIndex = std::make_unique< QgsAnnotationLayerSpatialIndex >();
511 mNonIndexedItems.clear();
512
513 const QDomNodeList itemsElements = node.toElement().elementsByTagName( QStringLiteral( "items" ) );
514 if ( itemsElements.size() == 0 )
515 return false;
516
517 const QDomNodeList items = itemsElements.at( 0 ).childNodes();
518 for ( int i = 0; i < items.size(); ++i )
519 {
520 const QDomElement itemElement = items.at( i ).toElement();
521 const QString id = itemElement.attribute( QStringLiteral( "id" ) );
522 const QString type = itemElement.attribute( QStringLiteral( "type" ) );
523 std::unique_ptr< QgsAnnotationItem > item( QgsApplication::annotationItemRegistry()->createItem( type ) );
524 if ( item )
525 {
526 item->readXml( itemElement, context );
528 mNonIndexedItems.insert( id );
529 else
530 mSpatialIndex->insert( id, item->boundingBox() );
531 mItems.insert( id, item.release() );
532 }
533 }
534
535 return true;
536}
537
538bool QgsAnnotationLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
539{
541
542 writeItems( node, doc, errorMessage, context, categories );
543
544 return writeSymbology( node, doc, errorMessage, context, categories );
545}
546
547bool QgsAnnotationLayer::readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
548{
550
551 readItems( node, errorMessage, context, categories );
552
553 return readSymbology( node, errorMessage, context, categories );
554}
555
557{
559
560 // annotation layers are always editable
561 return true;
562}
563
565{
567
568 return true;
569}
570
577
579{
581
582 return mDataProvider;
583}
584
586{
588
589 QString metadata = QStringLiteral( "<html>\n<body>\n<h1>" ) + tr( "General" ) + QStringLiteral( "</h1>\n<hr>\n" ) + QStringLiteral( "<table class=\"list-view\">\n" );
590
591 metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Name" ) + QStringLiteral( "</td><td>" ) + name() + QStringLiteral( "</td></tr>\n" );
592
593 // Extent
594 metadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Extent" ) + QStringLiteral( "</td><td>" ) + extent().toString() + QStringLiteral( "</td></tr>\n" );
595
596 // item count
597 QLocale locale = QLocale();
598 locale.setNumberOptions( locale.numberOptions() &= ~QLocale::NumberOption::OmitGroupSeparator );
599 const int itemCount = mItems.size();
600 metadata += QStringLiteral( "<tr><td class=\"highlight\">" )
601 + tr( "Item count" ) + QStringLiteral( "</td><td>" )
602 + locale.toString( static_cast<qlonglong>( itemCount ) )
603 + QStringLiteral( "</td></tr>\n" );
604 metadata += QLatin1String( "</table>\n<br><br>" );
605
606 // CRS
608
609 // items section
610 metadata += QStringLiteral( "<h1>" ) + tr( "Items" ) + QStringLiteral( "</h1>\n<hr>\n" );
611
612 metadata += QLatin1String( "<table width=\"100%\" class=\"tabular-view\">\n" );
613 metadata += QLatin1String( "<tr><th>" ) + tr( "Type" ) + QLatin1String( "</th><th>" ) + tr( "Count" ) + QLatin1String( "</th></tr>\n" );
614
615 QMap< QString, int > itemCounts;
616 for ( auto it = mItems.constBegin(); it != mItems.constEnd(); ++it )
617 {
618 itemCounts[ it.value()->type() ]++;
619 }
620
621 const QMap<QString, QString> itemTypes = QgsApplication::annotationItemRegistry()->itemTypes();
622 int i = 0;
623 for ( auto it = itemTypes.begin(); it != itemTypes.end(); ++it )
624 {
625 QString rowClass;
626 if ( i % 2 )
627 rowClass = QStringLiteral( "class=\"odd-row\"" );
628 metadata += QLatin1String( "<tr " ) + rowClass + QLatin1String( "><td>" ) + it.value() + QLatin1String( "</td><td>" ) + locale.toString( static_cast<qlonglong>( itemCounts.value( it.key() ) ) ) + QLatin1String( "</td></tr>\n" );
629 i++;
630 }
631
632 metadata += QLatin1String( "</table>\n<br><br>" );
633
634 metadata += QLatin1String( "\n</body>\n</html>\n" );
635 return metadata;
636}
637
639{
641
642 return mPaintEffect.get();
643}
644
646{
648
649 mPaintEffect.reset( effect );
650}
651
652
653//
654// QgsAnnotationLayerDataProvider
655//
657QgsAnnotationLayerDataProvider::QgsAnnotationLayerDataProvider(
658 const ProviderOptions &options,
660 : QgsDataProvider( QString(), options, flags )
661{}
662
663QgsCoordinateReferenceSystem QgsAnnotationLayerDataProvider::crs() const
664{
666
668}
669
670QString QgsAnnotationLayerDataProvider::name() const
671{
673
674 return QStringLiteral( "annotation" );
675}
676
677QString QgsAnnotationLayerDataProvider::description() const
678{
680
681 return QString();
682}
683
684QgsRectangle QgsAnnotationLayerDataProvider::extent() const
685{
687
688 return QgsRectangle();
689}
690
691bool QgsAnnotationLayerDataProvider::isValid() const
692{
694
695 return true;
696}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ UsersCannotToggleEditing
Indicates that users are not allowed to toggle editing for this layer. Note that this does not imply ...
@ ScaleDependentBoundingBox
Item's bounding box will vary depending on map scale.
AnnotationItemEditOperationResult
Results from an edit operation on an annotation item.
Definition qgis.h:2138
@ Invalid
Operation has invalid parameters for the item, no change occurred.
@ Success
Item was modified successfully.
@ ItemCleared
The operation results in the item being cleared, and the item should be removed from the layer as a r...
BlendMode
Blending modes defining the available composition modes that can be used when painting.
Definition qgis.h:4280
@ Annotation
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
QFlags< MapLayerProperty > MapLayerProperties
Map layer properties.
Definition qgis.h:1921
Abstract base class for annotation item edit operations.
QString itemId() const
Returns the associated item ID.
QMap< QString, QString > itemTypes() const
Returns a map of available item types to translated name.
Abstract base class for annotation items which are drawn with QgsAnnotationLayers.
virtual QgsRectangle boundingBox() const =0
Returns the bounding box of the item's geographic location, in the parent layer's coordinate referenc...
virtual bool readXml(const QDomElement &element, const QgsReadWriteContext &context)=0
Reads the item's state from the given DOM element.
virtual Qgis::AnnotationItemFlags flags() const
Returns item flags.
Represents a map layer containing a set of georeferenced annotations, e.g.
QgsRectangle extent() const override
Returns the extent of the layer.
bool writeSymbology(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &, StyleCategories categories=AllStyleCategories) const override
Write the style for the layer into the document provided.
bool readSymbology(const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) override
Read the symbology for the current layer from the DOM node supplied.
bool readStyle(const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, StyleCategories categories) override
Read the style for the current layer from the DOM node supplied.
void clear()
Removes all items from the layer.
QgsDataProvider * dataProvider() override
Returns the layer's data provider, it may be nullptr.
QgsMapLayerRenderer * createMapRenderer(QgsRenderContext &rendererContext) override
Returns new instance of QgsMapLayerRenderer that will be used for rendering of given context.
bool isEditable() const override
Returns true if the layer can be edited.
bool removeItem(const QString &id)
Removes (and deletes) the item with matching id.
QStringList itemsInBounds(const QgsRectangle &bounds, QgsRenderContext &context, QgsFeedback *feedback=nullptr) const
Returns a list of the IDs of all annotation items within the specified bounds (in layer CRS),...
void setTransformContext(const QgsCoordinateTransformContext &context) override
Sets the coordinate transform context to transformContext.
Qgis::AnnotationItemEditOperationResult applyEdit(QgsAbstractAnnotationItemEditOperation *operation)
Applies an edit operation to the layer.
void setPaintEffect(QgsPaintEffect *effect)
Sets the current paint effect for the layer.
QgsPaintEffect * paintEffect() const
Returns the current paint effect for the layer.
void replaceItem(const QString &id, QgsAnnotationItem *item)
Replaces the existing item with matching id with a new item.
QgsAnnotationLayer * clone() const override
Returns a new instance equivalent to this one except for the id which is still unique.
friend class QgsAnnotationLayerRenderer
bool supportsEditing() const override
Returns whether the layer supports editing or not.
void reset()
Resets the annotation layer to a default state, and clears all items from it.
QString addItem(QgsAnnotationItem *item)
Adds an item to the layer.
QString htmlMetadata() const override
Obtain a formatted HTML string containing assorted metadata for this layer.
Qgis::MapLayerProperties properties() const override
Returns the map layer properties of this layer.
bool isEmpty() const
Returns true if the annotation layer is empty and contains no annotations.
QgsAnnotationItem * item(const QString &id) const
Returns the item with the specified id, or nullptr if no matching item was found.
bool writeXml(QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context) const override
Called by writeLayerXML(), used by children to write state specific to them to project files.
bool readXml(const QDomNode &layerNode, QgsReadWriteContext &context) override
Called by readLayerXML(), used by children to read state specific to them from project files.
QgsAnnotationLayer(const QString &name, const QgsAnnotationLayer::LayerOptions &options)
Constructor for a new QgsAnnotationLayer with the specified layer name.
QMap< QString, QgsAnnotationItem * > items() const
Returns a map of items contained in the layer, by unique item ID.
bool writeStyle(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, StyleCategories categories) const override
Write just the symbology information for the layer into the document.
static QgsAnnotationItemRegistry * annotationItemRegistry()
Returns the application's annotation item registry, used for annotation item types.
static QgsPaintEffectRegistry * paintEffectRegistry()
Returns the application's paint effect registry, used for managing paint effects.
This class represents a coordinate reference system (CRS).
Contains information about the context in which a coordinate transform is executed.
Abstract base class for spatial data provider implementations.
QFlags< ReadFlag > ReadFlags
virtual void setTransformContext(const QgsCoordinateTransformContext &transformContext)
Sets data coordinate transform context to transformContext.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
static QString typeToString(Qgis::LayerType type)
Converts a map layer type to a string value.
Base class for utility classes that encapsulate information necessary for rendering of map layers.
Base class for all map layer types.
Definition qgsmaplayer.h:75
QString name
Definition qgsmaplayer.h:79
void setBlendMode(QPainter::CompositionMode blendMode)
Set the blending mode used for rendering a 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.
QgsLayerMetadata metadata
Definition qgsmaplayer.h:81
Qgis::LayerType type
Definition qgsmaplayer.h:85
QPainter::CompositionMode blendMode() const
Returns the current blending mode for a layer.
virtual void setOpacity(double opacity)
Sets the opacity for the layer, where opacity is a value between 0 (totally transparent) and 1....
QFlags< StyleCategory > StyleCategories
QUndoStack * undoStackStyles()
Returns pointer to layer's style undo stack.
void willBeDeleted()
Emitted in the destructor when the layer is about to be deleted, but it is still in a perfectly valid...
virtual QgsMapLayer * clone() const =0
Returns a new instance equivalent to this one except for the id which is still unique.
@ FlagDontResolveLayers
Don't resolve layer paths or create data providers for layers.
void readCommonStyle(const QDomElement &layerElement, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories)
Read style data common to all layer types.
QgsMapLayer::ReadFlags mReadFlags
Read flags. It's up to the subclass to respect these when restoring state from XML.
double opacity
Definition qgsmaplayer.h:87
bool mValid
Indicates if the layer is valid and can be drawn.
@ Symbology
Symbology.
@ Rendering
Rendering: scale visibility, simplify method, opacity.
void writeCommonStyle(QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) const
Write style data common to all layer types.
void invalidateWgs84Extent()
Invalidates the WGS84 extent.
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 QgsPaintEffect * defaultStack()
Returns a new effect stack consisting of a sensible selection of default effects.
static bool isDefaultStack(QgsPaintEffect *effect)
Tests whether a paint effect matches the default effects stack.
Base class for visual effects which can be applied to QPicture drawings.
static Qgis::BlendMode getBlendModeEnum(QPainter::CompositionMode blendMode)
Returns a Qgis::BlendMode corresponding to a QPainter::CompositionMode.
static QPainter::CompositionMode getCompositionMode(Qgis::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a Qgis::BlendMode.
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
double xMinimum() const
Returns the x minimum value (left side of rectangle).
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
double xMaximum() const
Returns the x maximum value (right side of rectangle).
double yMaximum() const
Returns the y maximum value (top side of rectangle).
void combineExtentWith(const QgsRectangle &rect)
Expands the rectangle so that it covers both the original rectangle and the given rectangle.
Contains information about the context of a rendering operation.
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:39
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
Setting options for loading annotation layers.
QgsCoordinateTransformContext transformContext
Coordinate transform context.
Setting options for creating vector data providers.
QgsCoordinateTransformContext transformContext
Coordinate transform context.