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