ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/FAS/src/event.h
(Generate patch)

Comparing trunk/FAS/src/event.h (file contents):
Revision 90 by tim, Mon Aug 19 23:06:57 2002 UTC vs.
Revision 92 by tim, Tue Aug 20 23:26:55 2002 UTC

# Line 21 | Line 21
21   #define eventH
22   #include <iostream>
23   #include <vector>
24 + #include <string>
25 + #include <algorithm>
26 + #include <functional>
27 + //in this version, we register the event type and event object to event table.
28 + //Alternately, we can record the event types which event object want to response
29 + //by itself. I will consider to implement in latter way in next version
30  
31   using namespace std;
32  
33   class TEventObject;
34 < class TEventDispatcher;
34 > class TEvenPoster;
35  
36   namespace TEventType
37   {
38 <  const int All = 1;
38 >  const int Unknown = 1;
39    const int FrameChanged = 2;
40   };
41  
42 < struct TEventItem
42 > typedef void (TEventObject::*PEventHandler)(int, TEvenPoster *, void *) ;
43 >
44 > class TEventItem
45   {
46 <  TEventObject *_object;
47 <  void (TEventObject::*Handle)(int eventType, TEventDispatcher * dispatcher, void *extra);
46 >  protected:
47 >    TEventObject *_object;
48 >    vector<PEventHandler> _handlers;
49 >
50 >    void Clear();
51 >
52 >  public:
53 >    TEventItem(TEventObject *object);
54 >    ~TEventItem();
55 >
56 >    TEventObject *GetEventObject()  { return _object;}
57 >    vector<PEventHandler> &GetHandlers()  { return _handlers;}
58 >
59 >    virtual void AddHandler(PEventHandler handler);
60 >    virtual void RemoveHandler(PEventHandler handler);
61 >
62 >    virtual void ExecuteHandler(int eventType, TEvenPoster *poster, void *extra);
63 >    int Count() { return _handlers.size();}
64   };
65  
66 + //functor for match TEventItem
67 + class TMatchEventItem : public unary_function<TEventItem, bool>
68 + {
69 +  private:
70 +    TEventObject *_object;
71  
72 +  public:
73 +    TMatchEventItem(TEventObject *object)
74 +    {
75 +      _object = object;
76 +    }
77 +
78 +    bool operator()(TEventItem *eventItem)
79 +    {
80 +      return _object == eventItem->GetEventObject();
81 +    }
82 + };
83 +
84   class TEventItems
85   {
86 <  int _eventType;
87 <  vector<TEventItem> _items;
86 >  protected:
87 >    vector<TEventItem*> _items;
88 >
89 >    void Clear();
90 >
91 >  public:
92 >    int _eventType;
93 >
94 >    TEventItems(int eventType = TEventType::Unknown);
95 >    ~TEventItems();
96 >
97 >    int GetType() { return _eventType;}
98 >    void SetType(int eventType)  {_eventType =eventType;}
99 >
100 >    int Count() { return _items.size();}
101 >
102 >    void AddItem(TEventObject *object, PEventHandler handler);
103 >    void RemoveItem(TEventObject *object, PEventHandler handler);
104 >    void RemoveItem(TEventObject *object);
105 >
106 >    TEventItem *GetEventItem(TEventObject *object);
107 >
108 >    void Dispatch(int eventType, TEvenPoster *poster, void *extra);
109   };
110  
111 + //functor for match TEventItem
112 + class TMatchEventItems : public unary_function<TEventItems*, bool>
113 + {
114 +  private:
115 +    int _eventType;
116 +
117 +  public:
118 +    TMatchEventItems(int eventType)
119 +    {
120 +
121 +      _eventType = eventType;
122 +    }
123 +
124 +    bool operator()(TEventItems *eventItems) const
125 +    {
126 +      return _eventType == eventItems->GetType();
127 +    }
128 + };
129 +
130   class TEventTable
131   {
132    protected:
133      vector<TEventItems*> _table;
134  
135 +    void Clear();
136 +
137    public:
138      TEventTable();
56 –    TEventTable(const TEventTable &table);
139      ~TEventTable();
140  
141 <    void AddItem(int eventType, TEventObject *object,
142 <                 void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
143 <    void RemoveItem(int eventType, TEventObject *object,
144 <                    void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
141 >    int Count() { return _table.size();}
142 >
143 >    void AddItem(int eventType, TEventObject *object, PEventHandler handler);
144 >    void RemoveItem(int eventType, TEventObject *object, PEventHandler handler);
145      void RemoveItem(int eventType, TEventObject *object);
146 +    void RemoveItem(TEventObject *object);
147  
148 <    void Dispatch(int eventType, TEventDispatcher * dispatcher, void *extra);
148 >    TEventItems *GetEventItemsByType(int eventType);
149 >
150 >    void Dispatch(int eventType, TEvenPoster *poster, void *extra);
151   };
152  
153 + namespace TEventObjectType
154 + {
155 +  const int BaseEventObject = 1;
156 + };
157 +
158   class TEventObject
159   {
160    protected:
161 +    int _type;
162 +    string _ident;
163      TEventTable *_table;
164  
165    public:
166 <    TEventObject(TEventTable *table)  { _table = table;}
167 <    ~TEventObject()  {}
166 >    TEventObject(TEventTable *table = NULL)
167 >    {
168  
169 +      _table = table;
170 +    }
171 +    ~TEventObject();
172 +
173 +    int GetEventObjectType()  { return _type;}
174 +    string GetIdent() { return _ident;}
175      TEventTable *GetEventTable()  { return _table;}
176 +
177 +    void SetEventObjectType(int type) { _type = type;}
178 +    void SetIdent(string ident) { _ident = ident;}
179      void SetEventTable(TEventTable *table)  { _table = table;}
180  
181 <    virtual void DefaultHandle(int eventType,
182 <                               TEventDispatcher * dispatcher, void *extra)  {}
183 <
181 >    void DefaultHandle(int eventType,TEvenPoster *poster, void *extra)  {}
182 > //GCC did not support default argument here
183 > #ifdef __GNUC__
184      void Register(int eventType, TEventObject *object,
185 <        void (TEventObject::*Handle)(int, TEventDispatcher*, void *) = DefaultHandle);
186 <    void UnRegister(int eventType, TEventObject *object,
187 <        void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
185 >                  PEventHandler handler);
186 > #else
187 >    void Register(int eventType, TEventObject *object,
188 >                  PEventHandler handler = DefaultHandle);
189 > #endif
190 >    void UnRegister(int eventType, TEventObject *object, PEventHandler handler);
191      void UnRegister(int eventType, TEventObject *object);
192 +    void UnRegister(TEventObject *object);
193   };
194  
195 < class TEventDispatcher
195 > class TEvenPoster
196   {
197    protected:
198      TEventTable *_table;
199  
200    public:
201 <    TEventDispatcher(TEventTable *table)  { _table = table;}
202 <    ~TEventDispatcher()  {}
201 >    TEvenPoster(TEventTable *table = NULL)  { _table = table;}
202 >    ~TEvenPoster()  {}
203  
204 <    Dispatch(int eventType, TEventDispatcher * dispatcher, void *extra);
204 >    TEventTable *GetEventTable()  { return _table;}
205 >    void SetEventTable(TEventTable *table)  { _table = table;}
206 >
207 >    virtual void PostEvent(int eventType, TEvenPoster *poster, void *extra);
208 >
209   };
210  
211 + class EventFactory
212 + {
213 +  public:
214 +    virtual TEventItem *CreatEventItem(TEventObject *object)
215 +    {
216 +      return new TEventItem(object);
217 +    }
218 +
219 +    virtual TEventItems *CreatEventItems(int eventType)
220 +    {
221 +      return new TEventItems(eventType);
222 +    }
223 +
224 +    virtual TEventTable *CreatEventTable()
225 +    {
226 +      return new TEventTable();
227 +    }
228 +
229 +    virtual TEventObject *CreatEventObject(TEventTable *table)
230 +    {
231 +      return new TEventObject(table);
232 +    }
233 +
234 +    virtual TEvenPoster *CreatEventDispatcher(TEventTable *table)
235 +    {
236 +      return new TEvenPoster(table);
237 +    }
238 + };
239 +
240 + template<class T> CallHandler(T *object, const vector<PEventHandler>& handlers,
241 +                      int eventType, TEvenPoster *poster, void *extra);
242 +
243   #endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines