new timer infrastructure. takes a function pointer for the timeout, with a void* parameter (useful for holding a class instance!)

11 files changed, 29 insertions, 321 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 4a5ea177..314d265f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -16,7 +16,7 @@ bin_PROGRAMS= openbox
 openbox_LDADD=../otk/libotk.a @LIBINTL@
 
 openbox_SOURCES= configuration.cc screen.cc openbox.cc \
-                 timer.cc util.cc window.cc workspace.cc xatom.cc blackbox.cc \
+                 util.cc window.cc workspace.cc xatom.cc blackbox.cc \
                  main.cc
 
 MAINTAINERCLEANFILES= Makefile.in
diff --git a/src/blackbox.cc b/src/blackbox.cc
index 90d0d3cc..6d267b53 100644
--- a/src/blackbox.cc
+++ b/src/blackbox.cc
@@ -158,7 +158,9 @@ Blackbox::Blackbox(int argc, char **m_argv, char *rc)
 
   reconfigure_wait = False;
 
-  timer = new OBTimer(this);
+  timer = new otk::OBTimer(Openbox::instance->timerManager(),
+                           (otk::OBTimeoutHandler)timeout,
+                           this);
   timer->setTimeout(0l);
 }
 
@@ -1151,11 +1153,11 @@ void Blackbox::saveStyleFilename(const string& filename) {
 }
 
 
-void Blackbox::timeout(void) {
-  if (reconfigure_wait)
-    real_reconfigure();
+void Blackbox::timeout(Blackbox *t) {
+  if (t->reconfigure_wait)
+    t->real_reconfigure();
 
-  reconfigure_wait = False;
+  t->reconfigure_wait = False;
 }
 
 
diff --git a/src/blackbox.hh b/src/blackbox.hh
index 947c0a99..00f70cb9 100644
--- a/src/blackbox.hh
+++ b/src/blackbox.hh
@@ -25,6 +25,7 @@ extern "C" {
 #include <map>
 #include <string>
 
+#include "otk/timer.hh"
 #include "openbox.hh"
 #include "configuration.hh"
 #include "timer.hh"
@@ -69,7 +70,7 @@ class Blackbox;
 class BlackboxWindow;
 class BWindowGroup;
 
-class Blackbox : public Openbox, public TimeoutHandler {
+class Blackbox : public Openbox {
 private:
   struct BCursor {
     Cursor session, move, ll_angle, lr_angle, ul_angle, ur_angle;
@@ -109,7 +110,7 @@ private:
 
   BScreen *active_screen;
   BlackboxWindow *focused_window, *changing_window;
-  OBTimer *timer;
+  otk::OBTimer *timer;
   Configuration config;
   XAtom *xatom;
 
@@ -213,7 +214,7 @@ public:
 
   virtual bool handleSignal(int sig);
 
-  virtual void timeout(void);
+  static void timeout(Blackbox *t);
 
   enum { B_AmericanDate = 1, B_EuropeanDate };
 };
diff --git a/src/openbox.hh b/src/openbox.hh
index 4649f7a9..76a7d973 100644
--- a/src/openbox.hh
+++ b/src/openbox.hh
@@ -10,7 +10,7 @@ extern "C" {
 #include <vector>
 
 #include "otk/screeninfo.hh"
-#include "timer.hh"
+#include "otk/timer.hh"
 
 namespace ob {
 
@@ -35,8 +35,8 @@ 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
+  otk::OBTimerQueueManager _timermanager; // manages timers, so that they fire
+                                          // when their time elapses
 
   RunState _state;           // the state of the window manager
 
@@ -62,7 +62,7 @@ public:
   //! Returns the state of the window manager (starting, exiting, etc).
   inline RunState state() const { return _state; }
 
-  inline OBTimerQueueManager *timerManager() { return &_timermanager; }
+  inline otk::OBTimerQueueManager *timerManager() { return &_timermanager; }
 
   void eventLoop();
 
diff --git a/src/screen.cc b/src/screen.cc
index 7ac74c3c..f8b998e6 100644
--- a/src/screen.cc
+++ b/src/screen.cc
@@ -132,7 +132,8 @@ BScreen::BScreen(Blackbox *bb, unsigned int scrn) : ScreenInfo(scrn) {
   updateAvailableArea();
 
   image_control =
-    new otk::BImageControl(this, True, blackbox->getColorsPerChannel(),
+    new otk::BImageControl(Openbox::instance->timerManager(),
+                           this, True, blackbox->getColorsPerChannel(),
                            blackbox->getCacheLife(), blackbox->getCacheMax());
   image_control->installRootColormap();
   root_colormap_installed = True;
@@ -779,7 +780,7 @@ void BScreen::reconfigure(void) {
       bw->reconfigure();
   }
 
-  image_control->timeout();
+  otk::BImageControl::timeout(image_control);
 }
 
 
diff --git a/src/timer.cc b/src/timer.cc
deleted file mode 100644
index 856ac8f7..00000000
--- a/src/timer.cc
+++ /dev/null
@@ -1,150 +0,0 @@
-// -*- mode: C++; indent-tabs-mode: nil; -*-
-
-#ifdef    HAVE_CONFIG_H
-#  include "../config.h"
-#endif // HAVE_CONFIG_H
-
-#include "otk/display.hh"
-#include "openbox.hh"
-#include "timer.hh"
-#include "util.hh"
-
-namespace ob {
-
-OBTimer::OBTimer(TimeoutHandler *h) {
-  handler = h;
-
-  recur = timing = False;
-}
-
-
-OBTimer::~OBTimer(void) {
-  if (timing) stop();
-}
-
-
-void OBTimer::setTimeout(long t) {
-  _timeout.tv_sec = t / 1000;
-  _timeout.tv_usec = t % 1000;
-  _timeout.tv_usec *= 1000;
-}
-
-
-void OBTimer::setTimeout(const timeval &t) {
-  _timeout.tv_sec = t.tv_sec;
-  _timeout.tv_usec = t.tv_usec;
-}
-
-
-void OBTimer::start(void) {
-  gettimeofday(&_start, 0);
-
-  if (! timing) {
-    timing = True;
-    Openbox::instance->timerManager()->addTimer(this);
-  }
-}
-
-
-void OBTimer::stop(void) {
-  timing = False;
-
-  Openbox::instance->timerManager()->removeTimer(this);
-}
-
-
-void OBTimer::halt(void) {
-  timing = False;
-}
-
-
-void OBTimer::fireTimeout(void) {
-  if (handler)
-    handler->timeout();
-}
-
-
-timeval OBTimer::timeRemaining(const timeval &tm) const {
-  timeval ret = endpoint();
-
-  ret.tv_sec  -= tm.tv_sec;
-  ret.tv_usec -= tm.tv_usec;
-
-  return normalizeTimeval(ret);
-}
-
-
-timeval OBTimer::endpoint(void) const {
-  timeval ret;
-
-  ret.tv_sec = _start.tv_sec + _timeout.tv_sec;
-  ret.tv_usec = _start.tv_usec + _timeout.tv_usec;
-
-  return normalizeTimeval(ret);
-}
-
-
-bool OBTimer::shouldFire(const timeval &tm) const {
-  timeval end = endpoint();
-
-  return ! ((tm.tv_sec < end.tv_sec) ||
-            (tm.tv_sec == end.tv_sec && tm.tv_usec < end.tv_usec));
-}
-
-
-void OBTimerQueueManager::fire()
-{
-  fd_set rfds;
-  timeval now, tm, *timeout = (timeval *) 0;
-
-  const int xfd = ConnectionNumber(otk::OBDisplay::display);
-  
-  FD_ZERO(&rfds);
-  FD_SET(xfd, &rfds); // break on any x events
-
-  if (! timerList.empty()) {
-    const OBTimer* 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()) {
-    OBTimer *timer = timerList.top();
-    if (! timer->shouldFire(now))
-      break;
-
-    timerList.pop();
-
-    timer->fireTimeout();
-    timer->halt();
-    if (timer->isRecurring())
-      timer->start();
-  }
-}
-
-
-void OBTimerQueueManager::addTimer(OBTimer *timer)
-{
-  assert(timer);
-  timerList.push(timer);
-}
-
-void OBTimerQueueManager::removeTimer(OBTimer* timer)
-{
-  assert(timer);
-  timerList.release(timer);
-}
-
-}
diff --git a/src/timer.hh b/src/timer.hh
deleted file mode 100644
index 774d0e49..00000000
--- a/src/timer.hh
+++ /dev/null
@@ -1,124 +0,0 @@
-// -*- mode: C++; indent-tabs-mode: nil; -*-
-#ifndef   _BLACKBOX_Timer_hh
-#define   _BLACKBOX_Timer_hh
-
-extern "C" {
-#ifdef    TIME_WITH_SYS_TIME
-#  include <sys/time.h>
-#  include <time.h>
-#else // !TIME_WITH_SYS_TIME
-#  ifdef    HAVE_SYS_TIME_H
-#    include <sys/time.h>
-#  else // !HAVE_SYS_TIME_H
-#    include <time.h>
-#  endif // HAVE_SYS_TIME_H
-#endif // TIME_WITH_SYS_TIME
-}
-
-#include <queue>
-#include <algorithm>
-#include <vector>
-
-namespace ob {
-
-// forward declaration
-class OBTimerQueueManager;
-
-class TimeoutHandler {
-public:
-  virtual void timeout(void) = 0;
-};
-
-class OBTimer {
-private:
-  TimeoutHandler *handler;
-  bool timing, recur;
-
-  timeval _start, _timeout;
-
-  OBTimer(const OBTimer&);
-  OBTimer& operator=(const OBTimer&);
-
-public:
-  OBTimer(TimeoutHandler *h);
-  virtual ~OBTimer(void);
-
-  void fireTimeout(void);
-
-  inline bool isTiming(void) const { return timing; }
-  inline bool isRecurring(void) const { return recur; }
-
-  inline const timeval &getTimeout(void) const { return _timeout; }
-  inline const timeval &getStartTime(void) const { return _start; }
-
-  timeval timeRemaining(const timeval &tm) const;
-  bool shouldFire(const timeval &tm) const;
-  timeval endpoint(void) const;
-
-  inline void recurring(bool b) { recur = b; }
-
-  void setTimeout(long t);
-  void setTimeout(const timeval &t);
-
-  void start(void);  // manager acquires timer
-  void stop(void);   // manager releases timer
-  void halt(void);   // halts the timer
-
-  bool operator<(const OBTimer& other) const
-  { return shouldFire(other.endpoint()); }
-};
-
-
-template <class _Tp, class _Sequence, class _Compare>
-class _timer_queue: protected std::priority_queue<_Tp, _Sequence, _Compare> {
-public:
-  typedef std::priority_queue<_Tp, _Sequence, _Compare> _Base;
-
-  _timer_queue(void): _Base() {}
-  ~_timer_queue(void) {}
-
-  void release(const _Tp& value) {
-    c.erase(std::remove(c.begin(), c.end(), value), c.end());
-    // after removing the item we need to make the heap again
-    std::make_heap(c.begin(), c.end(), comp);
-  }
-  bool empty(void) const { return _Base::empty(); }
-  size_t size(void) const { return _Base::size(); }
-  void push(const _Tp& value) { _Base::push(value); }
-  void pop(void) { _Base::pop(); }
-  const _Tp& top(void) const { return _Base::top(); }
-private:
-  // no copying!
-  _timer_queue(const _timer_queue&) {}
-  _timer_queue& operator=(const _timer_queue&) {}
-};
-
-struct TimerLessThan {
-  bool operator()(const OBTimer* const l, const OBTimer* const r) const {
-    return *r < *l;
-  }
-};
-
-typedef _timer_queue<OBTimer*,
-                     std::vector<OBTimer*>, TimerLessThan> TimerQueue;
-
-class OBTimerQueueManager {
-private:
-  TimerQueue timerList;
-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 addTimer(OBTimer* timer);
-  virtual void removeTimer(OBTimer* timer);
-};
-
-}
-
-#endif // _BLACKBOX_Timer_hh
diff --git a/src/util.cc b/src/util.cc
index 6a6ac417..77913952 100644
--- a/src/util.cc
+++ b/src/util.cc
@@ -83,29 +83,6 @@ string textPropertyToString(Display *display, XTextProperty& text_prop) {
 }
 
 
-timeval normalizeTimeval(const timeval &tm) {
-  timeval ret = tm;
-
-  while (ret.tv_usec < 0) {
-    if (ret.tv_sec > 0) {
-      --ret.tv_sec;
-      ret.tv_usec += 1000000;
-    } else {
-      ret.tv_usec = 0;
-    }
-  }
-
-  if (ret.tv_usec >= 1000000) {
-    ret.tv_sec += ret.tv_usec / 1000000;
-    ret.tv_usec %= 1000000;
-  }
-
-  if (ret.tv_sec < 0) ret.tv_sec = 0;
-
-  return ret;
-}
-
-
 string itostring(unsigned long i) {
   if (i == 0)
     return string("0");
diff --git a/src/util.hh b/src/util.hh
index 1e17657e..b6da7520 100644
--- a/src/util.hh
+++ b/src/util.hh
@@ -39,8 +39,6 @@ void bexec(const std::string& command, const std::string& displaystring);
 
 std::string textPropertyToString(Display *display, XTextProperty& text_prop);
 
-timeval normalizeTimeval(const timeval &tm);
-
 std::string itostring(unsigned long i);
 std::string itostring(long i);
 inline std::string itostring(unsigned int i)
diff --git a/src/window.cc b/src/window.cc
index 2e7ba087..035d2469 100644
--- a/src/window.cc
+++ b/src/window.cc
@@ -135,7 +135,9 @@ BlackboxWindow::BlackboxWindow(Blackbox *b, Window w, BScreen *s) {
 
   lastButtonPressTime = 0;
 
-  timer = new OBTimer(this);
+  timer = new otk::OBTimer(Openbox::instance->timerManager(),
+                           (otk::OBTimeoutHandler)timeout,
+                           this);
   timer->setTimeout(blackbox->getAutoRaiseDelay());
 
   // get size, aspect, minimum/maximum size and other hints set by the
@@ -3902,8 +3904,9 @@ void BlackboxWindow::restore(bool remap) {
 
 
 // timer for autoraise
-void BlackboxWindow::timeout(void) {
-  screen->getWorkspace(blackbox_attrib.workspace)->raiseWindow(this);
+void BlackboxWindow::timeout(BlackboxWindow *t) {
+  t->screen->getWorkspace(t->blackbox_attrib.workspace)->raiseWindow(t);
+  printf("TIMED OUT YA YAY\n");
 }
 
 
diff --git a/src/window.hh b/src/window.hh
index c8ccc341..29818b43 100644
--- a/src/window.hh
+++ b/src/window.hh
@@ -12,8 +12,8 @@ extern "C" {
 
 #include <string>
 
+#include "otk/timer.hh"
 #include "blackbox.hh"
-#include "timer.hh"
 #include "util.hh"
 
 #define MwmHintsFunctions     (1l << 0)
@@ -70,7 +70,7 @@ public:
 };
 
 
-class BlackboxWindow : public TimeoutHandler {
+class BlackboxWindow {
 public:
   enum Function { Func_Resize   = (1l << 0),
                   Func_Move     = (1l << 1),
@@ -105,7 +105,7 @@ private:
   Blackbox *blackbox;
   BScreen *screen;
   XAtom *xatom;
-  OBTimer *timer;
+  otk::OBTimer *timer;
   BlackboxAttributes blackbox_attrib;
 
   Time lastButtonPressTime;  // used for double clicks, when were we clicked
@@ -405,7 +405,7 @@ public:
   void shapeEvent(XShapeEvent * /*unused*/);
 #endif // SHAPE
 
-  virtual void timeout(void);
+  static void timeout(BlackboxWindow *t);
 };
 
 }