--- trunk/FAS/src/event.h	2002/08/19 23:06:57	90
+++ trunk/FAS/src/event.h	2002/08/20 17:54:47	91
@@ -21,6 +21,9 @@
 #define eventH
 #include <iostream>
 #include <vector>
+#include <string>
+#include <algorithm>
+#include <functional>
 
 using namespace std;
 
@@ -29,42 +32,124 @@ namespace TEventType
 
 namespace TEventType
 {
-  const int All = 1;
+  const int Unknown = 1;
   const int FrameChanged = 2;
 };
 
-struct TEventItem
+//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
 {
-  TEventObject *_object;
-  void (TEventObject::*Handle)(int eventType, TEventDispatcher * dispatcher, void *extra);
+  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
 {
-  int _eventType;
-  vector<TEventItem> _items;
+  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(const TEventTable &table);
     ~TEventTable();
 
-    void AddItem(int eventType, TEventObject *object,
-                 void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
-    void RemoveItem(int eventType, TEventObject *object,
-                    void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
+    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);
 
-    void Dispatch(int eventType, TEventDispatcher * dispatcher, void *extra);
+    TEventItems *GetEventItemsByType(int eventType);
+
+    void Dispatch(int eventType, TEventDispatcher *dispatcher, void *extra);
 };
 
+
 class TEventObject
 {
   protected:
@@ -72,19 +157,23 @@ class TEventObject
 
   public:
     TEventObject(TEventTable *table)  { _table = table;}
-    ~TEventObject()  {}
+    ~TEventObject();
 
     TEventTable *GetEventTable()  { return _table;}
     void SetEventTable(TEventTable *table)  { _table = table;}
 
-    virtual void DefaultHandle(int eventType,
-                               TEventDispatcher * dispatcher, void *extra)  {}
-
+    void DefaultHandle(int eventType,TEventDispatcher *dispatcher, void *extra)  {}
+//GCC did not support default argument here
+#ifdef __GNUC__
     void Register(int eventType, TEventObject *object,
-        void (TEventObject::*Handle)(int, TEventDispatcher*, void *) = DefaultHandle);
-    void UnRegister(int eventType, TEventObject *object,
-        void (TEventObject::*Handle)(int, TEventDispatcher*, void *));
+                  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
@@ -96,7 +185,7 @@ class TEventDispatcher
     TEventDispatcher(TEventTable *table)  { _table = table;}
     ~TEventDispatcher()  {}
 
-    Dispatch(int eventType, TEventDispatcher * dispatcher, void *extra);
+    void Dispatch(int eventType, TEventDispatcher *dispatcher, void *extra);
 };
 
 #endif