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