geom_obs.H

Go to the documentation of this file.

#ifndef GEOM_OBS_H_HAS_BEEN_INCLUDED
#define GEOM_OBS_H_HAS_BEEN_INCLUDED

#include "geom/geom.H"

#define CXFORMobs_list const XFORMobs_list
#define CXFORMobs      const XFORMobs
class XFORMobs;
typedef ARRAYptrs<XFORMobs*> XFORMobs_list;
//--------------------------------------------
// XFORMobs -
//   An object that can be notified when some
// other object is transformed
//--------------------------------------------
class XFORMobs {
      static HASH          _hash_xf;
      static XFORMobs_list _all_xf;
      static XFORMobs_list _every_xf;
   public:
      enum STATE { START = 0, // Start of manipulation
                   MIDDLE,    // Middle of manipulation
                   END,       // End of manipulation
                   PRIMARY,   // top-level calls to set_xform/mult_by
                   GRAB,      // Start of spreadsheet drag & drop
                   DRAG,      // Spreadsheet drag 
                   DROP,      // Spreadsheet drop
                   NET,       // xform from the network
                   EVERY 
                 };
      virtual ~XFORMobs() {}
      virtual          void notify_xform    (CGEOMptr &, STATE state) = 0;
      static void notify_xform_obs(CGEOMptr &, STATE start);
      static void notify_xform_every_obs(CGEOMptr &);

   /* ---  object xform observer --- */
      void   xform_obs  (CGELptr& g)  { xform_obs_list(g).add_uniquely(this); }
      void   xform_obs  ()            { _all_xf.add_uniquely(this); }
      void   every_xform_obs  ()      { _every_xf.add_uniquely(this); }
      void   unobs_xform()            { _all_xf.rem(this); }
      void   unobs_every_xform()      { _every_xf.rem(this); }
      void   unobs_xform(CGEOMptr &g) { xform_obs_list(g).rem(this); }
   protected :
      static XFORMobs_list &xform_obs_list(CGELptr &g)  {
         XFORMobs_list *list = (XFORMobs_list *) _hash_xf.find((long) &*g);
         if (!list)
            _hash_xf.add((long)&*g, (void *)(list = new XFORMobs_list));
         return *list;
      }
};


#define CCOLORobs_list const COLORobs_list
#define CCOLORobs      const COLORobs
class COLORobs;
typedef ARRAYptrs<COLORobs*> COLORobs_list;
//--------------------------------------------
// COLORobs -
//   An object that can be notified when some
// other object's color has changed
//--------------------------------------------
class COLORobs {
      static COLORobs_list *_all_col;
      static COLORobs_list *col_list() { if (!_all_col)
                    _all_col = new COLORobs_list; return _all_col; }
   public:
      virtual ~COLORobs() {}
      virtual void notify_color    (CGEOMptr &, APPEAR *app) = 0;
      static  void notify_color_obs(CGEOMptr &g, APPEAR *app = 0) {
                                   for (int i=0; i < col_list()->num(); i++)
                                      (*_all_col)[i]->notify_color(g,
                                                                   app ? app
                                                           : (APPEAR *) &*g); }

   /* ---  object color observer --- */
      void   color_obs  ()            { col_list()->add_uniquely(this); }
      void   unobs_color()            { col_list()->rem(this); }
};



#define CTRANSPobs_list const TRANSPobs_list
#define CTRANSPobs      const TRANSPobs
class TRANSPobs;
typedef ARRAYptrs<TRANSPobs*> TRANSPobs_list;
//--------------------------------------------
// TRANSPobs -
//   An object that can be notified when some
// other object's transp has changed
//--------------------------------------------
class TRANSPobs {
      static TRANSPobs_list _all_transp;
   public:
      virtual ~TRANSPobs() {}
      virtual void notify_transp    (CGEOMptr &) = 0;
      static  void notify_transp_obs(CGEOMptr &g) {
                                      for (int i=0; i < _all_transp.num(); i++)
                                          _all_transp[i]->notify_transp(g); }

   /* ---  object transp observer --- */
      void   transp_obs  ()            { _all_transp.add_uniquely(this); }
      void   unobs_transp()            { _all_transp.rem(this); }
};

#define CTEXTUREobs_list const TEXTUREobs_list
#define CTEXTUREobs      const TEXTUREobs
class TEXTUREobs;
typedef ARRAYptrs<TEXTUREobs*> TEXTUREobs_list;
//--------------------------------------------
// TEXTUREobs -
//   An object that can be notified when some
// other object's texture has changed
//--------------------------------------------
class TEXTUREobs {
      static TEXTUREobs_list *_all_texture;

      static TEXTUREobs_list *texobs_list() { if (!_all_texture)
                    _all_texture = new TEXTUREobs_list; return _all_texture; }
   public:
      virtual ~TEXTUREobs() {}
      virtual void notify_texture    (CGEOMptr &) = 0;
      static  void notify_texture_obs(CGEOMptr &g) {
                                for (int i=0; i < texobs_list()->num(); i++)
                                   (*_all_texture)[i]->notify_texture(g); }

   /* ---  object texture observer --- */
      void   texture_obs  ()            { texobs_list()->add_uniquely(this); }
      void   unobs_texture()            { texobs_list()->rem(this); }
};

#define CCSGobs_list const CSGobs_list
#define CCSGobs      const CSGobs
class CSGobs;
typedef ARRAYptrs<CSGobs*> CSGobs_list;
//--------------------------------------------
// CSGobs -
//   An object that can be notified when some
// other object's csg has changed
//--------------------------------------------
class CSGobs {
      static CSGobs_list _all_csg;
   public:
      virtual ~CSGobs() {}
      virtual void notify_csg    (CGEOMlist &l) = 0;
      static  void notify_csg_obs(CGEOMlist &l) {
                                         for (int i=0; i < _all_csg.num(); i++)
                                             _all_csg[i]->notify_csg(l); }

   /* ---  object csg observer --- */
      void   csg_obs  ()            { _all_csg.add_uniquely(this); }
      void   unobs_csg()            { _all_csg.rem(this); }
};

#define CGEOMobs_list const GEOMobs_list
#define CGEOMobs      const GEOMobs
class GEOMobs;
typedef ARRAYptrs<GEOMobs*> GEOMobs_list;
//--------------------------------------------
// GEOMobs -
//   An object that can be notified when some
// other object's geom has changed
//--------------------------------------------
class GEOMobs {
      static GEOMobs_list _all_geom;
   public:
      virtual ~GEOMobs() {}
      virtual void notify_geom    (CGEOMptr &l) = 0;
      static  void notify_geom_obs(CGEOMptr &l) {
                                         for (int i=0; i < _all_geom.num(); i++)
                                             _all_geom[i]->notify_geom(l); }

   /* ---  object geom observer --- */
      void   geom_obs  ()            { _all_geom.add_uniquely(this); }
      void   unobs_geom()            { _all_geom.rem(this); }
};

#endif // GEOM_OBS_H_HAS_BEEN_INCLUDED

// end of file geom_obs.H

---