openbox/event.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    event.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "event.h"
  21 #include "debug.h"
  22 #include "window.h"
  23 #include "openbox.h"
  24 #include "dock.h"
  25 #include "actions.h"
  26 #include "client.h"
  27 #include "config.h"
  28 #include "screen.h"
  29 #include "frame.h"
  30 #include "grab.h"
  31 #include "menu.h"
  32 #include "prompt.h"
  33 #include "menuframe.h"
  34 #include "keyboard.h"
  35 #include "mouse.h"
  36 #include "focus.h"
  37 #include "focus_cycle.h"
  38 #include "moveresize.h"
  39 #include "group.h"
  40 #include "stacking.h"
  41 #include "ping.h"
  42 #include "obt/display.h"
  43 #include "obt/xqueue.h"
  44 #include "obt/prop.h"
  45 #include "obt/keyboard.h"
  46
  47 #include <X11/Xlib.h>
  48 #include <X11/Xatom.h>
  49 #include <glib.h>
  50
  51 #ifdef HAVE_SYS_SELECT_H
  52 #  include <sys/select.h>
  53 #endif
  54 #ifdef HAVE_SIGNAL_H
  55 #  include <signal.h>
  56 #endif
  57 #ifdef HAVE_UNISTD_H
  58 #  include <unistd.h> /* for usleep() */
  59 #endif
  60
  61 #ifdef USE_SM
  62 #include <X11/ICE/ICElib.h>
  63 #endif
  64
  65 typedef struct
  66 {
  67     gboolean ignored;
  68 } ObEventData;
  69
  70 typedef struct
  71 {
  72     ObClient *client;
  73     Time time;
  74     gulong serial;
  75 } ObFocusDelayData;
  76
  77 typedef struct
  78 {
  79     gulong start; /* inclusive */
  80     gulong end;   /* inclusive */
  81 } ObSerialRange;
  82
  83 static void event_process(const XEvent *e, gpointer data);
  84 static void event_handle_root(XEvent *e);
  85 static gboolean event_handle_menu_input(XEvent *e);
  86 static void event_handle_menu(ObMenuFrame *frame, XEvent *e);
  87 static gboolean event_handle_prompt(ObPrompt *p, XEvent *e);
  88 static void event_handle_dock(ObDock *s, XEvent *e);
  89 static void event_handle_dockapp(ObDockApp *app, XEvent *e);
  90 static void event_handle_client(ObClient *c, XEvent *e);
  91 static gboolean event_handle_user_input(ObClient *client, XEvent *e);
  92 static gboolean is_enter_focus_event_ignored(gulong serial);
  93 static void event_ignore_enter_range(gulong start, gulong end);
  94
  95 static void focus_delay_dest(gpointer data);
  96 static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2);
  97 static gboolean focus_delay_func(gpointer data);
  98 static gboolean unfocus_delay_func(gpointer data);
  99 static void focus_delay_client_dest(ObClient *client, gpointer data);
 100
 101 Time event_last_user_time;
 102
 103 /*! The time of the current X event (if it had a timestamp) */
 104 static Time event_curtime;
 105 /*! The source time that started the current X event (user-provided, so not
 106   to be trusted) */
 107 static Time event_sourcetime;
 108
 109 /*! The serial of the current X event */
 110 static gulong event_curserial;
 111 static gboolean focus_left_screen = FALSE;
 112 static gboolean waiting_for_focusin = FALSE;
 113 /*! A list of ObSerialRanges which are to be ignored for mouse enter events */
 114 static GSList *ignore_serials = NULL;
 115
 116 #ifdef USE_SM
 117 static void ice_handler(gint fd, gpointer conn)
 118 {
 119     Bool b;
 120     IceProcessMessages(conn, NULL, &b);
 121 }
 122
 123 static void ice_watch(IceConn conn, IcePointer data, Bool opening,
 124                       IcePointer *watch_data)
 125 {
 126     static gint fd = -1;
 127
 128     if (opening) {
 129         fd = IceConnectionNumber(conn);
 130         obt_main_loop_fd_add(ob_main_loop, fd, ice_handler, conn, NULL);
 131     } else {
 132         obt_main_loop_fd_remove(ob_main_loop, fd);
 133         fd = -1;
 134     }
 135 }
 136 #endif
 137
 138 void event_startup(gboolean reconfig)
 139 {
 140     if (reconfig) return;
 141
 142     obt_main_loop_x_add(ob_main_loop, event_process, NULL, NULL);
 143
 144 #ifdef USE_SM
 145     IceAddConnectionWatch(ice_watch, NULL);
 146 #endif
 147
 148     client_add_destroy_notify(focus_delay_client_dest, NULL);
 149
 150     event_curtime = CurrentTime;
 151     event_sourcetime = CurrentTime;
 152     event_last_user_time = CurrentTime;
 153 }
 154
 155 void event_shutdown(gboolean reconfig)
 156 {
 157     if (reconfig) return;
 158
 159 #ifdef USE_SM
 160     IceRemoveConnectionWatch(ice_watch, NULL);
 161 #endif
 162
 163     client_remove_destroy_notify(focus_delay_client_dest);
 164 }
 165
 166 static Window event_get_window(XEvent *e)
 167 {
 168     Window window;
 169
 170     /* pick a window */
 171     switch (e->type) {
 172     case SelectionClear:
 173         window = obt_root(ob_screen);
 174         break;
 175     case CreateNotify:
 176         window = e->xcreatewindow.window;
 177         break;
 178     case MapRequest:
 179         window = e->xmaprequest.window;
 180         break;
 181     case MapNotify:
 182         window = e->xmap.window;
 183         break;
 184     case UnmapNotify:
 185         window = e->xunmap.window;
 186         break;
 187     case DestroyNotify:
 188         window = e->xdestroywindow.window;
 189         break;
 190     case ConfigureRequest:
 191         window = e->xconfigurerequest.window;
 192         break;
 193     case ConfigureNotify:
 194         window = e->xconfigure.window;
 195         break;
 196     default:
 197 #ifdef XKB
 198         if (obt_display_extension_xkb &&
 199             e->type == obt_display_extension_xkb_basep)
 200         {
 201             switch (((XkbAnyEvent*)e)->xkb_type) {
 202             case XkbBellNotify:
 203                 window = ((XkbBellNotifyEvent*)e)->window;
 204             default:
 205                 window = None;
 206             }
 207         } else
 208 #endif
 209 #ifdef SYNC
 210         if (obt_display_extension_sync &&
 211             e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
 212         {
 213             window = None;
 214         } else
 215 #endif
 216             window = e->xany.window;
 217     }
 218     return window;
 219 }
 220
 221 static inline Time event_get_timestamp(const XEvent *e)
 222 {
 223     Time t = CurrentTime;
 224
 225     /* grab the lasttime and hack up the state */
 226     switch (e->type) {
 227     case ButtonPress:
 228     case ButtonRelease:
 229         t = e->xbutton.time;
 230         break;
 231     case KeyPress:
 232         t = e->xkey.time;
 233         break;
 234     case KeyRelease:
 235         t = e->xkey.time;
 236         break;
 237     case MotionNotify:
 238         t = e->xmotion.time;
 239         break;
 240     case PropertyNotify:
 241         t = e->xproperty.time;
 242         break;
 243     case EnterNotify:
 244     case LeaveNotify:
 245         t = e->xcrossing.time;
 246         break;
 247     default:
 248 #ifdef SYNC
 249         if (obt_display_extension_sync &&
 250             e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
 251         {
 252             t = ((const XSyncAlarmNotifyEvent*)e)->time;
 253         }
 254 #endif
 255         /* if more event types are anticipated, get their timestamp
 256            explicitly */
 257         break;
 258     }
 259
 260     return t;
 261 }
 262
 263 static void event_set_curtime(XEvent *e)
 264 {
 265     Time t = event_get_timestamp(e);
 266
 267     /* watch that if we get an event earlier than the last specified user_time,
 268        which can happen if the clock goes backwards, we erase the last
 269        specified user_time */
 270     if (t && event_last_user_time && event_time_after(event_last_user_time, t))
 271         event_last_user_time = CurrentTime;
 272
 273     event_sourcetime = CurrentTime;
 274     event_curtime = t;
 275 }
 276
 277 static void event_hack_mods(XEvent *e)
 278 {
 279     switch (e->type) {
 280     case ButtonPress:
 281     case ButtonRelease:
 282         e->xbutton.state = obt_keyboard_only_modmasks(e->xbutton.state);
 283         break;
 284     case KeyPress:
 285         break;
 286     case KeyRelease:
 287         break;
 288     case MotionNotify:
 289         e->xmotion.state = obt_keyboard_only_modmasks(e->xmotion.state);
 290         /* compress events */
 291         {
 292             XEvent ce;
 293             ObtXQueueWindowType wt;
 294
 295             wt.window = e->xmotion.window;
 296             wt.type = MotionNotify;
 297             while (xqueue_remove_local(&ce, xqueue_match_window_type, &wt)) {
 298                 e->xmotion.x = ce.xmotion.x;
 299                 e->xmotion.y = ce.xmotion.y;
 300                 e->xmotion.x_root = ce.xmotion.x_root;
 301                 e->xmotion.y_root = ce.xmotion.y_root;
 302             }
 303         }
 304         break;
 305     }
 306 }
 307
 308 static gboolean wanted_focusevent(XEvent *e, gboolean in_client_only)
 309 {
 310     gint mode = e->xfocus.mode;
 311     gint detail = e->xfocus.detail;
 312     Window win = e->xany.window;
 313
 314     if (e->type == FocusIn) {
 315         /* These are ones we never want.. */
 316
 317         /* This means focus was given by a keyboard/mouse grab. */
 318         if (mode == NotifyGrab)
 319             return FALSE;
 320         /* This means focus was given back from a keyboard/mouse grab. */
 321         if (mode == NotifyUngrab)
 322             return FALSE;
 323
 324         /* These are the ones we want.. */
 325
 326         if (win == obt_root(ob_screen)) {
 327             /* If looking for a focus in on a client, then always return
 328                FALSE for focus in's to the root window */
 329             if (in_client_only)
 330                 return FALSE;
 331             /* This means focus reverted off of a client */
 332             else if (detail == NotifyPointerRoot ||
 333                      detail == NotifyDetailNone ||
 334                      detail == NotifyInferior ||
 335                      /* This means focus got here from another screen */
 336                      detail == NotifyNonlinear)
 337                 return TRUE;
 338             else
 339                 return FALSE;
 340         }
 341
 342         /* It was on a client, was it a valid one?
 343            It's possible to get a FocusIn event for a client that was managed
 344            but has disappeared.
 345         */
 346         if (in_client_only) {
 347             ObWindow *w = window_find(e->xfocus.window);
 348             if (!w || !WINDOW_IS_CLIENT(w))
 349                 return FALSE;
 350         }
 351         else {
 352             /* This means focus reverted to parent from the client (this
 353                happens often during iconify animation) */
 354             if (detail == NotifyInferior)
 355                 return TRUE;
 356         }
 357
 358         /* This means focus moved from the root window to a client */
 359         if (detail == NotifyVirtual)
 360             return TRUE;
 361         /* This means focus moved from one client to another */
 362         if (detail == NotifyNonlinearVirtual)
 363             return TRUE;
 364
 365         /* Otherwise.. */
 366         return FALSE;
 367     } else {
 368         g_assert(e->type == FocusOut);
 369
 370         /* These are ones we never want.. */
 371
 372         /* This means focus was taken by a keyboard/mouse grab. */
 373         if (mode == NotifyGrab)
 374             return FALSE;
 375         /* This means focus was grabbed on a window and it was released. */
 376         if (mode == NotifyUngrab)
 377             return FALSE;
 378
 379         /* Focus left the root window revertedto state */
 380         if (win == obt_root(ob_screen))
 381             return FALSE;
 382
 383         /* These are the ones we want.. */
 384
 385         /* This means focus moved from a client to the root window */
 386         if (detail == NotifyVirtual)
 387             return TRUE;
 388         /* This means focus moved from one client to another */
 389         if (detail == NotifyNonlinearVirtual)
 390             return TRUE;
 391
 392         /* Otherwise.. */
 393         return FALSE;
 394     }
 395 }
 396
 397 static gboolean event_look_for_focusin(XEvent *e, gpointer data)
 398 {
 399     return e->type == FocusIn && wanted_focusevent(e, FALSE);
 400 }
 401
 402 static gboolean event_look_for_focusin_client(XEvent *e, gpointer data)
 403 {
 404     return e->type == FocusIn && wanted_focusevent(e, TRUE);
 405 }
 406
 407 static void print_focusevent(XEvent *e)
 408 {
 409     gint mode = e->xfocus.mode;
 410     gint detail = e->xfocus.detail;
 411     Window win = e->xany.window;
 412     const gchar *modestr, *detailstr;
 413
 414     switch (mode) {
 415     case NotifyNormal:       modestr="NotifyNormal";       break;
 416     case NotifyGrab:         modestr="NotifyGrab";         break;
 417     case NotifyUngrab:       modestr="NotifyUngrab";       break;
 418     case NotifyWhileGrabbed: modestr="NotifyWhileGrabbed"; break;
 419     default:                 g_assert_not_reached();
 420     }
 421     switch (detail) {
 422     case NotifyAncestor:    detailstr="NotifyAncestor";    break;
 423     case NotifyVirtual:     detailstr="NotifyVirtual";     break;
 424     case NotifyInferior:    detailstr="NotifyInferior";    break;
 425     case NotifyNonlinear:   detailstr="NotifyNonlinear";   break;
 426     case NotifyNonlinearVirtual: detailstr="NotifyNonlinearVirtual"; break;
 427     case NotifyPointer:     detailstr="NotifyPointer";     break;
 428     case NotifyPointerRoot: detailstr="NotifyPointerRoot"; break;
 429     case NotifyDetailNone:  detailstr="NotifyDetailNone";  break;
 430     default:                g_assert_not_reached();
 431     }
 432
 433     if (mode == NotifyGrab || mode == NotifyUngrab)
 434         return;
 435
 436     g_assert(modestr);
 437     g_assert(detailstr);
 438     ob_debug_type(OB_DEBUG_FOCUS, "Focus%s 0x%x mode=%s detail=%s",
 439                   (e->xfocus.type == FocusIn ? "In" : "Out"),
 440                   win,
 441                   modestr, detailstr);
 442
 443 }
 444
 445 static void event_process(const XEvent *ec, gpointer data)
 446 {
 447     XEvent ee, *e;
 448     Window window;
 449     ObClient *client = NULL;
 450     ObDock *dock = NULL;
 451     ObDockApp *dockapp = NULL;
 452     ObWindow *obwin = NULL;
 453     ObMenuFrame *menu = NULL;
 454     ObPrompt *prompt = NULL;
 455     gboolean used;
 456
 457     /* make a copy we can mangle */
 458     ee = *ec;
 459     e = &ee;
 460
 461     window = event_get_window(e);
 462     if (window == obt_root(ob_screen))
 463         /* don't do any lookups, waste of cpu */;
 464     else if ((obwin = window_find(window))) {
 465         switch (obwin->type) {
 466         case OB_WINDOW_CLASS_DOCK:
 467             dock = WINDOW_AS_DOCK(obwin);
 468             break;
 469         case OB_WINDOW_CLASS_CLIENT:
 470             client = WINDOW_AS_CLIENT(obwin);
 471             /* events on clients can be events on prompt windows too */
 472             prompt = client->prompt;
 473             break;
 474         case OB_WINDOW_CLASS_MENUFRAME:
 475             menu = WINDOW_AS_MENUFRAME(obwin);
 476             break;
 477         case OB_WINDOW_CLASS_INTERNAL:
 478             /* we don't do anything with events directly on these windows */
 479             break;
 480         case OB_WINDOW_CLASS_PROMPT:
 481             prompt = WINDOW_AS_PROMPT(obwin);
 482             break;
 483         }
 484     }
 485     else
 486         dockapp = dock_find_dockapp(window);
 487
 488     event_set_curtime(e);
 489     event_curserial = e->xany.serial;
 490     event_hack_mods(e);
 491
 492     /* deal with it in the kernel */
 493
 494     if (e->type == FocusIn) {
 495         print_focusevent(e);
 496         if (!wanted_focusevent(e, FALSE)) {
 497             if (waiting_for_focusin) {
 498                 /* We were waiting for this FocusIn, since we got a FocusOut
 499                    earlier, but it went to a window that isn't a client. */
 500                 ob_debug_type(OB_DEBUG_FOCUS,
 501                               "Focus went to an unmanaged window 0x%x !",
 502                               e->xfocus.window);
 503                 focus_fallback(TRUE, config_focus_under_mouse, TRUE, TRUE);
 504             }
 505         }
 506         else if (client && e->xfocus.detail == NotifyInferior) {
 507             ob_debug_type(OB_DEBUG_FOCUS, "Focus went to the frame window");
 508
 509             focus_left_screen = FALSE;
 510
 511             focus_fallback(FALSE, config_focus_under_mouse, TRUE, TRUE);
 512
 513             /* We don't get a FocusOut for this case, because it's just moving
 514                from our Inferior up to us. This happens when iconifying a
 515                window with RevertToParent focus */
 516             frame_adjust_focus(client->frame, FALSE);
 517             /* focus_set_client(NULL) has already been called */
 518         }
 519         else if (e->xfocus.detail == NotifyPointerRoot ||
 520                  e->xfocus.detail == NotifyDetailNone ||
 521                  e->xfocus.detail == NotifyInferior ||
 522                  e->xfocus.detail == NotifyNonlinear)
 523         {
 524             ob_debug_type(OB_DEBUG_FOCUS,
 525                           "Focus went to root or pointer root/none");
 526
 527             if (e->xfocus.detail == NotifyInferior ||
 528                 e->xfocus.detail == NotifyNonlinear)
 529             {
 530                 focus_left_screen = FALSE;
 531             }
 532
 533             /* If another FocusIn is in the queue then don't fallback yet. This
 534                fixes the fun case of:
 535                window map -> send focusin
 536                window unmap -> get focusout
 537                window map -> send focusin
 538                get first focus out -> fall back to something (new window
 539                  hasn't received focus yet, so something else) -> send focusin
 540                which means the "something else" is the last thing to get a
 541                focusin sent to it, so the new window doesn't end up with focus.
 542
 543                But if the other focus in is something like PointerRoot then we
 544                still want to fall back.
 545             */
 546             if (xqueue_exists_local(event_look_for_focusin_client, NULL)) {
 547                 ob_debug_type(OB_DEBUG_FOCUS,
 548                               "  but another FocusIn is coming");
 549             } else {
 550                 /* Focus has been reverted.
 551
 552                    FocusOut events come after UnmapNotify, so we don't need to
 553                    worry about focusing an invalid window
 554                 */
 555
 556                 if (!focus_left_screen)
 557                     focus_fallback(FALSE, config_focus_under_mouse,
 558                                    TRUE, TRUE);
 559             }
 560         }
 561         else if (!client)
 562         {
 563             ob_debug_type(OB_DEBUG_FOCUS,
 564                           "Focus went to a window that is already gone");
 565
 566             /* If you send focus to a window and then it disappears, you can
 567                get the FocusIn for it, after it is unmanaged.
 568                Just wait for the next FocusOut/FocusIn pair, but make note that
 569                the window that was focused no longer is. */
 570             focus_set_client(NULL);
 571         }
 572         else if (client != focus_client) {
 573             focus_left_screen = FALSE;
 574             frame_adjust_focus(client->frame, TRUE);
 575             focus_set_client(client);
 576             client_calc_layer(client);
 577             client_bring_helper_windows(client);
 578         }
 579
 580         waiting_for_focusin = FALSE;
 581     } else if (e->type == FocusOut) {
 582         print_focusevent(e);
 583         if (!wanted_focusevent(e, FALSE))
 584             ; /* skip this one */
 585         /* Look for the followup FocusIn */
 586         else if (!xqueue_exists_local(event_look_for_focusin, NULL)) {
 587             /* There is no FocusIn, this means focus went to a window that
 588                is not being managed, or a window on another screen. */
 589             Window win, root;
 590             gint i;
 591             guint u;
 592             obt_display_ignore_errors(TRUE);
 593             if (XGetInputFocus(obt_display, &win, &i) &&
 594                 XGetGeometry(obt_display, win, &root, &i,&i,&u,&u,&u,&u) &&
 595                 root != obt_root(ob_screen))
 596             {
 597                 ob_debug_type(OB_DEBUG_FOCUS,
 598                               "Focus went to another screen !");
 599                 focus_left_screen = TRUE;
 600             }
 601             else
 602                 ob_debug_type(OB_DEBUG_FOCUS,
 603                               "Focus went to a black hole !");
 604             obt_display_ignore_errors(FALSE);
 605             /* nothing is focused */
 606             focus_set_client(NULL);
 607         } else {
 608             /* Focus moved, so mark that we are waiting to process that
 609                FocusIn */
 610             waiting_for_focusin = TRUE;
 611
 612             /* nothing is focused right now, but will be again shortly */
 613             focus_set_client(NULL);
 614         }
 615
 616         if (client && client != focus_client)
 617             frame_adjust_focus(client->frame, FALSE);
 618     }
 619     else if (client)
 620         event_handle_client(client, e);
 621     else if (dockapp)
 622         event_handle_dockapp(dockapp, e);
 623     else if (dock)
 624         event_handle_dock(dock, e);
 625     else if (menu)
 626         event_handle_menu(menu, e);
 627     else if (window == obt_root(ob_screen))
 628         event_handle_root(e);
 629     else if (e->type == MapRequest)
 630         window_manage(window);
 631     else if (e->type == MappingNotify) {
 632         /* keyboard layout changes for modifier mapping changes. reload the
 633            modifier map, and rebind all the key bindings as appropriate */
 634         ob_debug("Keyboard map changed. Reloading keyboard bindings.");
 635         ob_set_state(OB_STATE_RECONFIGURING);
 636         obt_keyboard_reload();
 637         keyboard_rebind();
 638         ob_set_state(OB_STATE_RUNNING);
 639     }
 640     else if (e->type == ClientMessage) {
 641         /* This is for _NET_WM_REQUEST_FRAME_EXTENTS messages. They come for
 642            windows that are not managed yet. */
 643         if (e->xclient.message_type ==
 644             OBT_PROP_ATOM(NET_REQUEST_FRAME_EXTENTS))
 645         {
 646             /* Pretend to manage the client, getting information used to
 647                determine its decorations */
 648             ObClient *c = client_fake_manage(e->xclient.window);
 649             gulong vals[4];
 650
 651             /* set the frame extents on the window */
 652             vals[0] = c->frame->size.left;
 653             vals[1] = c->frame->size.right;
 654             vals[2] = c->frame->size.top;
 655             vals[3] = c->frame->size.bottom;
 656             OBT_PROP_SETA32(e->xclient.window, NET_FRAME_EXTENTS,
 657                             CARDINAL, vals, 4);
 658
 659             /* Free the pretend client */
 660             client_fake_unmanage(c);
 661         }
 662     }
 663     else if (e->type == ConfigureRequest) {
 664         /* unhandled configure requests must be used to configure the
 665            window directly */
 666         XWindowChanges xwc;
 667
 668         xwc.x = e->xconfigurerequest.x;
 669         xwc.y = e->xconfigurerequest.y;
 670         xwc.width = e->xconfigurerequest.width;
 671         xwc.height = e->xconfigurerequest.height;
 672         xwc.border_width = e->xconfigurerequest.border_width;
 673         xwc.sibling = e->xconfigurerequest.above;
 674         xwc.stack_mode = e->xconfigurerequest.detail;
 675
 676         /* we are not to be held responsible if someone sends us an
 677            invalid request! */
 678         obt_display_ignore_errors(TRUE);
 679         XConfigureWindow(obt_display, window,
 680                          e->xconfigurerequest.value_mask, &xwc);
 681         obt_display_ignore_errors(FALSE);
 682     }
 683 #ifdef SYNC
 684     else if (obt_display_extension_sync &&
 685              e->type == obt_display_extension_sync_basep + XSyncAlarmNotify)
 686     {
 687         XSyncAlarmNotifyEvent *se = (XSyncAlarmNotifyEvent*)e;
 688         if (se->alarm == moveresize_alarm && moveresize_in_progress)
 689             moveresize_event(e);
 690     }
 691 #endif
 692
 693     if (e->type == ButtonPress || e->type == ButtonRelease) {
 694         ObWindow *w;
 695         static guint pressed = 0;
 696         static Window pressed_win = None;
 697
 698         /* If the button press was on some non-root window, or was physically
 699            on the root window... */
 700         if (window != obt_root(ob_screen) ||
 701             e->xbutton.subwindow == None ||
 702             /* ...or if it is related to the last button press we handled... */
 703             pressed == e->xbutton.button ||
 704             /* ...or it if it was physically on an openbox
 705                internal window... */
 706             ((w = window_find(e->xbutton.subwindow)) &&
 707              WINDOW_IS_INTERNAL(w)))
 708             /* ...then process the event, otherwise ignore it */
 709         {
 710             used = event_handle_user_input(client, e);
 711
 712             if (prompt && !used)
 713                 used = event_handle_prompt(prompt, e);
 714
 715             if (e->type == ButtonPress) {
 716                 pressed = e->xbutton.button;
 717                 pressed_win = e->xbutton.subwindow;
 718             }
 719         }
 720     }
 721     else if (e->type == KeyPress || e->type == KeyRelease ||
 722              e->type == MotionNotify)
 723     {
 724         used = event_handle_user_input(client, e);
 725
 726         if (prompt && !used)
 727             used = event_handle_prompt(prompt, e);
 728     }
 729
 730     /* if something happens and it's not from an XEvent, then we don't know
 731        the time, so clear it here until the next event is handled */
 732     event_curtime = event_sourcetime = CurrentTime;
 733     event_curserial = 0;
 734 }
 735
 736 static void event_handle_root(XEvent *e)
 737 {
 738     Atom msgtype;
 739
 740     switch(e->type) {
 741     case SelectionClear:
 742         ob_debug("Another WM has requested to replace us. Exiting.");
 743         ob_exit_replace();
 744         break;
 745
 746     case ClientMessage:
 747         if (e->xclient.format != 32) break;
 748
 749         msgtype = e->xclient.message_type;
 750         if (msgtype == OBT_PROP_ATOM(NET_CURRENT_DESKTOP)) {
 751             guint d = e->xclient.data.l[0];
 752             if (d < screen_num_desktops) {
 753                 if (e->xclient.data.l[1] == 0)
 754                     ob_debug_type(OB_DEBUG_APP_BUGS,
 755                                   "_NET_CURRENT_DESKTOP message is missing "
 756                                   "a timestamp");
 757                 else
 758                     event_sourcetime = e->xclient.data.l[1];
 759                 screen_set_desktop(d, TRUE);
 760             }
 761         } else if (msgtype == OBT_PROP_ATOM(NET_NUMBER_OF_DESKTOPS)) {
 762             guint d = e->xclient.data.l[0];
 763             if (d > 0 && d <= 1000)
 764                 screen_set_num_desktops(d);
 765         } else if (msgtype == OBT_PROP_ATOM(NET_SHOWING_DESKTOP)) {
 766             screen_show_desktop(e->xclient.data.l[0] != 0, NULL);
 767         } else if (msgtype == OBT_PROP_ATOM(OB_CONTROL)) {
 768             ob_debug("OB_CONTROL: %d", e->xclient.data.l[0]);
 769             if (e->xclient.data.l[0] == 1)
 770                 ob_reconfigure();
 771             else if (e->xclient.data.l[0] == 2)
 772                 ob_restart();
 773             else if (e->xclient.data.l[0] == 3)
 774                 ob_exit(0);
 775         } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
 776             if ((Atom)e->xclient.data.l[0] == OBT_PROP_ATOM(NET_WM_PING))
 777                 ping_got_pong(e->xclient.data.l[1]);
 778         }
 779         break;
 780     case PropertyNotify:
 781         if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_NAMES)) {
 782             ob_debug("UPDATE DESKTOP NAMES");
 783             screen_update_desktop_names();
 784         }
 785         else if (e->xproperty.atom == OBT_PROP_ATOM(NET_DESKTOP_LAYOUT))
 786             screen_update_layout();
 787         break;
 788     case ConfigureNotify:
 789 #ifdef XRANDR
 790         XRRUpdateConfiguration(e);
 791 #endif
 792         screen_resize();
 793         break;
 794     default:
 795         ;
 796     }
 797 }
 798
 799 void event_enter_client(ObClient *client)
 800 {
 801     g_assert(config_focus_follow);
 802
 803     if (is_enter_focus_event_ignored(event_curserial)) {
 804         ob_debug_type(OB_DEBUG_FOCUS, "Ignoring enter event with serial %lu\n"
 805                       "on client 0x%x", event_curserial, client->window);
 806         return;
 807     }
 808
 809     if (client_enter_focusable(client) && client_can_focus(client)) {
 810         if (config_focus_delay) {
 811             ObFocusDelayData *data;
 812
 813             obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
 814
 815             data = g_slice_new(ObFocusDelayData);
 816             data->client = client;
 817             data->time = event_time();
 818             data->serial = event_curserial;
 819
 820             obt_main_loop_timeout_add(ob_main_loop,
 821                                       config_focus_delay * 1000,
 822                                       focus_delay_func,
 823                                       data, focus_delay_cmp, focus_delay_dest);
 824         } else {
 825             ObFocusDelayData data;
 826             data.client = client;
 827             data.time = event_time();
 828             data.serial = event_curserial;
 829             focus_delay_func(&data);
 830         }
 831     }
 832 }
 833
 834 void event_leave_client(ObClient *client)
 835 {
 836     g_assert(config_focus_follow);
 837
 838     if (is_enter_focus_event_ignored(event_curserial)) {
 839         ob_debug_type(OB_DEBUG_FOCUS, "Ignoring leave event with serial %lu\n"
 840                       "on client 0x%x", event_curserial, client->window);
 841         return;
 842     }
 843
 844     if (client == focus_client) {
 845         if (config_focus_delay) {
 846             ObFocusDelayData *data;
 847
 848             obt_main_loop_timeout_remove(ob_main_loop, unfocus_delay_func);
 849
 850             data = g_slice_new(ObFocusDelayData);
 851             data->client = client;
 852             data->time = event_time();
 853             data->serial = event_curserial;
 854
 855             obt_main_loop_timeout_add(ob_main_loop,
 856                                       config_focus_delay * 1000,
 857                                       unfocus_delay_func,
 858                                       data, focus_delay_cmp, focus_delay_dest);
 859         } else {
 860             ObFocusDelayData data;
 861             data.client = client;
 862             data.time = event_time();
 863             data.serial = event_curserial;
 864             unfocus_delay_func(&data);
 865         }
 866     }
 867 }
 868
 869 static gboolean *context_to_button(ObFrame *f, ObFrameContext con, gboolean press)
 870 {
 871     if (press) {
 872         switch (con) {
 873         case OB_FRAME_CONTEXT_MAXIMIZE:
 874             return &f->max_press;
 875         case OB_FRAME_CONTEXT_CLOSE:
 876             return &f->close_press;
 877         case OB_FRAME_CONTEXT_ICONIFY:
 878             return &f->iconify_press;
 879         case OB_FRAME_CONTEXT_ALLDESKTOPS:
 880             return &f->desk_press;
 881         case OB_FRAME_CONTEXT_SHADE:
 882             return &f->shade_press;
 883         default:
 884             return NULL;
 885         }
 886     } else {
 887         switch (con) {
 888         case OB_FRAME_CONTEXT_MAXIMIZE:
 889             return &f->max_hover;
 890         case OB_FRAME_CONTEXT_CLOSE:
 891             return &f->close_hover;
 892         case OB_FRAME_CONTEXT_ICONIFY:
 893             return &f->iconify_hover;
 894         case OB_FRAME_CONTEXT_ALLDESKTOPS:
 895             return &f->desk_hover;
 896         case OB_FRAME_CONTEXT_SHADE:
 897             return &f->shade_hover;
 898         default:
 899             return NULL;
 900         }
 901     }
 902 }
 903
 904 static gboolean more_client_message_event(Window window, Atom msgtype)
 905 {
 906     ObtXQueueWindowMessage wm;
 907     wm.window = window;
 908     wm.message = msgtype;
 909     return xqueue_exists_local(xqueue_match_window_message, &wm);
 910 }
 911
 912 struct ObSkipPropertyChange {
 913     Window window;
 914     Atom prop;
 915 };
 916
 917 static gboolean skip_property_change(XEvent *e, gpointer data)
 918 {
 919     const struct ObSkipPropertyChange s = *(struct ObSkipPropertyChange*)data;
 920
 921     if (e->type == PropertyNotify && e->xproperty.window == s.window) {
 922         const Atom a = e->xproperty.atom;
 923         const Atom b = s.prop;
 924
 925         /* these are all updated together */
 926         if ((a == OBT_PROP_ATOM(NET_WM_NAME) ||
 927              a == OBT_PROP_ATOM(WM_NAME) ||
 928              a == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
 929              a == OBT_PROP_ATOM(WM_ICON_NAME))
 930             &&
 931             (b == OBT_PROP_ATOM(NET_WM_NAME) ||
 932              b == OBT_PROP_ATOM(WM_NAME) ||
 933              b == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
 934              b == OBT_PROP_ATOM(WM_ICON_NAME)))
 935         {
 936             return TRUE;
 937         }
 938         else if (a == b && a == OBT_PROP_ATOM(NET_WM_ICON))
 939             return TRUE;
 940     }
 941     return FALSE;
 942 }
 943
 944 static void event_handle_client(ObClient *client, XEvent *e)
 945 {
 946     Atom msgtype;
 947     ObFrameContext con;
 948     gboolean *but;
 949     static gint px = -1, py = -1;
 950     static guint pb = 0;
 951     static ObFrameContext pcon = OB_FRAME_CONTEXT_NONE;
 952
 953     switch (e->type) {
 954     case ButtonPress:
 955         /* save where the press occured for the first button pressed */
 956         if (!pb) {
 957             pb = e->xbutton.button;
 958             px = e->xbutton.x;
 959             py = e->xbutton.y;
 960
 961             pcon = frame_context(client, e->xbutton.window, px, py);
 962             pcon = mouse_button_frame_context(pcon, e->xbutton.button,
 963                                               e->xbutton.state);
 964         }
 965     case ButtonRelease:
 966         /* Wheel buttons don't draw because they are an instant click, so it
 967            is a waste of resources to go drawing it.
 968            if the user is doing an interactive thing, or has a menu open then
 969            the mouse is grabbed (possibly) and if we get these events we don't
 970            want to deal with them
 971         */
 972         if (!(e->xbutton.button == 4 || e->xbutton.button == 5) &&
 973             !grab_on_keyboard())
 974         {
 975             /* use where the press occured */
 976             con = frame_context(client, e->xbutton.window, px, py);
 977             con = mouse_button_frame_context(con, e->xbutton.button,
 978                                              e->xbutton.state);
 979
 980             /* button presses on CLIENT_CONTEXTs are not accompanied by a
 981                release because they are Replayed to the client */
 982             if ((e->type == ButtonRelease || CLIENT_CONTEXT(con, client)) &&
 983                 e->xbutton.button == pb)
 984                 pb = 0, px = py = -1, pcon = OB_FRAME_CONTEXT_NONE;
 985
 986             but = context_to_button(client->frame, con, TRUE);
 987             if (but) {
 988                 *but = (e->type == ButtonPress);
 989                 frame_adjust_state(client->frame);
 990             }
 991         }
 992         break;
 993     case MotionNotify:
 994         /* when there is a grab on the pointer, we won't get enter/leave
 995            notifies, but we still get motion events */
 996         if (grab_on_pointer()) break;
 997
 998         con = frame_context(client, e->xmotion.window,
 999                             e->xmotion.x, e->xmotion.y);
1000         switch (con) {
1001         case OB_FRAME_CONTEXT_TITLEBAR:
1002         case OB_FRAME_CONTEXT_TLCORNER:
1003         case OB_FRAME_CONTEXT_TRCORNER:
1004             /* we've left the button area inside the titlebar */
1005             if (client->frame->max_hover || client->frame->desk_hover ||
1006                 client->frame->shade_hover || client->frame->iconify_hover ||
1007                 client->frame->close_hover)
1008             {
1009                 client->frame->max_hover =
1010                     client->frame->desk_hover =
1011                     client->frame->shade_hover =
1012                     client->frame->iconify_hover =
1013                     client->frame->close_hover = FALSE;
1014                 frame_adjust_state(client->frame);
1015             }
1016             break;
1017         default:
1018             but = context_to_button(client->frame, con, FALSE);
1019             if (but && !*but && !pb) {
1020                 *but = TRUE;
1021                 frame_adjust_state(client->frame);
1022             }
1023             break;
1024         }
1025         break;
1026     case LeaveNotify:
1027         con = frame_context(client, e->xcrossing.window,
1028                             e->xcrossing.x, e->xcrossing.y);
1029         switch (con) {
1030         case OB_FRAME_CONTEXT_TITLEBAR:
1031         case OB_FRAME_CONTEXT_TLCORNER:
1032         case OB_FRAME_CONTEXT_TRCORNER:
1033             /* we've left the button area inside the titlebar */
1034             client->frame->max_hover =
1035                 client->frame->desk_hover =
1036                 client->frame->shade_hover =
1037                 client->frame->iconify_hover =
1038                 client->frame->close_hover = FALSE;
1039             if (e->xcrossing.mode == NotifyGrab) {
1040                 client->frame->max_press =
1041                     client->frame->desk_press =
1042                     client->frame->shade_press =
1043                     client->frame->iconify_press =
1044                     client->frame->close_press = FALSE;
1045             }
1046             break;
1047         case OB_FRAME_CONTEXT_FRAME:
1048             /* When the mouse leaves an animating window, don't use the
1049                corresponding enter events. Pretend like the animating window
1050                doesn't even exist..! */
1051             if (frame_iconify_animating(client->frame))
1052                 event_end_ignore_all_enters(event_start_ignore_all_enters());
1053
1054             ob_debug_type(OB_DEBUG_FOCUS,
1055                           "%sNotify mode %d detail %d on %lx",
1056                           (e->type == EnterNotify ? "Enter" : "Leave"),
1057                           e->xcrossing.mode,
1058                           e->xcrossing.detail, (client?client->window:0));
1059             if (grab_on_keyboard())
1060                 break;
1061             if (config_focus_follow &&
1062                 /* leave inferior events can happen when the mouse goes onto
1063                    the window's border and then into the window before the
1064                    delay is up */
1065                 e->xcrossing.detail != NotifyInferior)
1066             {
1067                 if (config_focus_delay)
1068                     obt_main_loop_timeout_remove_data(ob_main_loop,
1069                                                       focus_delay_func,
1070                                                       client, FALSE);
1071                 if (config_unfocus_leave)
1072                     event_leave_client(client);
1073             }
1074             break;
1075         default:
1076             but = context_to_button(client->frame, con, FALSE);
1077             if (but) {
1078                 *but = FALSE;
1079                 if (e->xcrossing.mode == NotifyGrab) {
1080                     but = context_to_button(client->frame, con, TRUE);
1081                     *but = FALSE;
1082                 }
1083                 frame_adjust_state(client->frame);
1084             }
1085             break;
1086         }
1087         break;
1088     case EnterNotify:
1089     {
1090         con = frame_context(client, e->xcrossing.window,
1091                             e->xcrossing.x, e->xcrossing.y);
1092         switch (con) {
1093         case OB_FRAME_CONTEXT_FRAME:
1094             if (grab_on_keyboard())
1095                 break;
1096             if (e->xcrossing.mode == NotifyGrab ||
1097                 e->xcrossing.mode == NotifyUngrab ||
1098                 /*ignore enters when we're already in the window */
1099                 e->xcrossing.detail == NotifyInferior)
1100             {
1101                 ob_debug_type(OB_DEBUG_FOCUS,
1102                               "%sNotify mode %d detail %d serial %lu on %lx "
1103                               "IGNORED",
1104                               (e->type == EnterNotify ? "Enter" : "Leave"),
1105                               e->xcrossing.mode,
1106                               e->xcrossing.detail,
1107                               e->xcrossing.serial,
1108                               client?client->window:0);
1109             }
1110             else {
1111                 ob_debug_type(OB_DEBUG_FOCUS,
1112                               "%sNotify mode %d detail %d serial %lu on %lx, "
1113                               "focusing window",
1114                               (e->type == EnterNotify ? "Enter" : "Leave"),
1115                               e->xcrossing.mode,
1116                               e->xcrossing.detail,
1117                               e->xcrossing.serial,
1118                               (client?client->window:0));
1119                 if (config_focus_follow) {
1120                     if (config_focus_delay)
1121                         obt_main_loop_timeout_remove_data(ob_main_loop,
1122                                                           unfocus_delay_func,
1123                                                           client, FALSE);
1124                     event_enter_client(client);
1125                 }
1126             }
1127             break;
1128         default:
1129             but = context_to_button(client->frame, con, FALSE);
1130             if (but) {
1131                 *but = TRUE;
1132                 if (e->xcrossing.mode == NotifyUngrab) {
1133                     but = context_to_button(client->frame, con, TRUE);
1134                     *but = (con == pcon);
1135                 }
1136                 frame_adjust_state(client->frame);
1137             }
1138             break;
1139         }
1140         break;
1141     }
1142     case ConfigureRequest:
1143     {
1144         /* dont compress these unless you're going to watch for property
1145            notifies in between (these can change what the configure would
1146            do to the window).
1147            also you can't compress stacking events
1148         */
1149
1150         gint x, y, w, h;
1151         gboolean move = FALSE;
1152         gboolean resize = FALSE;
1153
1154         /* get the current area */
1155         RECT_TO_DIMS(client->area, x, y, w, h);
1156
1157         ob_debug("ConfigureRequest for \"%s\" desktop %d wmstate %d "
1158                  "visible %d",
1159                  client->title,
1160                  screen_desktop, client->wmstate, client->frame->visible);
1161         ob_debug("                     x %d y %d w %d h %d b %d",
1162                  x, y, w, h, client->border_width);
1163
1164         if (e->xconfigurerequest.value_mask & CWBorderWidth)
1165             if (client->border_width != e->xconfigurerequest.border_width) {
1166                 client->border_width = e->xconfigurerequest.border_width;
1167
1168                 /* if the border width is changing then that is the same
1169                    as requesting a resize, but we don't actually change
1170                    the client's border, so it will change their root
1171                    coordinates (since they include the border width) and
1172                    we need to a notify then */
1173                 move = TRUE;
1174             }
1175
1176         if (e->xconfigurerequest.value_mask & CWStackMode) {
1177             ObClient *sibling = NULL;
1178             gulong ignore_start;
1179             gboolean ok = TRUE;
1180
1181             /* get the sibling */
1182             if (e->xconfigurerequest.value_mask & CWSibling) {
1183                 ObWindow *win;
1184                 win = window_find(e->xconfigurerequest.above);
1185                 if (win && WINDOW_IS_CLIENT(win) &&
1186                     WINDOW_AS_CLIENT(win) != client)
1187                 {
1188                     sibling = WINDOW_AS_CLIENT(win);
1189                 }
1190                 else
1191                     /* an invalid sibling was specified so don't restack at
1192                        all, it won't make sense no matter what we do */
1193                     ok = FALSE;
1194             }
1195
1196             if (ok) {
1197                 if (!config_focus_under_mouse)
1198                     ignore_start = event_start_ignore_all_enters();
1199                 stacking_restack_request(client, sibling,
1200                                          e->xconfigurerequest.detail);
1201                 if (!config_focus_under_mouse)
1202                     event_end_ignore_all_enters(ignore_start);
1203             }
1204
1205             /* a stacking change moves the window without resizing */
1206             move = TRUE;
1207         }
1208
1209         if ((e->xconfigurerequest.value_mask & CWX) ||
1210             (e->xconfigurerequest.value_mask & CWY) ||
1211             (e->xconfigurerequest.value_mask & CWWidth) ||
1212             (e->xconfigurerequest.value_mask & CWHeight))
1213         {
1214             /* don't allow clients to move shaded windows (fvwm does this)
1215             */
1216             if (e->xconfigurerequest.value_mask & CWX) {
1217                 if (!client->shaded)
1218                     x = e->xconfigurerequest.x;
1219                 move = TRUE;
1220             }
1221             if (e->xconfigurerequest.value_mask & CWY) {
1222                 if (!client->shaded)
1223                     y = e->xconfigurerequest.y;
1224                 move = TRUE;
1225             }
1226
1227             if (e->xconfigurerequest.value_mask & CWWidth) {
1228                 w = e->xconfigurerequest.width;
1229                 resize = TRUE;
1230             }
1231             if (e->xconfigurerequest.value_mask & CWHeight) {
1232                 h = e->xconfigurerequest.height;
1233                 resize = TRUE;
1234             }
1235         }
1236
1237         ob_debug("ConfigureRequest x(%d) %d y(%d) %d w(%d) %d h(%d) %d "
1238                  "move %d resize %d",
1239                  e->xconfigurerequest.value_mask & CWX, x,
1240                  e->xconfigurerequest.value_mask & CWY, y,
1241                  e->xconfigurerequest.value_mask & CWWidth, w,
1242                  e->xconfigurerequest.value_mask & CWHeight, h,
1243                  move, resize);
1244
1245         /* check for broken apps moving to their root position
1246
1247            XXX remove this some day...that would be nice. right now all
1248            kde apps do this when they try activate themselves on another
1249            desktop. eg. open amarok window on desktop 1, switch to desktop
1250            2, click amarok tray icon. it will move by its decoration size.
1251         */
1252         if (x != client->area.x &&
1253             x == (client->frame->area.x + client->frame->size.left -
1254                   (gint)client->border_width) &&
1255             y != client->area.y &&
1256             y == (client->frame->area.y + client->frame->size.top -
1257                   (gint)client->border_width) &&
1258             w == client->area.width &&
1259             h == client->area.height)
1260         {
1261             ob_debug_type(OB_DEBUG_APP_BUGS,
1262                           "Application %s is trying to move via "
1263                           "ConfigureRequest to it's root window position "
1264                           "but it is not using StaticGravity",
1265                           client->title);
1266             /* don't move it */
1267             x = client->area.x;
1268             y = client->area.y;
1269
1270             /* they still requested a move, so don't change whether a
1271                notify is sent or not */
1272         }
1273
1274         /* check for broken apps (java swing) moving to 0,0 when there is a
1275            strut there.
1276
1277            XXX remove this some day...that would be nice. but really unexpected
1278            from Sun Microsystems.
1279         */
1280         if (x == 0 && y == 0 && client->gravity == NorthWestGravity &&
1281             client_normal(client))
1282         {
1283             const Rect to = { x, y, w, h };
1284
1285             /* oldschool fullscreen windows are allowed */
1286             if (!client_is_oldfullscreen(client, &to)) {
1287                 Rect *r;
1288
1289                 r = screen_area(client->desktop, SCREEN_AREA_ALL_MONITORS,
1290                                 NULL);
1291                 if (r->x || r->y) {
1292                     /* move the window only to the corner outside struts */
1293                     x = r->x;
1294                     y = r->y;
1295
1296                     ob_debug_type(OB_DEBUG_APP_BUGS,
1297                                   "Application %s is trying to move via "
1298                                   "ConfigureRequest to 0,0 using "
1299                                   "NorthWestGravity, while there is a "
1300                                   "strut there. "
1301                                   "Moving buggy app from (0,0) to (%d,%d)",
1302                                   client->title, r->x, r->y);
1303                 }
1304
1305                 g_slice_free(Rect, r);
1306
1307                 /* they still requested a move, so don't change whether a
1308                    notify is sent or not */
1309             }
1310         }
1311
1312         {
1313             gint lw, lh;
1314
1315             client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
1316
1317             /* if x was not given, then use gravity to figure out the new
1318                x.  the reference point should not be moved */
1319             if ((e->xconfigurerequest.value_mask & CWWidth &&
1320                  !(e->xconfigurerequest.value_mask & CWX)))
1321                 client_gravity_resize_w(client, &x, client->area.width, w);
1322             /* same for y */
1323             if ((e->xconfigurerequest.value_mask & CWHeight &&
1324                  !(e->xconfigurerequest.value_mask & CWY)))
1325                 client_gravity_resize_h(client, &y, client->area.height,h);
1326
1327             client_find_onscreen(client, &x, &y, w, h, FALSE);
1328
1329             ob_debug("Granting ConfigureRequest x %d y %d w %d h %d",
1330                      x, y, w, h);
1331             client_configure(client, x, y, w, h, FALSE, TRUE, TRUE);
1332         }
1333         break;
1334     }
1335     case UnmapNotify:
1336         ob_debug("UnmapNotify for window 0x%x eventwin 0x%x sendevent %d "
1337                  "ignores left %d",
1338                  client->window, e->xunmap.event, e->xunmap.from_configure,
1339                  client->ignore_unmaps);
1340         if (client->ignore_unmaps) {
1341             client->ignore_unmaps--;
1342             break;
1343         }
1344         client_unmanage(client);
1345         break;
1346     case DestroyNotify:
1347         ob_debug("DestroyNotify for window 0x%x", client->window);
1348         client_unmanage(client);
1349         break;
1350     case ReparentNotify:
1351         /* this is when the client is first taken captive in the frame */
1352         if (e->xreparent.parent == client->frame->window) break;
1353
1354         /*
1355           This event is quite rare and is usually handled in unmapHandler.
1356           However, if the window is unmapped when the reparent event occurs,
1357           the window manager never sees it because an unmap event is not sent
1358           to an already unmapped window.
1359         */
1360
1361         ob_debug("ReparentNotify for window 0x%x", client->window);
1362         client_unmanage(client);
1363         break;
1364     case MapRequest:
1365         ob_debug("MapRequest for 0x%lx", client->window);
1366         if (!client->iconic) break; /* this normally doesn't happen, but if it
1367                                        does, we don't want it!
1368                                        it can happen now when the window is on
1369                                        another desktop, but we still don't
1370                                        want it! */
1371         client_activate(client, FALSE, FALSE, TRUE, TRUE, TRUE);
1372         break;
1373     case ClientMessage:
1374         /* validate cuz we query stuff off the client here */
1375         if (!client_validate(client)) break;
1376
1377         if (e->xclient.format != 32) return;
1378
1379         msgtype = e->xclient.message_type;
1380         if (msgtype == OBT_PROP_ATOM(WM_CHANGE_STATE)) {
1381             if (!more_client_message_event(client->window, msgtype))
1382                 client_set_wm_state(client, e->xclient.data.l[0]);
1383         } else if (msgtype == OBT_PROP_ATOM(NET_WM_DESKTOP)) {
1384             if (!more_client_message_event(client->window, msgtype) &&
1385                 ((unsigned)e->xclient.data.l[0] < screen_num_desktops ||
1386                  (unsigned)e->xclient.data.l[0] == DESKTOP_ALL))
1387             {
1388                 client_set_desktop(client, (unsigned)e->xclient.data.l[0],
1389                                    FALSE, FALSE);
1390             }
1391         } else if (msgtype == OBT_PROP_ATOM(NET_WM_STATE)) {
1392             gulong ignore_start;
1393
1394             /* can't compress these */
1395             ob_debug("net_wm_state %s %ld %ld for 0x%lx",
1396                      (e->xclient.data.l[0] == 0 ? "Remove" :
1397                       e->xclient.data.l[0] == 1 ? "Add" :
1398                       e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
1399                      e->xclient.data.l[1], e->xclient.data.l[2],
1400                      client->window);
1401
1402             /* ignore enter events caused by these like ob actions do */
1403             if (!config_focus_under_mouse)
1404                 ignore_start = event_start_ignore_all_enters();
1405             client_set_state(client, e->xclient.data.l[0],
1406                              e->xclient.data.l[1], e->xclient.data.l[2]);
1407             if (!config_focus_under_mouse)
1408                 event_end_ignore_all_enters(ignore_start);
1409         } else if (msgtype == OBT_PROP_ATOM(NET_CLOSE_WINDOW)) {
1410             ob_debug("net_close_window for 0x%lx", client->window);
1411             client_close(client);
1412         } else if (msgtype == OBT_PROP_ATOM(NET_ACTIVE_WINDOW)) {
1413             ob_debug("net_active_window for 0x%lx source=%s",
1414                      client->window,
1415                      (e->xclient.data.l[0] == 0 ? "unknown" :
1416                       (e->xclient.data.l[0] == 1 ? "application" :
1417                        (e->xclient.data.l[0] == 2 ? "user" : "INVALID"))));
1418             /* XXX make use of data.l[2] !? */
1419             if (e->xclient.data.l[0] == 1 || e->xclient.data.l[0] == 2) {
1420                 /* we can not trust the timestamp from applications.
1421                    e.g. chromium passes a very old timestamp.  openbox thinks
1422                    the window will get focus and calls XSetInputFocus with the
1423                    (old) timestamp, which doesn't end up moving focus at all.
1424                    but the window is raised, not hilited, etc, as if it was
1425                    really going to get focus.
1426
1427                    so do not use this timestamp in event_curtime, as this would
1428                    be used in XSetInputFocus.
1429                 */
1430                 event_sourcetime = e->xclient.data.l[1];
1431                 if (e->xclient.data.l[1] == 0)
1432                     ob_debug_type(OB_DEBUG_APP_BUGS,
1433                                   "_NET_ACTIVE_WINDOW message for window %s is"
1434                                   " missing a timestamp", client->title);
1435             } else
1436                 ob_debug_type(OB_DEBUG_APP_BUGS,
1437                               "_NET_ACTIVE_WINDOW message for window %s is "
1438                               "missing source indication", client->title);
1439             client_activate(client, FALSE, FALSE, TRUE, TRUE,
1440                             (e->xclient.data.l[0] == 0 ||
1441                              e->xclient.data.l[0] == 2));
1442         } else if (msgtype == OBT_PROP_ATOM(NET_WM_MOVERESIZE)) {
1443             ob_debug("net_wm_moveresize for 0x%lx direction %d",
1444                      client->window, e->xclient.data.l[2]);
1445             if ((Atom)e->xclient.data.l[2] ==
1446                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPLEFT) ||
1447                 (Atom)e->xclient.data.l[2] ==
1448                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOP) ||
1449                 (Atom)e->xclient.data.l[2] ==
1450                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_TOPRIGHT) ||
1451                 (Atom)e->xclient.data.l[2] ==
1452                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
1453                 (Atom)e->xclient.data.l[2] ==
1454                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_RIGHT) ||
1455                 (Atom)e->xclient.data.l[2] ==
1456                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT) ||
1457                 (Atom)e->xclient.data.l[2] ==
1458                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOM) ||
1459                 (Atom)e->xclient.data.l[2] ==
1460                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT) ||
1461                 (Atom)e->xclient.data.l[2] ==
1462                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_LEFT) ||
1463                 (Atom)e->xclient.data.l[2] ==
1464                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE) ||
1465                 (Atom)e->xclient.data.l[2] ==
1466                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_SIZE_KEYBOARD) ||
1467                 (Atom)e->xclient.data.l[2] ==
1468                 OBT_PROP_ATOM(NET_WM_MOVERESIZE_MOVE_KEYBOARD))
1469             {
1470                 moveresize_start(client, e->xclient.data.l[0],
1471                                  e->xclient.data.l[1], e->xclient.data.l[3],
1472                                  e->xclient.data.l[2]);
1473             }
1474             else if ((Atom)e->xclient.data.l[2] ==
1475                      OBT_PROP_ATOM(NET_WM_MOVERESIZE_CANCEL))
1476                 moveresize_end(TRUE);
1477         } else if (msgtype == OBT_PROP_ATOM(NET_MOVERESIZE_WINDOW)) {
1478             gint ograv, x, y, w, h;
1479
1480             ograv = client->gravity;
1481
1482             if (e->xclient.data.l[0] & 0xff)
1483                 client->gravity = e->xclient.data.l[0] & 0xff;
1484
1485             if (e->xclient.data.l[0] & 1 << 8)
1486                 x = e->xclient.data.l[1];
1487             else
1488                 x = client->area.x;
1489             if (e->xclient.data.l[0] & 1 << 9)
1490                 y = e->xclient.data.l[2];
1491             else
1492                 y = client->area.y;
1493
1494             if (e->xclient.data.l[0] & 1 << 10) {
1495                 w = e->xclient.data.l[3];
1496
1497                 /* if x was not given, then use gravity to figure out the new
1498                    x.  the reference point should not be moved */
1499                 if (!(e->xclient.data.l[0] & 1 << 8))
1500                     client_gravity_resize_w(client, &x, client->area.width, w);
1501             }
1502             else
1503                 w = client->area.width;
1504
1505             if (e->xclient.data.l[0] & 1 << 11) {
1506                 h = e->xclient.data.l[4];
1507
1508                 /* same for y */
1509                 if (!(e->xclient.data.l[0] & 1 << 9))
1510                     client_gravity_resize_h(client, &y, client->area.height,h);
1511             }
1512             else
1513                 h = client->area.height;
1514
1515             ob_debug("MOVERESIZE x %d %d y %d %d (gravity %d)",
1516                      e->xclient.data.l[0] & 1 << 8, x,
1517                      e->xclient.data.l[0] & 1 << 9, y,
1518                      client->gravity);
1519
1520             client_find_onscreen(client, &x, &y, w, h, FALSE);
1521
1522             client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
1523
1524             client->gravity = ograv;
1525         } else if (msgtype == OBT_PROP_ATOM(NET_RESTACK_WINDOW)) {
1526             if (e->xclient.data.l[0] != 2) {
1527                 ob_debug_type(OB_DEBUG_APP_BUGS,
1528                               "_NET_RESTACK_WINDOW sent for window %s with "
1529                               "invalid source indication %ld",
1530                               client->title, e->xclient.data.l[0]);
1531             } else {
1532                 ObClient *sibling = NULL;
1533                 if (e->xclient.data.l[1]) {
1534                     ObWindow *win = window_find(e->xclient.data.l[1]);
1535                     if (WINDOW_IS_CLIENT(win) &&
1536                         WINDOW_AS_CLIENT(win) != client)
1537                     {
1538                         sibling = WINDOW_AS_CLIENT(win);
1539                     }
1540                     if (sibling == NULL)
1541                         ob_debug_type(OB_DEBUG_APP_BUGS,
1542                                       "_NET_RESTACK_WINDOW sent for window %s "
1543                                       "with invalid sibling 0x%x",
1544                                  client->title, e->xclient.data.l[1]);
1545                 }
1546                 if (e->xclient.data.l[2] == Below ||
1547                     e->xclient.data.l[2] == BottomIf ||
1548                     e->xclient.data.l[2] == Above ||
1549                     e->xclient.data.l[2] == TopIf ||
1550                     e->xclient.data.l[2] == Opposite)
1551                 {
1552                     gulong ignore_start;
1553
1554                     if (!config_focus_under_mouse)
1555                         ignore_start = event_start_ignore_all_enters();
1556                     /* just raise, don't activate */
1557                     stacking_restack_request(client, sibling,
1558                                              e->xclient.data.l[2]);
1559                     if (!config_focus_under_mouse)
1560                         event_end_ignore_all_enters(ignore_start);
1561
1562                     /* send a synthetic ConfigureNotify, cuz this is supposed
1563                        to be like a ConfigureRequest. */
1564                     client_reconfigure(client, TRUE);
1565                 } else
1566                     ob_debug_type(OB_DEBUG_APP_BUGS,
1567                                   "_NET_RESTACK_WINDOW sent for window %s "
1568                                   "with invalid detail %d",
1569                                   client->title, e->xclient.data.l[2]);
1570             }
1571         }
1572         break;
1573     case PropertyNotify:
1574         /* validate cuz we query stuff off the client here */
1575         if (!client_validate(client)) break;
1576
1577         msgtype = e->xproperty.atom;
1578
1579         /* ignore changes to some properties if there is another change
1580            coming in the queue */
1581         {
1582             struct ObSkipPropertyChange s;
1583             s.window = client->window;
1584             s.prop = msgtype;
1585             if (xqueue_exists_local(skip_property_change, &s))
1586                 break;
1587         }
1588
1589         msgtype = e->xproperty.atom;
1590         if (msgtype == XA_WM_NORMAL_HINTS) {
1591             int x, y, w, h, lw, lh;
1592
1593             ob_debug("Update NORMAL hints");
1594             client_update_normal_hints(client);
1595             /* normal hints can make a window non-resizable */
1596             client_setup_decor_and_functions(client, FALSE);
1597
1598             x = client->area.x;
1599             y = client->area.y;
1600             w = client->area.width;
1601             h = client->area.height;
1602
1603             /* apply the new normal hints */
1604             client_try_configure(client, &x, &y, &w, &h, &lw, &lh, FALSE);
1605             /* make sure the window is visible, and if the window is resized
1606                off-screen due to the normal hints changing then this will push
1607                it back onto the screen. */
1608             client_find_onscreen(client, &x, &y, w, h, FALSE);
1609
1610             /* make sure the client's sizes are within its bounds, but don't
1611                make it reply with a configurenotify unless something changed.
1612                emacs will update its normal hints every time it receives a
1613                configurenotify */
1614             client_configure(client, x, y, w, h, FALSE, TRUE, FALSE);
1615         } else if (msgtype == OBT_PROP_ATOM(MOTIF_WM_HINTS)) {
1616             client_get_mwm_hints(client);
1617             /* This can override some mwm hints */
1618             client_get_type_and_transientness(client);
1619
1620             /* Apply the changes to the window */
1621             client_setup_decor_and_functions(client, TRUE);
1622         } else if (msgtype == XA_WM_HINTS) {
1623             client_update_wmhints(client);
1624         } else if (msgtype == XA_WM_TRANSIENT_FOR) {
1625             /* get the transient-ness first, as this affects if the client
1626                decides to be transient for the group or not in
1627                client_update_transient_for() */
1628             client_get_type_and_transientness(client);
1629             client_update_transient_for(client);
1630             /* type may have changed, so update the layer */
1631             client_calc_layer(client);
1632             client_setup_decor_and_functions(client, TRUE);
1633         } else if (msgtype == OBT_PROP_ATOM(NET_WM_NAME) ||
1634                    msgtype == OBT_PROP_ATOM(WM_NAME) ||
1635                    msgtype == OBT_PROP_ATOM(NET_WM_ICON_NAME) ||
1636                    msgtype == OBT_PROP_ATOM(WM_ICON_NAME)) {
1637             client_update_title(client);
1638         } else if (msgtype == OBT_PROP_ATOM(WM_PROTOCOLS)) {
1639             client_update_protocols(client);
1640             client_setup_decor_and_functions(client, TRUE);
1641         }
1642         else if (msgtype == OBT_PROP_ATOM(NET_WM_STRUT) ||
1643                  msgtype == OBT_PROP_ATOM(NET_WM_STRUT_PARTIAL)) {
1644             client_update_strut(client);
1645         }
1646         else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON)) {
1647             client_update_icons(client);
1648         }
1649         else if (msgtype == OBT_PROP_ATOM(NET_WM_ICON_GEOMETRY)) {
1650             client_update_icon_geometry(client);
1651         }
1652         else if (msgtype == OBT_PROP_ATOM(NET_WM_USER_TIME)) {
1653             guint32 t;
1654             if (client == focus_client &&
1655                 OBT_PROP_GET32(client->window, NET_WM_USER_TIME, CARDINAL, &t)
1656                 && t && !event_time_after(t, e->xproperty.time) &&
1657                 (!event_last_user_time ||
1658                  event_time_after(t, event_last_user_time)))
1659             {
1660                 event_last_user_time = t;
1661             }
1662         }
1663 #ifdef SYNC
1664         else if (msgtype == OBT_PROP_ATOM(NET_WM_SYNC_REQUEST_COUNTER)) {
1665             /* if they are resizing right now this would cause weird behaviour.
1666                if one day a user reports clients stop resizing, then handle
1667                this better by resetting a new XSync alarm and stuff on the
1668                new counter, but I expect it will never happen */
1669             if (moveresize_client == client)
1670                 moveresize_end(FALSE);
1671             client_update_sync_request_counter(client);
1672         }
1673 #endif
1674         break;
1675     case ColormapNotify:
1676         client_update_colormap(client, e->xcolormap.colormap);
1677         break;
1678     default:
1679         ;
1680 #ifdef SHAPE
1681         {
1682             int kind;
1683             if (obt_display_extension_shape &&
1684                 e->type == obt_display_extension_shape_basep)
1685             {
1686                 switch (((XShapeEvent*)e)->kind) {
1687                     case ShapeBounding:
1688                     case ShapeClip:
1689                         client->shaped = ((XShapeEvent*)e)->shaped;
1690                         kind = ShapeBounding;
1691                         break;
1692                     case ShapeInput:
1693                         client->shaped_input = ((XShapeEvent*)e)->shaped;
1694                         kind = ShapeInput;
1695                         break;
1696                     default:
1697                         g_assert_not_reached();
1698                 }
1699                 frame_adjust_shape_kind(client->frame, kind);
1700             }
1701         }
1702 #endif
1703     }
1704 }
1705
1706 static void event_handle_dock(ObDock *s, XEvent *e)
1707 {
1708     switch (e->type) {
1709     case ButtonPress:
1710         if (e->xbutton.button == 1)
1711             stacking_raise(DOCK_AS_WINDOW(s));
1712         else if (e->xbutton.button == 2)
1713             stacking_lower(DOCK_AS_WINDOW(s));
1714         break;
1715     case EnterNotify:
1716         dock_hide(FALSE);
1717         break;
1718     case LeaveNotify:
1719         /* don't hide when moving into a dock app */
1720         if (e->xcrossing.detail != NotifyInferior)
1721             dock_hide(TRUE);
1722         break;
1723     }
1724 }
1725
1726 static void event_handle_dockapp(ObDockApp *app, XEvent *e)
1727 {
1728     switch (e->type) {
1729     case MotionNotify:
1730         dock_app_drag(app, &e->xmotion);
1731         break;
1732     case UnmapNotify:
1733         if (app->ignore_unmaps) {
1734             app->ignore_unmaps--;
1735             break;
1736         }
1737         dock_unmanage(app, TRUE);
1738         break;
1739     case DestroyNotify:
1740     case ReparentNotify:
1741         dock_unmanage(app, FALSE);
1742         break;
1743     case ConfigureNotify:
1744         dock_app_configure(app, e->xconfigure.width, e->xconfigure.height);
1745         break;
1746     }
1747 }
1748
1749 static ObMenuFrame* find_active_menu(void)
1750 {
1751     GList *it;
1752     ObMenuFrame *ret = NULL;
1753
1754     for (it = menu_frame_visible; it; it = g_list_next(it)) {
1755         ret = it->data;
1756         if (ret->selected)
1757             break;
1758         ret = NULL;
1759     }
1760     return ret;
1761 }
1762
1763 static ObMenuFrame* find_active_or_last_menu(void)
1764 {
1765     ObMenuFrame *ret = NULL;
1766
1767     ret = find_active_menu();
1768     if (!ret && menu_frame_visible)
1769         ret = menu_frame_visible->data;
1770     return ret;
1771 }
1772
1773 static gboolean event_handle_prompt(ObPrompt *p, XEvent *e)
1774 {
1775     switch (e->type) {
1776     case ButtonPress:
1777     case ButtonRelease:
1778     case MotionNotify:
1779         return prompt_mouse_event(p, e);
1780         break;
1781     case KeyPress:
1782         return prompt_key_event(p, e);
1783         break;
1784     }
1785     return FALSE;
1786 }
1787
1788 static gboolean event_handle_menu_input(XEvent *ev)
1789 {
1790     gboolean ret = FALSE;
1791
1792     if (ev->type == ButtonRelease || ev->type == ButtonPress) {
1793         ObMenuEntryFrame *e;
1794
1795         if (menu_hide_delay_reached() &&
1796             (ev->xbutton.button < 4 || ev->xbutton.button > 5))
1797         {
1798             if ((e = menu_entry_frame_under(ev->xbutton.x_root,
1799                                             ev->xbutton.y_root)))
1800             {
1801                 if (ev->type == ButtonPress && e->frame->child)
1802                     menu_frame_select(e->frame->child, NULL, TRUE);
1803                 menu_frame_select(e->frame, e, TRUE);
1804                 if (ev->type == ButtonRelease)
1805                     menu_entry_frame_execute(e, ev->xbutton.state);
1806             }
1807             else if (ev->type == ButtonRelease)
1808                 menu_frame_hide_all();
1809         }
1810         ret = TRUE;
1811     }
1812     else if (ev->type == MotionNotify) {
1813         ObMenuFrame *f;
1814         ObMenuEntryFrame *e;
1815
1816         if ((e = menu_entry_frame_under(ev->xmotion.x_root,
1817                                         ev->xmotion.y_root)))
1818             if (!(f = find_active_menu()) ||
1819                 f == e->frame ||
1820                 f->parent == e->frame ||
1821                 f->child == e->frame)
1822                 menu_frame_select(e->frame, e, FALSE);
1823     }
1824     else if (ev->type == KeyPress || ev->type == KeyRelease) {
1825         guint mods;
1826         ObMenuFrame *frame;
1827
1828         /* get the modifiers */
1829         mods = obt_keyboard_only_modmasks(ev->xkey.state);
1830
1831         frame = find_active_or_last_menu();
1832         if (frame == NULL)
1833             g_assert_not_reached(); /* there is no active menu */
1834
1835         /* Allow control while going thru the menu */
1836         else if (ev->type == KeyPress && (mods & ~ControlMask) == 0) {
1837             gunichar unikey;
1838             KeySym sym;
1839
1840             frame->got_press = TRUE;
1841             frame->press_keycode = ev->xkey.keycode;
1842             frame->press_doexec = FALSE;
1843
1844             sym = obt_keyboard_keypress_to_keysym(ev);
1845
1846             if (sym == XK_Escape) {
1847                 menu_frame_hide_all();
1848                 ret = TRUE;
1849             }
1850
1851             else if (sym == XK_Left) {
1852                 /* Left goes to the parent menu */
1853                 if (frame->parent) {
1854                     /* remove focus from the child */
1855                     menu_frame_select(frame, NULL, TRUE);
1856                     /* and put it in the parent */
1857                     menu_frame_select(frame->parent, frame->parent->selected,
1858                                       TRUE);
1859                 }
1860                 ret = TRUE;
1861             }
1862
1863             else if (sym == XK_Right) {
1864                 /* Right goes to the selected submenu */
1865                 if (frame->selected &&
1866                     frame->selected->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
1867                 {
1868                     /* make sure it is visible */
1869                     menu_frame_select(frame, frame->selected, TRUE);
1870                     menu_frame_select_next(frame->child);
1871                 }
1872                 ret = TRUE;
1873             }
1874
1875             else if (sym == XK_Up) {
1876                 menu_frame_select_previous(frame);
1877                 ret = TRUE;
1878             }
1879
1880             else if (sym == XK_Down) {
1881                 menu_frame_select_next(frame);
1882                 ret = TRUE;
1883             }
1884
1885             else if (sym == XK_Home) {
1886                 menu_frame_select_first(frame);
1887                 ret = TRUE;
1888             }
1889
1890             else if (sym == XK_End) {
1891                 menu_frame_select_last(frame);
1892                 ret = TRUE;
1893             }
1894
1895             else if (sym == XK_Return || sym == XK_KP_Enter) {
1896                 frame->press_doexec = TRUE;
1897                 ret = TRUE;
1898             }
1899
1900             /* keyboard accelerator shortcuts. (if it was a valid key) */
1901             else if (frame->entries &&
1902                      (unikey =
1903                       obt_keyboard_keypress_to_unichar(menu_frame_ic(frame),
1904                                                        ev)))
1905             {
1906                 GList *start;
1907                 GList *it;
1908                 ObMenuEntryFrame *found = NULL;
1909                 guint num_found = 0;
1910
1911                 /* start after the selected one */
1912                 start = frame->entries;
1913                 if (frame->selected) {
1914                     for (it = start; frame->selected != it->data;
1915                          it = g_list_next(it))
1916                         g_assert(it != NULL); /* nothing was selected? */
1917                     /* next with wraparound */
1918                     start = g_list_next(it);
1919                     if (start == NULL) start = frame->entries;
1920                 }
1921
1922                 it = start;
1923                 do {
1924                     ObMenuEntryFrame *e = it->data;
1925                     gunichar entrykey = 0;
1926
1927                     if (e->entry->type == OB_MENU_ENTRY_TYPE_NORMAL)
1928                         entrykey = e->entry->data.normal.shortcut;
1929                     else if (e->entry->type == OB_MENU_ENTRY_TYPE_SUBMENU)
1930                         entrykey = e->entry->data.submenu.submenu->shortcut;
1931
1932                     if (unikey == entrykey) {
1933                         if (found == NULL) found = e;
1934                         ++num_found;
1935                     }
1936
1937                     /* next with wraparound */
1938                     it = g_list_next(it);
1939                     if (it == NULL) it = frame->entries;
1940                 } while (it != start);
1941
1942                 if (found) {
1943                     menu_frame_select(frame, found, TRUE);
1944
1945                     if (num_found == 1)
1946                         frame->press_doexec = TRUE;
1947                     ret = TRUE;
1948                 }
1949             }
1950         }
1951
1952         /* Use KeyRelease events for running things so that the key release
1953            doesn't get sent to the focused application.
1954
1955            Allow ControlMask only, and don't bother if the menu is empty */
1956         else if (ev->type == KeyRelease && (mods & ~ControlMask) == 0) {
1957             if (frame->press_keycode == ev->xkey.keycode &&
1958                 frame->got_press &&
1959                 frame->press_doexec)
1960             {
1961                 if (frame->child)
1962                     menu_frame_select_next(frame->child);
1963                 else if (frame->selected)
1964                     menu_entry_frame_execute(frame->selected, ev->xkey.state);
1965             }
1966         }
1967     }
1968
1969     return ret;
1970 }
1971
1972 static gboolean event_look_for_menu_enter(XEvent *ev, gpointer data)
1973 {
1974     const ObMenuFrame *f = (ObMenuFrame*)data;
1975     ObMenuEntryFrame *e;
1976     return ev->type == EnterNotify &&
1977         (e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window)) &&
1978         e->frame == f && !e->ignore_enters;
1979 }
1980
1981 static void event_handle_menu(ObMenuFrame *frame, XEvent *ev)
1982 {
1983     ObMenuFrame *f;
1984     ObMenuEntryFrame *e;
1985
1986     switch (ev->type) {
1987     case EnterNotify:
1988         if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
1989             if (e->ignore_enters)
1990                 --e->ignore_enters;
1991             else if (!(f = find_active_menu()) ||
1992                      f == e->frame ||
1993                      f->parent == e->frame ||
1994                      f->child == e->frame)
1995                 menu_frame_select(e->frame, e, FALSE);
1996         }
1997         break;
1998     case LeaveNotify:
1999         /*ignore leaves when we're already in the window */
2000         if (ev->xcrossing.detail == NotifyInferior)
2001             break;
2002
2003         if ((e = g_hash_table_lookup(menu_frame_map, &ev->xcrossing.window))) {
2004             /* check if an EnterNotify event is coming, and if not, then select
2005                nothing in the menu */
2006             if (!xqueue_exists_local(event_look_for_menu_enter, e->frame))
2007                 menu_frame_select(e->frame, NULL, FALSE);
2008         }
2009         break;
2010     }
2011 }
2012
2013 static gboolean event_handle_user_input(ObClient *client, XEvent *e)
2014 {
2015     g_assert(e->type == ButtonPress || e->type == ButtonRelease ||
2016              e->type == MotionNotify || e->type == KeyPress ||
2017              e->type == KeyRelease);
2018
2019     if (menu_frame_visible) {
2020         if (event_handle_menu_input(e))
2021             /* don't use the event if the menu used it, but if the menu
2022                didn't use it and it's a keypress that is bound, it will
2023                close the menu and be used */
2024             return TRUE;
2025     }
2026
2027     /* if the keyboard interactive action uses the event then dont
2028        use it for bindings. likewise is moveresize uses the event. */
2029     if (actions_interactive_input_event(e) || moveresize_event(e))
2030         return TRUE;
2031
2032     if (moveresize_in_progress)
2033         /* make further actions work on the client being
2034            moved/resized */
2035         client = moveresize_client;
2036
2037     if (e->type == ButtonPress ||
2038         e->type == ButtonRelease ||
2039         e->type == MotionNotify)
2040     {
2041         /* the frame may not be "visible" but they can still click on it
2042            in the case where it is animating before disappearing */
2043         if (!client || !frame_iconify_animating(client->frame))
2044             return mouse_event(client, e);
2045     } else
2046         return keyboard_event((focus_cycle_target ? focus_cycle_target :
2047                                (client ? client : focus_client)), e);
2048
2049     return FALSE;
2050 }
2051
2052 static void focus_delay_dest(gpointer data)
2053 {
2054     g_slice_free(ObFocusDelayData, data);
2055 }
2056
2057 static gboolean focus_delay_cmp(gconstpointer d1, gconstpointer d2)
2058 {
2059     const ObFocusDelayData *f1 = d1;
2060     return f1->client == d2;
2061 }
2062
2063 static gboolean focus_delay_func(gpointer data)
2064 {
2065     ObFocusDelayData *d = data;
2066     Time old = event_curtime; /* save the curtime */
2067
2068     event_curtime = d->time;
2069     event_curserial = d->serial;
2070     if (client_focus(d->client) && config_focus_raise)
2071         stacking_raise(CLIENT_AS_WINDOW(d->client));
2072     event_curtime = old;
2073     return FALSE; /* no repeat */
2074 }
2075
2076 static gboolean unfocus_delay_func(gpointer data)
2077 {
2078     ObFocusDelayData *d = data;
2079     Time old = event_curtime; /* save the curtime */
2080
2081     event_curtime = d->time;
2082     event_curserial = d->serial;
2083     focus_nothing();
2084     event_curtime = old;
2085     return FALSE; /* no repeat */
2086 }
2087
2088 static void focus_delay_client_dest(ObClient *client, gpointer data)
2089 {
2090     obt_main_loop_timeout_remove_data(ob_main_loop, focus_delay_func,
2091                                       client, FALSE);
2092     obt_main_loop_timeout_remove_data(ob_main_loop, unfocus_delay_func,
2093                                       client, FALSE);
2094 }
2095
2096 void event_halt_focus_delay(void)
2097 {
2098     /* ignore all enter events up till the event which caused this to occur */
2099     if (event_curserial) event_ignore_enter_range(1, event_curserial);
2100     obt_main_loop_timeout_remove(ob_main_loop, focus_delay_func);
2101     obt_main_loop_timeout_remove(ob_main_loop, unfocus_delay_func);
2102 }
2103
2104 gulong event_start_ignore_all_enters(void)
2105 {
2106     return NextRequest(obt_display);
2107 }
2108
2109 static void event_ignore_enter_range(gulong start, gulong end)
2110 {
2111     ObSerialRange *r;
2112
2113     g_assert(start != 0);
2114     g_assert(end != 0);
2115
2116     r = g_slice_new(ObSerialRange);
2117     r->start = start;
2118     r->end = end;
2119     ignore_serials = g_slist_prepend(ignore_serials, r);
2120
2121     ob_debug_type(OB_DEBUG_FOCUS, "ignoring enters from %lu until %lu",
2122                   r->start, r->end);
2123
2124     /* increment the serial so we don't ignore events we weren't meant to */
2125     OBT_PROP_ERASE(screen_support_win, MOTIF_WM_HINTS);
2126 }
2127
2128 void event_end_ignore_all_enters(gulong start)
2129 {
2130     /* Use (NextRequest-1) so that we ignore up to the current serial only.
2131        Inside event_ignore_enter_range, we increment the serial by one, but if
2132        we ignore that serial too, then any enter events generated by mouse
2133        movement will be ignored until we create some further network traffic.
2134        Instead ignore up to NextRequest-1, then when we increment the serial,
2135        we will be *past* the range of ignored serials */
2136     event_ignore_enter_range(start, NextRequest(obt_display)-1);
2137 }
2138
2139 static gboolean is_enter_focus_event_ignored(gulong serial)
2140 {
2141     GSList *it, *next;
2142
2143     for (it = ignore_serials; it; it = next) {
2144         ObSerialRange *r = it->data;
2145
2146         next = g_slist_next(it);
2147
2148         if ((glong)(serial - r->end) > 0) {
2149             /* past the end */
2150             ignore_serials = g_slist_delete_link(ignore_serials, it);
2151             g_slice_free(ObSerialRange, r);
2152         }
2153         else if ((glong)(serial - r->start) >= 0)
2154             return TRUE;
2155     }
2156     return FALSE;
2157 }
2158
2159 void event_cancel_all_key_grabs(void)
2160 {
2161     if (actions_interactive_act_running()) {
2162         actions_interactive_cancel_act();
2163         ob_debug("KILLED interactive action");
2164     }
2165     else if (menu_frame_visible) {
2166         menu_frame_hide_all();
2167         ob_debug("KILLED open menus");
2168     }
2169     else if (moveresize_in_progress) {
2170         moveresize_end(TRUE);
2171         ob_debug("KILLED interactive moveresize");
2172     }
2173     else if (grab_on_keyboard()) {
2174         ungrab_keyboard();
2175         ob_debug("KILLED active grab on keyboard");
2176     }
2177     else
2178         ungrab_passive_key();
2179
2180     XSync(obt_display, FALSE);
2181 }
2182
2183 gboolean event_time_after(guint32 t1, guint32 t2)
2184 {
2185     g_assert(t1 != CurrentTime);
2186     g_assert(t2 != CurrentTime);
2187
2188     /*
2189       Timestamp values wrap around (after about 49.7 days). The server, given
2190       its current time is represented by timestamp T, always interprets
2191       timestamps from clients by treating half of the timestamp space as being
2192       later in time than T.
2193       - http://tronche.com/gui/x/xlib/input/pointer-grabbing.html
2194     */
2195
2196     /* TIME_HALF is not half of the number space of a Time type variable.
2197      * Rather, it is half the number space of a timestamp value, which is
2198      * always 32 bits. */
2199 #define TIME_HALF (guint32)(1 << 31)
2200
2201     if (t2 >= TIME_HALF)
2202         /* t2 is in the second half so t1 might wrap around and be smaller than
2203            t2 */
2204         return t1 >= t2 || t1 < (t2 + TIME_HALF);
2205     else
2206         /* t2 is in the first half so t1 has to come after it */
2207         return t1 >= t2 && t1 < (t2 + TIME_HALF);
2208 }
2209
2210 gboolean find_timestamp(XEvent *e, gpointer data)
2211 {
2212     const Time t = event_get_timestamp(e);
2213     if (t != CurrentTime) {
2214         event_curtime = t;
2215         return TRUE;
2216     }
2217     else
2218         return FALSE;
2219 }
2220
2221 Time event_time(void)
2222 {
2223     if (event_curtime) return event_curtime;
2224
2225     /* Some events don't come with timestamps :(
2226        ...but we can get one anyways >:) */
2227
2228     /* Generate a timestamp so there is guaranteed at least one in the queue
2229        eventually */
2230     XChangeProperty(obt_display, screen_support_win,
2231                     OBT_PROP_ATOM(WM_CLASS), OBT_PROP_ATOM(STRING),
2232                     8, PropModeAppend, NULL, 0);
2233
2234     /* Grab the first timestamp available */
2235     xqueue_exists(find_timestamp, NULL);
2236
2237     /*g_assert(event_curtime != CurrentTime);*/
2238
2239     /* Save the time so we don't have to do this again for this event */
2240     return event_curtime;
2241 }
2242
2243 Time event_source_time(void)
2244 {
2245     return event_sourcetime;
2246 }