FAS/src/event.cpp

/***********************************************************************
*           Copyright (C) 2002-2003 by Gezelter's Group
*This program is free software; you can redistribute it and/or modify
*it under the terms of the GNU General Public License as published by
*the Free Software Foundation version 2 of the License.
*
*This program is distributed in the hope that it will be useful,
*but WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*GNU General Public License for more details.
*
************************************************************************
*Author: Teng Lin               Email:  tlin@nd.edu
*Date: 08/13/2002               Version: 1.0
*
************************************************************************
*Description:
* 
***********************************************************************/
#include "event.h"
/***********************************************************************
* Class TEventItem
***********************************************************************/
void TEventItem::Clear()
{
  _handlers.clear();
}
TEventItem::TEventItem(TEventObject *object)
{
  Clear();

  _object = object;
}

TEventItem::~TEventItem()
{
  Clear();
}

void TEventItem::AddHandler(PEventHandler handler)
{
  vector<PEventHandler>::iterator i;

  i = find(_handlers.begin(), _handlers.end(), handler);

  if (i == _handlers.end())
  {
    _handlers.push_back(handler);
  }
}

void TEventItem::RemoveHandler(PEventHandler handler)
{
  vector<PEventHandler>::iterator i;

  i = find(_handlers.begin(), _handlers.end(), handler);

  if (i != _handlers.end())
  {
    _handlers.erase(i);
  }

}
/***********************************************************************
* Class TEventItems
***********************************************************************/
void TEventItems::Clear()
{
  for(int i=0; i<_items.size(); i++)
  {
    if (_items[i] != NULL)
    {
      delete _items[i];
    }
  }

  _items.clear();
}

TEventItems::TEventItems()
{
  Clear();

  SetType(TEventType::Unknown);
}

TEventItems::TEventItems(int eventType)
{
  Clear();
  SetType(eventType);
}

TEventItems::~TEventItems()
{
  Clear();
}

void TEventItems::AddItem(TEventObject *object, PEventHandler handler)
{
  TEventItem * item;

  item = GetEventItem(object);

  if (item != NULL)
  {
    item->AddHandler(handler);
  }
  else
  {
    item = new TEventItem(object);
    if(item != NULL)
    {
      item->AddHandler(handler);
      _items.push_back(item);
    }
    else
    {
     //Memory allocation fail
    }
  }
}

void TEventItems::RemoveItem(TEventObject *object, PEventHandler handler)
{
  TEventItem * item;

  item = GetEventItem(object);

  if (item !=NULL)
  {
    item->RemoveHandler(handler);
    if (item->Count() == 0)
      _items.erase(find(_items.begin(), _items.end(), item));
  }
}

void TEventItems::RemoveItem(TEventObject *object)
{
  vector<TEventItem *>::iterator i;

  i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));

  if (i != _items.end())
  {
    delete *i;
    _items.erase(i);
  }
}

TEventItem *TEventItems::GetEventItem(TEventObject *object)
{
  vector<TEventItem *>::iterator i;

  i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));

  if (i != _items.end())
  {
    return *i;
  }
  else
  {
    return NULL;
  }

}
void TEventItems::Dispatch(TEventDispatcher *dispatcher, void *extra)
{

}
/***********************************************************************
* Class TEventTable
***********************************************************************/
void TEventTable::Clear()
{
  for(int i=0; i<_table.size(); i++)
  {
    if (_table[i] != NULL)
      delete _table[i];
  }

  _table.clear();
}

TEventTable::TEventTable()
{
  Clear();
}

TEventTable::~TEventTable()
{
  Clear();
}

void TEventTable::AddItem(int eventType,
                          TEventObject *object, PEventHandler handler)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);


  if (items == NULL)
  {
    items = new TEventItems(eventType);
    if (items != NULL)
    {
      items->AddItem(object, handler);
      _table.push_back(items);
    }
    else
    {
    //Error
    }
  }
  else
  {
    items->AddItem(object, handler);
  }

}

void TEventTable::RemoveItem(int eventType,
                              TEventObject *object, PEventHandler handler)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);

  if (items != NULL)
  {
    items->RemoveItem(object, handler);

  }
}

void TEventTable::RemoveItem(int eventType, TEventObject *object)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);

  if (items != NULL)
  {
    items->RemoveItem(object);
  }
}

void TEventTable::RemoveItem(TEventObject *object)
{
  for(int i=0; i<_table.size(); i++)
    RemoveItem(_table[i]->_eventType, object);
}

TEventItems *TEventTable::GetEventItemsByType(int eventType)
{
  vector<TEventItems*>::iterator i;


  i = find_if(_table.begin(), _table.end(), TMatchEventItems(eventType));

  if(i == _table.end())
  {
    return NULL;
  }
  else
  {
    return *i;
  }
}

void TEventTable::Dispatch(int eventType,
                            TEventDispatcher *dispatcher, void *extra)
{
  TEventItems *items;

  items = GetEventItemsByType(eventType);

  if (items != NULL)
  {
    items->Dispatch(dispatcher, extra);
  }
  else
  {
    return;
  }
}

/***********************************************************************
* Class TEventObject
***********************************************************************/
TEventObject::~TEventObject()
{
  UnRegister(this);
}

void TEventObject::Register(int eventType, TEventObject *object,
                            PEventHandler handler)
{
  _table->AddItem(eventType, object, handler);
}

void TEventObject::UnRegister(int eventType, TEventObject *object,
                              PEventHandler handler)
{
  _table->RemoveItem(eventType, object, handler);
}

void TEventObject::UnRegister(int eventType, TEventObject *object)
{
  _table->RemoveItem(eventType, object);
}

void TEventObject::UnRegister(TEventObject *object)
{
  _table->RemoveItem(object);
}
/***********************************************************************
* Class TEventDispatcher
***********************************************************************/
void TEventDispatcher::Dispatch(int eventType,
                                TEventDispatcher *dispatcher,void *extra)
{
  _table->Dispatch(eventType, dispatcher, extra);
}

Revision:	91
Committed:	Tue Aug 20 17:54:47 2002 UTC (21 years, 10 months ago) by tim
File size:	6549 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	tim	90	/***********************************************************************
2			* Copyright (C) 2002-2003 by Gezelter's Group
3			*This program is free software; you can redistribute it and/or modify
4			*it under the terms of the GNU General Public License as published by
5			*the Free Software Foundation version 2 of the License.
6			*
7			*This program is distributed in the hope that it will be useful,
8			*but WITHOUT ANY WARRANTY; without even the implied warranty of
9			*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10			*GNU General Public License for more details.
11			*
12			************************************************************************
13			*Author: Teng Lin Email: tlin@nd.edu
14			*Date: 08/13/2002 Version: 1.0
15			*
16			************************************************************************
17			*Description:
18			*
19			***********************************************************************/
20			#include "event.h"
21			/***********************************************************************
22	tim	91	* Class TEventItem
23	tim	90	***********************************************************************/
24	tim	91	void TEventItem::Clear()
25			{
26			_handlers.clear();
27			}
28			TEventItem::TEventItem(TEventObject *object)
29			{
30			Clear();
31	tim	90
32	tim	91	_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			* Class TEventItems
66			***********************************************************************/
67			void TEventItems::Clear()
68			{
69			for(int i=0; i<_items.size(); i++)
70			{
71			if (_items[i] != NULL)
72			{
73			delete _items[i];
74			}
75			}
76
77			_items.clear();
78			}
79
80			TEventItems::TEventItems()
81			{
82			Clear();
83
84			SetType(TEventType::Unknown);
85			}
86
87			TEventItems::TEventItems(int eventType)
88			{
89			Clear();
90			SetType(eventType);
91			}
92
93			TEventItems::~TEventItems()
94			{
95			Clear();
96			}
97
98			void TEventItems::AddItem(TEventObject *object, PEventHandler handler)
99			{
100			TEventItem * item;
101
102			item = GetEventItem(object);
103
104			if (item != NULL)
105			{
106			item->AddHandler(handler);
107			}
108			else
109			{
110			item = new TEventItem(object);
111			if(item != NULL)
112			{
113			item->AddHandler(handler);
114			_items.push_back(item);
115			}
116			else
117			{
118			//Memory allocation fail
119			}
120			}
121			}
122
123			void TEventItems::RemoveItem(TEventObject *object, PEventHandler handler)
124			{
125			TEventItem * item;
126
127			item = GetEventItem(object);
128
129			if (item !=NULL)
130			{
131			item->RemoveHandler(handler);
132			if (item->Count() == 0)
133			_items.erase(find(_items.begin(), _items.end(), item));
134			}
135			}
136
137			void TEventItems::RemoveItem(TEventObject *object)
138			{
139			vector<TEventItem *>::iterator i;
140
141			i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));
142
143			if (i != _items.end())
144			{
145			delete *i;
146			_items.erase(i);
147			}
148			}
149
150			TEventItem TEventItems::GetEventItem(TEventObject object)
151			{
152			vector<TEventItem *>::iterator i;
153
154			i = find_if(_items.begin(), _items.end(), TMatchEventItem(object));
155
156			if (i != _items.end())
157			{
158			return *i;
159			}
160			else
161			{
162			return NULL;
163			}
164
165			}
166			void TEventItems::Dispatch(TEventDispatcher dispatcher, void extra)
167			{
168
169			}
170			/***********************************************************************
171			* Class TEventTable
172			***********************************************************************/
173			void TEventTable::Clear()
174			{
175			for(int i=0; i<_table.size(); i++)
176			{
177			if (_table[i] != NULL)
178			delete _table[i];
179			}
180
181			_table.clear();
182			}
183
184			TEventTable::TEventTable()
185			{
186			Clear();
187			}
188
189			TEventTable::~TEventTable()
190			{
191			Clear();
192			}
193
194			void TEventTable::AddItem(int eventType,
195			TEventObject *object, PEventHandler handler)
196			{
197			TEventItems *items;
198
199			items = GetEventItemsByType(eventType);
200
201
202			if (items == NULL)
203			{
204			items = new TEventItems(eventType);
205			if (items != NULL)
206			{
207			items->AddItem(object, handler);
208			_table.push_back(items);
209			}
210			else
211			{
212			//Error
213			}
214			}
215			else
216			{
217			items->AddItem(object, handler);
218			}
219
220			}
221
222			void TEventTable::RemoveItem(int eventType,
223			TEventObject *object, PEventHandler handler)
224			{
225			TEventItems *items;
226
227			items = GetEventItemsByType(eventType);
228
229			if (items != NULL)
230			{
231			items->RemoveItem(object, handler);
232
233			}
234			}
235
236			void TEventTable::RemoveItem(int eventType, TEventObject *object)
237			{
238			TEventItems *items;
239
240			items = GetEventItemsByType(eventType);
241
242			if (items != NULL)
243			{
244			items->RemoveItem(object);
245			}
246			}
247
248			void TEventTable::RemoveItem(TEventObject *object)
249			{
250			for(int i=0; i<_table.size(); i++)
251			RemoveItem(_table[i]->_eventType, object);
252			}
253
254			TEventItems *TEventTable::GetEventItemsByType(int eventType)
255			{
256			vector<TEventItems*>::iterator i;
257
258
259			i = find_if(_table.begin(), _table.end(), TMatchEventItems(eventType));
260
261			if(i == _table.end())
262			{
263			return NULL;
264			}
265			else
266			{
267			return *i;
268			}
269			}
270
271			void TEventTable::Dispatch(int eventType,
272			TEventDispatcher dispatcher, void extra)
273			{
274			TEventItems *items;
275
276			items = GetEventItemsByType(eventType);
277
278			if (items != NULL)
279			{
280			items->Dispatch(dispatcher, extra);
281			}
282			else
283			{
284			return;
285			}
286			}
287
288			/***********************************************************************
289			* Class TEventObject
290			***********************************************************************/
291			TEventObject::~TEventObject()
292			{
293			UnRegister(this);
294			}
295
296			void TEventObject::Register(int eventType, TEventObject *object,
297			PEventHandler handler)
298			{
299			_table->AddItem(eventType, object, handler);
300			}
301
302			void TEventObject::UnRegister(int eventType, TEventObject *object,
303			PEventHandler handler)
304			{
305			_table->RemoveItem(eventType, object, handler);
306			}
307
308			void TEventObject::UnRegister(int eventType, TEventObject *object)
309			{
310			_table->RemoveItem(eventType, object);
311			}
312
313			void TEventObject::UnRegister(TEventObject *object)
314			{
315			_table->RemoveItem(object);
316			}
317			/***********************************************************************
318			* Class TEventDispatcher
319			***********************************************************************/
320			void TEventDispatcher::Dispatch(int eventType,
321			TEventDispatcher dispatcher,void extra)
322			{
323			_table->Dispatch(eventType, dispatcher, extra);
324			}
325