qgslayertreeutils.cpp

Go to the documentation of this file.

/***************************************************************************
  qgslayertreeutils.cpp
  --------------------------------------
  Date                 : May 2014
  Copyright            : (C) 2014 by Martin Dobias
  Email                : wonder dot sk at gmail dot com
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgslayertreeutils.h"
 
#include "qgslayertree.h"
#include "qgslogger.h"
#include "qgsmaplayer.h"
#include "qgsproject.h"
#include "qgsstringutils.h"
#include "qgsvectorlayer.h"
 
#include <QDomElement>
#include <QString>
#include <QTextStream>
 
using namespace Qt::StringLiterals;
 
static void _readOldLegendGroup( const QDomElement &groupElem, QgsLayerTreeGroup *parent );
static void _readOldLegendLayer( const QDomElement &layerElem, QgsLayerTreeGroup *parent );
 
bool QgsLayerTreeUtils::readOldLegend( QgsLayerTreeGroup *root, const QDomElement &legendElem )
{
  if ( legendElem.isNull() )
    return false;
 
  const QDomNodeList legendChildren = legendElem.childNodes();
 
  for ( int i = 0; i < legendChildren.size(); ++i )
  {
    const QDomElement currentChildElem = legendChildren.at( i ).toElement();
    if ( currentChildElem.tagName() == "legendlayer"_L1 )
    {
      _readOldLegendLayer( currentChildElem, root );
    }
    else if ( currentChildElem.tagName() == "legendgroup"_L1 )
    {
      _readOldLegendGroup( currentChildElem, root );
    }
  }
 
  return true;
}
 
 
static bool _readOldLegendLayerOrderGroup( const QDomElement &groupElem, QMap<int, QString> &layerIndexes )
{
  const QDomNodeList legendChildren = groupElem.childNodes();
 
  for ( int i = 0; i < legendChildren.size(); ++i )
  {
    const QDomElement currentChildElem = legendChildren.at( i ).toElement();
    if ( currentChildElem.tagName() == "legendlayer"_L1 )
    {
      const QDomElement layerFileElem = currentChildElem.firstChildElement( u"filegroup"_s ).firstChildElement( u"legendlayerfile"_s );
 
      const int layerIndex = currentChildElem.attribute( u"drawingOrder"_s ).toInt();
      if ( layerIndex == -1 )
        return false; // order undefined
      layerIndexes.insert( layerIndex, layerFileElem.attribute( u"layerid"_s ) );
    }
    else if ( currentChildElem.tagName() == "legendgroup"_L1 )
    {
      if ( !_readOldLegendLayerOrderGroup( currentChildElem, layerIndexes ) )
        return false;
    }
  }
 
  return true;
}
 
 
bool QgsLayerTreeUtils::readOldLegendLayerOrder( const QDomElement &legendElem, bool &hasCustomOrder, QStringList &order )
{
  if ( legendElem.isNull() )
    return false;
 
  hasCustomOrder = legendElem.attribute( u"updateDrawingOrder"_s ) == "false"_L1;
  order.clear();
 
  QMap<int, QString> layerIndexes;
 
  // try to read the order. may be undefined (order = -1) for some or all items
  const bool res = _readOldLegendLayerOrderGroup( legendElem, layerIndexes );
 
  if ( !res && hasCustomOrder )
    return false; // invalid state
 
  const auto constLayerIndexes = layerIndexes;
  for ( const QString &layerId : constLayerIndexes )
  {
    QgsDebugMsgLevel( layerId, 2 );
    order.append( layerId );
  }
 
  return true;
}
 
 
static QDomElement _writeOldLegendLayer( QDomDocument &doc, QgsLayerTreeLayer *nodeLayer, bool hasCustomOrder, const QList<QgsMapLayer *> &order )
{
  int drawingOrder = -1;
  if ( hasCustomOrder )
    drawingOrder = order.indexOf( nodeLayer->layer() );
 
  QDomElement layerElem = doc.createElement( u"legendlayer"_s );
  layerElem.setAttribute( u"drawingOrder"_s, drawingOrder );
  layerElem.setAttribute( u"open"_s, nodeLayer->isExpanded() ? u"true"_s : u"false"_s );
  layerElem.setAttribute( u"checked"_s, QgsLayerTreeUtils::checkStateToXml( nodeLayer->itemVisibilityChecked() ? Qt::Checked : Qt::Unchecked ) );
  layerElem.setAttribute( u"name"_s, nodeLayer->name() );
  layerElem.setAttribute( u"showFeatureCount"_s, nodeLayer->customProperty( u"showFeatureCount"_s ).toInt() );
 
  QDomElement fileGroupElem = doc.createElement( u"filegroup"_s );
  fileGroupElem.setAttribute( u"open"_s, nodeLayer->isExpanded() ? u"true"_s : u"false"_s );
  fileGroupElem.setAttribute( u"hidden"_s, u"false"_s );
 
  QDomElement layerFileElem = doc.createElement( u"legendlayerfile"_s );
  layerFileElem.setAttribute( u"isInOverview"_s, nodeLayer->customProperty( u"overview"_s ).toInt() );
  layerFileElem.setAttribute( u"layerid"_s, nodeLayer->layerId() );
  layerFileElem.setAttribute( u"visible"_s, nodeLayer->isVisible() ? 1 : 0 );
 
  layerElem.appendChild( fileGroupElem );
  fileGroupElem.appendChild( layerFileElem );
  return layerElem;
}
 
// need forward declaration as write[..]Group and write[..]GroupChildren call each other
static void _writeOldLegendGroupChildren( QDomDocument &doc, QDomElement &groupElem, QgsLayerTreeGroup *nodeGroup, bool hasCustomOrder, const QList<QgsMapLayer *> &order );
 
static QDomElement _writeOldLegendGroup( QDomDocument &doc, QgsLayerTreeGroup *nodeGroup, bool hasCustomOrder, const QList<QgsMapLayer *> &order )
{
  QDomElement groupElem = doc.createElement( u"legendgroup"_s );
  groupElem.setAttribute( u"open"_s, nodeGroup->isExpanded() ? u"true"_s : u"false"_s );
  groupElem.setAttribute( u"name"_s, nodeGroup->name() );
  groupElem.setAttribute( u"checked"_s, QgsLayerTreeUtils::checkStateToXml( nodeGroup->itemVisibilityChecked() ? Qt::Checked : Qt::Unchecked ) );
 
  if ( nodeGroup->customProperty( u"embedded"_s ).toInt() )
  {
    groupElem.setAttribute( u"embedded"_s, 1 );
    groupElem.setAttribute( u"project"_s, nodeGroup->customProperty( u"embedded_project"_s ).toString() );
  }
 
  _writeOldLegendGroupChildren( doc, groupElem, nodeGroup, hasCustomOrder, order );
  return groupElem;
}
 
 
static void _writeOldLegendGroupChildren( QDomDocument &doc, QDomElement &groupElem, QgsLayerTreeGroup *nodeGroup, bool hasCustomOrder, const QList<QgsMapLayer *> &order )
{
  const auto constChildren = nodeGroup->children();
  for ( QgsLayerTreeNode *node : constChildren )
  {
    if ( QgsLayerTree::isGroup( node ) )
    {
      groupElem.appendChild( _writeOldLegendGroup( doc, QgsLayerTree::toGroup( node ), hasCustomOrder, order ) );
    }
    else if ( QgsLayerTree::isLayer( node ) )
    {
      groupElem.appendChild( _writeOldLegendLayer( doc, QgsLayerTree::toLayer( node ), hasCustomOrder, order ) );
    }
  }
}
 
 
QDomElement QgsLayerTreeUtils::writeOldLegend( QDomDocument &doc, QgsLayerTreeGroup *root, bool hasCustomOrder, const QList<QgsMapLayer *> &order )
{
  QDomElement legendElem = doc.createElement( u"legend"_s );
  legendElem.setAttribute( u"updateDrawingOrder"_s, hasCustomOrder ? u"false"_s : u"true"_s );
 
  _writeOldLegendGroupChildren( doc, legendElem, root, hasCustomOrder, order );
 
  return legendElem;
}
 
 
QString QgsLayerTreeUtils::checkStateToXml( Qt::CheckState state )
{
  switch ( state )
  {
    case Qt::Unchecked:
      return u"Qt::Unchecked"_s;
    case Qt::PartiallyChecked:
      return u"Qt::PartiallyChecked"_s;
    case Qt::Checked:
      return u"Qt::Checked"_s;
  }
  return QString();
}
 
Qt::CheckState QgsLayerTreeUtils::checkStateFromXml( const QString &txt )
{
  if ( txt == "Qt::Unchecked"_L1 )
    return Qt::Unchecked;
  else if ( txt == "Qt::PartiallyChecked"_L1 )
    return Qt::PartiallyChecked;
  else // "Qt::Checked"
    return Qt::Checked;
}
 
 
static void _readOldLegendGroup( const QDomElement &groupElem, QgsLayerTreeGroup *parent )
{
  const QDomNodeList groupChildren = groupElem.childNodes();
 
  QgsLayerTreeGroup *groupNode = new QgsLayerTreeGroup( groupElem.attribute( u"name"_s ) );
 
  groupNode->setItemVisibilityChecked( QgsLayerTreeUtils::checkStateFromXml( groupElem.attribute( u"checked"_s ) ) != Qt::Unchecked );
  groupNode->setExpanded( groupElem.attribute( u"open"_s ) == "true"_L1 );
 
  if ( groupElem.attribute( u"embedded"_s ) == "1"_L1 )
  {
    groupNode->setCustomProperty( u"embedded"_s, 1 );
    groupNode->setCustomProperty( u"embedded_project"_s, groupElem.attribute( u"project"_s ) );
  }
 
  for ( int i = 0; i < groupChildren.size(); ++i )
  {
    const QDomElement currentChildElem = groupChildren.at( i ).toElement();
    if ( currentChildElem.tagName() == "legendlayer"_L1 )
    {
      _readOldLegendLayer( currentChildElem, groupNode );
    }
    else if ( currentChildElem.tagName() == "legendgroup"_L1 )
    {
      _readOldLegendGroup( currentChildElem, groupNode );
    }
  }
 
  parent->addChildNode( groupNode );
}
 
static void _readOldLegendLayer( const QDomElement &layerElem, QgsLayerTreeGroup *parent )
{
  const QDomElement layerFileElem = layerElem.firstChildElement( u"filegroup"_s ).firstChildElement( u"legendlayerfile"_s );
  const QString layerId = layerFileElem.attribute( u"layerid"_s );
  QgsLayerTreeLayer *layerNode = new QgsLayerTreeLayer( layerId, layerElem.attribute( u"name"_s ) );
 
  layerNode->setItemVisibilityChecked( QgsLayerTreeUtils::checkStateFromXml( layerElem.attribute( u"checked"_s ) ) != Qt::Unchecked );
  layerNode->setExpanded( layerElem.attribute( u"open"_s ) == "true"_L1 );
 
  if ( layerFileElem.attribute( u"isInOverview"_s ) == "1"_L1 )
    layerNode->setCustomProperty( u"overview"_s, 1 );
 
  if ( layerElem.attribute( u"embedded"_s ) == "1"_L1 )
    layerNode->setCustomProperty( u"embedded"_s, 1 );
 
  if ( layerElem.attribute( u"showFeatureCount"_s ) == "1"_L1 )
    layerNode->setCustomProperty( u"showFeatureCount"_s, 1 );
 
  // drawing order is handled by readOldLegendLayerOrder()
 
  parent->addChildNode( layerNode );
}
 
bool QgsLayerTreeUtils::layersEditable( const QList<QgsLayerTreeLayer *> &layerNodes, bool ignoreLayersWhichCannotBeToggled )
{
  const auto constLayerNodes = layerNodes;
  for ( QgsLayerTreeLayer *layerNode : constLayerNodes )
  {
    QgsMapLayer *layer = layerNode->layer();
    if ( !layer )
      continue;
 
    if ( layer->isEditable() && ( !ignoreLayersWhichCannotBeToggled || !( layer->properties() & Qgis::MapLayerProperty::UsersCannotToggleEditing ) ) )
      return true;
  }
  return false;
}
 
bool QgsLayerTreeUtils::layersModified( const QList<QgsLayerTreeLayer *> &layerNodes )
{
  const auto constLayerNodes = layerNodes;
  for ( QgsLayerTreeLayer *layerNode : constLayerNodes )
  {
    QgsMapLayer *layer = layerNode->layer();
    if ( !layer )
      continue;
 
    if ( layer->isEditable() && layer->isModified() )
      return true;
  }
  return false;
}
 
void QgsLayerTreeUtils::removeInvalidLayers( QgsLayerTreeGroup *group )
{
  QList<QgsLayerTreeNode *> nodesToRemove;
  const auto constChildren = group->children();
  for ( QgsLayerTreeNode *node : constChildren )
  {
    if ( QgsLayerTree::isGroup( node ) )
      removeInvalidLayers( QgsLayerTree::toGroup( node ) );
    else if ( QgsLayerTree::isLayer( node ) )
    {
      if ( !QgsLayerTree::toLayer( node )->layer() )
        nodesToRemove << node;
    }
  }
 
  const auto constNodesToRemove = nodesToRemove;
  for ( QgsLayerTreeNode *node : constNodesToRemove )
    group->removeChildNode( node );
}
 
void QgsLayerTreeUtils::regenerateGroupIds( QgsLayerTreeNode *node )
{
  if ( QgsLayerTree::isGroup( node ) )
    QgsLayerTree::toGroup( node )->setId( QgsStringUtils::createUniqueId( u"group"_s ) );
 
  const QList<QgsLayerTreeNode *> children = node->children();
  for ( QgsLayerTreeNode *child : children )
    regenerateGroupIds( child );
}
 
void QgsLayerTreeUtils::storeOriginalLayersProperties( QgsLayerTreeGroup *group, const QDomDocument *doc )
{
  const QDomElement projectLayersElement { doc->documentElement().firstChildElement( u"projectlayers"_s ) };
 
  std::function<void( QgsLayerTreeNode * )> _store = [&]( QgsLayerTreeNode *node ) {
    if ( QgsLayerTree::isLayer( node ) )
    {
      if ( QgsMapLayer *l = QgsLayerTree::toLayer( node )->layer() )
      {
        // no need to store for annotation layers, they can never break!
        if ( l->type() == Qgis::LayerType::Annotation )
          return;
 
        QDomElement layerElement { projectLayersElement.firstChildElement( u"maplayer"_s ) };
        while ( !layerElement.isNull() )
        {
          const QString id( layerElement.firstChildElement( u"id"_s ).firstChild().nodeValue() );
          if ( id == l->id() )
          {
            QString str;
            QTextStream stream( &str );
            layerElement.save( stream, 4 /*indent*/ );
            l->setOriginalXmlProperties( u"<!DOCTYPE qgis PUBLIC 'http://mrcc.com/qgis.dtd' 'SYSTEM'>\n%1"_s.arg( str ) );
            break;
          }
          layerElement = layerElement.nextSiblingElement();
        }
      }
    }
    else if ( QgsLayerTree::isGroup( node ) )
    {
      const QList<QgsLayerTreeNode *> constChildren( node->children() );
      for ( const auto &childNode : constChildren )
      {
        _store( childNode );
      }
    }
  };
 
  const QList<QgsLayerTreeNode *> children = group->children();
  for ( QgsLayerTreeNode *node : children )
  {
    _store( node );
  }
}
 
QStringList QgsLayerTreeUtils::invisibleLayerList( QgsLayerTreeNode *node )
{
  QStringList list;
 
  if ( QgsLayerTree::isGroup( node ) )
  {
    const auto constChildren = QgsLayerTree::toGroup( node )->children();
    for ( QgsLayerTreeNode *child : constChildren )
    {
      if ( child->itemVisibilityChecked() == Qt::Unchecked )
      {
        list << invisibleLayerList( child );
      }
    }
  }
  else if ( QgsLayerTree::isLayer( node ) )
  {
    QgsLayerTreeLayer *layer = QgsLayerTree::toLayer( node );
 
    if ( !layer->isVisible() )
      list << layer->layerId();
  }
 
  return list;
}
 
void QgsLayerTreeUtils::replaceChildrenOfEmbeddedGroups( QgsLayerTreeGroup *group )
{
  const auto constChildren = group->children();
  for ( QgsLayerTreeNode *child : constChildren )
  {
    if ( QgsLayerTree::isGroup( child ) )
    {
      if ( child->customProperty( u"embedded"_s ).toInt() )
      {
        child->setCustomProperty( u"embedded-invisible-layers"_s, invisibleLayerList( child ) );
        QgsLayerTree::toGroup( child )->removeAllChildren();
      }
      else
      {
        replaceChildrenOfEmbeddedGroups( QgsLayerTree::toGroup( child ) );
      }
    }
  }
}
 
 
void QgsLayerTreeUtils::updateEmbeddedGroupsProjectPath( QgsLayerTreeGroup *group, const QgsProject *project )
{
  const auto constChildren = group->children();
  for ( QgsLayerTreeNode *node : constChildren )
  {
    if ( !node->customProperty( u"embedded_project"_s ).toString().isEmpty() )
    {
      // may change from absolute path to relative path
      const QString newPath = project->writePath( node->customProperty( u"embedded_project"_s ).toString() );
      node->setCustomProperty( u"embedded_project"_s, newPath );
    }
 
    if ( QgsLayerTree::isGroup( node ) )
    {
      updateEmbeddedGroupsProjectPath( QgsLayerTree::toGroup( node ), project );
    }
  }
}
 
void QgsLayerTreeUtils::setLegendFilterByExpression( QgsLayerTreeLayer &layer, const QString &expr, bool enabled )
{
  layer.setCustomProperty( u"legend/expressionFilter"_s, expr );
  layer.setCustomProperty( u"legend/expressionFilterEnabled"_s, enabled && !expr.isEmpty() );
}
 
QString QgsLayerTreeUtils::legendFilterByExpression( const QgsLayerTreeLayer &layer, bool *enabled )
{
  const QString expression = layer.customProperty( u"legend/expressionFilter"_s, QString() ).toString();
  if ( enabled )
    *enabled = !expression.isEmpty() && layer.customProperty( u"legend/expressionFilterEnabled"_s, QString() ).toBool();
  return expression;
}
 
bool QgsLayerTreeUtils::hasLegendFilterExpression( const QgsLayerTreeGroup &group )
{
  const auto constFindLayers = group.findLayers();
  for ( QgsLayerTreeLayer *l : constFindLayers )
  {
    bool exprEnabled;
    const QString expr = legendFilterByExpression( *l, &exprEnabled );
    if ( exprEnabled && !expr.isEmpty() )
    {
      return true;
    }
  }
  return false;
}
 
QgsLayerTreeLayer *QgsLayerTreeUtils::insertLayerBelow( QgsLayerTreeGroup *group, const QgsMapLayer *refLayer, QgsMapLayer *layerToInsert )
{
  // get the index of the reflayer
  QgsLayerTreeLayer *inTree = group->findLayer( refLayer->id() );
  if ( !inTree )
    return nullptr;
 
  int idx = 0;
  const auto constChildren = inTree->parent()->children();
  for ( QgsLayerTreeNode *vl : constChildren )
  {
    if ( vl->nodeType() == QgsLayerTreeNode::NodeLayer && static_cast<QgsLayerTreeLayer *>( vl )->layer() == refLayer )
    {
      break;
    }
    idx++;
  }
  // insert the new layer
  QgsLayerTreeGroup *parent = static_cast<QgsLayerTreeGroup *>( inTree->parent() ) ? static_cast<QgsLayerTreeGroup *>( inTree->parent() ) : group;
  return parent->insertLayer( idx + 1, layerToInsert );
}
 
static void _collectMapLayers( const QList<QgsLayerTreeNode *> &nodes, QSet<QgsMapLayer *> &layersSet )
{
  for ( QgsLayerTreeNode *node : nodes )
  {
    if ( QgsLayerTree::isLayer( node ) )
    {
      QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
      if ( nodeLayer->layer() )
        layersSet << nodeLayer->layer();
    }
    else if ( QgsLayerTree::isGroup( node ) )
    {
      _collectMapLayers( QgsLayerTree::toGroup( node )->children(), layersSet );
    }
  }
}
 
QSet<QgsMapLayer *> QgsLayerTreeUtils::collectMapLayersRecursive( const QList<QgsLayerTreeNode *> &nodes )
{
  QSet<QgsMapLayer *> layersSet;
  _collectMapLayers( nodes, layersSet );
  return layersSet;
}
 
int QgsLayerTreeUtils::countMapLayerInTree( QgsLayerTreeNode *tree, QgsMapLayer *layer )
{
  if ( QgsLayerTree::isLayer( tree ) )
  {
    if ( QgsLayerTree::toLayer( tree )->layer() == layer )
      return 1;
    return 0;
  }
 
  int cnt = 0;
  const QList<QgsLayerTreeNode *> children = tree->children();
  for ( QgsLayerTreeNode *child : children )
    cnt += countMapLayerInTree( child, layer );
  return cnt;
}
 
QgsLayerTreeGroup *QgsLayerTreeUtils::firstGroupWithoutCustomProperty( QgsLayerTreeGroup *group, const QString &property )
{
  // if the group is embedded go to the first non-embedded group, at worst the top level item
  while ( group->customProperty( property ).toInt() )
  {
    if ( !group->parent() )
      break;
 
    if ( QgsLayerTree::isGroup( group->parent() ) )
      group = QgsLayerTree::toGroup( group->parent() );
    else
      Q_ASSERT( false );
  }
  return group;
}
 
QgsLayerTreeLayer *QgsLayerTreeUtils::insertLayerAtOptimalPlacement( QgsLayerTreeGroup *group, QgsMapLayer *layer )
{
  int vectorLineIndex = 0;
  int vectorPolygonIndex = 0;
  int pointCloudIndex = 0;
  int meshIndex = 0;
  int rasterIndex = 0;
  int basemapIndex = 0;
 
  const QList<QgsLayerTreeNode *> children = group->children();
  int nodeIdx = 0;
  for ( const QgsLayerTreeNode *child : children )
  {
    if ( QgsLayerTree::isLayer( child ) )
    {
      nodeIdx++;
      const QgsMapLayer *childLayer = qobject_cast<const QgsLayerTreeLayer *>( child )->layer();
      if ( !childLayer )
        continue;
 
      switch ( childLayer->type() )
      {
        case Qgis::LayerType::Vector:
        {
          const QgsVectorLayer *vlayer = static_cast<const QgsVectorLayer *>( childLayer );
          if ( vlayer->geometryType() == Qgis::GeometryType::Point )
          {
            if ( vectorLineIndex < nodeIdx )
              vectorLineIndex = nodeIdx;
            if ( vectorPolygonIndex < nodeIdx )
              vectorPolygonIndex = nodeIdx;
            if ( pointCloudIndex < nodeIdx )
              pointCloudIndex = nodeIdx;
            if ( meshIndex < nodeIdx )
              meshIndex = nodeIdx;
            if ( rasterIndex < nodeIdx )
              rasterIndex = nodeIdx;
            if ( basemapIndex < nodeIdx )
              basemapIndex = nodeIdx;
          }
          else if ( vlayer->geometryType() == Qgis::GeometryType::Line )
          {
            if ( vectorPolygonIndex < nodeIdx )
              vectorPolygonIndex = nodeIdx;
            if ( pointCloudIndex < nodeIdx )
              pointCloudIndex = nodeIdx;
            if ( meshIndex < nodeIdx )
              meshIndex = nodeIdx;
            if ( rasterIndex < nodeIdx )
              rasterIndex = nodeIdx;
            if ( basemapIndex < nodeIdx )
              basemapIndex = nodeIdx;
          }
          else if ( vlayer->geometryType() == Qgis::GeometryType::Polygon )
          {
            if ( pointCloudIndex < nodeIdx )
              pointCloudIndex = nodeIdx;
            if ( meshIndex < nodeIdx )
              meshIndex = nodeIdx;
            if ( rasterIndex < nodeIdx )
              rasterIndex = nodeIdx;
            if ( basemapIndex < nodeIdx )
              basemapIndex = nodeIdx;
          }
          break;
        }
 
        case Qgis::LayerType::PointCloud:
        {
          if ( meshIndex < nodeIdx )
            meshIndex = nodeIdx;
          if ( rasterIndex < nodeIdx )
            rasterIndex = nodeIdx;
          if ( basemapIndex < nodeIdx )
            basemapIndex = nodeIdx;
          break;
        }
 
        case Qgis::LayerType::Mesh:
        {
          if ( rasterIndex < nodeIdx )
            rasterIndex = nodeIdx;
          if ( basemapIndex < nodeIdx )
            basemapIndex = nodeIdx;
          break;
        }
 
        case Qgis::LayerType::Raster:
        {
          if ( childLayer->dataProvider() && childLayer->dataProvider()->name() == "gdal"_L1 )
          {
            // Assume non-gdal raster layers are most likely to be base maps (e.g. XYZ raster)
            // Admittedly a gross assumption, but better than nothing
            if ( basemapIndex < nodeIdx )
              basemapIndex = nodeIdx;
          }
          break;
        }
 
        case Qgis::LayerType::VectorTile:
        case Qgis::LayerType::Annotation:
        case Qgis::LayerType::Group:
        case Qgis::LayerType::Plugin:
        default:
          break;
      }
    }
  }
 
  int index = 0;
  switch ( layer->type() )
  {
    case Qgis::LayerType::Vector:
    {
      QgsVectorLayer *vlayer = static_cast<QgsVectorLayer *>( layer );
      if ( vlayer->geometryType() == Qgis::GeometryType::Point )
      {
        index = 0;
      }
      else if ( vlayer->geometryType() == Qgis::GeometryType::Line )
      {
        index = vectorLineIndex;
      }
      else if ( vlayer->geometryType() == Qgis::GeometryType::Polygon )
      {
        index = vectorPolygonIndex;
      }
      break;
    }
 
    case Qgis::LayerType::PointCloud:
    {
      index = pointCloudIndex;
      break;
    }
 
    case Qgis::LayerType::Mesh:
    {
      index = meshIndex;
      break;
    }
 
    case Qgis::LayerType::Raster:
    {
      if ( layer->dataProvider() && layer->dataProvider()->name() == "gdal"_L1 )
      {
        index = rasterIndex;
      }
      else
      {
        index = basemapIndex;
      }
      break;
    }
 
    case Qgis::LayerType::VectorTile:
    {
      index = basemapIndex;
      break;
    }
 
    case Qgis::LayerType::Annotation:
    case Qgis::LayerType::Group:
    case Qgis::LayerType::Plugin:
    default:
      break;
  }
  return group->insertLayer( index, layer );
}