EventHandler.h

#ifndef EVENTHANDLER
#define EVENTHANDLER

/* EventHandler
 * It is represented as a switcher between all the other
 * user-defined handlers. Depending on the mouse mode (select, edit,
 * navigate, sketch, etc), it choses the right handle() function of the
 * corresponding event handler. Of course, all the handlers must be
 * initialized in the contstructor. The mode can be reset by a user class.
*/

#include <osgGA/GUIEventHandler>
#include <osgGA/GUIEventAdapter>
#include <osgGA/GUIActionAdapter>
#include <osg/ref_ptr>
#include <osg/observer_ptr>

#include "../libGUI/GLWidget.h"
#include "Settings.h"
#include "Canvas.h"
#include "Photo.h"
#include "SVMData.h"
#include "DraggableWire.h"
#include "CamPoseData.h"
#include "EditableWire.h"
#include "UserScene.h"
#include "RootScene.h"
#include "StrokeIntersector.h"
#include "Entity2DIntersector.h"
#include "LineIntersector.h"
#include "PolyLineIntersector.h"
#include "PointIntersector.h"
#include "VirtualPlaneIntersector.h"
#include "BookmarkToolIntersector.h"
#include "CanvasNormalProjector.h"

class GLWidget;

class EventHandler : public osgGA::GUIEventHandler {
public:
    EventHandler(GLWidget* widget, RootScene* scene, cher::MOUSE_MODE mode = cher::SELECT_ENTITY);

    virtual bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void setMode(cher::MOUSE_MODE mode);
    cher::MOUSE_MODE getMode() const;

protected:
    void doEraseStroke(entity::Stroke *stroke, int first, int last, cher::EVENT event = cher::EVENT_DRAGGED);

    void doSelectEntity(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    template <typename T1, typename T2>
    void doSelectCanvas(const osgGA::GUIEventAdapter &ea, osgGA::GUIActionAdapter &aa);

    void doSketch(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doSketchPolygon(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doSketchLineSegment(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doDeleteEntity(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doEditCanvas(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doEditCanvasOffset(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    /* A sub-method for canvas editing to perform rotation. */
    void doEditCanvasRotate(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa,
                            osg::Vec3f alongAxis, osg::Vec3f rotAxis);

    void doCanvasClone(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doCanvasSeparate(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    template <typename T1, typename T2>
    void doEditPhotoPush(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doEditEntitiesMove(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doEditEntitiesScale(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    void doEditEntitiesRotate(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa);

    /* A method for idle mode of SVM (Single View Metrology) related activity. PolyLineIntersector is used. */
    void doIdleMouse(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doHoverWire(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doHoverPoint(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doDragPoint(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doCameraEye(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doCameraCenter(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doCameraFocal(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doPhotoScaleModelPlane(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

    void doPhotoScaleBookmark(const osgGA::GUIEventAdapter & ea, osgGA::GUIActionAdapter & aa);

protected:
    entity::Stroke*     getStroke(const StrokeIntersector::Intersection& result);

    template <typename EntityType>
    EntityType*         getEntity2D(const Entity2DIntersector<entity::Entity2D>::Intersection& result)
    {
        return dynamic_cast<EntityType*>(result.drawable.get());
    }

    entity::Canvas*     getCanvas(const osgUtil::LineSegmentIntersector::Intersection& result);

    entity::Photo*      getPhoto(const osgUtil::LineSegmentIntersector::Intersection& result);

    entity::Polygon*    getPolygon(const osgUtil::LineSegmentIntersector::Intersection& result);

    entity::DraggableWire* getDraggableWire(const PolyLineIntersector::Intersection& result);

    entity::BookmarkTool* getBookmarkTool(const PolyLineIntersector::Intersection& result);

    int getSelectedPoint(const PointIntersector::Intersection& result);

    template <typename T>
    cher::MOUSE_MODE getMouseModeFromName(const T& result, cher::MOUSE_MODE mode_default) const;

    cher::MOUSE_MODE getMouseModeFromEvent(cher::MOUSE_MODE mode, const osgGA::GUIEventAdapter& ea);

    template <typename TypeIntersection, typename TypeIntersector>
    bool getIntersection(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa, unsigned int mask,
                         TypeIntersection& resultIntersection);

    bool getRaytraceCanvasIntersection(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa,
                                 double& u, double& v);

    bool getRaytraceNormalProjection(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa,
                                     osg::Vec3f &XC);

    bool getRaytracePlaneIntersection(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa,
                                      const osg::Vec3f& axis, osg::Vec3f& P);

    template <typename TResult, typename TIntersector>
    bool setCanvasMouseMode(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa, cher::MOUSE_MODE modeDefault, bool selected = true);

    template <typename TResult, typename TIntersector>
    std::tuple<bool, TResult> setSVMMouseMode(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa, cher::MOUSE_MODE modeDefault);

    void setDrawableColorFromMode(osg::Drawable* draw);

    void updateWireGeometry(const PolyLineIntersector::Intersection& intersection);
    void updatePointGeometry(const PointIntersector::Intersection& intersection);
    void updateDragPointGeometry(const std::tuple<double, double, bool>& intersection, const osgGA::GUIEventAdapter& ea);

    void finishAll();

protected:
    GLWidget*                           m_glWidget;     
    cher::MOUSE_MODE                    m_mode;         
    osg::observer_ptr<RootScene>        m_scene;        
    osg::observer_ptr<entity::DraggableWire> m_selection;
    osg::observer_ptr<entity::EditableWire> m_selection2;
    osg::observer_ptr<entity::BookmarkTool> m_tool;
};

#endif // EVENTHANDLER