# Makefile.am for Openbox
-SUBDIRS = intl po m4 data doc otk src util
+SUBDIRS = intl po m4 data doc otk src
MAINTAINERCLEANFILES = aclocal.m4 config.h.in configure Makefile.in stamp-h.in
uninstall-local:
noinst_LIBRARIES=libotk.a
libotk_a_SOURCES= color.cc display.cc font.cc gccache.cc image.cc \
- imagecontrol.cc rect.cc screeninfo.cc texture.cc
+ imagecontrol.cc rect.cc screeninfo.cc texture.cc timer.cc
MAINTAINERCLEANFILES= Makefile.in
rm -f *\~ *.orig *.rej .\#*
# local dependencies
-color.o: color.cc color.hh ../src/basedisplay.hh ../src/timer.hh ../src/util.hh
-font.o: font.cc font.hh ../src/screen.hh color.hh texture.hh ../src/util.hh image.hh \
- ../src/timer.hh ../src/basedisplay.hh ../src/workspace.hh ../src/xatom.hh ../src/blackbox.hh \
- ../src/configuration.hh gccache.hh
-gccache.o: gccache.cc gccache.hh ../src/basedisplay.hh ../src/timer.hh ../src/util.hh \
- color.hh
-image.o: image.cc ../src/blackbox.hh ../src/basedisplay.hh ../src/timer.hh ../src/util.hh \
- ../src/configuration.hh ../src/xatom.hh gccache.hh color.hh image.hh texture.hh
-imagecontrol.o: imagecontrol.cc ../src/blackbox.hh ../src/basedisplay.hh ../src/timer.hh \
- ../src/util.hh ../src/configuration.hh ../src/xatom.hh color.hh image.hh texture.hh
-texture.o: texture.cc texture.hh color.hh ../src/util.hh ../src/basedisplay.hh \
- ../src/timer.hh image.hh ../src/screen.hh ../src/workspace.hh ../src/xatom.hh \
- ../src/blackbox.hh ../src/configuration.hh
+color.o: color.cc color.hh display.hh screeninfo.hh rect.hh
+gccache.o: gccache.cc gccache.hh display.hh color.hh assassin.hh \
+ screeninfo.hh rect.hh
+rect.o: rect.cc rect.hh
#include "color.hh"
#include "screeninfo.hh"
-#include "src/timer.hh"
+#include "timer.hh"
namespace otk {
};
-class BImageControl : public ob::TimeoutHandler {
+class BImageControl {
public:
struct CachedImage {
Pixmap pixmap;
unsigned long pixel1, pixel2, texture;
};
- BImageControl(const ScreenInfo *scrn,
+ BImageControl(OBTimerQueueManager *timermanager,
+ const ScreenInfo *scrn,
bool _dither= False, int _cpc = 4,
unsigned long cache_timeout = 300000l,
unsigned long cmax = 200l);
void setDither(bool d) { dither = d; }
void setColorsPerChannel(int cpc);
- virtual void timeout(void);
+ static void timeout(BImageControl *t);
private:
bool dither;
const ScreenInfo *screeninfo;
- ob::OBTimer *timer;
+ OBTimer *timer;
Colormap colormap;
BImageControl *ctrl = 0;
-BImageControl::BImageControl(const ScreenInfo *scrn,
+BImageControl::BImageControl(OBTimerQueueManager *timermanager,
+ const ScreenInfo *scrn,
bool _dither, int _cpc,
unsigned long cache_timeout,
unsigned long cmax) {
cache_max = cmax;
if (cache_timeout) {
- // XXX: FIX THIS
- timer = 0;/*new BTimer(this);
+ timer = new OBTimer(timermanager, (OBTimeoutHandler)timeout, this);
timer->setTimeout(cache_timeout);
- timer->start();*/
+ timer->start();
} else {
- timer = (ob::OBTimer *) 0;
+ timer = (OBTimer *) 0;
}
colors = (XColor *) 0;
"forcing cleanout\n");
#endif // DEBUG
- timeout();
+ timeout(this);
}
return pixmap;
}
if (! timer)
- timeout();
+ timeout(this);
}
};
-void BImageControl::timeout(void) {
+void BImageControl::timeout(BImageControl *t) {
CacheCleaner cleaner;
- std::for_each(cache.begin(), cache.end(), cleaner);
- cache.remove_if(cleaner.ref_check);
+ std::for_each(t->cache.begin(), t->cache.end(), cleaner);
+ t->cache.remove_if(cleaner.ref_check);
}
}
# include "../config.h"
#endif // HAVE_CONFIG_H
-#include "otk/display.hh"
-#include "openbox.hh"
#include "timer.hh"
+#include "display.hh"
#include "util.hh"
-namespace ob {
+namespace otk {
-OBTimer::OBTimer(TimeoutHandler *h) {
+static 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;
+}
+
+
+OBTimer::OBTimer(OBTimerQueueManager *m, OBTimeoutHandler h, OBTimeoutData d)
+{
+ manager = m;
handler = h;
+ data = d;
recur = timing = False;
}
-OBTimer::~OBTimer(void) {
+OBTimer::~OBTimer(void)
+{
if (timing) stop();
}
-void OBTimer::setTimeout(long t) {
+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) {
+void OBTimer::setTimeout(const timeval &t)
+{
_timeout.tv_sec = t.tv_sec;
_timeout.tv_usec = t.tv_usec;
}
-void OBTimer::start(void) {
+void OBTimer::start(void)
+{
gettimeofday(&_start, 0);
if (! timing) {
timing = True;
- Openbox::instance->timerManager()->addTimer(this);
+ manager->addTimer(this);
}
}
-void OBTimer::stop(void) {
+void OBTimer::stop(void)
+{
timing = False;
- Openbox::instance->timerManager()->removeTimer(this);
+ manager->removeTimer(this);
}
-void OBTimer::halt(void) {
+void OBTimer::halt(void)
+{
timing = False;
}
-void OBTimer::fireTimeout(void) {
+void OBTimer::fireTimeout(void)
+{
if (handler)
- handler->timeout();
+ handler(data);
}
-timeval OBTimer::timeRemaining(const timeval &tm) const {
+timeval OBTimer::timeRemaining(const timeval &tm) const
+{
timeval ret = endpoint();
ret.tv_sec -= tm.tv_sec;
}
-timeval OBTimer::endpoint(void) const {
+timeval OBTimer::endpoint(void) const
+{
timeval ret;
ret.tv_sec = _start.tv_sec + _timeout.tv_sec;
}
-bool OBTimer::shouldFire(const timeval &tm) const {
+bool OBTimer::shouldFire(const timeval &tm) const
+{
timeval end = endpoint();
return ! ((tm.tv_sec < end.tv_sec) ||
#include <algorithm>
#include <vector>
-namespace ob {
+namespace otk {
// forward declaration
class OBTimerQueueManager;
-class TimeoutHandler {
-public:
- virtual void timeout(void) = 0;
-};
+typedef void *OBTimeoutData;
+typedef void (*OBTimeoutHandler)(OBTimeoutData);
class OBTimer {
private:
- TimeoutHandler *handler;
+ OBTimerQueueManager *manager;
+ OBTimeoutHandler handler;
+ OBTimeoutData data;
bool timing, recur;
timeval _start, _timeout;
OBTimer& operator=(const OBTimer&);
public:
- OBTimer(TimeoutHandler *h);
- virtual ~OBTimer(void);
+ OBTimer(OBTimerQueueManager *m, OBTimeoutHandler h, OBTimeoutData d);
+ virtual ~OBTimer();
- void fireTimeout(void);
+ void fireTimeout();
- inline bool isTiming(void) const { return timing; }
- inline bool isRecurring(void) const { return recur; }
+ inline bool isTiming() const { return timing; }
+ inline bool isRecurring() const { return recur; }
- inline const timeval &getTimeout(void) const { return _timeout; }
- inline const timeval &getStartTime(void) const { return _start; }
+ inline const timeval &getTimeout() const { return _timeout; }
+ inline const timeval &getStartTime() const { return _start; }
timeval timeRemaining(const timeval &tm) const;
bool shouldFire(const timeval &tm) const;
- timeval endpoint(void) const;
+ timeval endpoint() 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
+ void start(); // manager acquires timer
+ void stop(); // manager releases timer
+ void halt(); // halts the timer
bool operator<(const OBTimer& other) const
{ return shouldFire(other.endpoint()); }
public:
typedef std::priority_queue<_Tp, _Sequence, _Compare> _Base;
- _timer_queue(void): _Base() {}
- ~_timer_queue(void) {}
+ _timer_queue(): _Base() {}
+ ~_timer_queue() {}
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(); }
+ bool empty() const { return _Base::empty(); }
+ size_t size() 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(); }
+ void pop() { _Base::pop(); }
+ const _Tp& top() const { return _Base::top(); }
private:
// no copying!
_timer_queue(const _timer_queue&) {}
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
reconfigure_wait = False;
- timer = new OBTimer(this);
+ timer = new otk::OBTimer(Openbox::instance->timerManager(),
+ (otk::OBTimeoutHandler)timeout,
+ this);
timer->setTimeout(0l);
}
}
-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;
}
#include <map>
#include <string>
+#include "otk/timer.hh"
#include "openbox.hh"
#include "configuration.hh"
#include "timer.hh"
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;
BScreen *active_screen;
BlackboxWindow *focused_window, *changing_window;
- OBTimer *timer;
+ otk::OBTimer *timer;
Configuration config;
XAtom *xatom;
virtual bool handleSignal(int sig);
- virtual void timeout(void);
+ static void timeout(Blackbox *t);
enum { B_AmericanDate = 1, B_EuropeanDate };
};
#include <vector>
#include "otk/screeninfo.hh"
-#include "timer.hh"
+#include "otk/timer.hh"
namespace ob {
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
//! 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();
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;
bw->reconfigure();
}
- image_control->timeout();
+ otk::BImageControl::timeout(image_control);
}
}
-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");
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)
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
// 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");
}
#include <string>
+#include "otk/timer.hh"
#include "blackbox.hh"
-#include "timer.hh"
#include "util.hh"
#define MwmHintsFunctions (1l << 0)
};
-class BlackboxWindow : public TimeoutHandler {
+class BlackboxWindow {
public:
enum Function { Func_Resize = (1l << 0),
Func_Move = (1l << 1),
Blackbox *blackbox;
BScreen *screen;
XAtom *xatom;
- OBTimer *timer;
+ otk::OBTimer *timer;
BlackboxAttributes blackbox_attrib;
Time lastButtonPressTime; // used for double clicks, when were we clicked
void shapeEvent(XShapeEvent * /*unused*/);
#endif // SHAPE
- virtual void timeout(void);
+ static void timeout(BlackboxWindow *t);
};
}