ucall.hpp

/************************************************************************
 *
 *  ucall.hpp: Callback objects
 *  Ubit GUI Toolkit - Version 6
 *  (C) 2009 | Eric Lecolinet | TELECOM ParisTech | 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.
 * ***********************************************************************/

#ifndef _ucall_hpp_
#define _ucall_hpp_ 1
#include <ubit/unode.hpp>
#include <ubit/uevent.hpp>
#include <typeinfo>
namespace ubit {
  
  class UCall: public UNode {
  public:
    //UCLASS("#call", UCall, null)
    UABSTRACT_CLASS(UCall)
    
    virtual ~UCall() {destructs();}

    virtual void operator()(UEvent&) = 0;
    
  protected:
    virtual UCall* toCall() {return this;}
    virtual const UCall* toCall() const {return this;}
    virtual void addingTo(UChild&, UElem& parent);
    
    template <class E> 
    E* checkType(UEvent& e) {
      E* actual_e = dynamic_cast<E*>(&e);
      if (actual_e) return actual_e;
      else {
        wrongEventType(typeid(E).name(), typeid(e).name());
        return null;
        //return (E*)&e; !!!
      }
    }
    
    virtual void wrongEventType(const char* event_name, const char* call_name);
  };
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  
  UCall& ucloseWin(int stat = 0);
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // uopen()
  
  template <class CC>
  class UCall_open : public UCall {
    CC obj;
  public:
    UCall_open(CC _o) : obj(_o) {}
    void operator()(UEvent& e) {
      UMouseEvent*_e = checkType<UMouseEvent>(e); if (_e) obj.open(*_e);
    }
  };
  
  
  template <class CC> 
  UCall& uopen(CC& obj) {return *new UCall_open<CC&>(obj);}
  
  template <class CC> 
  UCall& uopen(CC* obj) {return *new UCall_open<CC&>(*obj);}
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // ushow()
  
  template <class CC, class VAL>
  class UCall_show : public UCall {
    CC obj; VAL val;
  public:
    UCall_show(CC _o, VAL _v) : obj(_o), val(_v) {}
    void operator()(UEvent&) {obj.show(val);}
  };
  
  
  template <class CC> 
  UCall& ushow(CC& obj) {return *new UCall_show<CC&,bool>(obj,true);}
  
  template <class CC> 
  UCall& ushow(CC* obj) {return *new UCall_show<CC&,bool>(*obj,true);}

  
  // NB: not available with g++2.*.* doit etre en premier avec CC car valeur par defaut 
  template <class CC, class VAL> 
  UCall& ushow(CC& obj, VAL state) {return *new UCall_show<CC&,VAL>(obj,state);}
    
  template <class CC, class VAL> 
  UCall& ushow(CC* obj, VAL state) {return *new UCall_show<CC&,VAL>(*obj,state);}
   
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // uset(x, y)
  
  template <class CC, class VAL>
  class UCall_set : public UCall {
    CC obj; VAL val;
  public:
    UCall_set(CC _o, VAL _v) : obj(_o), val(_v) {}
    void operator()(UEvent&) {obj.set(val);}
  };
  
  template <class CC, class VAL> 
  UCall& uset(CC& _o, VAL& _v) {return *new UCall_set<CC&,VAL&>(_o,_v);}
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // uassign(x, y)
  
  template <class CC, class VAL>
  class UCall_assign : public UCall {
    CC obj; VAL val;
  public:
    UCall_assign(CC _o, VAL _v) : obj(_o), val(_v) {}
    void operator()(UEvent&) {obj = val;}
  };
  
  template <class CC, class VAL> 
  UCall& uassign(CC& _o, VAL& _v) {return *new UCall_assign<CC&,VAL&>(_o,_v);}
  
  template <class CC, class VAL> 
  UCall& ucopy(CC& _o, VAL _v) {return *new UCall_assign<CC&,VAL>(_o,_v);}
  
  
  // ============================================================== [Elc] ======== 
  // Callback objects for firing objects' methods. 
  
  // ucall(obj, &Obj::method)
  
  template <class O, class R, class M> 
  class UCall_M0 : public UCall {
    O obj;
    R (M::*fun)();
  public:
    UCall_M0(O o, R(M::*m)()) : obj(o), fun(m) {}
    void operator()(UEvent&) {(obj.*fun)();}
  };
  
  template <class O, class R,  class M, class E> 
  class UCall_M0E : public UCall {
    O obj;
    R (M::*fun)(E&);
  public:
    UCall_M0E(O o, R(M::*m)(E&)) : obj(o), fun(m) {}
    void operator()(UEvent& e) {E*_e = checkType<E>(e); if(_e) (obj.*fun)(*_e);}
  };
  
  
  template <class O, class R, class M> 
  UCall& ucall(O& o, R(M::*m)()) {return *new UCall_M0<O&, R,M>(o,m);}
  
  template <class O, class R, class M, class E> 
  UCall& ucall(O& o, R(M::*m)(E&)) {return *new UCall_M0E<O&, R,M,E>(o,m);}
  
  template <class O, class R, class M> 
  UCall& ucall(O* o, R(M::*m)()) {return *new UCall_M0<O&, R,M>(*o,m);}
   
  template <class O, class R, class M, class E> 
  UCall& ucall(O* o, R(M::*m)(E&)) {return *new UCall_M0E<O&, R,M,E>(*o,m);}

  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // ucall(obj, arg1, &Obj::method)
  
  template <class O, class A, class R, class M> 
  class UCall_M1 : public UCall {
    O obj;
    R (M::*fun)(A);
    A arg;
  public:
    UCall_M1(O o, R(M::*m)(A), A a) : obj(o), fun(m), arg(a) {}
    void operator()(UEvent&) {(obj.*fun)(arg);}
  };
  
  template <class O, class A, class R, class M, class E> 
  class UCall_M1E : public UCall {
    O obj;
    R (M::*fun)(E&, A);
    A arg1;
  public:
    UCall_M1E(O o, R(M::*m)(E&,A), A a) : obj(o), fun(m), arg1(a) {}
    void operator()(UEvent& e) {E*_e = checkType<E>(e); if(_e) (obj.*fun)(*_e,arg1);}
  };
  
  
  template <class O, class A, class R, class M>
  UCall& ucall(O& o, A a, R(M::*m)(A)) {return *new UCall_M1<O&, A,R,M>(o,m,a);}
  
  template <class O, class A, class R, class M>
  UCall& ucall(O& o, A& a, R(M::*m)(A&)) {return *new UCall_M1<O&, A&,R,M>(o,m,a);}
  
  template <class O, class A, class R, class M, class E> 
  UCall& ucall(O& o, A a, R(M::*m)(E&,A)) {return *new UCall_M1E<O&, A,R,M,E>(o,m,a);}
  
  template <class O, class A, class R, class M, class E> 
  UCall& ucall(O& o, A& a, R(M::*m)(E&,A&)) {return *new UCall_M1E<O&, A&,R,M,E>(o,m,a);}
  
  
  template <class O, class A, class R, class M>
  UCall& ucall(O* o, A a, R(M::*m)(A)) {return *new UCall_M1<O&, A,R,M>(*o,m,a);}
  
  template <class O, class A, class R, class M>
  UCall& ucall(O* o, A& a, R(M::*m)(A&)) {return *new UCall_M1<O&, A&,R,M>(*o,m,a);}
  
  template <class O, class A, class R, class M, class E> 
  UCall& ucall(O* o, A a, R(M::*m)(E&,A)) {return *new UCall_M1E<O&, A,R,M,E>(*o,m,a);}
  
  template <class O, class A, class R, class M, class E> 
  UCall& ucall(O* o, A& a, R(M::*m)(E&,A&)) {return *new UCall_M1E<O&, A&,R,M,E>(*o,m,a);}
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // ucall(obj, arg1, args2, &Obj::method)
  
  template <class O, class A1, class A2, class R, class M> 
  class UCall_M2 : public UCall {
    O obj;
    R (M::*fun)(A1,A2);
    A1 arg1; 
    A2 arg2;
  public:
    UCall_M2(O o, R(M::*m)(A1,A2), A1 a1, A2 a2) : obj(o), fun(m), arg1(a1), arg2(a2) {} 
    void operator()(UEvent&) {(obj.*fun)(arg1, arg2);}
  };
  
  template <class O, class A1, class A2, class R, class M, class E> 
  class UCall_M2E : public UCall {
    O obj;
    R (M::*fun)(E&,A1,A2);
    A1 arg1; 
    A2 arg2;
  public:
    UCall_M2E(O o, R(M::*m)(E&,A1,A2), A1 a1, A2 a2): obj(o),fun(m),arg1(a1),arg2(a2) {} 
    void operator()(UEvent& e) {E*_e = checkType<E>(e); if(_e) (obj.*fun)(*_e,arg1,arg2);}
  };
  
  template <class O, class A1, class A2, class R, class M> 
  UCall& ucall(O& o, A1 a1, A2 a2, R(M::*m)(A1,A2)) 
  {return *new UCall_M2<O&,A1,A2,R,M>(o, m, a1, a2);}
  
  template <class O, class A1, class A2, class R, class M, class E> 
  UCall& ucall(O& o, A1 a1, A2 a2, R(M::*m)(E&,A1,A2)) 
  {return *new UCall_M2E<O&,A1,A2,R,M,E>(o, m, a1, a2);}
  
  template <class O, class A1, class A2, class R, class M> 
  UCall& ucall(O* o, A1 a1, A2 a2, R(M::*m)(A1,A2)) 
  {return *new UCall_M2<O&,A1,A2,R,M>(*o, m, a1, a2);}
  
  template <class O, class A1, class A2, class R, class M, class E> 
  UCall& ucall(O* o, A1 a1, A2 a2, R(M::*m)(E&,A1,A2)) 
  {return *new UCall_M2E<O&,A1,A2,R,M,E>(*o, m, a1, a2);}
  
  
  // ============================================================ [Elc] ======== 
  // Callback objects for firing functions. 
  
  // ucall(func)
  
  template <class R> 
  class UCall_F0 : public UCall {
    R (*fun)();
  public:
    UCall_F0( R(*f)()) : fun(f) {}
    void operator()(UEvent&) {(*fun)();}
  };
  
  template <class R, class E> 
  class UCall_F0E : public UCall {
    R (*fun)(E&);
  public:
    UCall_F0E( R(*f)(E&)) : fun(f) {}
    void operator()(UEvent& e) {E*_e = checkType<E>(e); if(_e) (*fun)(*_e);}
  };
  
  
  template <class R> 
  UCall& ucall(R(*f)()) {return *new UCall_F0<R>(f);}
    
  template <class R, class E> 
  UCall& ucall(R(*f)(E&)) {return *new UCall_F0E<R,E>(f);}
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // ucall(arg, function)
  
  template <class A, class R> 
  class UCall_F1 : public UCall {
    R (*fun)(A);
    A arg;
  public:
    UCall_F1( R(*f)(A), A a) : fun(f), arg(a) {}
    void operator()(UEvent&) {(*fun)(arg);}
  };
  
  template <class A, class R, class E> 
  class UCall_F1E : public UCall {
    R (*fun)(E&, A);
    A arg1;
  public:
    UCall_F1E( R(*f)(E&,A), A a) : fun(f), arg1(a) {}
    void operator()(UEvent& e) {E*_e = checkType<E>(e); if(_e) (*fun)(*_e,arg1);}
  };
  
  
  template <class A, class R> 
  UCall& ucall(A a, R(*f)(A)) {return *new UCall_F1<A,R>(f,a);}
  
  template <class A, class R> 
  UCall& ucall(A& a, R(*f)(A&)) {return *new UCall_F1<A&,R>(f,a);}
  
  template <class A, class R, class E> 
  UCall& ucall(A a, R(*f)(E&,A)) {return *new UCall_F1E<A,R,E>(f,a);}
  
  template <class A, class R, class E> 
  UCall& ucall(A& a, R(*f)(E&,A&)) {return *new UCall_F1E<A&,R,E>(f,a);}
  
  
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  // ucall(arg1, arg2, function)
  
  template <class A1, class A2, class R> 
  class UCall_F2 : public UCall {
    R (*fun)(A1,A2);
    A1 arg1; A2 arg2;
  public:
    UCall_F2( R(*f)(A1,A2), A1 a1, A2 a2) : fun(f), arg1(a1), arg2(a2) {}
    void operator()(UEvent&) {(*fun)(arg1,arg2);}
  };
  
  template <class A1, class A2, class R, class E> 
  class UCall_F2E : public UCall {
    R (*fun)(E&,A1,A2);
    A1 arg1; 
    A2 arg2;
  public:
    UCall_F2E( R(*f)(E&,A1,A2), A1 a1, A2 a2) : fun(f), arg1(a1), arg2(a2) {}
    void operator()(UEvent& e) {E*_e = checkType<E>(e); if(_e) (*fun)(*_e,arg1,arg2);}
  };
  
  template <class A1, class A2, class R> 
  UCall& ucall(A1 a1, A2 a2, R(*f)(A1,A2)) {return *new UCall_F2<A1,A2,R>(f,a1,a2);}
  
  template <class A1, class A2, class R, class E> 
  UCall& ucall(A1 a1, A2 a2, R(*f)(E&,A1,A2)) {return *new UCall_F2E<A1,A2,R,E>(f,a1,a2);}
  
}
#endif