00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef _CEGUIEvent_h_
00028 #define _CEGUIEvent_h_
00029
00030 #if defined (_MSC_VER)
00031 # pragma warning(push)
00032 # pragma warning(disable : 4786)
00033 # pragma warning(disable : 4251)
00034 # if !defined (_MSC_EXTENSIONS)
00035 # pragma warning (disable : 4224)
00036 # endif
00037 #endif
00038
00039 #include "CEGUIBase.h"
00040 #include "CEGUIString.h"
00041 #include "CEGUIEventArgs.h"
00042 #include "CEGUIRefPtr.h"
00043
00044 #include <map>
00045
00046
00047
00048 namespace CEGUI
00049 {
00050
00056 template <typename Ret, typename Args>
00057 class SubscriberInterface {
00058 public:
00059 virtual Ret operator()(Args) const = 0;
00060 virtual ~SubscriberInterface() {}
00061 };
00062
00063
00068 template <typename Ret, typename Args>
00069 class _freeBinder : public SubscriberInterface<Ret,Args>
00070 {
00071 public:
00072 virtual Ret operator()(Args args) const
00073 {
00074 return d_f(args);
00075 }
00076 typedef Ret (*SlotFunction)(Args);
00077 _freeBinder(SlotFunction f) : d_f(f) {}
00078 protected:
00079 SlotFunction d_f;
00080 };
00081
00082
00087 template <class Functor, typename Ret, typename Args>
00088 class _functorBinder : public SubscriberInterface<Ret,Args>
00089 {
00090 public:
00091 virtual Ret operator()(Args args) const
00092 {
00093 return d_f(args);
00094 }
00095 _functorBinder(const Functor& f) : d_f(f) {}
00096 protected:
00097 Functor d_f;
00098 };
00099
00100
00105 template <class T, typename Ret, typename Args>
00106 class _memberBinder : public SubscriberInterface<Ret,Args>
00107 {
00108 typedef Ret (T::*F)(Args);
00109 public:
00110 virtual Ret operator()(Args args) const
00111 {
00112 return (d_t->*d_f)(args);
00113 }
00114 _memberBinder(F f, T* t) : d_f(f), d_t(t) {}
00115 protected:
00116 F d_f;
00117 T* d_t;
00118 };
00119
00120
00127 template <typename Ret, typename Args>
00128 class SubscriberTemplate
00129 {
00130 public:
00131 Ret operator()(Args args) const
00132 {
00133 return (*d_si)(args);
00134 }
00135
00136 typedef Ret (*SlotFunction)(Args);
00137
00139 SubscriberTemplate(SlotFunction f)
00140 {
00141 d_si = new _freeBinder<Ret,Args>(f);
00142 }
00143
00145 template <class T>
00146 SubscriberTemplate(Ret (T::*f)(Args), T* target)
00147 {
00148 d_si = new _memberBinder<T,Ret,Args>(f, target);
00149 }
00150
00152 template <typename Functor>
00153 SubscriberTemplate(const Functor& f)
00154 {
00155 d_si = new _functorBinder<Functor,Ret,Args>(f);
00156 }
00157
00163 SubscriberTemplate(SubscriberInterface<Ret,Args>* si) : d_si(si) {}
00164
00166 SubscriberTemplate(const SubscriberTemplate<Ret,Args>& copy) : d_si(copy.d_si) {}
00167
00169 bool operator<(const SubscriberTemplate<Ret,Args>& rhs) const { return d_si < rhs.d_si; }
00170
00172 void release() const
00173 {
00174 delete d_si;
00175 }
00176
00177 protected:
00178 SubscriberInterface<Ret,Args>* d_si;
00179 };
00180
00181
00188 template <class Functor, typename Ret, typename Args>
00189 class _refBinder : public SubscriberInterface<Ret,Args>
00190 {
00191 public:
00192 virtual Ret operator()(Args args) const
00193 {
00194 return d_f(args);
00195 }
00196 _refBinder(const Functor& f) : d_f(f) {}
00197 protected:
00198 const Functor& d_f;
00199 };
00200
00205 template <class Functor>
00206 SubscriberInterface<bool, const EventArgs&>*
00207 SubscriberRef(const Functor& f)
00208 {
00209 return new _refBinder<Functor,bool,const EventArgs&>(f);
00210 }
00211
00212
00224 class CEGUIEXPORT Event
00225 {
00226 public:
00231 class ConnectionInterface : public Referenced {
00232 public:
00233 virtual bool connected() { return false; }
00234 virtual void disconnect() {}
00235 };
00236 typedef RefPtr<ConnectionInterface> Connection;
00237
00243 class ScopedConnection {
00244 public:
00245 ScopedConnection(Connection conn_) : conn(conn_) {}
00246 ~ScopedConnection() { conn->disconnect(); }
00247 Connection conn;
00248 };
00249
00250
00251 typedef SubscriberTemplate<bool, const EventArgs&> Subscriber;
00252 typedef int Group;
00253
00254
00255
00256
00261 Event(const String& name);
00262
00267 virtual ~Event(void);
00268
00269
00277 const String& getName(void) const {return d_name;}
00278
00279
00290 Connection subscribe(Subscriber subscriber) { return subscribe(0, subscriber); }
00291
00292
00307 Connection subscribe(Group group, Subscriber subscriber);
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320 void operator()(EventArgs& args);
00321
00322 private:
00323
00324
00325
00326 Event(const Event& evt) {}
00327 Event& operator=(const Event& evt) {return *this;}
00328
00329
00330
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340 bool unsubscribe(Subscriber subscriber, Group group=0);
00341
00342 class GroupSubscriber {
00343 public:
00344 Group group;
00345 Subscriber subscriber;
00346 GroupSubscriber(Group group_, Subscriber subscriber_)
00347 : group(group_), subscriber(subscriber_) {}
00348 };
00349
00350 struct ltGroupSubscriber
00351 {
00352 bool operator()(const GroupSubscriber& gs1, const GroupSubscriber& gs2) const
00353 {
00354 return gs1.group < gs2.group ||
00355 gs1.group == gs2.group && gs1.subscriber < gs2.subscriber;
00356 }
00357 };
00358 typedef std::map<GroupSubscriber, Connection, ltGroupSubscriber> ConnectionOrdering;
00359
00360
00361
00362
00363
00364 const String d_name;
00365 ConnectionOrdering connectionOrdering;
00366 friend class ConnectionImpl;
00367 };
00368
00369
00370 }
00371
00372 #if defined(_MSC_VER)
00373 # pragma warning(pop)
00374 #endif
00375
00376 #endif // end of guard _CEGUIEvent_h_