Initial commit

Lts/Viewer/SituationMap/Rubberbands/rubberband_point_handle.cpp

@@ -0,0 +1,390 @@
+
+/**
+**
+** @RDE_HEADER@
+** Implementation of base class for rubberband handles
+** $Id$
+** $HeadURL$
+** $Author$
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Hardware-Environment: Intel-PC
+** Software-Environment: Windows 7, Qt 5.4. ArcGIS 10.2.5
+**
+** Language ........: C++ 11
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Author ...........: Jörg Turla, SPD G, Tel. 3132
+**
+** -----------------------------------------------------------------------------------------------
+**
+** Notes .........:
+**
+**   27.03.2015, JT  : First edition for use with Qt5
+**
+** -----------------------------------------------------------------------------------------------
+*/
+
+#include "rubberband_point_handle.h"
+
+#include <MathUtils/math_const.h>
+
+#include <arcgis/MapGraphicsView.h>
+
+#include <QtWidgets/QGraphicsScene>
+#include <QtWidgets/QGraphicsEllipseItem>
+
+namespace SituationMap { namespace RB
+{
+
+   RubberbandPointHandle::RubberbandPointHandle( Esri::ArcGISRuntime::MapGraphicsView * mapView
+                                               , QGraphicsScene                       * scene
+                                               , const QPointF                        & scenePosition )
+      : RubberbandHandle(mapView,scene)
+      , _pointSymbol(nullptr)
+      , _coordinate( mapView, scenePosition )
+      , _sceneOffset(0,0)
+      , _iconPixmap(nullptr)
+      , _boundingRect(nullptr)
+   {
+      zBufferPlane( ZBufferPlane::PointHandle );
+      buildHandle( scenePosition );
+   } /* RubberbandPointHandle::RubberbandPointHandle */
+
+
+   RubberbandPointHandle::RubberbandPointHandle( Esri::ArcGISRuntime::MapGraphicsView * mapView
+                                               , QGraphicsScene                       * scene
+                                               , const Esri::ArcGISRuntime::Point     & mapCoordinate )
+      : RubberbandHandle(mapView,scene)
+      , _pointSymbol(nullptr)
+      , _coordinate( mapView, mapCoordinate )
+      , _sceneOffset(0,0)
+      , _iconPixmap(nullptr)
+      , _boundingRect(nullptr)
+   {
+      zBufferPlane( ZBufferPlane::PointHandle );
+      buildHandle( _coordinate._sceneCoordinate );
+   } /* RubberbandPointHandle::RubberbandPointHandle */
+
+
+      RubberbandPointHandle::RubberbandPointHandle( Esri::ArcGISRuntime::MapGraphicsView * mapView
+                                                   , QGraphicsScene                 * scene
+                                                   , const QPointF                  & scenePosition
+                                                   , const QPixmap                  & icon              )
+      : RubberbandHandle(mapView,scene)
+      , _pointSymbol(nullptr)
+      , _coordinate( mapView, scenePosition )
+      , _sceneOffset(0,0)
+      , _iconPixmap( new QPixmap(icon) )
+      , _boundingRect(nullptr)
+   {
+      zBufferPlane( ZBufferPlane::PointHandle );
+      buildHandle( scenePosition );
+   } /* RubberbandPointHandle::RubberbandPointHandle */
+
+
+   RubberbandPointHandle::RubberbandPointHandle( Esri::ArcGISRuntime::MapGraphicsView * mapView
+                                               , QGraphicsScene                       * scene
+                                               , const Esri::ArcGISRuntime::Point     & mapCoordinate
+                                               , const QPixmap                        & icon            )
+      : RubberbandHandle(mapView,scene)
+      , _pointSymbol(nullptr)
+      , _coordinate( mapView, mapCoordinate )
+      , _sceneOffset(0,0)
+      , _iconPixmap( new QPixmap(icon) )
+      , _boundingRect(nullptr)
+   {
+      zBufferPlane( ZBufferPlane::PointHandle );
+      buildHandle( _coordinate._sceneCoordinate );
+   } /* RubberbandPointHandle::RubberbandPointHandle */
+
+
+   void RubberbandPointHandle::setIcon( const QPixmap & icon )
+   {
+      if (_iconPixmap == nullptr)
+      {
+         _iconPixmap  = new QPixmap(icon);
+         if (_pointSymbol)
+         {
+           _scene->removeItem(_pointSymbol);
+           delete _pointSymbol;
+           _pointSymbol = nullptr;
+         }
+         buildHandle( _coordinate._sceneCoordinate );
+         return;
+      }
+
+      *_iconPixmap = icon;
+
+      QGraphicsPixmapItem * iconItem = static_cast<QGraphicsPixmapItem*>( _pointSymbol);
+      if (iconItem)
+      {
+         iconItem->setPixmap( *_iconPixmap );
+         QRectF bbox = iconItem->boundingRect();
+          bbox.moveCenter( _coordinate._sceneCoordinate );
+         if (_boundingRect) _boundingRect->setRect(bbox);
+      }
+      else buildHandle( _coordinate._sceneCoordinate );
+   } /* RubberbandPointHandle::setIcon */
+
+
+   void RubberbandPointHandle::buildHandle( const QPointF & scenePosition )
+   {
+      if (_scene != nullptr)
+      {
+         if (_iconPixmap != nullptr)
+         {
+            if (_iconPixmap->isNull())
+            {
+               delete _iconPixmap;
+               _iconPixmap = nullptr;
+            }
+         }
+
+         if (_iconPixmap == nullptr)
+         {
+            QGraphicsEllipseItem * kuller = new QGraphicsEllipseItem();
+
+            _pointSymbol = kuller;
+
+            if (_pointSymbol != nullptr)
+            {
+               _scene -> addItem( _pointSymbol );
+
+               kuller -> setPos( scenePosition+_sceneOffset );
+               kuller -> setRect( -qreal(_pickingRatio), -qreal(_pickingRatio), qreal(2*_pickingRatio), qreal(2*_pickingRatio) );
+               kuller -> setZValue( _zBufferValue );
+
+               kuller -> setCacheMode(QGraphicsItem::CacheMode::NoCache, QSize(_pickingRatio*2,_pickingRatio*2) );
+               kuller -> setFlags( QGraphicsItem::ItemIgnoresTransformations );
+               kuller -> setVisible( _isVisible );
+            }
+         }
+         else
+         {
+            QGraphicsPixmapItem * icon = new QGraphicsPixmapItem(*_iconPixmap);
+
+            _pointSymbol = icon;
+
+            if (_pointSymbol != nullptr)
+            {
+               _scene -> addItem( _pointSymbol );
+
+               qreal xOff = -(_iconPixmap->width()  * 0.5);
+               qreal yOff = -(_iconPixmap->height() * 0.5);
+
+               icon -> setPos( scenePosition+_sceneOffset );
+               icon -> setZValue( _zBufferValue );
+               icon -> setFlags( QGraphicsItem::ItemIgnoresTransformations );
+               icon -> setVisible( _isVisible );
+               icon -> setOffset( xOff, yOff );
+               icon -> setShapeMode( QGraphicsPixmapItem::BoundingRectShape );
+
+               QRectF bbox = icon->boundingRect();
+               bbox.moveCenter( scenePosition );
+
+               _boundingRect  = new QGraphicsRectItem( bbox );
+               _boundingRect -> setZValue(_zBufferValue-1);
+               _boundingRect -> setVisible( _isVisible );
+
+               _scene -> addItem( _boundingRect );
+
+            }
+         }
+      }
+   } /* RubberbandPointHandle::buildHandle */
+
+
+   RubberbandPointHandle::~RubberbandPointHandle()
+   {
+      delete _iconPixmap;
+      if (_scene)
+      {
+        
+        if (nullptr != _boundingRect)
+        {
+          _scene->removeItem(_boundingRect);
+          delete _boundingRect;
+        }
+
+        if (nullptr != _pointSymbol)
+        {
+          _scene->removeItem(_pointSymbol);
+          delete _pointSymbol;
+        }
+      }
+
+      _pointSymbol  = nullptr;
+      _iconPixmap   = nullptr;
+      _boundingRect = nullptr;
+
+   } /* RubberbandHandle::~Rubberbandhandle */
+
+
+   QPointF RubberbandPointHandle::getRotatedSceneOffset() const
+   {
+      auto rotate = [](const QPointF & p, qreal sinA, qreal cosA) -> QPointF { return QPointF(p.x()*cosA+p.y()*sinA,p.y()*cosA-p.x()*sinA); };
+
+      qreal mapRotatePhi = _mapView->mapRotation() * MathConst::pi / 180.0;
+
+      qreal sinMap = sin(mapRotatePhi);
+      qreal cosMap = cos(mapRotatePhi);
+
+      return rotate( _sceneOffset, sinMap, cosMap );
+   } /* RubberbandPointHandle::getRotatedSceneOffset */
+
+
+   void RubberbandPointHandle::adjustCoordinates()
+   {
+      const QPointF & rotatedSceneOffset = getRotatedSceneOffset();
+
+      if (_iconPixmap == nullptr)
+      {
+         static_cast<QGraphicsEllipseItem*>(_pointSymbol)->setPos(_coordinate.mapToScene(_mapView)+rotatedSceneOffset);
+      }
+      else
+      {
+         QGraphicsPixmapItem * icon = static_cast<QGraphicsPixmapItem*>( _pointSymbol);
+
+         const QPointF & scenePosition = _coordinate.mapToScene(_mapView);
+         icon -> setPos( scenePosition+rotatedSceneOffset );
+
+         QRectF bbox = icon->boundingRect();
+         bbox.moveCenter( scenePosition+rotatedSceneOffset );
+         _boundingRect->setRect(bbox);
+      }
+      
+      DEBUG_LOG(_logger) << LOGFUNCTION << " map-coordinate = "   << QString::number(_coordinate._mapCoordinate.x(),'f',15)   
+                                                         << " ; " << QString::number(_coordinate._mapCoordinate.y(),'f',15)
+                                        << " scene-coordinate = " << _coordinate._sceneCoordinate.x() << " ; " << _coordinate._sceneCoordinate.y();
+      emit adjusted();
+   } /* RubberbandPointHandle::onDo_adjustCoordinates */
+
+
+   void RubberbandPointHandle::adjustWindow( const QRectF& )
+   {
+      onDo_adjustCoordinates();
+   } /* RubberbandPointHandle::onDo_adjustWindow */
+
+
+   void RubberbandPointHandle::updateGraphic()
+   {
+      if (_pointSymbol)
+      {
+         if (_pointSymbol != nullptr)
+         {
+            if (_iconPixmap == nullptr)
+            {
+               QGraphicsEllipseItem * kuller = static_cast<QGraphicsEllipseItem*>( _pointSymbol);
+
+               kuller -> setPen( QPen(_drawColor) );
+
+               QRadialGradient gradient(0, 0, _pickingRatio, 0, 0);
+               QColor          gradientColor = (_isSelected) ? _selectionColor : _fillColor;
+
+               gradient.setColorAt( 0, gradientColor);
+               gradient.setColorAt( 1, QColor(gradientColor.red(), gradientColor.green(), gradientColor.blue(), 0) );
+               kuller -> setBrush( QBrush(gradient) );
+               kuller -> setVisible( _isVisible );
+            }
+            else
+            {
+               QGraphicsPixmapItem * icon = static_cast<QGraphicsPixmapItem*>( _pointSymbol);
+
+               _boundingRect -> setPen( QPen(_drawColor) );
+               const QColor &backColor = (_isSelected) ? _selectionColor : _fillColor;
+               _boundingRect -> setBrush( QBrush(backColor) );
+               _boundingRect -> setVisible( _isVisible );
+               icon          -> setVisible( _isVisible );
+            }
+         }
+      }
+   } /* RubberbandPointHandle::updateGraphic */
+
+
+   void RubberbandPointHandle::updateCoordinate(const QPointF & scenePosition)
+   {
+      const QPointF & rotatedSceneOffset = getRotatedSceneOffset();
+
+      _coordinate.updateSceneCoordinate( _mapView, scenePosition );
+
+      if (_pointSymbol != nullptr)
+      {
+         if (_iconPixmap == nullptr)
+         {
+            QGraphicsEllipseItem * kuller = static_cast<QGraphicsEllipseItem*>( _pointSymbol);
+            kuller -> setPos( scenePosition+rotatedSceneOffset );
+         }
+         else
+         {
+            QGraphicsPixmapItem * icon = static_cast<QGraphicsPixmapItem*>( _pointSymbol);
+            icon -> setPos( scenePosition+rotatedSceneOffset );
+
+            QRectF bbox = icon->boundingRect();
+            bbox.moveCenter( scenePosition+rotatedSceneOffset );
+
+            _boundingRect->setRect(bbox);
+         }
+      }
+   } /* RubberbandPointHandle::updateCoordinate */
+
+
+   void RubberbandPointHandle::updateCoordinate()
+   {
+      const QPointF & rotatedSceneOffset = getRotatedSceneOffset();
+
+      if (_pointSymbol != nullptr)
+      {
+         if (_iconPixmap == nullptr)
+         {
+            QGraphicsEllipseItem * kuller = static_cast<QGraphicsEllipseItem*>( _pointSymbol);
+            kuller -> setPos( _coordinate._sceneCoordinate+rotatedSceneOffset );
+         }
+         else
+         {
+            QGraphicsPixmapItem * icon = static_cast<QGraphicsPixmapItem*>( _pointSymbol);
+            icon -> setPos( _coordinate._sceneCoordinate+rotatedSceneOffset );
+
+            QRectF bbox = icon->boundingRect();
+
+            bbox.moveCenter( _coordinate._sceneCoordinate+rotatedSceneOffset );
+            _boundingRect->setRect(bbox);
+         }
+      }
+   } /* RubberbandPointHandle::updateCoordinate */
+
+
+   void RubberbandPointHandle::moveCoordinate(const QPointF & sceneDelta)
+   {
+      _coordinate.updateSceneCoordinate( _mapView, _coordinate._sceneCoordinate+sceneDelta );
+      updateCoordinate();
+   } /* RubberbandPointHandle::moveCoordinate */
+
+
+   void RubberbandPointHandle::setCoordinate(const  RubberbandHandle::RubberbandCoordinate & p)
+   {
+      _coordinate = p;
+      updateCoordinate();
+   } /*  RubberbandPointHandle::setCoordinate */
+
+
+   RubberbandHandle::RubberbandCoordinate RubberbandPointHandle::getCoordinate() const  { return _coordinate; }
+
+   QPointF RubberbandPointHandle::getPixelCoordinate() const
+   {
+     return _coordinate._sceneCoordinate;
+   }
+
+
+   bool RubberbandPointHandle::isPositionInside( const QPointF & scenePosition ) const
+   {
+      if (_pointSymbol)
+      {
+         return _pointSymbol->contains( _coordinate._sceneCoordinate+getRotatedSceneOffset() - scenePosition );
+      }
+      return false;
+   } /* RubberbandPointHandle::isPositionInside */
+
+} } /* namespace SituationMap::RB */