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