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