---

discrete_contact.H

Go to the documentation of this file.

#ifndef _discrete_contact_H_
#define _discrete_contact_H_

#include "event/event.H"
#include "dev/dev.H"

/* This device has some finite number of contact points and reports multiple
   disjoint sets of these buttons; each set represents one set of contacts
   among the contact points. For instance, you might have a pinch glove and
   each set reported is a pinch involving some number of fingers (possibly
   more than two). A device doesn't have to support more than one concurrent
   touching set, but it can.

   An event is the entire state change from the previous state (list of sets
   of contacts) to the new state. We don't try to break this up into separate
   events for the contacting and uncontacting parameters because we might get
   a split (1&2&3&4 -> 1&2, 3&4) and don't want to get two events that might
   trigger two update functions later (especially if they just look at the
   state on the device anyway). If you want up/down events, you probably want
   to reinterpret this device as a DEVice_btns; use the DEVice_discrete_btns
   class (as a handler on the DEVice_discrete_contact class) which handles the
   mapping for you. However, we do support testing against an interest mask
   and resulting value here; if any set when anded with the mask matches the
   result then it returns true, else false. (This is used by
   DEVice_discrete_btns.)  */

/* These should really be templated instead of using unsigned long, but it's
   not necessary yet and I don't want to have to go through all that work. */

MAKE_PTR_SUBC(EVENTdiscrete_contact, EVENT);
class EVENTdiscrete_contact : public EVENT {
 public:
   typedef unsigned long bits;

 protected:
   ARRAY<bits> _oldstate;
   ARRAY<bits> _newstate;

   bool testmask(const ARRAY<bits> &s, const bits &m, const bits &r) const {
      int i; for(i = 0; i < s.num(); i++) if((s[i]&m) == r) return true;
      return false; }

   /* ----------- EVENT methods --------------- */

   virtual bool compare(cEVENTptr &e) const 
               { cerr << "EVENTdiscrete_contact::compare - Need to implement\n";
                 return false; }

   virtual void debug_data(ostream &o)const { o << " contacts=";
                          for (int i=8*sizeof(bits)-1;i>=0&&_newstate.num();i--)
                             o << ((_newstate[0] & (1 << i)) ? "1":"0"); }

 public:
                      EVENTdiscrete_contact(EVENTsource *s,
                                            const ARRAY<bits> &o,
                                            const ARRAY<bits> &n) : EVENT(s),
                                            _oldstate(o), _newstate(n)
                                       { }

   const ARRAY<bits> &oldstate() const { return _oldstate; }
   const ARRAY<bits> &newstate() const { return _newstate; }

   bool               testmaskold(const bits &mask, const bits &result) const {
                                     return testmask(_oldstate, mask, result); }
   bool               testmasknew(const bits &mask, const bits &result) const {
                                     return testmask(_newstate, mask, result); }

   /* ----------- TYPEDOBJ methods --------------- */
   DEFINE_DERIVED_TYPE(EVENTdiscrete_contact, EVENT, cEVENTptr);
}; 


class DEVdiscrete_btns;

//
//  DEVdiscrete_contact - device generating contact events
//
//
//
//
//
class DllImpExp DEVdiscrete_contact : public DEVice {
 public:
   typedef EVENTdiscrete_contact::bits bits;

 protected:
   ARRAY<bits>       _state;
   DEVdiscrete_btns *_btnmap;

 public:
                 DEVdiscrete_contact(Cstr_ptr &n);
   virtual      ~DEVdiscrete_contact() { }

   virtual void  event(const ARRAY<bits> &newstate) {
                    distrib(new EVENTdiscrete_contact(this, _state, newstate));
                    _state = newstate;
                 } 

    /* ----------- TYPEDOBJ methods --------------- */
    DEFINE_DERIVED_TYPE(DEVdiscrete_contact, DEVice, const DEVice *);
};


#endif

---