openbox/event.c

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