qgsannotationrectitem.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsannotationrectitem.cpp
    ----------------
    begin                : July 2024
    copyright            : (C) 2024 by Nyall Dawson
    email                : nyall dot dawson 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 "qgsannotationrectitem.h"
 
#include "qgsannotationitemeditoperation.h"
#include "qgsannotationitemnode.h"
#include "qgsapplication.h"
#include "qgscalloutsregistry.h"
#include "qgsfillsymbol.h"
#include "qgsfillsymbollayer.h"
#include "qgsgeometry.h"
#include "qgslinestring.h"
#include "qgslinesymbollayer.h"
#include "qgspainting.h"
#include "qgspolygon.h"
#include "qgsrendercontext.h"
#include "qgssymbollayerutils.h"
#include "qgsunittypes.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;
 
QgsAnnotationRectItem::QgsAnnotationRectItem( const QgsRectangle &bounds )
  : QgsAnnotationItem()
  , mBounds( bounds )
{
  mBackgroundSymbol = std::make_unique< QgsFillSymbol >(
    QgsSymbolLayerList { new QgsSimpleFillSymbolLayer( QColor( 255, 255, 255 ), Qt::BrushStyle::SolidPattern, QColor( 0, 0, 0 ), Qt::PenStyle::NoPen ) }
  );
  QgsSimpleLineSymbolLayer *borderSymbol = new QgsSimpleLineSymbolLayer( QColor( 0, 0, 0 ) );
  borderSymbol->setPenJoinStyle( Qt::MiterJoin );
  mFrameSymbol = std::make_unique< QgsFillSymbol >( QgsSymbolLayerList { borderSymbol } );
}
 
QgsAnnotationRectItem::~QgsAnnotationRectItem() = default;
 
Qgis::AnnotationItemFlags QgsAnnotationRectItem::flags() const
{
  switch ( mPlacementMode )
  {
    case Qgis::AnnotationPlacementMode::SpatialBounds:
      return Qgis::AnnotationItemFlag::SupportsCallouts;
    case Qgis::AnnotationPlacementMode::FixedSize:
      return Qgis::AnnotationItemFlag::ScaleDependentBoundingBox | Qgis::AnnotationItemFlag::SupportsCallouts;
    case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
      return Qgis::AnnotationItemFlag::ScaleDependentBoundingBox;
  }
  BUILTIN_UNREACHABLE
}
 
double QgsAnnotationRectItem::appliedRotation( double mapRotation ) const
{
  double angle = mRotation;
  if ( mRotationMode == Qgis::SymbolRotationMode::RespectMapRotation && mPlacementMode != Qgis::AnnotationPlacementMode::RelativeToMapFrame )
    angle += mapRotation;
  return angle;
}
 
QgsGeometry QgsAnnotationRectItem::rotatedBoundsGeometry( const QgsRectangle &layerBounds, const QgsRenderContext &renderContext ) const
{
  const double angle = appliedRotation( renderContext.mapToPixel().mapRotation() );
  if ( qgsDoubleNear( angle, 0 ) )
    return QgsGeometry::fromRect( layerBounds );
 
  // Rotate in painter coordinates, then convert back to layer coordinates so
  // the preview matches the rendered item.
  QgsRectangle mapBounds = layerBounds;
  if ( renderContext.coordinateTransform().isValid() )
  {
    try
    {
      mapBounds = renderContext.coordinateTransform().transformBoundingBox( layerBounds );
    }
    catch ( QgsCsException & )
    {
      return QgsGeometry::fromRect( layerBounds );
    }
  }
 
  QPointF center = mapBounds.center().toQPointF();
  renderContext.mapToPixel().transformInPlace( center.rx(), center.ry() );
  const double mupp = renderContext.mapToPixel().mapUnitsPerPixel();
  const double widthPixels = mapBounds.width() / mupp;
  const double heightPixels = mapBounds.height() / mupp;
  const QRectF painterBounds( center.x() - widthPixels * 0.5, center.y() - heightPixels * 0.5, widthPixels, heightPixels );
 
  QTransform transform;
  transform.translate( center.x(), center.y() );
  transform.rotate( angle );
  transform.translate( -center.x(), -center.y() );
 
  QVector< QgsPointXY > points;
  points.reserve( 5 );
  for ( const QPointF &corner : { painterBounds.topLeft(), painterBounds.topRight(), painterBounds.bottomRight(), painterBounds.bottomLeft() } )
    points.append( QgsPointXY( transform.map( corner ) ) );
  points.append( points.constFirst() );
 
  QgsGeometry geometry( new QgsPolygon( new QgsLineString( points ) ) );
  geometry.transform( renderContext.mapToPixel().transform().inverted() );
  if ( renderContext.coordinateTransform().isValid() )
    geometry.transform( renderContext.coordinateTransform(), Qgis::TransformDirection::Reverse );
  return geometry;
}
 
QgsRectangle QgsAnnotationRectItem::boundsFromPixelRect( const QgsMapToPixel *mapToPixel, const QPointF &centerPixel, double widthPixels, double heightPixels )
{
  const QgsPointXY centerMap = mapToPixel->toMapCoordinates( centerPixel.x(), centerPixel.y() );
  const double mupp = mapToPixel->mapUnitsPerPixel();
  const double halfWidthMap = 0.5 * widthPixels * mupp;
  const double halfHeightMap = 0.5 * heightPixels * mupp;
  return QgsRectangle( centerMap.x() - halfWidthMap, centerMap.y() - halfHeightMap, centerMap.x() + halfWidthMap, centerMap.y() + halfHeightMap );
}
 
void QgsAnnotationRectItem::render( QgsRenderContext &context, QgsFeedback *feedback )
{
  QgsRectangle bounds = mBounds;
  if ( mPlacementMode != Qgis::AnnotationPlacementMode::RelativeToMapFrame && context.coordinateTransform().isValid() )
  {
    try
    {
      bounds = context.coordinateTransform().transformBoundingBox( mBounds );
    }
    catch ( QgsCsException & )
    {
      return;
    }
  }
 
  QRectF painterBounds;
 
  switch ( mPlacementMode )
  {
    case Qgis::AnnotationPlacementMode::SpatialBounds:
    {
      // Use the unrotated pixel size around the transformed center, not the
      // axis-aligned bbox, so the size stays correct when the map is rotated.
      QPointF center = bounds.center().toQPointF();
      context.mapToPixel().transformInPlace( center.rx(), center.ry() );
      const double mupp = context.mapToPixel().mapUnitsPerPixel();
      const double widthPixels = bounds.width() / mupp;
      const double heightPixels = bounds.height() / mupp;
      painterBounds = QRectF( center.x() - widthPixels * 0.5, center.y() - heightPixels * 0.5, widthPixels, heightPixels );
      break;
    }
 
    case Qgis::AnnotationPlacementMode::FixedSize:
    {
      const double widthPixels = context.convertToPainterUnits( mFixedSize.width(), mFixedSizeUnit );
      const double heightPixels = context.convertToPainterUnits( mFixedSize.height(), mFixedSizeUnit );
 
      if ( callout() && !calloutAnchor().isEmpty() )
      {
        QgsGeometry anchor = calloutAnchor();
 
        const double calloutOffsetWidthPixels = context.convertToPainterUnits( offsetFromCallout().width(), offsetFromCalloutUnit() );
        const double calloutOffsetHeightPixels = context.convertToPainterUnits( offsetFromCallout().height(), offsetFromCalloutUnit() );
 
        QPointF anchorPoint = anchor.asQPointF();
        if ( context.coordinateTransform().isValid() )
        {
          double x = anchorPoint.x();
          double y = anchorPoint.y();
          double z = 0.0;
          context.coordinateTransform().transformInPlace( x, y, z );
          anchorPoint = QPointF( x, y );
        }
 
        context.mapToPixel().transformInPlace( anchorPoint.rx(), anchorPoint.ry() );
 
        painterBounds = QRectF( anchorPoint.x() + calloutOffsetWidthPixels, anchorPoint.y() + calloutOffsetHeightPixels, widthPixels, heightPixels );
      }
      else
      {
        QPointF center = bounds.center().toQPointF();
 
        context.mapToPixel().transformInPlace( center.rx(), center.ry() );
        painterBounds = QRectF( center.x() - widthPixels * 0.5, center.y() - heightPixels * 0.5, widthPixels, heightPixels );
      }
      break;
    }
 
    case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
    {
      const double widthPixels = context.convertToPainterUnits( mFixedSize.width(), mFixedSizeUnit );
      const double heightPixels = context.convertToPainterUnits( mFixedSize.height(), mFixedSizeUnit );
 
      QPointF center = bounds.center().toQPointF();
      center.rx() *= context.outputSize().width();
      center.ry() *= context.outputSize().height();
 
      painterBounds = QRectF( center.x() - widthPixels * 0.5, center.y() - heightPixels * 0.5, widthPixels, heightPixels );
      break;
    }
  }
 
  if ( painterBounds.width() < 1 || painterBounds.height() < 1 )
    return;
 
  QPainter *painter = context.painter();
  double angle = appliedRotation( context.mapToPixel().mapRotation() );
  const bool rotated = !qgsDoubleNear( angle, 0 );
  const QPointF rotationCenter = painterBounds.center();
 
  QgsScopedQPainterState painterState( painter, QgsScopedQPainterState::InitialState::NoSave );
  if ( mDrawBackground && mBackgroundSymbol )
  {
    if ( rotated )
    {
      painterState.save();
      QgsPainting::rotatePainterAroundPoint( painter, rotationCenter, angle );
    }
    mBackgroundSymbol->startRender( context );
    mBackgroundSymbol->renderPolygon( painterBounds, nullptr, nullptr, context );
    mBackgroundSymbol->stopRender( context );
    if ( rotated )
      painterState.restore();
  }
 
  if ( mPlacementMode != Qgis::AnnotationPlacementMode::RelativeToMapFrame && callout() )
  {
    QgsCallout::QgsCalloutContext calloutContext;
    renderCallout( context, painterBounds, angle, calloutContext, feedback );
  }
 
  if ( rotated )
  {
    painterState.save();
    QgsPainting::rotatePainterAroundPoint( painter, rotationCenter, angle );
  }
 
  renderInBounds( context, painterBounds, feedback );
 
  if ( mDrawFrame && mFrameSymbol )
  {
    mFrameSymbol->startRender( context );
    mFrameSymbol->renderPolygon( painterBounds, nullptr, nullptr, context );
    mFrameSymbol->stopRender( context );
  }
}
 
QList<QgsAnnotationItemNode> QgsAnnotationRectItem::nodesV2( const QgsAnnotationItemEditContext &context ) const
{
  QList<QgsAnnotationItemNode> res;
  switch ( mPlacementMode )
  {
    case Qgis::AnnotationPlacementMode::SpatialBounds:
    {
      res = {
        QgsAnnotationItemNode( QgsVertexId( 0, 0, 0 ), QgsPointXY( mBounds.xMinimum(), mBounds.yMinimum() ), Qgis::AnnotationItemNodeType::VertexHandle, Qt::CursorShape::SizeBDiagCursor ),
        QgsAnnotationItemNode( QgsVertexId( 0, 0, 1 ), QgsPointXY( mBounds.xMaximum(), mBounds.yMinimum() ), Qgis::AnnotationItemNodeType::VertexHandle, Qt::CursorShape::SizeFDiagCursor ),
        QgsAnnotationItemNode( QgsVertexId( 0, 0, 2 ), QgsPointXY( mBounds.xMaximum(), mBounds.yMaximum() ), Qgis::AnnotationItemNodeType::VertexHandle, Qt::CursorShape::SizeBDiagCursor ),
        QgsAnnotationItemNode( QgsVertexId( 0, 0, 3 ), QgsPointXY( mBounds.xMinimum(), mBounds.yMaximum() ), Qgis::AnnotationItemNodeType::VertexHandle, Qt::CursorShape::SizeFDiagCursor ),
      };
 
      QgsPointXY calloutNodePoint;
      if ( !calloutAnchor().isEmpty() )
      {
        calloutNodePoint = calloutAnchor().asPoint();
      }
      else
      {
        calloutNodePoint = mBounds.center();
      }
      res.append( QgsAnnotationItemNode( QgsVertexId( 1, 0, 0 ), calloutNodePoint, Qgis::AnnotationItemNodeType::CalloutHandle ) );
 
      return res;
    }
 
    case Qgis::AnnotationPlacementMode::FixedSize:
    {
      res = { QgsAnnotationItemNode( QgsVertexId( 0, 0, 0 ), mBounds.center(), Qgis::AnnotationItemNodeType::VertexHandle ) };
 
      QgsPointXY calloutNodePoint;
      if ( !calloutAnchor().isEmpty() )
      {
        calloutNodePoint = calloutAnchor().asPoint();
      }
      else
      {
        calloutNodePoint = QgsPointXY( context.currentItemBounds().xMinimum(), context.currentItemBounds().yMinimum() );
      }
      res.append( QgsAnnotationItemNode( QgsVertexId( 1, 0, 0 ), calloutNodePoint, Qgis::AnnotationItemNodeType::CalloutHandle ) );
 
      return res;
    }
 
    case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
    {
      return { QgsAnnotationItemNode( QgsVertexId( 0, 0, 0 ), context.currentItemBounds().center(), Qgis::AnnotationItemNodeType::VertexHandle ) };
    }
  }
  BUILTIN_UNREACHABLE
}
 
Qgis::AnnotationItemEditOperationResult QgsAnnotationRectItem::applyEditV2( QgsAbstractAnnotationItemEditOperation *operation, const QgsAnnotationItemEditContext &context )
{
  switch ( operation->type() )
  {
    case QgsAbstractAnnotationItemEditOperation::Type::MoveNode:
    {
      QgsAnnotationItemEditOperationMoveNode *moveOperation = qgis::down_cast< QgsAnnotationItemEditOperationMoveNode * >( operation );
      if ( moveOperation->nodeId().part == 0 )
      {
        switch ( mPlacementMode )
        {
          case Qgis::AnnotationPlacementMode::SpatialBounds:
          {
            switch ( moveOperation->nodeId().vertex )
            {
              case 0:
                mBounds = QgsRectangle( moveOperation->after().x(), moveOperation->after().y(), mBounds.xMaximum(), mBounds.yMaximum() );
                break;
              case 1:
                mBounds = QgsRectangle( mBounds.xMinimum(), moveOperation->after().y(), moveOperation->after().x(), mBounds.yMaximum() );
                break;
              case 2:
                mBounds = QgsRectangle( mBounds.xMinimum(), mBounds.yMinimum(), moveOperation->after().x(), moveOperation->after().y() );
                break;
              case 3:
                mBounds = QgsRectangle( moveOperation->after().x(), mBounds.yMinimum(), mBounds.xMaximum(), moveOperation->after().y() );
                break;
              default:
                break;
            }
            return Qgis::AnnotationItemEditOperationResult::Success;
          }
 
          case Qgis::AnnotationPlacementMode::FixedSize:
          {
            mBounds = QgsRectangle::fromCenterAndSize( moveOperation->after(), mBounds.width(), mBounds.height() );
            return Qgis::AnnotationItemEditOperationResult::Success;
          }
 
          case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
          {
            const double deltaX = moveOperation->translationXPixels() / context.renderContext().outputSize().width();
            const double deltaY = moveOperation->translationYPixels() / context.renderContext().outputSize().height();
            mBounds = QgsRectangle::fromCenterAndSize( QgsPointXY( mBounds.center().x() + deltaX, mBounds.center().y() + deltaY ), mBounds.width(), mBounds.height() );
            return Qgis::AnnotationItemEditOperationResult::Success;
          }
        }
      }
      else if ( moveOperation->nodeId().part == 1 )
      {
        setCalloutAnchor( QgsGeometry::fromPoint( moveOperation->after() ) );
        if ( !callout() )
        {
          setCallout( QgsApplication::calloutRegistry()->defaultCallout().release() );
        }
        return Qgis::AnnotationItemEditOperationResult::Success;
      }
      break;
    }
 
    case QgsAbstractAnnotationItemEditOperation::Type::TranslateItem:
    {
      QgsAnnotationItemEditOperationTranslateItem *moveOperation = qgis::down_cast< QgsAnnotationItemEditOperationTranslateItem * >( operation );
      switch ( mPlacementMode )
      {
        case Qgis::AnnotationPlacementMode::SpatialBounds:
          mBounds = QgsRectangle(
            mBounds.xMinimum() + moveOperation->translationX(),
            mBounds.yMinimum() + moveOperation->translationY(),
            mBounds.xMaximum() + moveOperation->translationX(),
            mBounds.yMaximum() + moveOperation->translationY()
          );
          break;
 
        case Qgis::AnnotationPlacementMode::FixedSize:
        {
          if ( callout() && !calloutAnchor().isEmpty() )
          {
            const double xOffset = context.renderContext().convertFromPainterUnits( moveOperation->translationXPixels(), offsetFromCalloutUnit() );
            const double yOffset = context.renderContext().convertFromPainterUnits( moveOperation->translationYPixels(), offsetFromCalloutUnit() );
            setOffsetFromCallout( QSizeF( offsetFromCallout().width() + xOffset, offsetFromCallout().height() + yOffset ) );
          }
          else
          {
            mBounds = QgsRectangle(
              mBounds.xMinimum() + moveOperation->translationX(),
              mBounds.yMinimum() + moveOperation->translationY(),
              mBounds.xMaximum() + moveOperation->translationX(),
              mBounds.yMaximum() + moveOperation->translationY()
            );
          }
          break;
        }
 
        case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
        {
          const double deltaX = moveOperation->translationXPixels() / context.renderContext().outputSize().width();
          const double deltaY = moveOperation->translationYPixels() / context.renderContext().outputSize().height();
          mBounds = QgsRectangle::fromCenterAndSize( QgsPointXY( mBounds.center().x() + deltaX, mBounds.center().y() + deltaY ), mBounds.width(), mBounds.height() );
          break;
        }
      }
      return Qgis::AnnotationItemEditOperationResult::Success;
    }
 
    case QgsAbstractAnnotationItemEditOperation::Type::RotateItem:
    {
      QgsAnnotationItemEditOperationRotateItem *rotateOperation = qgis::down_cast< QgsAnnotationItemEditOperationRotateItem * >( operation );
      mRotation = std::fmod( mRotation + rotateOperation->angle(), 360.0 );
      return Qgis::AnnotationItemEditOperationResult::Success;
    }
 
    case QgsAbstractAnnotationItemEditOperation::Type::SetItemBounds:
    {
      mBounds = qgis::down_cast< QgsAnnotationItemEditOperationSetItemBounds * >( operation )->bounds();
      return Qgis::AnnotationItemEditOperationResult::Success;
    }
 
    case QgsAbstractAnnotationItemEditOperation::Type::DeleteNode:
    case QgsAbstractAnnotationItemEditOperation::Type::AddNode:
      break;
  }
  return Qgis::AnnotationItemEditOperationResult::Invalid;
}
 
QgsAnnotationItemEditOperationTransientResults *QgsAnnotationRectItem::transientEditResultsV2( QgsAbstractAnnotationItemEditOperation *operation, const QgsAnnotationItemEditContext &context )
{
  switch ( operation->type() )
  {
    case QgsAbstractAnnotationItemEditOperation::Type::MoveNode:
    {
      QgsAnnotationItemEditOperationMoveNode *moveOperation = qgis::down_cast< QgsAnnotationItemEditOperationMoveNode * >( operation );
      if ( moveOperation->nodeId().part == 0 )
      {
        switch ( mPlacementMode )
        {
          case Qgis::AnnotationPlacementMode::SpatialBounds:
          {
            QgsRectangle modifiedBounds = mBounds;
            switch ( moveOperation->nodeId().vertex )
            {
              case 0:
                modifiedBounds.setXMinimum( moveOperation->after().x() );
                modifiedBounds.setYMinimum( moveOperation->after().y() );
                break;
              case 1:
                modifiedBounds.setXMaximum( moveOperation->after().x() );
                modifiedBounds.setYMinimum( moveOperation->after().y() );
                break;
              case 2:
                modifiedBounds.setXMaximum( moveOperation->after().x() );
                modifiedBounds.setYMaximum( moveOperation->after().y() );
                break;
              case 3:
                modifiedBounds.setXMinimum( moveOperation->after().x() );
                modifiedBounds.setYMaximum( moveOperation->after().y() );
                break;
              default:
                break;
            }
            return new QgsAnnotationItemEditOperationTransientResults( rotatedBoundsGeometry( modifiedBounds, context.renderContext() ) );
          }
          case Qgis::AnnotationPlacementMode::FixedSize:
          {
            const QgsRectangle currentBounds = context.currentItemBounds();
            const QgsRectangle newBounds = QgsRectangle::fromCenterAndSize( moveOperation->after(), currentBounds.width(), currentBounds.height() );
            return new QgsAnnotationItemEditOperationTransientResults( rotatedBoundsGeometry( newBounds, context.renderContext() ) );
          }
          case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
          {
            const QgsRectangle currentBounds = context.currentItemBounds();
            const QgsRectangle newBounds = QgsRectangle::fromCenterAndSize( currentBounds.center() + ( moveOperation->after() - moveOperation->before() ), currentBounds.width(), currentBounds.height() );
            return new QgsAnnotationItemEditOperationTransientResults( QgsGeometry::fromRect( newBounds ) );
          }
        }
      }
      else
      {
        QgsAnnotationItemEditOperationMoveNode *moveOperation = qgis::down_cast< QgsAnnotationItemEditOperationMoveNode * >( operation );
        return new QgsAnnotationItemEditOperationTransientResults( QgsGeometry( moveOperation->after().clone() ) );
      }
      break;
    }
 
    case QgsAbstractAnnotationItemEditOperation::Type::TranslateItem:
    {
      QgsAnnotationItemEditOperationTranslateItem *moveOperation = qgis::down_cast< QgsAnnotationItemEditOperationTranslateItem * >( operation );
      switch ( mPlacementMode )
      {
        case Qgis::AnnotationPlacementMode::SpatialBounds:
        {
          const QgsRectangle modifiedBounds(
            mBounds.xMinimum() + moveOperation->translationX(),
            mBounds.yMinimum() + moveOperation->translationY(),
            mBounds.xMaximum() + moveOperation->translationX(),
            mBounds.yMaximum() + moveOperation->translationY()
          );
          return new QgsAnnotationItemEditOperationTransientResults( rotatedBoundsGeometry( modifiedBounds, context.renderContext() ) );
        }
 
        case Qgis::AnnotationPlacementMode::FixedSize:
        {
          if ( callout() && !calloutAnchor().isEmpty() )
          {
            QgsGeometry anchor = calloutAnchor();
 
            const double calloutOffsetWidthPixels = context.renderContext().convertToPainterUnits( offsetFromCallout().width(), offsetFromCalloutUnit() ) + moveOperation->translationXPixels();
            const double calloutOffsetHeightPixels = context.renderContext().convertToPainterUnits( offsetFromCallout().height(), offsetFromCalloutUnit() ) + moveOperation->translationYPixels();
 
            QPointF anchorPoint = anchor.asQPointF();
            if ( context.renderContext().coordinateTransform().isValid() )
            {
              double x = anchorPoint.x();
              double y = anchorPoint.y();
              double z = 0.0;
              context.renderContext().coordinateTransform().transformInPlace( x, y, z );
              anchorPoint = QPointF( x, y );
            }
 
            context.renderContext().mapToPixel().transformInPlace( anchorPoint.rx(), anchorPoint.ry() );
 
            const double textOriginXPixels = anchorPoint.x() + calloutOffsetWidthPixels;
            const double textOriginYPixels = anchorPoint.y() + calloutOffsetHeightPixels;
 
            const double widthPixels = context.renderContext().convertToPainterUnits( mFixedSize.width(), mFixedSizeUnit );
            const double heightPixels = context.renderContext().convertToPainterUnits( mFixedSize.height(), mFixedSizeUnit );
 
            QgsLineString ls(
              QVector<QgsPointXY> {
                QgsPointXY( textOriginXPixels, textOriginYPixels ),
                QgsPointXY( textOriginXPixels + widthPixels, textOriginYPixels ),
                QgsPointXY( textOriginXPixels + widthPixels, textOriginYPixels + heightPixels ),
                QgsPointXY( textOriginXPixels, textOriginYPixels + heightPixels ),
                QgsPointXY( textOriginXPixels, textOriginYPixels )
              }
            );
 
            QgsGeometry g( new QgsPolygon( ls.clone() ) );
            g.transform( context.renderContext().mapToPixel().transform().inverted() );
            g.transform( context.renderContext().coordinateTransform(), Qgis::TransformDirection::Reverse );
            return new QgsAnnotationItemEditOperationTransientResults( g );
          }
          else
          {
            const QgsRectangle currentBounds = context.currentItemBounds();
            const QgsRectangle newBounds
              = QgsRectangle::fromCenterAndSize( mBounds.center() + QgsVector( moveOperation->translationX(), moveOperation->translationY() ), currentBounds.width(), currentBounds.height() );
            return new QgsAnnotationItemEditOperationTransientResults( rotatedBoundsGeometry( newBounds, context.renderContext() ) );
          }
        }
 
        case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
        {
          const QgsRectangle currentBounds = context.currentItemBounds();
          const QgsRectangle newBounds
            = QgsRectangle::fromCenterAndSize( currentBounds.center() + QgsVector( moveOperation->translationX(), moveOperation->translationY() ), currentBounds.width(), currentBounds.height() );
          return new QgsAnnotationItemEditOperationTransientResults( QgsGeometry::fromRect( newBounds ) );
        }
      }
      break;
    }
 
    case QgsAbstractAnnotationItemEditOperation::Type::SetItemBounds:
    {
      const QgsRectangle newBounds = qgis::down_cast< QgsAnnotationItemEditOperationSetItemBounds * >( operation )->bounds();
      return new QgsAnnotationItemEditOperationTransientResults( rotatedBoundsGeometry( newBounds, context.renderContext() ) );
    }
 
    case QgsAbstractAnnotationItemEditOperation::Type::RotateItem:
    case QgsAbstractAnnotationItemEditOperation::Type::DeleteNode:
    case QgsAbstractAnnotationItemEditOperation::Type::AddNode:
      break;
  }
  return nullptr;
}
 
QgsRectangle QgsAnnotationRectItem::boundingBox() const
{
  QgsRectangle bounds;
  switch ( mPlacementMode )
  {
    case Qgis::AnnotationPlacementMode::SpatialBounds:
    {
      bounds = mBounds;
      if ( callout() && !calloutAnchor().isEmpty() )
      {
        QgsGeometry anchor = calloutAnchor();
        bounds.combineExtentWith( anchor.boundingBox() );
      }
      break;
    }
 
    case Qgis::AnnotationPlacementMode::FixedSize:
      if ( callout() && !calloutAnchor().isEmpty() )
      {
        bounds = calloutAnchor().boundingBox();
      }
      else
      {
        bounds = QgsRectangle( mBounds.center(), mBounds.center() );
      }
      break;
 
    case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
      bounds = mBounds;
      break;
  }
 
  return bounds;
}
 
QgsRectangle QgsAnnotationRectItem::boundingBox( QgsRenderContext &context ) const
{
  switch ( mPlacementMode )
  {
    case Qgis::AnnotationPlacementMode::SpatialBounds:
      return QgsAnnotationRectItem::boundingBox();
 
    case Qgis::AnnotationPlacementMode::FixedSize:
    {
      const double widthPixels = context.convertToPainterUnits( mFixedSize.width(), mFixedSizeUnit );
      const double heightPixels = context.convertToPainterUnits( mFixedSize.height(), mFixedSizeUnit );
 
      QRectF boundsInPixels;
      if ( callout() && !calloutAnchor().isEmpty() )
      {
        QgsGeometry anchor = calloutAnchor();
 
        const double calloutOffsetWidthPixels = context.convertToPainterUnits( offsetFromCallout().width(), offsetFromCalloutUnit() );
        const double calloutOffsetHeightPixels = context.convertToPainterUnits( offsetFromCallout().height(), offsetFromCalloutUnit() );
 
        QPointF anchorPoint = anchor.asQPointF();
        if ( context.coordinateTransform().isValid() )
        {
          double x = anchorPoint.x();
          double y = anchorPoint.y();
          double z = 0.0;
          context.coordinateTransform().transformInPlace( x, y, z );
          anchorPoint = QPointF( x, y );
        }
 
        context.mapToPixel().transformInPlace( anchorPoint.rx(), anchorPoint.ry() );
 
        QgsRectangle
          textRect( anchorPoint.x() + calloutOffsetWidthPixels, anchorPoint.y() + calloutOffsetHeightPixels, anchorPoint.x() + calloutOffsetWidthPixels + widthPixels, anchorPoint.y() + calloutOffsetHeightPixels + heightPixels );
        QgsRectangle anchorRect( anchorPoint.x(), anchorPoint.y(), anchorPoint.x(), anchorPoint.y() );
        anchorRect.combineExtentWith( textRect );
 
        boundsInPixels = anchorRect.toRectF();
      }
      else
      {
        QPointF center = mBounds.center().toQPointF();
        if ( context.coordinateTransform().isValid() )
        {
          double x = center.x();
          double y = center.y();
          double z = 0.0;
          context.coordinateTransform().transformInPlace( x, y, z );
          center = QPointF( x, y );
        }
 
        context.mapToPixel().transformInPlace( center.rx(), center.ry() );
        boundsInPixels = QRectF( center.x() - widthPixels * 0.5, center.y() - heightPixels * 0.5, widthPixels, heightPixels );
      }
      const QgsPointXY topLeft = context.mapToPixel().toMapCoordinates( boundsInPixels.left(), boundsInPixels.top() );
      const QgsPointXY topRight = context.mapToPixel().toMapCoordinates( boundsInPixels.right(), boundsInPixels.top() );
      const QgsPointXY bottomLeft = context.mapToPixel().toMapCoordinates( boundsInPixels.left(), boundsInPixels.bottom() );
      const QgsPointXY bottomRight = context.mapToPixel().toMapCoordinates( boundsInPixels.right(), boundsInPixels.bottom() );
 
      const QgsRectangle boundsMapUnits = QgsRectangle( topLeft.x(), bottomLeft.y(), bottomRight.x(), topRight.y() );
      QgsRectangle textRect = context.coordinateTransform().transformBoundingBox( boundsMapUnits, Qgis::TransformDirection::Reverse );
      return textRect;
    }
 
    case Qgis::AnnotationPlacementMode::RelativeToMapFrame:
    {
      const double widthPixels = context.convertToPainterUnits( mFixedSize.width(), mFixedSizeUnit );
      const double heightPixels = context.convertToPainterUnits( mFixedSize.height(), mFixedSizeUnit );
 
      QRectF boundsInPixels;
 
      const double centerMapX = context.mapExtent().xMinimum() + mBounds.center().x() * context.mapExtent().width();
      const double centerMapY = context.mapExtent().yMaximum() - mBounds.center().y() * context.mapExtent().height();
      QPointF center( centerMapX, centerMapY );
      if ( context.coordinateTransform().isValid() )
      {
        double x = centerMapX;
        double y = centerMapY;
        double z = 0.0;
        context.coordinateTransform().transformInPlace( x, y, z );
        center = QPointF( x, y );
      }
 
      context.mapToPixel().transformInPlace( center.rx(), center.ry() );
      boundsInPixels = QRectF( center.x() - widthPixels * 0.5, center.y() - heightPixels * 0.5, widthPixels, heightPixels );
 
      const QgsPointXY topLeft = context.mapToPixel().toMapCoordinates( boundsInPixels.left(), boundsInPixels.top() );
      const QgsPointXY topRight = context.mapToPixel().toMapCoordinates( boundsInPixels.right(), boundsInPixels.top() );
      const QgsPointXY bottomLeft = context.mapToPixel().toMapCoordinates( boundsInPixels.left(), boundsInPixels.bottom() );
      const QgsPointXY bottomRight = context.mapToPixel().toMapCoordinates( boundsInPixels.right(), boundsInPixels.bottom() );
 
      const QgsRectangle boundsMapUnits = QgsRectangle( topLeft.x(), bottomLeft.y(), bottomRight.x(), topRight.y() );
      QgsRectangle textRect = context.coordinateTransform().transformBoundingBox( boundsMapUnits, Qgis::TransformDirection::Reverse );
      return textRect;
    }
  }
  BUILTIN_UNREACHABLE
}
 
void QgsAnnotationRectItem::setBounds( const QgsRectangle &bounds )
{
  mBounds = bounds;
}
 
const QgsFillSymbol *QgsAnnotationRectItem::backgroundSymbol() const
{
  return mBackgroundSymbol.get();
}
 
void QgsAnnotationRectItem::setBackgroundSymbol( QgsFillSymbol *symbol )
{
  mBackgroundSymbol.reset( symbol );
}
 
const QgsFillSymbol *QgsAnnotationRectItem::frameSymbol() const
{
  return mFrameSymbol.get();
}
 
void QgsAnnotationRectItem::setFrameSymbol( QgsFillSymbol *symbol )
{
  mFrameSymbol.reset( symbol );
}
 
void QgsAnnotationRectItem::copyCommonProperties( const QgsAnnotationItem *other )
{
  if ( const QgsAnnotationRectItem *otherRect = dynamic_cast< const QgsAnnotationRectItem * >( other ) )
  {
    setPlacementMode( otherRect->mPlacementMode );
    setFixedSize( otherRect->mFixedSize );
    setFixedSizeUnit( otherRect->mFixedSizeUnit );
    setRotation( otherRect->mRotation );
    setRotationMode( otherRect->mRotationMode );
 
    setBackgroundEnabled( otherRect->mDrawBackground );
    if ( otherRect->mBackgroundSymbol )
      setBackgroundSymbol( otherRect->mBackgroundSymbol->clone() );
 
    setFrameEnabled( otherRect->mDrawFrame );
    if ( otherRect->mFrameSymbol )
      setFrameSymbol( otherRect->mFrameSymbol->clone() );
  }
 
  QgsAnnotationItem::copyCommonProperties( other );
}
 
bool QgsAnnotationRectItem::writeCommonProperties( QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context ) const
{
  element.setAttribute( u"xMin"_s, qgsDoubleToString( mBounds.xMinimum() ) );
  element.setAttribute( u"xMax"_s, qgsDoubleToString( mBounds.xMaximum() ) );
  element.setAttribute( u"yMin"_s, qgsDoubleToString( mBounds.yMinimum() ) );
  element.setAttribute( u"yMax"_s, qgsDoubleToString( mBounds.yMaximum() ) );
  element.setAttribute( u"sizeMode"_s, qgsEnumValueToKey( mPlacementMode ) );
  element.setAttribute( u"fixedWidth"_s, qgsDoubleToString( mFixedSize.width() ) );
  element.setAttribute( u"fixedHeight"_s, qgsDoubleToString( mFixedSize.height() ) );
  element.setAttribute( u"fixedSizeUnit"_s, QgsUnitTypes::encodeUnit( mFixedSizeUnit ) );
  if ( !qgsDoubleNear( mRotation, 0 ) )
  {
    element.setAttribute( u"rotation"_s, qgsDoubleToString( mRotation ) );
  }
  if ( mRotationMode != Qgis::SymbolRotationMode::IgnoreMapRotation )
  {
    element.setAttribute( u"rotationMode"_s, qgsEnumValueToKey( mRotationMode ) );
  }
 
  element.setAttribute( u"backgroundEnabled"_s, mDrawBackground ? u"1"_s : u"0"_s );
  if ( mBackgroundSymbol )
  {
    QDomElement backgroundElement = document.createElement( u"backgroundSymbol"_s );
    backgroundElement.appendChild( QgsSymbolLayerUtils::saveSymbol( u"backgroundSymbol"_s, mBackgroundSymbol.get(), document, context ) );
    element.appendChild( backgroundElement );
  }
 
  element.setAttribute( u"frameEnabled"_s, mDrawFrame ? u"1"_s : u"0"_s );
  if ( mFrameSymbol )
  {
    QDomElement frameElement = document.createElement( u"frameSymbol"_s );
    frameElement.appendChild( QgsSymbolLayerUtils::saveSymbol( u"frameSymbol"_s, mFrameSymbol.get(), document, context ) );
    element.appendChild( frameElement );
  }
 
  return QgsAnnotationItem::writeCommonProperties( element, document, context );
}
 
bool QgsAnnotationRectItem::readCommonProperties( const QDomElement &element, const QgsReadWriteContext &context )
{
  mBounds.setXMinimum( element.attribute( u"xMin"_s ).toDouble() );
  mBounds.setXMaximum( element.attribute( u"xMax"_s ).toDouble() );
  mBounds.setYMinimum( element.attribute( u"yMin"_s ).toDouble() );
  mBounds.setYMaximum( element.attribute( u"yMax"_s ).toDouble() );
 
  mPlacementMode = qgsEnumKeyToValue( element.attribute( u"sizeMode"_s ), Qgis::AnnotationPlacementMode::SpatialBounds );
 
  mFixedSize = QSizeF( element.attribute( u"fixedWidth"_s ).toDouble(), element.attribute( u"fixedHeight"_s ).toDouble() );
  mFixedSizeUnit = QgsUnitTypes::decodeRenderUnit( element.attribute( u"fixedSizeUnit"_s ) );
  mRotation = element.attribute( u"rotation"_s ).toDouble();
  mRotationMode = qgsEnumKeyToValue( element.attribute( u"rotationMode"_s ), Qgis::SymbolRotationMode::IgnoreMapRotation );
 
  mDrawBackground = element.attribute( u"backgroundEnabled"_s, u"0"_s ).toInt();
  const QDomElement backgroundSymbolElem = element.firstChildElement( u"backgroundSymbol"_s ).firstChildElement();
  if ( !backgroundSymbolElem.isNull() )
  {
    setBackgroundSymbol( QgsSymbolLayerUtils::loadSymbol< QgsFillSymbol >( backgroundSymbolElem, context ).release() );
  }
 
  mDrawFrame = element.attribute( u"frameEnabled"_s, u"0"_s ).toInt();
  const QDomElement frameSymbolElem = element.firstChildElement( u"frameSymbol"_s ).firstChildElement();
  if ( !frameSymbolElem.isNull() )
  {
    setFrameSymbol( QgsSymbolLayerUtils::loadSymbol< QgsFillSymbol >( frameSymbolElem, context ).release() );
  }
 
  return QgsAnnotationItem::readCommonProperties( element, context );
}
 
QSizeF QgsAnnotationRectItem::fixedSize() const
{
  return mFixedSize;
}
 
void QgsAnnotationRectItem::setFixedSize( const QSizeF &size )
{
  mFixedSize = size;
}
 
Qgis::RenderUnit QgsAnnotationRectItem::fixedSizeUnit() const
{
  return mFixedSizeUnit;
}
 
void QgsAnnotationRectItem::setFixedSizeUnit( Qgis::RenderUnit unit )
{
  mFixedSizeUnit = unit;
}
 
Qgis::AnnotationPlacementMode QgsAnnotationRectItem::placementMode() const
{
  return mPlacementMode;
}
 
void QgsAnnotationRectItem::setPlacementMode( Qgis::AnnotationPlacementMode mode )
{
  mPlacementMode = mode;
}