ucall.hpp

/* ==================================================== ======== ======= *
 *
 *  ucall.hpp: callback objects
 *  Ubit Project
 *  Part of the Ubit Toolkit: A Brick Construction Game Model for Creating GUIs
 *  (C) 1999-2006 / 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 _ucall_hpp_
#define _ucall_hpp_
//pragma ident  "@(#)ucall.hpp  ubit:05.05.00"
#include <ubit/ubrick.hpp>
namespace ubit {

class UCall: public UBrick {
public:
  UBIT_ABSTRACT_CLASS(UCall,UBrick)
  
  virtual void operator()(UEvent&) = 0;

  virtual ~UCall() {destructs();}

  virtual UCall* callCast() {return this;}

  virtual void addingTo(UChild* self, UGroup* parent);
};

/* ==================================================== ====== ======= */
// 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);}

/* ==================================================== ====== ======= */
// ushow(box, bool)

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, class VAL> 
UCall& ushow(CC& _o, VAL _v = true) {return *new UCall_show<CC&,VAL>(_o,_v);}

template <class CC, class VAL> 
UCall& ushow(CC* _o, VAL _v) {return *new UCall_show<CC&,VAL>(*_o,_v);}

/* ==================================================== ===== ======= */
// compatibility 

  UCall& ucloseWin(int stat = 0);

  UCall& ucompactEvents(UCall&);

// ==================================================== ====== =======
// ucall(obj, &ObjClass::foo) : calls obj->foo() or obj->foo(event)

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 = (E&)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);}

// ==================================================== ====== =======
// ucall(obj, a, &ObjClass::foo) : calls obj->foo(a) or obj->foo(event,a)

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 arg;
public:
  UCall_M1E(O o, R(M::*m)(E&,A), A a) : obj(o), fun(m), arg(a) {}
  void operator()(UEvent& e) {E& _e = (E&)e; (obj->*fun)(_e, arg);}
};

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);}

// ==================================================== ====== ======= 
// ucall(obj, a, b, &ObjClass::foo) : calls obj->foo(a,b) or obj->foo(event,a,b)

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 = (E&)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);
}

/* ==================================================== [Elc:] ======= */
/* ==================================================== ====== ======= */
// Callback Function with ONE argument

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 arg;
public:
  UCall_F1E( R(*f)(E&,A), A a) : fun(f), arg(a) {}
  void operator()(UEvent& e) {E& _e = (E&)e; (*fun)(_e, arg);}
};

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 Truc_F1 {
  const UCond& cond;
  R (*fun)(A);
public:
  Truc_F1(const UCond& c, R(*f)(A)) : cond(c), fun(f) {}
  UChild operator()(A a) {return UChild(new UCall_F1<A,R>(fun,a), cond);}
};

template <class A, class R, class E> 
class Truc_F1E {
  const UCond& cond;
  R (*fun)(E&,A);
public:
  Truc_F1E(const UCond& c, R(*f)(E&,A)) : cond(c), fun(f) {}
  UChild operator()(A a) {return UChild(new UCall_F1E<A,R,E>(fun,a), cond);}
};

/* ==================================================== [Elc:] ======= */
/* ==================================================== ====== ======= */
// Callback Function with TWO arguments

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 = (E&)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);}

template <class A1, class A2, class R> 
class Truc_F2 {
  const UCond& cond;
  R (*fun)(A1,A2);
public:
  Truc_F2(const UCond& c, R(*f)(A1,A2)) : cond(c), fun(f) {}
  UChild operator()(A1 a1, A2 a2) 
  {return UChild(new UCall_F2<A1,A2,R>(fun,a1,a2), cond);}
};

template <class A1, class A2, class R, class E> 
class Truc_F2E {
  const UCond& cond;
  R (*fun)(E&,A1,A2);
public:
  Truc_F2E(const UCond& c, R(*f)(E&,A1,A2)) : cond(c), fun(f) {}
  UChild operator()(A1 a1, A2 a2) 
  {return UChild(new UCall_F2E<A1,A2,R,E>(fun,a1,a2), cond);}
};

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

---