---

event.H

Go to the documentation of this file.

#ifndef GLUE_EVENT_H
#define GLUE_EVENT_H

#include "std/list.H"
#include "std/strings.H"
#include "std/typedobj.H"


//
// EVENTsource - an identifier of a source of EVENTs
//   Whenever an EVENT is created, an EVENTsource must be provided.
// The EVENTsource describes the static characteristics of the object
// that triggered the EVENT.  This EVENTsource description is then typically
// used by EVENT consumers to identify only those EVENTs from specific
// EVENT producers (EVENTsources).  For example, multiple producers,
// such as a mouse or tablet, may produce 2D EVENTs, and so the EVENTsource
// of each 2D EVENT allows a consumer to distinguish the mouse from the
// tablet.
//
typedef const class EVENTsource cEVENTsource;
class DllImpExp EVENTsource {
 protected:
     str_list              _tags;
     ARRAY<void *>         _vals;
     ARRAY<cEVENTsource *> _sources;
     str_ptr               _evt_name;

     bool     find_tag(Cstr_ptr &tag, void *&v) const;

 public :
           EVENTsource(Cstr_ptr &tag, void *v=0){ _evt_name=tag; add_tag(tag,v); }
  virtual ~EVENTsource() {}

  void         add_source(cEVENTsource *s)      {_sources += s; }
  EVENTsource* add_tag(Cstr_ptr &t, void *v=0)  {if (_tags.contains(t))
                                                   _vals[_tags.get_index(t)]=v;
                                                 else {
                                                    _tags+=t;_vals+=v;}
                                                 return this;}
  int          operator == (cEVENTsource &)      const { assert(0); return 0; }
  int          test(cEVENTsource &e)             const;
  void         print_data()                      const;
  void         print()                           const;
  Cstr_ptr    &evt_name()                        const { return _evt_name; }
virtual void   debug(ostream &os)                const { os << "evt = " << _evt_name; }
};


//
// EVENT - base class for an event, typically generated by a device
//
//   EVENT is a base class for system EVENTs, typically generated by a
// device.  Each device may associate specific device data with an EVENT
// by generating sub-classes of EVENTs that provide data accessors.  In 
// addition, sub-classes will have to fill-in the protected compare() 
// virtual method so that the device-specific information can be compared 
// when EVENT's are compared with the public test() method.
//   EVENTs created by devices contain EVENTsource descriptions of the 
// device.  However, consumers of EVENTs need to provide an EVENTsource
// description only if they need to distinguish between EVENTs of the
// same type that come from different EVENTsources.
//
MAKE_PTR_BASEC(EVENT);
class DllImpExp EVENT: public REFcounter, public TYPEDOBJ {
  protected:
static bool       _debug;
    cEVENTsource *_source;
    virtual bool   compare(cEVENTptr &) const = 0;
    virtual void  debug_data(ostream &/*o*/)   const { }

  public:

static void       set_debug(bool f)         { _debug = f; }
    bool          debug_on() const;
  
                  EVENT(cEVENTsource *s=0):_source(s)     { }

    cEVENTsource *source()            const { return _source; }

    virtual void  debug(ostream &o)   const { o << class_name() << "(";
                                              if (_source) _source->debug(o);
                                              else o << str_ptr("<none>");
                                              debug_data(o);
                                              o <<")"; }
    virtual bool  test(cEVENTptr &)   const;
    virtual double time()             const { return 0; }

    /* ------- TYPEDOBJ methods ----------- */ 
    DEFINE_BASE_TYPE(EVENT, cEVENTptr);
   static EVENTptr cast(cEVENTptr &e)       { return e; } // for fsa templates
};


//
// EVENTset - is a set of EVENTs
//   An EVENTset is used to describe a logically OR'ed set of EVENTs.
// The primary use of an EVENTset is to test whether a generated 
// EVENT matches any of a set of similar EVENTs, such as different
// buttons on the same device, or equivalent buttons on different
// devices.
//
MAKE_PTR_SUBC(EVENTset, EVENT);
class EVENTset: public EVENT
{
   protected:
    LIST<EVENTptr> _events;

       /* ------- EVENT methods ----------- */ 
    virtual bool compare(cEVENTptr &) const { return true; }

   public:
                 EVENTset()               { }
            void add (cEVENTptr &e)       { _events += e; }
            void rem (cEVENTptr &e)       { _events -= e; }

       /* ------- EVENT methods ----------- */ 
    virtual void debug(ostream &o)  const { if (!_events.num()) return;
                                            _events[0]->debug(o);
                                            for (int i=1;i<_events.num();i++){
                                               o<<"|";_events[i]->debug(o); }}

       /* ------- EVENT methods ----------- */ 
    virtual bool test(cEVENTptr &e) const { for (int i=0; i<_events.num();i++)
                                              if (_events[i]->test(e))
                                                 return true;
                                            return false; }
};


//
// EVENTmsg - is a generic message EVENT
//   EVENTmsg's are used to send message strings through the EVENT
// distribution mechanism.
//
MAKE_PTR_SUBC(EVENTmsg, EVENT);
class EVENTmsg : public EVENT {
  protected:
   Cstr_ptr _msg;

       /* ------- EVENT methods ----------- */ 
   virtual bool compare(cEVENTptr &e) const { EVENTmsg *m = (EVENTmsg *) &*e;
                                              return m->_msg == _msg; }
  public:
                EVENTmsg(Cstr_ptr &m, cEVENTsource *s=0):EVENT(s),_msg(m) { }

   virtual void debug(ostream &o)     const { o << class_name() 
                                                << "(" << _msg << ")"; }
         Cstr_ptr &msg()              const { return _msg; }

       /* ------- TYPEDOBJ methods ----------- */ 
   DEFINE_DERIVED_TYPE(EVENTmsg, EVENT, cEVENTptr);
   static EVENTmsgptr cast(cEVENTptr &e) { return EVENTmsg::isa(e) ? 
                                                 (EVENTmsg *)&*e : 0; }
};



//
//
//  EVENThandler - callback class for observing device events
//     
//  All events are distributed to registered EVENThandlers
//  by calling the handler's abstract handle_event() interface.  Any
//  given class that wants to observe device events must inherit
//  and implement the EVENThandler interface.
//
class EVENThandler {
  public:
   virtual     ~EVENThandler() { }

   virtual void handle_event( cEVENTptr & ) = 0;
};


class EVENTfilter {
   public:
      virtual EVENTptr filter(cEVENTptr &) = 0;
};


//
//
//  EVENTmgr - a unique instance for distributing EVENTs
//     
//     All system events should be distributed through the EVENTmgr.
//  Thus, anyone who wants to listen to a specific device event 
//  registers their EVENThandler with the EVENTmgr and then uses a
//  template EVENT's 'test()' method to filter out unwanted EVENTs.
//
class DllImpExp EVENTmgr {

  static ARRAY<EVENThandler *> *_hdlrs;
  static ARRAY<EVENThandler *> &hdlrs();
  static ARRAY<EVENTfilter  *> *_filters;
  static ARRAY<EVENTfilter  *> &filters();
  
public :
  
  static void add_filter (EVENTfilter  *f) { filters() += f; }
  static void rem_filter (EVENTfilter  *f) { filters() -= f; }
  static void add_handler(EVENThandler *h) { hdlrs() += h; }
  static void rem_handler(EVENThandler *h) { hdlrs() -= h; }

  static void distrib(cEVENTptr &e) { 
    if (e->debug_on()) {
      e->debug(cerr);
      cerr << endl;
    }
    EVENTptr evt = e;
    for (int f=0;f<filters().num();f++) {
      EVENTptr nevt = filters()[f]->filter(evt);
      if (nevt != evt) {
    evt = nevt;
    if (evt->debug_on()) {
      cerr << "EVENT remapped:";
      evt->debug(cerr);
      cerr << endl;
    }
      }
    }
    for (int i=0;i<hdlrs().num();i++)
      hdlrs()[i]->handle_event(evt);
  }
  
};


#endif

---