FAS/src/event.h

/**********************************************************************
*           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:
* The Classes of handling event
***********************************************************************/
#ifndef eventH
#define eventH
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <functional>
//in this version, we register the event type and event object to event table.
//Alternately, we can record the event types which event object want to response
//by itself. I will consider to implement in latter way in next version

using namespace std;

class TEventObject;
class TEvenPoster;

namespace TEventType
{
  const int Unknown = 1;
  const int FrameChanged = 2;
};

typedef void (TEventObject::*PEventHandler)(int, TEvenPoster *, void *) ;

class TEventItem
{
  protected:
    TEventObject *_object;
    vector<PEventHandler> _handlers;

    void Clear();

  public:
    TEventItem(TEventObject *object);
    ~TEventItem();

    TEventObject *GetEventObject()  { return _object;}
    vector<PEventHandler> &GetHandlers()  { return _handlers;}

    virtual void AddHandler(PEventHandler handler);
    virtual void RemoveHandler(PEventHandler handler);

    virtual void ExecuteHandler(int eventType, TEvenPoster *poster, void *extra);
    int Count() { return _handlers.size();}
};

//functor for match TEventItem
class TMatchEventItem : public unary_function<TEventItem, bool>
{
  private:
    TEventObject *_object;

  public:
    TMatchEventItem(TEventObject *object)
    {
      _object = object;
    }

    bool operator()(TEventItem *eventItem)
    {
      return _object == eventItem->GetEventObject();
    }
};

class TEventItems
{
  protected:
    vector<TEventItem*> _items;

    void Clear();

  public:
    int _eventType;

    TEventItems(int eventType = TEventType::Unknown);
    ~TEventItems();

    int GetType() { return _eventType;}
    void SetType(int eventType)  {_eventType =eventType;}

    int Count() { return _items.size();}

    void AddItem(TEventObject *object, PEventHandler handler);
    void RemoveItem(TEventObject *object, PEventHandler handler);
    void RemoveItem(TEventObject *object);

    TEventItem *GetEventItem(TEventObject *object);

    void Dispatch(int eventType, TEvenPoster *poster, void *extra);
};

//functor for match TEventItem
class TMatchEventItems : public unary_function<TEventItems*, bool>
{
  private:
    int _eventType;

  public:
    TMatchEventItems(int eventType)
    {

      _eventType = eventType;
    }

    bool operator()(TEventItems *eventItems) const
    {
      return _eventType == eventItems->GetType();
    }
};

class TEventTable
{
  protected:
    vector<TEventItems*> _table;

    void Clear();

  public:
    TEventTable();
    ~TEventTable();

    int Count() { return _table.size();}

    void AddItem(int eventType, TEventObject *object, PEventHandler handler);
    void RemoveItem(int eventType, TEventObject *object, PEventHandler handler);
    void RemoveItem(int eventType, TEventObject *object);
    void RemoveItem(TEventObject *object);

    TEventItems *GetEventItemsByType(int eventType);

    void Dispatch(int eventType, TEvenPoster *poster, void *extra);
};

namespace TEventObjectType
{
  const int BaseEventObject = 1;
};

class TEventObject
{
  protected:
    int _type;
    string _ident;
    TEventTable *_table;

  public:
    TEventObject(TEventTable *table = NULL)
    {

      _table = table;
    }
    ~TEventObject();

    int GetEventObjectType()  { return _type;}
    string GetIdent() { return _ident;}
    TEventTable *GetEventTable()  { return _table;}

    void SetEventObjectType(int type) { _type = type;}
    void SetIdent(string ident) { _ident = ident;}
    void SetEventTable(TEventTable *table)  { _table = table;}

    void DefaultHandle(int eventType,TEvenPoster *poster, void *extra)  {}
//GCC did not support default argument here
#ifdef __GNUC__
    void Register(int eventType, TEventObject *object,
                  PEventHandler handler);
#else
    void Register(int eventType, TEventObject *object,
                  PEventHandler handler = DefaultHandle);
#endif
    void UnRegister(int eventType, TEventObject *object, PEventHandler handler);
    void UnRegister(int eventType, TEventObject *object);
    void UnRegister(TEventObject *object);
};

class TEvenPoster
{
  protected:
    TEventTable *_table;

  public:
    TEvenPoster(TEventTable *table = NULL)  { _table = table;}
    ~TEvenPoster()  {}

    TEventTable *GetEventTable()  { return _table;}
    void SetEventTable(TEventTable *table)  { _table = table;}

    virtual void PostEvent(int eventType, TEvenPoster *poster, void *extra);

};

class EventFactory
{
  public:
    virtual TEventItem *CreatEventItem(TEventObject *object)
    {
      return new TEventItem(object);
    }

    virtual TEventItems *CreatEventItems(int eventType)
    {
      return new TEventItems(eventType);
    }

    virtual TEventTable *CreatEventTable()
    {
      return new TEventTable();
    }

    virtual TEventObject *CreatEventObject(TEventTable *table)
    {
      return new TEventObject(table);
    }

    virtual TEvenPoster *CreatEventDispatcher(TEventTable *table)
    {
      return new TEvenPoster(table);
    }
};

template<class T> CallHandler(T *object, const vector<PEventHandler>& handlers,
                      int eventType, TEvenPoster *poster, void *extra);

#endif
Revision:	92
Committed:	Tue Aug 20 23:26:55 2002 UTC (21 years, 10 months ago) by tim
Content type:	text/plain
File size:	6145 byte(s)
Log Message:	* empty log message *
#	Content
1	/**********************************************************************
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	* The Classes of handling event
19	***********************************************************************/
20	#ifndef eventH
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 TEvenPoster;
35
36	namespace TEventType
37	{
38	const int Unknown = 1;
39	const int FrameChanged = 2;
40	};
41
42	typedef void (TEventObject::PEventHandler)(int, TEvenPoster , void *) ;
43
44	class TEventItem
45	{
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	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();
139	~TEventTable();
140
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	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 = 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,TEvenPoster poster, void extra) {}
182	//GCC did not support default argument here
183	#ifdef __GNUC__
184	void Register(int eventType, TEventObject *object,
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 TEvenPoster
196	{
197	protected:
198	TEventTable *_table;
199
200	public:
201	TEvenPoster(TEventTable *table = NULL) { _table = table;}
202	~TEvenPoster() {}
203
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