new timers, timer manager

diff --git a/otk/image.hh b/otk/image.hh
index eedd65127f4660d7c8b9fbdb13a0d68be813c164..ac5794b5fb5298c84f3d7cb3aafb8a7d67651ebc 100644 (file)
--- a/otk/image.hh
+++ b/otk/image.hh
@@ -116,7 +116,7 @@ public:
 private:
   bool dither;
   const ScreenInfo *screeninfo;
-  ob::BTimer *timer;
+  ob::OBTimer *timer;
 
   Colormap colormap;
 

diff --git a/otk/imagecontrol.cc b/otk/imagecontrol.cc
index 062c959d7dea9b86529b2f7fa6eb65d1ad5a23fb..7120f1cf9306be8bc84db9a52fd97ba8a6862367 100644 (file)
--- a/otk/imagecontrol.cc
+++ b/otk/imagecontrol.cc
@@ -58,7 +58,7 @@ BImageControl::BImageControl(const ScreenInfo *scrn,
     timer->setTimeout(cache_timeout);
     timer->start();*/
   } else {
-    timer = (ob::BTimer *) 0;
+    timer = (ob::OBTimer *) 0;
   }
 
   colors = (XColor *) 0;

diff --git a/src/blackbox.cc b/src/blackbox.cc
index a845431aee4e297c52492d0a3dc73f27a2b78730..e5e498a3e7a6bea2320d7d4a91e9f5df08bf0007 100644 (file)
--- a/src/blackbox.cc
+++ b/src/blackbox.cc
@@ -158,7 +158,7 @@ Blackbox::Blackbox(int argc, char **m_argv, char *rc)
 
   reconfigure_wait = False;
 
-  timer = new BTimer(this, this);
+  timer = new OBTimer(this);
   timer->setTimeout(0l);
 }
 
@@ -1215,14 +1215,4 @@ void Blackbox::setFocusedWindow(BlackboxWindow *win) {
 }
 
 
-void Blackbox::addTimer(BTimer *timer) {
-  (void)timer;
-}
-
-
-void Blackbox::removeTimer(BTimer *timer) {
-  (void)timer;
-}
-
- 
 } 

diff --git a/src/blackbox.hh b/src/blackbox.hh
index 71acf5132e09a3e8965303a2d264510463583ba4..947c0a99b25641a3ca3a67eb50046310fbe329a4 100644 (file)
--- a/src/blackbox.hh
+++ b/src/blackbox.hh
@@ -69,7 +69,7 @@ class Blackbox;
 class BlackboxWindow;
 class BWindowGroup;
 
-class Blackbox : public Openbox, public TimeoutHandler, public TimerQueueManager  {
+class Blackbox : public Openbox, public TimeoutHandler {
 private:
   struct BCursor {
     Cursor session, move, ll_angle, lr_angle, ul_angle, ur_angle;
@@ -109,7 +109,7 @@ private:
 
   BScreen *active_screen;
   BlackboxWindow *focused_window, *changing_window;
-  BTimer *timer;
+  OBTimer *timer;
   Configuration config;
   XAtom *xatom;
 
@@ -216,9 +216,6 @@ public:
   virtual void timeout(void);
 
   enum { B_AmericanDate = 1, B_EuropeanDate };
-
-  virtual void addTimer(BTimer *timer);
-  virtual void removeTimer(BTimer *timer);
 };
 
 }

diff --git a/src/openbox.cc b/src/openbox.cc
index 440c4f70fd6c56f5be43acfaa6110b8e51b2bb51..1af59c25fbce1ea575adb84a06050a55a5a32f22 100644 (file)
--- a/src/openbox.cc
+++ b/src/openbox.cc
@@ -208,50 +208,13 @@ void Openbox::showHelp()
 
 void Openbox::eventLoop()
 {
-  const int xfd = ConnectionNumber(otk::OBDisplay::display);
-
   while (_state == State_Normal) {
     if (XPending(otk::OBDisplay::display)) {
       XEvent e;
       XNextEvent(otk::OBDisplay::display, &e);
       process_event(&e);
     } else {
-      fd_set rfds;
-      timeval now, tm, *timeout = (timeval *) 0;
-
-      FD_ZERO(&rfds);
-      FD_SET(xfd, &rfds);
-
-/*      if (! timerList.empty()) {
-        const BTimer* const timer = timerList.top();
-
-        gettimeofday(&now, 0);
-        tm = timer->timeRemaining(now);
-
-        timeout = &tm;
-      }
-
-      select(xfd + 1, &rfds, 0, 0, timeout);
-
-      // check for timer timeout
-      gettimeofday(&now, 0);
-
-      // there is a small chance for deadlock here:
-      // *IF* the timer list keeps getting refreshed *AND* the time between
-      // timer->start() and timer->shouldFire() is within the timer's period
-      // then the timer will keep firing.  This should be VERY near impossible.
-      while (! timerList.empty()) {
-        BTimer *timer = timerList.top();
-        if (! timer->shouldFire(now))
-          break;
-
-        timerList.pop();
-
-        timer->fireTimeout();
-        timer->halt();
-        if (timer->isRecurring())
-          timer->start();
-          }*/
+      _timermanager.fire();
     }
   }
 }

diff --git a/src/openbox.hh b/src/openbox.hh
index 96cb2158b90912c96353dd094102d229e69a3510..4649f7a965505d0a4ab906332e4ba75f702954d7 100644 (file)
--- a/src/openbox.hh
+++ b/src/openbox.hh
@@ -10,6 +10,7 @@ extern "C" {
 #include <vector>
 
 #include "otk/screeninfo.hh"
+#include "timer.hh"
 
 namespace ob {
 
@@ -34,6 +35,9 @@ private:
   char *_displayreq;         // display requested by the user
   char *_argv0;              // argv[0], how the program was called
 
+  OBTimerQueueManager _timermanager; // manages timers, so that they fire when
+                                     // their time elapses
+
   RunState _state;           // the state of the window manager
 
   ScreenInfoList _screenInfoList; // info for all screens on the display
@@ -58,6 +62,8 @@ public:
   //! Returns the state of the window manager (starting, exiting, etc).
   inline RunState state() const { return _state; }
 
+  inline OBTimerQueueManager *timerManager() { return &_timermanager; }
+
   void eventLoop();
 
   // XXX: TEMPORARY!#!@%*!^#*!#!#!

diff --git a/src/timer.cc b/src/timer.cc
index 9066fd010563e54b9d5bdf3b73227f5a624bfc49..856ac8f7141fa2a1f3e844da8879d60ddf2296a1 100644 (file)
--- a/src/timer.cc
+++ b/src/timer.cc
@@ -5,66 +5,66 @@
 #endif // HAVE_CONFIG_H
 
 #include "otk/display.hh"
+#include "openbox.hh"
 #include "timer.hh"
 #include "util.hh"
 
 namespace ob {
 
-BTimer::BTimer(OBTimerQueueManager *m, TimeoutHandler *h) {
-  manager = m;
+OBTimer::OBTimer(TimeoutHandler *h) {
   handler = h;
 
   recur = timing = False;
 }
 
 
-BTimer::~BTimer(void) {
+OBTimer::~OBTimer(void) {
   if (timing) stop();
 }
 
 
-void BTimer::setTimeout(long t) {
+void OBTimer::setTimeout(long t) {
   _timeout.tv_sec = t / 1000;
   _timeout.tv_usec = t % 1000;
   _timeout.tv_usec *= 1000;
 }
 
 
-void BTimer::setTimeout(const timeval &t) {
+void OBTimer::setTimeout(const timeval &t) {
   _timeout.tv_sec = t.tv_sec;
   _timeout.tv_usec = t.tv_usec;
 }
 
 
-void BTimer::start(void) {
+void OBTimer::start(void) {
   gettimeofday(&_start, 0);
 
   if (! timing) {
     timing = True;
-    manager->addTimer(this);
+    Openbox::instance->timerManager()->addTimer(this);
   }
 }
 
 
-void BTimer::stop(void) {
+void OBTimer::stop(void) {
   timing = False;
 
-  manager->removeTimer(this);
+  Openbox::instance->timerManager()->removeTimer(this);
 }
 
 
-void BTimer::halt(void) {
+void OBTimer::halt(void) {
   timing = False;
 }
 
 
-void BTimer::fireTimeout(void) {
+void OBTimer::fireTimeout(void) {
   if (handler)
     handler->timeout();
 }
 
 
-timeval BTimer::timeRemaining(const timeval &tm) const {
+timeval OBTimer::timeRemaining(const timeval &tm) const {
   timeval ret = endpoint();
 
   ret.tv_sec  -= tm.tv_sec;
@@ -74,7 +74,7 @@ timeval BTimer::timeRemaining(const timeval &tm) const {
 }
 
 
-timeval BTimer::endpoint(void) const {
+timeval OBTimer::endpoint(void) const {
   timeval ret;
 
   ret.tv_sec = _start.tv_sec + _timeout.tv_sec;
@@ -84,7 +84,7 @@ timeval BTimer::endpoint(void) const {
 }
 
 
-bool BTimer::shouldFire(const timeval &tm) const {
+bool OBTimer::shouldFire(const timeval &tm) const {
   timeval end = endpoint();
 
   return ! ((tm.tv_sec < end.tv_sec) ||
@@ -92,7 +92,7 @@ bool BTimer::shouldFire(const timeval &tm) const {
 }
 
 
-void OBTimerQueueManager::go()
+void OBTimerQueueManager::fire()
 {
   fd_set rfds;
   timeval now, tm, *timeout = (timeval *) 0;
@@ -103,7 +103,7 @@ void OBTimerQueueManager::go()
   FD_SET(xfd, &rfds); // break on any x events
 
   if (! timerList.empty()) {
-    const BTimer* const timer = timerList.top();
+    const OBTimer* const timer = timerList.top();
 
     gettimeofday(&now, 0);
     tm = timer->timeRemaining(now);
@@ -121,7 +121,7 @@ void OBTimerQueueManager::go()
   // timer->start() and timer->shouldFire() is within the timer's period
   // then the timer will keep firing.  This should be VERY near impossible.
   while (! timerList.empty()) {
-    BTimer *timer = timerList.top();
+    OBTimer *timer = timerList.top();
     if (! timer->shouldFire(now))
       break;
 
@@ -135,13 +135,13 @@ void OBTimerQueueManager::go()
 }
 
 
-void OBTimerQueueManager::addTimer(BTimer *timer)
+void OBTimerQueueManager::addTimer(OBTimer *timer)
 {
   assert(timer);
   timerList.push(timer);
 }
 
-void OBTimerQueueManager::removeTimer(BTimer* timer)
+void OBTimerQueueManager::removeTimer(OBTimer* timer)
 {
   assert(timer);
   timerList.release(timer);

diff --git a/src/timer.hh b/src/timer.hh
index 2eb5065f0106c8df5f2d314919f395d283ea0d04..774d0e49c385743e0ae476ddfccd5cf1da4bbb53 100644 (file)
--- a/src/timer.hh
+++ b/src/timer.hh
@@ -29,20 +29,19 @@ public:
   virtual void timeout(void) = 0;
 };
 
-class BTimer {
+class OBTimer {
 private:
-  OBTimerQueueManager *manager;
   TimeoutHandler *handler;
   bool timing, recur;
 
   timeval _start, _timeout;
 
-  BTimer(const BTimer&);
-  BTimer& operator=(const BTimer&);
+  OBTimer(const OBTimer&);
+  OBTimer& operator=(const OBTimer&);
 
 public:
-  BTimer(OBTimerQueueManager *m, TimeoutHandler *h);
-  virtual ~BTimer(void);
+  OBTimer(TimeoutHandler *h);
+  virtual ~OBTimer(void);
 
   void fireTimeout(void);
 
@@ -65,7 +64,7 @@ public:
   void stop(void);   // manager releases timer
   void halt(void);   // halts the timer
 
-  bool operator<(const BTimer& other) const
+  bool operator<(const OBTimer& other) const
   { return shouldFire(other.endpoint()); }
 };
 
@@ -95,12 +94,13 @@ private:
 };
 
 struct TimerLessThan {
-  bool operator()(const BTimer* const l, const BTimer* const r) const {
+  bool operator()(const OBTimer* const l, const OBTimer* const r) const {
     return *r < *l;
   }
 };
 
-typedef _timer_queue<BTimer*, std::vector<BTimer*>, TimerLessThan> TimerQueue;
+typedef _timer_queue<OBTimer*,
+                     std::vector<OBTimer*>, TimerLessThan> TimerQueue;
 
 class OBTimerQueueManager {
 private:
@@ -108,11 +108,15 @@ private:
 public:
   OBTimerQueueManager() {}
   virtual ~OBTimerQueueManager() {}
+
+  //! Will wait for and fire the next timer in the queue.
+  /*!
+    The function will stop waiting if an event is received from the X server.
+  */
+  virtual void fire();
   
-  virtual void go();
-  
-  virtual void addTimer(BTimer* timer);
-  virtual void removeTimer(BTimer* timer);
+  virtual void addTimer(OBTimer* timer);
+  virtual void removeTimer(OBTimer* timer);
 };
 
 }

diff --git a/src/window.cc b/src/window.cc
index 94589a2dd72e5af29010449476a7ea7d5a6d905f..2e7ba087488534bdb72605a98790c49a6b200477 100644 (file)
--- a/src/window.cc
+++ b/src/window.cc
@@ -135,7 +135,7 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
 
   lastButtonPressTime = 0;
 
-  timer = new BTimer(blackbox, this);
+  timer = new OBTimer(this);
   timer->setTimeout(blackbox->getAutoRaiseDelay());
 
   // get size, aspect, minimum/maximum size and other hints set by the

diff --git a/src/window.hh b/src/window.hh
index 4070cffe3789ca80475f2a6d38acbf7bb232d58a..c8ccc3414afbfeeca4bc95c71d79e76a97f488c9 100644 (file)
--- a/src/window.hh
+++ b/src/window.hh
@@ -105,7 +105,7 @@ private:
   Blackbox *blackbox;
   BScreen *screen;
   XAtom *xatom;
-  BTimer *timer;
+  OBTimer *timer;
   BlackboxAttributes blackbox_attrib;
 
   Time lastButtonPressTime;  // used for double clicks, when were we clicked