QGIS API Documentation  3.37.0-Master (a5b4d9743e8)
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"
28 #include "qgspainteffectregistry.h"
29 #include "qgsthreadingutils.h"
30 #include <QUuid>
31 #include "RTree.h"
32 
34 class 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 
103 QgsAnnotationLayer::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 
127 {
129 
130  setOpacity( 1.0 );
133 
134  undoStackStyles()->clear();
135 
136  clear();
137 }
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 
150  triggerRepaint();
151 
152  return uuid;
153 }
154 
155 void QgsAnnotationLayer::replaceItem( const QString &id, QgsAnnotationItem *item )
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 
180  triggerRepaint();
181 }
182 
183 bool 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 
204  triggerRepaint();
205 
206  return true;
207 }
208 
210 {
212 
213  qDeleteAll( mItems );
214  mItems.clear();
215  mSpatialIndex = std::make_unique< QgsAnnotationLayerSpatialIndex >();
216  mNonIndexedItems.clear();
217 
218  triggerRepaint();
219 }
220 
222 {
224 
225  return mItems.empty();
226 }
227 
228 QgsAnnotationItem *QgsAnnotationLayer::item( const QString &id ) const
229 {
231 
232  return mItems.value( id );
233 }
234 
235 QStringList 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 
249 QStringList 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 
297  triggerRepaint();
298 
299  return res;
300 }
301 
303 {
305 
306  // annotation layers are always editable
308 }
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 
334 {
336 
337  return new QgsAnnotationLayerRenderer( this, rendererContext );
338 }
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 
370 bool 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 
383  triggerRepaint();
384 
385  return mValid;
386 }
387 
388 bool 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 
410 bool 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 
443 bool 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 
485 bool 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 
504 bool 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 
538 bool 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 
547 bool 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 
572 {
574 
575  return mDataProvider;
576 }
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 //
657 QgsAnnotationLayerDataProvider::QgsAnnotationLayerDataProvider(
658  const ProviderOptions &options,
660  : QgsDataProvider( QString(), options, flags )
661 {}
662 
664 {
666 
668 }
669 
670 QString QgsAnnotationLayerDataProvider::name() const
671 {
673 
674  return QStringLiteral( "annotation" );
675 }
676 
677 QString QgsAnnotationLayerDataProvider::description() const
678 {
680 
681  return QString();
682 }
683 
684 QgsRectangle QgsAnnotationLayerDataProvider::extent() const
685 {
687 
688  return QgsRectangle();
689 }
690 
691 bool 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:2022
@ 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:4007
@ Annotation
Contains freeform, georeferenced annotations. Added in QGIS 3.16.
QFlags< MapLayerProperty > MapLayerProperties
Map layer properties.
Definition: qgis.h:1805
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.
QMap< QString, QgsAnnotationItem * > items() const
Returns a map of items contained in the layer, by unique item ID.
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.
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:78
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:80
Qgis::LayerType type
Definition: qgsmaplayer.h:82
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
Definition: qgsmaplayer.h:188
virtual QgsMapLayer * clone() const =0
Returns a new instance equivalent to this one except for the id which is still unique.
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...
@ FlagDontResolveLayers
Don't resolve layer paths or create data providers for layers.
Definition: qgsmaplayer.h:640
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.
Definition: qgsmaplayer.h:2167
double opacity
Definition: qgsmaplayer.h:84
bool mValid
Indicates if the layer is valid and can be drawn.
Definition: qgsmaplayer.h:2118
@ Symbology
Symbology.
Definition: qgsmaplayer.h:167
@ Rendering
Rendering: scale visibility, simplify method, opacity.
Definition: qgsmaplayer.h:176
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.
Definition: qgsmaplayer.h:2174
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.
Definition: qgspainting.cpp:81
static QPainter::CompositionMode getCompositionMode(Qgis::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a Qgis::BlendMode.
Definition: qgspainting.cpp:21
The class is used as a container of context for various read/write operations on other objects.
A rectangle specified with double values.
Definition: qgsrectangle.h:42
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).
Definition: qgsrectangle.h:201
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:211
double xMaximum() const
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:196
double yMaximum() const
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:206
void combineExtentWith(const QgsRectangle &rect)
Expands the rectangle so that it covers both the original rectangle and the given rectangle.
Definition: qgsrectangle.h:413
Contains information about the context of a rendering operation.
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
const QgsCoordinateReferenceSystem & crs
Setting options for loading annotation layers.
QgsCoordinateTransformContext transformContext
Coordinate transform context.
Setting options for creating vector data providers.
QgsCoordinateTransformContext transformContext
Coordinate transform context.