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 91 by tim, Tue Aug 20 17:54:47 2002 UTC vs.
Revision 92 by tim, Tue Aug 20 23:26:55 2002 UTC

# Line 24 | Line 24
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   {
# Line 36 | Line 39 | namespace TEventType
39    const int FrameChanged = 2;
40   };
41  
42 < //in next version, we may use map data structure to store the event items which
40 < //can speed up the searching.
41 < typedef void (TEventObject::*PEventHandler)(int, TEventDispatcher *, void *) ;
42 > typedef void (TEventObject::*PEventHandler)(int, TEvenPoster *, void *) ;
43  
44   class TEventItem
45   {
# Line 55 | Line 56 | class TEventItem
56      TEventObject *GetEventObject()  { return _object;}
57      vector<PEventHandler> &GetHandlers()  { return _handlers;}
58  
59 <    void AddHandler(PEventHandler handler);
60 <    void RemoveHandler(PEventHandler handler);
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  
# Line 89 | Line 91 | class TEventItems
91    public:
92      int _eventType;
93  
94 <    TEventItems();
93 <    TEventItems(int eventType);
94 >    TEventItems(int eventType = TEventType::Unknown);
95      ~TEventItems();
96  
97      int GetType() { return _eventType;}
# Line 104 | Line 105 | class TEventItems
105  
106      TEventItem *GetEventItem(TEventObject *object);
107  
108 <    void Dispatch(TEventDispatcher *dispatcher, void *extra);
108 >    void Dispatch(int eventType, TEvenPoster *poster, void *extra);
109   };
110  
111   //functor for match TEventItem
# Line 146 | Line 147 | class TEventTable
147  
148      TEventItems *GetEventItemsByType(int eventType);
149  
150 <    void Dispatch(int eventType, TEventDispatcher *dispatcher, void *extra);
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;}
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 <    void DefaultHandle(int eventType,TEventDispatcher *dispatcher, void *extra)  {}
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,
# Line 176 | Line 192 | class TEventObject
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 <    void 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