Moved some of the low level scene graph construction code over to simgear.

[flightgear.git] / src / Time / FGEventMgr.hxx

diff --git a/src/Time/FGEventMgr.hxx b/src/Time/FGEventMgr.hxx
index daeaaa7bb3d8f77732c54fa7b1dd427ded954cfd..54ec6ae7b46df3a35c479174dc69f151d2873837 100644 (file)
--- a/src/Time/FGEventMgr.hxx
+++ b/src/Time/FGEventMgr.hxx
@@ -24,12 +24,12 @@
 #ifndef FG_EVENT_MGR_H_INCLUDED
 #define FG_EVENT_MGR_H_INCLUDED 1
 
-#include <boost/function.hpp>
-
 #include <simgear/compiler.h>
 #include <simgear/timing/timestamp.hxx>
 
 #include <Main/fgfs.hxx>
+#include <Include/fg_callback.hxx>
+
 #include <vector>
 #include <string>
 
@@ -43,16 +43,6 @@ class FGEventMgr : public FGSubsystem
 {
 public:
 
-    /**
-     * 
-     */
-    enum EventState {
-       FG_EVENT_SUSP   = 0,
-       FG_EVENT_READY  = 1,
-       FG_EVENT_QUEUED = 2
-    };
-
-    typedef boost::function<void> callback_type;
     typedef int interval_type;
 
 private:
@@ -68,10 +58,10 @@ private:
         */
        FGEvent();
 
-       FGEvent( const string& desc,
-                callback_type cb,
-                EventState status_,
-                interval_type ms );
+       FGEvent( const char* desc,
+                fgCallback* cb,
+                interval_type repeat_value,
+                interval_type initial_value );
 
        /**
         * 
@@ -83,8 +73,7 @@ private:
         */
        void reset()
        {
-           status = FG_EVENT_READY;
-           ms_to_go = interval_ms;
+           ms_to_go_ = repeat_value_;
        }
 
        /**
@@ -92,6 +81,10 @@ private:
         */
        void run();
 
+       string name() const { return name_; }
+       interval_type repeat_value() const { return repeat_value_; }
+       int value() const { return ms_to_go_; }
+
        /**
         * Display event statistics.
         */
@@ -104,19 +97,16 @@ private:
         */
        bool update( int dt_ms )
        {
-           if (status != FG_EVENT_READY)
-               return false;
-
-           ms_to_go -= dt_ms;
-           return ms_to_go <= 0;
+           ms_to_go_ -= dt_ms;
+           return ms_to_go_ <= 0;
        }
 
     private:
-       string description;
-       callback_type callback;
-       EventState status;
-       interval_type interval_ms;
-       int ms_to_go;
+       string name_;
+       fgCallback* callback_;
+       interval_type repeat_value_;
+       interval_type initial_value_;
+       int ms_to_go_;
 
        unsigned long cum_time;    // cumulative processor time of this event
        unsigned long min_time;    // time of quickest execution
@@ -139,30 +129,41 @@ public:
 
     /*
      * Update the elapsed time for all events.
-     * @param dt elapsed time in milliseconds.
+     * @param dt elapsed time in seconds.
      */
-    void update( int dt );
+    void update( double dt );
 
     /**
-     * Register a function to be executed every 'interval' milliseconds.
+     * Register a free standing function to be executed some time in the future.
      * @param desc A brief description of this callback for logging.
      * @param cb The callback function to be executed.
-     * @param state
-     * @param interval Callback repetition rate in milliseconds.
+     * @param repeat_value repetition rate in milliseconds.
+     * @param initial_value initial delay value in milliseconds.  A value of
+     * -1 means run immediately.
      */
-    void Register( const string& desc,
-                  callback_type cb,
-                  EventState state,
-                  interval_type interval_ms );
+    template< typename Fun >
+    void Register( const char* name,
+                  const Fun& f,
+                  interval_type repeat_value,
+                  interval_type initial_value = -1 )
+    {
+       this->Register( FGEvent( name,
+                                make_callback(f),
+                                repeat_value,
+                                initial_value ) );
+    }
 
-    /**
-     * 
-     */
-    void Register( const string& desc,
-                  callback_type cb,
-                  interval_type interval_ms )
+    template< class ObjPtr, typename MemFn >
+    void Register( const char* name,
+                  const ObjPtr& p,
+                  MemFn pmf,
+                  interval_type repeat_value,
+                  interval_type initial_value = -1 )
     {
-       this->Register( desc, cb, FG_EVENT_READY, interval_ms );
+       this->Register( FGEvent( name,
+                                make_callback(p,pmf),
+                                repeat_value,
+                                initial_value ) );
     }
 
     /**
@@ -170,6 +171,9 @@ public:
      */
     void print_stats() const;
 
+private:
+    void Register( const FGEvent& event );
+
 private:
 
     typedef vector< FGEvent > event_container_type;