QGIS API Documentation 3.27.0-Master (f261cc1f8b)
qgslayertreegroup.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgslayertreegroup.cpp
3 --------------------------------------
4 Date : May 2014
5 Copyright : (C) 2014 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgslayertreegroup.h"
17
18#include "qgslayertree.h"
19#include "qgslayertreeutils.h"
20#include "qgsmaplayer.h"
21#include "qgsgrouplayer.h"
22
23#include <QDomElement>
24#include <QStringList>
25
26
27QgsLayerTreeGroup::QgsLayerTreeGroup( const QString &name, bool checked )
28 : QgsLayerTreeNode( NodeGroup, checked )
29 , mName( name )
30{
31 init();
32}
33
35 : QgsLayerTreeNode( other )
36 , mName( other.mName )
37 , mChangingChildVisibility( other.mChangingChildVisibility )
38 , mMutuallyExclusive( other.mMutuallyExclusive )
39 , mMutuallyExclusiveChildIndex( other.mMutuallyExclusiveChildIndex )
40 , mGroupLayer( other.mGroupLayer )
41{
42 init();
43}
44
45void QgsLayerTreeGroup::init()
46{
48 connect( this, &QgsLayerTreeNode::addedChildren, this, &QgsLayerTreeGroup::updateGroupLayers );
49 connect( this, &QgsLayerTreeNode::removedChildren, this, &QgsLayerTreeGroup::updateGroupLayers );
50 connect( this, &QgsLayerTreeNode::visibilityChanged, this, &QgsLayerTreeGroup::updateGroupLayers );
51}
52
54{
55 return mName;
56}
57
58void QgsLayerTreeGroup::setName( const QString &n )
59{
60 if ( mName == n )
61 return;
62
63 mName = n;
64 emit nameChanged( this, n );
65}
66
67
68QgsLayerTreeGroup *QgsLayerTreeGroup::insertGroup( int index, const QString &name )
69{
71 insertChildNode( index, grp );
72 return grp;
73}
74
76{
78 addChildNode( grp );
79 return grp;
80}
81
83{
84 if ( !layer )
85 return nullptr;
86
87 QgsLayerTreeLayer *ll = new QgsLayerTreeLayer( layer );
88 insertChildNode( index, ll );
89
90 updateGroupLayers();
91 return ll;
92}
93
95{
96 if ( !layer )
97 return nullptr;
98
99 QgsLayerTreeLayer *ll = new QgsLayerTreeLayer( layer );
100 addChildNode( ll );
101
102 updateGroupLayers();
103 return ll;
104}
105
107{
108 QList<QgsLayerTreeNode *> nodes;
109 nodes << node;
110 insertChildNodes( index, nodes );
111}
112
113void QgsLayerTreeGroup::insertChildNodes( int index, const QList<QgsLayerTreeNode *> &nodes )
114{
115 QgsLayerTreeNode *meChild = nullptr;
118
119 // low-level insert
120 insertChildrenPrivate( index, nodes );
121
122 if ( mMutuallyExclusive )
123 {
124 if ( meChild )
125 {
126 // the child could have change its index - or the new children may have been also set as visible
127 mMutuallyExclusiveChildIndex = mChildren.indexOf( meChild );
128 }
129 else if ( mChecked )
130 {
131 // we have not picked a child index yet, but we should pick one now
132 // ... so pick the first one from the newly added
133 if ( index == -1 )
134 index = mChildren.count() - nodes.count(); // get real insertion index
136 }
138 }
139
140 updateGroupLayers();
141}
142
144{
145 insertChildNode( -1, node );
146
147 updateGroupLayers();
148}
149
151{
152 int i = mChildren.indexOf( node );
153 if ( i >= 0 )
154 removeChildren( i, 1 );
155
156 updateGroupLayers();
157}
158
160{
161 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
162 {
163 if ( QgsLayerTree::isLayer( child ) )
164 {
165 QgsLayerTreeLayer *childLayer = QgsLayerTree::toLayer( child );
166 if ( childLayer->layer() == layer )
167 {
168 removeChildren( mChildren.indexOf( child ), 1 );
169 break;
170 }
171 }
172 }
173
174 updateGroupLayers();
175}
176
177void QgsLayerTreeGroup::removeChildren( int from, int count )
178{
179 QgsLayerTreeNode *meChild = nullptr;
182
183 removeChildrenPrivate( from, count );
184
185 if ( meChild )
186 {
187 // the child could have change its index - or may have been removed completely
188 mMutuallyExclusiveChildIndex = mChildren.indexOf( meChild );
189 // we need to uncheck this group
190 //if ( mMutuallyExclusiveChildIndex == -1 )
191 // setItemVisibilityChecked( false );
192 }
193
194 updateGroupLayers();
195}
196
198{
199 // clean the layer tree by removing empty group
200 const auto childNodes = children();
201 for ( QgsLayerTreeNode *treeNode : childNodes )
202 {
203 if ( treeNode->nodeType() == QgsLayerTreeNode::NodeGroup )
204 {
205 QgsLayerTreeGroup *treeGroup = qobject_cast<QgsLayerTreeGroup *>( treeNode );
206 if ( treeGroup->findLayerIds().isEmpty() )
207 removeChildNode( treeNode );
208 else
210 }
211 }
212
213 updateGroupLayers();
214}
215
217{
218 removeChildren( 0, mChildren.count() );
219}
220
222{
223 if ( !layer )
224 return nullptr;
225
226 return findLayer( layer->id() );
227}
228
229QgsLayerTreeLayer *QgsLayerTreeGroup::findLayer( const QString &layerId ) const
230{
231 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
232 {
233 if ( QgsLayerTree::isLayer( child ) )
234 {
235 QgsLayerTreeLayer *childLayer = QgsLayerTree::toLayer( child );
236 if ( childLayer->layerId() == layerId )
237 return childLayer;
238 }
239 else if ( QgsLayerTree::isGroup( child ) )
240 {
241 QgsLayerTreeLayer *res = QgsLayerTree::toGroup( child )->findLayer( layerId );
242 if ( res )
243 return res;
244 }
245 }
246 return nullptr;
247}
248
249QList<QgsLayerTreeLayer *> QgsLayerTreeGroup::findLayers() const
250{
251 QList<QgsLayerTreeLayer *> list;
252 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
253 {
254 if ( QgsLayerTree::isLayer( child ) )
255 list << QgsLayerTree::toLayer( child );
256 else if ( QgsLayerTree::isGroup( child ) )
257 list << QgsLayerTree::toGroup( child )->findLayers();
258 }
259 return list;
260}
261
263{
264 QList<QgsMapLayer *> list;
265 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
266 {
267 if ( QgsLayerTree::isLayer( child ) )
268 {
269 QgsMapLayer *layer = QgsLayerTree::toLayer( child )->layer();
270 if ( !layer || !layer->isSpatial() )
271 continue;
272 list << layer;
273 }
274 else if ( QgsLayerTree::isGroup( child ) )
275 {
277 if ( group->groupLayer() )
278 {
279 list << group->groupLayer();
280 }
281 else
282 {
283 list << group->layerOrderRespectingGroupLayers();
284 }
285 }
286 }
287 return list;
288}
289
291{
292 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
293 {
294 if ( QgsLayerTree::isGroup( child ) )
295 {
296 QgsLayerTreeGroup *childGroup = QgsLayerTree::toGroup( child );
297 if ( childGroup->name() == name )
298 return childGroup;
299 else
300 {
301 QgsLayerTreeGroup *grp = childGroup->findGroup( name );
302 if ( grp )
303 return grp;
304 }
305 }
306 }
307 return nullptr;
308}
309
310QList<QgsLayerTreeGroup *> QgsLayerTreeGroup::findGroups( bool recursive ) const
311{
312 QList<QgsLayerTreeGroup *> list;
313
314 for ( QgsLayerTreeNode *child : mChildren )
315 {
316 if ( QgsLayerTree::isGroup( child ) )
317 {
318 QgsLayerTreeGroup *childGroup = QgsLayerTree::toGroup( child );
319 list << childGroup;
320 if ( recursive )
321 list << childGroup->findGroups( recursive );
322 }
323 }
324 return list;
325}
326
328{
329 if ( element.tagName() != QLatin1String( "layer-tree-group" ) )
330 return nullptr;
331
332 QString name = context.projectTranslator()->translate( QStringLiteral( "project:layergroups" ), element.attribute( QStringLiteral( "name" ) ) );
333 bool isExpanded = ( element.attribute( QStringLiteral( "expanded" ), QStringLiteral( "1" ) ) == QLatin1String( "1" ) );
334 bool checked = QgsLayerTreeUtils::checkStateFromXml( element.attribute( QStringLiteral( "checked" ) ) ) != Qt::Unchecked;
335 bool isMutuallyExclusive = element.attribute( QStringLiteral( "mutually-exclusive" ), QStringLiteral( "0" ) ) == QLatin1String( "1" );
336 int mutuallyExclusiveChildIndex = element.attribute( QStringLiteral( "mutually-exclusive-child" ), QStringLiteral( "-1" ) ).toInt();
337
338 QgsLayerTreeGroup *groupNode = new QgsLayerTreeGroup( name, checked );
339 groupNode->setExpanded( isExpanded );
340
341 groupNode->readCommonXml( element );
342
343 groupNode->readChildrenFromXml( element, context );
344
345 groupNode->setIsMutuallyExclusive( isMutuallyExclusive, mutuallyExclusiveChildIndex );
346
347 groupNode->mGroupLayer = QgsMapLayerRef( element.attribute( QStringLiteral( "groupLayer" ) ) );
348
349 return groupNode;
350}
351
352QgsLayerTreeGroup *QgsLayerTreeGroup::readXml( QDomElement &element, const QgsProject *project, const QgsReadWriteContext &context )
353{
354 QgsLayerTreeGroup *node = readXml( element, context );
355 if ( node )
356 node->resolveReferences( project );
357 return node;
358}
359
360void QgsLayerTreeGroup::writeXml( QDomElement &parentElement, const QgsReadWriteContext &context )
361{
362 QDomDocument doc = parentElement.ownerDocument();
363 QDomElement elem = doc.createElement( QStringLiteral( "layer-tree-group" ) );
364 elem.setAttribute( QStringLiteral( "name" ), mName );
365 elem.setAttribute( QStringLiteral( "expanded" ), mExpanded ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
366 elem.setAttribute( QStringLiteral( "checked" ), mChecked ? QStringLiteral( "Qt::Checked" ) : QStringLiteral( "Qt::Unchecked" ) );
367 if ( mMutuallyExclusive )
368 {
369 elem.setAttribute( QStringLiteral( "mutually-exclusive" ), QStringLiteral( "1" ) );
370 elem.setAttribute( QStringLiteral( "mutually-exclusive-child" ), mMutuallyExclusiveChildIndex );
371 }
372 elem.setAttribute( QStringLiteral( "groupLayer" ), mGroupLayer.layerId );
373
374 writeCommonXml( elem );
375
376 for ( QgsLayerTreeNode *node : std::as_const( mChildren ) )
377 node->writeXml( elem, context );
378
379 parentElement.appendChild( elem );
380}
381
382void QgsLayerTreeGroup::readChildrenFromXml( QDomElement &element, const QgsReadWriteContext &context )
383{
384 QList<QgsLayerTreeNode *> nodes;
385 QDomElement childElem = element.firstChildElement();
386 while ( !childElem.isNull() )
387 {
388 QgsLayerTreeNode *newNode = QgsLayerTreeNode::readXml( childElem, context );
389 if ( newNode )
390 nodes << newNode;
391
392 childElem = childElem.nextSiblingElement();
393 }
394
395 insertChildNodes( -1, nodes );
396}
397
399{
400 QString header = QStringLiteral( "GROUP: %1 checked=%2 expanded=%3\n" ).arg( name() ).arg( mChecked ).arg( mExpanded );
401 QStringList childrenDump;
402 for ( QgsLayerTreeNode *node : std::as_const( mChildren ) )
403 childrenDump << node->dump().split( '\n' );
404 for ( int i = 0; i < childrenDump.count(); ++i )
405 childrenDump[i].prepend( " " );
406 return header + childrenDump.join( QLatin1Char( '\n' ) );
407}
408
410{
411 return new QgsLayerTreeGroup( *this );
412}
413
414void QgsLayerTreeGroup::resolveReferences( const QgsProject *project, bool looseMatching )
415{
416 for ( QgsLayerTreeNode *node : std::as_const( mChildren ) )
417 node->resolveReferences( project, looseMatching );
418
419 mGroupLayer.resolve( project );
420}
421
422static bool _nodeIsChecked( QgsLayerTreeNode *node )
423{
424 return node->itemVisibilityChecked();
425}
426
427
429{
430 return mMutuallyExclusive;
431}
432
433void QgsLayerTreeGroup::setIsMutuallyExclusive( bool enabled, int initialChildIndex )
434{
435 mMutuallyExclusive = enabled;
436 mMutuallyExclusiveChildIndex = initialChildIndex;
437
438 if ( !enabled )
439 {
440 return;
441 }
442
443 if ( mMutuallyExclusiveChildIndex < 0 || mMutuallyExclusiveChildIndex >= mChildren.count() )
444 {
445 // try to use first checked index
446 int index = 0;
447 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
448 {
449 if ( _nodeIsChecked( child ) )
450 {
452 break;
453 }
454 index++;
455 }
456 }
457
459}
460
462{
463 return qobject_cast< QgsGroupLayer * >( mGroupLayer.layer );
464}
465
467{
468 mGroupLayer.setLayer( layer );
469 refreshParentGroupLayerMembers();
470}
471
473{
474 if ( !mGroupLayer.layerId.isEmpty() )
475 return nullptr;
476
477 std::unique_ptr< QgsGroupLayer > res = std::make_unique< QgsGroupLayer >( name(), options );
478
479 mGroupLayer.setLayer( res.get() );
480 updateGroupLayers();
481
482 return res.release();
483}
484
485void QgsLayerTreeGroup::refreshParentGroupLayerMembers()
486{
487 QgsLayerTreeGroup *parentGroup = qobject_cast< QgsLayerTreeGroup * >( parent() );
488 while ( parentGroup )
489 {
490 if ( QgsLayerTree *layerTree = qobject_cast< QgsLayerTree * >( parentGroup ) )
491 layerTree->emit layerOrderChanged();
492
493 parentGroup->updateGroupLayers();
494 parentGroup = qobject_cast< QgsLayerTreeGroup * >( parentGroup->parent() );
495 }
496}
497
499{
500 QStringList lst;
501 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
502 {
503 if ( QgsLayerTree::isGroup( child ) )
504 lst << QgsLayerTree::toGroup( child )->findLayerIds();
505 else if ( QgsLayerTree::isLayer( child ) )
506 lst << QgsLayerTree::toLayer( child )->layerId();
507 }
508 return lst;
509}
510
512{
513 int childIndex = mChildren.indexOf( node );
514 if ( childIndex == -1 )
515 {
516 updateGroupLayers();
517 return; // not a direct child - ignore
518 }
519
520 if ( mMutuallyExclusive )
521 {
522 if ( _nodeIsChecked( node ) )
523 mMutuallyExclusiveChildIndex = childIndex;
524 else if ( mMutuallyExclusiveChildIndex == childIndex )
526
527 // we need to make sure there is only one child node checked
529 }
530
531 updateGroupLayers();
532}
533
535{
536 if ( mChildren.isEmpty() )
537 return;
538
539 mChangingChildVisibility = true; // guard against running again setVisible() triggered from children
540
541 int index = 0;
542 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
543 {
544 child->setItemVisibilityChecked( index == mMutuallyExclusiveChildIndex );
545 ++index;
546 }
547
549
550 updateGroupLayers();
551}
552
554{
556 // Reconnect internal signals
558}
559
560void QgsLayerTreeGroup::updateGroupLayers()
561{
562 QgsGroupLayer *groupLayer = qobject_cast< QgsGroupLayer * >( mGroupLayer.get() );
563 if ( !groupLayer )
564 return;
565
566 QList< QgsMapLayer * > layers;
567
568 std::function< void( QgsLayerTreeGroup * ) > findGroupLayerChildren;
569 findGroupLayerChildren = [&layers, &findGroupLayerChildren]( QgsLayerTreeGroup * group )
570 {
571 for ( auto it = group->mChildren.crbegin(); it != group->mChildren.crend(); ++it )
572 {
573 if ( QgsLayerTreeLayer *layerTreeLayer = qobject_cast< QgsLayerTreeLayer * >( *it ) )
574 {
575 if ( layerTreeLayer->layer() && layerTreeLayer->isVisible() )
576 layers << layerTreeLayer->layer();
577 }
578 else if ( QgsLayerTreeGroup *childGroup = qobject_cast< QgsLayerTreeGroup * >( *it ) )
579 {
580 if ( childGroup->isVisible() )
581 {
582 if ( QgsGroupLayer *groupLayer = childGroup->groupLayer() )
583 layers << groupLayer;
584 else
585 findGroupLayerChildren( childGroup );
586 }
587 }
588 }
589 };
590 findGroupLayerChildren( this );
591
592 groupLayer->setChildLayers( layers );
593 refreshParentGroupLayerMembers();
594}
595
597{
599
600 mChangingChildVisibility = true; // guard against running again setVisible() triggered from children
601
602 int index = 0;
603 for ( QgsLayerTreeNode *child : std::as_const( mChildren ) )
604 {
605 child->setItemVisibilityCheckedRecursive( checked && ( mMutuallyExclusiveChildIndex < 0 || index == mMutuallyExclusiveChildIndex ) );
606 ++index;
607 }
608
610
611 updateGroupLayers();
612}
A map layer which consists of a set of child layers, where all component layers are rendered as a sin...
Definition: qgsgrouplayer.h:42
void setChildLayers(const QList< QgsMapLayer * > &layers)
Sets the child layers contained by the group.
Layer tree group node serves as a container for layers and further groups.
void insertChildNode(int index, QgsLayerTreeNode *node)
Insert existing node at specified position.
void setName(const QString &n) override
Sets the group's name.
void resolveReferences(const QgsProject *project, bool looseMatching=false) override
Calls resolveReferences() on child tree nodes.
QgsLayerTreeGroup * findGroup(const QString &name)
Find group node with specified name.
QgsGroupLayer * convertToGroupLayer(const QgsGroupLayer::LayerOptions &options)
Converts the group to a QgsGroupLayer.
QgsLayerTreeGroup * insertGroup(int index, const QString &name)
Insert a new group node with given name at specified position.
void removeChildNode(QgsLayerTreeNode *node)
Remove a child node from this group.
QList< QgsLayerTreeGroup * > findGroups(bool recursive=false) const
Find group layer nodes.
void writeXml(QDomElement &parentElement, const QgsReadWriteContext &context) override
Write group (tree) as XML element <layer-tree-group> and add it to the given parent element.
QString name() const override
Returns the group's name.
QgsLayerTreeGroup(const QString &name=QString(), bool checked=true)
Constructor.
QStringList findLayerIds() const
Find layer IDs used in all layer nodes.
QList< QgsMapLayer * > layerOrderRespectingGroupLayers() const
Returns an ordered list of map layers in the group, ignoring any layers which are child layers of Qgs...
void addChildNode(QgsLayerTreeNode *node)
Append an existing node.
void insertChildNodes(int index, const QList< QgsLayerTreeNode * > &nodes)
Insert existing nodes at specified position.
void removeAllChildren()
Remove all child nodes.
bool mMutuallyExclusive
Whether the group is mutually exclusive (i.e. only one child can be checked at a time)
void setIsMutuallyExclusive(bool enabled, int initialChildIndex=-1)
Set whether the group is mutually exclusive (only one child can be checked at a time).
void readChildrenFromXml(QDomElement &element, const QgsReadWriteContext &context)
Read children from XML and append them to the group.
void setItemVisibilityCheckedRecursive(bool checked) override
Check or uncheck a node and all its children (taking into account exclusion rules)
QgsLayerTreeGroup * clone() const override
Returns a clone of the group.
QList< QgsLayerTreeLayer * > findLayers() const
Find all layer nodes.
QgsLayerTreeLayer * findLayer(QgsMapLayer *layer) const
Find layer node representing the map layer.
bool isMutuallyExclusive() const
Returns whether the group is mutually exclusive (only one child can be checked at a time)
void updateChildVisibilityMutuallyExclusive()
Set check state of children - if mutually exclusive.
static QgsLayerTreeGroup * readXml(QDomElement &element, const QgsReadWriteContext &context)
Read group (tree) from XML element <layer-tree-group> and return the newly created group (or nullptr ...
void setGroupLayer(QgsGroupLayer *layer)
Sets the associated group layer, if the layer tree group will be treated as group layer during map re...
QgsLayerTreeGroup * addGroup(const QString &name)
Append a new group node with given name.
void removeChildren(int from, int count)
Remove child nodes from index "from".
void removeChildrenGroupWithoutLayers()
Remove all child group nodes without layers.
QgsLayerTreeLayer * addLayer(QgsMapLayer *layer)
Append a new layer node for given map layer.
virtual void makeOrphan() override
Sets parent to nullptr and disconnects all external and forwarded signals.
void removeLayer(QgsMapLayer *layer)
Remove map layer's node from this group.
QgsLayerTreeLayer * insertLayer(int index, QgsMapLayer *layer)
Insert a new layer node for given map layer at specified position.
QString dump() const override
Returns text representation of the tree.
void nodeVisibilityChanged(QgsLayerTreeNode *node)
int mMutuallyExclusiveChildIndex
Keeps track which child has been most recently selected (so if the whole group is unchecked and check...
QgsGroupLayer * groupLayer()
Returns a reference to the associated group layer, if the layer tree group will be treated as group l...
Layer tree node points to a map layer.
QString layerId() const
Returns the ID for the map layer associated with this node.
QgsMapLayer * layer() const
Returns the map layer associated with this node.
This class is a base class for nodes in a layer tree.
void readCommonXml(QDomElement &element)
Read common XML elements.
virtual void makeOrphan()
Sets parent to nullptr and disconnects all external and forwarded signals.
@ NodeGroup
Container of other groups and layers.
void removedChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes has been removed from a node within the tree.
void nameChanged(QgsLayerTreeNode *node, QString name)
Emitted when the name of the node is changed.
static QgsLayerTreeNode * readXml(QDomElement &element, const QgsReadWriteContext &context)
Read layer tree from XML.
QList< QgsLayerTreeNode * > children()
Gets list of children of the node. Children are owned by the parent.
void setExpanded(bool expanded)
Sets whether the node should be shown as expanded or collapsed in GUI.
QgsLayerTreeNode * parent()
Gets pointer to the parent. If parent is nullptr, the node is a root node.
void writeCommonXml(QDomElement &element)
Write common XML elements.
void insertChildrenPrivate(int index, const QList< QgsLayerTreeNode * > &nodes)
Low-level insertion of children to the node. The children must not have any parent yet!
void addedChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes have been added to a node within the tree.
void visibilityChanged(QgsLayerTreeNode *node)
Emitted when check state of a node within the tree has been changed.
QList< QgsLayerTreeNode * > mChildren
list of children - node is responsible for their deletion
bool mExpanded
whether the node should be shown in GUI as expanded
bool isExpanded() const
Returns whether the node should be shown as expanded or collapsed in GUI.
void setItemVisibilityChecked(bool checked)
Check or uncheck a node (independently of its ancestors or children)
bool itemVisibilityChecked() const
Returns whether a node is checked (independently of its ancestors or children)
void removeChildrenPrivate(int from, int count, bool destroy=true)
Low-level removal of children from the node.
static Qt::CheckState checkStateFromXml(const QString &txt)
Convert QString to Qt::CheckState.
Namespace with helper functions for layer tree operations.
Definition: qgslayertree.h:33
static QgsLayerTreeLayer * toLayer(QgsLayerTreeNode *node)
Cast node to a layer.
Definition: qgslayertree.h:75
static bool isLayer(const QgsLayerTreeNode *node)
Check whether the node is a valid layer node.
Definition: qgslayertree.h:53
static bool isGroup(QgsLayerTreeNode *node)
Check whether the node is a valid group node.
Definition: qgslayertree.h:43
static QgsLayerTreeGroup * toGroup(QgsLayerTreeNode *node)
Cast node to a group.
Definition: qgslayertree.h:64
Base class for all map layer types.
Definition: qgsmaplayer.h:73
virtual bool isSpatial() const
Returns true if the layer is considered a spatial layer, ie it has some form of geometry associated w...
QString id() const
Returns the layer's unique ID, which is used to access this layer from QgsProject.
virtual QString translate(const QString &context, const QString &sourceText, const char *disambiguation=nullptr, int n=-1) const =0
The derived translate() translates with QTranslator and qm file the sourceText.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
Definition: qgsproject.h:104
The class is used as a container of context for various read/write operations on other objects.
const QgsProjectTranslator * projectTranslator() const
Returns the project translator.
QgsLayerTree * layerTree(const QgsWmsRenderContext &context)
_LayerRef< QgsMapLayer > QgsMapLayerRef
Setting options for loading group layers.
Definition: qgsgrouplayer.h:52
TYPE * get() const
Returns a pointer to the layer, or nullptr if the reference has not yet been matched to a layer.
QPointer< TYPE > layer
Weak pointer to map layer.
TYPE * resolve(const QgsProject *project)
Resolves the map layer by attempting to find a layer with matching ID within a project.
void setLayer(TYPE *l)
Sets the reference to point to a specified layer.
QString layerId
Original layer ID.