gest_int.H

Go to the documentation of this file.

/**********************************************************************
 * gest_int.H
 **********************************************************************/
#ifndef GEST_INT_H_HAS_BEEN_INCLUDED
#define GEST_INT_H_HAS_BEEN_INCLUDED

#include "geom/fsa.H"
#include "manip/manip.H"
#include "std/stop_watch.H"

#include "gesture.H"

// forward declare gesture observer class (defined below)
class GestObs;

/*****************************************************************
 * GESTURE_list:
 *****************************************************************/
class GESTURE_list : public LIST<GESTUREptr> {
 public:
   //******** MANAGERS ********
   GESTURE_list(int n=0) : LIST<GESTUREptr>(n) { begin_index(); }
   GESTURE_list(const GESTURE_list& list) : LIST<GESTUREptr>(list) {
      begin_index();
   }

   virtual ~GESTURE_list() { end_index(); }

   //******** ARRAY INDEXING ********
   virtual void set_index(CGESTUREptr& g, int i) const {
      // XXX -
      //  Should confirm g belongs to this list?
      //  Yes but, for now, assume GESTURE_list 
      //    is only used by GEST_INT.
      //
      if (g)
         ((GESTUREptr&)g)->set_index(i);
   }
   virtual void clear_index(CGESTUREptr& g) const { set_index(g, BAD_IND); }
   virtual int  get_index  (CGESTUREptr& g) const {
      return g ? ((GESTUREptr&)g)->index() : BAD_IND;
   }
};

/*****************************************************************
 * GEST_INT
 *
 *      Interactor for drawing stroke-based gestures.
 *
 *      Handles down/move/up events to record gestures, then hands off
 *      the gestures to "observers," i.e. Pens that trigger
 *      appropriate callbacks.
 *****************************************************************/
#define CGEST_INTptr const GEST_INTptr
MAKE_PTR_SUBC(GEST_INT,FRAMEobs);
//permuted FRAMEobs and CAMobs because of segfault when compiled with g++ 3.3.2
class GEST_INT : public FRAMEobs, public CAMobs, public Simple_int {
 protected:
   VIEWptr              _view;          // view
   ARRAY<GestObs*>      _obs;           // observers of gestures
   GESTURE_list         _stack;         // recent gestures
   GestureDrawer*       _drawer;        // for drawing gestures
   FSA                  _fsa;           // the fsa for this interactor

   State                _b2_pressed;

   // XXX - doubtful:
   bool                 _keep_history;  // keep gestures on the stack 
                                        // until history is cleared
   int                  _num_history;   // number of gestures in history

   void activate();
   void deactivate();

 public:
   //******** MANAGERS ********
   GEST_INT(CVIEWptr& view,
            CEvent &d, CEvent &m, CEvent &u,
            CEvent &d2, CEvent &u2);
   virtual ~GEST_INT() 
   { 
      err_mesg(ERR_LEV_SPAM, "GEST_INT destructor");
   }

   // add/remove observers
   // (e.g. called in Pen::activate/deactivate):
   void rem_obs(GestObs* g);
   void add_obs(GestObs* g);

   // restore FSA to initial state:
   void reset()                                 { _fsa.reset(); }

   // set the thing that draws Gestures:
   void set_drawer(GestureDrawer* drawer)     { _drawer = drawer; }
   GestureDrawer* drawer()                    { return _drawer; }

   void set_keep_history(bool b)              
   { 
      err_mesg(ERR_LEV_SPAM, "GEST_INT::set keep history() - Now is %d",(b)?(1):(0));
      _keep_history = b; 
   }
   bool keep_history()                        { return _keep_history; } 
   void start_history();

   // gesture accessors
   // (get gesture number k out of the entire gesture history):
   GESTUREptr gesture(int k) const {
      return _stack.valid_index(k) ? _stack[k] : GESTUREptr(0);
   }
   GESTUREptr last() const { return gesture(_stack.num()-1); }

   virtual int null_cb(CEvent&, State*&) { return 0; }

   //******** Simple_int methods ********
   virtual int down(CEvent &,State *&);
   virtual int move(CEvent &,State *&);
   virtual int up  (CEvent &,State *&);

   //******** CAMobs Method *************
   virtual void notify(CCAMdataptr &data);

   //******** FRAMEobs methods ********
   virtual int  tick();
};

/*****************************************************************
 * GestObs:
 *
 *      Abstract base class for "gesture observers" that receive
 *      gestures from the gesture interactor.
 *****************************************************************/
class GestObs {
 public:
   //******** MANAGERS ********
   virtual ~GestObs() {}

   // get notification of the latest gesture
   virtual void notify_gesture(GEST_INT* gest_int, CGESTUREptr& gest) = 0;

   // take over the given down/move/up event from the GEST_INT:
   // can be used to invoke a menu, e.g., depending on context.
   virtual int handle_event(CEvent&, State* &) { return 0; }
};

#endif  // GEST_INT_H_HAS_BEEN_INCLUDED

/* end of file gest_int.H */

---