gest_int.C

Go to the documentation of this file.

#include "geom/world.H"
#include "gtex/buffer_ref_image.H"
#include "std/config.H"

#include "gest_int.H"

using mlib::PIXEL;

static bool debug = Config::get_var_bool("DEBUG_GEST_INT",false);

GEST_INT::GEST_INT(
   CVIEWptr& view,
   CEvent &d, CEvent &m, CEvent &u,
   CEvent &d2, CEvent &u2) :
   Simple_int(d,m,u),
   _view(view),
   _obs(0),
   _stack(16),
   _drawer(new GestureDrawer()),
   _fsa(&_entry),
   _keep_history(false),
   _num_history(0)
{
   // turn on indexing:
   _stack.begin_index();

   // for safety, no observers can get listed twice:
   _obs.set_unique();

   // If button 2 is pressed, jump to a useless state until button 2
   // is released. That way if button 1 gets pressed *while* button 2
   // is already pressed, no gesture is processed. This is useful,
   // because with the Wacom stylus, it's natural to press button 2
   // and also put the stylus to the tablet (which presses button 1).

   // This is a subclass of Simple_int, so the callback paramater to
   // Cb must be a CallMeth_t<Simple_int,Event>::_method), so we do a
   // cast:
   _entry +=
      Arc(d2, Cb((_callb::_method) &GEST_INT::null_cb, &_b2_pressed));
   _b2_pressed +=
      Arc(u2, Cb((_callb::_method) &GEST_INT::null_cb, (State *)-1));

   // Sign up for CAMobs callbacks:
   _view->cam()->data()->add_cb(this);
}

void 
GEST_INT::rem_obs(GestObs* g) 
{
   _obs -= g;
   if (_obs.empty())
      deactivate();
}

void 
GEST_INT::add_obs(GestObs* g)
{
   _obs += g;
   activate();
}

void
GEST_INT::activate()
{
   // get tick callbacks:
   _view->schedule(this);

   // get down/motion/up events:
   VIEWint_list::get(_view)->add_interactor(&_fsa);
}

void
GEST_INT::deactivate()
{
   // tick callbacks:
   _view->unschedule(this);

   // down/motion/up events:
   VIEWint_list::get(_view)->rem_interactor(&_fsa);
}

int
GEST_INT::down(CEvent &e, State *&s)
{
   // see if any of them observers want it:
   for (int k=0; k<_obs.num(); k++) {
      if (_obs[k]->handle_event(e,s))
         return 0;
   }
   
   // as usual, none did. but just check whether there are any
   // interactive widgets begging for it:
   DEVice_buttons *btns=(DEVice_buttons *)e._d;
   DEVice_2d      *ptr=btns->ptr2d();
   RAYhit r(ptr->cur());

   // here they go:
   if (e.view()->intersect(r).success() &&
       ray_geom(r,GEOM::null) &&
       ray_geom(r,GEOM::null)->interactive(e,s))
      return 0;

   // as usual, it's up to us to handle this gesture ourselves!

   // start a new one and make sure it's drawn
   _stack += new GESTURE(
      this, _stack.num(), ptr->cur(), ptr->pressure(), _drawer, e
      );

   BufferRefImage *buf = BufferRefImage::lookup(_view);
   if (buf && (buf->is_observing()))
      buf->add(_stack.last());
   else
      WORLD::display(_stack.last(), false);


   return 0;
}

int
GEST_INT::move(CEvent &, State *&)
{
   // mac version can get an up without a down, so this can be 0
   if (!DEVice_2d::last)
      return 0;

   DEVice_2d* ptr = DEVice_2d::last;

   double MIN_DIST = Config::get_var_dbl("GEST_ADD_MIN_DIST", 2.5, true);
   
   // XXX - If the camera is moving, then the GESTURE might
   // have started in a previous frame, and now be gone from
   // da stack.  Just punt this event if so...

   if ( !_stack.empty() ) {
      _stack.last()->add(
         PIXEL(ptr->cur()),        // location
         MIN_DIST,                 // threshold distance for accepting
         ptr->pressure()           // pressure
         );
   } else {
      err_adv(debug, "GEST_INT::move: tossing event for missing gesture.");
   }
   return 0;
}

int
GEST_INT::up(CEvent &e, State *&)
{
   // mac version can get an up without a down, so this can be 0
   if (!DEVice_2d::last)
      return 0;

   if (_stack.empty()) {
      // XXX - If the camera is moving, then the GESTURE might
      // have started in a previous frame, and now be gone from
      // da stack.  Just punt this event if so...
      err_adv(debug, "GEST_INT::move: tossing event for missing gesture.");
   } else {
      _stack.last()->complete(DEVice_2d::last->cur(), e);

      // Remove from BufferRefImage list if it's observing, else remove
      // from the WORLD's list...
        
      BufferRefImage *buf = BufferRefImage::lookup(_view);
      if (buf && buf->is_observing())
         buf->rem(_stack.last());
      else
         WORLD::undisplay(_stack.last(), false);

      for (int k=0; k<_obs.num(); k++)
         _obs[k]->notify_gesture(this, _stack.last());
   }

   return 0;
}

void
GEST_INT::start_history()
{
   // XXX - ???
   err_mesg(ERR_LEV_SPAM, "GEST_INT::start_history()");

   if(!_keep_history)
      return;

   assert(_num_history < _stack.num());

   // undisplay gestures in current history, if any
   for(int i=0; i<_num_history; i++)
   {
      err_mesg(ERR_LEV_SPAM, "GEST_INT::start_history() - Clearing history: %d", i);
   }

   _num_history = 0;
}

void
GEST_INT::notify(CCAMdataptr&)
{
   // CAMobs virtual method: notification that camera changed.

   // Undisplay any dangling GESTURE

   if (!(_stack.empty() || _stack.last()->complete())) 
   {
      err_adv(debug, "GEST_INT::move: undisplaying 'dangling' gesture.");
      BufferRefImage *buf = BufferRefImage::lookup(_view);
      if (buf && buf->is_observing())
         buf->rem(_stack.last());
      else
         WORLD::undisplay(_stack.last(), false);
   }

   // Forget previous gestures since they go with the old camera:
    _stack.clear();
}

int
GEST_INT::tick()
{
   // look for timeouts etc. here

   return 1;
}

/* end of file gest_int.C */

---