ManipEvents.h

Go to the documentation of this file.

///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2003
///////////////////////////////////////////////////////////////////////////

//ManipEvents.h
// Joe Kniss

#ifndef __MANIPULATOR_EVENTS_DOT_H
#define __MANIPULATOR_EVENTS_DOT_H

#include "ManipEventBase.h"
#include "Manip.h"

namespace gutz {

typedef ManipEventBase<Manip>        ManipEvent;
typedef gutz::SmartPtr< ManipEvent > ManipEventSP;

///////////////////////////////////////////////////////////////////////////
/// Rotate Manip Event.  Rotates a manipulator about its center of
/// rotation.  
///////////////////////////////////////////////////////////////////////////
class RotateManipEvent : public ManipEventBase<Manip> {
public:
   RotateManipEvent(float speed = 1.0f)
      : ManipEventBase<Manip>(speed), _tumbquat(quatf_id) {}
   RotateManipEvent(const RotateManipEvent &mre)
      : ManipEventBase<Manip>(mre), _tumbquat(mre._tumbquat)
   {}
   virtual ~RotateManipEvent() {}

   RotateManipEvent &operator=(const RotateManipEvent &mre)
   { ManipEventBase<Manip>::operator =(mre); return *this; 
     _tumbquat = mre._tumbquat;
   }

   virtual ManipEventBase<Manip> *clone() const { return new RotateManipEvent(*this); }

   ///@name Event Handlers
   ///@{

   /// should be called on a Mouse-down event, starts the event
   bool startEvent(Manip *m, const MouseEvent &me);
   /// should be called when the mouse moves
   bool handleEvent(Manip *m, const MouseMoveEvent &mme);
   /// called when the event is over, may or may not be on a Mouse-up event
   void endEvent(Manip *m, const MouseEvent &me);
   /// repeat last event
   bool tumble(Manip *m);
   ///@}

protected:
   float _rad;
   quatf _tumbquat;
};

///////////////////////////////////////////////////////////////////////////
/// Translate XY Manip Event.  Translates the manipulator in X&Y relative
///  to the current view. This is also a base class for other translation
///  events.
///////////////////////////////////////////////////////////////////////////

class TransXYManipEvent : public ManipEventBase<Manip> {
public:
   TransXYManipEvent(float speed = 1.0f)
      : ManipEventBase<Manip>(speed), _lastTrans(vec3f_zero)
   {}
   TransXYManipEvent(const TransXYManipEvent &tme)
      : ManipEventBase<Manip>(tme), _lastTrans(vec3f_zero)
   {}
   virtual ~TransXYManipEvent() {}

   TransXYManipEvent &operator=(const TransXYManipEvent &tme)
   {  ManipEventBase<Manip>::operator =(tme); 
      _lastTrans = vec3f_zero;
      return *this; 
   }

   /// be sure to override this in any sub-classes
   virtual ManipEventBase<Manip> *clone() const { return new TransXYManipEvent(*this); }

   ///@name Event Handlers
   ///@{

   /// should be called on a Mouse-down event, starts the event
   bool startEvent(Manip *m, const MouseEvent &me);
   /// should be called when the mouse moves
   bool handleEvent(Manip *m, const MouseMoveEvent &mme);
   /// called when the event is over, may or may not be on a Mouse-up event
   void endEvent(Manip *m, const MouseEvent &me);
   /// repeat last event
   bool tumble(Manip *m);
   ///@}

protected:
   /// returns the translaton for this local frame (actually defined in parent's space)
   vec3f getDelta(Manip *m, const MouseMoveEvent &mme) const;

   vec3f _lastTrans;
};

///////////////////////////////////////////////////////////////////////////
/// Translate Z Manip Event.  Translates the manipulator in Z relative
///  to the current view (along the view direction)
///////////////////////////////////////////////////////////////////////////

class TransZManipEvent : public TransXYManipEvent {
public:
   TransZManipEvent(float speed = 1.0f)
      : TransXYManipEvent(speed)
   {}
   TransZManipEvent(const TransZManipEvent &tme)
      : TransXYManipEvent(tme)
   {}
   virtual ~TransZManipEvent() {}

   TransZManipEvent &operator=(const TransZManipEvent &tme)
   {  TransXYManipEvent::operator =(tme); 
      return *this; 
   }

   virtual ManipEventBase<Manip> *clone() const { return new TransZManipEvent(*this); }

   ///@name Event Handlers
   ///@{
   /// should be called when the mouse moves
   bool handleEvent(Manip *m, const MouseMoveEvent &mme);
   ///@}

protected:
};

///////////////////////////////////////////////////////////////////////////
/// Translate in Plane.  Translates only in a user-defined plane.  
///  This class "HAS_SLOTS" so that the plane can be defined dynamically.
///  See gutz::Signal for more info on Signals & Slots.  The plane is 
///  defined in WORLD space.
///////////////////////////////////////////////////////////////////////////

class TransPlaneManipEvent : public TransXYManipEvent {
public:
   HAS_SLOTS;

   TransPlaneManipEvent(gutz::vec3f ppos = vec3f_zero, 
                        gutz::vec3f pnorm = vec3f_z, 
                        float speed = 1.0f)
                        : TransXYManipEvent(speed), _ppos(ppos), _pnorm(pnorm)
   {}
   TransPlaneManipEvent(const TransPlaneManipEvent &tpme)
      : TransXYManipEvent(tpme), _ppos(tpme._ppos), _pnorm(tpme._pnorm)
   {}
   virtual ~TransPlaneManipEvent() {}

   TransPlaneManipEvent &operator=(const TransPlaneManipEvent &tpme)
   {
      TransXYManipEvent::operator =(tpme);
      _ppos = tpme._ppos;
      _pnorm = tpme._pnorm;
   }

   virtual ManipEventBase<Manip> *clone() const { return new TransPlaneManipEvent(*this); }

   ///////////////////////////////
   ///@name Set/Get Plane 
   ///   The plane should be set in WORLD space 
   ///@{
   void setPlane(const gutz::planef &pln)
   {  _ppos = pln.p; _pnorm = pln.n; }
   void        setPlanePos( const gutz::vec3f &ppos)   { _ppos = ppos; }
   gutz::vec3f getPlanePos() const                     { return _ppos; }
   void        setPlaneNorm( const gutz::vec3f &pnorm) { _pnorm = pnorm; }
   gutz::vec3f getPlaneNorm()const                     { return _pnorm; }
   ///@}
   ///////////////////////////////

   ///@name Event Handlers
   ///@{
   bool startEvent(Manip *m, const MouseEvent &me);
   /// should be called when the mouse moves
   bool handleEvent(Manip *m, const MouseMoveEvent &mme);
   ///@}

protected:
   gutz::vec3f _start;
   gutz::vec3f _ppos;
   gutz::vec3f _pnorm;

};


} /// end namespace gutz


#endif

---

Send questions, comments, and bug reports to: