#include "event_mgr.hxx"
-void SGEventMgr::add(SGCallback* cb,
+#include <simgear/math/SGMath.hxx>
+#include <simgear/debug/logstream.hxx>
+
+void SGEventMgr::add(const std::string& name, SGCallback* cb,
double interval, double delay,
bool repeat, bool simtime)
{
+ // Clamp the delay value to 1 usec, so that user code can use
+ // "zero" as a synonym for "next frame".
+ if(delay <= 0) delay = 0.000001;
+
SGTimer* t = new SGTimer;
t->interval = interval;
t->callback = cb;
- t->mgr = this;
t->repeat = repeat;
- t->simtime = simtime;
-
+ t->name = name;
+ t->running = false;
+
SGTimerQueue* q = simtime ? &_simQueue : &_rtQueue;
q->insert(t, delay);
}
+SGTimer::~SGTimer()
+{
+ delete callback;
+ callback = NULL;
+}
+
void SGTimer::run()
{
(*callback)();
-
- if(repeat) {
- SGTimerQueue* q = simtime ? &mgr->_simQueue : &mgr->_rtQueue;
- q->insert(this, interval);
- } else {
- delete callback;
- delete this;
- }
}
void SGEventMgr::update(double delta_time_sec)
{
- _rtQueue.update(delta_time_sec);
- if(!_freezeProp || _freezeProp->getBoolValue() == false)
- _simQueue.update(delta_time_sec);
+ _simQueue.update(delta_time_sec);
+
+ double rt = _rtProp ? _rtProp->getDoubleValue() : 0;
+ _rtQueue.update(rt);
+}
+
+void SGEventMgr::removeTask(const std::string& name)
+{
+ SGTimer* t = _simQueue.findByName(name);
+ if (t) {
+ _simQueue.remove(t);
+ } else if ((t = _rtQueue.findByName(name))) {
+ _rtQueue.remove(t);
+ } else {
+ SG_LOG(SG_GENERAL, SG_WARN, "removeTask: no task found with name:" << name);
+ return;
+ }
+ if (t->running) {
+ // mark as not repeating so that the SGTimerQueue::update()
+ // will clean it up
+ t->repeat = false;
+ } else {
+ delete t;
+ }
}
////////////////////////////////////////////////////////////////////////
SGTimerQueue::~SGTimerQueue()
{
+ for(int i=0; i<_numEntries; i++) {
+ delete _table[i].timer;
+ _table[i].timer = 0;
+ }
+ _numEntries = 0;
delete[] _table;
+ _table = 0;
+ _tableSize = 0;
}
void SGTimerQueue::update(double deltaSecs)
_now += deltaSecs;
while(_numEntries && nextTime() <= _now) {
SGTimer* t = remove();
+ if(t->repeat)
+ insert(t, t->interval);
+ // warning: this is not thread safe
+ // but the entire timer queue isn't either
+ t->running = true;
t->run();
+ t->running = false;
+ if (!t->repeat)
+ delete t;
}
}
void SGTimerQueue::insert(SGTimer* timer, double time)
{
- if(time < 0) *(int*)0=0;
-
if(_numEntries >= _tableSize)
growArray();
void SGTimerQueue::siftDown(int n)
{
- // While we have a child bigger than us:
- while(((lchild(n) < (_numEntries-1))
- && (_table[n].pri < _table[lchild(n)].pri))
- ||
- ((rchild(n) < (_numEntries-1))
- && (_table[n].pri < _table[rchild(n)].pri)))
- {
- // Swap us with the biggest child
- if(_table[lchild(n)].pri > _table[rchild(n)].pri) {
- swap(n, lchild(n));
- n = lchild(n);
- } else {
- swap(n, rchild(n));
- n = rchild(n);
- }
+ // While we have children bigger than us, swap us with the biggest
+ // child.
+ while(lchild(n) < _numEntries) {
+ int bigc = lchild(n);
+ if(rchild(n) < _numEntries && pri(rchild(n)) > pri(bigc))
+ bigc = rchild(n);
+ if(pri(bigc) <= pri(n))
+ break;
+ swap(n, bigc);
+ n = bigc;
}
}
delete[] _table;
_table = newTable;
}
+
+SGTimer* SGTimerQueue::findByName(const std::string& name) const
+{
+ for (int i=0; i < _numEntries; ++i) {
+ if (_table[i].timer->name == name) {
+ return _table[i].timer;
+ }
+ }
+
+ return NULL;
+}