QGIS API Documentation 4.3.0-Master (0cef2469b72)
Loading...
Searching...
No Matches
qgslayertreemodel.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgslayertreemodel.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 "qgslayertreemodel.h"
17
18#include "qgsapplication.h"
20#include "qgsiconutils.h"
21#include "qgslayerdefinition.h"
22#include "qgslayertree.h"
25#include "qgslayertreeutils.h"
26#include "qgslayoutitemlegend.h"
27#include "qgsmaphittest.h"
28#include "qgsmaplayer.h"
30#include "qgsmaplayerlegend.h"
31#include "qgsmaplayerstyle.h"
32#include "qgsmimedatautils.h"
33#include "qgsproject.h"
34#include "qgsrendercontext.h"
36#include "qgsvectorlayer.h"
37
38#include <QMimeData>
39#include <QPalette>
40#include <QString>
41#include <QTextStream>
42
43#include "moc_qgslayertreemodel.cpp"
44
45using namespace Qt::StringLiterals;
46
48 : QAbstractItemModel( parent )
49 , mRootNode( rootNode )
51{
52 if ( rootNode )
53 {
55 }
56
57 mFontLayer.setBold( true );
58
60 mDeferLegendInvalidationTimer.setSingleShot( true );
61}
62
67
69{
70 if ( !index.isValid() )
71 return mRootNode;
72
73 QObject *obj = reinterpret_cast<QObject *>( index.internalPointer() );
74 return qobject_cast<QgsLayerTreeNode *>( obj );
75}
76
77
78int QgsLayerTreeModel::rowCount( const QModelIndex &parent ) const
79{
81 return legendNodeRowCount( nodeLegend );
82
84 if ( !n )
85 return 0;
86
87 if ( QgsLayerTree::isLayer( n ) )
88 {
89 if ( !testFlag( ShowLegend ) )
90 return 0;
91
93 }
94
95 return n->children().count();
96}
97
98int QgsLayerTreeModel::columnCount( const QModelIndex &parent ) const
99{
100 Q_UNUSED( parent )
101 return 1;
102}
103
104QModelIndex QgsLayerTreeModel::index( int row, int column, const QModelIndex &parent ) const
105{
106 if ( column < 0 || column >= columnCount( parent ) || row < 0 || row >= rowCount( parent ) )
107 return QModelIndex();
108
110 return legendNodeIndex( row, column, nodeLegend );
111
113 if ( !n )
114 return QModelIndex(); // have no children
115
117 {
118 return legendRootIndex( row, column, QgsLayerTree::toLayer( n ) );
119 }
120
121 return createIndex( row, column, static_cast<QObject *>( n->children().at( row ) ) );
122}
123
124
125QModelIndex QgsLayerTreeModel::parent( const QModelIndex &child ) const
126{
127 if ( !child.isValid() )
128 return QModelIndex();
129
130 if ( QgsLayerTreeNode *n = index2node( child ) )
131 {
132 return indexOfParentLayerTreeNode( n->parent() ); // must not be null
133 }
134 else if ( QgsLayerTreeModelLegendNode *legendNode = index2legendNode( child ) )
135 {
136 return legendParent( legendNode );
137 }
138 else
139 {
140 Q_ASSERT( false ); // no other node types!
141 return QModelIndex();
142 }
143}
144
145
147{
148 Q_ASSERT( parentNode );
149
150 QgsLayerTreeNode *grandParentNode = parentNode->parent();
151 if ( !grandParentNode )
152 return QModelIndex(); // root node -> invalid index
153
154 int row = grandParentNode->children().indexOf( parentNode );
155 Q_ASSERT( row >= 0 );
156
157 return createIndex( row, 0, static_cast<QObject *>( parentNode ) );
158}
159
160
161QVariant QgsLayerTreeModel::data( const QModelIndex &index, int role ) const
162{
163 if ( !index.isValid() || index.column() > 1 )
164 return QVariant();
165
167 return legendNodeData( sym, role );
168
170 if ( role == Qt::DisplayRole || role == Qt::EditRole )
171 {
172 if ( QgsLayerTree::isGroup( node ) )
173 return QgsLayerTree::toGroup( node )->name();
174
175 if ( QgsLayerTree::isLayer( node ) )
176 {
177 QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
178 QString name = nodeLayer->name();
179 QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( nodeLayer->layer() );
180 if ( vlayer && nodeLayer->customProperty( u"showFeatureCount"_s, 0 ).toInt() && role == Qt::DisplayRole )
181 {
182 const bool estimatedCount = vlayer->dataProvider() ? QgsDataSourceUri( vlayer->dataProvider()->dataSourceUri() ).useEstimatedMetadata() : false;
183 const qlonglong count = vlayer->featureCount();
184
185 // if you modify this line, please update QgsSymbolLegendNode::updateLabel
186 name += u" [%1%2]"_s.arg( estimatedCount ? u"≈"_s : QString(), count != -1 ? QLocale().toString( count ) : tr( "N/A" ) );
187 }
188 return name;
189 }
190
191 if ( QgsLayerTree::isCustomNode( node ) )
192 {
193 return QgsLayerTree::toCustomNode( node )->name();
194 }
195 }
196 else if ( role == Qt::DecorationRole && index.column() == 0 )
197 {
198 if ( QgsLayerTree::isGroup( node ) )
199 {
200 const QString iconPath = node->customProperty( u"icon"_s ).toString();
201 if ( !iconPath.isEmpty() )
202 {
203 auto it = mNodeIcons.constFind( iconPath );
204 if ( it == mNodeIcons.constEnd() )
205 {
206 it = mNodeIcons.insert( iconPath, QIcon( iconPath ) );
207 }
208
209 return it->isNull() ? iconGroup() : *it;
210 }
211
212 return iconGroup();
213 }
214
215 if ( QgsLayerTree::isLayer( node ) )
216 {
217 QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
218
219 QgsMapLayer *layer = nodeLayer->layer();
220 if ( !layer )
221 return QVariant();
222
223 QIcon icon;
224
225 const QString iconPath = node->customProperty( u"icon"_s ).toString();
226 if ( !iconPath.isEmpty() )
227 {
228 auto it = mNodeIcons.constFind( iconPath );
229 if ( it == mNodeIcons.constEnd() )
230 {
231 it = mNodeIcons.insert( iconPath, QIcon( iconPath ) );
232 }
233
234 icon = it->isNull() ? QgsIconUtils::iconForLayer( layer ) : *it;
235 }
236 else
237 {
238 icon = QgsIconUtils::iconForLayer( layer );
239 }
240
241 // if there's just on legend entry that should be embedded in layer - do that!
242 if ( testFlag( ShowLegend ) && legendEmbeddedInParent( nodeLayer ) )
243 {
244 icon = legendIconEmbeddedInParent( nodeLayer );
245 }
246
247 if ( !icon.isNull() && layer->isEditable() && !( layer->properties() & Qgis::MapLayerProperty::UsersCannotToggleEditing ) && testFlag( UseTextFormatting ) )
248 {
249 const int iconSize = scaleIconSize( 16 );
250 QPixmap pixmap( icon.pixmap( iconSize, iconSize ) );
251
252 QPainter painter( &pixmap );
253 painter.drawPixmap( 0, 0, iconSize, iconSize, QgsApplication::getThemePixmap( layer->isModified() ? u"/mIconEditableEdits.svg"_s : u"/mActionToggleEditing.svg"_s ) );
254 painter.end();
255
256 icon = QIcon( pixmap );
257 }
258
259 return icon;
260 }
261 }
262 else if ( role == Qt::CheckStateRole )
263 {
265 return QVariant();
266
267 if ( QgsLayerTree::isLayer( node ) )
268 {
269 QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
270
271 if ( nodeLayer->layer() && !nodeLayer->layer()->isSpatial() )
272 return QVariant(); // do not show checkbox for non-spatial tables
273
274 return nodeLayer->itemVisibilityChecked() ? Qt::Checked : Qt::Unchecked;
275 }
276 else if ( QgsLayerTree::isGroup( node ) )
277 {
278 QgsLayerTreeGroup *nodeGroup = QgsLayerTree::toGroup( node );
279 return nodeGroup->itemVisibilityChecked() ? Qt::Checked : Qt::Unchecked;
280 }
281 else if ( QgsLayerTree::isCustomNode( node ) )
282 {
283 return node->itemVisibilityChecked() ? Qt::Checked : Qt::Unchecked;
284 }
285 }
286 else if ( role == Qt::FontRole && testFlag( UseTextFormatting ) )
287 {
288 QFont f( QgsLayerTree::isLayer( node ) ? mFontLayer : ( QgsLayerTree::isGroup( node ) || QgsLayerTree::isCustomNode( node ) ? mFontGroup : QFont() ) );
289 if ( index == mCurrentIndex )
290 f.setUnderline( true );
291 if ( QgsLayerTree::isLayer( node ) )
292 {
293 const QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer();
294 if ( ( !node->isVisible() && ( !layer || layer->isSpatial() ) ) || ( layer && !layer->isInScaleRange( mLegendMapViewScale ) ) )
295 {
296 f.setItalic( !f.italic() );
297 }
298 }
299 return f;
300 }
301 else if ( role == Qt::ForegroundRole && testFlag( UseTextFormatting ) )
302 {
303 QBrush brush( qApp->palette().color( QPalette::Text ), Qt::SolidPattern );
304 if ( QgsLayerTree::isLayer( node ) )
305 {
306 const QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer();
307 if ( ( !node->isVisible() && ( !layer || layer->isSpatial() ) ) || ( layer && !layer->isInScaleRange( mLegendMapViewScale ) ) )
308 {
309 QColor fadedTextColor = brush.color();
310 fadedTextColor.setAlpha( 128 );
311 brush.setColor( fadedTextColor );
312 }
313 }
314 return brush;
315 }
316 else if ( role == Qt::ToolTipRole )
317 {
318 if ( QgsLayerTree::isLayer( node ) )
319 {
320 if ( QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer() )
321 {
322 QString title = !layer->metadata().title().isEmpty() ? layer->metadata().title()
323 : !layer->serverProperties()->title().isEmpty() ? layer->serverProperties()->title()
324 : !layer->serverProperties()->shortName().isEmpty() ? layer->serverProperties()->shortName()
325 : layer->name();
326
327 title = "<b>" + title.toHtmlEscaped() + "</b>";
328
329 if ( layer->isSpatial() && layer->crs().isValid() )
330 {
331 const QString layerCrs = layer->crs().userFriendlyIdentifier( Qgis::CrsIdentifierType::ShortString );
332 if ( QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( layer ) )
333 title += tr( " (%1 - %2)" ).arg( QgsWkbTypes::displayString( vl->wkbType() ), layerCrs ).toHtmlEscaped();
334 else
335 title += tr( " (%1)" ).arg( layerCrs ).toHtmlEscaped();
336 }
337
338 QStringList parts;
339 parts << title;
340
341 const QString abstract = !layer->metadata().abstract().isEmpty() ? layer->metadata().abstract() : layer->serverProperties()->abstract();
342 if ( !abstract.isEmpty() )
343 {
344 parts << QString();
345 const QStringList abstractLines = abstract.split( '\n' );
346 for ( const auto &l : abstractLines )
347 {
348 parts << l.toHtmlEscaped();
349 }
350 parts << QString();
351 }
352
353 QString source( layer->publicSource() );
354 if ( source.size() > 1024 )
355 {
356 source = source.left( 1023 ) + QString( QChar( 0x2026 ) );
357 }
358
359 parts << "<i>" + source.toHtmlEscaped() + "</i>";
360
361 QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
362 const bool showFeatureCount = nodeLayer->customProperty( u"showFeatureCount"_s, 0 ).toBool();
363 const bool estimatedCount = layer->dataProvider() ? QgsDataSourceUri( layer->dataProvider()->dataSourceUri() ).useEstimatedMetadata() : false;
364 if ( showFeatureCount && estimatedCount )
365 {
366 parts << tr( "<b>Feature count is estimated</b> : the feature count is determined by the database statistics" );
367 }
368
370 {
371 parts << tr( "ID: %1" ).arg( layer->id() );
372 }
373
374 return parts.join( "<br/>"_L1 );
375 }
376 }
377 }
378
379 return QVariant();
380}
381
382
383Qt::ItemFlags QgsLayerTreeModel::flags( const QModelIndex &index ) const
384{
385 if ( !index.isValid() )
386 {
387 Qt::ItemFlags rootFlags = Qt::ItemFlags();
388 if ( testFlag( AllowNodeReorder ) )
389 rootFlags |= Qt::ItemIsDropEnabled;
390 return rootFlags;
391 }
392
394 return legendNodeFlags( symn );
395
396 Qt::ItemFlags f = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
397
398 if ( testFlag( AllowNodeRename ) )
399 f |= Qt::ItemIsEditable;
400
402 bool isEmbedded = node->customProperty( u"embedded"_s ).toInt();
403
404 if ( testFlag( AllowNodeReorder ) )
405 {
406 // only root embedded nodes can be reordered
407 if ( !isEmbedded || ( isEmbedded && node->parent() && !node->parent()->customProperty( u"embedded"_s ).toInt() ) )
408 f |= Qt::ItemIsDragEnabled;
409 }
410
412 f |= Qt::ItemIsUserCheckable;
413
414 if ( testFlag( AllowNodeReorder ) && QgsLayerTree::isGroup( node ) && !isEmbedded )
415 f |= Qt::ItemIsDropEnabled;
416
417 return f;
418}
419
420bool QgsLayerTreeModel::setData( const QModelIndex &index, const QVariant &value, int role )
421{
423 if ( sym )
424 {
425 if ( role == Qt::CheckStateRole && !testFlag( AllowLegendChangeState ) )
426 return false;
427 bool res = sym->setData( value, role );
428 if ( res )
429 emit dataChanged( index, index );
430 return res;
431 }
432
434 if ( !node )
435 return QAbstractItemModel::setData( index, value, role );
436
437 if ( role == Qt::CheckStateRole )
438 {
440 return false;
441
442 bool checked = static_cast< Qt::CheckState >( value.toInt() ) == Qt::Checked;
443 if ( checked && node->children().isEmpty() )
444 {
446 }
447 else if ( testFlag( ActionHierarchical ) )
448 {
449 if ( node->children().isEmpty() )
451 else
452 node->setItemVisibilityCheckedRecursive( checked );
453 }
454 else
455 {
456 node->setItemVisibilityChecked( checked );
457 }
458
460
461 return true;
462 }
463 else if ( role == Qt::EditRole )
464 {
465 if ( !testFlag( AllowNodeRename ) )
466 return false;
467
468 if ( QgsLayerTree::isLayer( node ) )
469 {
471 layer->setName( value.toString() );
472 emit dataChanged( index, index );
473 }
474 else if ( QgsLayerTree::isGroup( node ) )
475 {
476 QgsLayerTree::toGroup( node )->setName( value.toString() );
477 emit dataChanged( index, index );
478 }
479 else if ( QgsLayerTree::isCustomNode( node ) )
480 {
481 QgsLayerTree::toCustomNode( node )->setName( value.toString() );
482 emit dataChanged( index, index );
483 }
484 }
485
486 return QAbstractItemModel::setData( index, value, role );
487}
488
490{
491 if ( !node || !node->parent() )
492 return QModelIndex(); // this is the only root item -> invalid index
493
494 QModelIndex parentIndex = node2index( node->parent() );
495
496 int row = node->parent()->children().indexOf( node );
497 Q_ASSERT( row >= 0 );
498 return index( row, 0, parentIndex );
499}
500
501
502static bool _isChildOfNode( QgsLayerTreeNode *child, QgsLayerTreeNode *node )
503{
504 if ( !child->parent() )
505 return false;
506
507 if ( child->parent() == node )
508 return true;
509
510 return _isChildOfNode( child->parent(), node );
511}
512
513static bool _isChildOfNodes( QgsLayerTreeNode *child, const QList<QgsLayerTreeNode *> &nodes )
514{
515 for ( QgsLayerTreeNode *n : nodes )
516 {
517 if ( _isChildOfNode( child, n ) )
518 return true;
519 }
520
521 return false;
522}
523
524
525QList<QgsLayerTreeNode *> QgsLayerTreeModel::indexes2nodes( const QModelIndexList &list, bool skipInternal ) const
526{
527 QList<QgsLayerTreeNode *> nodes;
528 const auto constList = list;
529 for ( const QModelIndex &index : constList )
530 {
532 if ( !node )
533 continue;
534
535 nodes << node;
536 }
537
538 if ( !skipInternal )
539 return nodes;
540
541 // remove any children of nodes if both parent node and children are selected
542 QList<QgsLayerTreeNode *> nodesFinal;
543 for ( QgsLayerTreeNode *node : std::as_const( nodes ) )
544 {
545 if ( !_isChildOfNodes( node, nodes ) )
546 nodesFinal << node;
547 }
548
549 return nodesFinal;
550}
551
556
558{
559 beginResetModel();
560
562
563 Q_ASSERT( mLegend.isEmpty() );
564
565 mRootNode = newRootGroup;
566
567 endResetModel();
568
570}
571
573{
574 // update title
575 QModelIndex idx = node2index( nodeLayer );
576 emit dataChanged( idx, idx );
577
578 // update children
579 int oldNodeCount = rowCount( idx );
580 if ( oldNodeCount > 0 )
581 {
582 beginRemoveRows( idx, 0, oldNodeCount - 1 );
583 removeLegendFromLayer( nodeLayer );
584 endRemoveRows();
585 }
586
587 addLegendToLayer( nodeLayer );
588 int newNodeCount = rowCount( idx );
589
590 // automatic collapse of legend nodes - useful if a layer has many legend nodes
591 if ( mAutoCollapseLegendNodesCount != -1 && oldNodeCount != newNodeCount && newNodeCount >= mAutoCollapseLegendNodesCount )
592 nodeLayer->setExpanded( false );
593}
594
596{
597 return mCurrentIndex;
598}
599
604
605
606void QgsLayerTreeModel::setLayerTreeNodeFont( int nodeType, const QFont &font )
607{
608 if ( nodeType == QgsLayerTreeNode::NodeGroup )
609 {
610 if ( mFontGroup != font )
611 {
612 mFontGroup = font;
614 }
615 }
616 else if ( nodeType == QgsLayerTreeNode::NodeLayer )
617 {
618 if ( mFontLayer != font )
619 {
620 mFontLayer = font;
622 }
623 }
624 else
625 {
626 QgsDebugMsgLevel( u"invalid node type"_s, 4 );
627 }
628}
629
630
631QFont QgsLayerTreeModel::layerTreeNodeFont( int nodeType ) const
632{
633 if ( nodeType == QgsLayerTreeNode::NodeGroup )
634 return mFontGroup;
635 else if ( nodeType == QgsLayerTreeNode::NodeLayer )
636 return mFontLayer;
637 else
638 {
639 QgsDebugMsgLevel( u"invalid node type"_s, 4 );
640 return QFont();
641 }
642}
643
645{
646 mLegendFilterByScale = scale;
647
648 // this could be later done in more efficient way
649 // by just updating active legend nodes, without refreshing original legend nodes
650 const auto layers = mRootNode->findLayers();
651 for ( QgsLayerTreeLayer *nodeLayer : layers )
652 refreshLayerLegend( nodeLayer );
653}
654
656{
658 setLegendFilter( settings, /* useExtent = */ true );
660}
661
662void QgsLayerTreeModel::setLegendFilter( const QgsMapSettings *settings, bool useExtent, const QgsGeometry &polygon, bool useExpressions )
663{
664 if ( settings && settings->hasValidSettings() )
665 {
666 auto filterSettings = std::make_unique< QgsLayerTreeFilterSettings >( *settings );
667
668 if ( !useExtent ) // only expressions
669 {
671 }
672 else if ( polygon.type() == Qgis::GeometryType::Polygon )
673 {
674 filterSettings->setFilterPolygon( polygon );
675 }
676
677 if ( useExpressions )
678 {
679 filterSettings->setLayerFilterExpressionsFromLayerTree( mRootNode );
680 }
681
683 }
684 else
685 {
686 setFilterSettings( nullptr );
687 }
688}
689
691{
692 return mFilterSettings ? &mFilterSettings->mapSettings() : nullptr;
693}
694
696{
697 if ( settings )
698 {
699 mFilterSettings = std::make_unique< QgsLayerTreeFilterSettings >( *settings );
700 mFilterSettings->mapSettings().setLayerStyleOverrides( mLayerStyleOverrides );
701
702 bool hitTestWasRunning = false;
703 if ( mHitTestTask )
704 {
705 // cancel outdated task -- this is owned by the task manager and will get automatically deleted accordingly
706 disconnect( mHitTestTask, &QgsTask::taskCompleted, this, &QgsLayerTreeModel::hitTestTaskCompleted );
707 mHitTestTask->cancel();
708 mHitTestTask = nullptr;
709 hitTestWasRunning = true;
710 }
711
713 {
715 connect( mHitTestTask, &QgsTask::taskCompleted, this, &QgsLayerTreeModel::hitTestTaskCompleted );
717
718 if ( !hitTestWasRunning )
719 emit hitTestStarted();
720 }
721 else
722 {
723 auto blockingHitTest = std::make_unique< QgsMapHitTest >( *mFilterSettings );
724 blockingHitTest->run();
725 mHitTestResults = blockingHitTest->results();
726 mHitTestResultsRendererUpdatedCanvas = blockingHitTest->resultsRenderersUpdatedCanvas();
727 handleHitTestResults();
728 }
729 }
730 else
731 {
732 if ( !mFilterSettings )
733 return;
734
735 mFilterSettings.reset();
736 handleHitTestResults();
737 }
738}
739
744
745void QgsLayerTreeModel::handleHitTestResults()
746{
747 // temporarily disable autocollapse so that legend nodes stay visible
748 int bkAutoCollapse = autoCollapseLegendNodes();
750
751 // this could be later done in more efficient way
752 // by just updating active legend nodes, without refreshing original legend nodes
753 const auto layers = mRootNode->findLayers();
754 for ( QgsLayerTreeLayer *nodeLayer : layers )
755 refreshLayerLegend( nodeLayer );
756
757 setAutoCollapseLegendNodes( bkAutoCollapse );
758
759 // update any color ramp legend nodes with new min/max from hit test
761 {
762 const QList<QgsLayerTreeLayer *> treeLayers = rootGroup()->findLayers();
763
764 for ( QgsLayerTreeLayer *layerTreeLayer : treeLayers )
765 {
766 const QList<QgsLayerTreeModelLegendNode *> legendNodes = layerLegendNodes( layerTreeLayer );
767
768 if ( mHitTestResultsRendererUpdatedCanvas.contains( layerTreeLayer->layerId() ) )
769 {
770 QPair<double, double> limits = mHitTestResultsRendererUpdatedCanvas.value( layerTreeLayer->layerId() );
771
772 for ( QgsLayerTreeModelLegendNode *legendNode : legendNodes )
773 {
774 if ( auto *colorRampNode = dynamic_cast<QgsColorRampLegendNode *>( legendNode ) )
775 {
776 colorRampNode->setMinimum( limits.first );
777 colorRampNode->setMaximum( limits.second );
778 }
779 }
780 }
781 }
782 }
783}
784
785void QgsLayerTreeModel::setLegendMapViewData( double mapUnitsPerPixel, int dpi, double scale )
786{
787 if ( mLegendMapViewDpi == dpi && qgsDoubleNear( mLegendMapViewMupp, mapUnitsPerPixel ) && qgsDoubleNear( mLegendMapViewScale, scale ) )
788 return;
789
790 double previousScale = mLegendMapViewScale;
791 mLegendMapViewScale = scale;
792 mLegendMapViewMupp = mapUnitsPerPixel;
793 mLegendMapViewDpi = dpi;
794
795 // now invalidate legend nodes!
797
798 if ( scale != previousScale )
799 refreshScaleBasedLayers( QModelIndex(), previousScale );
800}
801
802void QgsLayerTreeModel::legendMapViewData( double *mapUnitsPerPixel, int *dpi, double *scale ) const
803{
804 if ( mapUnitsPerPixel )
805 *mapUnitsPerPixel = mLegendMapViewMupp;
806 if ( dpi )
807 *dpi = mLegendMapViewDpi;
808 if ( scale )
809 *scale = mLegendMapViewScale;
810}
811
812QMap<QString, QString> QgsLayerTreeModel::layerStyleOverrides() const
813{
815}
816
817void QgsLayerTreeModel::setLayerStyleOverrides( const QMap<QString, QString> &overrides )
818{
819 mLayerStyleOverrides = overrides;
820}
821
823{
824 if ( mTargetScreenProperties.contains( properties ) )
825 return;
826
827 mTargetScreenProperties.insert( properties );
828}
829
830void QgsLayerTreeModel::setTargetScreenProperties( const QSet<QgsScreenProperties> &properties )
831{
832 mTargetScreenProperties = properties;
834}
835
836QSet<QgsScreenProperties> QgsLayerTreeModel::targetScreenProperties() const
837{
839}
840
841int QgsLayerTreeModel::scaleIconSize( int standardSize )
842{
843 return QgsApplication::scaleIconSize( standardSize, true );
844}
845
847{
848 if ( mHitTestTask )
849 mHitTestTask->waitForFinished();
850}
851
853{
854 return static_cast< bool >( mHitTestTask );
855}
856
858{
859 std::function< void( QgsLayerTreeNode * ) > invalidateNode;
860 invalidateNode = [this, &invalidateNode]( QgsLayerTreeNode *node ) {
861 if ( !node )
862 return;
863
864 switch ( node->nodeType() )
865 {
867 {
868 auto layerNode = qobject_cast< QgsLayerTreeLayer * >( node );
869 const QList<QgsLayerTreeModelLegendNode *> legendNodes = layerLegendNodes( layerNode );
870 for ( QgsLayerTreeModelLegendNode *legendNode : legendNodes )
871 {
872 legendNode->invalidateDisplayData();
873 }
874
875 break;
876 }
877
880 break;
881 }
882
883 const QList<QgsLayerTreeNode *> children = node->children();
884 for ( QgsLayerTreeNode *childNode : children )
885 {
886 invalidateNode( childNode );
887 }
888 };
889 invalidateNode( mRootNode );
890}
891
892void QgsLayerTreeModel::nodeWillAddChildren( QgsLayerTreeNode *node, int indexFrom, int indexTo )
893{
894 beginInsertRows( node2index( node ), indexFrom, indexTo );
895}
896
897static QList<QgsLayerTreeLayer *> _layerNodesInSubtree( QgsLayerTreeNode *node, int indexFrom, int indexTo )
898{
899 QList<QgsLayerTreeNode *> children = node->children();
900 QList<QgsLayerTreeLayer *> newLayerNodes;
901 for ( int i = indexFrom; i <= indexTo; ++i )
902 {
903 QgsLayerTreeNode *child = children.at( i );
904 if ( QgsLayerTree::isLayer( child ) )
905 newLayerNodes << QgsLayerTree::toLayer( child );
906 else if ( QgsLayerTree::isGroup( child ) )
907 newLayerNodes << QgsLayerTree::toGroup( child )->findLayers();
908 }
909 return newLayerNodes;
910}
911
912void QgsLayerTreeModel::nodeAddedChildren( QgsLayerTreeNode *node, int indexFrom, int indexTo )
913{
914 Q_ASSERT( node );
915
916 endInsertRows();
917
918 const auto subNodes = _layerNodesInSubtree( node, indexFrom, indexTo );
919 for ( QgsLayerTreeLayer *newLayerNode : subNodes )
920 connectToLayer( newLayerNode );
921}
922
923void QgsLayerTreeModel::nodeWillRemoveChildren( QgsLayerTreeNode *node, int indexFrom, int indexTo )
924{
925 Q_ASSERT( node );
926
927 beginRemoveRows( node2index( node ), indexFrom, indexTo );
928
929 // disconnect from layers and remove their legend
930 const auto subNodes = _layerNodesInSubtree( node, indexFrom, indexTo );
931 for ( QgsLayerTreeLayer *nodeLayer : subNodes )
932 disconnectFromLayer( nodeLayer );
933}
934
936{
937 endRemoveRows();
938}
939
941{
942 Q_ASSERT( node );
943
944 const QModelIndex index = node2index( node );
945 emit dataChanged( index, index );
946}
947
948void QgsLayerTreeModel::nodeNameChanged( QgsLayerTreeNode *node, const QString &name )
949{
950 Q_UNUSED( name )
951 Q_ASSERT( node );
952
953 const QModelIndex index = node2index( node );
954 emit dataChanged( index, index );
955}
956
957
959{
960 if ( QgsLayerTree::isLayer( node ) && key == "showFeatureCount"_L1 )
962 else if ( ( QgsLayerTree::isGroup( node ) || QgsLayerTree::isLayer( node ) ) && key == "icon"_L1 )
963 {
964 const QModelIndex index = node2index( node );
965 if ( index.isValid() )
966 emit dataChanged( index, index, { Qt::DecorationRole } );
967 }
968}
969
970
972{
973 QgsLayerTreeLayer *nodeLayer = qobject_cast<QgsLayerTreeLayer *>( sender() );
974 if ( !nodeLayer )
975 return;
976
977 // deferred connection to the layer
978 connectToLayer( nodeLayer );
979}
980
982{
983 QgsLayerTreeLayer *nodeLayer = qobject_cast<QgsLayerTreeLayer *>( sender() );
984 if ( !nodeLayer )
985 return;
986
987 disconnectFromLayer( nodeLayer );
988
989 // wait for the layer to appear again
991}
992
994{
995 if ( !mRootNode )
996 return;
997
998 if ( !testFlag( ShowLegend ) )
999 return;
1000
1001 QgsMapLayer *layer = qobject_cast<QgsMapLayer *>( sender() );
1002 if ( !layer )
1003 return;
1004
1005 QgsLayerTreeLayer *nodeLayer = mRootNode->findLayer( layer->id() );
1006 if ( !nodeLayer )
1007 return;
1008
1009 refreshLayerLegend( nodeLayer );
1010}
1011
1013{
1014 if ( !mRootNode )
1015 return;
1016
1017 QgsMapLayer *layer = qobject_cast<QgsMapLayer *>( sender() );
1018 if ( !layer )
1019 return;
1020
1021 QgsLayerTreeLayer *nodeLayer = mRootNode->findLayer( layer->id() );
1022 if ( !nodeLayer )
1023 return;
1024
1025 const QModelIndex index = node2index( nodeLayer );
1026 emit dataChanged( index, index );
1027}
1028
1030{
1031 QgsMapLayer *layer = qobject_cast<QgsMapLayer *>( sender() );
1032 if ( !layer )
1033 return;
1034
1035 QgsLayerTreeLayer *nodeLayer = mRootNode->findLayer( layer->id() );
1036 if ( !nodeLayer )
1037 return;
1038
1039 QModelIndex index = node2index( nodeLayer );
1040 emit dataChanged( index, index );
1041
1042 if ( nodeLayer->customProperty( u"showFeatureCount"_s ).toInt() )
1043 refreshLayerLegend( nodeLayer );
1044}
1045
1046
1048{
1049 QgsLayerTreeModelLegendNode *legendNode = qobject_cast<QgsLayerTreeModelLegendNode *>( sender() );
1050 if ( !legendNode )
1051 return;
1052
1053 QModelIndex index = legendNode2index( legendNode );
1054 if ( index.isValid() )
1055 emit dataChanged( index, index );
1056}
1057
1058void QgsLayerTreeModel::legendNodeSizeChanged()
1059{
1060 QgsLayerTreeModelLegendNode *legendNode = qobject_cast<QgsLayerTreeModelLegendNode *>( sender() );
1061 if ( !legendNode )
1062 return;
1063
1064 QModelIndex index = legendNode2index( legendNode );
1065 if ( index.isValid() )
1066 emit dataChanged( index, index, QVector<int> { Qt::SizeHintRole } );
1067}
1068
1069void QgsLayerTreeModel::hitTestTaskCompleted()
1070{
1071 if ( mHitTestTask )
1072 {
1073 mHitTestResults = mHitTestTask->results();
1074 mHitTestResultsRendererUpdatedCanvas = mHitTestTask->resultsRenderersUpdatedCanvas();
1075
1076 handleHitTestResults();
1077 emit hitTestCompleted();
1078 }
1079}
1080
1082{
1083 if ( !nodeLayer->layer() )
1084 {
1085 // in order to connect to layer, we need to have it loaded.
1086 // keep an eye on the layer ID: once loaded, we will use it
1087 connect( nodeLayer, &QgsLayerTreeLayer::layerLoaded, this, &QgsLayerTreeModel::nodeLayerLoaded, Qt::UniqueConnection );
1088 return;
1089 }
1090
1091 // watch if the layer is getting removed
1092 connect( nodeLayer, &QgsLayerTreeLayer::layerWillBeUnloaded, this, &QgsLayerTreeModel::nodeLayerWillBeUnloaded, Qt::UniqueConnection );
1093
1094 if ( testFlag( ShowLegend ) )
1095 {
1096 addLegendToLayer( nodeLayer );
1097
1098 // if we aren't loading a layer from a project, setup some nice default settings
1099 if ( !mRootNode->customProperty( u"loading"_s ).toBool() )
1100 {
1101 // automatic collapse of legend nodes - useful if a layer has many legend nodes
1103 nodeLayer->setExpanded( false );
1104
1106 {
1107 nodeLayer->setCustomProperty( u"showFeatureCount"_s, true );
1108 }
1109 }
1110 }
1111
1112 QgsMapLayer *layer = nodeLayer->layer();
1113 connect( layer, &QgsMapLayer::legendChanged, this, &QgsLayerTreeModel::layerLegendChanged, Qt::UniqueConnection );
1114 connect( layer, &QgsMapLayer::flagsChanged, this, &QgsLayerTreeModel::layerFlagsChanged, Qt::UniqueConnection );
1115
1116 if ( QgsMapLayerElevationProperties *elevationProperties = layer->elevationProperties() )
1117 {
1118 connect( elevationProperties, &QgsMapLayerElevationProperties::profileGenerationPropertyChanged, this, &QgsLayerTreeModel::layerProfileGenerationPropertyChanged, Qt::UniqueConnection );
1119 }
1120
1121 // using unique connection because there may be temporarily more nodes for a layer than just one
1122 // which would create multiple connections, however disconnect() would disconnect all multiple connections
1123 // even if we wanted to disconnect just one connection in each call.
1124 connect( layer, &QgsMapLayer::editingStarted, this, &QgsLayerTreeModel::layerNeedsUpdate, Qt::UniqueConnection );
1125 connect( layer, &QgsMapLayer::editingStopped, this, &QgsLayerTreeModel::layerNeedsUpdate, Qt::UniqueConnection );
1126 connect( layer, &QgsMapLayer::layerModified, this, &QgsLayerTreeModel::layerNeedsUpdate, Qt::UniqueConnection );
1127
1128 emit dataChanged( node2index( nodeLayer ), node2index( nodeLayer ) );
1129}
1130
1131// try to find out if the layer ID is present in the tree multiple times
1132static int _numLayerCount( QgsLayerTreeGroup *group, const QString &layerId )
1133{
1134 int count = 0;
1135 const auto constChildren = group->children();
1136 for ( QgsLayerTreeNode *child : constChildren )
1137 {
1138 if ( QgsLayerTree::isLayer( child ) )
1139 {
1140 if ( QgsLayerTree::toLayer( child )->layerId() == layerId )
1141 count++;
1142 }
1143 else if ( QgsLayerTree::isGroup( child ) )
1144 {
1145 count += _numLayerCount( QgsLayerTree::toGroup( child ), layerId );
1146 }
1147 }
1148 return count;
1149}
1150
1152{
1153 disconnect( nodeLayer, nullptr, this, nullptr ); // disconnect from delayed load of layer
1154
1155 if ( !nodeLayer->layer() )
1156 return; // we were never connected
1157
1158 if ( testFlag( ShowLegend ) )
1159 {
1160 removeLegendFromLayer( nodeLayer );
1161 }
1162
1163 if ( _numLayerCount( mRootNode, nodeLayer->layerId() ) == 1 )
1164 {
1165 // last instance of the layer in the tree: disconnect from all signals from layer!
1166 disconnect( nodeLayer->layer(), nullptr, this, nullptr );
1167 }
1168}
1169
1171{
1172 const auto constChildren = parentGroup->children();
1173 for ( QgsLayerTreeNode *node : constChildren )
1174 {
1175 if ( QgsLayerTree::isGroup( node ) )
1177 else if ( QgsLayerTree::isLayer( node ) )
1179 }
1180}
1181
1183{
1184 const auto constChildren = parentGroup->children();
1185 for ( QgsLayerTreeNode *node : constChildren )
1186 {
1187 if ( QgsLayerTree::isGroup( node ) )
1189 else if ( QgsLayerTree::isLayer( node ) )
1191 }
1192}
1193
1195{
1196 Q_ASSERT( mRootNode );
1197
1198 connect( mRootNode, &QgsLayerTreeNode::willAddChildren, this, &QgsLayerTreeModel::nodeWillAddChildren, Qt::ConnectionType::UniqueConnection );
1199 connect( mRootNode, &QgsLayerTreeNode::addedChildren, this, &QgsLayerTreeModel::nodeAddedChildren, Qt::ConnectionType::UniqueConnection );
1200 connect( mRootNode, &QgsLayerTreeNode::willRemoveChildren, this, &QgsLayerTreeModel::nodeWillRemoveChildren, Qt::ConnectionType::UniqueConnection );
1201 connect( mRootNode, &QgsLayerTreeNode::removedChildren, this, &QgsLayerTreeModel::nodeRemovedChildren, Qt::ConnectionType::UniqueConnection );
1202 connect( mRootNode, &QgsLayerTreeNode::visibilityChanged, this, &QgsLayerTreeModel::nodeVisibilityChanged, Qt::ConnectionType::UniqueConnection );
1203 connect( mRootNode, &QgsLayerTreeNode::nameChanged, this, &QgsLayerTreeModel::nodeNameChanged, Qt::ConnectionType::UniqueConnection );
1204 connect( mRootNode, &QgsLayerTreeNode::customPropertyChanged, this, &QgsLayerTreeModel::nodeCustomPropertyChanged, Qt::ConnectionType::UniqueConnection );
1205
1207}
1208
1210{
1211 if ( mRootNode )
1212 {
1213 disconnect( mRootNode, nullptr, this, nullptr );
1215 }
1216}
1217
1219{
1220 QgsLayerTreeNode *node = index2node( idx );
1221 if ( !node )
1222 return;
1223
1224 int count = node->children().count();
1225 if ( count == 0 )
1226 return;
1227 emit dataChanged( index( 0, 0, idx ), index( count - 1, 0, idx ) );
1228 for ( int i = 0; i < count; ++i )
1229 recursivelyEmitDataChanged( index( i, 0, idx ) );
1230}
1231
1232void QgsLayerTreeModel::refreshScaleBasedLayers( const QModelIndex &idx, double previousScale )
1233{
1234 QgsLayerTreeNode *node = index2node( idx );
1235 if ( !node )
1236 return;
1237
1238 if ( node->nodeType() == QgsLayerTreeNode::NodeLayer )
1239 {
1240 const QgsMapLayer *layer = QgsLayerTree::toLayer( node )->layer();
1241 if ( layer && layer->hasScaleBasedVisibility() )
1242 {
1243 if ( layer->isInScaleRange( mLegendMapViewScale ) != layer->isInScaleRange( previousScale ) )
1244 emit dataChanged( idx, idx, QVector<int>() << Qt::FontRole << Qt::ForegroundRole );
1245 }
1246 }
1247 int count = node->children().count();
1248 for ( int i = 0; i < count; ++i )
1249 refreshScaleBasedLayers( index( i, 0, idx ), previousScale );
1250}
1251
1253{
1254 return Qt::CopyAction | Qt::MoveAction;
1255}
1256
1258{
1259 QStringList types;
1260 types << u"application/qgis.layertreemodeldata"_s;
1261 return types;
1262}
1263
1264
1265QMimeData *QgsLayerTreeModel::mimeData( const QModelIndexList &indexes ) const
1266{
1267 // Sort the indexes. Depending on how the user selected the items, the indexes may be unsorted.
1268 QModelIndexList sortedIndexes = indexes;
1269 std::sort( sortedIndexes.begin(), sortedIndexes.end(), std::less<QModelIndex>() );
1270
1271 QList<QgsLayerTreeNode *> nodesFinal = indexes2nodes( sortedIndexes, true );
1272
1273 if ( nodesFinal.isEmpty() )
1274 return nullptr;
1275
1276 QMimeData *mimeData = new QMimeData();
1277
1278 QDomDocument layerTreeDoc;
1279 QDomElement rootLayerTreeElem = layerTreeDoc.createElement( u"layer_tree_model_data"_s );
1280
1281 for ( QgsLayerTreeNode *node : std::as_const( nodesFinal ) )
1282 {
1283 node->writeXml( rootLayerTreeElem, QgsReadWriteContext() );
1284 }
1285 layerTreeDoc.appendChild( rootLayerTreeElem );
1286
1287 QString errorMessage;
1288 QgsReadWriteContext readWriteContext;
1289 QDomDocument layerDefinitionsDoc( u"qgis-layer-definition"_s );
1290 QgsLayerDefinition::exportLayerDefinition( layerDefinitionsDoc, nodesFinal, errorMessage, QgsReadWriteContext() );
1291
1292 QString txt = layerDefinitionsDoc.toString();
1293
1294 mimeData->setData( u"application/qgis.layertreemodeldata"_s, layerTreeDoc.toString().toUtf8() );
1295 mimeData->setData( u"application/qgis.application.pid"_s, QString::number( QCoreApplication::applicationPid() ).toUtf8() );
1296 mimeData->setData( u"application/qgis.layertree.source"_s, u":0x%1"_s.arg( reinterpret_cast<quintptr>( this ), 2 * QT_POINTER_SIZE, 16, '0'_L1 ).toUtf8() );
1297 mimeData->setData( u"application/qgis.layertree.layerdefinitions"_s, txt.toUtf8() );
1298 mimeData->setData( u"application/x-vnd.qgis.qgis.uri"_s, QgsMimeDataUtils::layerTreeNodesToUriList( nodesFinal ) );
1299
1300 return mimeData;
1301}
1302
1303bool QgsLayerTreeModel::dropMimeData( const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent )
1304{
1305 if ( action == Qt::IgnoreAction )
1306 return true;
1307
1308 if ( !data->hasFormat( u"application/qgis.layertreemodeldata"_s ) )
1309 return false;
1310
1311 if ( column >= columnCount( parent ) )
1312 return false;
1313
1314 // don't accept drops from some layer tree subclasses to non-matching subclasses
1315 const QString restrictTypes( data->data( u"application/qgis.restrictlayertreemodelsubclass"_s ) );
1316 if ( !restrictTypes.isEmpty() && restrictTypes != QString( metaObject()->className() ) )
1317 return false;
1318
1319 QgsLayerTreeNode *nodeParent = index2node( parent );
1320 if ( !QgsLayerTree::isGroup( nodeParent ) )
1321 return false;
1322
1323 if ( parent.isValid() && row == -1 )
1324 row = 0; // if dropped directly onto group item, insert at first position
1325
1326 // if we are coming from another QGIS instance, we need to add the layers too
1327 bool ok = false;
1328 // the application pid is only provided from QGIS 3.14, so do not check to OK before defaulting to moving in the legend
1329 qint64 qgisPid = data->data( u"application/qgis.application.pid"_s ).toInt( &ok );
1330
1331 if ( ok && qgisPid != QCoreApplication::applicationPid() )
1332 {
1333 QByteArray encodedLayerDefinitionData = data->data( u"application/qgis.layertree.layerdefinitions"_s );
1334 QDomDocument layerDefinitionDoc;
1335 if ( !layerDefinitionDoc.setContent( QString::fromUtf8( encodedLayerDefinitionData ) ) )
1336 return false;
1337 QgsReadWriteContext context;
1338 QString errorMessage;
1339 QgsLayerDefinition::loadLayerDefinition( layerDefinitionDoc, QgsProject::instance(), QgsLayerTree::toGroup( nodeParent ), errorMessage, context ); // skip-keyword-check
1340 emit messageEmitted( tr( "New layers added from another QGIS instance" ) );
1341 }
1342 else
1343 {
1344 QByteArray encodedLayerTreeData = data->data( u"application/qgis.layertreemodeldata"_s );
1345
1346 QDomDocument layerTreeDoc;
1347 if ( !layerTreeDoc.setContent( QString::fromUtf8( encodedLayerTreeData ) ) )
1348 return false;
1349
1350 QDomElement rootLayerTreeElem = layerTreeDoc.documentElement();
1351 if ( rootLayerTreeElem.tagName() != "layer_tree_model_data"_L1 )
1352 return false;
1353
1354 QList<QgsLayerTreeNode *> nodes;
1355
1356 QDomElement elem = rootLayerTreeElem.firstChildElement();
1357 while ( !elem.isNull() )
1358 {
1359 QgsLayerTreeNode *node = QgsLayerTreeNode::readXml( elem, QgsProject::instance() ); // skip-keyword-check
1360 if ( node )
1361 nodes << node;
1362
1363 elem = elem.nextSiblingElement();
1364 }
1365
1366 if ( nodes.isEmpty() )
1367 return false;
1368
1369 // moving around layer group preserves id but copying creates new id for the group + subgroups
1370 if ( action == Qt::CopyAction )
1371 {
1372 for ( QgsLayerTreeNode *node : std::as_const( nodes ) )
1374 }
1375
1376 QgsLayerTree::toGroup( nodeParent )->insertChildNodes( row, nodes );
1377 }
1378 return true;
1379}
1380
1381bool QgsLayerTreeModel::removeRows( int row, int count, const QModelIndex &parent )
1382{
1383 QgsLayerTreeNode *parentNode = index2node( parent );
1384 if ( QgsLayerTree::isGroup( parentNode ) )
1385 {
1386 QgsLayerTree::toGroup( parentNode )->removeChildren( row, count );
1387 return true;
1388 }
1389 return false;
1390}
1391
1396
1398{
1399 if ( on )
1400 mFlags |= f;
1401 else
1402 mFlags &= ~f;
1403}
1404
1409
1411{
1412 return mFlags.testFlag( f );
1413}
1414
1416{
1417 return QgsApplication::getThemeIcon( u"/mActionFolder.svg"_s );
1418}
1419
1420QList<QgsLayerTreeModelLegendNode *> QgsLayerTreeModel::filterLegendNodes( const QList<QgsLayerTreeModelLegendNode *> &nodes )
1421{
1422 QList<QgsLayerTreeModelLegendNode *> filtered;
1423
1424 if ( mLegendFilterByScale > 0 )
1425 {
1426 for ( QgsLayerTreeModelLegendNode *node : std::as_const( nodes ) )
1427 {
1428 if ( node->isScaleOK( mLegendFilterByScale ) )
1429 filtered << node;
1430 }
1431 }
1432 else if ( mFilterSettings )
1433 {
1434 if ( !nodes.isEmpty() && mFilterSettings->layers().contains( nodes.at( 0 )->layerNode()->layer() ) )
1435 {
1436 for ( QgsLayerTreeModelLegendNode *node : std::as_const( nodes ) )
1437 {
1439 switch ( nodeType )
1440 {
1442 filtered << node;
1443 break;
1444
1452 {
1453 const QString ruleKey = node->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::RuleKey ) ).toString();
1454 const bool isDataDefinedSize = node->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::IsDataDefinedSize ) ).toBool();
1455 const bool checked = ( mFilterSettings && !( mFilterSettings->flags() & Qgis::LayerTreeFilterFlag::SkipVisibilityCheck ) ) || node->data( Qt::CheckStateRole ).toInt() == Qt::Checked;
1456
1457 if ( checked )
1458 {
1459 if ( QgsVectorLayer *vl = qobject_cast<QgsVectorLayer *>( node->layerNode()->layer() ) )
1460 {
1461 auto it = mHitTestResults.constFind( vl->id() );
1462 if ( it != mHitTestResults.constEnd() && ( it->contains( ruleKey ) || ( !it->isEmpty() && isDataDefinedSize ) ) )
1463 {
1464 filtered << node;
1465 }
1466 }
1467 else
1468 {
1469 filtered << node;
1470 }
1471 }
1472 else // unknown node type or unchecked
1473 filtered << node;
1474 break;
1475 }
1476 }
1477 }
1478 }
1479 }
1480 else
1481 {
1482 return nodes;
1483 }
1484
1485 return filtered;
1486}
1487
1488
1490// Legend nodes routines - start
1491
1493{
1494 const auto constMLegend = mLegend;
1495 for ( const LayerLegendData &data : constMLegend )
1496 {
1497 qDeleteAll( data.originalNodes );
1498 delete data.tree;
1499 }
1500 mLegend.clear();
1501
1502 if ( mHitTestTask )
1503 {
1504 // cancel outdated task -- this is owned by the task manager and will get automatically deleted accordingly
1505 disconnect( mHitTestTask, &QgsTask::taskCompleted, this, &QgsLayerTreeModel::hitTestTaskCompleted );
1506 mHitTestTask->cancel();
1507 mHitTestTask = nullptr;
1508 }
1509}
1510
1511
1513{
1514 if ( mLegend.contains( nodeLayer ) )
1515 {
1516 qDeleteAll( mLegend[nodeLayer].originalNodes );
1517 delete mLegend[nodeLayer].tree;
1518 mLegend.remove( nodeLayer );
1519 }
1520}
1521
1522
1524{
1525 if ( !nodeL || !nodeL->layer() )
1526 return;
1527
1528 QgsMapLayer *ml = nodeL->layer();
1529
1530 QgsMapLayerStyleOverride styleOverride( ml );
1531 if ( mLayerStyleOverrides.contains( ml->id() ) )
1532 styleOverride.setOverrideStyle( mLayerStyleOverrides.value( ml->id() ) );
1533
1534 QgsMapLayerLegend *layerLegend = ml->legend();
1535 if ( !layerLegend )
1536 return;
1537 QList<QgsLayerTreeModelLegendNode *> lstNew = layerLegend->createLayerTreeModelLegendNodes( nodeL );
1538
1539 // apply filtering defined in layer node's custom properties (reordering, filtering, custom labels)
1541
1543 {
1544 // generate placeholder legend nodes that will be replaced by widgets in QgsLayerTreeView
1545 int widgetsCount = ml->customProperty( u"embeddedWidgets/count"_s, 0 ).toInt();
1546 while ( widgetsCount > 0 )
1547 {
1548 lstNew.insert( 0, new EmbeddedWidgetLegendNode( nodeL ) );
1549 --widgetsCount;
1550 }
1551 }
1552
1553 QList<QgsLayerTreeModelLegendNode *> filteredLstNew = filterLegendNodes( lstNew );
1554
1555 const auto constLstNew = lstNew;
1556 for ( QgsLayerTreeModelLegendNode *n : constLstNew )
1557 {
1558 n->setParent( this );
1560 connect( n, &QgsLayerTreeModelLegendNode::sizeChanged, this, &QgsLayerTreeModel::legendNodeSizeChanged );
1561 }
1562
1563 // See if we have an embedded node - if we do, we will not use it among active nodes.
1564 // Legend node embedded in parent does not have to be the first one,
1565 // there can be also nodes generated for embedded widgets
1566 QgsLayerTreeModelLegendNode *embeddedNode = nullptr;
1567 const auto constFilteredLstNew = filteredLstNew;
1568 for ( QgsLayerTreeModelLegendNode *legendNode : constFilteredLstNew )
1569 {
1570 if ( legendNode->isEmbeddedInParent() )
1571 {
1572 embeddedNode = legendNode;
1573 filteredLstNew.removeOne( legendNode );
1574 break;
1575 }
1576 }
1577
1578 LayerLegendTree *legendTree = nullptr;
1579
1580 // maybe the legend nodes form a tree - try to create a tree structure from the list
1581 if ( testFlag( ShowLegendAsTree ) )
1582 legendTree = tryBuildLegendTree( filteredLstNew );
1583
1584 int count = legendTree ? legendTree->children[nullptr].count() : filteredLstNew.count();
1585
1586 if ( !filteredLstNew.isEmpty() )
1587 {
1588 // Make sure it's clear
1589 const QModelIndex nodeIndex { node2index( nodeL ) };
1590 if ( rowCount( nodeIndex ) > 0 )
1591 {
1592 beginRemoveRows( node2index( nodeL ), 0, rowCount( nodeIndex ) - 1 );
1593 mLegend[nodeL] = LayerLegendData();
1594 endRemoveRows();
1595 }
1596 beginInsertRows( node2index( nodeL ), 0, count - 1 );
1597 }
1598
1600 data.originalNodes = lstNew;
1601 data.activeNodes = filteredLstNew;
1602 data.embeddedNodeInParent = embeddedNode;
1603 data.tree = legendTree;
1604
1605 mLegend[nodeL] = data;
1606
1607 if ( !filteredLstNew.isEmpty() )
1608 {
1609 endInsertRows();
1610 }
1611
1612 // invalidate map based data even if the data is not map-based to make sure
1613 // the symbol sizes are computed at least once
1614 mInvalidatedNodes.insert( nodeL );
1616}
1617
1618
1619QgsLayerTreeModel::LayerLegendTree *QgsLayerTreeModel::tryBuildLegendTree( const QList<QgsLayerTreeModelLegendNode *> &nodes )
1620{
1621 // first check whether there are any legend nodes that are not top-level
1622 bool hasParentKeys = false;
1623 for ( QgsLayerTreeModelLegendNode *n : nodes )
1624 {
1625 if ( !n->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::ParentRuleKey ) ).toString().isEmpty() )
1626 {
1627 hasParentKeys = true;
1628 break;
1629 }
1630 }
1631 if ( !hasParentKeys )
1632 return nullptr; // all legend nodes are top-level => stick with list representation
1633
1634 // make mapping from rules to nodes and do some sanity checks
1635 QHash<QString, QgsLayerTreeModelLegendNode *> rule2node;
1636 rule2node[QString()] = nullptr;
1637 for ( QgsLayerTreeModelLegendNode *n : nodes )
1638 {
1639 QString ruleKey = n->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::RuleKey ) ).toString();
1640 if ( ruleKey.isEmpty() ) // in tree all nodes must have key
1641 return nullptr;
1642 if ( rule2node.contains( ruleKey ) ) // and they must be unique
1643 return nullptr;
1644 rule2node[ruleKey] = n;
1645 }
1646
1647 // create the tree structure
1648 LayerLegendTree *tree = new LayerLegendTree;
1649 for ( QgsLayerTreeModelLegendNode *n : nodes )
1650 {
1651 QString parentRuleKey = n->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::ParentRuleKey ) ).toString();
1652 QgsLayerTreeModelLegendNode *parent = rule2node.value( parentRuleKey, nullptr );
1653 tree->parents[n] = parent;
1654 tree->children[parent] << n;
1655 }
1656 return tree;
1657}
1658
1660{
1661 double scale = 0.0;
1662 double mupp = 0.0;
1663 int dpi = 0;
1664 legendMapViewData( &mupp, &dpi, &scale );
1665 bool validData = !qgsDoubleNear( mupp, 0.0 ) && dpi != 0 && !qgsDoubleNear( scale, 0.0 );
1666
1667 // setup temporary render context
1668 std::unique_ptr<QgsRenderContext> context( new QgsRenderContext );
1669 context->setScaleFactor( dpi / 25.4 );
1670
1671 if ( !mTargetScreenProperties.isEmpty() )
1672 {
1673 mTargetScreenProperties.begin()->updateRenderContextForScreen( *context );
1674 }
1675
1676 context->setRendererScale( scale );
1677 context->setMapToPixel( QgsMapToPixel( mupp ) );
1678 context->setFlag( Qgis::RenderContextFlag::Antialiasing, true );
1679 context->setFlag( Qgis::RenderContextFlag::RenderSymbolPreview, true );
1680 context->setFlag( Qgis::RenderContextFlag::RenderLayerTree, true );
1681 return validData ? context.release() : nullptr;
1682}
1683
1685{
1686 return qobject_cast<QgsLayerTreeModelLegendNode *>( reinterpret_cast<QObject *>( index.internalPointer() ) );
1687}
1688
1689
1691{
1692 const LayerLegendData &data = mLegend[legendNode->layerNode()];
1693 if ( data.tree )
1694 {
1695 if ( QgsLayerTreeModelLegendNode *parentLegendNode = data.tree->parents[legendNode] )
1696 {
1697 QModelIndex parentIndex = legendNode2index( parentLegendNode );
1698 int row = data.tree->children[parentLegendNode].indexOf( legendNode );
1699 return index( row, 0, parentIndex );
1700 }
1701 else
1702 {
1703 QModelIndex parentIndex = node2index( legendNode->layerNode() );
1704 int row = data.tree->children[nullptr].indexOf( legendNode );
1705 return index( row, 0, parentIndex );
1706 }
1707 }
1708
1709 QModelIndex parentIndex = node2index( legendNode->layerNode() );
1710 Q_ASSERT( parentIndex.isValid() );
1711 int row = data.activeNodes.indexOf( legendNode );
1712 if ( row < 0 ) // legend node may be filtered (exists within the list of original nodes, but not in active nodes)
1713 return QModelIndex();
1714
1715 return index( row, 0, parentIndex );
1716}
1717
1718
1720{
1721 const LayerLegendData &data = mLegend[node->layerNode()];
1722 if ( data.tree )
1723 return data.tree->children[node].count();
1724
1725 return 0; // they are leaves
1726}
1727
1728
1730{
1731 if ( !mLegend.contains( nL ) )
1732 return 0;
1733
1734 const LayerLegendData &data = mLegend[nL];
1735 if ( data.tree )
1736 return data.tree->children[nullptr].count();
1737
1738 int count = data.activeNodes.count();
1739 return count;
1740}
1741
1742
1743QModelIndex QgsLayerTreeModel::legendRootIndex( int row, int column, QgsLayerTreeLayer *nL ) const
1744{
1745 Q_ASSERT( mLegend.contains( nL ) );
1746 const LayerLegendData &data = mLegend[nL];
1747 if ( data.tree )
1748 return createIndex( row, column, static_cast<QObject *>( data.tree->children[nullptr].at( row ) ) );
1749
1750 return createIndex( row, column, static_cast<QObject *>( data.activeNodes.at( row ) ) );
1751}
1752
1753
1754QModelIndex QgsLayerTreeModel::legendNodeIndex( int row, int column, QgsLayerTreeModelLegendNode *node ) const
1755{
1756 const LayerLegendData &data = mLegend[node->layerNode()];
1757 if ( data.tree )
1758 return createIndex( row, column, static_cast<QObject *>( data.tree->children[node].at( row ) ) );
1759
1760 return QModelIndex(); // have no children
1761}
1762
1763
1765{
1766 QgsLayerTreeLayer *layerNode = legendNode->layerNode();
1767 const LayerLegendData &data = mLegend[layerNode];
1768 if ( data.tree )
1769 {
1770 if ( QgsLayerTreeModelLegendNode *parentNode = data.tree->parents[legendNode] )
1771 {
1772 QgsLayerTreeModelLegendNode *grandParentNode = data.tree->parents[parentNode]; // may be null (not a problem)
1773 int row = data.tree->children[grandParentNode].indexOf( parentNode );
1774 return createIndex( row, 0, static_cast<QObject *>( parentNode ) );
1775 }
1776 else
1777 return indexOfParentLayerTreeNode( layerNode );
1778 }
1779
1780 return indexOfParentLayerTreeNode( layerNode );
1781}
1782
1783
1785{
1786 if ( role == Qt::CheckStateRole && !testFlag( AllowLegendChangeState ) )
1787 return QVariant();
1788 return node->data( role );
1789}
1790
1791
1793{
1794 Qt::ItemFlags f = node->flags();
1796 f &= ~Qt::ItemIsUserCheckable;
1797 return f;
1798}
1799
1800
1802{
1803 return static_cast< bool >( mLegend[nodeLayer].embeddedNodeInParent );
1804}
1805
1807{
1808 return mLegend[nodeLayer].embeddedNodeInParent;
1809}
1810
1811
1813{
1814 QgsLayerTreeModelLegendNode *legendNode = mLegend[nodeLayer].embeddedNodeInParent;
1815 if ( !legendNode )
1816 return QIcon();
1817 return QIcon( qvariant_cast<QPixmap>( legendNode->data( Qt::DecorationRole ) ) );
1818}
1819
1820
1821QList<QgsLayerTreeModelLegendNode *> QgsLayerTreeModel::layerLegendNodes( QgsLayerTreeLayer *nodeLayer, bool skipNodeEmbeddedInParent )
1822{
1823 if ( !mLegend.contains( nodeLayer ) )
1824 return QList<QgsLayerTreeModelLegendNode *>();
1825
1826 const LayerLegendData &data = mLegend[nodeLayer];
1827 QList<QgsLayerTreeModelLegendNode *> lst( data.activeNodes );
1828 if ( !skipNodeEmbeddedInParent && data.embeddedNodeInParent )
1829 lst.prepend( data.embeddedNodeInParent );
1830 return lst;
1831}
1832
1833QList<QgsLayerTreeModelLegendNode *> QgsLayerTreeModel::layerOriginalLegendNodes( QgsLayerTreeLayer *nodeLayer )
1834{
1835 return mLegend.value( nodeLayer ).originalNodes;
1836}
1837
1838QgsLayerTreeModelLegendNode *QgsLayerTreeModel::findLegendNode( const QString &layerId, const QString &ruleKey ) const
1839{
1840 for ( auto it = mLegend.constBegin(); it != mLegend.constEnd(); ++it )
1841 {
1842 QgsLayerTreeLayer *layer = it.key();
1843 if ( layer->layerId() == layerId )
1844 {
1845 const auto activeNodes = mLegend.value( layer ).activeNodes;
1846 for ( QgsLayerTreeModelLegendNode *legendNode : activeNodes )
1847 {
1848 if ( legendNode->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::RuleKey ) ).toString() == ruleKey )
1849 {
1850 //found it!
1851 return legendNode;
1852 }
1853 }
1854 }
1855 }
1856
1857 return nullptr;
1858}
1859
1867
1869{
1870 // we have varying icon sizes, and we want icon to be centered and
1871 // text to be left aligned, so we have to compute the max width of icons
1872 //
1873 // we do that for nodes which share a common parent
1874 //
1875 // we do that here because for symbols with size defined in map units
1876 // the symbol sizes changes depends on the zoom level
1877
1878 std::unique_ptr<QgsRenderContext> context( createTemporaryRenderContext() );
1879
1880 for ( QgsLayerTreeLayer *layerNode : std::as_const( mInvalidatedNodes ) )
1881 {
1882 const LayerLegendData &data = mLegend.value( layerNode );
1883
1884 QList<QgsSymbolLegendNode *> symbolNodes;
1885 QMap<QString, int> widthMax;
1886 for ( QgsLayerTreeModelLegendNode *legendNode : std::as_const( data.originalNodes ) )
1887 {
1888 QgsSymbolLegendNode *n = qobject_cast<QgsSymbolLegendNode *>( legendNode );
1889 if ( n )
1890 {
1891 const QSize sz( n->minimumIconSize( context.get() ) );
1892 const QString parentKey( n->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::ParentRuleKey ) ).toString() );
1893 widthMax[parentKey] = std::max( sz.width(), widthMax.contains( parentKey ) ? widthMax[parentKey] : 0 );
1894 n->setIconSize( sz );
1895 symbolNodes.append( n );
1896 }
1897 }
1898 for ( QgsSymbolLegendNode *n : std::as_const( symbolNodes ) )
1899 {
1900 const QString parentKey( n->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::ParentRuleKey ) ).toString() );
1901 Q_ASSERT( widthMax[parentKey] > 0 );
1902 const int twiceMarginWidth = 2; // a one pixel margin avoids hugly rendering of icon
1903 n->setIconSize( QSize( widthMax[parentKey] + twiceMarginWidth, n->iconSize().rheight() + twiceMarginWidth ) );
1904 }
1905 for ( QgsLayerTreeModelLegendNode *legendNode : std::as_const( data.originalNodes ) )
1906 legendNode->invalidateMapBasedData();
1907 }
1908
1909 mInvalidatedNodes.clear();
1910}
1911
1912void QgsLayerTreeModel::layerProfileGenerationPropertyChanged()
1913{
1914 if ( !mRootNode )
1915 return;
1916
1917 QgsMapLayerElevationProperties *elevationProperties = qobject_cast<QgsMapLayerElevationProperties *>( sender() );
1918 if ( !elevationProperties )
1919 return;
1920
1921 if ( QgsMapLayer *layer = qobject_cast< QgsMapLayer * >( elevationProperties->parent() ) )
1922 {
1923 QgsLayerTreeLayer *nodeLayer = mRootNode->findLayer( layer->id() );
1924 if ( !nodeLayer )
1925 return;
1926
1927 QModelIndex index = node2index( nodeLayer );
1928 emit dataChanged( index, index );
1929 }
1930}
1931
1932// Legend nodes routines - end
@ UsersCannotToggleEditing
Indicates that users are not allowed to toggle editing for this layer. Note that this does not imply ...
Definition qgis.h:2465
@ ShortString
A heavily abbreviated string, for use when a compact representation is required.
Definition qgis.h:2604
@ SkipVisibilityCheck
If set, the standard visibility check should be skipped.
Definition qgis.h:5061
@ Polygon
Polygons.
Definition qgis.h:402
@ Vector
Vector layer.
Definition qgis.h:207
@ RenderSymbolPreview
The render is for a symbol preview only and map based properties may not be available,...
Definition qgis.h:2988
@ RenderLayerTree
The render is for a layer tree display where map based properties are not available and where avoidan...
Definition qgis.h:2999
@ Antialiasing
Use antialiasing while drawing.
Definition qgis.h:2984
static int scaleIconSize(int standardSize, bool applyDevicePixelRatio=false)
Scales an icon size to compensate for display pixel density, making the icon size hi-dpi friendly,...
static QPixmap getThemePixmap(const QString &name, const QColor &foreColor=QColor(), const QColor &backColor=QColor(), int size=16)
Helper to get a theme icon as a pixmap.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static QgsTaskManager * taskManager()
Returns the application's task manager, used for managing application wide background task handling.
A legend node which renders a color ramp.
virtual QString dataSourceUri(bool expandAuthConfig=false) const
Gets the data source specification.
Stores the component parts of a data source URI (e.g.
bool useEstimatedMetadata() const
Returns true if estimated metadata should be used for the connection.
A geometry is the spatial representation of a feature.
Qgis::GeometryType type
static QIcon iconForLayer(const QgsMapLayer *layer)
Returns the icon corresponding to a specified map layer.
static bool loadLayerDefinition(const QString &path, QgsProject *project, QgsLayerTreeGroup *rootGroup, QString &errorMessage, Qgis::LayerTreeInsertionMethod insertMethod=Qgis::LayerTreeInsertionMethod::OptimalInInsertionGroup, const QgsLayerTreeRegistryBridge::InsertionPoint *insertPoint=nullptr)
Loads the QLR at path into QGIS.
static Q_DECL_DEPRECATED bool exportLayerDefinition(const QString &path, const QList< QgsLayerTreeNode * > &selectedTreeNodes, QString &errorMessage)
Exports the selected layer tree nodes to a QLR file.
QString name() const override
Returns the node's name.
void setName(const QString &name) override
Sets the node's name.
Contains settings relating to filtering the contents of QgsLayerTreeModel and views.
Layer tree group node serves as a container for layers and further groups.
void setName(const QString &n) override
Sets the group's name.
QString name() const override
Returns the group's name.
void insertChildNodes(int index, const QList< QgsLayerTreeNode * > &nodes)
Insert existing nodes at specified position.
QList< QgsLayerTreeLayer * > findLayers() const
Find all layer nodes.
QgsLayerTreeLayer * findLayer(QgsMapLayer *layer) const
Find layer node representing the map layer.
void removeChildren(int from, int count)
Remove child nodes from index "from".
Layer tree node points to a map layer.
QString layerId() const
Returns the ID for the map layer associated with this node.
void layerWillBeUnloaded()
Emitted when a previously available layer got unloaded (from layer registry).
void setName(const QString &n) override
Sets the layer's name.
QString name() const override
Returns the layer's name.
void layerLoaded()
Emitted when a previously unavailable layer got loaded.
QgsMapLayer * layer() const
Returns the map layer associated with this node.
An abstract interface for legend items returned from QgsMapLayerLegend implementation.
virtual QVariant data(int role) const =0
Returns data associated with the item. Must be implemented in derived class.
@ SimpleLegend
Simple label with icon legend node type.
@ RasterSymbolLegend
Raster symbol legend node type.
@ ImageLegend
Raster image legend node type.
@ DataDefinedSizeLegend
Marker symbol legend node type.
@ EmbeddedWidget
Embedded widget placeholder node type.
@ SymbolLegend
Vector symbol legend node type.
@ ParentRuleKey
Rule key of the parent legend node - for legends with tree hierarchy (QString). Added in 2....
@ IsDataDefinedSize
Set when a node is related to data defined size (title or separated legend items)....
virtual void invalidateMapBasedData()
Notification from model that information from associated map view has changed.
void sizeChanged()
Emitted when the size of this node changes.
void dataChanged()
Emitted on internal data change so the layer tree model can forward the signal to views.
virtual Qt::ItemFlags flags() const
Returns item flags associated with the item. Default implementation returns Qt::ItemIsEnabled.
QgsLayerTreeLayer * layerNode() const
Returns pointer to the parent layer node.
virtual void invalidateDisplayData()
Invalidates cached display data for the node.
virtual bool setData(const QVariant &value, int role)
Sets some data associated with the item. Default implementation does nothing and returns false.
void connectToLayer(QgsLayerTreeLayer *nodeLayer)
int columnCount(const QModelIndex &parent=QModelIndex()) const override
QModelIndex node2index(QgsLayerTreeNode *node) const
Returns index for a given node. If the node does not belong to the layer tree, the result is undefine...
Flags flags() const
Returns OR-ed combination of model flags.
double mLegendFilterByScale
scale denominator for filtering of legend nodes (<= 0 means no filtering)
QList< QgsLayerTreeModelLegendNode * > layerLegendNodes(QgsLayerTreeLayer *nodeLayer, bool skipNodeEmbeddedInParent=false)
Returns filtered list of active legend nodes attached to a particular layer node (by default it retur...
bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) override
bool setData(const QModelIndex &index, const QVariant &value, int role=Qt::EditRole) override
int autoCollapseLegendNodes() const
Returns at what number of legend nodes the layer node should be collapsed. -1 means no auto-collapse ...
void setFilterSettings(const QgsLayerTreeFilterSettings *settings=nullptr)
Sets the filter settings to use to filter legend nodes.
QVariant legendNodeData(QgsLayerTreeModelLegendNode *node, int role) const
void hitTestStarted()
Emitted when a hit test for visible legend items starts.
void setRootGroup(QgsLayerTree *newRootGroup)
Reset the model and use a new root group node.
Q_DECL_DEPRECATED void setLegendFilterByMap(const QgsMapSettings *settings)
Force only display of legend nodes which are valid for given map settings.
QModelIndex legendNode2index(QgsLayerTreeModelLegendNode *legendNode)
Returns index for a given legend node.
void setLegendFilterByScale(double scale)
Force only display of legend nodes which are valid for a given scale.
void hitTestCompleted()
Emitted when a hit test for visible legend items completes.
std::unique_ptr< QgsLayerTreeFilterSettings > mFilterSettings
QVariant data(const QModelIndex &index, int role=Qt::DisplayRole) const override
void setLegendMapViewData(double mapUnitsPerPixel, int dpi, double scale)
Give the layer tree model hints about the currently associated map view so that legend nodes that use...
void nodeCustomPropertyChanged(QgsLayerTreeNode *node, const QString &key)
QgsLayerTreeModel(QgsLayerTree *rootNode, QObject *parent=nullptr)
Construct a new tree model with given layer tree (root node must not be nullptr).
void connectToLayers(QgsLayerTreeGroup *parentGroup)
QMap< QString, QSet< QString > > mHitTestResults
QModelIndex parent(const QModelIndex &child) const override
void setFlag(Flag f, bool on=true)
Enable or disable a model flag.
QModelIndex legendParent(QgsLayerTreeModelLegendNode *legendNode) const
void setLayerTreeNodeFont(int nodeType, const QFont &font)
Sets font for a particular type of layer tree node. nodeType should come from QgsLayerTreeNode::NodeT...
int legendNodeRowCount(QgsLayerTreeModelLegendNode *node) const
void invalidateDisplayData()
Invalidates all cached display data throughout the model.
void nodeAddedChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
void setAutoCollapseLegendNodes(int nodeCount)
Sets at what number of legend nodes the layer node should be collapsed. Setting -1 disables the auto-...
void legendMapViewData(double *mapUnitsPerPixel, int *dpi, double *scale) const
Gets hints about map view - to be used in legend nodes.
QModelIndex currentIndex() const
Gets index of the item marked as current. Item marked as current is underlined.
bool hitTestInProgress() const
Returns true if a hit test for visible legend items is currently in progress.
void recursivelyEmitDataChanged(const QModelIndex &index=QModelIndex())
emit dataChanged() for layer tree node items
bool legendEmbeddedInParent(QgsLayerTreeLayer *nodeLayer) const
QHash< QgsLayerTreeLayer *, LayerLegendData > mLegend
Per layer data about layer's legend nodes.
void disconnectFromLayer(QgsLayerTreeLayer *nodeLayer)
void setCurrentIndex(const QModelIndex &currentIndex)
Sets index of the current item. May be used by view. Item marked as current is underlined.
QIcon legendIconEmbeddedInParent(QgsLayerTreeLayer *nodeLayer) const
void layerFlagsChanged()
Triggered when layer flags have changed.
void nodeNameChanged(QgsLayerTreeNode *node, const QString &name)
Updates model when node's name has changed.
QPersistentModelIndex mCurrentIndex
Current index - will be underlined.
LayerLegendTree * tryBuildLegendTree(const QList< QgsLayerTreeModelLegendNode * > &nodes)
Qt::DropActions supportedDropActions() const override
QModelIndex legendNodeIndex(int row, int column, QgsLayerTreeModelLegendNode *node) const
QgsRenderContext * createTemporaryRenderContext() const
Returns a temporary render context.
void setFlags(QgsLayerTreeModel::Flags f)
Sets OR-ed combination of model flags.
QgsLayerTree * rootGroup() const
Returns pointer to the root node of the layer tree. Always a non nullptr value.
void nodeWillRemoveChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
QgsLayerTreeNode * index2node(const QModelIndex &index) const
Returns layer tree node for given index.
QgsLayerTree * mRootNode
Pointer to the root node of the layer tree. Not owned by the model.
QSet< QgsScreenProperties > targetScreenProperties() const
Returns the target screen properties to use when generating icons.
QStringList mimeTypes() const override
QMimeData * mimeData(const QModelIndexList &indexes) const override
QSet< QgsScreenProperties > mTargetScreenProperties
int rowCount(const QModelIndex &parent=QModelIndex()) const override
QPointer< QgsMapHitTestTask > mHitTestTask
bool removeRows(int row, int count, const QModelIndex &parent=QModelIndex()) override
static int scaleIconSize(int standardSize)
Scales an layer tree model icon size to compensate for display pixel density, making the icon size hi...
void messageEmitted(const QString &message, Qgis::MessageLevel level=Qgis::MessageLevel::Info, int duration=5)
Emits a message than can be displayed to the user in a GUI class.
QgsLayerTreeModelLegendNode * legendNodeEmbeddedInParent(QgsLayerTreeLayer *nodeLayer) const
Returns legend node that may be embedded in parent (i.e.
QList< QgsLayerTreeNode * > indexes2nodes(const QModelIndexList &list, bool skipInternal=false) const
Convert a list of indexes to a list of layer tree nodes.
QModelIndex index(int row, int column, const QModelIndex &parent=QModelIndex()) const override
QMap< QString, QPair< double, double > > mHitTestResultsRendererUpdatedCanvas
QList< QgsLayerTreeModelLegendNode * > filterLegendNodes(const QList< QgsLayerTreeModelLegendNode * > &nodes)
Filter nodes from QgsMapLayerLegend according to the current filtering rules.
const QgsLayerTreeFilterSettings * filterSettings() const
Returns the filter settings to use to filter legend nodes.
QList< QgsLayerTreeModelLegendNode * > layerOriginalLegendNodes(QgsLayerTreeLayer *nodeLayer)
Returns original (unfiltered) list of legend nodes attached to a particular layer node.
void setTargetScreenProperties(const QSet< QgsScreenProperties > &properties)
Sets all target screen properties to use when generating icons for Qt::DecorationRole data.
int mAutoCollapseLegendNodesCount
Minimal number of nodes when legend should be automatically collapsed. -1 = disabled.
QMap< QString, QString > layerStyleOverrides() const
Gets map of map layer style overrides (key: layer ID, value: style name) where a different style shou...
Qt::ItemFlags legendNodeFlags(QgsLayerTreeModelLegendNode *node) const
void setLayerStyleOverrides(const QMap< QString, QString > &overrides)
Sets map of map layer style overrides (key: layer ID, value: style name) where a different style shou...
void nodeVisibilityChanged(QgsLayerTreeNode *node)
void refreshScaleBasedLayers(const QModelIndex &index=QModelIndex(), double previousScale=0.0)
Updates layer data for scale dependent layers, should be called when map scale changes.
void removeLegendFromLayer(QgsLayerTreeLayer *nodeLayer)
QModelIndex legendRootIndex(int row, int column, QgsLayerTreeLayer *nL) const
static QgsLayerTreeModelLegendNode * index2legendNode(const QModelIndex &index)
Returns legend node for given index.
QMap< QString, QString > mLayerStyleOverrides
Overrides of map layers' styles: key = layer ID, value = style XML.
void nodeWillAddChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
const QgsMapSettings * legendFilterMapSettings() const
Returns the current map settings used for the current legend filter (or nullptr if none is enabled).
QFont layerTreeNodeFont(int nodeType) const
Gets font for a particular type of layer tree node. nodeType should come from QgsLayerTreeNode::NodeT...
void refreshLayerLegend(QgsLayerTreeLayer *nodeLayer)
Force a refresh of legend nodes of a layer node.
void waitForHitTestBlocking()
When a current hit test for visible legend items is in progress, calling this method will block until...
void addLegendToLayer(QgsLayerTreeLayer *nodeL)
bool testFlag(Flag f) const
Check whether a flag is enabled.
void disconnectFromLayers(QgsLayerTreeGroup *parentGroup)
QModelIndex indexOfParentLayerTreeNode(QgsLayerTreeNode *parentNode) const
QSet< QgsLayerTreeLayer * > mInvalidatedNodes
Keep track of layer nodes for which the legend size needs to be recalculated.
@ ActionHierarchical
Check/uncheck action has consequences on children (or parents for leaf node).
@ AllowNodeChangeVisibility
Allow user to set node visibility with a checkbox.
@ ShowLegendAsTree
For legends that support it, will show them in a tree instead of a list (needs also ShowLegend)....
@ UseTextFormatting
Layer nodes will alter text appearance based on layer properties, such as scale based visibility.
@ AllowNodeReorder
Allow reordering with drag'n'drop.
@ ShowLegend
Add legend nodes for layer nodes.
@ DeferredLegendInvalidation
Defer legend model invalidation.
@ AllowNodeRename
Allow renaming of groups and layers.
@ AllowLegendChangeState
Allow check boxes for legend nodes (if supported by layer's legend).
@ UseEmbeddedWidgets
Layer nodes may optionally include extra embedded widgets (if used in QgsLayerTreeView)....
@ UseThreadedHitTest
Run legend hit tests in a background thread.
void addTargetScreenProperties(const QgsScreenProperties &properties)
Adds additional target screen properties to use when generating icons for Qt::DecorationRole data.
Flags mFlags
Sets of flags for the model.
Q_DECL_DEPRECATED void setLegendFilter(const QgsMapSettings *settings, bool useExtent=true, const QgsGeometry &polygon=QgsGeometry(), bool useExpressions=true)
Filter display of legend nodes for given map settings.
int legendRootRowCount(QgsLayerTreeLayer *nL) const
QgsLayerTreeModelLegendNode * findLegendNode(const QString &layerId, const QString &ruleKey) const
Searches through the layer tree to find a legend node with a matching layer ID and rule key.
Base class for nodes in a layer tree.
@ NodeCustom
Leaf node pointing to a custom object.
@ NodeGroup
Container of other groups and layers.
@ NodeLayer
Leaf node pointing to a layer.
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.
bool isVisible() const
Returns whether a node is really visible (ie checked and all its ancestors checked as well).
void setCustomProperty(const QString &key, const QVariant &value)
Sets a custom property for the node. Properties are stored in a map and saved in project file.
virtual void writeXml(QDomElement &parentElement, const QgsReadWriteContext &context)=0
Write layer tree to XML.
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 willRemoveChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes will be removed from a node within the tree.
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.
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.
NodeType nodeType() const
Find out about type of the node. It is usually shorter to use convenience functions from QgsLayerTree...
void customPropertyChanged(QgsLayerTreeNode *node, const QString &key)
Emitted when a custom property of a node within the tree has been changed or removed.
void addedChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes have been added to a node within the tree.
void willAddChildren(QgsLayerTreeNode *node, int indexFrom, int indexTo)
Emitted when one or more nodes will be added to a node within the tree.
void visibilityChanged(QgsLayerTreeNode *node)
Emitted when check state of a node within the tree has been changed.
virtual void setItemVisibilityCheckedRecursive(bool checked)
Check or uncheck a node and all its children (taking into account exclusion rules).
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 setItemVisibilityCheckedParentRecursive(bool checked)
Check or uncheck a node and all its parents.
static void regenerateGroupIds(QgsLayerTreeNode *node)
Assigns a new unique id to every group in the sub-tree rooted at node.
Namespace with helper functions for layer tree operations.
static QgsLayerTreeLayer * toLayer(QgsLayerTreeNode *node)
Cast node to a layer.
static bool isLayer(const QgsLayerTreeNode *node)
Check whether the node is a valid layer node.
static bool isGroup(QgsLayerTreeNode *node)
Check whether the node is a valid group node.
static QgsLayerTreeGroup * toGroup(QgsLayerTreeNode *node)
Cast node to a group.
static bool isCustomNode(const QgsLayerTreeNode *node)
Check whether the node is a valid custom node.
static QgsLayerTreeCustomNode * toCustomNode(QgsLayerTreeNode *node)
Cast node to a custom node.
Executes a QgsMapHitTest in a background thread.
Base class for storage of map layer elevation properties.
void profileGenerationPropertyChanged()
Emitted when any of the elevation properties which relate solely to generation of elevation profiles ...
static void applyLayerNodeProperties(QgsLayerTreeLayer *nodeLayer, QList< QgsLayerTreeModelLegendNode * > &nodes)
update according to layer node's custom properties (order of items, user labels for items)
An abstract interface for implementations of legends for one map layer.
virtual QList< QgsLayerTreeModelLegendNode * > createLayerTreeModelLegendNodes(QgsLayerTreeLayer *nodeLayer)=0
Returns list of legend nodes to be used for a particular layer tree layer node.
Restore overridden layer style on destruction.
void setOverrideStyle(const QString &style)
Temporarily apply a different style to the layer.
Base class for all map layer types.
Definition qgsmaplayer.h:84
virtual bool isSpatial() const
Returns true if the layer is considered a spatial layer, ie it has some form of geometry associated w...
bool isInScaleRange(double scale) const
Tests whether the layer should be visible at the specified scale.
void legendChanged()
Signal emitted when legend of the layer has changed.
QgsMapLayerLegend * legend() const
Can be nullptr.
void editingStopped()
Emitted when edited changes have been successfully written to the data provider.
Q_INVOKABLE QVariant customProperty(const QString &value, const QVariant &defaultValue=QVariant()) const
Read a custom property from layer.
void editingStarted()
Emitted when editing on this layer has started.
QString id
Definition qgsmaplayer.h:87
Qgis::LayerType type
Definition qgsmaplayer.h:94
virtual Qgis::MapLayerProperties properties() const
Returns the map layer properties of this layer.
virtual bool isEditable() const
Returns true if the layer can be edited.
bool hasScaleBasedVisibility() const
Returns whether scale based visibility is enabled for the layer.
virtual bool isModified() const
Returns true if the layer has been modified since last commit/save.
void flagsChanged()
Emitted when layer's flags have been modified.
virtual QgsMapLayerElevationProperties * elevationProperties()
Returns the layer's elevation properties.
void layerModified()
Emitted when modifications has been done on layer.
Contains configuration for rendering maps.
bool hasValidSettings() const
Check whether the map settings are valid and can be used for rendering.
Perform transforms between map coordinates and device coordinates.
static QByteArray layerTreeNodesToUriList(const QList< QgsLayerTreeNode * > &nodes)
Returns encoded URI list from a list of layer tree nodes.
static QgsProject * instance()
Returns the QgsProject singleton instance.
A container for the context for various read/write operations on objects.
Contains information about the context of a rendering operation.
Stores properties relating to a screen.
static const QgsSettingsEntryBool * settingsLayerTreeShowFeatureCountForNewLayers
Settings entry show feature counts for newly added layers by default.
static const QgsSettingsEntryBool * settingsLayerTreeShowIdInLayerTooltips
Settings entry for hidden ID in layer tooltips.
Implementation of legend node interface for displaying preview of vector symbols and their labels and...
void setIconSize(QSize sz)
Set the icon size.
QSize minimumIconSize() const
Calculates the minimum icon size to prevent cropping.
QVariant data(int role) const override
Returns data associated with the item. Must be implemented in derived class.
long addTask(QgsTask *task, int priority=0)
Adds a task to the manager.
void taskCompleted()
Will be emitted by task to indicate its successful completion.
Represents a vector layer which manages a vector based dataset.
long long featureCount(const QString &legendKey) const
Number of features rendered with specified legend key.
QgsVectorDataProvider * dataProvider() final
Returns the layer's data provider, it may be nullptr.
static Q_INVOKABLE QString displayString(Qgis::WkbType type)
Returns a non-translated display string type for a WKB type, e.g., the geometry name used in WKT geom...
#define Q_NOWARN_DEPRECATED_POP
Definition qgis.h:8447
#define Q_NOWARN_DEPRECATED_PUSH
Definition qgis.h:8446
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference).
Definition qgis.h:7811
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:80
Structure that stores all data associated with one map layer.
Structure that stores tree representation of map layer's legend.
QMap< QgsLayerTreeModelLegendNode *, QgsLayerTreeModelLegendNode * > parents
Pointer to parent for each active node. Top-level nodes have nullptr parent. Pointers are not owned.
QMap< QgsLayerTreeModelLegendNode *, QList< QgsLayerTreeModelLegendNode * > > children
List of children for each active node. Top-level nodes are under nullptr key. Pointers are not owned.