SceneMouseHandler.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLGeom/src/ICLGeom/SceneMouseHandler.h                **
** Module : ICLGeom                                                **
** Authors: Christof Elbrechter, Erik Weitnauer, Daniel Dornbusch  **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#if !defined(HAVE_OPENGL) || !defined(HAVE_QT)
#warning "this header must not be included if HAVE_OPENGL or HAVE_QT is not defined"
#else


#include <ICLGeom/Camera.h>
#include <ICLQt/MouseHandler.h>

namespace icl{

  namespace qt{
    class GUI;
  }
  namespace geom{
    

    typedef void (*MouseActionCallback)(const qt::MouseEvent&,const utils::Point32f&,
                                        const utils::Point32f&,Camera&,void* );
    
    
    class Scene;
    
    
    struct MouseMappingTableEntry{
      MouseActionCallback mMouseAction;
      
      void* mData;
    };
    
    
    struct MouseSensitivities{
      float mTranslation;
      
      float mRotation;
      
      float mMouse;
      
      float mWheel;
    };
    
    
    enum MouseSensitivitiesModifier{
      LowMouseSensitivity    = 0,
      NormalMouseSensitivity = 1,
      HighMouseSensitivity   = 2,
      MAX_MOUSE_SENSITIVITY  = HighMouseSensitivity
    };
    
    
        
    class SceneMouseHandler : public qt::MouseHandler{
      protected:
      

      MouseMappingTableEntry mMouseMappingTable[qt::MAX_MOUSE_EVENT + 1][2][2][2][2][2][2];
      
      MouseSensitivities mMouseSensitivities[MAX_MOUSE_SENSITIVITY + 1];
      
      Camera mCameraBackup;
      
      utils::Point32f mAnchor;
      
      Scene* mParentScene;
      
      int mCameraIndex;
      
      int mKeyboardModifiersBackup;
      
      qt::GUI *mGUI;
      
      public:
      

      SceneMouseHandler(const int pCameraIndex, Scene* pParentScene );
      

      SceneMouseHandler(const SceneMouseHandler& pSceneMouseHandler){
        *this = pSceneMouseHandler;
      }

      ~SceneMouseHandler();
      
      SceneMouseHandler& operator=(const SceneMouseHandler& pSceneMouseHandler);
      
      void setParentScene(Scene* pParentScene){
        mParentScene = pParentScene;
      }
      
      Scene* getParentScene(){
        return mParentScene;
      }
      

      void setSensitivities(const float pTranslation, const float pRotation = 1.0,
                            const float pMouse = 1.0, const float pWheel = 0.001,
                            const float pModifier = 10.0 );
      


      MouseSensitivities getSensitivities(MouseSensitivitiesModifier pMouseSensitivitiesModifier){
        return mMouseSensitivities[pMouseSensitivitiesModifier];
      };
      
      

      void setCameraIndex(const int pCameraIndex){
        mCameraIndex = pCameraIndex;
      }
      
      

      int getCameraIndex(){
        return mCameraIndex;
      }



      virtual void setMouseMappings();
      
      

      void setMouseMapping(const qt::MouseEventType pMouseEventType,
                           const bool pLeftMouseButton,
                           const bool pMiddleMouseButton,
                           const bool pRightMouseButton,
                           const bool pShift,
                           const bool pControl,
                           const bool pAlt,
                           MouseActionCallback pMouseActionCallback,
                           void* pData=0);



      static void freeView(const qt::MouseEvent &pMouseEvent,
                           const utils::Point32f &pCurrentMousePosition,
                           const utils::Point32f &pDeltaMousePosition,
                           Camera &pCamera, void *pData,
                           bool pInverseX, bool pInverseY);



      static void freeView(const qt::MouseEvent &pMouseEvent,
                           const utils::Point32f &pCurrentMousePosition,
                           const utils::Point32f &pDeltaMousePosition,
                           Camera &pCamera, void *pData){
        freeView( pMouseEvent, pCurrentMousePosition, pDeltaMousePosition, pCamera, pData, false, false );
      }
      
      

      static void freeViewInverseMouseX(const qt::MouseEvent &pMouseEvent,
                                        const utils::Point32f &pCurrentMousePosition,
                                        const utils::Point32f &pDeltaMousePosition,
                                        Camera &pCamera, void *pData){
        freeView( pMouseEvent, pCurrentMousePosition, pDeltaMousePosition, pCamera, pData, true, false );
      }



      static void freeViewInverseMouseY(const qt::MouseEvent &pMouseEvent,
                                        const utils::Point32f &pCurrentMousePosition,
                                        const utils::Point32f &pDeltaMousePosition,
                                        Camera &pCamera, void *pData){
        freeView( pMouseEvent, pCurrentMousePosition, pDeltaMousePosition, pCamera, pData, false, true );
      }
      
      

      static void freeViewInverseBoth(const qt::MouseEvent &pMouseEvent,
                                      const utils::Point32f &pCurrentMousePosition,
                                      const utils::Point32f &pDeltaMousePosition,
                                      Camera &pCamera, void *pData){
        freeView( pMouseEvent, pCurrentMousePosition, pDeltaMousePosition, pCamera, pData, true, true );
      }
      
      

      static void rotateAroundOrigin(const qt::MouseEvent &pMouseEvent,
                                     const utils::Point32f &pCurrentMousePosition,
                                     const utils::Point32f &pDeltaMousePosition,
                                     Camera &pCamera, void *pData);
      

      static void strafe(const qt::MouseEvent &pMouseEvent,
                         const utils::Point32f &pCurrentMousePosition,
                         const utils::Point32f &pDeltaMousePosition,
                         Camera &pCamera, void *pData);
      

      static void rollAndDistance(const qt::MouseEvent &pMouseEvent,
                                  const utils::Point32f &pCurrentMousePosition,
                                  const utils::Point32f &pDeltaMousePosition,
                                  Camera &pCamera, void *pData);
      
      

      virtual void process(const qt::MouseEvent &pMouseEvent);
    };
    
  } // namespace geom
}

#endif