@@ -1196,30 +1196,45 @@ void QgsLayerTreeModel::addLegendToLayer( QgsLayerTreeLayer* nodeL )
1196
1196
1197
1197
QList<QgsLayerTreeModelLegendNode*> filteredLstNew = filterLegendNodes ( lstNew );
1198
1198
1199
- bool hasOnlyEmbedded = filteredLstNew.count () == 1 && filteredLstNew[0 ]->isEmbeddedInParent ();
1200
-
1201
1199
Q_FOREACH ( QgsLayerTreeModelLegendNode* n, lstNew )
1202
1200
{
1203
1201
n->setParent ( this );
1204
1202
connect ( n, SIGNAL ( dataChanged () ), this , SLOT ( legendNodeDataChanged () ) );
1205
1203
}
1206
1204
1207
- LayerLegendData data;
1208
- data.originalNodes = lstNew;
1209
- data.activeNodes = filteredLstNew;
1210
- data.tree = nullptr ;
1205
+ // See if we have an embedded node - if we do, we will not use it among active nodes.
1206
+ // Legend node embedded in parent does not have to be the first one,
1207
+ // there can be also nodes generated for embedded widgets
1208
+ QgsLayerTreeModelLegendNode* embeddedNode = nullptr ;
1209
+ Q_FOREACH ( QgsLayerTreeModelLegendNode* legendNode, filteredLstNew )
1210
+ {
1211
+ if ( legendNode->isEmbeddedInParent () )
1212
+ {
1213
+ embeddedNode = legendNode;
1214
+ filteredLstNew.removeOne ( legendNode );
1215
+ break ;
1216
+ }
1217
+ }
1218
+
1219
+ LayerLegendTree* legendTree = nullptr ;
1211
1220
1212
1221
// maybe the legend nodes form a tree - try to create a tree structure from the list
1213
1222
if ( testFlag ( ShowLegendAsTree ) )
1214
- tryBuildLegendTree ( data );
1223
+ legendTree = tryBuildLegendTree ( filteredLstNew );
1215
1224
1216
- int count = data. tree ? data. tree ->children [nullptr ].count () : filteredLstNew.count ();
1225
+ int count = legendTree ? legendTree ->children [nullptr ].count () : filteredLstNew.count ();
1217
1226
1218
- if ( ! hasOnlyEmbedded ) beginInsertRows ( node2index ( nodeL ), 0 , count - 1 );
1227
+ if ( !filteredLstNew.isEmpty () ) beginInsertRows ( node2index ( nodeL ), 0 , count - 1 );
1228
+
1229
+ LayerLegendData data;
1230
+ data.originalNodes = lstNew;
1231
+ data.activeNodes = filteredLstNew;
1232
+ data.embeddedNodeInParent = embeddedNode;
1233
+ data.tree = legendTree;
1219
1234
1220
1235
mLegend [nodeL] = data;
1221
1236
1222
- if ( ! hasOnlyEmbedded ) endInsertRows ();
1237
+ if ( !filteredLstNew. isEmpty () ) endInsertRows ();
1223
1238
1224
1239
if ( hasStyleOverride )
1225
1240
ml->styleManager ()->restoreOverrideStyle ();
@@ -1230,11 +1245,11 @@ void QgsLayerTreeModel::addLegendToLayer( QgsLayerTreeLayer* nodeL )
1230
1245
}
1231
1246
1232
1247
1233
- void QgsLayerTreeModel::tryBuildLegendTree ( LayerLegendData& data )
1248
+ QgsLayerTreeModel::LayerLegendTree* QgsLayerTreeModel::tryBuildLegendTree ( const QList<QgsLayerTreeModelLegendNode*>& nodes )
1234
1249
{
1235
1250
// first check whether there are any legend nodes that are not top-level
1236
1251
bool hasParentKeys = false ;
1237
- Q_FOREACH ( QgsLayerTreeModelLegendNode* n, data. activeNodes )
1252
+ Q_FOREACH ( QgsLayerTreeModelLegendNode* n, nodes )
1238
1253
{
1239
1254
if ( !n->data ( QgsLayerTreeModelLegendNode::ParentRuleKeyRole ).toString ().isEmpty () )
1240
1255
{
@@ -1243,30 +1258,31 @@ void QgsLayerTreeModel::tryBuildLegendTree( LayerLegendData& data )
1243
1258
}
1244
1259
}
1245
1260
if ( !hasParentKeys )
1246
- return ; // all legend nodes are top-level => stick with list representation
1261
+ return nullptr ; // all legend nodes are top-level => stick with list representation
1247
1262
1248
1263
// make mapping from rules to nodes and do some sanity checks
1249
1264
QHash<QString, QgsLayerTreeModelLegendNode*> rule2node;
1250
1265
rule2node[QString ()] = nullptr ;
1251
- Q_FOREACH ( QgsLayerTreeModelLegendNode* n, data. activeNodes )
1266
+ Q_FOREACH ( QgsLayerTreeModelLegendNode* n, nodes )
1252
1267
{
1253
1268
QString ruleKey = n->data ( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString ();
1254
1269
if ( ruleKey.isEmpty () ) // in tree all nodes must have key
1255
- return ;
1270
+ return nullptr ;
1256
1271
if ( rule2node.contains ( ruleKey ) ) // and they must be unique
1257
- return ;
1272
+ return nullptr ;
1258
1273
rule2node[ruleKey] = n;
1259
1274
}
1260
1275
1261
1276
// create the tree structure
1262
- data. tree = new LayerLegendTree;
1263
- Q_FOREACH ( QgsLayerTreeModelLegendNode* n, data. activeNodes )
1277
+ LayerLegendTree* tree = new LayerLegendTree;
1278
+ Q_FOREACH ( QgsLayerTreeModelLegendNode* n, nodes )
1264
1279
{
1265
1280
QString parentRuleKey = n->data ( QgsLayerTreeModelLegendNode::ParentRuleKeyRole ).toString ();
1266
1281
QgsLayerTreeModelLegendNode* parent = rule2node.value ( parentRuleKey, nullptr );
1267
- data. tree ->parents [n] = parent;
1268
- data. tree ->children [parent] << n;
1282
+ tree->parents [n] = parent;
1283
+ tree->children [parent] << n;
1269
1284
}
1285
+ return tree;
1270
1286
}
1271
1287
1272
1288
QgsRenderContext* QgsLayerTreeModel::createTemporaryRenderContext () const
@@ -1316,6 +1332,7 @@ QModelIndex QgsLayerTreeModel::legendNode2index( QgsLayerTreeModelLegendNode* le
1316
1332
int row = data.activeNodes .indexOf ( legendNode );
1317
1333
if ( row < 0 ) // legend node may be filtered (exists within the list of original nodes, but not in active nodes)
1318
1334
return QModelIndex ();
1335
+
1319
1336
return index ( row, 0 , parentIndex );
1320
1337
}
1321
1338
@@ -1340,10 +1357,6 @@ int QgsLayerTreeModel::legendRootRowCount( QgsLayerTreeLayer* nL ) const
1340
1357
return data.tree ->children [nullptr ].count ();
1341
1358
1342
1359
int count = data.activeNodes .count ();
1343
-
1344
- if ( legendEmbeddedInParent ( nL ) )
1345
- count--; // one item less -- it is embedded in parent
1346
-
1347
1360
return count;
1348
1361
}
1349
1362
@@ -1408,35 +1421,34 @@ Qt::ItemFlags QgsLayerTreeModel::legendNodeFlags( QgsLayerTreeModelLegendNode* n
1408
1421
1409
1422
bool QgsLayerTreeModel::legendEmbeddedInParent ( QgsLayerTreeLayer* nodeLayer ) const
1410
1423
{
1411
- return legendNodeEmbeddedInParent ( nodeLayer ) ;
1424
+ return mLegend [ nodeLayer]. embeddedNodeInParent != nullptr ;
1412
1425
}
1413
1426
1414
1427
QgsLayerTreeModelLegendNode* QgsLayerTreeModel::legendNodeEmbeddedInParent ( QgsLayerTreeLayer* nodeLayer ) const
1415
1428
{
1416
- // legend node embedded in parent does not have to be the first one...
1417
- // there could be extra legend nodes generated for embedded widgets
1418
- const LayerLegendData& data = mLegend [nodeLayer];
1419
- Q_FOREACH ( QgsLayerTreeModelLegendNode* legendNode, data.activeNodes )
1420
- {
1421
- if ( legendNode->isEmbeddedInParent () )
1422
- return legendNode;
1423
- }
1424
- return nullptr ;
1429
+ return mLegend [nodeLayer].embeddedNodeInParent ;
1425
1430
}
1426
1431
1427
1432
1428
1433
QIcon QgsLayerTreeModel::legendIconEmbeddedInParent ( QgsLayerTreeLayer* nodeLayer ) const
1429
1434
{
1430
- QgsLayerTreeModelLegendNode* legendNode = legendNodeEmbeddedInParent ( nodeLayer ) ;
1435
+ QgsLayerTreeModelLegendNode* legendNode = mLegend [ nodeLayer]. embeddedNodeInParent ;
1431
1436
if ( !legendNode )
1432
1437
return QIcon ();
1433
1438
return QIcon ( qvariant_cast<QPixmap>( legendNode->data ( Qt::DecorationRole ) ) );
1434
1439
}
1435
1440
1436
1441
1437
- QList<QgsLayerTreeModelLegendNode*> QgsLayerTreeModel::layerLegendNodes ( QgsLayerTreeLayer* nodeLayer )
1442
+ QList<QgsLayerTreeModelLegendNode*> QgsLayerTreeModel::layerLegendNodes ( QgsLayerTreeLayer* nodeLayer, bool skipNodeEmbeddedInParent )
1438
1443
{
1439
- return mLegend .value ( nodeLayer ).activeNodes ;
1444
+ if ( !mLegend .contains ( nodeLayer ) )
1445
+ return QList<QgsLayerTreeModelLegendNode*>();
1446
+
1447
+ const LayerLegendData& data = mLegend [nodeLayer];
1448
+ QList<QgsLayerTreeModelLegendNode*> lst ( data.activeNodes );
1449
+ if ( !skipNodeEmbeddedInParent && data.embeddedNodeInParent )
1450
+ lst.prepend ( data.embeddedNodeInParent );
1451
+ return lst;
1440
1452
}
1441
1453
1442
1454
QList<QgsLayerTreeModelLegendNode*> QgsLayerTreeModel::layerOriginalLegendNodes ( QgsLayerTreeLayer* nodeLayer )
0 commit comments