QGIS » QGIS Application

                              qgsmaptooltextannotation.cpp

  begin                : February 9, 2010

  copyright            : (C) 2010 by Marco Hugentobler

  email                : marco dot hugentobler at hugis dot net

#include "qgsmaptooltextannotation.h"

#include "qgstextannotationitem.h"

QgsMapToolTextAnnotation::QgsMapToolTextAnnotation( QgsMapCanvas* canvas ): QgsMapToolAnnotation( canvas )

QgsMapToolTextAnnotation::~QgsMapToolTextAnnotation()

QgsAnnotationItem* QgsMapToolTextAnnotation::createItem( QMouseEvent* e )

  QgsTextAnnotationItem* textItem = new QgsTextAnnotationItem( mCanvas );

  textItem->setMapPosition( toMapCoordinates( e->pos() ) );

  textItem->setFrameSize( QSizeF( 200, 100 ) );

  textItem->setSelected( true );

  return textItem;

                              qgsmaptooltextannotation.h

  begin                : February 9, 2010

  copyright            : (C) 2010 by Marco Hugentobler

  email                : marco dot hugentobler at hugis dot net

#ifndef QGSMAPTOOLTEXTANNOTATION_H

#define QGSMAPTOOLTEXTANNOTATION_H

class QgsMapToolTextAnnotation: public QgsMapToolAnnotation

    QgsMapToolTextAnnotation( QgsMapCanvas* canvas );

    ~QgsMapToolTextAnnotation();

#endif // QGSMAPTOOLTEXTANNOTATION_H

  ../core/gps ../core/gps/qextserialport

  ../core/composer ../core/raster ../core/renderer ../core/symbology ../core/symbology-ng

  ../gui ../gui/symbology-ng

/***************************************************************************

                              qgstextannotationitem.cpp

                              ------------------------

  begin                : February 9, 2010

  copyright            : (C) 2010 by Marco Hugentobler

  email                : marco dot hugentobler at hugis dot net

 ***************************************************************************/

/***************************************************************************

 *                                                                         *

 *   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 "qgstextannotationitem.h"

#include <QDomDocument>

#include <QPainter>

QgsTextAnnotationItem::QgsTextAnnotationItem( QgsMapCanvas* canvas ): QgsAnnotationItem( canvas ), mDocument( new QTextDocument( QObject::tr( "QGIS rocks!" ) ) )

{

  mDocument->setUseDesignMetrics( true );

}

QgsTextAnnotationItem::~QgsTextAnnotationItem()

{

  delete mDocument;

}

QTextDocument* QgsTextAnnotationItem::document() const

{

  if ( !mDocument )

  {

    return 0;

  }

  return mDocument->clone();

}

void QgsTextAnnotationItem::setDocument( const QTextDocument* doc )

{

  delete mDocument;

  mDocument = doc->clone();

}

void QgsTextAnnotationItem::paint( QPainter * painter )

{

  if ( !painter || !mDocument )

  {

    return;

  }

  drawFrame( painter );

  if ( mMapPositionFixed )

  {

    drawMarkerSymbol( painter );

  }

  double frameWidth = mFrameBorderWidth;

  mDocument->setTextWidth( mFrameSize.width() );

  painter->save();

  painter->translate( mOffsetFromReferencePoint.x() + frameWidth / 2.0,

                      mOffsetFromReferencePoint.y() + frameWidth / 2.0 );

  //draw text document

  mDocument->drawContents( painter, QRectF( 0, 0, mFrameSize.width() - frameWidth / 2.0, mFrameSize.height() - frameWidth / 2.0 ) );

  painter->restore();

  if ( isSelected() )

  {

    drawSelectionBoxes( painter );

  }

}

void QgsTextAnnotationItem::writeXML( QDomDocument& doc ) const

{

  QDomElement documentElem = doc.documentElement();

  if ( documentElem.isNull() )

  {

    return;

  }

  QDomElement annotationElem = doc.createElement( "TextAnnotationItem" );

  if ( mDocument )

  {

    annotationElem.setAttribute( "document", mDocument->toHtml() );

  }

  _writeXML( doc, annotationElem );

  documentElem.appendChild( annotationElem );

}

void QgsTextAnnotationItem::readXML( const QDomDocument& doc, const QDomElement& itemElem )

{

  delete mDocument;

  mDocument = new QTextDocument;

  mDocument->setHtml( itemElem.attribute( "document", QObject::tr( "<html>QGIS rocks!</html>" ) ) );

  QDomElement annotationElem = itemElem.firstChildElement( "AnnotationItem" );

  if ( !annotationElem.isNull() )

  {

    _readXML( doc, annotationElem );

  }

}

/**An annotation item that displays formated text*/

/**An annotation item can be either placed either on screen corrdinates or on map coordinates.

/***************************************************************************

                              qgsformannotationitem.h

                              ------------------------

  begin                : February 26, 2010

  copyright            : (C) 2010 by Marco Hugentobler

  email                : marco dot hugentobler at hugis dot net

 ***************************************************************************/

/***************************************************************************

 *                                                                         *

 *   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 "qgsformannotationitem.h"

#include "qgsattributeeditor.h"

#include "qgsfeature.h"

#include "qgslogger.h"

#include "qgsmapcanvas.h"

#include "qgsmaplayerregistry.h"

#include "qgsvectorlayer.h"

#include <QDomElement>

#include <QDir>

#include <QFile>

#include <QFileInfo>

#include <QGraphicsProxyWidget>

#include <QPainter>

#include <QSettings>

#include <QUiLoader>

#include <QWidget>

QgsFormAnnotationItem::QgsFormAnnotationItem( QgsMapCanvas* canvas, QgsVectorLayer* vlayer, bool hasFeature, int feature ): \

    QgsAnnotationItem( canvas ), mWidgetContainer( 0 ), mDesignerWidget( 0 ), mVectorLayer( vlayer ), \

    mHasAssociatedFeature( hasFeature ), mFeature( feature )

{

  mWidgetContainer = new QGraphicsProxyWidget( this );

  if ( mVectorLayer && mMapCanvas ) //default to the layers edit form

  {

    mDesignerForm = mVectorLayer->annotationForm();

    QObject::connect( mVectorLayer, SIGNAL( layerModified( bool ) ), this, SLOT( setFeatureForMapPosition() ) );

    QObject::connect( mMapCanvas, SIGNAL( renderComplete( QPainter* ) ), this, SLOT( setFeatureForMapPosition() ) );

    QObject::connect( mMapCanvas, SIGNAL( layersChanged() ), this, SLOT( updateVisibility() ) );

  }

  setFeatureForMapPosition();

}

QgsFormAnnotationItem::~QgsFormAnnotationItem()

{

  delete mDesignerWidget;

}

void QgsFormAnnotationItem::setDesignerForm( const QString& uiFile )

{

  mDesignerForm = uiFile;

  mWidgetContainer->setWidget( 0 );

  delete mDesignerWidget;

  mDesignerWidget = createDesignerWidget( uiFile );

  if ( mDesignerWidget )

  {

    mFrameBackgroundColor = mDesignerWidget->palette().color( QPalette::Window );

    mWidgetContainer->setWidget( mDesignerWidget );

    setFrameSize( preferredFrameSize() );

  }

}

QWidget* QgsFormAnnotationItem::createDesignerWidget( const QString& filePath )

{

  QFile file( filePath );

  if ( !file.open( QFile::ReadOnly ) )

  {

    return 0;

  }

  QUiLoader loader;

  QFileInfo fi( file );

  loader.setWorkingDirectory( fi.dir() );

  QWidget* widget = loader.load( &file, 0 );

  file.close();

  //get feature and set attribute information

  if ( mVectorLayer && mHasAssociatedFeature )

  {

    QgsFeature f;

    if ( mVectorLayer->featureAtId( mFeature, f, false, true ) )

    {

      const QgsFieldMap& fieldMap = mVectorLayer->pendingFields();

      QgsAttributeMap attMap = f.attributeMap();

      QgsAttributeMap::const_iterator attIt = attMap.constBegin();

      for ( ; attIt != attMap.constEnd(); ++attIt )

      {

        QgsFieldMap::const_iterator fieldIt = fieldMap.find( attIt.key() );

        if ( fieldIt != fieldMap.constEnd() )

        {

          QWidget* attWidget = widget->findChild<QWidget*>( fieldIt->name() );

          if ( attWidget )

          {

            QgsAttributeEditor::createAttributeEditor( widget, attWidget, mVectorLayer, attIt.key(), attIt.value() );

          }

        }

      }

    }

  }

  return widget;

}

void QgsFormAnnotationItem::setMapPosition( const QgsPoint& pos )

{

  QgsAnnotationItem::setMapPosition( pos );

  setFeatureForMapPosition();

}

void QgsFormAnnotationItem::paint( QPainter * painter )

{

}

void QgsFormAnnotationItem::paint( QPainter * painter, const QStyleOptionGraphicsItem * option, QWidget * widget )

{

  if ( !painter || !mWidgetContainer )

  {

    return;

  }

  drawFrame( painter );

  if ( mMapPositionFixed )

  {

    drawMarkerSymbol( painter );

  }

  mWidgetContainer->setGeometry( QRectF( mOffsetFromReferencePoint.x() + mFrameBorderWidth / 2.0, mOffsetFromReferencePoint.y() \

                                         + mFrameBorderWidth / 2.0, mFrameSize.width() - mFrameBorderWidth, mFrameSize.height() \

                                         - mFrameBorderWidth ) );

  if ( isSelected() )

  {

    drawSelectionBoxes( painter );

  }

}

QSizeF QgsFormAnnotationItem::minimumFrameSize() const

{

  if ( mDesignerWidget )

  {

    QSizeF widgetMinSize = mDesignerWidget->minimumSize();

    return QSizeF( 2 * mFrameBorderWidth + widgetMinSize.width(), 2 * mFrameBorderWidth + widgetMinSize.height() );

  }

  else

  {

    return QSizeF( 0, 0 );

  }

}

QSizeF QgsFormAnnotationItem::preferredFrameSize() const

{

  if ( mDesignerWidget )

  {

    return mDesignerWidget->sizeHint();

  }

  else

  {

    return QSizeF( 0, 0 );

  }

}

void QgsFormAnnotationItem::writeXML( QDomDocument& doc ) const

{

  QDomElement documentElem = doc.documentElement();

  if ( documentElem.isNull() )

  {

    return;

  }

  QDomElement formAnnotationElem = doc.createElement( "FormAnnotationItem" );

  if ( mVectorLayer )

  {

    formAnnotationElem.setAttribute( "vectorLayer", mVectorLayer->getLayerID() );

  }

  formAnnotationElem.setAttribute( "hasFeature", mHasAssociatedFeature );

  formAnnotationElem.setAttribute( "feature", mFeature );

  formAnnotationElem.setAttribute( "designerForm", mDesignerForm );

  _writeXML( doc, formAnnotationElem );

  documentElem.appendChild( formAnnotationElem );

}

void QgsFormAnnotationItem::readXML( const QDomDocument& doc, const QDomElement& itemElem )

{

  mVectorLayer = 0;

  if ( itemElem.hasAttribute( "vectorLayer" ) )

  {

    mVectorLayer = dynamic_cast<QgsVectorLayer*>( QgsMapLayerRegistry::instance()->mapLayer( itemElem.attribute( "vectorLayer", "" ) ) );

    if ( mVectorLayer )

    {

      QObject::connect( mVectorLayer, SIGNAL( layerModified( bool ) ), this, SLOT( setFeatureForMapPosition() ) );

      QObject::connect( mMapCanvas, SIGNAL( renderComplete( QPainter* ) ), this, SLOT( setFeatureForMapPosition() ) );

      QObject::connect( mMapCanvas, SIGNAL( layersChanged() ), this, SLOT( updateVisibility() ) );

    }

  }

  mHasAssociatedFeature = itemElem.attribute( "hasFeature", "0" ).toInt();

  mFeature = itemElem.attribute( "feature", "0" ).toInt();

  mDesignerForm = itemElem.attribute( "designerForm", "" );

  QDomElement annotationElem = itemElem.firstChildElement( "AnnotationItem" );

  if ( !annotationElem.isNull() )

  {

    _readXML( doc, annotationElem );

  }

  mDesignerWidget = createDesignerWidget( mDesignerForm );

  if ( mDesignerWidget )

  {

    mFrameBackgroundColor = mDesignerWidget->palette().color( QPalette::Window );

    mWidgetContainer->setWidget( mDesignerWidget );

  }

  updateVisibility();

}

void QgsFormAnnotationItem::setFeatureForMapPosition()

{

  if ( !mVectorLayer || !mMapCanvas )

  {

    return;

  }

  QgsAttributeList noAttributes;

  QSettings settings;

  double identifyValue = settings.value( "/Map/identifyRadius", QGis::DEFAULT_IDENTIFY_RADIUS ).toDouble();

  double halfIdentifyWidth = mMapCanvas->extent().width() / 100 / 2 * identifyValue;

  QgsRectangle searchRect( mMapPosition.x() - halfIdentifyWidth, mMapPosition.y() - halfIdentifyWidth, \

                           mMapPosition.x() + halfIdentifyWidth, mMapPosition.y() + halfIdentifyWidth );

  mVectorLayer->select( noAttributes, searchRect, false, true );

  QgsFeature currentFeature;

  int currentFeatureId = 0;

  bool featureFound = false;

  while ( mVectorLayer->nextFeature( currentFeature ) )

  {

    currentFeatureId = currentFeature.id();

    featureFound = true;

    break;

  }

  mHasAssociatedFeature = featureFound;

  mFeature = currentFeatureId;

  //create new embedded widget

  mWidgetContainer->setWidget( 0 );

  delete mDesignerWidget;

  mDesignerWidget = createDesignerWidget( mDesignerForm );

  if ( mDesignerWidget )

  {

    mFrameBackgroundColor = mDesignerWidget->palette().color( QPalette::Window );

    mWidgetContainer->setWidget( mDesignerWidget );

  }

}

void QgsFormAnnotationItem::updateVisibility()

{

  bool visible = true;

  if ( mVectorLayer && mMapCanvas )

  {

    visible = mMapCanvas->layers().contains( mVectorLayer );

  }

  setVisible( visible );

}

/***************************************************************************

                              qgsannotationitem.cpp

                              ----------------------

  begin                : February 9, 2010

  copyright            : (C) 2010 by Marco Hugentobler

  email                : marco dot hugentobler at hugis dot net

 ***************************************************************************/

/***************************************************************************

 *                                                                         *

 *   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 "qgsannotationitem.h"

#include "qgsmapcanvas.h"

#include "qgsrendercontext.h"

#include "qgssymbollayerv2utils.h"

#include "qgssymbolv2.h"

#include <QPainter>

#include <QPen>

QgsAnnotationItem::QgsAnnotationItem( QgsMapCanvas* mapCanvas ): QgsMapCanvasItem( mapCanvas ), mMapPositionFixed( true ), mOffsetFromReferencePoint( QPointF( 50, -50 ) )

{

  setFlag( QGraphicsItem::ItemIsSelectable, true );

  mMarkerSymbol = new QgsMarkerSymbolV2();

  mFrameBorderWidth = 1.0;

  mFrameColor = QColor( 0, 0, 0 );

  mFrameBackgroundColor = QColor( 255, 255, 255 );

}

QgsAnnotationItem::~QgsAnnotationItem()

{

  delete mMarkerSymbol;

}

void QgsAnnotationItem::setMarkerSymbol( QgsMarkerSymbolV2* symbol )

{

  delete mMarkerSymbol;

  mMarkerSymbol = symbol;

  updateBoundingRect();

}

void QgsAnnotationItem::setMapPosition( const QgsPoint& pos )

{

  mMapPosition = pos;

  setPos( toCanvasCoordinates( mMapPosition ) );

}

void QgsAnnotationItem::setOffsetFromReferencePoint( const QPointF& offset )

{

  mOffsetFromReferencePoint = offset;

  updateBoundingRect();

  updateBalloon();

}

void QgsAnnotationItem::setMapPositionFixed( bool fixed )

{

  if ( mMapPositionFixed && !fixed )

  {

    //set map position to the top left corner of the balloon

    setMapPosition( toMapCoordinates( QPointF( pos() + mOffsetFromReferencePoint ).toPoint() ) );

    mOffsetFromReferencePoint = QPointF( 0, 0 );

  }

  else if ( fixed && !mMapPositionFixed )

  {

    setMapPosition( toMapCoordinates( QPointF( pos() + QPointF( -100, -100 ) ).toPoint() ) );

    mOffsetFromReferencePoint = QPointF( 100, 100 );

  }

  mMapPositionFixed = fixed;

  updateBoundingRect();

  updateBalloon();

  update();

}

void QgsAnnotationItem::updatePosition()

{

  if ( mMapPositionFixed )

  {

    setPos( toCanvasCoordinates( mMapPosition ) );

  }

  else

  {

    mMapPosition = toMapCoordinates( pos().toPoint() );

  }

}

QRectF QgsAnnotationItem::boundingRect() const

{

  return mBoundingRect;

}

QSizeF QgsAnnotationItem::minimumFrameSize() const

{

  return QSizeF( 0, 0 );

}

void QgsAnnotationItem::updateBoundingRect()

{

  prepareGeometryChange();

  double halfSymbolSize = 0.0;

  if ( mMarkerSymbol )

  {

    halfSymbolSize = scaledSymbolSize() / 2.0;

  }

  double xMinPos = std::min( -halfSymbolSize, mOffsetFromReferencePoint.x() - mFrameBorderWidth );

  double xMaxPos = std::max( halfSymbolSize, mOffsetFromReferencePoint.x() + mFrameSize.width() + mFrameBorderWidth );

  double yMinPos = std::min( -halfSymbolSize, mOffsetFromReferencePoint.y() - mFrameBorderWidth );

  double yMaxPos = std::max( halfSymbolSize, mOffsetFromReferencePoint.y() + mFrameSize.height() + mFrameBorderWidth );

  mBoundingRect = QRectF( xMinPos, yMinPos, xMaxPos - xMinPos, yMaxPos - yMinPos );

}

void QgsAnnotationItem::updateBalloon()

{

  //first test if the point is in the frame. In that case we don't need a balloon.

  if ( !mMapPositionFixed ||

       ( mOffsetFromReferencePoint.x() < 0 && ( mOffsetFromReferencePoint.x() + mFrameSize.width() ) > 0 \

         && mOffsetFromReferencePoint.y() < 0 && ( mOffsetFromReferencePoint.y() + mFrameSize.height() ) > 0 ) )

  {

    mBalloonSegment = -1;

    return;

  }

  //edge list

  QList<QLineF> segmentList;

  segmentList << segment( 0 ); segmentList << segment( 1 ); segmentList << segment( 2 ); segmentList << segment( 3 );

  //find  closest edge / closest edge point

  double minEdgeDist = DBL_MAX;

  int minEdgeIndex = -1;

  QLineF minEdge;

  QgsPoint minEdgePoint;

  QgsPoint origin( 0, 0 );

  for ( int i = 0; i < 4; ++i )

  {

    QLineF currentSegment = segmentList.at( i );

    QgsPoint currentMinDistPoint;

    double currentMinDist = origin.sqrDistToSegment( currentSegment.x1(), currentSegment.y1(), currentSegment.x2(), currentSegment.y2(), currentMinDistPoint );

    if ( currentMinDist < minEdgeDist )

    {

      minEdgeIndex = i;

      minEdgePoint = currentMinDistPoint;

      minEdgeDist = currentMinDist;

      minEdge = currentSegment;

    }

  }

  if ( minEdgeIndex < 0 )

  {

    return;

  }

  //make that configurable for the item

  double segmentPointWidth = 10;

  mBalloonSegment = minEdgeIndex;

  QPointF minEdgeEnd = minEdge.p2();

  mBalloonSegmentPoint1 = QPointF( minEdgePoint.x(), minEdgePoint.y() );

  if ( sqrt( minEdgePoint.sqrDist( minEdgeEnd.x(), minEdgeEnd.y() ) ) < segmentPointWidth )

  {

    mBalloonSegmentPoint1 = pointOnLineWithDistance( minEdge.p2(), minEdge.p1(), segmentPointWidth );

  }

  mBalloonSegmentPoint2 = pointOnLineWithDistance( mBalloonSegmentPoint1, minEdge.p2(), 10 );

}

void QgsAnnotationItem::drawFrame( QPainter* p )

{

  QPen framePen( mFrameColor );

  framePen.setWidthF( mFrameBorderWidth );

  p->setPen( framePen );

  QBrush frameBrush( mFrameBackgroundColor );

  p->setBrush( frameBrush );

  p->setRenderHint( QPainter::Antialiasing, true );

  QPolygonF poly;

  for ( int i = 0; i < 4; ++i )

  {

    QLineF currentSegment = segment( i );

    poly << currentSegment.p1();

    if ( i == mBalloonSegment && mMapPositionFixed )

    {

      poly << mBalloonSegmentPoint1;

      poly << QPointF( 0, 0 );

      poly << mBalloonSegmentPoint2;

    }

    poly << currentSegment.p2();

  }

  p->drawPolygon( poly );

}

void QgsAnnotationItem::setFrameSize( const QSizeF& size )

{

  QSizeF frameSize = minimumFrameSize().expandedTo( size ); //don't allow frame sizes below minimum

  mFrameSize = frameSize;

  updateBoundingRect();

  updateBalloon();

}

void QgsAnnotationItem::drawMarkerSymbol( QPainter* p )

{

  if ( !p )

  {

    return;

  }

  QgsRenderContext renderContext;

  if ( !setRenderContextVariables( p, renderContext ) )

  {

    return;

  }

  QPointF canvasPoint = toCanvasCoordinates( mMapPosition );

  if ( mMarkerSymbol )

  {

    mMarkerSymbol->startRender( renderContext );

    mMarkerSymbol->renderPoint( QPointF( 0, 0 ), renderContext );

    mMarkerSymbol->stopRender( renderContext );

  }

}

void QgsAnnotationItem::drawSelectionBoxes( QPainter* p )

{

  if ( !p )

  {

    return;

  }

  //no selection boxes for composer mode

  if ( data( 0 ).toString() == "composer" )

  {

    return;

  }

  double handlerSize = 10;

  p->setPen( Qt::NoPen );

  p->setBrush( QColor( 200, 200, 210, 120 ) );

  p->drawRect( QRectF( mBoundingRect.left(), mBoundingRect.top(), handlerSize, handlerSize ) );

  p->drawRect( QRectF( mBoundingRect.right() - handlerSize, mBoundingRect.top(), handlerSize, handlerSize ) );

  p->drawRect( QRectF( mBoundingRect.right() - handlerSize, mBoundingRect.bottom() - handlerSize, handlerSize, handlerSize ) );

  p->drawRect( QRectF( mBoundingRect.left(), mBoundingRect.bottom() - handlerSize, handlerSize, handlerSize ) );

}

QLineF QgsAnnotationItem::segment( int index )

{

  switch ( index )

  {

    case 0:

      return QLineF( mOffsetFromReferencePoint.x(), mOffsetFromReferencePoint.y(), mOffsetFromReferencePoint.x() \

                     + mFrameSize.width(), mOffsetFromReferencePoint.y() );

    case 1:

      return QLineF( mOffsetFromReferencePoint.x() + mFrameSize.width(), mOffsetFromReferencePoint.y(), \

                     mOffsetFromReferencePoint.x() + mFrameSize.width(), mOffsetFromReferencePoint.y() + mFrameSize.height() );

    case 2:

      return QLineF( mOffsetFromReferencePoint.x() + mFrameSize.width(), mOffsetFromReferencePoint.y() + mFrameSize.height(), \

                     mOffsetFromReferencePoint.x(), mOffsetFromReferencePoint.y() + mFrameSize.height() );

    case 3:

      return QLineF( mOffsetFromReferencePoint.x(), mOffsetFromReferencePoint.y() + mFrameSize.height(), \

                     mOffsetFromReferencePoint.x(), mOffsetFromReferencePoint.y() );

    default:

      return QLineF();

  }

}

QPointF QgsAnnotationItem::pointOnLineWithDistance( const QPointF& startPoint, const QPointF& directionPoint, double distance ) const

{

  double dx = directionPoint.x() - startPoint.x();

  double dy = directionPoint.y() - startPoint.y();

  double length = sqrt( dx * dx + dy * dy );

  double scaleFactor = distance / length;

  return QPointF( startPoint.x() + dx * scaleFactor, startPoint.y() + dy * scaleFactor );

}

QgsAnnotationItem::MouseMoveAction QgsAnnotationItem::moveActionForPosition( const QPointF& pos ) const

{

  QPointF itemPos = mapFromScene( pos );

  int cursorSensitivity = 7;

  if ( abs( itemPos.x() ) < cursorSensitivity && abs( itemPos.y() ) < cursorSensitivity ) //move map point if position is close to the origin

  {

    return MoveMapPosition;

  }

  bool left, right, up, down;

  left = abs( itemPos.x() - mOffsetFromReferencePoint.x() ) < cursorSensitivity;

  right = abs( itemPos.x() - ( mOffsetFromReferencePoint.x() + mFrameSize.width() ) ) < cursorSensitivity;

  up = abs( itemPos.y() - mOffsetFromReferencePoint.y() ) < cursorSensitivity;

  down = abs( itemPos.y() - ( mOffsetFromReferencePoint.y() + mFrameSize.height() ) ) < cursorSensitivity;

  if ( left && up )

  {

    return ResizeFrameLeftUp;

  }

  else if ( right && up )

  {

    return ResizeFrameRightUp;

  }

  else if ( left && down )

  {

    return ResizeFrameLeftDown;

  }

  else if ( right && down )

  {

    return ResizeFrameRightDown;

  }

  if ( left )

  {

    return ResizeFrameLeft;

  }

  if ( right )

  {

    return ResizeFrameRight;

  }

  if ( up )

  {

    return ResizeFrameUp;

  }

  if ( down )

  {

    return ResizeFrameDown;