#include "menu.h"
#include "menuframe.h"
#include "keyboard.h"
+#include "modkeys.h"
#include "mouse.h"
#include "mainloop.h"
#include "framerender.h"
#include "group.h"
#include "stacking.h"
#include "extensions.h"
+#include "translate.h"
#include <X11/Xlib.h>
#include <X11/keysym.h>
#ifdef HAVE_SIGNAL_H
# include <signal.h>
#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h> /* for usleep() */
+#endif
#ifdef XKB
# include <X11/XKBlib.h>
#endif
static void event_process(const XEvent *e, gpointer data);
static void event_handle_root(XEvent *e);
-static void event_handle_menu(XEvent *e);
+static gboolean event_handle_menu_keyboard(XEvent *e);
+static gboolean 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 event_handle_user_input(ObClient *client, XEvent *e);
static void focus_delay_dest(gpointer data);
static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2);
/* The time for the current event being processed */
Time event_curtime = CurrentTime;
-/*! The value of the mask for the NumLock modifier */
-guint NumLockMask;
-/*! The value of the mask for the ScrollLock modifier */
-guint ScrollLockMask;
-/*! The key codes for the modifier keys */
-static XModifierKeymap *modmap;
-/*! Table of the constant modifier masks */
-static const gint mask_table[] = {
- ShiftMask, LockMask, ControlMask, Mod1Mask,
- Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
-};
-static gint mask_table_size;
-
static guint ignore_enter_focus = 0;
-
static gboolean menu_can_hide;
+static gboolean focus_left_screen = FALSE;
#ifdef USE_SM
static void ice_handler(gint fd, gpointer conn)
{
if (reconfig) return;
- mask_table_size = sizeof(mask_table) / sizeof(mask_table[0]);
-
- /* get lock masks that are defined by the display (not constant) */
- modmap = XGetModifierMapping(ob_display);
- g_assert(modmap);
- if (modmap && modmap->max_keypermod > 0) {
- size_t cnt;
- const size_t size = mask_table_size * modmap->max_keypermod;
- /* get the values of the keyboard lock modifiers
- Note: Caps lock is not retrieved the same way as Scroll and Num
- lock since it doesn't need to be. */
- const KeyCode num_lock = XKeysymToKeycode(ob_display, XK_Num_Lock);
- const KeyCode scroll_lock = XKeysymToKeycode(ob_display,
- XK_Scroll_Lock);
-
- for (cnt = 0; cnt < size; ++cnt) {
- if (! modmap->modifiermap[cnt]) continue;
-
- if (num_lock == modmap->modifiermap[cnt])
- NumLockMask = mask_table[cnt / modmap->max_keypermod];
- if (scroll_lock == modmap->modifiermap[cnt])
- ScrollLockMask = mask_table[cnt / modmap->max_keypermod];
- }
- }
-
ob_main_loop_x_add(ob_main_loop, event_process, NULL, NULL);
#ifdef USE_SM
#endif
client_remove_destructor(focus_delay_client_dest);
- XFreeModifiermap(modmap);
}
static Window event_get_window(XEvent *e)
window = None;
}
} else
+#endif
+#ifdef SYNC
+ if (extensions_sync &&
+ e->type == extensions_sync_event_basep + XSyncAlarmNotify)
+ {
+ window = None;
+ } else
#endif
window = e->xany.window;
}
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;
event_curtime = t;
}
-#define STRIP_MODS(s) \
- s &= ~(LockMask | NumLockMask | ScrollLockMask), \
- /* kill off the Button1Mask etc, only want the modifiers */ \
- s &= (ControlMask | ShiftMask | Mod1Mask | \
- Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask) \
-
static void event_hack_mods(XEvent *e)
{
#ifdef XKB
XkbStateRec xkb_state;
#endif
- KeyCode *kp;
- gint i, k;
switch (e->type) {
case ButtonPress:
case ButtonRelease:
- STRIP_MODS(e->xbutton.state);
+ e->xbutton.state = modkeys_only_modifier_masks(e->xbutton.state);
break;
case KeyPress:
- STRIP_MODS(e->xkey.state);
+ e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
break;
case KeyRelease:
- STRIP_MODS(e->xkey.state);
- /* remove from the state the mask of the modifier being released, if
- it is a modifier key being released (this is a little ugly..) */
+ e->xkey.state = modkeys_only_modifier_masks(e->xkey.state);
#ifdef XKB
if (XkbGetState(ob_display, XkbUseCoreKbd, &xkb_state) == Success) {
e->xkey.state = xkb_state.compat_state;
break;
}
#endif
- kp = modmap->modifiermap;
- for (i = 0; i < mask_table_size; ++i) {
- for (k = 0; k < modmap->max_keypermod; ++k) {
- if (*kp == e->xkey.keycode) { /* found the keycode */
- /* remove the mask for it */
- e->xkey.state &= ~mask_table[i];
- /* cause the first loop to break; */
- i = mask_table_size;
- break; /* get outta here! */
- }
- ++kp;
- }
- }
+ /* 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 &= ~modkeys_keycode_to_mask(e->xkey.keycode);
break;
case MotionNotify:
- STRIP_MODS(e->xmotion.state);
+ e->xmotion.state = modkeys_only_modifier_masks(e->xmotion.state);
/* compress events */
{
XEvent ce;
/* This means focus moved from one client to another */
if (detail == NotifyNonlinearVirtual)
return TRUE;
+ /* This means focus moved to the frame window */
+ if (detail == NotifyInferior)
+ return TRUE;
/* Otherwise.. */
return FALSE;
/* crossing events for menu */
event_handle_menu(e);
} else if (e->type == FocusIn) {
- if (client && client != focus_client) {
+ if (e->xfocus.detail == NotifyPointerRoot ||
+ e->xfocus.detail == NotifyDetailNone)
+ {
+ ob_debug_type(OB_DEBUG_FOCUS, "Focus went to pointer root/none\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
+ */
+ if (!focus_left_screen)
+ focus_fallback(TRUE);
+ } else if (e->xfocus.detail == NotifyInferior) {
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to root or our frame window");
+ /* Focus has been given to the root window. */
+ focus_fallback(TRUE);
+ } else if (client && client != focus_client) {
+ focus_left_screen = FALSE;
frame_adjust_focus(client->frame, TRUE);
focus_set_client(client);
client_calc_layer(client);
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");
+ Window win, root;
+ gint i;
+ guint u;
+ xerror_set_ignore(TRUE);
+ if (XGetInputFocus(ob_display, &win, &i) != 0 &&
+ XGetGeometry(ob_display, win, &root, &i,&i,&u,&u,&u,&u) != 0 &&
+ root != RootWindow(ob_display, ob_screen))
+ {
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to another screen !\n");
+ focus_left_screen = TRUE;
+ }
+ else
+ ob_debug_type(OB_DEBUG_FOCUS,
+ "Focus went to a black hole !\n");
+ xerror_set_ignore(FALSE);
/* 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 };
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 ||
e->type == MotionNotify || e->type == KeyPress ||
e->type == KeyRelease)
{
- if (menu_frame_visible)
- event_handle_menu(e);
- else {
- if (!keyboard_process_interactive_grab(e, &client)) {
- if (moveresize_in_progress) {
- moveresize_event(e);
-
- /* make further actions work on the client being
- moved/resized */
- client = moveresize_client;
- }
-
- menu_can_hide = FALSE;
- ob_main_loop_timeout_add(ob_main_loop,
- config_menu_hide_delay * 1000,
- menu_hide_delay_func,
- NULL, g_direct_equal, NULL);
-
- if (e->type == ButtonPress || e->type == ButtonRelease ||
- e->type == MotionNotify) {
- mouse_event(client, e);
- } else if (e->type == KeyPress) {
- keyboard_event((focus_cycle_target ? focus_cycle_target :
- client), e);
- }
- }
- }
+ event_handle_user_input(client, e);
}
+
/* if something happens and it's not from an XEvent, then we don't know
the time */
event_curtime = CurrentTime;
guint d = e->xclient.data.l[0];
if (d < screen_num_desktops) {
event_curtime = e->xclient.data.l[1];
- ob_debug("SWITCH DESKTOP TIME: %d\n", event_curtime);
+ if (event_curtime == 0)
+ ob_debug_type(OB_DEBUG_APP_BUGS,
+ "_NET_CURRENT_DESKTOP message is missing "
+ "a timestamp\n");
screen_set_desktop(d);
}
} else if (msgtype == prop_atoms.net_number_of_desktops) {
if (d > 0)
screen_set_num_desktops(d);
} else if (msgtype == prop_atoms.net_showing_desktop) {
- screen_show_desktop(e->xclient.data.l[0] != 0);
- } else if (msgtype == prop_atoms.ob_control) {
+ screen_show_desktop(e->xclient.data.l[0] != 0, TRUE);
+ } else if (msgtype == prop_atoms.openbox_control) {
if (e->xclient.data.l[0] == 1)
ob_reconfigure();
else if (e->xclient.data.l[0] == 2)
{
XEvent ce;
Atom msgtype;
- gint i=0;
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
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
+ doesn't even exist..! */
+ if (frame_iconify_animating(client->frame))
+ event_ignore_queued_enters();
+
ob_debug_type(OB_DEBUG_FOCUS,
"%sNotify mode %d detail %d on %lx\n",
(e->type == EnterNotify ? "Enter" : "Leave"),
if (keyboard_interactively_grabbed())
break;
if (config_focus_follow && config_focus_delay &&
- /* leaveinferior events can happen when the mouse goes onto the
- window's border and then into the window before the delay
- is up */
+ /* 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,
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)
{
ob_debug_type(OB_DEBUG_FOCUS,
"%sNotify mode %d detail %d on %lx IGNORED\n",
break;
}
case ConfigureRequest:
- /* compress these */
- while (XCheckTypedWindowEvent(ob_display, client->window,
- ConfigureRequest, &ce)) {
- ++i;
- /* XXX if this causes bad things.. we can compress config req's
- with the same mask. */
- e->xconfigurerequest.value_mask |=
- ce.xconfigurerequest.value_mask;
- if (ce.xconfigurerequest.value_mask & CWX)
- e->xconfigurerequest.x = ce.xconfigurerequest.x;
- if (ce.xconfigurerequest.value_mask & CWY)
- e->xconfigurerequest.y = ce.xconfigurerequest.y;
- if (ce.xconfigurerequest.value_mask & CWWidth)
- e->xconfigurerequest.width = ce.xconfigurerequest.width;
- if (ce.xconfigurerequest.value_mask & CWHeight)
- e->xconfigurerequest.height = ce.xconfigurerequest.height;
- if (ce.xconfigurerequest.value_mask & CWBorderWidth)
- e->xconfigurerequest.border_width =
- ce.xconfigurerequest.border_width;
- if (ce.xconfigurerequest.value_mask & CWStackMode)
- e->xconfigurerequest.detail = ce.xconfigurerequest.detail;
- }
+ /* dont compress these unless you're going to watch for property
+ notifies in between (these can change what the configure would
+ do to the window).
+ also you can't compress stacking events
+ */
- /* if we are iconic (or shaded (fvwm does this)) ignore the event */
- if (client->iconic || client->shaded) return;
+ ob_debug("ConfigureRequest desktop %d wmstate %d vis %d\n",
+ screen_desktop, client->wmstate, client->frame->visible);
+
+ /* don't allow clients to move shaded windows (fvwm does this) */
+ if (client->shaded) {
+ e->xconfigurerequest.value_mask &= ~CWX;
+ e->xconfigurerequest.value_mask &= ~CWY;
+ }
/* resize, then move, as specified in the EWMH section 7.7 */
if (e->xconfigurerequest.value_mask & (CWWidth | CWHeight |
CWX | CWY |
CWBorderWidth)) {
gint x, y, w, h;
- ObCorner corner;
if (e->xconfigurerequest.value_mask & CWBorderWidth)
client->border_width = e->xconfigurerequest.border_width;
h = (e->xconfigurerequest.value_mask & CWHeight) ?
e->xconfigurerequest.height : client->area.height;
+ ob_debug("ConfigureRequest x %d %d y %d %d\n",
+ e->xconfigurerequest.value_mask & CWX, x,
+ e->xconfigurerequest.value_mask & CWY, y);
+
+ /* check for broken apps moving to their root position
+
+ XXX remove this some day...that would be nice. right now all
+ kde apps do this when they try activate themselves on another
+ desktop. eg. open amarok window on desktop 1, switch to desktop
+ 2, click amarok tray icon. it will move by its decoration size.
+ */
+ if (x != client->area.x &&
+ x == (client->frame->area.x + client->frame->size.left -
+ (gint)client->border_width) &&
+ y != client->area.y &&
+ y == (client->frame->area.y + client->frame->size.top -
+ (gint)client->border_width))
{
- gint newx = x;
- gint newy = y;
- gint fw = w +
- client->frame->size.left + client->frame->size.right;
- gint fh = h +
- client->frame->size.top + client->frame->size.bottom;
- /* make this rude for size-only changes but not for position
- changes.. */
- gboolean moving = ((e->xconfigurerequest.value_mask & CWX) ||
- (e->xconfigurerequest.value_mask & CWY));
-
- client_find_onscreen(client, &newx, &newy, fw, fh,
- !moving);
- if (e->xconfigurerequest.value_mask & CWX)
- x = newx;
- if (e->xconfigurerequest.value_mask & CWY)
- y = newy;
- }
-
- switch (client->gravity) {
- case NorthEastGravity:
- case EastGravity:
- corner = OB_CORNER_TOPRIGHT;
- break;
- case SouthWestGravity:
- case SouthGravity:
- corner = OB_CORNER_BOTTOMLEFT;
- break;
- case SouthEastGravity:
- corner = OB_CORNER_BOTTOMRIGHT;
- break;
- default: /* NorthWest, Static, etc */
- corner = OB_CORNER_TOPLEFT;
+ 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",
+ client->title);
+ /* don't move it */
+ x = client->area.x;
+ y = client->area.y;
}
- client_configure_full(client, corner, x, y, w, h, FALSE, TRUE,
- TRUE);
+ client_find_onscreen(client, &x, &y, w, h, FALSE);
+ client_configure_full(client, x, y, w, h, FALSE, TRUE, TRUE);
}
if (e->xconfigurerequest.value_mask & CWStackMode) {
(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] ! */
+ /* XXX make use of data.l[2] !? */
event_curtime = e->xclient.data.l[1];
+ ob_debug_type(OB_DEBUG_APP_BUGS,
+ "_NET_ACTIVE_WINDOW message for window %s is "
+ "missing a timestamp\n", client->title);
client_activate(client, FALSE,
(e->xclient.data.l[0] == 0 ||
e->xclient.data.l[0] == 2));
prop_atoms.net_wm_moveresize_cancel)
moveresize_end(TRUE);
} else if (msgtype == prop_atoms.net_moveresize_window) {
- gint oldg = client->gravity;
- gint tmpg, x, y, w, h;
+ gint grav, x, y, w, h;
if (e->xclient.data.l[0] & 0xff)
- tmpg = e->xclient.data.l[0] & 0xff;
- else
- tmpg = oldg;
+ grav = e->xclient.data.l[0] & 0xff;
+ else
+ grav = client->gravity;
if (e->xclient.data.l[0] & 1 << 8)
x = e->xclient.data.l[1];
h = e->xclient.data.l[4];
else
h = client->area.height;
- client->gravity = tmpg;
-
- {
- gint newx = x;
- gint newy = y;
- gint fw = w +
- client->frame->size.left + client->frame->size.right;
- gint fh = h +
- client->frame->size.top + client->frame->size.bottom;
- client_find_onscreen(client, &newx, &newy, fw, fh,
- client_normal(client));
- if (e->xclient.data.l[0] & 1 << 8)
- x = newx;
- if (e->xclient.data.l[0] & 1 << 9)
- y = newy;
- }
-
- client_configure(client, OB_CORNER_TOPLEFT,
- x, y, w, h, FALSE, TRUE);
- client->gravity = oldg;
+ ob_debug("MOVERESIZE x %d %d y %d %d\n",
+ e->xclient.data.l[0] & 1 << 8, x,
+ e->xclient.data.l[0] & 1 << 9, y);
+ client_convert_gravity(client, grav, &x, &y, w, h);
+ client_find_onscreen(client, &x, &y, w, h, FALSE);
+ client_configure(client, x, y, w, h, FALSE, TRUE);
}
break;
case PropertyNotify:
else if (msgtype == prop_atoms.net_wm_icon) {
client_update_icons(client);
}
+ else if (msgtype == prop_atoms.net_wm_icon_geometry) {
+ client_update_icon_geometry(client);
+ }
else if (msgtype == prop_atoms.net_wm_user_time) {
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(XEvent *ev)
+static gboolean event_handle_menu_keyboard(XEvent *ev)
+{
+ guint keycode, state;
+ gunichar unikey;
+ ObMenuFrame *frame;
+ gboolean ret = TRUE;
+
+ keycode = ev->xkey.keycode;
+ state = ev->xkey.state;
+ unikey = translate_unichar(keycode);
+
+ frame = find_active_or_last_menu();
+ if (frame == NULL)
+ ret = FALSE;
+
+ else if (keycode == ob_keycode(OB_KEY_ESCAPE) && state == 0) {
+ /* Escape closes the active menu */
+ menu_frame_hide(frame);
+ }
+
+ else if (keycode == ob_keycode(OB_KEY_RETURN) && (state == 0 ||
+ state == ControlMask))
+ {
+ /* 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
+ menu_entry_frame_execute(frame->selected, state, ev->xkey.time);
+ }
+
+ else if (keycode == ob_keycode(OB_KEY_LEFT) && ev->xkey.state == 0) {
+ /* Left goes to the parent menu */
+ menu_frame_select(frame, NULL, TRUE);
+ }
+
+ else if (keycode == ob_keycode(OB_KEY_RIGHT) && ev->xkey.state == 0) {
+ /* Right goes to the selected submenu */
+ if (frame->child) menu_frame_select_next(frame->child);
+ }
+
+ else if (keycode == ob_keycode(OB_KEY_UP) && state == 0) {
+ menu_frame_select_previous(frame);
+ }
+
+ else if (keycode == ob_keycode(OB_KEY_DOWN) && state == 0) {
+ menu_frame_select_next(frame);
+ }
+
+ /* keyboard accelerator shortcuts. */
+ else if (ev->xkey.state == 0 &&
+ /* was it a valid key? */
+ unikey != 0 &&
+ /* don't bother if the menu is empty. */
+ frame->entries)
+ {
+ GList *start;
+ GList *it;
+ ObMenuEntryFrame *found = NULL;
+ guint num_found = 0;
+
+ /* 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); /* highlight the item for a short bit so the
+ user can see what happened */
+ menu_entry_frame_execute(found, state, ev->xkey.time);
+ } else {
+ menu_frame_select(frame, found, TRUE);
+ if (num_found == 1)
+ menu_frame_select_next(frame->child);
+ }
+ } else
+ ret = FALSE;
+ }
+ else
+ ret = FALSE;
+
+ return ret;
+}
+
+static gboolean event_handle_menu(XEvent *ev)
{
ObMenuFrame *f;
ObMenuEntryFrame *e;
+ gboolean ret = TRUE;
switch (ev->type) {
case ButtonRelease:
- if (menu_can_hide) {
+ if ((ev->xbutton.button < 4 || ev->xbutton.button > 5)
+ && menu_can_hide)
+ {
if ((e = menu_entry_frame_under(ev->xbutton.x_root,
ev->xbutton.y_root)))
menu_entry_frame_execute(e, ev->xbutton.state,
if (e->ignore_enters)
--e->ignore_enters;
else
- menu_frame_select(e->frame, e);
+ menu_frame_select(e->frame, e, FALSE);
}
break;
case LeaveNotify:
(f = find_active_menu()) && f->selected == e &&
e->entry->type != OB_MENU_ENTRY_TYPE_SUBMENU)
{
- menu_frame_select(e->frame, 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);
+ menu_frame_select(e->frame, e, FALSE);
break;
case KeyPress:
- if (ev->xkey.keycode == ob_keycode(OB_KEY_ESCAPE))
- 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);
- } 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);
- } else if (ev->xkey.keycode == ob_keycode(OB_KEY_RIGHT)) {
- ObMenuFrame *f;
- if ((f = find_active_or_last_menu()) && f->child)
- menu_frame_select_next(f->child);
- } else if (ev->xkey.keycode == ob_keycode(OB_KEY_UP)) {
- ObMenuFrame *f;
- if ((f = find_active_or_last_menu()))
- menu_frame_select_previous(f);
- } else if (ev->xkey.keycode == ob_keycode(OB_KEY_DOWN)) {
- ObMenuFrame *f;
- if ((f = find_active_or_last_menu()))
- menu_frame_select_next(f);
- }
+ ret = event_handle_menu_keyboard(ev);
break;
}
+ return ret;
+}
+
+static void event_handle_user_input(ObClient *client, XEvent *e)
+{
+ g_assert(e->type == ButtonPress || e->type == ButtonRelease ||
+ e->type == MotionNotify || e->type == KeyPress ||
+ e->type == KeyRelease);
+
+ if (menu_frame_visible) {
+ if (event_handle_menu(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;
+ }
+
+ /* if the keyboard interactive action uses the event then dont
+ use it for bindings. likewise is moveresize uses the event. */
+ if (!keyboard_process_interactive_grab(e, &client) &&
+ !(moveresize_in_progress && moveresize_event(e)))
+ {
+ if (moveresize_in_progress)
+ /* make further actions work on the client being
+ moved/resized */
+ client = moveresize_client;
+
+ menu_can_hide = FALSE;
+ ob_main_loop_timeout_add(ob_main_loop,
+ config_menu_hide_delay * 1000,
+ menu_hide_delay_func,
+ NULL, g_direct_equal, NULL);
+
+ 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 if (e->type == KeyPress) {
+ keyboard_event((focus_cycle_target ? focus_cycle_target :
+ (client ? client : focus_client)), e);
+ }
+ }
}
static gboolean menu_hide_delay_func(gpointer data)
projects / chaz / openbox / blobdiff