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>

using namespace std;

class TEventObject;
class TEventDispatcher;

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

//in next version, we may use map data structure to store the event items which
//can speed up the searching.
typedef void (TEventObject::*PEventHandler)(int, TEventDispatcher *, 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;}

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

    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();
    TEventItems(int eventType);
    ~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(TEventDispatcher *dispatcher, 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, TEventDispatcher *dispatcher, void *extra);
};


class TEventObject
{
  protected:
    TEventTable *_table;

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

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

    void DefaultHandle(int eventType,TEventDispatcher *dispatcher, 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 TEventDispatcher
{
  protected:
    TEventTable *_table;

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

    void Dispatch(int eventType, TEventDispatcher *dispatcher, void *extra);
};

#endif
Revision:	91
Committed:	Tue Aug 20 17:54:47 2002 UTC (22 years, 8 months ago) by tim
Content type:	text/plain
File size:	4794 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
28	using namespace std;
29
30	class TEventObject;
31	class TEventDispatcher;
32
33	namespace TEventType
34	{
35	const int Unknown = 1;
36	const int FrameChanged = 2;
37	};
38
39	//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
43	class TEventItem
44	{
45	protected:
46	TEventObject *_object;
47	vector<PEventHandler> _handlers;
48
49	void Clear();
50
51	public:
52	TEventItem(TEventObject *object);
53	~TEventItem();
54
55	TEventObject *GetEventObject() { return _object;}
56	vector<PEventHandler> &GetHandlers() { return _handlers;}
57
58	void AddHandler(PEventHandler handler);
59	void RemoveHandler(PEventHandler handler);
60
61	int Count() { return _handlers.size();}
62	};
63
64	//functor for match TEventItem
65	class TMatchEventItem : public unary_function<TEventItem, bool>
66	{
67	private:
68	TEventObject *_object;
69
70	public:
71	TMatchEventItem(TEventObject *object)
72	{
73	_object = object;
74	}
75
76	bool operator()(TEventItem *eventItem)
77	{
78	return _object == eventItem->GetEventObject();
79	}
80	};
81
82	class TEventItems
83	{
84	protected:
85	vector<TEventItem*> _items;
86
87	void Clear();
88
89	public:
90	int _eventType;
91
92	TEventItems();
93	TEventItems(int eventType);
94	~TEventItems();
95
96	int GetType() { return _eventType;}
97	void SetType(int eventType) {_eventType =eventType;}
98
99	int Count() { return _items.size();}
100
101	void AddItem(TEventObject *object, PEventHandler handler);
102	void RemoveItem(TEventObject *object, PEventHandler handler);
103	void RemoveItem(TEventObject *object);
104
105	TEventItem GetEventItem(TEventObject object);
106
107	void Dispatch(TEventDispatcher dispatcher, void extra);
108	};
109
110	//functor for match TEventItem
111	class TMatchEventItems : public unary_function<TEventItems*, bool>
112	{
113	private:
114	int _eventType;
115
116	public:
117	TMatchEventItems(int eventType)
118	{
119
120	_eventType = eventType;
121	}
122
123	bool operator()(TEventItems *eventItems) const
124	{
125	return _eventType == eventItems->GetType();
126	}
127	};
128
129	class TEventTable
130	{
131	protected:
132	vector<TEventItems*> _table;
133
134	void Clear();
135
136	public:
137	TEventTable();
138	~TEventTable();
139
140	int Count() { return _table.size();}
141
142	void AddItem(int eventType, TEventObject *object, PEventHandler handler);
143	void RemoveItem(int eventType, TEventObject *object, PEventHandler handler);
144	void RemoveItem(int eventType, TEventObject *object);
145	void RemoveItem(TEventObject *object);
146
147	TEventItems *GetEventItemsByType(int eventType);
148
149	void Dispatch(int eventType, TEventDispatcher dispatcher, void extra);
150	};
151
152
153	class TEventObject
154	{
155	protected:
156	TEventTable *_table;
157
158	public:
159	TEventObject(TEventTable *table) { _table = table;}
160	~TEventObject();
161
162	TEventTable *GetEventTable() { return _table;}
163	void SetEventTable(TEventTable *table) { _table = table;}
164
165	void DefaultHandle(int eventType,TEventDispatcher dispatcher, void extra) {}
166	//GCC did not support default argument here
167	#ifdef __GNUC__
168	void Register(int eventType, TEventObject *object,
169	PEventHandler handler);
170	#else
171	void Register(int eventType, TEventObject *object,
172	PEventHandler handler = DefaultHandle);
173	#endif
174	void UnRegister(int eventType, TEventObject *object, PEventHandler handler);
175	void UnRegister(int eventType, TEventObject *object);
176	void UnRegister(TEventObject *object);
177	};
178
179	class TEventDispatcher
180	{
181	protected:
182	TEventTable *_table;
183
184	public:
185	TEventDispatcher(TEventTable *table) { _table = table;}
186	~TEventDispatcher() {}
187
188	void Dispatch(int eventType, TEventDispatcher dispatcher, void extra);
189	};
190
191	#endif