simgear/structure/event_mgr.cxx

   1 #include "event_mgr.hxx"
   2
   3 void SGEventMgr::add(SGCallback* cb,
   4                      double interval, double delay,
   5                      bool repeat, bool simtime)
   6 {
   7     // Clamp the delay value to 1 usec, so that user code can use
   8     // "zero" as a synonym for "next frame".
   9     if(delay <= 0) delay = 0.000001;
  10
  11     SGTimer* t = new SGTimer;
  12     t->interval = interval;
  13     t->callback = cb;
  14     t->mgr = this;
  15     t->repeat = repeat;
  16     t->simtime = simtime;
  17
  18     SGTimerQueue* q = simtime ? &_simQueue : &_rtQueue;
  19
  20     q->insert(t, delay);
  21 }
  22
  23 void SGTimer::run()
  24 {
  25     (*callback)();
  26
  27     if(repeat) {
  28         SGTimerQueue* q = simtime ? &mgr->_simQueue : &mgr->_rtQueue;
  29         q->insert(this, interval);
  30     } else {
  31         delete callback;
  32         delete this;
  33     }
  34 }
  35
  36 void SGEventMgr::update(double delta_time_sec)
  37 {
  38     _rtQueue.update(delta_time_sec);
  39     if(!_freezeProp || _freezeProp->getBoolValue() == false)
  40         _simQueue.update(delta_time_sec);
  41 }
  42
  43 ////////////////////////////////////////////////////////////////////////
  44 // SGTimerQueue
  45 // This is the priority queue implementation:
  46 ////////////////////////////////////////////////////////////////////////
  47
  48 SGTimerQueue::SGTimerQueue(int size)
  49 {
  50     _now = 0;
  51     _numEntries = 0;
  52     _tableSize = 1;
  53     while(size > _tableSize)
  54         _tableSize = ((_tableSize + 1)<<1) - 1;
  55
  56     _table = new HeapEntry[_tableSize];
  57     for(int i=0; i<_tableSize; i++) {
  58         _table[i].pri = 0;
  59         _table[i].timer = 0;
  60     }
  61 }
  62
  63
  64 SGTimerQueue::~SGTimerQueue()
  65 {
  66     for(int i=0; i<_numEntries; i++) {
  67         delete _table[i].timer;
  68         _table[i].timer = 0;
  69     }
  70     _numEntries = 0;
  71     delete[] _table;
  72     _table = 0;
  73     _tableSize = 0;
  74 }
  75
  76 void SGTimerQueue::update(double deltaSecs)
  77 {
  78     _now += deltaSecs;
  79     while(_numEntries && nextTime() <= _now) {
  80         SGTimer* t = remove();
  81         t->run();
  82     }
  83 }
  84
  85 void SGTimerQueue::insert(SGTimer* timer, double time)
  86 {
  87     if(_numEntries >= _tableSize)
  88         growArray();
  89
  90     _numEntries++;
  91     _table[_numEntries-1].pri = -(_now + time);
  92     _table[_numEntries-1].timer = timer;
  93
  94     siftUp(_numEntries-1);
  95 }
  96
  97 SGTimer* SGTimerQueue::remove(SGTimer* t)
  98 {
  99     int entry;
 100     for(entry=0; entry<_numEntries; entry++)
 101         if(_table[entry].timer == t)
 102             break;
 103     if(entry == _numEntries)
 104         return 0;
 105
 106     // Swap in the last item in the table, and sift down
 107     swap(entry, _numEntries-1);
 108     _numEntries--;
 109     siftDown(entry);
 110
 111     return t;
 112 }
 113
 114 SGTimer* SGTimerQueue::remove()
 115 {
 116     if(_numEntries == 0) {
 117         return 0;
 118     } else if(_numEntries == 1) {
 119         _numEntries = 0;
 120         return _table[0].timer;
 121     }
 122
 123     SGTimer *result = _table[0].timer;
 124     _table[0] = _table[_numEntries - 1];
 125     _numEntries--;
 126     siftDown(0);
 127     return result;
 128 }
 129
 130 void SGTimerQueue::siftDown(int n)
 131 {
 132     // While we have children bigger than us, swap us with the biggest
 133     // child.
 134     while(lchild(n) < _numEntries) {
 135         int bigc = lchild(n);
 136         if(rchild(n) < _numEntries && pri(rchild(n)) > pri(bigc))
 137             bigc = rchild(n);
 138         if(pri(bigc) <= pri(n))
 139             break;
 140         swap(n, bigc);
 141         n = bigc;
 142     }
 143 }
 144
 145 void SGTimerQueue::siftUp(int n)
 146 {
 147     while((n != 0) && (_table[n].pri > _table[parent(n)].pri)) {
 148         swap(n, parent(n));
 149         n = parent(n);
 150     }
 151     siftDown(n);
 152 }
 153
 154 void SGTimerQueue::growArray()
 155 {
 156     _tableSize = ((_tableSize+1)<<1) - 1;
 157     HeapEntry *newTable = new HeapEntry[_tableSize];
 158     for(int i=0; i<_numEntries; i++) {
 159         newTable[i].pri  = _table[i].pri;
 160         newTable[i].timer = _table[i].timer;
 161     }
 162     delete[] _table;
 163     _table = newTable;
 164 }