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 90 by tim, Mon Aug 19 23:06:57 2002 UTC vs.
Revision 91 by tim, Tue Aug 20 17:54:47 2002 UTC

# Line 21 | Line 21
21   #define eventH
22   #include <iostream>
23   #include <vector>
24 + #include <string>
25 + #include <algorithm>
26 + #include <functional>
27  
28   using namespace std;
29  
# Line 29 | Line 32 | namespace TEventType
32  
33   namespace TEventType
34   {
35 <  const int All = 1;
35 >  const int Unknown = 1;
36    const int FrameChanged = 2;
37   };
38  
39 < struct TEventItem
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 <  TEventObject *_object;
46 <  void (TEventObject::*Handle)(int eventType, TEventDispatcher * dispatcher, void *extra);
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 <  int _eventType;
85 <  vector<TEventItem> _items;
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();
56 –    TEventTable(const TEventTable &table);
138      ~TEventTable();
139  
140 <    void AddItem(int eventType, TEventObject *object,
141 <                 void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
142 <    void RemoveItem(int eventType, TEventObject *object,
143 <                    void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
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 <    void Dispatch(int eventType, TEventDispatcher * dispatcher, void *extra);
147 >    TEventItems *GetEventItemsByType(int eventType);
148 >
149 >    void Dispatch(int eventType, TEventDispatcher *dispatcher, void *extra);
150   };
151  
152 +
153   class TEventObject
154   {
155    protected:
# Line 72 | Line 157 | class TEventObject
157  
158    public:
159      TEventObject(TEventTable *table)  { _table = table;}
160 <    ~TEventObject()  {}
160 >    ~TEventObject();
161  
162      TEventTable *GetEventTable()  { return _table;}
163      void SetEventTable(TEventTable *table)  { _table = table;}
164  
165 <    virtual void DefaultHandle(int eventType,
166 <                               TEventDispatcher * dispatcher, void *extra)  {}
167 <
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 <        void (TEventObject::*Handle)(int, TEventDispatcher*, void *) = DefaultHandle);
170 <    void UnRegister(int eventType, TEventObject *object,
171 <        void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
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
# Line 96 | Line 185 | class TEventDispatcher
185      TEventDispatcher(TEventTable *table)  { _table = table;}
186      ~TEventDispatcher()  {}
187  
188 <    Dispatch(int eventType, TEventDispatcher * dispatcher, void *extra);
188 >    void Dispatch(int eventType, TEventDispatcher *dispatcher, void *extra);
189   };
190  
191   #endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines