ucond.hpp

/* ==================================================== ======== ======= *
 *
 *  ucond.hpp
 *  Ubit Project
 *  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
 *  (C) 1999-2005 Eric Lecolinet / ENST Paris / http://www.enst.fr/~elc/ubit
 *
 * ***********************************************************************
 * COPYRIGHT NOTICE : 
 * THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY AND WITHOUT EVEN THE 
 * IMPLIED WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. 
 * YOU CAN REDISTRIBUTE IT AND/OR MODIFY IT UNDER THE TERMS OF THE GNU 
 * GENERAL PUBLIC LICENSE AS PUBLISHED BY THE FREE SOFTWARE FOUNDATION; 
 * EITHER VERSION 2 OF THE LICENSE, OR (AT YOUR OPTION) ANY LATER VERSION.
 * SEE FILES 'COPYRIGHT' AND 'COPYING' FOR MORE DETAILS.
 * ***********************************************************************
 * ==================================================== [(c)Elc] ======= *
 * ==================================================== ======== ======= */

#ifndef _ucond_hpp_
#define _ucond_hpp_
#include <ubit/umode.hpp>
#include <ubit/ucall.hpp>
//pragma ident  "@(#)ucond.hpp  ubit:05.05.00"
namespace ubit {
  
/* ==================================================== ===== ======= */
class UCond {
public:
  virtual ~UCond() {}
  
  virtual bool operator==(const UCond& c) const {return this == &c;}
  virtual bool operator!=(const UCond& c) const {return this != &c;}
  virtual const UCond* matches(const UCond& c) const {return this == &c? this: 0;}
  virtual bool verifies(const UContext&, const UControl*) const = 0;

  template <class A, class R> 
  Truc_F1<A,R> operator/(R(*f)(A)) {return Truc_F1<A,R>(*this,f);}
  
  template <class A, class R, class E> 
  Truc_F1E<A,R,E> operator/(R(*f)(E&,A)) {return Truc_F1E<A,R,E>(*this,f);}
  
  template <class A1, class A2, class R> 
  Truc_F2<A1,A2,R> operator/(R(*f)(A1,A2)) {return Truc_F2<A1,A2,R>(*this,f);}
    
  template <class A1, class A2, class R, class E> 
  Truc_F2E<A1,A2,R,E> operator/(R(*f)(E&,A1,A2)) {return Truc_F2E<A1,A2,R,E>(*this,f);}

  // - - - impl - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  
  virtual UOn* onCast() {return null;}
  virtual const UOn* onCast() const {return null;}
  virtual void setParentModes(UControl* parent) const {};
};

/* ==================================================== ===== ======= */

class UMultiCond : public UCond {
public:
  virtual void add(const UCond&);
  virtual void remove(const UCond&);

  virtual const UCond* matches(const UCond& c) const;
  virtual bool verifies(const UContext&, const UControl*) const;
  virtual void setParentModes(UControl* parent) const;

private:
  typedef std::list<const UCond*> CondList;
  CondList condlist;
};

/* ==================================================== ===== ======= */
class UInscale : public UCond {
public:
  UInscale();
  UInscale(float smin, float smax);
  friend UInscale& uinscale(float smin, float smax) {return *new UInscale(smin,smax);}
    
  void  setMin(float smin);
  void  setMax(float smax);
  float getMin() const {return smin;}
  float getMax() const {return smax;}
  
  virtual bool verifies(const UContext&, const UControl*) const;
private:
  float smin, smax;
};

/* ==================================================== ===== ======= */
class UFlag : public UCond {
public:
  static const UFlag none;
  virtual bool verifies(const UContext&, const UControl*) const;
};

/* ==================================================== ======== ======= */
 class UNotFlag : public UCond {
public:
   const UFlag& cond;
   UNotFlag(const UFlag& c) : cond(c) {}
   virtual bool verifies(const UContext&, const UControl*) const;
 };
 
inline UNotFlag& operator!(const UFlag& c) {return *new UNotFlag(c);}

}
#endif
/* ==================================================== [TheEnd] ======= */
/* ==================================================== [(c)Elc] ======= */

---