qgslegendrenderer.cpp

Go to the documentation of this file.

/***************************************************************************
  qgslegendrenderer.cpp
  --------------------------------------
  Date                 : July 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 "qgslegendrenderer.h"
 
#include <memory>
 
#include "qgsexpressioncontextutils.h"
#include "qgslayertree.h"
#include "qgslayertreefilterproxymodel.h"
#include "qgslayertreemodel.h"
#include "qgslayertreemodellegendnode.h"
#include "qgslegendstyle.h"
#include "qgsrendercontext.h"
#include "qgstextdocument.h"
#include "qgstextdocumentmetrics.h"
#include "qgstextrenderer.h"
 
#include <QJsonObject>
#include <QPainter>
#include <QString>
 
using namespace Qt::StringLiterals;
 
QgsLegendRenderer::QgsLegendRenderer( QgsLayerTreeModel *legendModel, const QgsLegendSettings &settings )
  : mLegendModel( legendModel )
  , mProxyModel( std::make_unique< QgsLayerTreeFilterProxyModel >() )
  , mSettings( settings )
{
  mProxyModel->setLayerTreeModel( mLegendModel );
}
 
QgsLegendRenderer::QgsLegendRenderer( QgsLegendRenderer &&other )
  : mLegendModel( other.mLegendModel )
  , mProxyModel( std::move( other.mProxyModel ) )
  , mSettings( std::move( other.mSettings ) )
  , mLegendSize( other.mLegendSize )
{
  mProxyModel->setLayerTreeModel( mLegendModel );
}
 
void QgsLegendRenderer::setProxyModel( QgsLayerTreeFilterProxyModel *model )
{
  if ( mProxyModel.get() == model )
    return;
 
  mProxyModel.reset( model );
  mProxyModel->setLayerTreeModel( mLegendModel );
}
 
QgsLegendRenderer::~QgsLegendRenderer() = default;
 
QSizeF QgsLegendRenderer::minimumSize( QgsRenderContext *renderContext )
{
  std::unique_ptr< QgsRenderContext > tmpContext;
 
  if ( !renderContext )
  {
    // QGIS 5.0 - make render context mandatory
    Q_NOWARN_DEPRECATED_PUSH
    tmpContext = std::make_unique<QgsRenderContext>( QgsRenderContext::fromQPainter( nullptr ) );
    tmpContext->setRendererScale( mSettings.mapScale() );
    tmpContext->setMapToPixel( QgsMapToPixel( 1 / ( mSettings.mmPerMapUnit() * tmpContext->scaleFactor() ) ) );
    tmpContext->setFlag( Qgis::RenderContextFlag::ApplyScalingWorkaroundForTextRendering, true );
    renderContext = tmpContext.get();
    Q_NOWARN_DEPRECATED_POP
  }
 
  QgsScopedRenderContextPainterSwap nullPainterSwap( *renderContext, nullptr );
  return paintAndDetermineSize( *renderContext );
}
 
void QgsLegendRenderer::drawLegend( QPainter *painter )
{
  Q_NOWARN_DEPRECATED_PUSH
  QgsRenderContext context = QgsRenderContext::fromQPainter( painter );
  QgsScopedRenderContextScaleToMm scaleToMm( context );
 
  context.setRendererScale( mSettings.mapScale() );
  context.setMapToPixel( QgsMapToPixel( 1 / ( mSettings.mmPerMapUnit() * context.scaleFactor() ) ) );
  Q_NOWARN_DEPRECATED_POP
 
  paintAndDetermineSize( context );
}
 
QJsonObject QgsLegendRenderer::exportLegendToJson( const QgsRenderContext &context )
{
  QJsonObject json;
 
  QgsLayerTreeGroup *rootGroup = mLegendModel->rootGroup();
  if ( !rootGroup )
    return json;
 
  json = exportLegendToJson( context, rootGroup );
  json[u"title"_s] = mSettings.title();
  return json;
}
 
QJsonObject QgsLegendRenderer::exportLegendToJson( const QgsRenderContext &context, QgsLayerTreeGroup *nodeGroup )
{
  QJsonObject json;
  QJsonArray nodes;
  const QList<QgsLayerTreeNode *> childNodes = nodeGroup->children();
  for ( QgsLayerTreeNode *node : childNodes )
  {
    if ( !mProxyModel->nodeShown( node ) )
      continue;
 
    if ( QgsLayerTree::isGroup( node ) )
    {
      QgsLayerTreeGroup *nodeGroup = QgsLayerTree::toGroup( node );
      const QModelIndex idx = mLegendModel->node2index( nodeGroup );
      const QString text = mLegendModel->data( idx, Qt::DisplayRole ).toString();
 
      QJsonObject group = exportLegendToJson( context, nodeGroup );
      group[u"type"_s] = u"group"_s;
      group[u"title"_s] = text;
      nodes.append( group );
    }
    else if ( QgsLayerTree::isLayer( node ) )
    {
      QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
 
      QString text;
      if ( nodeLegendStyle( nodeLayer ) != Qgis::LegendComponent::Hidden )
      {
        const QModelIndex idx = mLegendModel->node2index( nodeLayer );
        text = mLegendModel->data( idx, Qt::DisplayRole ).toString();
      }
 
      QList<QgsLayerTreeModelLegendNode *> legendNodes = mLegendModel->layerLegendNodes( nodeLayer );
 
      if ( legendNodes.isEmpty() && mLegendModel->legendFilterMapSettings() )
        continue;
 
      if ( legendNodes.count() == 1 )
      {
        QJsonObject group = legendNodes.at( 0 )->exportToJson( mSettings, context );
        group[u"type"_s] = u"layer"_s;
        if ( mSettings.jsonRenderFlags().testFlag( Qgis::LegendJsonRenderFlag::ShowRuleDetails ) )
        {
          if ( QgsVectorLayer *vLayer = qobject_cast<QgsVectorLayer *>( nodeLayer->layer() ) )
          {
            if ( vLayer->renderer() )
            {
              const QString ruleKey { legendNodes.at( 0 )->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::RuleKey ) ).toString() };
              if ( !ruleKey.isEmpty() )
              {
                bool ok = false;
                const QString ruleExp { vLayer->renderer()->legendKeyToExpression( ruleKey, vLayer, ok ) };
                if ( ok )
                {
                  group[u"rule"_s] = ruleExp;
                }
              }
            }
          }
        }
        nodes.append( group );
      }
      else if ( legendNodes.count() > 1 )
      {
        QJsonObject group;
        group[u"type"_s] = u"layer"_s;
        group[u"title"_s] = text;
 
        QJsonArray symbols;
        for ( int j = 0; j < legendNodes.count(); j++ )
        {
          QgsLayerTreeModelLegendNode *legendNode = legendNodes.at( j );
          QJsonObject symbol = legendNode->exportToJson( mSettings, context );
          if ( mSettings.jsonRenderFlags().testFlag( Qgis::LegendJsonRenderFlag::ShowRuleDetails ) )
          {
            if ( QgsVectorLayer *vLayer = qobject_cast<QgsVectorLayer *>( nodeLayer->layer() ) )
            {
              if ( vLayer->renderer() )
              {
                const QString ruleKey { legendNode->data( static_cast< int >( QgsLayerTreeModelLegendNode::CustomRole::RuleKey ) ).toString() };
                if ( !ruleKey.isEmpty() )
                {
                  bool ok = false;
                  const QString ruleExp { vLayer->renderer()->legendKeyToExpression( ruleKey, vLayer, ok ) };
                  if ( ok )
                  {
                    symbol[u"rule"_s] = ruleExp;
                  }
                }
              }
            }
          }
          symbols.append( symbol );
        }
        group[u"symbols"_s] = symbols;
 
        nodes.append( group );
      }
    }
  }
 
  json[u"nodes"_s] = nodes;
  return json;
}
 
QSizeF QgsLegendRenderer::paintAndDetermineSize( QgsRenderContext &context )
{
  QSizeF size( 0, 0 );
  QgsLayerTreeGroup *rootGroup = mLegendModel->rootGroup();
  if ( !rootGroup )
    return size;
 
  mSettings.updateDataDefinedProperties( context );
 
  // temporarily remove painter from context -- we don't need to actually draw anything yet. But we DO need
  // to send the full render context so that an expression context is available during the size calculation
  QgsScopedRenderContextPainterSwap noPainter( context, nullptr );
 
  QList<LegendComponentGroup> componentGroups = createComponentGroupList( rootGroup, context );
 
  const int columnCount = setColumns( componentGroups );
 
  QMap< int, double > maxColumnWidths;
  qreal maxEqualColumnWidth = 0;
  // another iteration -- this one is required to calculate the maximum item width for each
  // column. Unfortunately, we can't trust the component group widths at this stage, as they are minimal widths
  // only. When actually rendering a symbol node, the text is aligned according to the WIDEST
  // symbol in a column. So that means we can't possibly determine the exact size of legend components
  // until now. BUUUUUUUUUUUUT. Because everything sucks, we can't even start the actual render of items
  // at the same time we calculate this -- legend items REQUIRE the REAL width of the columns in order to
  // correctly align right or center-aligned symbols/text. Bah -- A triple iteration it is!
  for ( const LegendComponentGroup &group : std::as_const( componentGroups ) )
  {
    const QSizeF actualSize = drawGroup( group, context, ColumnContext() );
    maxEqualColumnWidth = std::max( actualSize.width(), maxEqualColumnWidth );
    maxColumnWidths[group.column] = std::max( actualSize.width(), maxColumnWidths.value( group.column, 0 ) );
  }
 
  if ( columnCount == 1 )
  {
    // single column - use the full available width
    maxEqualColumnWidth = std::max( maxEqualColumnWidth, mLegendSize.width() - 2 * mSettings.boxSpace() );
    maxColumnWidths[0] = maxEqualColumnWidth;
  }
 
  //calculate size of title
  QSizeF titleSize = drawTitle( context, 0 );
  //add title margin to size of title text
  titleSize.rwidth() += mSettings.boxSpace() * 2.0;
  double columnTop = mSettings.boxSpace() + titleSize.height() + mSettings.style( Qgis::LegendComponent::Title ).margin( QgsLegendStyle::Bottom );
 
  noPainter.reset();
 
  bool firstInColumn = true;
  double columnMaxHeight = 0;
  qreal columnWidth = 0;
  int column = -1;
  ColumnContext columnContext;
  columnContext.left = mSettings.boxSpace();
  columnContext.right = std::max( mLegendSize.width() - mSettings.boxSpace(), mSettings.boxSpace() );
  double currentY = columnTop;
 
  for ( const LegendComponentGroup &group : std::as_const( componentGroups ) )
  {
    if ( group.column > column )
    {
      // Switch to next column
      columnContext.left = group.column > 0 ? ( columnContext.right + mSettings.columnSpace() ) : mSettings.boxSpace();
      columnWidth = mSettings.equalColumnWidth() ? maxEqualColumnWidth : maxColumnWidths.value( group.column );
      columnContext.right = columnContext.left + columnWidth;
      currentY = columnTop;
      column++;
      firstInColumn = true;
    }
    if ( !firstInColumn )
    {
      currentY += spaceAboveGroup( group );
    }
 
    drawGroup( group, context, columnContext, currentY );
 
    currentY += group.size.height();
    columnMaxHeight = std::max( currentY - columnTop, columnMaxHeight );
 
    firstInColumn = false;
  }
  const double totalWidth = columnContext.right + mSettings.boxSpace();
 
  size.rheight() = columnTop + columnMaxHeight + mSettings.boxSpace();
  size.rwidth() = totalWidth;
  if ( !mSettings.title().isEmpty() )
  {
    size.rwidth() = std::max( titleSize.width(), size.width() );
  }
 
  // override the size if it was set by the user
  if ( mLegendSize.isValid() )
  {
    qreal w = std::max( size.width(), mLegendSize.width() );
    qreal h = std::max( size.height(), mLegendSize.height() );
    size = QSizeF( w, h );
  }
 
  // Now we have set the correct total item width and can draw the title centered
  if ( !mSettings.title().isEmpty() )
  {
    drawTitle( context, mSettings.boxSpace(), mSettings.titleAlignment(), size.width() );
  }
 
  return size;
}
 
void QgsLegendRenderer::widthAndOffsetForTitleText( const Qt::AlignmentFlag halignment, const double legendWidth, double &textBoxWidth, double &textBoxLeft ) const
{
  switch ( halignment )
  {
    default:
      textBoxLeft = mSettings.boxSpace();
      textBoxWidth = legendWidth - 2 * mSettings.boxSpace();
      break;
 
    case Qt::AlignHCenter:
    {
      // not sure on this logic, I just moved it -- don't blame me for it being totally obscure!
      const double centerX = legendWidth / 2;
      textBoxWidth = ( std::min( static_cast< double >( centerX ), legendWidth - centerX ) - mSettings.boxSpace() ) * 2.0;
      textBoxLeft = centerX - textBoxWidth / 2.;
      break;
    }
  }
}
 
QList<QgsLegendRenderer::LegendComponentGroup> QgsLegendRenderer::createComponentGroupList( QgsLayerTreeGroup *parentGroup, QgsRenderContext &context, double indent )
{
  QList<LegendComponentGroup> componentGroups;
 
  if ( !parentGroup )
    return componentGroups;
 
  const QList<QgsLayerTreeNode *> childNodes = parentGroup->children();
  for ( QgsLayerTreeNode *node : childNodes )
  {
    if ( !mProxyModel->nodeShown( node ) )
      continue;
 
    if ( QgsLayerTree::isGroup( node ) )
    {
      QgsLayerTreeGroup *nodeGroup = QgsLayerTree::toGroup( node );
      QString style = node->customProperty( u"legend/title-style"_s ).toString();
      // Update the required indent for the group/subgroup items, starting from the indent accumulated from parent groups
      double newIndent = indent;
      if ( style == "subgroup"_L1 )
      {
        newIndent += mSettings.style( Qgis::LegendComponent::Subgroup ).indent();
      }
      else
      {
        newIndent += mSettings.style( Qgis::LegendComponent::Group ).indent();
      }
 
      // Group subitems
      QList<LegendComponentGroup> subgroups = createComponentGroupList( nodeGroup, context, newIndent );
 
      bool hasSubItems = !subgroups.empty();
 
      if ( nodeLegendStyle( nodeGroup ) != Qgis::LegendComponent::Hidden )
      {
        LegendComponent component;
        component.item = node;
        component.indent = newIndent;
        component.size = drawGroupTitle( nodeGroup, context );
 
        if ( !subgroups.isEmpty() )
        {
          // Add internal space between this group title and the next component
          subgroups[0].size.rheight() += spaceAboveGroup( subgroups[0] );
          // Prepend this group title to the first group
          subgroups[0].components.prepend( component );
          subgroups[0].size.rheight() += component.size.height();
          subgroups[0].size.rwidth() = std::max( component.size.width(), subgroups[0].size.width() );
          if ( nodeGroup->customProperty( u"legend/column-break"_s ).toInt() )
            subgroups[0].placeColumnBreakBeforeGroup = true;
        }
        else
        {
          // no subitems, create new group
          LegendComponentGroup group;
          group.placeColumnBreakBeforeGroup = nodeGroup->customProperty( u"legend/column-break"_s ).toInt();
          group.components.append( component );
          group.size.rwidth() += component.size.width();
          group.size.rheight() += component.size.height();
          group.size.rwidth() = std::max( component.size.width(), group.size.width() );
          subgroups.append( group );
        }
      }
 
      if ( hasSubItems ) //leave away groups without content
      {
        componentGroups.append( subgroups );
      }
    }
    else if ( QgsLayerTree::isLayer( node ) )
    {
      QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
      Qgis::LegendComponent layerStyle = nodeLegendStyle( nodeLayer );
      bool allowColumnSplit = false;
      switch ( nodeLayer->legendSplitBehavior() )
      {
        case QgsLayerTreeLayer::UseDefaultLegendSetting:
          allowColumnSplit = mSettings.splitLayer();
          break;
        case QgsLayerTreeLayer::AllowSplittingLegendNodesOverMultipleColumns:
          allowColumnSplit = true;
          break;
        case QgsLayerTreeLayer::PreventSplittingLegendNodesOverMultipleColumns:
          allowColumnSplit = false;
          break;
      }
 
      LegendComponentGroup group;
      group.placeColumnBreakBeforeGroup = nodeLayer->customProperty( u"legend/column-break"_s ).toInt();
 
      if ( layerStyle != Qgis::LegendComponent::Hidden )
      {
        LegendComponent component;
        component.item = node;
        component.size = drawLayerTitle( nodeLayer, context );
        component.indent = indent;
        group.components.append( component );
        group.size.rwidth() = component.size.width();
        group.size.rheight() = component.size.height();
      }
 
      QList<QgsLayerTreeModelLegendNode *> legendNodes = mLegendModel->layerLegendNodes( nodeLayer );
 
      // workaround for the issue that "filtering by map" does not remove layer nodes that have no symbols present
      // on the map. We explicitly skip such layers here. In future ideally that should be handled directly
      // in the layer tree model
      if ( legendNodes.isEmpty() && mLegendModel->legendFilterMapSettings() )
        continue;
 
      QList<LegendComponentGroup> layerGroups;
      layerGroups.reserve( legendNodes.count() );
 
      bool groupIsLayerGroup = true;
      double symbolIndent = indent;
      switch ( layerStyle )
      {
        case Qgis::LegendComponent::Subgroup:
        case Qgis::LegendComponent::Group:
          symbolIndent += mSettings.style( layerStyle ).indent();
          break;
        default:
          break;
      }
      for ( int j = 0; j < legendNodes.count(); j++ )
      {
        QgsLayerTreeModelLegendNode *legendNode = legendNodes.at( j );
 
        LegendComponent symbolComponent = drawSymbolItem( legendNode, context, ColumnContext(), 0 );
 
        const bool forceBreak = legendNode->columnBreak();
 
        if ( !allowColumnSplit || j == 0 )
        {
          if ( forceBreak )
          {
            if ( groupIsLayerGroup )
              layerGroups.prepend( group );
            else
              layerGroups.append( group );
 
            group = LegendComponentGroup();
            group.placeColumnBreakBeforeGroup = true;
            groupIsLayerGroup = false;
          }
 
          // append to layer group
          // the width is not correct at this moment, we must align all symbol labels
          group.size.rwidth() = std::max( symbolComponent.size.width(), group.size.width() );
          // Add symbol space only if there is already title or another item above
          if ( !group.components.isEmpty() )
          {
            // TODO: for now we keep Symbol and SymbolLabel Top margin in sync
            group.size.rheight() += mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Top );
          }
          group.size.rheight() += symbolComponent.size.height();
          symbolComponent.indent = symbolIndent;
          group.components.append( symbolComponent );
        }
        else
        {
          if ( group.size.height() > 0 )
          {
            if ( groupIsLayerGroup )
              layerGroups.prepend( group );
            else
              layerGroups.append( group );
            group = LegendComponentGroup();
            groupIsLayerGroup = false;
          }
          LegendComponentGroup symbolGroup;
          symbolGroup.placeColumnBreakBeforeGroup = forceBreak;
          symbolComponent.indent = symbolIndent;
          symbolGroup.components.append( symbolComponent );
          symbolGroup.size.rwidth() = symbolComponent.size.width();
          symbolGroup.size.rheight() = symbolComponent.size.height();
          layerGroups.append( symbolGroup );
        }
      }
      if ( group.size.height() > 0 )
      {
        if ( groupIsLayerGroup )
          layerGroups.prepend( group );
        else
          layerGroups.append( group );
      }
      componentGroups.append( layerGroups );
    }
  }
 
  return componentGroups;
}
 
 
int QgsLegendRenderer::setColumns( QList<LegendComponentGroup> &componentGroups )
{
  // Divide groups to columns
  double totalHeight = 0;
  qreal maxGroupHeight = 0;
  int forcedColumnBreaks = 0;
  double totalSpaceAboveGroups = 0;
 
  for ( const LegendComponentGroup &group : std::as_const( componentGroups ) )
  {
    const double topMargin = spaceAboveGroup( group );
    totalHeight += topMargin;
    totalSpaceAboveGroups += topMargin;
 
    const double groupHeight = group.size.height();
    totalHeight += groupHeight;
    maxGroupHeight = std::max( groupHeight, maxGroupHeight );
 
    if ( group.placeColumnBreakBeforeGroup )
      forcedColumnBreaks++;
  }
  const double totalGroupHeight = ( totalHeight - totalSpaceAboveGroups );
  double averageGroupHeight = totalGroupHeight / componentGroups.size();
 
  if ( mSettings.columnCount() == 0 && forcedColumnBreaks == 0 )
    return 0;
 
  // the target number of columns allowed is dictated by the number of forced column
  // breaks OR the manually set column count (whichever is greater!)
  const int targetNumberColumns = std::max( forcedColumnBreaks + 1, mSettings.columnCount() );
  const int numberAutoPlacedBreaks = targetNumberColumns - forcedColumnBreaks - 1;
 
  // We know height of each group and we have to split them into columns
  // minimizing max column height. It is sort of bin packing problem, NP-hard.
  // We are using simple heuristic, brute fore appeared to be to slow,
  // the number of combinations is N = n!/(k!*(n-k)!) where n = groupCount-1
  // and k = columnsCount-1
  double maxColumnHeight = 0;
  int currentColumn = 0;
  int currentColumnGroupCount = 0; // number of groups in current column
  double currentColumnHeight = 0;
  int autoPlacedBreaks = 0;
 
  // Calculate the expected average space between items
  double averageSpaceAboveGroups = 0;
  if ( componentGroups.size() > targetNumberColumns )
    averageSpaceAboveGroups = totalSpaceAboveGroups / ( componentGroups.size() );
 
  double totalRemainingGroupHeight = totalGroupHeight;
  double totalRemainingSpaceAboveGroups = totalSpaceAboveGroups;
  for ( int i = 0; i < componentGroups.size(); i++ )
  {
    const LegendComponentGroup &group = componentGroups.at( i );
    const double currentGroupHeight = group.size.height();
    const double spaceAboveCurrentGroup = spaceAboveGroup( group );
 
    totalRemainingGroupHeight -= currentGroupHeight;
    totalRemainingSpaceAboveGroups -= spaceAboveCurrentGroup;
 
    double currentColumnHeightIfGroupIsIncluded = currentColumnHeight;
    if ( currentColumnGroupCount > 0 )
      currentColumnHeightIfGroupIsIncluded += spaceAboveCurrentGroup;
    currentColumnHeightIfGroupIsIncluded += currentGroupHeight;
 
    const int numberRemainingGroupsIncludingThisOne = componentGroups.size() - i;
    const int numberRemainingColumnsIncludingThisOne = numberAutoPlacedBreaks + 1 - autoPlacedBreaks;
    const int numberRemainingColumnBreaks = numberRemainingColumnsIncludingThisOne - 1;
 
    const double averageRemainingSpaceAboveGroups = numberRemainingGroupsIncludingThisOne > 1 ? ( totalRemainingSpaceAboveGroups / ( numberRemainingGroupsIncludingThisOne - 1 ) ) : 0;
    const double estimatedRemainingSpaceAboveGroupsWhichWontBeUsedBecauseGroupsAreFirstInColumn = numberRemainingColumnBreaks * averageRemainingSpaceAboveGroups;
    const double estimatedRemainingTotalHeightAfterThisGroup = totalRemainingGroupHeight + totalRemainingSpaceAboveGroups - estimatedRemainingSpaceAboveGroupsWhichWontBeUsedBecauseGroupsAreFirstInColumn;
 
    const double estimatedTotalHeightOfRemainingColumnsIncludingThisOne = currentColumnHeightIfGroupIsIncluded + estimatedRemainingTotalHeightAfterThisGroup;
 
    // Recalc average height for remaining columns including current
    double averageRemainingColumnHeightIncludingThisOne = estimatedTotalHeightOfRemainingColumnsIncludingThisOne / numberRemainingColumnsIncludingThisOne;
 
    // Round up to the next full number of groups to put in one column
    // This ensures that earlier columns contain more elements than later columns
    const int averageGroupsPerRemainingColumnsIncludingThisOne = std::ceil( averageRemainingColumnHeightIncludingThisOne / ( averageGroupHeight + averageSpaceAboveGroups ) );
 
    averageRemainingColumnHeightIncludingThisOne = averageGroupsPerRemainingColumnsIncludingThisOne * ( averageGroupHeight + averageSpaceAboveGroups ) - averageSpaceAboveGroups;
 
    bool canCreateNewColumn = ( currentColumnGroupCount > 0 )                // do not leave empty column
                              && ( currentColumn < targetNumberColumns - 1 ) // must not exceed max number of columns
                              && ( autoPlacedBreaks < numberAutoPlacedBreaks );
 
    bool shouldCreateNewColumn = currentColumnHeightIfGroupIsIncluded > averageRemainingColumnHeightIncludingThisOne // current group height is greater than expected group height
                                 && currentColumnGroupCount > 0                                                      // do not leave empty column
                                 && currentColumnHeightIfGroupIsIncluded > maxGroupHeight                            // no sense to make smaller columns than max group height
                                 && currentColumnHeightIfGroupIsIncluded > maxColumnHeight;                          // no sense to make smaller columns than max column already created
 
    shouldCreateNewColumn |= group.placeColumnBreakBeforeGroup;
    canCreateNewColumn |= group.placeColumnBreakBeforeGroup;
 
    // also should create a new column if the number of items left < number of columns left
    // in this case we should spread the remaining items out over the remaining columns
    shouldCreateNewColumn |= ( componentGroups.size() - i < targetNumberColumns - currentColumn );
 
    if ( canCreateNewColumn && shouldCreateNewColumn )
    {
      // New column
      currentColumn++;
      if ( !group.placeColumnBreakBeforeGroup )
        autoPlacedBreaks++;
      currentColumnGroupCount = 0;
      currentColumnHeight = group.size.height();
    }
    else
    {
      currentColumnHeight = currentColumnHeightIfGroupIsIncluded;
    }
    componentGroups[i].column = currentColumn;
    currentColumnGroupCount++;
    maxColumnHeight = std::max( currentColumnHeight, maxColumnHeight );
  }
 
  auto refineColumns = [&componentGroups, this]() -> bool {
    QHash< int, double > columnHeights;
    QHash< int, int > columnGroupCounts;
    double currentColumnHeight = 0;
    int currentColumn = -1;
    int columnCount = 0;
    int groupCount = 0;
    double maxCurrentColumnHeight = 0;
    for ( int i = 0; i < componentGroups.size(); i++ )
    {
      const LegendComponentGroup &group = componentGroups.at( i );
      if ( group.column != currentColumn )
      {
        if ( currentColumn >= 0 )
        {
          columnHeights.insert( currentColumn, currentColumnHeight );
          columnGroupCounts.insert( currentColumn, groupCount );
        }
 
        currentColumn = group.column;
        currentColumnHeight = 0;
        groupCount = 0;
        columnCount = std::max( columnCount, currentColumn + 1 );
      }
 
      const double spaceAbove = spaceAboveGroup( group );
      currentColumnHeight += spaceAbove + group.size.height();
      groupCount++;
    }
    columnHeights.insert( currentColumn, currentColumnHeight );
    columnGroupCounts.insert( currentColumn, groupCount );
 
    double totalColumnHeights = 0;
    for ( int i = 0; i < columnCount; ++i )
    {
      totalColumnHeights += columnHeights[i];
      maxCurrentColumnHeight = std::max( maxCurrentColumnHeight, columnHeights[i] );
    }
 
    const double averageColumnHeight = totalColumnHeights / columnCount;
 
    bool changed = false;
    int nextCandidateColumnForShift = 1;
    for ( int i = 0; i < componentGroups.size(); i++ )
    {
      LegendComponentGroup &group = componentGroups[i];
      if ( group.column < nextCandidateColumnForShift )
        continue;
 
      // try shifting item to previous group
      const bool canShift = !group.placeColumnBreakBeforeGroup && columnGroupCounts[group.column] >= 2;
 
      if ( canShift && columnHeights[group.column - 1] < averageColumnHeight && ( columnHeights[group.column - 1] + group.size.height() ) * 0.9 < maxCurrentColumnHeight )
      {
        group.column -= 1;
        columnHeights[group.column] += group.size.height() + spaceAboveGroup( group );
        columnGroupCounts[group.column]++;
        columnHeights[group.column + 1] -= group.size.height();
        columnGroupCounts[group.column + 1]--;
        changed = true;
      }
      else
      {
        nextCandidateColumnForShift = group.column + 1;
      }
    }
    return changed;
  };
 
  bool wasRefined = true;
  int iterations = 0;
  while ( wasRefined && iterations < 2 )
  {
    wasRefined = refineColumns();
    iterations++;
  }
 
  // Align labels of symbols for each layer/column to the same labelXOffset
  QMap<QString, qreal> maxSymbolWidth;
  for ( int i = 0; i < componentGroups.size(); i++ )
  {
    LegendComponentGroup &group = componentGroups[i];
    for ( int j = 0; j < group.components.size(); j++ )
    {
      if ( QgsLayerTreeModelLegendNode *legendNode = qobject_cast<QgsLayerTreeModelLegendNode *>( group.components.at( j ).item ) )
      {
        QString key = u"%1-%2"_s.arg( reinterpret_cast< qulonglong >( legendNode->layerNode() ) ).arg( group.column );
        maxSymbolWidth[key] = std::max( group.components.at( j ).symbolSize.width(), maxSymbolWidth[key] );
      }
    }
  }
  for ( int i = 0; i < componentGroups.size(); i++ )
  {
    LegendComponentGroup &group = componentGroups[i];
    for ( int j = 0; j < group.components.size(); j++ )
    {
      if ( QgsLayerTreeModelLegendNode *legendNode = qobject_cast<QgsLayerTreeModelLegendNode *>( group.components.at( j ).item ) )
      {
        QString key = u"%1-%2"_s.arg( reinterpret_cast< qulonglong >( legendNode->layerNode() ) ).arg( group.column );
        double space = mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Right ) + mSettings.style( Qgis::LegendComponent::SymbolLabel ).margin( QgsLegendStyle::Left );
        group.components[j].labelXOffset = maxSymbolWidth[key] + space;
        group.components[j].maxSiblingSymbolWidth = maxSymbolWidth[key];
        group.components[j].size.rwidth() = maxSymbolWidth[key] + space + group.components.at( j ).labelSize.width();
      }
    }
  }
  return targetNumberColumns;
}
 
QSizeF QgsLegendRenderer::drawTitle( QgsRenderContext &context, double top, Qt::AlignmentFlag halignment, double legendWidth ) const
{
  QSizeF size( 0, 0 );
  if ( mSettings.title().isEmpty() )
  {
    return size;
  }
  const double dotsPerMM = context.scaleFactor();
 
  const QgsTextFormat titleFormat = mSettings.style( Qgis::LegendComponent::Title ).textFormat();
 
  QStringList lines = mSettings.splitStringForWrapping( mSettings.title() );
  const QgsTextDocument textDocument = QgsTextDocument::fromTextAndFormat( lines, titleFormat );
 
  QgsTextDocumentRenderContext documentContext;
  QgsScopedRenderContextScaleToPixels scaleToPx( context );
  if ( mSettings.autoWrapLinesAfter() > 0 )
  {
    documentContext.setMaximumWidth( context.convertToPainterUnits( mSettings.autoWrapLinesAfter(), Qgis::RenderUnit::Millimeters ) );
    documentContext.setFlags( Qgis::TextRendererFlag::WrapLines );
  }
 
  //calculate width and left pos of rectangle to draw text into
  double textBoxWidth;
  double textBoxLeft;
  widthAndOffsetForTitleText( halignment, legendWidth, textBoxWidth, textBoxLeft );
 
  const double textScaleFactor = QgsTextRenderer::calculateScaleFactorForFormat( context, titleFormat );
  const QgsTextDocumentMetrics textDocumentMetrics = QgsTextDocumentMetrics::calculateMetrics( textDocument, titleFormat, context, textScaleFactor, documentContext );
  const double overallTextHeight = textDocumentMetrics.documentSize( Qgis::TextLayoutMode::Rectangle, Qgis::TextOrientation::Horizontal ).height();
  const double overallTextWidth = textDocumentMetrics.documentSize( Qgis::TextLayoutMode::Rectangle, Qgis::TextOrientation::Horizontal ).width();
 
  size.rheight() = overallTextHeight / dotsPerMM;
  size.rwidth() = overallTextWidth / dotsPerMM;
 
  if ( context.painter() )
  {
    const QRectF r( textBoxLeft * dotsPerMM, top * dotsPerMM, textBoxWidth * dotsPerMM, overallTextHeight );
 
    Qgis::TextHorizontalAlignment halign = halignment == Qt::AlignLeft    ? Qgis::TextHorizontalAlignment::Left
                                           : halignment == Qt::AlignRight ? Qgis::TextHorizontalAlignment::Right
                                                                          : Qgis::TextHorizontalAlignment::Center;
 
    QgsTextRenderer::drawDocument( r, titleFormat, textDocumentMetrics.document(), textDocumentMetrics, context, halign, Qgis::TextVerticalAlignment::Top );
  }
 
  return size;
}
 
 
double QgsLegendRenderer::spaceAboveGroup( const LegendComponentGroup &group )
{
  if ( group.components.isEmpty() )
    return 0;
 
  LegendComponent component = group.components.first();
 
  if ( QgsLayerTreeGroup *nodeGroup = qobject_cast<QgsLayerTreeGroup *>( component.item ) )
  {
    return mSettings.style( nodeLegendStyle( nodeGroup ) ).margin( QgsLegendStyle::Top );
  }
  else if ( QgsLayerTreeLayer *nodeLayer = qobject_cast<QgsLayerTreeLayer *>( component.item ) )
  {
    return mSettings.style( nodeLegendStyle( nodeLayer ) ).margin( QgsLegendStyle::Top );
  }
  else if ( qobject_cast<QgsLayerTreeModelLegendNode *>( component.item ) )
  {
    // TODO: use Symbol or SymbolLabel Top margin
    return mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Top );
  }
 
  return 0;
}
 
QSizeF QgsLegendRenderer::drawGroup( const LegendComponentGroup &group, QgsRenderContext &context, ColumnContext columnContext, double top )
{
  bool first = true;
  QSizeF size = QSizeF( group.size );
  double currentY = top;
  for ( const LegendComponent &component : std::as_const( group.components ) )
  {
    if ( QgsLayerTreeGroup *groupItem = qobject_cast<QgsLayerTreeGroup *>( component.item ) )
    {
      Qgis::LegendComponent s = nodeLegendStyle( groupItem );
      if ( s != Qgis::LegendComponent::Hidden )
      {
        if ( !first )
        {
          currentY += mSettings.style( s ).margin( QgsLegendStyle::Top );
        }
        QSizeF groupSize;
        ColumnContext columnContextForItem = columnContext;
        double indentWidth = component.indent;
        if ( s == Qgis::LegendComponent::Subgroup )
        {
          // Remove indent - the subgroup items should be indented, not the subgroup title
          indentWidth -= mSettings.style( Qgis::LegendComponent::Subgroup ).indent();
        }
        else
        {
          // Remove indent - the group items should be indented, not the group title
          indentWidth -= mSettings.style( Qgis::LegendComponent::Group ).indent();
        }
        if ( mSettings.style( Qgis::LegendComponent::SymbolLabel ).alignment() == Qt::AlignLeft )
        {
          columnContextForItem.left += indentWidth;
        }
        if ( mSettings.style( Qgis::LegendComponent::SymbolLabel ).alignment() == Qt::AlignRight )
        {
          columnContextForItem.right -= indentWidth;
        }
        groupSize = drawGroupTitle( groupItem, context, columnContextForItem, currentY );
        size.rwidth() = std::max( groupSize.width(), size.width() );
      }
    }
    else if ( QgsLayerTreeLayer *layerItem = qobject_cast<QgsLayerTreeLayer *>( component.item ) )
    {
      Qgis::LegendComponent s = nodeLegendStyle( layerItem );
      if ( s != Qgis::LegendComponent::Hidden )
      {
        if ( !first )
        {
          currentY += mSettings.style( s ).margin( QgsLegendStyle::Top );
        }
        QSizeF subGroupSize;
 
        ColumnContext columnContextForItem = columnContext;
        double indentWidth = component.indent;
        columnContextForItem.left += indentWidth;
        subGroupSize = drawLayerTitle( layerItem, context, columnContextForItem, currentY );
        size.rwidth() = std::max( subGroupSize.width(), size.width() );
      }
    }
    else if ( QgsLayerTreeModelLegendNode *legendNode = qobject_cast<QgsLayerTreeModelLegendNode *>( component.item ) )
    {
      if ( !first )
      {
        currentY += mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Top );
      }
 
      ColumnContext columnContextForItem = columnContext;
      double indentWidth = 0;
      indentWidth = component.indent;
      if ( mSettings.style( Qgis::LegendComponent::SymbolLabel ).alignment() == Qt::AlignLeft )
      {
        columnContextForItem.left += indentWidth;
      }
      if ( mSettings.style( Qgis::LegendComponent::SymbolLabel ).alignment() == Qt::AlignRight )
      {
        columnContextForItem.right -= indentWidth;
      }
 
      LegendComponent symbolComponent = drawSymbolItem( legendNode, context, columnContextForItem, currentY, component.maxSiblingSymbolWidth );
      // expand width, it may be wider because of label offsets
      size.rwidth() = std::max( symbolComponent.size.width() + indentWidth, size.width() );
    }
    currentY += component.size.height();
    first = false;
  }
  return size;
}
 
QgsLegendRenderer::LegendComponent QgsLegendRenderer::drawSymbolItem( QgsLayerTreeModelLegendNode *symbolItem, QgsRenderContext &context, ColumnContext columnContext, double top, double maxSiblingSymbolWidth )
{
  QgsLayerTreeModelLegendNode::ItemContext ctx;
  ctx.context = &context;
 
  // add a layer expression context scope
  QgsExpressionContextScope *layerScope = nullptr;
  if ( symbolItem->layerNode()->layer() )
  {
    layerScope = QgsExpressionContextUtils::layerScope( symbolItem->layerNode()->layer() );
    context.expressionContext().appendScope( layerScope );
  }
 
  ctx.painter = context.painter();
  Q_NOWARN_DEPRECATED_PUSH
  ctx.point = QPointF( columnContext.left, top );
  ctx.labelXOffset = maxSiblingSymbolWidth;
  Q_NOWARN_DEPRECATED_POP
 
  ctx.top = top;
 
  ctx.columnLeft = columnContext.left;
  ctx.columnRight = columnContext.right;
 
  switch ( mSettings.symbolAlignment() )
  {
    case Qt::AlignLeft:
    default:
      ctx.columnLeft += mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Left );
      break;
 
    case Qt::AlignRight:
      ctx.columnRight -= mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Left );
      break;
  }
 
  ctx.maxSiblingSymbolWidth = maxSiblingSymbolWidth;
 
  QgsExpressionContextScope *symbolScope = nullptr;
  if ( const QgsSymbolLegendNode *symbolNode = dynamic_cast< const QgsSymbolLegendNode * >( symbolItem ) )
  {
    symbolScope = symbolNode->createSymbolScope();
    context.expressionContext().appendScope( symbolScope );
    ctx.patchShape = symbolNode->patchShape();
  }
 
  ctx.patchSize = symbolItem->userPatchSize();
 
  QgsLayerTreeModelLegendNode::ItemMetrics im = symbolItem->draw( mSettings, ctx );
 
  if ( symbolScope )
    delete context.expressionContext().popScope();
 
  if ( layerScope )
    delete context.expressionContext().popScope();
 
  LegendComponent component;
  component.item = symbolItem;
  component.symbolSize = im.symbolSize;
  component.labelSize = im.labelSize;
  //QgsDebugMsgLevel( u"symbol height = %1 label height = %2"_s.arg( symbolSize.height()).arg( labelSize.height() ), 2);
  // NOTE -- we hard code left/right margins below, because those are the only ones exposed for use currently.
  // ideally we could (should?) expose all these margins as settings, and then adapt the below to respect the current symbol/text alignment
  // and consider the correct margin sides...
  double width = std::max( static_cast< double >( im.symbolSize.width() ), maxSiblingSymbolWidth )
                 + mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Left )
                 + mSettings.style( Qgis::LegendComponent::Symbol ).margin( QgsLegendStyle::Right )
                 + mSettings.style( Qgis::LegendComponent::SymbolLabel ).margin( QgsLegendStyle::Left )
                 + im.labelSize.width();
 
  double height = std::max( im.symbolSize.height(), im.labelSize.height() );
  component.size = QSizeF( width, height );
  return component;
}
 
QSizeF QgsLegendRenderer::drawLayerTitle( QgsLayerTreeLayer *nodeLayer, QgsRenderContext &context, ColumnContext columnContext, double top )
{
  QSizeF size( 0, 0 );
  QModelIndex idx = mLegendModel->node2index( nodeLayer );
  QString titleString = mLegendModel->data( idx, Qt::DisplayRole ).toString();
  //Let the user omit the layer title item by having an empty layer title string
  if ( titleString.isEmpty() )
    return size;
 
  const double dotsPerMM = context.scaleFactor();
 
  const QgsTextFormat layerFormat = mSettings.style( nodeLegendStyle( nodeLayer ) ).textFormat();
 
  QgsExpressionContextScope *layerScope = nullptr;
  if ( nodeLayer->layer() )
  {
    layerScope = QgsExpressionContextUtils::layerScope( nodeLayer->layer() );
    context.expressionContext().appendScope( layerScope );
  }
 
  const QStringList lines = mSettings.evaluateItemText( titleString, context.expressionContext() );
  const QgsTextDocument textDocument = QgsTextDocument::fromTextAndFormat( lines, layerFormat );
 
  QgsTextDocumentRenderContext documentContext;
  QgsScopedRenderContextScaleToPixels scaleToPx( context );
  if ( mSettings.autoWrapLinesAfter() > 0 )
  {
    documentContext.setMaximumWidth( context.convertToPainterUnits( mSettings.autoWrapLinesAfter(), Qgis::RenderUnit::Millimeters ) );
    documentContext.setFlags( Qgis::TextRendererFlag::WrapLines );
  }
 
  const double textScaleFactor = QgsTextRenderer::calculateScaleFactorForFormat( context, layerFormat );
  const QgsTextDocumentMetrics textDocumentMetrics = QgsTextDocumentMetrics::calculateMetrics( textDocument, layerFormat, context, textScaleFactor, documentContext );
 
  const double overallTextHeight = textDocumentMetrics.documentSize( Qgis::TextLayoutMode::RectangleAscentBased, Qgis::TextOrientation::Horizontal ).height();
  const double overallTextWidth = textDocumentMetrics.documentSize( Qgis::TextLayoutMode::RectangleAscentBased, Qgis::TextOrientation::Horizontal ).width();
 
  const double sideMargin = mSettings.style( nodeLegendStyle( nodeLayer ) ).margin( QgsLegendStyle::Left );
 
  size.rheight() = overallTextHeight / dotsPerMM;
  size.rwidth() = overallTextWidth / dotsPerMM + sideMargin * ( mSettings.style( nodeLegendStyle( nodeLayer ) ).alignment() == Qt::AlignHCenter ? 2 : 1 );
 
  if ( context.painter() )
  {
    Qgis::TextHorizontalAlignment halign = mSettings.style( nodeLegendStyle( nodeLayer ) ).alignment() == Qt::AlignLeft    ? Qgis::TextHorizontalAlignment::Left
                                           : mSettings.style( nodeLegendStyle( nodeLayer ) ).alignment() == Qt::AlignRight ? Qgis::TextHorizontalAlignment::Right
                                                                                                                           : Qgis::TextHorizontalAlignment::Center;
    const QRectF
      r( ( columnContext.left + ( halign == Qgis::TextHorizontalAlignment::Left ? sideMargin : 0 ) ) * dotsPerMM,
         top * dotsPerMM,
         ( ( columnContext.right - columnContext.left ) - ( halign == Qgis::TextHorizontalAlignment::Right ? sideMargin : 0 ) ) * dotsPerMM,
         overallTextHeight );
    QgsTextRenderer::drawDocument( r, layerFormat, textDocumentMetrics.document(), textDocumentMetrics, context, halign, Qgis::TextVerticalAlignment::Top );
  }
 
  size.rheight() += mSettings.style( nodeLegendStyle( nodeLayer ) ).margin( QgsLegendStyle::Side::Bottom );
 
  if ( layerScope )
    delete context.expressionContext().popScope();
 
  return size;
}
 
QSizeF QgsLegendRenderer::drawGroupTitle( QgsLayerTreeGroup *nodeGroup, QgsRenderContext &context, ColumnContext columnContext, double top )
{
  QSizeF size( 0, 0 );
  QModelIndex idx = mLegendModel->node2index( nodeGroup );
 
  const double dotsPerMM = context.scaleFactor();
 
  const QgsTextFormat groupFormat = mSettings.style( nodeLegendStyle( nodeGroup ) ).textFormat();
 
  const QStringList lines = mSettings.evaluateItemText( mLegendModel->data( idx, Qt::DisplayRole ).toString(), context.expressionContext() );
  const QgsTextDocument textDocument = QgsTextDocument::fromTextAndFormat( lines, groupFormat );
 
  QgsTextDocumentRenderContext documentContext;
  QgsScopedRenderContextScaleToPixels scaleToPx( context );
  if ( mSettings.autoWrapLinesAfter() > 0 )
  {
    documentContext.setMaximumWidth( context.convertToPainterUnits( mSettings.autoWrapLinesAfter(), Qgis::RenderUnit::Millimeters ) );
    documentContext.setFlags( Qgis::TextRendererFlag::WrapLines );
  }
 
  const double textScaleFactor = QgsTextRenderer::calculateScaleFactorForFormat( context, groupFormat );
  const QgsTextDocumentMetrics textDocumentMetrics = QgsTextDocumentMetrics::calculateMetrics( textDocument, groupFormat, context, textScaleFactor, documentContext );
 
  const double overallTextHeight = textDocumentMetrics.documentSize( Qgis::TextLayoutMode::RectangleAscentBased, Qgis::TextOrientation::Horizontal ).height();
  const double overallTextWidth = textDocumentMetrics.documentSize( Qgis::TextLayoutMode::RectangleAscentBased, Qgis::TextOrientation::Horizontal ).width();
 
  const double sideMargin = mSettings.style( nodeLegendStyle( nodeGroup ) ).margin( QgsLegendStyle::Left );
 
  size.rheight() = overallTextHeight / dotsPerMM;
  size.rwidth() = overallTextWidth / dotsPerMM + sideMargin * ( mSettings.style( nodeLegendStyle( nodeGroup ) ).alignment() == Qt::AlignHCenter ? 2 : 1 );
 
  if ( context.painter() )
  {
    Qgis::TextHorizontalAlignment halign = mSettings.style( nodeLegendStyle( nodeGroup ) ).alignment() == Qt::AlignLeft    ? Qgis::TextHorizontalAlignment::Left
                                           : mSettings.style( nodeLegendStyle( nodeGroup ) ).alignment() == Qt::AlignRight ? Qgis::TextHorizontalAlignment::Right
                                                                                                                           : Qgis::TextHorizontalAlignment::Center;
 
    const QRectF
      r( dotsPerMM * ( columnContext.left + ( halign == Qgis::TextHorizontalAlignment::Left ? sideMargin : 0 ) ),
         top * dotsPerMM,
         dotsPerMM * ( ( columnContext.right - columnContext.left ) - ( halign == Qgis::TextHorizontalAlignment::Right ? sideMargin : 0 ) ),
         overallTextHeight );
    QgsTextRenderer::drawDocument( r, groupFormat, textDocumentMetrics.document(), textDocumentMetrics, context, halign, Qgis::TextVerticalAlignment::Top );
  }
 
  size.rheight() += mSettings.style( nodeLegendStyle( nodeGroup ) ).margin( QgsLegendStyle::Bottom );
  return size;
}
 
Qgis::LegendComponent QgsLegendRenderer::nodeLegendStyle( QgsLayerTreeNode *node, QgsLayerTreeModel *model )
{
  QString style = node->customProperty( u"legend/title-style"_s ).toString();
  if ( style == "hidden"_L1 )
    return Qgis::LegendComponent::Hidden;
  else if ( style == "group"_L1 )
    return Qgis::LegendComponent::Group;
  else if ( style == "subgroup"_L1 )
    return Qgis::LegendComponent::Subgroup;
 
  // use a default otherwise
  if ( QgsLayerTree::isGroup( node ) )
    return Qgis::LegendComponent::Group;
  else if ( QgsLayerTree::isLayer( node ) )
  {
    if ( model->legendNodeEmbeddedInParent( QgsLayerTree::toLayer( node ) ) )
      return Qgis::LegendComponent::Hidden;
    return Qgis::LegendComponent::Subgroup;
  }
 
  return Qgis::LegendComponent::Undefined; // should not happen, only if corrupted project file
}
 
Qgis::LegendComponent QgsLegendRenderer::nodeLegendStyle( QgsLayerTreeNode *node )
{
  return nodeLegendStyle( node, mLegendModel );
}
 
QgsLayerTreeFilterProxyModel *QgsLegendRenderer::proxyModel()
{
  return mProxyModel.get();
}
 
void QgsLegendRenderer::setNodeLegendStyle( QgsLayerTreeNode *node, Qgis::LegendComponent style )
{
  QString str;
  switch ( style )
  {
    case Qgis::LegendComponent::Hidden:
      str = u"hidden"_s;
      break;
    case Qgis::LegendComponent::Group:
      str = u"group"_s;
      break;
    case Qgis::LegendComponent::Subgroup:
      str = u"subgroup"_s;
      break;
    default:
      break; // nothing
  }
 
  if ( !str.isEmpty() )
    node->setCustomProperty( u"legend/title-style"_s, str );
  else
    node->removeCustomProperty( u"legend/title-style"_s );
}
 
void QgsLegendRenderer::drawLegend( QgsRenderContext &context )
{
  paintAndDetermineSize( context );
}