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

Comparing trunk/FAS/src/event.cpp (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 15 | Line 15
15   *
16   ************************************************************************
17   *Description:
18 < *
18 > *
19   ***********************************************************************/
20   #include "event.h"
21   /***********************************************************************
22 < * Class TAnimation
22 > * Class TEventItem
23   ***********************************************************************/
24 + void TEventItem::Clear()
25 + {
26 +  _handlers.clear();
27 + }
28 + TEventItem::TEventItem(TEventObject *object)
29 + {
30 +  Clear();
31  
32 +  _object = object;
33 + }
34 +
35 + TEventItem::~TEventItem()
36 + {
37 +  Clear();
38 + }
39 +
40 + void TEventItem::AddHandler(PEventHandler handler)
41 + {
42 +  vector<PEventHandler>::iterator i;
43 +
44 +  i = find(_handlers.begin(), _handlers.end(), handler);
45 +
46 +  if (i == _handlers.end())
47 +  {
48 +    _handlers.push_back(handler);
49 +  }
50 + }
51 +
52 + void TEventItem::RemoveHandler(PEventHandler handler)
53 + {
54 +  vector<PEventHandler>::iterator i;
55 +
56 +  i = find(_handlers.begin(), _handlers.end(), handler);
57 +
58 +  if (i != _handlers.end())
59 +  {
60 +    _handlers.erase(i);
61 +  }
62 + }
63 +
64 +
65 + void TEventItem::ExecuteHandler(int eventType, TEvenPoster *poster, void *extra)
66 + {
67 +  PEventHandler handler;
68 +  switch (_object->GetEventObjectType())
69 +  {
70 +    case TEventObjectType::BaseEventObject :
71 +      CallHandler<TEventObject>(_object, _handlers, eventType, poster, extra);
72 +      break;
73 +    default:
74 +      ;
75 +  }
76 + }
77 + /***********************************************************************
78 + * Class TEventItems
79 + ***********************************************************************/
80 + void TEventItems::Clear()
81 + {
82 +  for(int i=0; i<_items.size(); i++)
83 +  {
84 +    if (_items[i] != NULL)
85 +    {
86 +      delete _items[i];
87 +    }
88 +  }
89 +
90 +  _items.clear();
91 + }
92 +
93 + TEventItems::TEventItems(int eventType)
94 + {
95 +  Clear();
96 +  SetType(eventType);
97 + }
98 +
99 + TEventItems::~TEventItems()
100 + {
101 +  Clear();
102 + }
103 +
104 + void TEventItems::AddItem(TEventObject *object, PEventHandler handler)
105 + {
106 +  TEventItem * item;
107 +
108 +  item = GetEventItem(object);
109 +
110 +  if (item != NULL)
111 +  {
112 +    item->AddHandler(handler);
113 +  }
114 +  else
115 +  {
116 +    item = new TEventItem(object);
117 +    if(item != NULL)
118 +    {
119 +      item->AddHandler(handler);
120 +      _items.push_back(item);
121 +    }
122 +    else
123 +    {
124 +     //Memory allocation fail
125 +    }
126 +  }
127 + }
128 +
129 + void TEventItems::RemoveItem(TEventObject *object, PEventHandler handler)
130 + {
131 +  TEventItem * item;
132 +
133 +  item = GetEventItem(object);
134 +
135 +  if (item !=NULL)
136 +  {
137 +    item->RemoveHandler(handler);
138 +    if (item->Count() == 0)
139 +      _items.erase(find(_items.begin(), _items.end(), item));
140 +  }
141 + }
142 +
143 + void TEventItems::RemoveItem(TEventObject *object)
144 + {
145 +  vector<TEventItem *>::iterator i;
146 +
147 +  i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));
148 +
149 +  if (i != _items.end())
150 +  {
151 +    delete *i;
152 +    _items.erase(i);
153 +  }
154 + }
155 +
156 + TEventItem *TEventItems::GetEventItem(TEventObject *object)
157 + {
158 +  vector<TEventItem *>::iterator i;
159 +
160 +  i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));
161 +
162 +  if (i != _items.end())
163 +  {
164 +    return *i;
165 +  }
166 +  else
167 +  {
168 +    return NULL;
169 +  }
170 + }
171 +
172 + void TEventItems::Dispatch(int eventType, TEvenPoster *poster, void *extra)
173 + {
174 +  for(int i=0; i < Count(); i++)
175 +    _items[i]->ExecuteHandler(eventType, poster, extra);
176 + }
177 +
178 + /***********************************************************************
179 + * Class TEventTable
180 + ***********************************************************************/
181 + void TEventTable::Clear()
182 + {
183 +  for(int i=0; i<_table.size(); i++)
184 +  {
185 +    if (_table[i] != NULL)
186 +      delete _table[i];
187 +  }
188 +
189 +  _table.clear();
190 + }
191 +
192 + TEventTable::TEventTable()
193 + {
194 +  Clear();
195 + }
196 +
197 + TEventTable::~TEventTable()
198 + {
199 +  Clear();
200 + }
201 +
202 + void TEventTable::AddItem(int eventType,
203 +                          TEventObject *object, PEventHandler handler)
204 + {
205 +  TEventItems *items;
206 +
207 +  items = GetEventItemsByType(eventType);
208 +
209 +
210 +  if (items == NULL)
211 +  {
212 +    items = new TEventItems(eventType);
213 +    if (items != NULL)
214 +    {
215 +      items->AddItem(object, handler);
216 +      _table.push_back(items);
217 +    }
218 +    else
219 +    {
220 +    //Error
221 +    }
222 +  }
223 +  else
224 +  {
225 +    items->AddItem(object, handler);
226 +  }
227 +
228 + }
229 +
230 + void TEventTable::RemoveItem(int eventType,
231 +                              TEventObject *object, PEventHandler handler)
232 + {
233 +  TEventItems *items;
234 +
235 +  items = GetEventItemsByType(eventType);
236 +
237 +  if (items != NULL)
238 +  {
239 +    items->RemoveItem(object, handler);
240 +
241 +  }
242 + }
243 +
244 + void TEventTable::RemoveItem(int eventType, TEventObject *object)
245 + {
246 +  TEventItems *items;
247 +
248 +  items = GetEventItemsByType(eventType);
249 +
250 +  if (items != NULL)
251 +  {
252 +    items->RemoveItem(object);
253 +  }
254 + }
255 +
256 + void TEventTable::RemoveItem(TEventObject *object)
257 + {
258 +  for(int i=0; i<_table.size(); i++)
259 +    RemoveItem(_table[i]->_eventType, object);
260 + }
261 +
262 + TEventItems *TEventTable::GetEventItemsByType(int eventType)
263 + {
264 +  vector<TEventItems*>::iterator i;
265 +
266 +
267 +  i = find_if(_table.begin(), _table.end(), TMatchEventItems(eventType));
268 +
269 +  if(i == _table.end())
270 +  {
271 +    return NULL;
272 +  }
273 +  else
274 +  {
275 +    return *i;
276 +  }
277 + }
278 +
279 + void TEventTable::Dispatch(int eventType,
280 +                            TEvenPoster *poster, void *extra)
281 + {
282 +  TEventItems *items;
283 +
284 +  items = GetEventItemsByType(eventType);
285 +
286 +  if (items != NULL)
287 +  {
288 +    items->Dispatch(eventType,poster, extra);
289 +  }
290 +  else
291 +  {
292 +    return;
293 +  }
294 + }
295 +
296 + /***********************************************************************
297 + * Class TEventObject
298 + ***********************************************************************/
299 + TEventObject::~TEventObject()
300 + {
301 +  UnRegister(this);
302 + }
303 +
304 + void TEventObject::Register(int eventType, TEventObject *object,
305 +                            PEventHandler handler)
306 + {
307 +  if (_table != NULL)
308 +    _table->AddItem(eventType, object, handler);
309 + }
310 +
311 + void TEventObject::UnRegister(int eventType, TEventObject *object,
312 +                              PEventHandler handler)
313 + {
314 +  if (_table != NULL)
315 +    _table->RemoveItem(eventType, object, handler);
316 + }
317 +
318 + void TEventObject::UnRegister(int eventType, TEventObject *object)
319 + {
320 +  if (_table != NULL)
321 +    _table->RemoveItem(eventType, object);
322 + }
323 +
324 + void TEventObject::UnRegister(TEventObject *object)
325 + {
326 +  if (_table != NULL)
327 +    _table->RemoveItem(object);
328 + }
329 + /***********************************************************************
330 + * Class TEvenPoster
331 + ***********************************************************************/
332 + void TEvenPoster::PostEvent(int eventType,
333 +                                TEvenPoster *poster, void *extra)
334 + {
335 +  if (_table != NULL)
336 +    _table->Dispatch(eventType, poster, extra);
337 + }
338 +
339 +
340 + template<class T> CallHandler(T *object, const vector<PEventHandler>& handlers,
341 +                      int eventType, TEvenPoster *poster, void *extra)
342 + {
343 +  PEventHandler handler;
344 +
345 +  for(int i=0; i<handlers.size(); i++)
346 +  {
347 +    handler = handlers[i];
348 +    (object->*handler)(eventType, poster, extra);
349 +  }
350 + }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines