Fix state-machine test linkage with static libs.

[simgear.git] / simgear / structure / event_mgr.hxx

diff --git a/simgear/structure/event_mgr.hxx b/simgear/structure/event_mgr.hxx
index 4c89b06022da3851df8217cf5d24b45ef969856a..b8dda323fb7e7c15f4ae3156a69b1d52b99702dc 100644 (file)
--- a/simgear/structure/event_mgr.hxx
+++ b/simgear/structure/event_mgr.hxx
@@ -8,13 +8,16 @@
 
 class SGEventMgr;
 
-struct SGTimer {
+class SGTimer {
+public:
+    ~SGTimer();
+    void run();
+    
+    std::string name;
     double interval;
     SGCallback* callback;
-    SGEventMgr* mgr;
     bool repeat;
-    bool simtime;
-    void run();
+    bool running;
 };
 
 class SGTimerQueue {
@@ -33,9 +36,10 @@ public:
     SGTimer* nextTimer() { return _numEntries ? _table[0].timer : 0; }
     double   nextTime()  { return -_table[0].pri; }
 
+    SGTimer* findByName(const std::string& name) const;
 private:
     // The "priority" is stored as a negative time.  This allows the
-    // implemenetation to treat the "top" of the heap as the largest
+    // implementation to treat the "top" of the heap as the largest
     // value and avoids developer mindbugs. ;)
     struct HeapEntry { double pri; SGTimer* timer; };
 
@@ -51,7 +55,9 @@ private:
     void siftDown(int n);
     void siftUp(int n);
     void growArray();
-    void check();
+
+    // gcc complains there is no function specification anywhere.
+    // void check();
 
     double _now;
     HeapEntry *_table;
@@ -62,60 +68,63 @@ private:
 class SGEventMgr : public SGSubsystem
 {
 public:
-    SGEventMgr() { _freezeProp = 0; }
-    ~SGEventMgr() { _freezeProp = 0; }
+    SGEventMgr() { _rtProp = 0; }
+    ~SGEventMgr() { _rtProp = 0; }
 
     virtual void init() {}
     virtual void update(double delta_time_sec);
 
-    void setFreezeProperty(SGPropertyNode* node) { _freezeProp = node; }
+    void setRealtimeProperty(SGPropertyNode* node) { _rtProp = node; }
 
     /**
      * Add a single function callback event as a repeating task.
      * ex: addTask("foo", &Function ... )
      */
     template<typename FUNC>
-    inline void addTask(const char* name, const FUNC& f,
+    inline void addTask(const std::string& name, const FUNC& f,
                         double interval, double delay=0, bool sim=false)
-    { add(make_callback(f), interval, delay, true, sim); }
+    { add(name, make_callback(f), interval, delay, true, sim); }
 
     /**
      * Add a single function callback event as a one-shot event.
      * ex: addEvent("foo", &Function ... )
      */
     template<typename FUNC>
-    inline void addEvent(const char* name, const FUNC& f,
+    inline void addEvent(const std::string& name, const FUNC& f,
                          double delay, bool sim=false)
-    { add(make_callback(f), 0, delay, false, sim); }
+    { add(name, make_callback(f), 0, delay, false, sim); }
 
     /**
      * Add a object/method pair as a repeating task.
      * ex: addTask("foo", &object, &ClassName::Method, ...)
      */
     template<class OBJ, typename METHOD>
-    inline void addTask(const char* name,
+    inline void addTask(const std::string& name,
                         const OBJ& o, METHOD m,
                         double interval, double delay=0, bool sim=false)
-    { add(make_callback(o,m), interval, delay, true, sim); }
+    { add(name, make_callback(o,m), interval, delay, true, sim); }
 
     /**
      * Add a object/method pair as a repeating task.
      * ex: addEvent("foo", &object, &ClassName::Method, ...)
      */
     template<class OBJ, typename METHOD>
-    inline void addEvent(const char* name,
+    inline void addEvent(const std::string& name,
                          const OBJ& o, METHOD m,
                          double delay, bool sim=false)
-    { add(make_callback(o,m), 0, delay, false, sim); }
+    { add(name, make_callback(o,m), 0, delay, false, sim); }
+
 
+    void removeTask(const std::string& name);
 private:
-    friend struct SGTimer;
+    friend class SGTimer;
 
-    void add(SGCallback* cb,
+    void add(const std::string& name, SGCallback* cb,
              double interval, double delay,
              bool repeat, bool simtime);
 
-    SGPropertyNode* _freezeProp;
+    SGPropertyNode_ptr _freezeProp;
+    SGPropertyNode_ptr _rtProp;
     SGTimerQueue _rtQueue; 
     SGTimerQueue _simQueue;
 };