X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Fevent.c;h=1b3a0e4674f85e8636ba315e87202da8bc5d50ad;hb=HEAD;hp=2e3a44c56a63f64a7c301c7b0de2e8a977ce7eef;hpb=52369e319f11e1189e8980f64974236eeb4de96e;p=chaz%2Fopenbox diff --git a/openbox/event.c b/openbox/event.c index 2e3a44c5..1b3a0e46 100644 --- a/openbox/event.c +++ b/openbox/event.c @@ -29,6 +29,7 @@ #include "frame.h" #include "grab.h" #include "menu.h" +#include "prompt.h" #include "menuframe.h" #include "keyboard.h" #include "mouse.h" @@ -39,6 +40,7 @@ #include "stacking.h" #include "ping.h" #include "obt/display.h" +#include "obt/xqueue.h" #include "obt/prop.h" #include "obt/keyboard.h" @@ -55,9 +57,6 @@ #ifdef HAVE_UNISTD_H # include /* for usleep() */ #endif -#ifdef XKB -# include -#endif #ifdef USE_SM #include @@ -85,45 +84,62 @@ static void event_process(const XEvent *e, gpointer data); static void event_handle_root(XEvent *e); static gboolean event_handle_menu_input(XEvent *e); static void event_handle_menu(ObMenuFrame *frame, XEvent *e); +static gboolean event_handle_prompt(ObPrompt *p, 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_user_input(ObClient *client, XEvent *e); -static gboolean is_enter_focus_event_ignored(XEvent *e); +static gboolean event_handle_user_input(ObClient *client, XEvent *e); +static gboolean is_enter_focus_event_ignored(gulong serial); static void event_ignore_enter_range(gulong start, gulong end); static void focus_delay_dest(gpointer data); -static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2); +static void unfocus_delay_dest(gpointer data); static gboolean focus_delay_func(gpointer data); +static gboolean unfocus_delay_func(gpointer data); static void focus_delay_client_dest(ObClient *client, gpointer data); -Time event_curtime = CurrentTime; Time event_last_user_time = CurrentTime; -/*! The serial of the current X event */ +/*! The time of the current X event (if it had a timestamp) */ +static Time event_curtime = CurrentTime; +/*! The source time that started the current X event (user-provided, so not + to be trusted) */ +static Time event_sourcetime = CurrentTime; + +/*! The serial of the current X event */ static gulong event_curserial; static gboolean focus_left_screen = FALSE; +static gboolean waiting_for_focusin = FALSE; /*! A list of ObSerialRanges which are to be ignored for mouse enter events */ static GSList *ignore_serials = NULL; +static guint focus_delay_timeout_id = 0; +static ObClient *focus_delay_timeout_client = NULL; +static guint unfocus_delay_timeout_id = 0; +static ObClient *unfocus_delay_timeout_client = NULL; #ifdef USE_SM -static void ice_handler(gint fd, gpointer conn) +static gboolean ice_handler(GIOChannel *source, GIOCondition cond, + gpointer conn) { Bool b; IceProcessMessages(conn, NULL, &b); + return TRUE; /* don't remove the event source */ } static void ice_watch(IceConn conn, IcePointer data, Bool opening, IcePointer *watch_data) { - static gint fd = -1; + static guint id = 0; if (opening) { - fd = IceConnectionNumber(conn); - obt_main_loop_fd_add(ob_main_loop, fd, ice_handler, conn, NULL); - } else { - obt_main_loop_fd_remove(ob_main_loop, fd); - fd = -1; + GIOChannel *ch; + + ch = g_io_channel_unix_new(IceConnectionNumber(conn)); + id = g_io_add_watch(ch, G_IO_IN, ice_handler, conn); + g_io_channel_unref(ch); + } else if (id) { + g_source_remove(id); + id = 0; } } #endif @@ -132,7 +148,7 @@ void event_startup(gboolean reconfig) { if (reconfig) return; - obt_main_loop_x_add(ob_main_loop, event_process, NULL, NULL); + xqueue_add_callback(event_process, NULL); #ifdef USE_SM IceAddConnectionWatch(ice_watch, NULL); @@ -161,7 +177,13 @@ static Window event_get_window(XEvent *e) case SelectionClear: window = obt_root(ob_screen); break; + case CreateNotify: + window = e->xcreatewindow.window; + break; case MapRequest: + window = e->xmaprequest.window; + break; + case MapNotify: window = e->xmap.window; break; case UnmapNotify: @@ -201,7 +223,7 @@ static Window event_get_window(XEvent *e) return window; } -static void event_set_curtime(XEvent *e) +static inline Time event_get_timestamp(const XEvent *e) { Time t = CurrentTime; @@ -232,7 +254,7 @@ static void event_set_curtime(XEvent *e) if (obt_display_extension_sync && e->type == obt_display_extension_sync_basep + XSyncAlarmNotify) { - t = ((XSyncAlarmNotifyEvent*)e)->time; + t = ((const XSyncAlarmNotifyEvent*)e)->time; } #endif /* if more event types are anticipated, get their timestamp @@ -240,52 +262,44 @@ static void event_set_curtime(XEvent *e) break; } + return t; +} + +static void event_set_curtime(XEvent *e) +{ + Time t = event_get_timestamp(e); + /* watch that if we get an event earlier than the last specified user_time, which can happen if the clock goes backwards, we erase the last specified user_time */ if (t && event_last_user_time && event_time_after(event_last_user_time, t)) - event_last_user_time = CurrentTime; + event_reset_user_time(); + event_sourcetime = CurrentTime; event_curtime = t; } static void event_hack_mods(XEvent *e) { -#ifdef XKB - XkbStateRec xkb_state; -#endif - switch (e->type) { case ButtonPress: case ButtonRelease: e->xbutton.state = obt_keyboard_only_modmasks(e->xbutton.state); break; case KeyPress: - e->xkey.state = obt_keyboard_only_modmasks(e->xkey.state); break; case KeyRelease: -#ifdef XKB - /* If XKB is present, then the modifiers are all strange from its - magic. Our X core protocol stuff won't work, so we use this to - find what the modifier state is instead. */ - if (XkbGetState(obt_display, XkbUseCoreKbd, &xkb_state) == Success) - e->xkey.state = xkb_state.compat_state; - else -#endif - { - e->xkey.state = obt_keyboard_only_modmasks(e->xkey.state); - /* remove from the state the mask of the modifier key being - released, if it is a modifier key being released that is */ - e->xkey.state &= ~obt_keyboard_keycode_to_modmask(e->xkey.keycode); - } break; case MotionNotify: e->xmotion.state = obt_keyboard_only_modmasks(e->xmotion.state); /* compress events */ { XEvent ce; - while (XCheckTypedWindowEvent(obt_display, e->xmotion.window, - e->type, &ce)) { + ObtXQueueWindowType wt; + + wt.window = e->xmotion.window; + wt.type = MotionNotify; + while (xqueue_remove_local(&ce, xqueue_match_window_type, &wt)) { e->xmotion.x = ce.xmotion.x; e->xmotion.y = ce.xmotion.y; e->xmotion.x_root = ce.xmotion.x_root; @@ -385,12 +399,12 @@ static gboolean wanted_focusevent(XEvent *e, gboolean in_client_only) } } -static Bool event_look_for_focusin(Display *d, XEvent *e, XPointer arg) +static gboolean event_look_for_focusin(XEvent *e, gpointer data) { return e->type == FocusIn && wanted_focusevent(e, FALSE); } -static Bool event_look_for_focusin_client(Display *d, XEvent *e, XPointer arg) +static gboolean event_look_for_focusin_client(XEvent *e, gpointer data) { return e->type == FocusIn && wanted_focusevent(e, TRUE); } @@ -407,6 +421,7 @@ static void print_focusevent(XEvent *e) case NotifyGrab: modestr="NotifyGrab"; break; case NotifyUngrab: modestr="NotifyUngrab"; break; case NotifyWhileGrabbed: modestr="NotifyWhileGrabbed"; break; + default: g_assert_not_reached(); } switch (detail) { case NotifyAncestor: detailstr="NotifyAncestor"; break; @@ -417,6 +432,7 @@ static void print_focusevent(XEvent *e) case NotifyPointer: detailstr="NotifyPointer"; break; case NotifyPointerRoot: detailstr="NotifyPointerRoot"; break; case NotifyDetailNone: detailstr="NotifyDetailNone"; break; + default: g_assert_not_reached(); } if (mode == NotifyGrab || mode == NotifyUngrab) @@ -424,54 +440,41 @@ static void print_focusevent(XEvent *e) g_assert(modestr); g_assert(detailstr); - ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s\n", + ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s", (e->xfocus.type == FocusIn ? "In" : "Out"), win, modestr, detailstr); } -static gboolean event_ignore(XEvent *e, ObClient *client) -{ - switch(e->type) { - case FocusIn: - print_focusevent(e); - if (!wanted_focusevent(e, FALSE)) - return TRUE; - break; - case FocusOut: - print_focusevent(e); - if (!wanted_focusevent(e, FALSE)) - return TRUE; - break; - } - return FALSE; -} - static void event_process(const XEvent *ec, gpointer data) { XEvent ee, *e; - ObEventData *ed = data; - Window window; ObClient *client = NULL; ObDock *dock = NULL; ObDockApp *dockapp = NULL; ObWindow *obwin = NULL; ObMenuFrame *menu = NULL; + ObPrompt *prompt = NULL; + gboolean used; /* make a copy we can mangle */ ee = *ec; e = ⅇ window = event_get_window(e); - if ((obwin = window_find(window))) { + if (window == obt_root(ob_screen)) + /* don't do any lookups, waste of cpu */; + else if ((obwin = window_find(window))) { switch (obwin->type) { case OB_WINDOW_CLASS_DOCK: dock = WINDOW_AS_DOCK(obwin); break; case OB_WINDOW_CLASS_CLIENT: client = WINDOW_AS_CLIENT(obwin); + /* events on clients can be events on prompt windows too */ + prompt = client->prompt; break; case OB_WINDOW_CLASS_MENUFRAME: menu = WINDOW_AS_MENUFRAME(obwin); @@ -479,6 +482,9 @@ static void event_process(const XEvent *ec, gpointer data) case OB_WINDOW_CLASS_INTERNAL: /* we don't do anything with events directly on these windows */ break; + case OB_WINDOW_CLASS_PROMPT: + prompt = WINDOW_AS_PROMPT(obwin); + break; } } else @@ -487,21 +493,23 @@ static void event_process(const XEvent *ec, gpointer data) event_set_curtime(e); event_curserial = e->xany.serial; event_hack_mods(e); - if (event_ignore(e, client)) { - if (ed) - ed->ignored = TRUE; - return; - } else if (ed) - ed->ignored = FALSE; /* deal with it in the kernel */ if (e->type == FocusIn) { - if (client && - e->xfocus.detail == NotifyInferior) - { - ob_debug_type(OB_DEBUG_FOCUS, - "Focus went to the frame window"); + print_focusevent(e); + if (!wanted_focusevent(e, FALSE)) { + if (waiting_for_focusin) { + /* We were waiting for this FocusIn, since we got a FocusOut + earlier, but it went to a window that isn't a client. */ + ob_debug_type(OB_DEBUG_FOCUS, + "Focus went to an unmanaged window 0x%x !", + e->xfocus.window); + focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE); + } + } + else if (client && e->xfocus.detail == NotifyInferior) { + ob_debug_type(OB_DEBUG_FOCUS, "Focus went to the frame window"); focus_left_screen = FALSE; @@ -512,17 +520,14 @@ static void event_process(const XEvent *ec, gpointer data) window with RevertToParent focus */ frame_adjust_focus(client->frame, FALSE); /* focus_set_client(NULL) has already been called */ - client_calc_layer(client); } else if (e->xfocus.detail == NotifyPointerRoot || e->xfocus.detail == NotifyDetailNone || e->xfocus.detail == NotifyInferior || e->xfocus.detail == NotifyNonlinear) { - XEvent ce; - ob_debug_type(OB_DEBUG_FOCUS, - "Focus went to root or pointer root/none\n"); + "Focus went to root or pointer root/none"); if (e->xfocus.detail == NotifyInferior || e->xfocus.detail == NotifyNonlinear) @@ -543,12 +548,9 @@ static void event_process(const XEvent *ec, gpointer data) But if the other focus in is something like PointerRoot then we still want to fall back. */ - if (XCheckIfEvent(obt_display, &ce, event_look_for_focusin_client, - NULL)) - { - XPutBackEvent(obt_display, &ce); + if (xqueue_exists_local(event_look_for_focusin_client, NULL)) { ob_debug_type(OB_DEBUG_FOCUS, - " but another FocusIn is coming\n"); + " but another FocusIn is coming"); } else { /* Focus has been reverted. @@ -564,7 +566,7 @@ static void event_process(const XEvent *ec, gpointer data) else if (!client) { ob_debug_type(OB_DEBUG_FOCUS, - "Focus went to a window that is already gone\n"); + "Focus went to a window that is already gone"); /* If you send focus to a window and then it disappears, you can get the FocusIn for it, after it is unmanaged. @@ -579,11 +581,14 @@ static void event_process(const XEvent *ec, gpointer data) client_calc_layer(client); client_bring_helper_windows(client); } - } else if (e->type == FocusOut) { - XEvent ce; + waiting_for_focusin = FALSE; + } else if (e->type == FocusOut) { + print_focusevent(e); + if (!wanted_focusevent(e, FALSE)) + ; /* skip this one */ /* Look for the followup FocusIn */ - if (!XCheckIfEvent(obt_display, &ce, event_look_for_focusin, NULL)) { + else if (!xqueue_exists_local(event_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. */ Window win, root; @@ -595,35 +600,26 @@ static void event_process(const XEvent *ec, gpointer data) root != obt_root(ob_screen)) { ob_debug_type(OB_DEBUG_FOCUS, - "Focus went to another screen !\n"); + "Focus went to another screen !"); focus_left_screen = TRUE; } else ob_debug_type(OB_DEBUG_FOCUS, - "Focus went to a black hole !\n"); + "Focus went to a black hole !"); obt_display_ignore_errors(FALSE); /* nothing is focused */ focus_set_client(NULL); } else { - /* Focus moved, 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, config_focus_under_mouse, TRUE, TRUE); - } + /* Focus moved, so mark that we are waiting to process that + FocusIn */ + waiting_for_focusin = TRUE; + + /* nothing is focused right now, but will be again shortly */ + focus_set_client(NULL); } - if (client && client != focus_client) { + if (client && client != focus_client) frame_adjust_focus(client->frame, FALSE); - /* focus_set_client(NULL) has already been called in this - section or by focus_fallback */ - client_calc_layer(client); - } } else if (client) event_handle_client(client, e); @@ -636,13 +632,15 @@ static void event_process(const XEvent *ec, gpointer data) else if (window == obt_root(ob_screen)) event_handle_root(e); else if (e->type == MapRequest) - client_manage(window); + window_manage(window); else if (e->type == MappingNotify) { /* keyboard layout changes for modifier mapping changes. reload the modifier map, and rebind all the key bindings as appropriate */ - ob_debug("Kepboard map changed. Reloading keyboard bindings.\n"); + ob_debug("Keyboard map changed. Reloading keyboard bindings."); + ob_set_state(OB_STATE_RECONFIGURING); obt_keyboard_reload(); keyboard_rebind(); + ob_set_state(OB_STATE_RUNNING); } else if (e->type == ClientMessage) { /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for @@ -698,32 +696,49 @@ static void event_process(const XEvent *ec, gpointer data) #endif if (e->type == ButtonPress || e->type == ButtonRelease) { + ObWindow *w; + static guint pressed = 0; + + event_sourcetime = event_curtime; + /* If the button press was on some non-root window, or was physically - on the root window, the process it */ + on the root window... */ if (window != obt_root(ob_screen) || - e->xbutton.subwindow == None) + e->xbutton.subwindow == None || + /* ...or if it is related to the last button press we handled... */ + pressed == e->xbutton.button || + /* ...or it if it was physically on an openbox + internal window... */ + ((w = window_find(e->xbutton.subwindow)) && + (WINDOW_IS_INTERNAL(w) || WINDOW_IS_DOCK(w)))) + /* ...then process the event, otherwise ignore it */ { - event_handle_user_input(client, e); - } - /* Otherwise only process it if it was physically on an openbox - internal window */ - else { - ObWindow *w; + used = event_handle_user_input(client, e); - if ((w = window_find(e->xbutton.subwindow)) && - WINDOW_IS_INTERNAL(w)) - { - event_handle_user_input(client, e); - } + if (prompt && !used) + used = event_handle_prompt(prompt, e); + + if (e->type == ButtonPress) + pressed = e->xbutton.button; } } else if (e->type == KeyPress || e->type == KeyRelease || e->type == MotionNotify) - event_handle_user_input(client, e); + { + event_sourcetime = event_curtime; + + used = event_handle_user_input(client, e); + + if (prompt && !used) + used = event_handle_prompt(prompt, e); + } + + /* show any debug prompts that are queued */ + ob_debug_show_prompts(); /* if something happens and it's not from an XEvent, then we don't know - the time */ - event_curtime = CurrentTime; + the time, so clear it here until the next event is handled */ + event_curtime = event_sourcetime = CurrentTime; event_curserial = 0; } @@ -733,7 +748,7 @@ static void event_handle_root(XEvent *e) switch(e->type) { case SelectionClear: - ob_debug("Another WM has requested to replace us. Exiting.\n"); + ob_debug("Another WM has requested to replace us. Exiting."); ob_exit_replace(); break; @@ -744,11 +759,12 @@ static void event_handle_root(XEvent *e) if (msgtype == OBT_PROP_ATOM(NET_CURRENT_DESKTOP)) { guint d = e->xclient.data.l[0]; if (d < screen_num_desktops) { - event_curtime = e->xclient.data.l[1]; - if (event_curtime == 0) + if (e->xclient.data.l[1] == 0) ob_debug_type(OB_DEBUG_APP_BUGS, "_NET_CURRENT_DESKTOP message is missing " - "a timestamp\n"); + "a timestamp"); + else + event_sourcetime = e->xclient.data.l[1]; screen_set_desktop(d, TRUE); } } else if (msgtype == OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS)) { @@ -758,7 +774,7 @@ static void event_handle_root(XEvent *e) } else if (msgtype == OBT_PROP_ATOM(NET_SHOWING_DESKTOP)) { screen_show_desktop(e->xclient.data.l[0] != 0, NULL); } else if (msgtype == OBT_PROP_ATOM(OB_CONTROL)) { - ob_debug("OB_CONTROL: %d\n", e->xclient.data.l[0]); + ob_debug("OB_CONTROL: %d", e->xclient.data.l[0]); if (e->xclient.data.l[0] == 1) ob_reconfigure(); else if (e->xclient.data.l[0] == 2) @@ -772,7 +788,7 @@ static void event_handle_root(XEvent *e) break; case PropertyNotify: if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_NAMES)) { - ob_debug("UPDATE DESKTOP NAMES\n"); + ob_debug("UPDATE DESKTOP NAMES"); screen_update_desktop_names(); } else if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_LAYOUT)) @@ -793,38 +809,164 @@ void event_enter_client(ObClient *client) { g_assert(config_focus_follow); + if (is_enter_focus_event_ignored(event_curserial)) { + ob_debug_type(OB_DEBUG_FOCUS, "Ignoring enter event with serial %lu " + "on client 0x%x", event_curserial, client->window); + return; + } + + ob_debug_type(OB_DEBUG_FOCUS, "using enter event with serial %lu " + "on client 0x%x", event_curserial, client->window); + if (client_enter_focusable(client) && client_can_focus(client)) { if (config_focus_delay) { ObFocusDelayData *data; - obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func); + if (focus_delay_timeout_id) + g_source_remove(focus_delay_timeout_id); - data = g_new(ObFocusDelayData, 1); + data = g_slice_new(ObFocusDelayData); data->client = client; - data->time = event_curtime; + data->time = event_time(); data->serial = event_curserial; - obt_main_loop_timeout_add(ob_main_loop, - config_focus_delay * 1000, - focus_delay_func, - data, focus_delay_cmp, focus_delay_dest); + focus_delay_timeout_id = g_timeout_add_full(G_PRIORITY_DEFAULT, + config_focus_delay, + focus_delay_func, + data, + focus_delay_dest); + focus_delay_timeout_client = client; } else { ObFocusDelayData data; data.client = client; - data.time = event_curtime; + data.time = event_time(); data.serial = event_curserial; focus_delay_func(&data); } } } +void event_leave_client(ObClient *client) +{ + g_assert(config_focus_follow); + + if (is_enter_focus_event_ignored(event_curserial)) { + ob_debug_type(OB_DEBUG_FOCUS, "Ignoring leave event with serial %lu\n" + "on client 0x%x", event_curserial, client->window); + return; + } + + if (client == focus_client) { + if (config_focus_delay) { + ObFocusDelayData *data; + + if (unfocus_delay_timeout_id) + g_source_remove(unfocus_delay_timeout_id); + + data = g_slice_new(ObFocusDelayData); + data->client = client; + data->time = event_time(); + data->serial = event_curserial; + + unfocus_delay_timeout_id = g_timeout_add_full(G_PRIORITY_DEFAULT, + config_focus_delay, + unfocus_delay_func, + data, + unfocus_delay_dest); + unfocus_delay_timeout_client = client; + } else { + ObFocusDelayData data; + data.client = client; + data.time = event_time(); + data.serial = event_curserial; + unfocus_delay_func(&data); + } + } +} + +static gboolean *context_to_button(ObFrame *f, ObFrameContext con, gboolean press) +{ + if (press) { + switch (con) { + case OB_FRAME_CONTEXT_MAXIMIZE: + return &f->max_press; + case OB_FRAME_CONTEXT_CLOSE: + return &f->close_press; + case OB_FRAME_CONTEXT_ICONIFY: + return &f->iconify_press; + case OB_FRAME_CONTEXT_ALLDESKTOPS: + return &f->desk_press; + case OB_FRAME_CONTEXT_SHADE: + return &f->shade_press; + default: + return NULL; + } + } else { + switch (con) { + case OB_FRAME_CONTEXT_MAXIMIZE: + return &f->max_hover; + case OB_FRAME_CONTEXT_CLOSE: + return &f->close_hover; + case OB_FRAME_CONTEXT_ICONIFY: + return &f->iconify_hover; + case OB_FRAME_CONTEXT_ALLDESKTOPS: + return &f->desk_hover; + case OB_FRAME_CONTEXT_SHADE: + return &f->shade_hover; + default: + return NULL; + } + } +} + +static gboolean more_client_message_event(Window window, Atom msgtype) +{ + ObtXQueueWindowMessage wm; + wm.window = window; + wm.message = msgtype; + return xqueue_exists_local(xqueue_match_window_message, &wm); +} + +struct ObSkipPropertyChange { + Window window; + Atom prop; +}; + +static gboolean skip_property_change(XEvent *e, gpointer data) +{ + const struct ObSkipPropertyChange s = *(struct ObSkipPropertyChange*)data; + + if (e->type == PropertyNotify && e->xproperty.window == s.window) { + const Atom a = e->xproperty.atom; + const Atom b = s.prop; + + /* these are all updated together */ + if ((a == OBT_PROP_ATOM(NET_WM_NAME) || + a == OBT_PROP_ATOM(WM_NAME) || + a == OBT_PROP_ATOM(NET_WM_ICON_NAME) || + a == OBT_PROP_ATOM(WM_ICON_NAME)) + && + (b == OBT_PROP_ATOM(NET_WM_NAME) || + b == OBT_PROP_ATOM(WM_NAME) || + b == OBT_PROP_ATOM(NET_WM_ICON_NAME) || + b == OBT_PROP_ATOM(WM_ICON_NAME))) + { + return TRUE; + } + else if (a == b && a == OBT_PROP_ATOM(NET_WM_ICON)) + return TRUE; + } + return FALSE; +} + static void event_handle_client(ObClient *client, XEvent *e) { - XEvent ce; Atom msgtype; ObFrameContext con; + gboolean *but; static gint px = -1, py = -1; static guint pb = 0; + static ObFrameContext pcon = OB_FRAME_CONTEXT_NONE; switch (e->type) { case ButtonPress: @@ -833,11 +975,15 @@ static void event_handle_client(ObClient *client, XEvent *e) pb = e->xbutton.button; px = e->xbutton.x; py = e->xbutton.y; + + pcon = frame_context(client, e->xbutton.window, px, py); + pcon = mouse_button_frame_context(pcon, e->xbutton.button, + e->xbutton.state); } case ButtonRelease: /* Wheel buttons don't draw because they are an instant click, so it is a waste of resources to go drawing it. - if the user is doing an intereactive thing, or has a menu open then + if the user is doing an interactive thing, or has a menu open then the mouse is grabbed (possibly) and if we get these events we don't want to deal with them */ @@ -849,33 +995,16 @@ static void event_handle_client(ObClient *client, XEvent *e) con = mouse_button_frame_context(con, e->xbutton.button, e->xbutton.state); - if (e->type == ButtonRelease && e->xbutton.button == pb) - pb = 0, px = py = -1; + /* button presses on CLIENT_CONTEXTs are not accompanied by a + release because they are Replayed to the client */ + if ((e->type == ButtonRelease || CLIENT_CONTEXT(con, client)) && + e->xbutton.button == pb) + pb = 0, px = py = -1, pcon = OB_FRAME_CONTEXT_NONE; - switch (con) { - case OB_FRAME_CONTEXT_MAXIMIZE: - client->frame->max_press = (e->type == ButtonPress); - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_CLOSE: - client->frame->close_press = (e->type == ButtonPress); - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_ICONIFY: - client->frame->iconify_press = (e->type == ButtonPress); - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_ALLDESKTOPS: - client->frame->desk_press = (e->type == ButtonPress); + but = context_to_button(client->frame, con, TRUE); + if (but) { + *but = (e->type == ButtonPress); frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_SHADE: - client->frame->shade_press = (e->type == ButtonPress); - frame_adjust_state(client->frame); - break; - default: - /* nothing changes with clicks for any other contexts */ - break; } } break; @@ -895,46 +1024,21 @@ static void event_handle_client(ObClient *client, XEvent *e) client->frame->shade_hover || client->frame->iconify_hover || client->frame->close_hover) { - client->frame->max_hover = FALSE; - client->frame->desk_hover = FALSE; - client->frame->shade_hover = FALSE; - client->frame->iconify_hover = FALSE; - client->frame->close_hover = FALSE; - frame_adjust_state(client->frame); - } - break; - case OB_FRAME_CONTEXT_MAXIMIZE: - if (!client->frame->max_hover) { - client->frame->max_hover = TRUE; - frame_adjust_state(client->frame); - } - break; - case OB_FRAME_CONTEXT_ALLDESKTOPS: - if (!client->frame->desk_hover) { - client->frame->desk_hover = TRUE; - frame_adjust_state(client->frame); - } - break; - case OB_FRAME_CONTEXT_SHADE: - if (!client->frame->shade_hover) { - client->frame->shade_hover = TRUE; - frame_adjust_state(client->frame); - } - break; - case OB_FRAME_CONTEXT_ICONIFY: - if (!client->frame->iconify_hover) { - client->frame->iconify_hover = TRUE; + client->frame->max_hover = + client->frame->desk_hover = + client->frame->shade_hover = + client->frame->iconify_hover = + client->frame->close_hover = FALSE; frame_adjust_state(client->frame); } break; - case OB_FRAME_CONTEXT_CLOSE: - if (!client->frame->close_hover) { - client->frame->close_hover = TRUE; + default: + but = context_to_button(client->frame, con, FALSE); + if (but && !*but && !pb) { + *but = TRUE; frame_adjust_state(client->frame); } break; - default: - break; } break; case LeaveNotify: @@ -945,38 +1049,19 @@ static void event_handle_client(ObClient *client, XEvent *e) case OB_FRAME_CONTEXT_TLCORNER: case OB_FRAME_CONTEXT_TRCORNER: /* we've left the button area inside the titlebar */ - if (client->frame->max_hover || client->frame->desk_hover || - client->frame->shade_hover || client->frame->iconify_hover || - client->frame->close_hover) - { - client->frame->max_hover = FALSE; - client->frame->desk_hover = FALSE; - client->frame->shade_hover = FALSE; - client->frame->iconify_hover = FALSE; + client->frame->max_hover = + client->frame->desk_hover = + client->frame->shade_hover = + client->frame->iconify_hover = client->frame->close_hover = FALSE; - frame_adjust_state(client->frame); + if (e->xcrossing.mode == NotifyGrab) { + client->frame->max_press = + client->frame->desk_press = + client->frame->shade_press = + client->frame->iconify_press = + client->frame->close_press = FALSE; } break; - case OB_FRAME_CONTEXT_MAXIMIZE: - client->frame->max_hover = FALSE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_ALLDESKTOPS: - client->frame->desk_hover = FALSE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_SHADE: - client->frame->shade_hover = FALSE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_ICONIFY: - client->frame->iconify_hover = FALSE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_CLOSE: - client->frame->close_hover = FALSE; - frame_adjust_state(client->frame); - break; case OB_FRAME_CONTEXT_FRAME: /* When the mouse leaves an animating window, don't use the corresponding enter events. Pretend like the animating window @@ -985,24 +1070,34 @@ static void event_handle_client(ObClient *client, XEvent *e) event_end_ignore_all_enters(event_start_ignore_all_enters()); ob_debug_type(OB_DEBUG_FOCUS, - "%sNotify mode %d detail %d on %lx\n", + "%sNotify mode %d detail %d on %lx", (e->type == EnterNotify ? "Enter" : "Leave"), e->xcrossing.mode, e->xcrossing.detail, (client?client->window:0)); if (grab_on_keyboard()) break; - if (config_focus_follow && config_focus_delay && + if (config_focus_follow && /* 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) { - obt_main_loop_timeout_remove_data(ob_main_loop, - focus_delay_func, - client, FALSE); + if (config_focus_delay && focus_delay_timeout_id) + g_source_remove(focus_delay_timeout_id); + if (config_unfocus_leave) + event_leave_client(client); } break; default: + but = context_to_button(client->frame, con, FALSE); + if (but) { + *but = FALSE; + if (e->xcrossing.mode == NotifyGrab) { + but = context_to_button(client->frame, con, TRUE); + *but = FALSE; + } + frame_adjust_state(client->frame); + } break; } break; @@ -1011,38 +1106,19 @@ static void event_handle_client(ObClient *client, XEvent *e) con = frame_context(client, e->xcrossing.window, e->xcrossing.x, e->xcrossing.y); switch (con) { - case OB_FRAME_CONTEXT_MAXIMIZE: - client->frame->max_hover = TRUE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_ALLDESKTOPS: - client->frame->desk_hover = TRUE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_SHADE: - client->frame->shade_hover = TRUE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_ICONIFY: - client->frame->iconify_hover = TRUE; - frame_adjust_state(client->frame); - break; - case OB_FRAME_CONTEXT_CLOSE: - client->frame->close_hover = TRUE; - frame_adjust_state(client->frame); - break; case OB_FRAME_CONTEXT_FRAME: if (grab_on_keyboard()) break; if (e->xcrossing.mode == NotifyGrab || - e->xcrossing.mode == NotifyUngrab || + (e->xcrossing.mode == NotifyUngrab && + /* ungrab enters are used when _under_ mouse is being used */ + !(config_focus_follow && config_focus_under_mouse)) || /*ignore enters when we're already in the window */ - e->xcrossing.detail == NotifyInferior || - is_enter_focus_event_ignored(e)) + e->xcrossing.detail == NotifyInferior) { ob_debug_type(OB_DEBUG_FOCUS, "%sNotify mode %d detail %d serial %lu on %lx " - "IGNORED\n", + "IGNORED", (e->type == EnterNotify ? "Enter" : "Leave"), e->xcrossing.mode, e->xcrossing.detail, @@ -1052,17 +1128,29 @@ static void event_handle_client(ObClient *client, XEvent *e) else { ob_debug_type(OB_DEBUG_FOCUS, "%sNotify mode %d detail %d serial %lu on %lx, " - "focusing window\n", + "focusing window", (e->type == EnterNotify ? "Enter" : "Leave"), e->xcrossing.mode, e->xcrossing.detail, e->xcrossing.serial, (client?client->window:0)); - if (config_focus_follow) + if (config_focus_follow) { + if (config_focus_delay && unfocus_delay_timeout_id) + g_source_remove(unfocus_delay_timeout_id); event_enter_client(client); + } } break; default: + but = context_to_button(client->frame, con, FALSE); + if (but) { + *but = TRUE; + if (e->xcrossing.mode == NotifyUngrab) { + but = context_to_button(client->frame, con, TRUE); + *but = (con == pcon); + } + frame_adjust_state(client->frame); + } break; } break; @@ -1083,10 +1171,10 @@ static void event_handle_client(ObClient *client, XEvent *e) RECT_TO_DIMS(client->area, x, y, w, h); ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d " - "visibile %d\n" - " x %d y %d w %d h %d b %d\n", + "visible %d", client->title, - screen_desktop, client->wmstate, client->frame->visible, + screen_desktop, client->wmstate, client->frame->visible); + ob_debug(" x %d y %d w %d h %d b %d", x, y, w, h, client->border_width); if (e->xconfigurerequest.value_mask & CWBorderWidth) @@ -1096,12 +1184,11 @@ static void event_handle_client(ObClient *client, XEvent *e) /* if the border width is changing then that is the same as requesting a resize, but we don't actually change the client's border, so it will change their root - coordiantes (since they include the border width) and + coordinates (since they include the border width) and we need to a notify then */ move = TRUE; } - if (e->xconfigurerequest.value_mask & CWStackMode) { ObClient *sibling = NULL; gulong ignore_start; @@ -1140,16 +1227,14 @@ static void event_handle_client(ObClient *client, XEvent *e) (e->xconfigurerequest.value_mask & CWWidth) || (e->xconfigurerequest.value_mask & CWHeight)) { + /* don't allow clients to move shaded windows (fvwm does this) + */ if (e->xconfigurerequest.value_mask & CWX) { - /* don't allow clients to move shaded windows (fvwm does this) - */ if (!client->shaded) x = e->xconfigurerequest.x; move = TRUE; } if (e->xconfigurerequest.value_mask & CWY) { - /* don't allow clients to move shaded windows (fvwm does this) - */ if (!client->shaded) y = e->xconfigurerequest.y; move = TRUE; @@ -1166,7 +1251,7 @@ static void event_handle_client(ObClient *client, XEvent *e) } ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d " - "move %d resize %d\n", + "move %d resize %d", e->xconfigurerequest.value_mask & CWX, x, e->xconfigurerequest.value_mask & CWY, y, e->xconfigurerequest.value_mask & CWWidth, w, @@ -1192,7 +1277,7 @@ static void event_handle_client(ObClient *client, XEvent *e) ob_debug_type(OB_DEBUG_APP_BUGS, "Application %s is trying to move via " "ConfigureRequest to it's root window position " - "but it is not using StaticGravity\n", + "but it is not using StaticGravity", client->title); /* don't move it */ x = client->area.x; @@ -1202,8 +1287,46 @@ static void event_handle_client(ObClient *client, XEvent *e) notify is sent or not */ } + /* check for broken apps (java swing) moving to 0,0 when there is a + strut there. + + XXX remove this some day...that would be nice. but really unexpected + from Sun Microsystems. + */ + if (x == 0 && y == 0 && client->gravity == NorthWestGravity && + client_normal(client)) + { + const Rect to = { x, y, w, h }; + + /* oldschool fullscreen windows are allowed */ + if (!client_is_oldfullscreen(client, &to)) { + Rect *r; + + r = screen_area(client->desktop, SCREEN_AREA_ALL_MONITORS, + NULL); + if (r->x || r->y) { + /* move the window only to the corner outside struts */ + x = r->x; + y = r->y; + + ob_debug_type(OB_DEBUG_APP_BUGS, + "Application %s is trying to move via " + "ConfigureRequest to 0,0 using " + "NorthWestGravity, while there is a " + "strut there. " + "Moving buggy app from (0,0) to (%d,%d)", + client->title, r->x, r->y); + } + + g_slice_free(Rect, r); + + /* they still requested a move, so don't change whether a + notify is sent or not */ + } + } + { - gint lw,lh; + gint lw, lh; client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE); @@ -1212,33 +1335,32 @@ static void event_handle_client(ObClient *client, XEvent *e) if ((e->xconfigurerequest.value_mask & CWWidth && !(e->xconfigurerequest.value_mask & CWX))) client_gravity_resize_w(client, &x, client->area.width, w); - /* if y was not given, then use gravity to figure out the new - y. the reference point should not be moved */ + /* same for y */ if ((e->xconfigurerequest.value_mask & CWHeight && !(e->xconfigurerequest.value_mask & CWY))) client_gravity_resize_h(client, &y, client->area.height,h); client_find_onscreen(client, &x, &y, w, h, FALSE); - ob_debug("Granting ConfigureRequest x %d y %d w %d h %d\n", + ob_debug("Granting ConfigureRequest x %d y %d w %d h %d", x, y, w, h); client_configure(client, x, y, w, h, FALSE, TRUE, TRUE); } break; } case UnmapNotify: + ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d " + "ignores left %d", + client->window, e->xunmap.event, e->xunmap.from_configure, + client->ignore_unmaps); if (client->ignore_unmaps) { 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); + ob_debug("DestroyNotify for window 0x%x", client->window); client_unmanage(client); break; case ReparentNotify: @@ -1252,21 +1374,17 @@ static void event_handle_client(ObClient *client, XEvent *e) to an already unmapped window. */ - /* we don't want the reparent event, put it back on the stack for the - X server to deal with after we unmanage the window */ - XPutBackEvent(obt_display, e); - - ob_debug("ReparentNotify for window 0x%x\n", client->window); + ob_debug("ReparentNotify for window 0x%x", client->window); client_unmanage(client); break; case MapRequest: - ob_debug("MapRequest for 0x%lx\n", client->window); + ob_debug("MapRequest for 0x%lx", client->window); if (!client->iconic) break; /* this normally doesn't happen, but if it does, we don't want it! it can happen now when the window is on another desktop, but we still don't want it! */ - client_activate(client, FALSE, TRUE, TRUE, TRUE); + client_activate(client, FALSE, FALSE, TRUE, TRUE, TRUE); break; case ClientMessage: /* validate cuz we query stuff off the client here */ @@ -1276,41 +1394,21 @@ static void event_handle_client(ObClient *client, XEvent *e) msgtype = e->xclient.message_type; if (msgtype == OBT_PROP_ATOM(WM_CHANGE_STATE)) { - /* compress changes into a single change */ - while (XCheckTypedWindowEvent(obt_display, client->window, - e->type, &ce)) { - /* XXX: it would be nice to compress ALL messages of a - type, not just messages in a row without other - message types between. */ - if (ce.xclient.message_type != msgtype) { - XPutBackEvent(obt_display, &ce); - break; - } - e->xclient = ce.xclient; - } - client_set_wm_state(client, e->xclient.data.l[0]); + if (!more_client_message_event(client->window, msgtype)) + client_set_wm_state(client, e->xclient.data.l[0]); } else if (msgtype == OBT_PROP_ATOM(NET_WM_DESKTOP)) { - /* compress changes into a single change */ - while (XCheckTypedWindowEvent(obt_display, client->window, - e->type, &ce)) { - /* XXX: it would be nice to compress ALL messages of a - type, not just messages in a row without other - message types between. */ - if (ce.xclient.message_type != msgtype) { - XPutBackEvent(obt_display, &ce); - break; - } - e->xclient = ce.xclient; - } - if ((unsigned)e->xclient.data.l[0] < screen_num_desktops || - (unsigned)e->xclient.data.l[0] == DESKTOP_ALL) + if (!more_client_message_event(client->window, msgtype) && + ((unsigned)e->xclient.data.l[0] < screen_num_desktops || + (unsigned)e->xclient.data.l[0] == DESKTOP_ALL)) + { client_set_desktop(client, (unsigned)e->xclient.data.l[0], FALSE, FALSE); + } } else if (msgtype == OBT_PROP_ATOM(NET_WM_STATE)) { gulong ignore_start; /* can't compress these */ - ob_debug("net_wm_state %s %ld %ld for 0x%lx\n", + ob_debug("net_wm_state %s %ld %ld for 0x%lx", (e->xclient.data.l[0] == 0 ? "Remove" : e->xclient.data.l[0] == 1 ? "Add" : e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"), @@ -1325,33 +1423,46 @@ static void event_handle_client(ObClient *client, XEvent *e) if (!config_focus_under_mouse) event_end_ignore_all_enters(ignore_start); } else if (msgtype == OBT_PROP_ATOM(NET_CLOSE_WINDOW)) { - ob_debug("net_close_window for 0x%lx\n", client->window); + ob_debug("net_close_window for 0x%lx", client->window); client_close(client); } else if (msgtype == OBT_PROP_ATOM(NET_ACTIVE_WINDOW)) { - ob_debug("net_active_window for 0x%lx source=%s\n", + ob_debug("net_active_window for 0x%lx source=%s", client->window, (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[2] !? */ if (e->xclient.data.l[0] == 1 || e->xclient.data.l[0] == 2) { - /* don't use the user's timestamp for client_focus, cuz if it's - an old broken timestamp (happens all the time) then focus - won't move even though we're trying to move it - event_curtime = e->xclient.data.l[1];*/ + /* we can not trust the timestamp from applications. + e.g. chromium passes a very old timestamp. openbox thinks + the window will get focus and calls XSetInputFocus with the + (old) timestamp, which doesn't end up moving focus at all. + but the window is raised, not hilited, etc, as if it was + really going to get focus. + + so do not use this timestamp in event_curtime, as this would + be used in XSetInputFocus. + */ + event_sourcetime = e->xclient.data.l[1]; if (e->xclient.data.l[1] == 0) ob_debug_type(OB_DEBUG_APP_BUGS, "_NET_ACTIVE_WINDOW message for window %s is" - " missing a timestamp\n", client->title); + " missing a timestamp", client->title); } else ob_debug_type(OB_DEBUG_APP_BUGS, "_NET_ACTIVE_WINDOW message for window %s is " - "missing source indication\n"); - client_activate(client, FALSE, TRUE, TRUE, - (e->xclient.data.l[0] == 0 || - e->xclient.data.l[0] == 2)); + "missing source indication", client->title); + /* TODO(danakj) This should use + (e->xclient.data.l[0] == 0 || + e->xclient.data.l[0] == 2) + to determine if a user requested the activation, however GTK+ + applications seem unable to make this distinction ever + (including panels such as xfce4-panel and gnome-panel). + So we are left just assuming all activations are from the user. + */ + client_activate(client, FALSE, FALSE, TRUE, TRUE, TRUE); } else if (msgtype == OBT_PROP_ATOM(NET_WM_MOVERESIZE)) { - ob_debug("net_wm_moveresize for 0x%lx direction %d\n", + ob_debug("net_wm_moveresize for 0x%lx direction %d", client->window, e->xclient.data.l[2]); if ((Atom)e->xclient.data.l[2] == OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT) || @@ -1384,7 +1495,8 @@ static void event_handle_client(ObClient *client, XEvent *e) } else if ((Atom)e->xclient.data.l[2] == OBT_PROP_ATOM(NET_WM_MOVERESIZE_CANCEL)) - moveresize_end(TRUE); + if (moveresize_client) + moveresize_end(TRUE); } else if (msgtype == OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW)) { gint ograv, x, y, w, h; @@ -1416,15 +1528,14 @@ static void event_handle_client(ObClient *client, XEvent *e) if (e->xclient.data.l[0] & 1 << 11) { h = e->xclient.data.l[4]; - /* if y was not given, then use gravity to figure out the new - y. the reference point should not be moved */ + /* same for y */ if (!(e->xclient.data.l[0] & 1 << 9)) client_gravity_resize_h(client, &y, client->area.height,h); } else h = client->area.height; - ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)\n", + ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)", e->xclient.data.l[0] & 1 << 8, x, e->xclient.data.l[0] & 1 << 9, y, client->gravity); @@ -1438,7 +1549,7 @@ static void event_handle_client(ObClient *client, XEvent *e) if (e->xclient.data.l[0] != 2) { ob_debug_type(OB_DEBUG_APP_BUGS, "_NET_RESTACK_WINDOW sent for window %s with " - "invalid source indication %ld\n", + "invalid source indication %ld", client->title, e->xclient.data.l[0]); } else { ObClient *sibling = NULL; @@ -1452,7 +1563,7 @@ static void event_handle_client(ObClient *client, XEvent *e) if (sibling == NULL) ob_debug_type(OB_DEBUG_APP_BUGS, "_NET_RESTACK_WINDOW sent for window %s " - "with invalid sibling 0x%x\n", + "with invalid sibling 0x%x", client->title, e->xclient.data.l[1]); } if (e->xclient.data.l[2] == Below || @@ -1477,7 +1588,7 @@ static void event_handle_client(ObClient *client, XEvent *e) } else ob_debug_type(OB_DEBUG_APP_BUGS, "_NET_RESTACK_WINDOW sent for window %s " - "with invalid detail %d\n", + "with invalid detail %d", client->title, e->xclient.data.l[2]); } } @@ -1486,54 +1597,59 @@ static void event_handle_client(ObClient *client, XEvent *e) /* validate cuz we query stuff off the client here */ if (!client_validate(client)) break; - /* compress changes to a single property into a single change */ - while (XCheckTypedWindowEvent(obt_display, client->window, - e->type, &ce)) { - Atom a, b; - - /* XXX: it would be nice to compress ALL changes to a property, - not just changes in a row without other props between. */ - - a = ce.xproperty.atom; - b = e->xproperty.atom; - - if (a == b) - continue; - if ((a == OBT_PROP_ATOM(NET_WM_NAME) || - a == OBT_PROP_ATOM(WM_NAME) || - a == OBT_PROP_ATOM(NET_WM_ICON_NAME) || - a == OBT_PROP_ATOM(WM_ICON_NAME)) - && - (b == OBT_PROP_ATOM(NET_WM_NAME) || - b == OBT_PROP_ATOM(WM_NAME) || - b == OBT_PROP_ATOM(NET_WM_ICON_NAME) || - b == OBT_PROP_ATOM(WM_ICON_NAME))) { - continue; - } - if (a == OBT_PROP_ATOM(NET_WM_ICON) && - b == OBT_PROP_ATOM(NET_WM_ICON)) - continue; + msgtype = e->xproperty.atom; - XPutBackEvent(obt_display, &ce); - break; + /* ignore changes to some properties if there is another change + coming in the queue */ + { + struct ObSkipPropertyChange s; + s.window = client->window; + s.prop = msgtype; + if (xqueue_exists_local(skip_property_change, &s)) + break; } msgtype = e->xproperty.atom; if (msgtype == XA_WM_NORMAL_HINTS) { - ob_debug("Update NORMAL hints\n"); + int x, y, w, h, lw, lh; + + ob_debug("Update NORMAL hints"); client_update_normal_hints(client); /* normal hints can make a window non-resizable */ client_setup_decor_and_functions(client, FALSE); - /* make sure the client's sizes are within its bounds, but only - reconfigure the window if it needs to. emacs will update its - normal hints every time it receives a conigurenotify */ - client_reconfigure(client, FALSE); + x = client->area.x; + y = client->area.y; + w = client->area.width; + h = client->area.height; + + /* apply the new normal hints */ + client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE); + /* make sure the window is visible, and if the window is resized + off-screen due to the normal hints changing then this will push + it back onto the screen. */ + client_find_onscreen(client, &x, &y, w, h, FALSE); + + /* make sure the client's sizes are within its bounds, but don't + make it reply with a configurenotify unless something changed. + emacs will update its normal hints every time it receives a + configurenotify */ + client_configure(client, x, y, w, h, FALSE, TRUE, FALSE); + } else if (msgtype == OBT_PROP_ATOM(MOTIF_WM_HINTS)) { + client_get_mwm_hints(client); + /* This can override some mwm hints */ + client_get_type_and_transientness(client); + + /* Apply the changes to the window */ + client_setup_decor_and_functions(client, TRUE); } else if (msgtype == XA_WM_HINTS) { client_update_wmhints(client); } else if (msgtype == XA_WM_TRANSIENT_FOR) { - client_update_transient_for(client); + /* get the transient-ness first, as this affects if the client + decides to be transient for the group or not in + client_update_transient_for() */ client_get_type_and_transientness(client); + client_update_transient_for(client); /* type may have changed, so update the layer */ client_calc_layer(client); client_setup_decor_and_functions(client, TRUE); @@ -1544,12 +1660,9 @@ static void event_handle_client(ObClient *client, XEvent *e) client_update_title(client); } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) { client_update_protocols(client); - client_setup_decor_and_functions(client, TRUE); } - else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT)) { - client_update_strut(client); - } - else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL)) { + else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT) || + msgtype == OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL)) { client_update_strut(client); } else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON)) { @@ -1569,8 +1682,17 @@ static void event_handle_client(ObClient *client, XEvent *e) event_last_user_time = t; } } + else if (msgtype == OBT_PROP_ATOM(NET_WM_WINDOW_OPACITY)) { + client_update_opacity(client); + } #ifdef SYNC else if (msgtype == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER)) { + /* if they are resizing right now this would cause weird behaviour. + if one day a user reports clients stop resizing, then handle + this better by resetting a new XSync alarm and stuff on the + new counter, but I expect it will never happen */ + if (moveresize_client == client) + moveresize_end(FALSE); client_update_sync_request_counter(client); } #endif @@ -1581,11 +1703,28 @@ static void event_handle_client(ObClient *client, XEvent *e) default: ; #ifdef SHAPE - if (obt_display_extension_shape && - e->type == obt_display_extension_shape_basep) { - client->shaped = ((XShapeEvent*)e)->shaped; - frame_adjust_shape(client->frame); + int kind; + if (obt_display_extension_shape && + e->type == obt_display_extension_shape_basep) + { + switch (((XShapeEvent*)e)->kind) { + case ShapeBounding: + case ShapeClip: + client->shaped = ((XShapeEvent*)e)->shaped; + kind = ShapeBounding; + break; +#ifdef ShapeInput + case ShapeInput: + client->shaped_input = ((XShapeEvent*)e)->shaped; + kind = ShapeInput; + break; +#endif + default: + g_assert_not_reached(); + } + frame_adjust_shape_kind(client->frame, kind); + } } #endif } @@ -1594,12 +1733,6 @@ static void event_handle_client(ObClient *client, XEvent *e) static void event_handle_dock(ObDock *s, XEvent *e) { switch (e->type) { - case ButtonPress: - if (e->xbutton.button == 1) - stacking_raise(DOCK_AS_WINDOW(s)); - else if (e->xbutton.button == 2) - stacking_lower(DOCK_AS_WINDOW(s)); - break; case EnterNotify: dock_hide(FALSE); break; @@ -1622,13 +1755,11 @@ static void event_handle_dockapp(ObDockApp *app, XEvent *e) app->ignore_unmaps--; break; } - dock_remove(app, TRUE); + dock_unmanage(app, TRUE); break; case DestroyNotify: - dock_remove(app, FALSE); - break; case ReparentNotify: - dock_remove(app, FALSE); + dock_unmanage(app, FALSE); break; case ConfigureNotify: dock_app_configure(app, e->xconfigure.width, e->xconfigure.height); @@ -1660,104 +1791,132 @@ static ObMenuFrame* find_active_or_last_menu(void) return ret; } +static gboolean event_handle_prompt(ObPrompt *p, XEvent *e) +{ + switch (e->type) { + case ButtonPress: + case ButtonRelease: + case MotionNotify: + return prompt_mouse_event(p, e); + break; + case KeyPress: + return prompt_key_event(p, e); + break; + } + return FALSE; +} + static gboolean event_handle_menu_input(XEvent *ev) { gboolean ret = FALSE; - if (ev->type == ButtonRelease) { + if (ev->type == ButtonRelease || ev->type == ButtonPress) { ObMenuEntryFrame *e; - if (menu_hide_delay_reached() && - (ev->xbutton.button < 4 || ev->xbutton.button > 5)) + if ((ev->xbutton.button < 4 || ev->xbutton.button > 5) && + ((ev->type == ButtonRelease && menu_hide_delay_reached()) || + ev->type == ButtonPress)) { if ((e = menu_entry_frame_under(ev->xbutton.x_root, ev->xbutton.y_root))) { + if (ev->type == ButtonPress && e->frame->child) + menu_frame_select(e->frame->child, NULL, TRUE); menu_frame_select(e->frame, e, TRUE); - menu_entry_frame_execute(e, ev->xbutton.state); + if (ev->type == ButtonRelease) + menu_entry_frame_execute(e, ev->xbutton.state); } else menu_frame_hide_all(); } ret = TRUE; } - else if (ev->type == MotionNotify) { - ObMenuFrame *f; - ObMenuEntryFrame *e; - - if ((e = menu_entry_frame_under(ev->xmotion.x_root, - ev->xmotion.y_root))) - if (!(f = find_active_menu()) || - f == e->frame || - f->parent == e->frame || - f->child == e->frame) - menu_frame_select(e->frame, e, FALSE); - } else if (ev->type == KeyPress || ev->type == KeyRelease) { - guint keycode, state; - gunichar unikey; + guint mods; ObMenuFrame *frame; - keycode = ev->xkey.keycode; - state = ev->xkey.state; - unikey = obt_keyboard_keycode_to_unichar(keycode); + /* get the modifiers */ + mods = obt_keyboard_only_modmasks(ev->xkey.state); frame = find_active_or_last_menu(); if (frame == NULL) g_assert_not_reached(); /* there is no active menu */ /* Allow control while going thru the menu */ - else if (ev->type == KeyPress && (state & ~ControlMask) == 0) { + else if (ev->type == KeyPress && (mods & ~ControlMask) == 0) { + gunichar unikey; + KeySym sym; + frame->got_press = TRUE; + frame->press_keycode = ev->xkey.keycode; + frame->press_doexec = FALSE; + + sym = obt_keyboard_keypress_to_keysym(ev); - if (keycode == ob_keycode(OB_KEY_ESCAPE)) { + if (sym == XK_Escape) { menu_frame_hide_all(); ret = TRUE; } - else if (keycode == ob_keycode(OB_KEY_LEFT)) { + else if (sym == XK_Left) { /* Left goes to the parent menu */ - menu_frame_select(frame, NULL, TRUE); + if (frame->parent) { + /* remove focus from the child */ + menu_frame_select(frame, NULL, TRUE); + /* and put it in the parent */ + menu_frame_select(frame->parent, frame->parent->selected, + TRUE); + } ret = TRUE; } - else if (keycode == ob_keycode(OB_KEY_RIGHT)) { - /* Right goes to the selected submenu */ - if (frame->child) menu_frame_select_next(frame->child); + else if (sym == XK_Right || sym == XK_Return || sym == XK_KP_Enter) + { + /* Right and enter goes to the selected submenu. + Enter executes instead if it's not on a submenu. */ + + if (frame->selected) { + const ObMenuEntryType t = frame->selected->entry->type; + + if (t == OB_MENU_ENTRY_TYPE_SUBMENU) { + /* make sure it is visible */ + menu_frame_select(frame, frame->selected, TRUE); + /* move focus to the child menu */ + menu_frame_select_next(frame->child); + } + else if (sym != XK_Right) { + frame->press_doexec = TRUE; + } + } ret = TRUE; } - else if (keycode == ob_keycode(OB_KEY_UP)) { + else if (sym == XK_Up) { menu_frame_select_previous(frame); ret = TRUE; } - else if (keycode == ob_keycode(OB_KEY_DOWN)) { + else if (sym == XK_Down) { menu_frame_select_next(frame); ret = TRUE; } - } - - /* Use KeyRelease events for running things so that the key release - doesn't get sent to the focused application. - Allow ControlMask only, and don't bother if the menu is empty */ - else if (ev->type == KeyRelease && (state & ~ControlMask) == 0 && - frame->entries && frame->got_press) - { - if (keycode == ob_keycode(OB_KEY_RETURN)) { - /* Enter runs the active item or goes into the submenu. - Control-Enter runs it without closing the menu. */ - if (frame->child) - menu_frame_select_next(frame->child); - else if (frame->selected) - menu_entry_frame_execute(frame->selected, state); + else if (sym == XK_Home) { + menu_frame_select_first(frame); + ret = TRUE; + } + else if (sym == XK_End) { + menu_frame_select_last(frame); ret = TRUE; } /* keyboard accelerator shortcuts. (if it was a valid key) */ - else if (unikey != 0) { + else if (frame->entries && + (unikey = + obt_keyboard_keypress_to_unichar(menu_frame_ic(frame), + ev))) + { GList *start; GList *it; ObMenuEntryFrame *found = NULL; @@ -1795,34 +1954,69 @@ static gboolean event_handle_menu_input(XEvent *ev) } 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); /* highlight the item for a short bit so - the user can see what happened */ - menu_entry_frame_execute(found, state); - } else { - menu_frame_select(frame, found, TRUE); - if (num_found == 1) + menu_frame_select(frame, found, TRUE); + + if (num_found == 1) { + if (found->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU) { + /* move focus to the child menu */ menu_frame_select_next(frame->child); + } + else { + frame->press_doexec = TRUE; + } } - ret = TRUE; } } } + + /* Use KeyRelease events for running things so that the key release + doesn't get sent to the focused application. + + Allow ControlMask only, and don't bother if the menu is empty */ + else if (ev->type == KeyRelease && (mods & ~ControlMask) == 0) { + if (frame->press_keycode == ev->xkey.keycode && + frame->got_press && + frame->press_doexec) + { + if (frame->selected) + menu_entry_frame_execute(frame->selected, ev->xkey.state); + } + } } return ret; } +static gboolean event_look_for_menu_enter(XEvent *ev, gpointer data) +{ + const ObMenuFrame *f = (ObMenuFrame*)data; + ObMenuEntryFrame *e; + return ev->type == EnterNotify && + (e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)) && + e->frame == f && !e->ignore_enters; +} + static void event_handle_menu(ObMenuFrame *frame, XEvent *ev) { ObMenuFrame *f; ObMenuEntryFrame *e; switch (ev->type) { + case MotionNotify: + /* We need to catch MotionNotify in addition to EnterNotify because + it is possible for the menu to be opened under the mouse cursor, and + moving the mouse should select the item. */ + if ((e = g_hash_table_lookup(menu_frame_map, &ev->xmotion.window))) { + if (e->ignore_enters) + --e->ignore_enters; + else if (!(f = find_active_menu()) || + f == e->frame || + f->parent == e->frame || + f->child == e->frame) + menu_frame_select(e->frame, e, FALSE); + } + break; case EnterNotify: if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) { if (e->ignore_enters) @@ -1835,21 +2029,21 @@ static void event_handle_menu(ObMenuFrame *frame, XEvent *ev) } break; case LeaveNotify: - /*ignore leaves when we're already in the window */ + /* ignore leaves when we're already in the window */ if (ev->xcrossing.detail == NotifyInferior) break; - 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) - { - menu_frame_select(e->frame, NULL, FALSE); + if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) { + /* check if an EnterNotify event is coming, and if not, then select + nothing in the menu */ + if (!xqueue_exists_local(event_look_for_menu_enter, e->frame)) + menu_frame_select(e->frame, NULL, FALSE); } break; } } -static void event_handle_user_input(ObClient *client, XEvent *e) +static gboolean event_handle_user_input(ObClient *client, XEvent *e) { g_assert(e->type == ButtonPress || e->type == ButtonRelease || e->type == MotionNotify || e->type == KeyPress || @@ -1860,49 +2054,52 @@ static void event_handle_user_input(ObClient *client, XEvent *e) /* don't use the event if the menu used it, but if the menu didn't use it and it's a keypress that is bound, it will close the menu and be used */ - return; + return TRUE; } /* if the keyboard interactive action uses the event then dont use it for bindings. likewise is moveresize uses the event. */ - if (!actions_interactive_input_event(e) && !moveresize_event(e)) { - if (moveresize_in_progress) - /* make further actions work on the client being - moved/resized */ - client = moveresize_client; - - if (e->type == ButtonPress || - e->type == ButtonRelease || - e->type == MotionNotify) - { - /* the frame may not be "visible" but they can still click on it - in the case where it is animating before disappearing */ - if (!client || !frame_iconify_animating(client->frame)) - mouse_event(client, e); - } else - keyboard_event((focus_cycle_target ? focus_cycle_target : - (client ? client : focus_client)), e); - } + if (actions_interactive_input_event(e) || moveresize_event(e)) + return TRUE; + + if (moveresize_in_progress) + /* make further actions work on the client being + moved/resized */ + client = moveresize_client; + + if (e->type == ButtonPress || + e->type == ButtonRelease || + e->type == MotionNotify) + { + /* the frame may not be "visible" but they can still click on it + in the case where it is animating before disappearing */ + if (!client || !frame_iconify_animating(client->frame)) + return mouse_event(client, e); + } else + return keyboard_event((focus_cycle_target ? focus_cycle_target : + (client ? client : focus_client)), e); + + return FALSE; } static void focus_delay_dest(gpointer data) { - g_free(data); + g_slice_free(ObFocusDelayData, data); + focus_delay_timeout_id = 0; + focus_delay_timeout_client = NULL; } -static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2) +static void unfocus_delay_dest(gpointer data) { - const ObFocusDelayData *f1 = d1; - return f1->client == d2; + g_slice_free(ObFocusDelayData, data); + unfocus_delay_timeout_id = 0; + unfocus_delay_timeout_client = NULL; } static gboolean focus_delay_func(gpointer data) { ObFocusDelayData *d = data; - Time old = event_curtime; - - /* don't move focus and kill the menu or the move/resize */ - if (menu_frame_visible || moveresize_in_progress) return FALSE; + Time old = event_curtime; /* save the curtime */ event_curtime = d->time; event_curserial = d->serial; @@ -1912,23 +2109,37 @@ static gboolean focus_delay_func(gpointer data) return FALSE; /* no repeat */ } +static gboolean unfocus_delay_func(gpointer data) +{ + ObFocusDelayData *d = data; + Time old = event_curtime; /* save the curtime */ + + event_curtime = d->time; + event_curserial = d->serial; + focus_nothing(); + event_curtime = old; + return FALSE; /* no repeat */ +} + static void focus_delay_client_dest(ObClient *client, gpointer data) { - obt_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func, - client, FALSE); + if (focus_delay_timeout_client == client && focus_delay_timeout_id) + g_source_remove(focus_delay_timeout_id); + if (unfocus_delay_timeout_client == client && unfocus_delay_timeout_id) + g_source_remove(unfocus_delay_timeout_id); } void event_halt_focus_delay(void) { /* ignore all enter events up till the event which caused this to occur */ if (event_curserial) event_ignore_enter_range(1, event_curserial); - obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func); + if (focus_delay_timeout_id) g_source_remove(focus_delay_timeout_id); + if (unfocus_delay_timeout_id) g_source_remove(unfocus_delay_timeout_id); } gulong event_start_ignore_all_enters(void) { - XSync(obt_display, FALSE); - return LastKnownRequestProcessed(obt_display); + return NextRequest(obt_display); } static void event_ignore_enter_range(gulong start, gulong end) @@ -1938,44 +2149,44 @@ static void event_ignore_enter_range(gulong start, gulong end) g_assert(start != 0); g_assert(end != 0); - r = g_new(ObSerialRange, 1); + r = g_slice_new(ObSerialRange); r->start = start; r->end = end; ignore_serials = g_slist_prepend(ignore_serials, r); - ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu\n", + ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu", r->start, r->end); /* increment the serial so we don't ignore events we weren't meant to */ - XSync(obt_display, FALSE); + OBT_PROP_ERASE(screen_support_win, MOTIF_WM_HINTS); } void event_end_ignore_all_enters(gulong start) { - XSync(obt_display, FALSE); - event_ignore_enter_range(start, LastKnownRequestProcessed(obt_display)); + /* Use (NextRequest-1) so that we ignore up to the current serial only. + Inside event_ignore_enter_range, we increment the serial by one, but if + we ignore that serial too, then any enter events generated by mouse + movement will be ignored until we create some further network traffic. + Instead ignore up to NextRequest-1, then when we increment the serial, + we will be *past* the range of ignored serials */ + event_ignore_enter_range(start, NextRequest(obt_display)-1); } -static gboolean is_enter_focus_event_ignored(XEvent *e) +static gboolean is_enter_focus_event_ignored(gulong serial) { GSList *it, *next; - g_assert(e->type == EnterNotify && - !(e->xcrossing.mode == NotifyGrab || - e->xcrossing.mode == NotifyUngrab || - e->xcrossing.detail == NotifyInferior)); - for (it = ignore_serials; it; it = next) { ObSerialRange *r = it->data; next = g_slist_next(it); - if ((glong)(e->xany.serial - r->end) > 0) { + if ((glong)(serial - r->end) > 0) { /* past the end */ ignore_serials = g_slist_delete_link(ignore_serials, it); - g_free(r); + g_slice_free(ObSerialRange, r); } - else if ((glong)(e->xany.serial - r->start) >= 0) + else if ((glong)(serial - r->start) >= 0) return TRUE; } return FALSE; @@ -1985,19 +2196,19 @@ void event_cancel_all_key_grabs(void) { if (actions_interactive_act_running()) { actions_interactive_cancel_act(); - ob_debug("KILLED interactive action\n"); + ob_debug("KILLED interactive action"); } else if (menu_frame_visible) { menu_frame_hide_all(); - ob_debug("KILLED open menus\n"); + ob_debug("KILLED open menus"); } else if (moveresize_in_progress) { moveresize_end(TRUE); - ob_debug("KILLED interactive moveresize\n"); + ob_debug("KILLED interactive moveresize"); } else if (grab_on_keyboard()) { ungrab_keyboard(); - ob_debug("KILLED active grab on keyboard\n"); + ob_debug("KILLED active grab on keyboard"); } else ungrab_passive_key(); @@ -2005,7 +2216,7 @@ void event_cancel_all_key_grabs(void) XSync(obt_display, FALSE); } -gboolean event_time_after(Time t1, Time t2) +gboolean event_time_after(guint32 t1, guint32 t2) { g_assert(t1 != CurrentTime); g_assert(t2 != CurrentTime); @@ -2018,8 +2229,10 @@ gboolean event_time_after(Time t1, Time t2) - 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)) + /* TIME_HALF is not half of the number space of a Time type variable. + * Rather, it is half the number space of a timestamp value, which is + * always 32 bits. */ +#define TIME_HALF (guint32)(1 << 31) if (t2 >= TIME_HALF) /* t2 is in the second half so t1 might wrap around and be smaller than @@ -2030,14 +2243,60 @@ gboolean event_time_after(Time t1, Time t2) return t1 >= t2 && t1 < (t2 + TIME_HALF); } -Time event_get_server_time(void) +gboolean find_timestamp(XEvent *e, gpointer data) +{ + const Time t = event_get_timestamp(e); + if (t && t >= event_curtime) { + event_curtime = t; + return TRUE; + } + else + return FALSE; +} + +static Time next_time(void) { - /* Generate a timestamp */ - XEvent event; + /* Some events don't come with timestamps :( + ...but we can get one anyways >:) */ + /* Generate a timestamp so there is guaranteed at least one in the queue + eventually */ XChangeProperty(obt_display, screen_support_win, OBT_PROP_ATOM(WM_CLASS), OBT_PROP_ATOM(STRING), 8, PropModeAppend, NULL, 0); - XWindowEvent(obt_display, screen_support_win, PropertyChangeMask, &event); - return event.xproperty.time; + + /* Grab the first timestamp available */ + xqueue_exists(find_timestamp, NULL); + + /*g_assert(event_curtime != CurrentTime);*/ + + /* Save the time so we don't have to do this again for this event */ + return event_curtime; +} + +Time event_time(void) +{ + if (event_curtime) return event_curtime; + + return next_time(); +} + +Time event_source_time(void) +{ + return event_sourcetime; +} + +void event_reset_time(void) +{ + next_time(); +} + +void event_update_user_time(void) +{ + event_last_user_time = event_time(); +} + +void event_reset_user_time(void) +{ + event_last_user_time = CurrentTime; }