Initial commit

Lts/Viewer/SituationMap/Tests/EsriMapTouchTest/abstract_event_dispatcher.h

@@ -0,0 +1,232 @@
+/**
+**
+** @RDE_HEADER@
+** Abstract Event Dispatcher for Qt5
+** $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 .........:
+**
+**   28.04.2003, JT  : First edition for use with Qt4 in START Feature Editor fee
+**   25.03.2015, JT  : Refactoring for use with Qt5
+**
+** -----------------------------------------------------------------------------------------------
+*/
+
+#pragma once
+
+#include <functional>
+
+#include <QtCore/QObject>
+#include <QtCore/QEvent>
+#include <QtCore/QList>
+#include <QtCore/QString>
+#include <QtCore/QTime>
+
+#include <QtGui/QCursor>
+
+
+class QWidget;
+class QWheelEvent;
+class QGestureRecognizer;
+
+
+namespace SituationMap { namespace RB
+{
+
+   /**
+     @class  AbstractEventDispatcher  abstract_event_dispatcher.h
+     @brief Base class of Qt event filter implementations to handle user interactions of map window
+
+     An EventDispatcher installs an event filter on a QWidget to receive all events that are send to
+     the widget. Depending on the type of event and the state of the event dispatcher the event will 
+     be processed by the dispatcher and stopped or forwarded to the QWidget. In case of processing
+     the event methodes of the EventActionInterface are called to controll a rubberband. 
+
+     @see EventDelegater, EventDispatcher, EventMouseNavigator
+   */
+   class AbstractEventDispatcher : public QObject
+   {
+      friend class EventDelegater;
+      
+      Q_OBJECT
+
+      public:
+
+         /**
+            @brief Logical interface between EventDispatcher and Rubberband
+            Defines interface functions the EventDispatcher will call to control a rubberband. The rubberband class 
+            is derived from EventActionInterface and overrides the interface functions to implement them. The mapping
+            user interaction to interface action is defined the derived classes of AbstractEventDispatcher.
+         */
+         class EventActionInterface
+         {
+            public:
+            
+               EventActionInterface()          = default;
+               virtual ~EventActionInterface() = default;
+
+               virtual void unlinkEventDispatcher( AbstractEventDispatcher * causer ) = 0;
+
+               virtual bool selectAction        ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool multiSelectAction   ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool setCoordinateAction ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool moveAction          ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool movePickedAction    ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual void resetAction         ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool contextMenuAction   ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool completeStateAction ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool deleteAction        ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool undoAction          ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool applyAndEndAction   ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+               virtual bool abortAction         ( AbstractEventDispatcher * causer, int x, int y ) = 0;
+
+         }; /* EventActionInterface */
+
+         /**
+            @name Construction & Destruction
+            @{
+         */
+         AbstractEventDispatcher( QWidget * getEventsFrom );
+         AbstractEventDispatcher( QWidget * getEventsFrom, EventActionInterface* );
+
+         virtual ~AbstractEventDispatcher();
+
+         AbstractEventDispatcher(const AbstractEventDispatcher &) = delete;
+         AbstractEventDispatcher & operator = (const AbstractEventDispatcher &) = delete;
+         /** @} */
+
+         /**
+           Conceal deleteLater slot. Use onDo_delete() instead to avoid "QCoreApplication::postEvent: Unexpected null receiver" warning.
+         */
+         void deleteLater() = delete;
+
+
+         inline void setEventActions(EventActionInterface * eventActions) { _eventActions = eventActions; }
+
+         inline bool hasGrab() const { return _hasGrab; }
+
+         inline void setCursor(const QCursor & cursor) { _dispatcherCursor = cursor; }
+
+         void setWhatsThis(const QString & whatsThis);
+
+         virtual void grab();
+         virtual void ungrab();
+
+
+      public slots:
+
+        /**
+           @brief Slot calling internal \c KickTheBucket methode
+           
+           Calls internal methode \c KickTheBucket. Be careful using this function. Should only be used
+           from implementations of \c EventActionInterface methodes or \c EventDelegater class.
+         */
+         void onDo_kickTheBucket();
+
+         /**
+           @brief Slot calling \c deleteLater function of QObject
+           
+           Never use \c delete directly for EventDispatcher class. Instead of use \c onDo_delete() function.
+         */
+         void onDo_delete();
+
+      protected:
+
+         QWidget * _getEventsFrom;
+         bool      _cursorIsInWidget;
+
+         inline bool hasFinished()    { return _finishFlag;  }
+         inline bool hasActiveEvent() { return _activeEvent; }
+
+         inline void setActiveEvent(bool val) { _activeEvent = val; }
+
+         /**
+            @brief Destroying EventDispatcher as result of an incoming event.
+
+            As result of an incomming event (e.g. Keypress ESC) the EventDispatcher will stop, emiting signal \c signalKickTheBucket() 
+            and calls methode \c EventActionInterface::unlinkEventDispatcher() before setup \c deleteLater() call to destroy it self.
+         */
+         virtual void KickTheBucket();
+
+
+         inline void unlinkEventDispatcher()
+         {
+            if (_eventActions)
+            {
+               _eventActions -> unlinkEventDispatcher( this );
+               _eventActions  = nullptr;
+            }
+         } /* unlinkEventDispatcher */
+
+
+         inline bool callEventAction( bool( EventActionInterface::*actionMethodePtr)( AbstractEventDispatcher*,int,int), int x, int y )
+         {
+            if (_eventActions == nullptr) return false;
+            return (_eventActions->*actionMethodePtr)( this, x, y );
+         } /* callEventAction */
+
+
+         /**
+            Event filter function to override to implement event handling. To workaround a cursor handling bug in QGraphicsView it is
+            necessary to call the eventFilter function of this base class, which will monitor enter and leave events.
+         */
+         virtual bool eventFilter( QObject * widget, QEvent * e );
+   
+         inline EventActionInterface * getEventActions() const { return _eventActions; }
+
+         void    setCursorToWidget( const QCursor & cursor );
+         QCursor getCursorFromWidget();
+
+         ulong                  _ignoreMouseMoveTimestamp;
+
+         bool                   _synthesisTouchFromMouseEvents;
+
+         static unsigned int    _applyGestureID;
+
+      private:
+
+         void initDispatcher();
+
+         bool                   _deleteRequested;
+
+         bool                   _hasGrab;
+         bool                   _finishFlag;
+
+         bool                   _restoreCursor;
+         bool                   _restoreMouseTracking;
+         QCursor                _cursorToRestore;
+
+         bool                   _activeEvent;
+
+         QCursor                _dispatcherCursor;
+         QString                _whatsThisBackup;
+
+         EventActionInterface * _eventActions;
+
+        
+
+         static QGestureRecognizer * _applyGestureDetection;
+         
+      signals:
+
+         void signalKickTheBucket();
+
+   }; /* EventDispatcher */
+
+} } /* namespace SituationMap::RB */
+