QGIS API Documentation  2.99.0-Master (53aba61)
qgslayertreenode.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  qgslayertreenode.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 "qgslayertreenode.h"
17 
18 #include "qgslayertree.h"
19 #include "qgslayertreeutils.h"
20 
21 #include <QDomElement>
22 #include <QStringList>
23 
24 
26  : mNodeType( t )
27  , mChecked( checked )
28  , mExpanded( true )
29 {
30 }
31 
33  : QObject()
34  , mNodeType( other.mNodeType )
35  , mChecked( other.mChecked )
36  , mExpanded( other.mExpanded )
37  , mProperties( other.mProperties )
38 {
39  QList<QgsLayerTreeNode *> clonedChildren;
40  Q_FOREACH ( QgsLayerTreeNode *child, other.mChildren )
41  clonedChildren << child->clone();
42  insertChildrenPrivate( -1, clonedChildren );
43 }
44 
46 {
47  qDeleteAll( mChildren );
48 }
49 
51 {
52  QgsLayerTreeNode *node = nullptr;
53  if ( element.tagName() == QLatin1String( "layer-tree-group" ) )
54  node = QgsLayerTreeGroup::readXml( element );
55  else if ( element.tagName() == QLatin1String( "layer-tree-layer" ) )
56  node = QgsLayerTreeLayer::readXml( element );
57 
58  return node;
59 }
60 
61 QgsLayerTreeNode *QgsLayerTreeNode::readXml( QDomElement &element, const QgsProject *project )
62 {
63  QgsLayerTreeNode *node = readXml( element );
64  if ( node )
65  node->resolveReferences( project );
66  return node;
67 }
68 
69 
71 {
72  if ( mChecked == checked )
73  return;
74  mChecked = checked;
75  emit visibilityChanged( this );
76 }
77 
79 {
80  setItemVisibilityChecked( checked );
81 }
82 
84 {
85  setItemVisibilityChecked( checked );
86  if ( mParent )
88 }
89 
91 {
92  return mChecked && ( !mParent || mParent->isVisible() );
93 }
94 
95 
97 {
98  return mExpanded;
99 }
100 
102 {
103  if ( !mChecked )
104  return false;
105  Q_FOREACH ( QgsLayerTreeNode *child, mChildren )
106  {
107  if ( !child->isItemVisibilityCheckedRecursive() )
108  return false;
109  }
110 
111  return true;
112 }
113 
115 {
116  if ( mChecked )
117  return false;
118  Q_FOREACH ( QgsLayerTreeNode *child, mChildren )
119  {
120  if ( !child->isItemVisibilityUncheckedRecursive() )
121  return false;
122  }
123 
124  return true;
125 }
126 
127 void fetchCheckedLayers( const QgsLayerTreeNode *node, QList<QgsMapLayer *> &layers )
128 {
129  if ( QgsLayerTree::isLayer( node ) )
130  {
131  const QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
132  if ( nodeLayer->isVisible() )
133  layers << nodeLayer->layer();
134  }
135 
136  Q_FOREACH ( QgsLayerTreeNode *child, node->children() )
137  fetchCheckedLayers( child, layers );
138 }
139 
140 QList<QgsMapLayer *> QgsLayerTreeNode::checkedLayers() const
141 {
142  QList<QgsMapLayer *> layers;
143  fetchCheckedLayers( this, layers );
144  return layers;
145 }
146 
147 void QgsLayerTreeNode::setExpanded( bool expanded )
148 {
149  if ( mExpanded == expanded )
150  return;
151 
152  mExpanded = expanded;
153  emit expandedChanged( this, expanded );
154 }
155 
156 
157 void QgsLayerTreeNode::setCustomProperty( const QString &key, const QVariant &value )
158 {
159  mProperties.setValue( key, value );
160  emit customPropertyChanged( this, key );
161 }
162 
163 QVariant QgsLayerTreeNode::customProperty( const QString &key, const QVariant &defaultValue ) const
164 {
165  return mProperties.value( key, defaultValue );
166 }
167 
168 void QgsLayerTreeNode::removeCustomProperty( const QString &key )
169 {
170  mProperties.remove( key );
171  emit customPropertyChanged( this, key );
172 }
173 
175 {
176  return mProperties.keys();
177 }
178 
179 void QgsLayerTreeNode::readCommonXml( QDomElement &element )
180 {
181  mProperties.readXml( element );
182 }
183 
184 void QgsLayerTreeNode::writeCommonXml( QDomElement &element )
185 {
186  QDomDocument doc( element.ownerDocument() );
187  mProperties.writeXml( element, doc );
188 }
189 
190 void QgsLayerTreeNode::insertChildrenPrivate( int index, QList<QgsLayerTreeNode *> nodes )
191 {
192  if ( nodes.isEmpty() )
193  return;
194 
195  Q_FOREACH ( QgsLayerTreeNode *node, nodes )
196  {
197  Q_ASSERT( !node->mParent );
198  node->mParent = this;
199  }
200 
201  if ( index < 0 || index >= mChildren.count() )
202  index = mChildren.count();
203 
204  int indexTo = index + nodes.count() - 1;
205  emit willAddChildren( this, index, indexTo );
206  for ( int i = 0; i < nodes.count(); ++i )
207  {
208  QgsLayerTreeNode *node = nodes.at( i );
209  mChildren.insert( index + i, node );
210 
211  // forward the signal towards the root
220  }
221  emit addedChildren( this, index, indexTo );
222 }
223 
224 void QgsLayerTreeNode::removeChildrenPrivate( int from, int count, bool destroy )
225 {
226  if ( from < 0 || count <= 0 )
227  return;
228 
229  int to = from + count - 1;
230  if ( to >= mChildren.count() )
231  return;
232  emit willRemoveChildren( this, from, to );
233  while ( --count >= 0 )
234  {
235  QgsLayerTreeNode *node = mChildren.takeAt( from );
236  node->mParent = nullptr;
237  if ( destroy )
238  delete node;
239  }
240  emit removedChildren( this, from, to );
241 }
242 
244 {
245  int index = mChildren.indexOf( node );
246  if ( index < 0 )
247  return false;
248 
249  int n = mChildren.size();
250 
251  removeChildrenPrivate( index, 1, false );
252 
253  return mChildren.size() < n;
254 }
static QgsLayerTreeLayer * toLayer(QgsLayerTreeNode *node)
Cast node to a layer.
Definition: qgslayertree.h:74
bool isItemVisibilityUncheckedRecursive() const
Return whether this node is unchecked and all its children.
void readXml(const QDomNode &parentNode, const QString &keyStartsWith=QString())
Read store contents from XML.
void insertChildrenPrivate(int index, QList< QgsLayerTreeNode *> nodes)
Low-level insertion of children to the node. The children must not have any parent yet! ...
bool takeChild(QgsLayerTreeNode *node)
Remove a child from a node.
virtual QgsLayerTreeNode * clone() const =0
Create a copy of the node. Returns new instance.
bool mExpanded
whether the node should be shown in GUI as expanded
void willRemoveChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes will be removed from a node within the tree.
bool isVisible() const
Returns whether a node is really visible (ie checked and all its ancestors checked as well) ...
QVariant value(const QString &key, const QVariant &defaultValue=QVariant()) const
Return value for the given key. If the key is not stored, default value will be used.
static QgsLayerTreeGroup * readXml(QDomElement &element)
Read group (tree) from XML element <layer-tree-group> and return the newly created group (or null on ...
void writeXml(QDomNode &parentNode, QDomDocument &doc) const
Write store contents to XML.
bool isExpanded() const
Return whether the node should be shown as expanded or collapsed in GUI.
NodeType
Enumeration of possible tree node types.
QStringList customProperties() const
Return list of keys stored in custom properties.
void remove(const QString &key)
Remove a key (entry) from the store.
void willAddChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes will be added to a node within the tree.
QList< QgsMapLayer *> checkedLayers() const
Returns a list of any checked layers which belong to this node or its children.
void removedChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes has been removed from a node within the tree.
NodeType mNodeType
type of the node - determines which subclass is used
virtual void setItemVisibilityCheckedRecursive(bool checked)
Check or uncheck a node and all its children (taking into account exclusion rules) ...
void setValue(const QString &key, const QVariant &value)
Add an entry to the store. If the entry with the keys exists already, it will be overwritten.
QList< QgsLayerTreeNode * > children()
Get list of children of the node. Children are owned by the parent.
void expandedChanged(QgsLayerTreeNode *node, bool expanded)
Emitted when the collapsed/expanded state of a node within the tree has been changed.
void addedChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes have been added to a node within the tree.
void writeCommonXml(QDomElement &element)
Write common XML elements.
QVariant customProperty(const QString &key, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer. Properties are stored in a map and saved in project file...
static QgsLayerTreeLayer * readXml(QDomElement &element)
Read layer node from XML.
QgsLayerTreeNode * mParent
pointer to the parent node - null in case of root node
static QgsLayerTreeNode * readXml(QDomElement &element)
Read layer tree from XML.
static bool isLayer(const QgsLayerTreeNode *node)
Check whether the node is a valid layer node.
Definition: qgslayertree.h:52
This class is a base class for nodes in a layer tree.
Reads and writes project states.
Definition: qgsproject.h:79
void removeCustomProperty(const QString &key)
Remove a custom property from layer. Properties are stored in a map and saved in project file...
QStringList keys() const
Return list of stored keys.
void setExpanded(bool expanded)
Set whether the node should be shown as expanded or collapsed in GUI.
void setItemVisibilityCheckedParentRecursive(bool checked)
Check or uncheck a node and all its parents.
void removeChildrenPrivate(int from, int count, bool destroy=true)
Low-level removal of children from the node.
bool isItemVisibilityCheckedRecursive() const
Return whether this node is checked and all its children.
QgsMapLayer * layer() const
void visibilityChanged(QgsLayerTreeNode *node)
Emitted when check state of a node within the tree has been changed.
void readCommonXml(QDomElement &element)
Read common XML elements.
virtual void resolveReferences(const QgsProject *project, bool looseMatching=false)=0
Turn textual references to layers into map layer object from project.
void setItemVisibilityChecked(bool checked)
Check or uncheck a node (independently of its ancestors or children)
void fetchCheckedLayers(const QgsLayerTreeNode *node, QList< QgsMapLayer *> &layers)
QList< QgsLayerTreeNode * > mChildren
list of children - node is responsible for their deletion
void customPropertyChanged(QgsLayerTreeNode *node, const QString &key)
Emitted when a custom property of a node within the tree has been changed or removed.
void nameChanged(QgsLayerTreeNode *node, QString name)
Emitted when the name of the node is changed.
QgsLayerTreeNode(NodeType t, bool checked=true)
Constructor.
void setCustomProperty(const QString &key, const QVariant &value)
Set a custom property for the node. Properties are stored in a map and saved in project file...
Layer tree node points to a map layer.
QgsObjectCustomProperties mProperties
custom properties attached to the node