---

buttons.H

Go to the documentation of this file.

#ifndef GLUE_DEVBTNS_H
#define GLUE_DEVBTNS_H

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


class XYpt;
typedef const XYpt cXYpt;
class Wpt;
typedef const Wpt cWpt;
class Wtransf;
typedef const Wtransf cWtransf;

//
//   EVENTbtn - a button transition event
//
//
MAKE_PTR_SUBC(EVENTbtn, EVENT);
class DllImpExp EVENTbtn : public EVENT {

  protected:
    bool   _transition;

    /* ----------- EVENT methods --------------- */
    virtual bool compare(cEVENTptr &e) const;
    virtual void debug_data(ostream &o)const { o << " " <<
                                                 (_transition ? "down":"up"); }

  public:

    EVENTbtn(Cstr_ptr &n, bool t=true)   : EVENT(new EVENTsource(n)),
                                           _transition(t) { }
    EVENTbtn(cEVENTsource *s, bool t=true): EVENT(s),
                                           _transition(t) { }

    bool transition()  const { return _transition; }


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

//
//   EVENTbtn - a button transition event
//
//
MAKE_PTR_SUBC(EVENTbtn_2d, EVENTbtn);
class EVENTbtn_2d : public EVENTbtn {

  protected:
    cXYpt   &_cur;

  public:

    EVENTbtn_2d(Cstr_ptr &n, cXYpt &c, bool t=true): 
                                              EVENTbtn(n,t),_cur(c) { }
    EVENTbtn_2d(cEVENTsource *s, cXYpt &c, bool t=true): 
                                              EVENTbtn(s,t),_cur(c) { }

    cXYpt &cur()  const { return _cur; }


    /* ----------- TYPEDOBJ methods --------------- */
    DEFINE_DERIVED_TYPE(EVENTbtn_2d, EVENTbtn, cEVENTptr);
   static EVENTbtn_2dptr cast(cEVENTptr &e) { return EVENTbtn_2d::isa(e) ? 
                                                 (EVENTbtn_2d *)&*e : 0; }
};

//
//   EVENTbtn - a button transition event
//
//
MAKE_PTR_SUBC(EVENTbtn_3d, EVENTbtn);
class EVENTbtn_3d : public EVENTbtn {

  protected:
    cWpt    &_cur;

  public:

    EVENTbtn_3d(Cstr_ptr &n, cWpt &c, bool t=true): 
                                              EVENTbtn(n,t),_cur(c) { }
    EVENTbtn_3d(cEVENTsource *s, cWpt &c, bool t=true): 
                                              EVENTbtn(s,t),_cur(c) { }

    cXYpt  cur()  const;


    /* ----------- TYPEDOBJ methods --------------- */
    DEFINE_DERIVED_TYPE(EVENTbtn_3d, EVENTbtn, cEVENTptr);
   static EVENTbtn_3dptr cast(cEVENTptr &e) { return EVENTbtn_3d::isa(e) ? 
                                                 (EVENTbtn_3d *)&*e : 0; }
};


//
//   EVENTbtn - a button transition event
//
//
MAKE_PTR_SUBC(EVENTbtn_6d, EVENTbtn);
class EVENTbtn_6d : public EVENTbtn {

  protected:
    cWtransf    &_cur;

  public:

    EVENTbtn_6d(Cstr_ptr &n, bool t=true);
    EVENTbtn_6d(Cstr_ptr &n, cWtransf &c, bool t=true): 
                                              EVENTbtn(n,t),_cur(c) { }
    EVENTbtn_6d(cEVENTsource *s, cWtransf &c, bool t=true): 
                                              EVENTbtn(s,t),_cur(c) { }

    cWtransf  &cur()  const;


    /* ----------- TYPEDOBJ methods --------------- */
    DEFINE_DERIVED_TYPE(EVENTbtn_6d, EVENTbtn, cEVENTptr);
   static EVENTbtn_6dptr cast(cEVENTptr &e) { return EVENTbtn_6d::isa(e) ? 
                                                 (EVENTbtn_6d *)&*e : 0; }
};

//
//   EVENTbtn_vr - a button transition event
//
//
MAKE_PTR_SUBC(EVENTbtn_vr, EVENTbtn);
class DllImpExp EVENTbtn_vr : public EVENTbtn {

  protected:
    cWtransf    &_cur;
    cWtransf    &_head;

  public:

    EVENTbtn_vr(Cstr_ptr &n, bool t=true);
    EVENTbtn_vr(Cstr_ptr &n, cWtransf &h, cWtransf &c, bool t=true): 
                                              EVENTbtn(n,t),_cur(c),_head(h){ }
    EVENTbtn_vr(cEVENTsource *s, cWtransf &h, cWtransf &c, bool t=true): 
                                              EVENTbtn(s,t),_cur(c),_head(h){ }

    cWtransf &cur()  const;
    cWtransf &head() const;


    /* ----------- TYPEDOBJ methods --------------- */
    DEFINE_DERIVED_TYPE(EVENTbtn_vr, EVENTbtn, cEVENTptr);
   static EVENTbtn_vrptr cast(cEVENTptr &e) { return EVENTbtn_vr::isa(e) ? 
                                                 (EVENTbtn_vr *)&*e : 0; }
};


//
//   DEVice_btn - a buttons device
//
//
class DllImpExp DEVice_btn : public DEVice {
  public :
                DEVice_btn(Cstr_ptr &name, Cstr_ptr &evt_name="");
   virtual     ~DEVice_btn()            { }

   virtual void event(bool t)           { distrib(new EVENTbtn(this,t)); }
   virtual void event(bool t, cXYpt &c) { distrib(new EVENTbtn_2d(this,c,t));}
   virtual void event(bool t, cWpt  &c) { distrib(new EVENTbtn_3d(this,c,t));}
   virtual void event(bool t, cWtransf&c){ distrib(new EVENTbtn_6d(this,c,t));}

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



#endif

---