qgsmaptoolmodifyannotation.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsmaptoolmodifyannotation.cpp
    ----------------
    copyright            : (C) 2021 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 "qgsmaptoolmodifyannotation.h"
 
#include <cmath>
 
#include "RTree.h"
#include "qgsannotationitem.h"
#include "qgsannotationitemeditoperation.h"
#include "qgsannotationitemnode.h"
#include "qgsannotationlayer.h"
#include "qgsannotationrectitem.h"
#include "qgslogger.h"
#include "qgsmapcanvas.h"
#include "qgsmaptopixel.h"
#include "qgsproject.h"
#include "qgsrenderedannotationitemdetails.h"
#include "qgsrendereditemdetails.h"
#include "qgsrendereditemresults.h"
#include "qgsrubberband.h"
#include "qgssnapindicator.h"
 
#include <QScreen>
#include <QString>
#include <QTransform>
#include <QWindow>
 
#include "moc_qgsmaptoolmodifyannotation.cpp"
 
using namespace Qt::StringLiterals;

class QgsAnnotationItemNodesSpatialIndex : public RTree<int, float, 2, float>
{
  public:
    void insert( int index, const QgsRectangle &bounds )
    {
      std::array<float, 4> scaledBounds = scaleBounds( bounds );
      const float aMin[2] { scaledBounds[0], scaledBounds[1] };
      const float aMax[2] { scaledBounds[2], scaledBounds[3] };
      this->Insert( aMin, aMax, index );
    }

    void remove( int index, const QgsRectangle &bounds )
    {
      std::array<float, 4> scaledBounds = scaleBounds( bounds );
      const float aMin[2] { scaledBounds[0], scaledBounds[1] };
      const float aMax[2] { scaledBounds[2], scaledBounds[3] };
      this->Remove( aMin, aMax, index );
    }

    bool intersects( const QgsRectangle &bounds, const std::function<bool( int index )> &callback ) const
    {
      std::array<float, 4> scaledBounds = scaleBounds( bounds );
      const float aMin[2] { scaledBounds[0], scaledBounds[1] };
      const float aMax[2] { scaledBounds[2], scaledBounds[3] };
      this->Search( aMin, aMax, callback );
      return true;
    }
 
  private:
    std::array<float, 4> scaleBounds( const QgsRectangle &bounds ) const
    {
      return { static_cast<float>( bounds.xMinimum() ), static_cast<float>( bounds.yMinimum() ), static_cast<float>( bounds.xMaximum() ), static_cast<float>( bounds.yMaximum() ) };
    }
};
 
 
QgsRectangle QgsMapToolModifyAnnotation::reconstructRotatedResizeBounds( const QgsMapToPixel *mapToPixel, double angle, const QgsPointXY &fixedMapPoint, const QgsPointXY &cursorMapPoint )
{
  const QgsPointXY fixedPixel = mapToPixel->transform( fixedMapPoint );
  const QgsPointXY cursorPixel = mapToPixel->transform( cursorMapPoint );
 
  // Un-rotating the diagonal between the fixed and dragged corners
  QTransform unrotate;
  unrotate.rotate( -angle );
  const QPointF diagonal = unrotate.map( QPointF( cursorPixel.x() - fixedPixel.x(), cursorPixel.y() - fixedPixel.y() ) );
  const double widthPixels = std::fabs( diagonal.x() );
  const double heightPixels = std::fabs( diagonal.y() );
  const QPointF centerPixel( ( fixedPixel.x() + cursorPixel.x() ) / 2.0, ( fixedPixel.y() + cursorPixel.y() ) / 2.0 );
 
  return QgsAnnotationRectItem::boundsFromPixelRect( mapToPixel, centerPixel, widthPixels, heightPixels );
}
 
QgsPointXY QgsMapToolModifyAnnotation::oppositeVertexMapPoint( const QList<QgsAnnotationItemNode> &nodes, int draggedVertex, bool &found )
{
  found = false;
  const int fixedVertex = ( draggedVertex + 2 ) % 4;
  for ( const QgsAnnotationItemNode &node : nodes )
  {
    if ( node.id().part == 0 && node.id().vertex == fixedVertex )
    {
      found = true;
      return node.point();
    }
  }
  return QgsPointXY();
}
 
std::optional<QgsRectangle> QgsMapToolModifyAnnotation::rotatedResizeLayerBounds( const QgsAnnotationRectItem *rectItem, QgsAnnotationLayer *layer, const QgsPointXY &cursorMapPoint )
{
  const int draggedVertex = mTargetNode.id().vertex;
  const double angle = rectItem->appliedRotation( canvas()->mapSettings().rotation() );
  if ( rectItem->placementMode() != Qgis::AnnotationPlacementMode::SpatialBounds || mTargetNode.id().part != 0 || draggedVertex < 0 || draggedVertex >= 4 || qgsDoubleNear( angle, 0 ) )
    return std::nullopt;
 
  bool foundFixed = false;
  const QgsPointXY fixedMapPoint = oppositeVertexMapPoint( mHoveredItemNodes, draggedVertex, foundFixed );
  if ( !foundFixed )
    return std::nullopt;
 
  const QgsRectangle newMapBounds = reconstructRotatedResizeBounds( canvas()->getCoordinateTransform(), angle, fixedMapPoint, cursorMapPoint );
  const QgsRectangle newLayerBounds = toLayerCoordinates( layer, newMapBounds );
  if ( qgsDoubleNear( newLayerBounds.width(), 0 ) || qgsDoubleNear( newLayerBounds.height(), 0 ) )
    return std::nullopt;
 
  return newLayerBounds;
}
 
 
QgsMapToolModifyAnnotation::QgsMapToolModifyAnnotation( QgsMapCanvas *canvas, QgsAdvancedDigitizingDockWidget *cadDockWidget )
  : QgsAnnotationMapTool( canvas, cadDockWidget )
  , mSnapIndicator( new QgsSnapIndicator( canvas ) )
{
  connect( QgsMapToolModifyAnnotation::canvas(), &QgsMapCanvas::mapCanvasRefreshed, this, &QgsMapToolModifyAnnotation::onCanvasRefreshed );
}
 
QgsMapToolModifyAnnotation::~QgsMapToolModifyAnnotation() = default;
 
void QgsMapToolModifyAnnotation::deactivate()
{
  mSnapIndicator->setMatch( QgsPointLocator::Match() );
 
  clearHoveredItem();
  clearSelectedItem();
  QgsMapToolAdvancedDigitizing::deactivate();
}
 
void QgsMapToolModifyAnnotation::cadCanvasMoveEvent( QgsMapMouseEvent *event )
{
  mLastHoverPoint = event->originalPixelPoint();
  event->snapPoint();
  mSnapIndicator->setMatch( event->mapPointMatch() );
 
  const QgsPointXY mapPoint = event->mapPoint();
 
  QgsAnnotationItemEditContext context;
  QgsAnnotationLayer *layer = annotationLayerFromId( mSelectedItemLayerId );
  context.setCurrentItemBounds( toLayerCoordinates( layer, mSelectedItemBounds ) );
  context.setRenderContext( QgsRenderContext::fromMapSettings( canvas()->mapSettings() ) );
 
  switch ( mCurrentAction )
  {
    case Action::NoAction:
    {
      setHoveredItemFromPoint( mapPoint );
      break;
    }
 
    case Action::MoveItem:
    {
      if ( QgsAnnotationItem *item = annotationItemFromId( mSelectedItemLayerId, mSelectedItemId ) )
      {
        const QgsVector delta = toLayerCoordinates( layer, event->mapPoint() ) - mMoveStartPointLayerCrs;
 
        QgsAnnotationItemEditOperationTranslateItem
          operation( mSelectedItemId, delta.x(), delta.y(), event->pixelPoint().x() - mMoveStartPointPixels.x(), event->pixelPoint().y() - mMoveStartPointPixels.y() );
        std::unique_ptr<QgsAnnotationItemEditOperationTransientResults> operationResults( item->transientEditResultsV2( &operation, context ) );
        if ( operationResults )
        {
          mTemporaryRubberBand = make_qobject_unique<QgsRubberBand>( mCanvas, operationResults->representativeGeometry().type() );
          const double scaleFactor = canvas()->fontMetrics().xHeight() * .2;
          mTemporaryRubberBand->setWidth( scaleFactor );
          mTemporaryRubberBand->setToGeometry( operationResults->representativeGeometry(), layer->crs() );
        }
        else
        {
          mTemporaryRubberBand.reset();
        }
      }
      break;
    }
 
    case Action::MoveNode:
    {
      if ( QgsAnnotationItem *item = annotationItemFromId( mSelectedItemLayerId, mSelectedItemId ) )
      {
        bool previewDone = false;
 
        if ( const QgsAnnotationRectItem *rectItem = dynamic_cast<const QgsAnnotationRectItem *>( item ) )
        {
          if ( const std::optional<QgsRectangle> newLayerBounds = rotatedResizeLayerBounds( rectItem, layer, event->mapPoint() ) )
          {
            const QgsGeometry preview = rectItem->rotatedBoundsGeometry( *newLayerBounds, context.renderContext() );
            mTemporaryRubberBand = make_qobject_unique<QgsRubberBand>( mCanvas, preview.type() );
            const double scaleFactor = canvas()->fontMetrics().xHeight() * .2;
            mTemporaryRubberBand->setWidth( scaleFactor );
            mTemporaryRubberBand->setToGeometry( preview, layer->crs() );
            previewDone = true;
          }
        }
 
        if ( !previewDone )
        {
          const QgsPointXY endPointLayer = toLayerCoordinates( layer, event->mapPoint() );
          QgsAnnotationItemEditOperationMoveNode operation(
            mSelectedItemId,
            mTargetNode.id(),
            QgsPoint( mTargetNode.point() ),
            QgsPoint( endPointLayer ),
            event->pixelPoint().x() - mMoveStartPointPixels.x(),
            event->pixelPoint().y() - mMoveStartPointPixels.y()
          );
          std::unique_ptr<QgsAnnotationItemEditOperationTransientResults> operationResults( item->transientEditResultsV2( &operation, context ) );
          if ( operationResults )
          {
            mTemporaryRubberBand = make_qobject_unique<QgsRubberBand>( mCanvas, operationResults->representativeGeometry().type() );
            const double scaleFactor = canvas()->fontMetrics().xHeight() * .2;
            mTemporaryRubberBand->setWidth( scaleFactor );
            mTemporaryRubberBand->setToGeometry( operationResults->representativeGeometry(), layer->crs() );
          }
          else
          {
            mTemporaryRubberBand.reset();
          }
        }
      }
      break;
    }
  }
}
 
void QgsMapToolModifyAnnotation::cadCanvasPressEvent( QgsMapMouseEvent *event )
{
  QgsAnnotationLayer *layer = annotationLayerFromId( mSelectedItemLayerId );
 
  QgsAnnotationItemEditContext context;
  context.setCurrentItemBounds( toLayerCoordinates( layer, mSelectedItemBounds ) );
  context.setRenderContext( QgsRenderContext::fromMapSettings( canvas()->mapSettings() ) );
 
  switch ( mCurrentAction )
  {
    case Action::NoAction:
    {
      if ( event->button() != Qt::LeftButton )
        return;
 
      if ( mHoveredItemId.isEmpty() || !mHoverRubberBand )
      {
        clearSelectedItem();
      }
      else if ( mHoveredItemId == mSelectedItemId && mHoveredItemLayerId == mSelectedItemLayerId )
      {
        // press is on selected item => move that item
        if ( layer )
        {
          const QgsPointXY mapPoint = event->mapPoint();
          QgsRectangle searchRect = QgsRectangle( mapPoint.x(), mapPoint.y(), mapPoint.x(), mapPoint.y() );
          searchRect.grow( searchRadiusMU( canvas() ) );
 
          QgsAnnotationItemNode hoveredNode;
          double currentNodeDistance = std::numeric_limits<double>::max();
          mHoveredItemNodesSpatialIndex->intersects( searchRect, [&hoveredNode, &currentNodeDistance, &mapPoint, this]( int index ) -> bool {
            const QgsAnnotationItemNode &thisNode = mHoveredItemNodes.at( index );
            const double nodeDistance = thisNode.point().sqrDist( mapPoint );
            if ( nodeDistance < currentNodeDistance )
            {
              hoveredNode = thisNode;
              currentNodeDistance = nodeDistance;
            }
            return true;
          } );
 
          mMoveStartPointCanvasCrs = mapPoint;
          mMoveStartPointPixels = event->pixelPoint();
          mMoveStartPointLayerCrs = toLayerCoordinates( layer, mMoveStartPointCanvasCrs );
          if ( mHoverRubberBand )
            mHoverRubberBand->hide();
          if ( mSelectedRubberBand )
            mSelectedRubberBand->hide();
 
          if ( hoveredNode.point().isEmpty() )
          {
            mCurrentAction = Action::MoveItem;
          }
          else
          {
            mCurrentAction = Action::MoveNode;
            mTargetNode = hoveredNode;
          }
        }
      }
      else
      {
        // press is on a different item to selected item => select that item
        mSelectedItemId = mHoveredItemId;
        mSelectedItemLayerId = mHoveredItemLayerId;
        mSelectedItemBounds = mHoveredItemBounds;
 
        if ( !mSelectedRubberBand )
          createSelectedItemBand();
 
        mSelectedRubberBand->copyPointsFrom( mHoverRubberBand );
        mSelectedRubberBand->show();
 
        setCursor( Qt::OpenHandCursor );
 
        emit itemSelected( annotationLayerFromId( mSelectedItemLayerId ), mSelectedItemId );
      }
      break;
    }
 
    case Action::MoveItem:
    {
      if ( event->button() == Qt::RightButton )
      {
        mCurrentAction = Action::NoAction;
        mTemporaryRubberBand.reset();
        if ( mSelectedRubberBand )
        {
          mSelectedRubberBand->setTranslationOffset( 0, 0 );
          mSelectedRubberBand->show();
        }
        mHoveredItemNodeRubberBands.clear();
        setCursor( Qt::ArrowCursor );
      }
      else if ( event->button() == Qt::LeftButton )
      {
        // apply move
        if ( layer )
        {
          const QgsVector delta = toLayerCoordinates( layer, event->mapPoint() ) - mMoveStartPointLayerCrs;
 
          QgsAnnotationItemEditOperationTranslateItem
            operation( mSelectedItemId, delta.x(), delta.y(), event->pixelPoint().x() - mMoveStartPointPixels.x(), event->pixelPoint().y() - mMoveStartPointPixels.y() );
          switch ( layer->applyEditV2( &operation, context ) )
          {
            case Qgis::AnnotationItemEditOperationResult::Success:
              QgsProject::instance()->setDirty( true );
              mRefreshSelectedItemAfterRedraw = true;
              break;
            case Qgis::AnnotationItemEditOperationResult::Invalid:
            case Qgis::AnnotationItemEditOperationResult::ItemCleared:
              break;
          }
        }
 
        mTemporaryRubberBand.reset();
        mCurrentAction = Action::NoAction;
        setCursor( Qt::ArrowCursor );
      }
      break;
    }
 
    case Action::MoveNode:
    {
      if ( event->button() == Qt::RightButton )
      {
        mCurrentAction = Action::NoAction;
        mTemporaryRubberBand.reset();
        mHoveredItemNodeRubberBands.clear();
        mTemporaryRubberBand.reset();
        setCursor( Qt::ArrowCursor );
      }
      else if ( event->button() == Qt::LeftButton )
      {
        if ( layer )
        {
          bool handled = false;
 
          const QgsAnnotationItem *resizedItem = annotationItemFromId( mSelectedItemLayerId, mSelectedItemId );
          if ( const QgsAnnotationRectItem *rectItem = dynamic_cast<const QgsAnnotationRectItem *>( resizedItem ) )
          {
            if ( const std::optional<QgsRectangle> newLayerBounds = rotatedResizeLayerBounds( rectItem, layer, event->mapPoint() ) )
            {
              QgsAnnotationItemEditOperationSetItemBounds operation( mSelectedItemId, *newLayerBounds );
              if ( layer->applyEditV2( &operation, context ) == Qgis::AnnotationItemEditOperationResult::Success )
              {
                handled = true;
                QgsProject::instance()->setDirty( true );
                mRefreshSelectedItemAfterRedraw = true;
              }
            }
          }
 
          if ( !handled )
          {
            const QgsPointXY endPointLayer = toLayerCoordinates( layer, event->mapPoint() );
            QgsAnnotationItemEditOperationMoveNode operation(
              mSelectedItemId,
              mTargetNode.id(),
              QgsPoint( mTargetNode.point() ),
              QgsPoint( endPointLayer ),
              event->pixelPoint().x() - mMoveStartPointPixels.x(),
              event->pixelPoint().y() - mMoveStartPointPixels.y()
            );
            switch ( layer->applyEditV2( &operation, context ) )
            {
              case Qgis::AnnotationItemEditOperationResult::Success:
                QgsProject::instance()->setDirty( true );
                mRefreshSelectedItemAfterRedraw = true;
                break;
 
              case Qgis::AnnotationItemEditOperationResult::Invalid:
              case Qgis::AnnotationItemEditOperationResult::ItemCleared:
                break;
            }
          }
        }
 
        mTemporaryRubberBand.reset();
        mHoveredItemNodeRubberBands.clear();
        mHoveredItemNodes.clear();
        mTemporaryRubberBand.reset();
        mCurrentAction = Action::NoAction;
        setCursor( Qt::ArrowCursor );
      }
      break;
    }
  }
}
 
void QgsMapToolModifyAnnotation::canvasDoubleClickEvent( QgsMapMouseEvent *event )
{
  switch ( mCurrentAction )
  {
    case Action::NoAction:
    case Action::MoveItem:
    {
      if ( event->button() != Qt::LeftButton )
        return;
 
      mCurrentAction = Action::NoAction;
      if ( mHoveredItemId == mSelectedItemId && mHoveredItemLayerId == mSelectedItemLayerId )
      {
        // double-click on selected item => add node
        if ( QgsAnnotationLayer *layer = annotationLayerFromId( mSelectedItemLayerId ) )
        {
          const QgsPointXY layerPoint = toLayerCoordinates( layer, event->mapPoint() );
          QgsAnnotationItemEditOperationAddNode operation( mSelectedItemId, QgsPoint( layerPoint ) );
          QgsAnnotationItemEditContext context;
          context.setCurrentItemBounds( toLayerCoordinates( layer, mSelectedItemBounds ) );
          context.setRenderContext( QgsRenderContext::fromMapSettings( canvas()->mapSettings() ) );
 
          switch ( layer->applyEditV2( &operation, context ) )
          {
            case Qgis::AnnotationItemEditOperationResult::Success:
              QgsProject::instance()->setDirty( true );
              mRefreshSelectedItemAfterRedraw = true;
              break;
 
            case Qgis::AnnotationItemEditOperationResult::Invalid:
            case Qgis::AnnotationItemEditOperationResult::ItemCleared:
              break;
          }
        }
      }
      else
      {
        // press is on a different item to selected item => select that item
        mSelectedItemId = mHoveredItemId;
        mSelectedItemLayerId = mHoveredItemLayerId;
        mSelectedItemBounds = mHoveredItemBounds;
 
        if ( !mSelectedRubberBand )
          createSelectedItemBand();
 
        mSelectedRubberBand->copyPointsFrom( mHoverRubberBand );
        mSelectedRubberBand->show();
 
        setCursor( Qt::OpenHandCursor );
 
        emit itemSelected( annotationLayerFromId( mSelectedItemLayerId ), mSelectedItemId );
      }
      break;
    }
 
    case Action::MoveNode:
      break;
  }
}
 
void QgsMapToolModifyAnnotation::keyPressEvent( QKeyEvent *event )
{
  QgsAnnotationItemEditContext context;
  QgsAnnotationLayer *layer = annotationLayerFromId( mSelectedItemLayerId );
  context.setCurrentItemBounds( toLayerCoordinates( layer, mSelectedItemBounds ) );
  context.setRenderContext( QgsRenderContext::fromMapSettings( canvas()->mapSettings() ) );
 
  switch ( mCurrentAction )
  {
    case Action::NoAction:
    {
      if ( event->key() == Qt::Key_Backspace || event->key() == Qt::Key_Delete )
      {
        if ( !layer || mSelectedItemId.isEmpty() )
          return;
 
        layer->removeItem( mSelectedItemId );
        clearSelectedItem();
        clearHoveredItem();
        event->ignore(); // disable default shortcut handling
      }
      else if ( event->key() == Qt::Key_Left || event->key() == Qt::Key_Right || event->key() == Qt::Key_Up || event->key() == Qt::Key_Down )
      {
        if ( !layer )
          return;
 
        const QSizeF deltaLayerCoordinates = deltaForKeyEvent( layer, mSelectedRubberBand->asGeometry().centroid().asPoint(), event );
 
        QgsAnnotationItemEditOperationTranslateItem operation( mSelectedItemId, deltaLayerCoordinates.width(), deltaLayerCoordinates.height() );
        switch ( layer->applyEditV2( &operation, context ) )
        {
          case Qgis::AnnotationItemEditOperationResult::Success:
            QgsProject::instance()->setDirty( true );
            mRefreshSelectedItemAfterRedraw = true;
            break;
          case Qgis::AnnotationItemEditOperationResult::Invalid:
          case Qgis::AnnotationItemEditOperationResult::ItemCleared:
            break;
        }
        event->ignore(); // disable default shortcut handling (move map)
      }
      break;
    }
 
    case Action::MoveNode:
    {
      if ( event->key() == Qt::Key_Delete || event->key() == Qt::Key_Backspace )
      {
        if ( layer )
        {
          QgsAnnotationItemEditOperationDeleteNode operation( mSelectedItemId, mTargetNode.id(), QgsPoint( mTargetNode.point() ) );
          switch ( layer->applyEditV2( &operation, context ) )
          {
            case Qgis::AnnotationItemEditOperationResult::Success:
              QgsProject::instance()->setDirty( true );
              mRefreshSelectedItemAfterRedraw = true;
              break;
            case Qgis::AnnotationItemEditOperationResult::Invalid:
              break;
            case Qgis::AnnotationItemEditOperationResult::ItemCleared:
              QgsProject::instance()->setDirty( true );
              break;
          }
        }
 
        mTemporaryRubberBand.reset();
        mHoveredItemNodeRubberBands.clear();
        mHoveredItemNodes.clear();
        mTemporaryRubberBand.reset();
        mCurrentAction = Action::NoAction;
        setCursor( Qt::ArrowCursor );
        event->ignore(); // disable default shortcut handling (delete vector feature)
        break;
      }
      [[fallthrough]];
    }
 
    case Action::MoveItem:
    {
      // warning -- fallthrough above!
      if ( event->key() == Qt::Key_Escape )
      {
        mCurrentAction = Action::NoAction;
        mTemporaryRubberBand.reset();
        if ( mSelectedRubberBand )
        {
          mSelectedRubberBand->setTranslationOffset( 0, 0 );
          mSelectedRubberBand->show();
        }
        mHoveredItemNodeRubberBands.clear();
 
        setCursor( Qt::ArrowCursor );
      }
      break;
    }
  }
}
 
void QgsMapToolModifyAnnotation::onCanvasRefreshed()
{
  bool needsSelectedItemRefresh = mRefreshSelectedItemAfterRedraw;
  if ( QgsAnnotationItem *item = annotationItemFromId( mSelectedItemLayerId, mSelectedItemId ) )
  {
    if ( item->flags() & Qgis::AnnotationItemFlag::ScaleDependentBoundingBox )
    {
      needsSelectedItemRefresh = true;
    }
  }
 
  if ( needsSelectedItemRefresh )
  {
    const QgsRenderedItemResults *renderedItemResults = canvas()->renderedItemResults( false );
    if ( !renderedItemResults )
    {
      return;
    }
 
    const QList<QgsRenderedItemDetails *> items = renderedItemResults->renderedItems();
    auto it = std::find_if( items.begin(), items.end(), [this]( const QgsRenderedItemDetails *item ) {
      if ( const QgsRenderedAnnotationItemDetails *annotationItem = dynamic_cast<const QgsRenderedAnnotationItemDetails *>( item ) )
      {
        if ( annotationItem->itemId() == mSelectedItemId && annotationItem->layerId() == mSelectedItemLayerId )
          return true;
      }
      return false;
    } );
    if ( it != items.end() )
    {
      const QgsRectangle itemBounds = ( *it )->boundingBox();
 
      setHoveredItem( dynamic_cast<const QgsRenderedAnnotationItemDetails *>( *it ), itemBounds );
      if ( !mSelectedRubberBand )
        createSelectedItemBand();
 
      mSelectedRubberBand->copyPointsFrom( mHoverRubberBand );
      mSelectedRubberBand->show();
      mSelectedItemBounds = mHoveredItemBounds;
    }
  }
  else
  {
    // recheck for hovered item at new mouse point
    const QgsPointXY mapPoint = canvas()->mapSettings().mapToPixel().toMapCoordinates( mLastHoverPoint );
    setHoveredItemFromPoint( mapPoint );
  }
  mRefreshSelectedItemAfterRedraw = false;
}
 
void QgsMapToolModifyAnnotation::setHoveredItem( const QgsRenderedAnnotationItemDetails *item, const QgsRectangle &itemMapBounds )
{
  mHoveredItemNodeRubberBands.clear();
  if ( mHoveredNodeRubberBand )
    mHoveredNodeRubberBand->hide();
  mHoveredItemId = item->itemId();
  mHoveredItemLayerId = item->layerId();
  mHoveredItemBounds = itemMapBounds;
  if ( !mHoverRubberBand )
    createHoverBand();
 
  mHoverRubberBand->show();
 
  const QgsAnnotationItem *annotationItem = annotationItemFromId( item->layerId(), item->itemId() );
  if ( !annotationItem )
  {
    // fall back to a plain axis-aligned hover rectangle
    mHoverRubberBand->reset( Qgis::GeometryType::Line );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMinimum(), itemMapBounds.yMinimum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMaximum(), itemMapBounds.yMinimum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMaximum(), itemMapBounds.yMaximum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMinimum(), itemMapBounds.yMaximum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMinimum(), itemMapBounds.yMinimum() ) );
    return;
  }
 
  QgsAnnotationLayer *layer = annotationLayerFromId( item->layerId() );
  const QgsCoordinateTransform layerToMapTransform = QgsCoordinateTransform( layer->crs(), canvas()->mapSettings().destinationCrs(), canvas()->mapSettings().transformContext() );
 
  // Rotate corners around the center in pixel space. Node points already went
  // through mapToPixel (which includes map rotation), so only the item's own
  // rotation is added here. The callout anchor is fixed and never rotated.
  const QgsAnnotationRectItem *rectItem = dynamic_cast<const QgsAnnotationRectItem *>( annotationItem );
  const double mapRotation = canvas()->mapSettings().rotation();
  const double frameRotation = rectItem ? rectItem->appliedRotation( mapRotation ) - mapRotation : 0;
  const QgsMapToPixel *mapToPixel = canvas()->getCoordinateTransform();
  bool rotated = rectItem && !qgsDoubleNear( frameRotation, 0 );
 
  QgsPointXY centerMap;
  if ( rotated )
  {
    try
    {
      centerMap = layerToMapTransform.transform( rectItem->bounds().center() );
    }
    catch ( QgsCsException & )
    {
      // no reliable pivot, so fall back to an unrotated band
      QgsDebugError( u"Error transforming annotation item center"_s );
      rotated = false;
    }
  }
 
  QTransform rotationTransform;
  if ( rotated )
  {
    const QgsPointXY centerPixel = mapToPixel->transform( centerMap );
    rotationTransform.translate( centerPixel.x(), centerPixel.y() );
    rotationTransform.rotate( frameRotation );
    rotationTransform.translate( -centerPixel.x(), -centerPixel.y() );
  }
 
  auto rotateMapPoint = [&]( const QgsPointXY &p ) -> QgsPointXY {
    if ( !rotated )
      return p;
    const QgsPointXY pPixel = mapToPixel->transform( p );
    const QPointF r = rotationTransform.map( QPointF( pPixel.x(), pPixel.y() ) );
    return mapToPixel->toMapCoordinates( r.x(), r.y() );
  };
 
  const double scaleFactor = canvas()->fontMetrics().xHeight() * .2;
 
  QgsAnnotationItemEditContext context;
  context.setCurrentItemBounds( toLayerCoordinates( layer, itemMapBounds ) );
  context.setRenderContext( QgsRenderContext::fromMapSettings( canvas()->mapSettings() ) );
 
  const QList<QgsAnnotationItemNode> itemNodes = annotationItem->nodesV2( context );
  QgsRubberBand *vertexNodeBand = new QgsRubberBand( mCanvas, Qgis::GeometryType::Point );
 
  vertexNodeBand->setIcon( Qgis::RubberBandIconType::Box );
  vertexNodeBand->setWidth( scaleFactor );
  vertexNodeBand->setIconSize( scaleFactor * 5 );
  vertexNodeBand->setColor( QColor( 200, 0, 120, 255 ) );
 
  QgsRubberBand *calloutNodeBand = new QgsRubberBand( mCanvas, Qgis::GeometryType::Point );
  calloutNodeBand->setWidth( scaleFactor );
  calloutNodeBand->setSecondaryStrokeColor( QColor( 255, 255, 255, 100 ) );
  calloutNodeBand->setColor( QColor( 120, 200, 0, 255 ) );
  calloutNodeBand->setIcon( Qgis::RubberBandIconType::CrossX );
  calloutNodeBand->setIconSize( scaleFactor * 5 );
 
  // store item nodes in a spatial index for quick searching
  mHoveredItemNodesSpatialIndex = std::make_unique<QgsAnnotationItemNodesSpatialIndex>();
  int index = 0;
  mHoveredItemNodes.clear();
  mHoveredItemNodes.reserve( itemNodes.size() );
  QVector<QgsPointXY> vertexFramePoints;
  for ( const QgsAnnotationItemNode &node : itemNodes )
  {
    QgsPointXY nodeMapPoint;
    try
    {
      nodeMapPoint = layerToMapTransform.transform( node.point() );
    }
    catch ( QgsCsException & )
    {
      continue;
    }
 
    switch ( node.type() )
    {
      case Qgis::AnnotationItemNodeType::VertexHandle:
        // vertex handles rotate together with the item body
        nodeMapPoint = rotateMapPoint( nodeMapPoint );
        vertexNodeBand->addPoint( nodeMapPoint );
        vertexFramePoints.append( nodeMapPoint );
        break;
 
      case Qgis::AnnotationItemNodeType::CalloutHandle:
        calloutNodeBand->addPoint( nodeMapPoint );
        break;
    }
 
    mHoveredItemNodesSpatialIndex->insert( index, QgsRectangle( nodeMapPoint.x(), nodeMapPoint.y(), nodeMapPoint.x(), nodeMapPoint.y() ) );
 
    QgsAnnotationItemNode transformedNode = node;
    transformedNode.setPoint( nodeMapPoint );
    mHoveredItemNodes.append( transformedNode );
 
    index++;
  }
 
  mHoveredItemNodeRubberBands.emplace_back( vertexNodeBand );
  mHoveredItemNodeRubberBands.emplace_back( calloutNodeBand );
 
  // Draw the hover frame. For spatial-bounds rectangles it follows the four
  // (rotated) corner handles; other modes use the axis-aligned bounds.
  mHoverRubberBand->reset( Qgis::GeometryType::Line );
  if ( rectItem && rectItem->placementMode() == Qgis::AnnotationPlacementMode::SpatialBounds && vertexFramePoints.size() == 4 )
  {
    for ( const QgsPointXY &framePoint : vertexFramePoints )
      mHoverRubberBand->addPoint( framePoint );
    mHoverRubberBand->addPoint( vertexFramePoints.constFirst() );
  }
  else
  {
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMinimum(), itemMapBounds.yMinimum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMaximum(), itemMapBounds.yMinimum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMaximum(), itemMapBounds.yMaximum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMinimum(), itemMapBounds.yMaximum() ) );
    mHoverRubberBand->addPoint( QgsPointXY( itemMapBounds.xMinimum(), itemMapBounds.yMinimum() ) );
  }
}
 
QSizeF QgsMapToolModifyAnnotation::deltaForKeyEvent( QgsAnnotationLayer *layer, const QgsPointXY &originalCanvasPoint, QKeyEvent *event )
{
  const double canvasDpi = canvas()->window()->windowHandle()->screen()->physicalDotsPerInch();
 
  // increment used for cursor key item movement
  double incrementPixels = 0.0;
  if ( event->modifiers() & Qt::ShiftModifier )
  {
    //holding shift while pressing cursor keys results in a big step - 20 mm
    incrementPixels = 20.0 / 25.4 * canvasDpi;
  }
  else if ( event->modifiers() & Qt::AltModifier )
  {
    //holding alt while pressing cursor keys results in a 1 pixel step
    incrementPixels = 1;
  }
  else
  {
    // 5 mm
    incrementPixels = 5.0 / 25.4 * canvasDpi;
  }
 
  double deltaXPixels = 0;
  double deltaYPixels = 0;
  switch ( event->key() )
  {
    case Qt::Key_Left:
      deltaXPixels = -incrementPixels;
      break;
    case Qt::Key_Right:
      deltaXPixels = incrementPixels;
      break;
    case Qt::Key_Up:
      deltaYPixels = -incrementPixels;
      break;
    case Qt::Key_Down:
      deltaYPixels = incrementPixels;
      break;
    default:
      break;
  }
 
  const QgsPointXY beforeMoveMapPoint = canvas()->getCoordinateTransform()->toMapCoordinates( originalCanvasPoint.x(), originalCanvasPoint.y() );
  const QgsPointXY beforeMoveLayerPoint = toLayerCoordinates( layer, beforeMoveMapPoint );
 
  const QgsPointXY afterMoveCanvasPoint( originalCanvasPoint.x() + deltaXPixels, originalCanvasPoint.y() + deltaYPixels );
  const QgsPointXY afterMoveMapPoint = canvas()->getCoordinateTransform()->toMapCoordinates( afterMoveCanvasPoint.x(), afterMoveCanvasPoint.y() );
  const QgsPointXY afterMoveLayerPoint = toLayerCoordinates( layer, afterMoveMapPoint );
 
  return QSizeF( afterMoveLayerPoint.x() - beforeMoveLayerPoint.x(), afterMoveLayerPoint.y() - beforeMoveLayerPoint.y() );
}
 
void QgsMapToolModifyAnnotation::setHoveredItemFromPoint( const QgsPointXY &mapPoint )
{
  QgsRectangle searchRect = QgsRectangle( mapPoint.x(), mapPoint.y(), mapPoint.x(), mapPoint.y() );
  searchRect.grow( searchRadiusMU( canvas() ) );
 
  const QgsRenderedItemResults *renderedItemResults = canvas()->renderedItemResults( false );
  if ( !renderedItemResults )
  {
    clearHoveredItem();
    return;
  }
 
  const QList<const QgsRenderedAnnotationItemDetails *> items = renderedItemResults->renderedAnnotationItemsInBounds( searchRect );
  if ( items.empty() )
  {
    clearHoveredItem();
    return;
  }
 
  // find closest item
  QgsRectangle itemBounds;
  const QgsRenderedAnnotationItemDetails *closestItem = findClosestItemToPoint( mapPoint, items, itemBounds );
  if ( !closestItem )
  {
    clearHoveredItem();
    return;
  }
 
  if ( closestItem->itemId() != mHoveredItemId || closestItem->layerId() != mHoveredItemLayerId )
  {
    setHoveredItem( closestItem, itemBounds );
  }
 
  // track hovered node too!... here we want to identify the closest node to the cursor position
  QgsAnnotationItemNode hoveredNode;
  if ( closestItem->itemId() == mSelectedItemId && closestItem->layerId() == mSelectedItemLayerId )
  {
    double currentNodeDistance = std::numeric_limits<double>::max();
    mHoveredItemNodesSpatialIndex->intersects( searchRect, [&hoveredNode, &currentNodeDistance, &mapPoint, this]( int index ) -> bool {
      if ( index >= mHoveredItemNodes.size() )
        return false;
 
      const QgsAnnotationItemNode &thisNode = mHoveredItemNodes.at( index );
      const double nodeDistance = thisNode.point().sqrDist( mapPoint );
      if ( nodeDistance < currentNodeDistance )
      {
        hoveredNode = thisNode;
        currentNodeDistance = nodeDistance;
      }
      return true;
    } );
  }
 
  if ( hoveredNode.point().isEmpty() )
  {
    // no hovered node
    if ( mHoveredNodeRubberBand )
      mHoveredNodeRubberBand->hide();
    setCursor( mHoveredItemId == mSelectedItemId && mHoveredItemLayerId == mSelectedItemLayerId ? Qt::OpenHandCursor : Qt::ArrowCursor );
  }
  else
  {
    if ( !mHoveredNodeRubberBand )
      createHoveredNodeBand();
 
    mHoveredNodeRubberBand->reset( Qgis::GeometryType::Point );
    mHoveredNodeRubberBand->addPoint( hoveredNode.point() );
    mHoveredNodeRubberBand->show();
 
    setCursor( hoveredNode.cursor() );
  }
}
 
void QgsMapToolModifyAnnotation::clearHoveredItem()
{
  if ( mHoverRubberBand )
    mHoverRubberBand->hide();
  if ( mHoveredNodeRubberBand )
    mHoveredNodeRubberBand->hide();
 
  mHoveredItemId.clear();
  mHoveredItemLayerId.clear();
  mHoveredItemNodeRubberBands.clear();
  mHoveredItemNodesSpatialIndex.reset();
 
  setCursor( Qt::ArrowCursor );
}
 
void QgsMapToolModifyAnnotation::clearSelectedItem()
{
  if ( mSelectedRubberBand )
    mSelectedRubberBand->hide();
 
  const bool hadSelection = !mSelectedItemId.isEmpty();
  mSelectedItemId.clear();
  mSelectedItemLayerId.clear();
  if ( hadSelection )
    emit selectionCleared();
}
 
void QgsMapToolModifyAnnotation::createHoverBand()
{
  const double scaleFactor = canvas()->fontMetrics().xHeight() * .2;
 
  mHoverRubberBand = make_qobject_unique<QgsRubberBand>( mCanvas, Qgis::GeometryType::Line );
  mHoverRubberBand->setWidth( scaleFactor );
  mHoverRubberBand->setSecondaryStrokeColor( QColor( 255, 255, 255, 100 ) );
  mHoverRubberBand->setColor( QColor( 100, 100, 100, 155 ) );
}
 
void QgsMapToolModifyAnnotation::createHoveredNodeBand()
{
  const double scaleFactor = canvas()->fontMetrics().xHeight() * .2;
 
  mHoveredNodeRubberBand = make_qobject_unique<QgsRubberBand>( mCanvas, Qgis::GeometryType::Point );
  mHoveredNodeRubberBand->setIcon( Qgis::RubberBandIconType::BoxFilled );
  mHoveredNodeRubberBand->setWidth( scaleFactor );
  mHoveredNodeRubberBand->setIconSize( scaleFactor * 5 );
  mHoveredNodeRubberBand->setColor( QColor( 200, 0, 120, 255 ) );
}
 
void QgsMapToolModifyAnnotation::createSelectedItemBand()
{
  const double scaleFactor = canvas()->fontMetrics().xHeight() * .2;
 
  mSelectedRubberBand = make_qobject_unique<QgsRubberBand>( mCanvas, Qgis::GeometryType::Line );
  mSelectedRubberBand->setWidth( scaleFactor );
  mSelectedRubberBand->setSecondaryStrokeColor( QColor( 255, 255, 255, 100 ) );
  mSelectedRubberBand->setColor( QColor( 50, 50, 50, 200 ) );
}