event.c for the Openbox window manager
Copyright (c) 2006 Mikael Magnusson
- Copyright (c) 2003 Ben Jansens
+ Copyright (c) 2003-2007 Dana Jansens
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "group.h"
#include "stacking.h"
#include "extensions.h"
+#include "translate.h"
#include <X11/Xlib.h>
#include <X11/keysym.h>
gboolean ignored;
} ObEventData;
+typedef struct
+{
+ ObClient *client;
+ Time time;
+} ObFocusDelayData;
+
static void event_process(const XEvent *e, gpointer data);
-static void event_client_dest(ObClient *client, gpointer data);
static void event_handle_root(XEvent *e);
+static void event_handle_menu_shortcut(XEvent *e);
static void event_handle_menu(XEvent *e);
static void event_handle_dock(ObDock *s, XEvent *e);
static void event_handle_dockapp(ObDockApp *app, XEvent *e);
static void event_handle_client(ObClient *c, XEvent *e);
static void event_handle_group(ObGroup *g, XEvent *e);
+static void focus_delay_dest(gpointer data);
+static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2);
static gboolean focus_delay_func(gpointer data);
static void focus_delay_client_dest(ObClient *client, gpointer data);
static gboolean menu_hide_delay_func(gpointer data);
-/* The most recent time at which an event with a timestamp occured. */
-static Time event_lasttime = 0;
-/* The time for the current event being processed
- (it's the event_lasttime for events without times, if this is a bug then
- use CurrentTime instead, but it seems ok) */
+/* The time for the current event being processed */
Time event_curtime = CurrentTime;
/*! The value of the mask for the NumLock modifier */
#endif
client_add_destructor(focus_delay_client_dest, NULL);
- client_add_destructor(event_client_dest, NULL);
}
void event_shutdown(gboolean reconfig)
#endif
client_remove_destructor(focus_delay_client_dest);
- client_remove_destructor(event_client_dest);
XFreeModifiermap(modmap);
}
window = None;
}
} else
+#endif
+#ifdef SYNC
+ if (extensions_sync &&
+ e->type == extensions_sync_event_basep + XSyncAlarmNotify)
+ {
+ window = None;
+ } else
#endif
window = e->xany.window;
}
return window;
}
-static void event_set_lasttime(XEvent *e)
+static void event_set_curtime(XEvent *e)
{
- Time t = 0;
+ Time t = CurrentTime;
/* grab the lasttime and hack up the state */
switch (e->type) {
t = e->xcrossing.time;
break;
default:
+#ifdef SYNC
+ if (extensions_sync &&
+ e->type == extensions_sync_event_basep + XSyncAlarmNotify)
+ {
+ t = ((XSyncAlarmNotifyEvent*)e)->time;
+ }
+#endif
/* if more event types are anticipated, get their timestamp
explicitly */
break;
}
- if (t > event_lasttime) {
- event_lasttime = t;
- event_curtime = event_lasttime;
- } else if (t == 0) {
- event_curtime = event_lasttime;
- } else {
- event_curtime = t;
- }
+ event_curtime = t;
}
#define STRIP_MODS(s) \
{
gint mode = e->xfocus.mode;
gint detail = e->xfocus.detail;
+ Window win = e->xany.window;
if (e->type == FocusIn) {
/* These are the ones we want.. */
+ if (win == RootWindow(ob_display, ob_screen)) {
+ /* This means focus reverted off of a client */
+ if (detail == NotifyPointerRoot || detail == NotifyDetailNone ||
+ detail == NotifyInferior)
+ return TRUE;
+ else
+ return FALSE;
+ }
+
/* This means focus moved from the root window to a client */
if (detail == NotifyVirtual)
return TRUE;
if (mode == NotifyGrab)
return FALSE;
+ /* Focus left the root window revertedto state */
+ if (win == RootWindow(ob_display, ob_screen))
+ return FALSE;
+
/* These are the ones we want.. */
/* This means focus moved from a client to the root window */
/* This means focus moved from one client to another */
if (detail == NotifyNonlinearVirtual)
return TRUE;
+ /* This means focus had moved to our frame window and now moved off */
+ if (detail == NotifyNonlinear)
+ return TRUE;
/* Otherwise.. */
return FALSE;
static gboolean event_ignore(XEvent *e, ObClient *client)
{
switch(e->type) {
- case EnterNotify:
- case LeaveNotify:
- if (e->xcrossing.detail == NotifyInferior)
+ case FocusIn:
+ if (!wanted_focusevent(e))
return TRUE;
break;
- case FocusIn:
case FocusOut:
- /* I don't think this should ever happen with our event masks, but
- if it does, we don't want it. */
- if (client == NULL)
- return TRUE;
if (!wanted_focusevent(e))
return TRUE;
break;
}
}
-#if 0 /* focus debugging stuff */
- if (e->type == FocusIn || e->type == FocusOut) {
- gint mode = e->xfocus.mode;
- gint detail = e->xfocus.detail;
- Window window = e->xfocus.window;
- if (detail == NotifyVirtual) {
- ob_debug("FOCUS %s NOTIFY VIRTUAL window 0x%x\n",
- (e->type == FocusIn ? "IN" : "OUT"), window);
- }
-
- else if (detail == NotifyNonlinearVirtual) {
- ob_debug("FOCUS %s NOTIFY NONLINVIRTUAL window 0x%x\n",
- (e->type == FocusIn ? "IN" : "OUT"), window);
- }
-
- else
- ob_debug("UNKNOWN FOCUS %s (d %d, m %d) window 0x%x\n",
- (e->type == FocusIn ? "IN" : "OUT"),
- detail, mode, window);
-#endif
-
- event_set_lasttime(e);
+ event_set_curtime(e);
event_hack_mods(e);
if (event_ignore(e, client)) {
if (ed)
ed->ignored = FALSE;
/* deal with it in the kernel */
- if (group)
+
+ if (menu_frame_visible &&
+ (e->type == EnterNotify || e->type == LeaveNotify))
+ {
+ /* crossing events for menu */
+ event_handle_menu(e);
+ } else if (e->type == FocusIn) {
+ if (client && client != focus_client) {
+ frame_adjust_focus(client->frame, TRUE);
+ focus_set_client(client);
+ client_calc_layer(client);
+ }
+ } else if (e->type == FocusOut) {
+ gboolean nomove = FALSE;
+ XEvent ce;
+
+ ob_debug_type(OB_DEBUG_FOCUS, "FocusOut Event\n");
+
+ /* Look for the followup FocusIn */
+ if (!XCheckIfEvent(ob_display, &ce, look_for_focusin, NULL)) {
+ /* There is no FocusIn, this means focus went to a window that
+ is not being managed, or a window on another screen. */
+ ob_debug_type(OB_DEBUG_FOCUS, "Focus went to a black hole !\n");
+ /* nothing is focused */
+ focus_set_client(NULL);
+ } else if (ce.xany.window == e->xany.window) {
+ ob_debug_type(OB_DEBUG_FOCUS, "Focus didn't go anywhere\n");
+ /* If focus didn't actually move anywhere, there is nothing to do*/
+ nomove = TRUE;
+ } else if (ce.xfocus.detail == NotifyPointerRoot ||
+ ce.xfocus.detail == NotifyDetailNone ||
+ ce.xfocus.detail == NotifyInferior) {
+ ob_debug_type(OB_DEBUG_FOCUS, "Focus went to root\n");
+ /* Focus has been reverted to the root window or nothing
+ FocusOut events come after UnmapNotify, so we don't need to
+ worry about focusing an invalid window
+ */
+ focus_fallback(TRUE);
+ } else {
+ /* Focus did move, so process the FocusIn event */
+ ObEventData ed = { .ignored = FALSE };
+ event_process(&ce, &ed);
+ if (ed.ignored) {
+ /* The FocusIn was ignored, this means it was on a window
+ that isn't a client. */
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to an unmanaged window 0x%x !\n",
+ ce.xfocus.window);
+ focus_fallback(TRUE);
+ }
+ }
+
+ if (client && !nomove) {
+ frame_adjust_focus(client->frame, FALSE);
+ /* focus_set_client has already been called for sure */
+ client_calc_layer(client);
+ }
+ } else if (group)
event_handle_group(group, e);
else if (client)
event_handle_client(client, e);
e->xconfigurerequest.value_mask, &xwc);
xerror_set_ignore(FALSE);
}
+#ifdef SYNC
+ else if (extensions_sync &&
+ e->type == extensions_sync_event_basep + XSyncAlarmNotify)
+ {
+ XSyncAlarmNotifyEvent *se = (XSyncAlarmNotifyEvent*)e;
+ if (se->alarm == moveresize_alarm && moveresize_in_progress)
+ moveresize_event(e);
+ }
+#endif
/* user input (action-bound) events */
if (e->type == ButtonPress || e->type == ButtonRelease ||
ob_main_loop_timeout_add(ob_main_loop,
config_menu_hide_delay * 1000,
menu_hide_delay_func,
- NULL, NULL);
+ NULL, g_direct_equal, NULL);
if (e->type == ButtonPress || e->type == ButtonRelease ||
- e->type == MotionNotify)
+ e->type == MotionNotify) {
mouse_event(client, e);
- else if (e->type == KeyPress)
+ } else if (e->type == KeyPress) {
keyboard_event((focus_cycle_target ? focus_cycle_target :
- (focus_hilite ? focus_hilite : client)),
- e);
+ (client ? client : focus_client)), e);
+ }
}
}
}
+ /* if something happens and it's not from an XEvent, then we don't know
+ the time */
+ event_curtime = CurrentTime;
}
static void event_handle_root(XEvent *e)
msgtype = e->xclient.message_type;
if (msgtype == prop_atoms.net_current_desktop) {
guint d = e->xclient.data.l[0];
- if (d < screen_num_desktops)
+ if (d < screen_num_desktops) {
+ event_curtime = e->xclient.data.l[1];
+ ob_debug("SWITCH DESKTOP TIME: %d\n", event_curtime);
screen_set_desktop(d);
+ }
} else if (msgtype == prop_atoms.net_number_of_desktops) {
guint d = e->xclient.data.l[0];
if (d > 0)
if (client_normal(client) && client_can_focus(client)) {
if (config_focus_delay) {
+ ObFocusDelayData *data;
+
ob_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
+
+ data = g_new(ObFocusDelayData, 1);
+ data->client = client;
+ data->time = event_curtime;
+
ob_main_loop_timeout_add(ob_main_loop,
config_focus_delay,
focus_delay_func,
- client, NULL);
- } else
- focus_delay_func(client);
+ data, focus_delay_cmp, focus_delay_dest);
+ } else {
+ ObFocusDelayData data;
+ data.client = client;
+ data.time = event_curtime;
+ focus_delay_func(&data);
+ }
}
}
ObFrameContext con;
switch (e->type) {
- case VisibilityNotify:
- client->frame->obscured = e->xvisibility.state != VisibilityUnobscured;
- break;
case ButtonPress:
case ButtonRelease:
/* Wheel buttons don't draw because they are an instant click, so it
}
}
break;
- case FocusIn:
- if (client != focus_client) {
- focus_set_client(client);
- frame_adjust_focus(client->frame, TRUE);
- client_calc_layer(client);
- }
- break;
- case FocusOut:
- /* Look for the followup FocusIn */
- if (!XCheckIfEvent(ob_display, &ce, look_for_focusin, NULL)) {
- /* There is no FocusIn, move focus where we can still hear events*/
- focus_set_client(NULL);
- } else if (ce.xany.window == e->xany.window) {
- /* If focus didn't actually move anywhere, there is nothing to do*/
- break;
- } else {
- /* Focus did move, so process the FocusIn event */
- ObEventData ed;
- event_process(&ce, &ed);
- if (ed.ignored) {
- /* The FocusIn was ignored, this means it was on a window
- that isn't a client? How did this happen? */
- g_assert_not_reached();
- }
- }
-
- /* This client is no longer focused, so show that */
- frame_adjust_focus(client->frame, FALSE);
- client_calc_layer(client);
- break;
case LeaveNotify:
con = frame_context(client, e->xcrossing.window);
switch (con) {
frame_adjust_state(client->frame);
break;
case OB_FRAME_CONTEXT_FRAME:
- if (config_focus_follow && config_focus_delay)
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "%sNotify mode %d detail %d on %lx\n",
+ (e->type == EnterNotify ? "Enter" : "Leave"),
+ e->xcrossing.mode,
+ e->xcrossing.detail, (client?client->window:0));
+ if (keyboard_interactively_grabbed())
+ break;
+ if (config_focus_follow && config_focus_delay &&
+ /* leave inferior events can happen when the mouse goes onto
+ the window's border and then into the window before the
+ delay is up */
+ e->xcrossing.detail != NotifyInferior)
+ {
ob_main_loop_timeout_remove_data(ob_main_loop,
focus_delay_func,
- client, TRUE);
+ client, FALSE);
+ }
break;
default:
break;
frame_adjust_state(client->frame);
break;
case OB_FRAME_CONTEXT_FRAME:
+ if (keyboard_interactively_grabbed())
+ break;
if (e->xcrossing.mode == NotifyGrab ||
- e->xcrossing.mode == NotifyUngrab)
+ e->xcrossing.mode == NotifyUngrab ||
+ /*ignore enters when we're already in the window */
+ e->xcrossing.detail == NotifyInferior)
{
-#ifdef DEBUG_FOCUS
- ob_debug("%sNotify mode %d detail %d on %lx IGNORED\n",
- (e->type == EnterNotify ? "Enter" : "Leave"),
- e->xcrossing.mode,
- e->xcrossing.detail, client?client->window:0);
-#endif
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "%sNotify mode %d detail %d on %lx IGNORED\n",
+ (e->type == EnterNotify ? "Enter" : "Leave"),
+ e->xcrossing.mode,
+ e->xcrossing.detail, client?client->window:0);
} else {
-#ifdef DEBUG_FOCUS
- ob_debug("%sNotify mode %d detail %d on %lx, "
- "focusing window: %d\n",
- (e->type == EnterNotify ? "Enter" : "Leave"),
- e->xcrossing.mode,
- e->xcrossing.detail, (client?client->window:0),
- !nofocus);
-#endif
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "%sNotify mode %d detail %d on %lx, "
+ "focusing window: %d\n",
+ (e->type == EnterNotify ? "Enter" : "Leave"),
+ e->xcrossing.mode,
+ e->xcrossing.detail, (client?client->window:0),
+ !nofocus);
if (!nofocus && config_focus_follow)
event_enter_client(client);
}
client->ignore_unmaps--;
break;
}
+ ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
+ "ignores left %d\n",
+ client->window, e->xunmap.event, e->xunmap.from_configure,
+ client->ignore_unmaps);
client_unmanage(client);
break;
case DestroyNotify:
+ ob_debug("DestroyNotify for window 0x%x\n", client->window);
client_unmanage(client);
break;
case ReparentNotify:
X server to deal with after we unmanage the window */
XPutBackEvent(ob_display, e);
+ ob_debug("ReparentNotify for window 0x%x\n", client->window);
client_unmanage(client);
break;
case MapRequest:
it can happen now when the window is on
another desktop, but we still don't
want it! */
- client_activate(client, FALSE, TRUE, CurrentTime);
+ client_activate(client, FALSE, TRUE);
break;
case ClientMessage:
/* validate cuz we query stuff off the client here */
(e->xclient.data.l[0] == 0 ? "unknown" :
(e->xclient.data.l[0] == 1 ? "application" :
(e->xclient.data.l[0] == 2 ? "user" : "INVALID"))));
- /* XXX make use of data.l[1] and [2] ! */
+ /* XXX make use of data.l[2] ! */
+ event_curtime = e->xclient.data.l[1];
client_activate(client, FALSE,
(e->xclient.data.l[0] == 0 ||
- e->xclient.data.l[0] == 2),
- e->xclient.data.l[1]);
+ e->xclient.data.l[0] == 2));
} else if (msgtype == prop_atoms.net_wm_moveresize) {
ob_debug("net_wm_moveresize for 0x%lx direction %d\n",
client->window, e->xclient.data.l[2]);
client_update_icons(client);
}
else if (msgtype == prop_atoms.net_wm_user_time) {
- client_update_user_time(client, TRUE);
+ client_update_user_time(client);
}
+#ifdef SYNC
+ else if (msgtype == prop_atoms.net_wm_sync_request_counter) {
+ client_update_sync_request_counter(client);
+ }
+#endif
else if (msgtype == prop_atoms.sm_client_id) {
client_update_sm_client_id(client);
}
+ case ColormapNotify:
+ client_update_colormap(client, e->xcolormap.colormap);
+ break;
default:
;
#ifdef SHAPE
}
}
-ObMenuFrame* find_active_menu()
+static ObMenuFrame* find_active_menu()
{
GList *it;
ObMenuFrame *ret = NULL;
return ret;
}
-ObMenuFrame* find_active_or_last_menu()
+static ObMenuFrame* find_active_or_last_menu()
{
ObMenuFrame *ret = NULL;
return ret;
}
+static void event_handle_menu_shortcut(XEvent *ev)
+{
+ gunichar unikey = 0;
+ ObMenuFrame *frame;
+ GList *start;
+ GList *it;
+ ObMenuEntryFrame *found = NULL;
+ guint num_found = 0;
+
+ {
+ const char *key;
+ if ((key = translate_keycode(ev->xkey.keycode)) == NULL)
+ return;
+ unikey = g_utf8_get_char_validated(key, -1);
+ if (unikey == (gunichar)-1 || unikey == (gunichar)-2 || unikey == 0)
+ return;
+ }
+
+ if ((frame = find_active_or_last_menu()) == NULL)
+ return;
+
+
+ if (!frame->entries)
+ return; /* nothing in the menu anyways */
+
+ /* start after the selected one */
+ start = frame->entries;
+ if (frame->selected) {
+ for (it = start; frame->selected != it->data; it = g_list_next(it))
+ g_assert(it != NULL); /* nothing was selected? */
+ /* next with wraparound */
+ start = g_list_next(it);
+ if (start == NULL) start = frame->entries;
+ }
+
+ it = start;
+ do {
+ ObMenuEntryFrame *e = it->data;
+ gunichar entrykey = 0;
+
+ if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
+ entrykey = e->entry->data.normal.shortcut;
+ else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
+ entrykey = e->entry->data.submenu.submenu->shortcut;
+
+ if (unikey == entrykey) {
+ if (found == NULL) found = e;
+ ++num_found;
+ }
+
+ /* next with wraparound */
+ it = g_list_next(it);
+ if (it == NULL) it = frame->entries;
+ } while (it != start);
+
+ if (found) {
+ if (found->entry->type == OB_MENU_ENTRY_TYPE_NORMAL &&
+ num_found == 1)
+ {
+ menu_frame_select(frame, found, TRUE);
+ usleep(50000);
+ menu_entry_frame_execute(found, ev->xkey.state,
+ ev->xkey.time);
+ } else {
+ menu_frame_select(frame, found, TRUE);
+ if (num_found == 1)
+ menu_frame_select_next(frame->child);
+ }
+ }
+}
+
static void event_handle_menu(XEvent *ev)
{
ObMenuFrame *f;
menu_frame_hide_all();
}
break;
- case MotionNotify:
- if ((f = menu_frame_under(ev->xmotion.x_root,
- ev->xmotion.y_root))) {
- menu_frame_move_on_screen(f);
- if ((e = menu_entry_frame_under(ev->xmotion.x_root,
- ev->xmotion.y_root)))
- menu_frame_select(f, e);
+ case EnterNotify:
+ if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
+ if (e->ignore_enters)
+ --e->ignore_enters;
+ else
+ menu_frame_select(e->frame, e, FALSE);
}
+ break;
+ case LeaveNotify:
+ if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)) &&
+ (f = find_active_menu()) && f->selected == e &&
+ e->entry->type != OB_MENU_ENTRY_TYPE_SUBMENU)
{
- ObMenuFrame *a;
-
- a = find_active_menu();
- if (a && a != f &&
- a->selected->entry->type != OB_MENU_ENTRY_TYPE_SUBMENU)
- {
- menu_frame_select(a, NULL);
- }
+ menu_frame_select(e->frame, NULL, FALSE);
}
+ case MotionNotify:
+ if ((e = menu_entry_frame_under(ev->xmotion.x_root,
+ ev->xmotion.y_root)))
+ menu_frame_select(e->frame, e, FALSE);
break;
case KeyPress:
if (ev->xkey.keycode == ob_keycode(OB_KEY_ESCAPE))
- menu_frame_hide_all();
+ if ((f = find_active_or_last_menu()) && f->parent)
+ menu_frame_select(f, NULL, TRUE);
+ else
+ menu_frame_hide_all();
else if (ev->xkey.keycode == ob_keycode(OB_KEY_RETURN)) {
ObMenuFrame *f;
- if ((f = find_active_menu()))
- menu_entry_frame_execute(f->selected, ev->xkey.state,
- ev->xkey.time);
+ if ((f = find_active_menu())) {
+ if (f->child)
+ menu_frame_select_next(f->child);
+ else
+ menu_entry_frame_execute(f->selected, ev->xkey.state,
+ ev->xkey.time);
+ }
} else if (ev->xkey.keycode == ob_keycode(OB_KEY_LEFT)) {
ObMenuFrame *f;
- if ((f = find_active_or_last_menu()) && f->parent)
- menu_frame_select(f, NULL);
+ if ((f = find_active_or_last_menu()))
+ menu_frame_select(f, NULL, TRUE);
} else if (ev->xkey.keycode == ob_keycode(OB_KEY_RIGHT)) {
ObMenuFrame *f;
- if ((f = find_active_or_last_menu()) && f->child)
+ if ((f = find_active_menu()) && f->child)
menu_frame_select_next(f->child);
} else if (ev->xkey.keycode == ob_keycode(OB_KEY_UP)) {
ObMenuFrame *f;
ObMenuFrame *f;
if ((f = find_active_or_last_menu()))
menu_frame_select_next(f);
- }
+ } else
+ event_handle_menu_shortcut(ev);
break;
}
}
return FALSE; /* no repeat */
}
+static void focus_delay_dest(gpointer data)
+{
+ g_free(data);
+}
+
+static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2)
+{
+ const ObFocusDelayData *f1 = d1;
+ return f1->client == d2;
+}
+
static gboolean focus_delay_func(gpointer data)
{
- ObClient *c = data;
+ ObFocusDelayData *d = data;
+ Time old = event_curtime;
- if (focus_client != c) {
- client_focus(c);
- if (config_focus_raise)
- client_raise(c);
+ event_curtime = d->time;
+ if (focus_client != d->client) {
+ if (client_focus(d->client) && config_focus_raise)
+ client_raise(d->client);
}
+ event_curtime = old;
return FALSE; /* no repeat */
}
static void focus_delay_client_dest(ObClient *client, gpointer data)
{
ob_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
- client, TRUE);
-}
-
-static void event_client_dest(ObClient *client, gpointer data)
-{
- if (client == focus_hilite)
- focus_hilite = NULL;
+ client, FALSE);
}
void event_halt_focus_delay()
}
g_slist_free(saved);
}
+
+gboolean event_time_after(Time t1, Time t2)
+{
+ g_assert(t1 != CurrentTime);
+ g_assert(t2 != CurrentTime);
+
+ /*
+ Timestamp values wrap around (after about 49.7 days). The server, given
+ its current time is represented by timestamp T, always interprets
+ timestamps from clients by treating half of the timestamp space as being
+ later in time than T.
+ - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
+ */
+
+ /* TIME_HALF is half of the number space of a Time type variable */
+#define TIME_HALF (Time)(1 << (sizeof(Time)*8-1))
+
+ if (t2 >= TIME_HALF)
+ /* t2 is in the second half so t1 might wrap around and be smaller than
+ t2 */
+ return t1 >= t2 || t1 < (t2 + TIME_HALF);
+ else
+ /* t2 is in the first half so t1 has to come after it */
+ return t1 >= t2 && t1 < (t2 + TIME_HALF);
+}
projects / chaz / openbox / blobdiff