openbox/event.c

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