void QgsLayerTreeView::setCurrentLayer( QgsMapLayer* layer )
{
if ( !layer )
{
setCurrentIndex( QModelIndex() );
return;
}
QgsLayerTreeLayer* nodeLayer = layerTreeModel()->rootGroup()->findLayer( layer->id() );
if ( !nodeLayer )
return;
setCurrentIndex( layerTreeModel()->node2index( nodeLayer ) );
}
void QgsLayerTreeView::updateExpandedStateFromNode( QgsLayerTreeNode* node )
{
QModelIndex idx = layerTreeModel()->node2index( node );
setExpanded( idx, node->isExpanded() );
foreach ( QgsLayerTreeNode* child, node->children() )
updateExpandedStateFromNode( child );
}
void QgsLayerTreeView::updateExpandedStateToNode( QModelIndex index )
{
QgsLayerTreeNode* node = layerTreeModel()->index2node( index );
if ( !node )
return;
node->setExpanded( isExpanded( index ) );
}
void QgsLayerTreeView::setModel( QAbstractItemModel* model )
{
if ( !qobject_cast<QgsLayerTreeModel*>( model ) )
return;
connect( model, SIGNAL( rowsInserted( QModelIndex, int, int ) ), this, SLOT( modelRowsInserted( QModelIndex, int, int ) ) );
connect( model, SIGNAL( rowsRemoved( QModelIndex, int, int ) ), this, SLOT( modelRowsRemoved() ) );
QTreeView::setModel( model );
connect( layerTreeModel()->rootGroup(), SIGNAL( expandedChanged( QgsLayerTreeNode*, bool ) ), this, SLOT( onExpandedChanged( QgsLayerTreeNode*, bool ) ) );
connect( selectionModel(), SIGNAL( currentChanged( QModelIndex, QModelIndex ) ), this, SLOT( onCurrentChanged() ) );
connect( layerTreeModel(), SIGNAL( modelReset() ), this, SLOT( onModelReset() ) );
updateExpandedStateFromNode( layerTreeModel()->rootGroup() );
}
QgsMapLayer* QgsLayerTreeView::layerForIndex( const QModelIndex& index ) const
{
QgsLayerTreeNode* node = layerTreeModel()->index2node( index );
if ( node )
{
if ( QgsLayerTree::isLayer( node ) )
return QgsLayerTree::toLayer( node )->layer();
}
else
{
// possibly a legend node
QgsLayerTreeModelLegendNode* legendNode = layerTreeModel()->index2legendNode( index );
if ( legendNode )
return legendNode->layerNode()->layer();
}
return 0;
}
void QgsLayerTreeView::onCurrentChanged()
{
QgsMapLayer* layerCurrent = layerForIndex( currentIndex() );
QString layerCurrentID = layerCurrent ? layerCurrent->id() : QString();
if ( mCurrentLayerID == layerCurrentID )
return;
// update the current index in model (the item will be underlined)
QModelIndex nodeLayerIndex;
if ( layerCurrent )
{
QgsLayerTreeLayer* nodeLayer = layerTreeModel()->rootGroup()->findLayer( layerCurrentID );
nodeLayerIndex = layerTreeModel()->node2index( nodeLayer );
}
layerTreeModel()->setCurrentIndex( nodeLayerIndex );
mCurrentLayerID = layerCurrentID;
emit currentLayerChanged( layerCurrent );
}
void QgsLayerTreeView::modelRowsInserted( const QModelIndex& index, int start, int end )
{
QgsLayerTreeNode* parentNode = layerTreeModel()->index2node( index );
if ( !parentNode )
return;
if ( QgsLayerTree::isLayer( parentNode ) )
{
// if ShowLegendAsTree flag is enabled in model, we may need to expand some legend nodes
QStringList expandedNodeKeys = parentNode->customProperty( "expandedLegendNodes" ).toStringList();
if ( expandedNodeKeys.isEmpty() )
return;
Q_FOREACH ( QgsLayerTreeModelLegendNode* legendNode, layerTreeModel()->layerLegendNodes( QgsLayerTree::toLayer( parentNode ) ) )
{
QString ruleKey = legendNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString();
if ( expandedNodeKeys.contains( ruleKey ) )
setExpanded( layerTreeModel()->legendNode2index( legendNode ), true );
}
return;
}
void QgsLayerTreeView::modelRowsInserted( QModelIndex index, int start, int end )
{
QgsLayerTreeNode* parentNode = layerTreeModel()->index2node( index );
if ( !parentNode )
return;
if ( QgsLayerTree::isLayer( parentNode ) )
return; // layers have only symbology nodes (no expanded/collapsed handling)
QList<QgsLayerTreeNode*> children = parentNode->children();
for ( int i = start; i <= end; ++i )
{
updateExpandedStateFromNode( children[i] );
}
// make sure we still have correct current layer
onCurrentChanged();
}
QgsLayerTreeGroup* QgsLayerTreeView::currentGroupNode() const
{
QgsLayerTreeNode* node = currentNode();
if ( QgsLayerTree::isGroup( node ) )
return QgsLayerTree::toGroup( node );
else if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeNode* parent = node->parent();
if ( QgsLayerTree::isGroup( parent ) )
return QgsLayerTree::toGroup( parent );
}
if ( QgsLayerTreeModelLegendNode* legendNode = layerTreeModel()->index2legendNode( selectionModel()->currentIndex() ) )
{
QgsLayerTreeLayer* parent = legendNode->layerNode();
if ( QgsLayerTree::isGroup( parent->parent() ) )
return QgsLayerTree::toGroup( parent->parent() );
}
return 0;
}
void QgsLayerTreeView::modelRowsInserted( const QModelIndex& index, int start, int end )
{
QgsLayerTreeNode* parentNode = layerTreeModel()->index2node( index );
if ( !parentNode )
return;
// Embedded widgets - replace placeholders in the model by actual widgets
if ( layerTreeModel()->testFlag( QgsLayerTreeModel::UseEmbeddedWidgets ) && QgsLayerTree::isLayer( parentNode ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( parentNode );
if ( QgsMapLayer* layer = nodeLayer->layer() )
{
int widgetsCount = layer->customProperty( "embeddedWidgets/count", 0 ).toInt();
QList<QgsLayerTreeModelLegendNode*> legendNodes = layerTreeModel()->layerLegendNodes( nodeLayer );
for ( int i = 0; i < widgetsCount; ++i )
{
QString providerId = layer->customProperty( QString( "embeddedWidgets/%1/id" ).arg( i ) ).toString();
if ( QgsLayerTreeEmbeddedWidgetProvider* provider = QgsLayerTreeEmbeddedWidgetRegistry::instance()->provider( providerId ) )
{
QModelIndex index = layerTreeModel()->legendNode2index( legendNodes[i] );
setIndexWidget( index, provider->createWidget( layer, i ) );
}
}
}
}
if ( QgsLayerTree::isLayer( parentNode ) )
{
// if ShowLegendAsTree flag is enabled in model, we may need to expand some legend nodes
QStringList expandedNodeKeys = parentNode->customProperty( "expandedLegendNodes" ).toStringList();
if ( expandedNodeKeys.isEmpty() )
return;
Q_FOREACH ( QgsLayerTreeModelLegendNode* legendNode, layerTreeModel()->layerLegendNodes( QgsLayerTree::toLayer( parentNode ) ) )
{
QString ruleKey = legendNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString();
if ( expandedNodeKeys.contains( ruleKey ) )
setExpanded( layerTreeModel()->legendNode2index( legendNode ), true );
}
return;
}
void QgsLayerTreeView::refreshLayerSymbology( const QString& layerId )
{
QgsLayerTreeLayer* nodeLayer = layerTreeModel()->rootGroup()->findLayer( layerId );
if ( nodeLayer )
layerTreeModel()->refreshLayerLegend( nodeLayer );
}
QList<QgsLayerTreeNode*> QgsLayerTreeView::selectedNodes( bool skipInternal ) const
{
return layerTreeModel()->indexes2nodes( selectionModel()->selectedIndexes(), skipInternal );
}
QgsLayerTreeNode* QgsLayerTreeView::currentNode() const
{
return layerTreeModel()->index2node( selectionModel()->currentIndex() );
}
void QgsLayerTreeView::onModelReset()
{
updateExpandedStateFromNode( layerTreeModel()->rootGroup() );
}
void QgsLayerTreeView::onExpandedChanged( QgsLayerTreeNode* node, bool expanded )
{
QModelIndex idx = layerTreeModel()->node2index( node );
if ( isExpanded( idx ) != expanded )
setExpanded( idx, expanded );
}
