openbox/event.c

   1 #include "openbox.h"
   2 #include "dock.h"
   3 #include "client.h"
   4 #include "xerror.h"
   5 #include "prop.h"
   6 #include "config.h"
   7 #include "screen.h"
   8 #include "frame.h"
   9 #include "menu.h"
  10 #include "framerender.h"
  11 #include "focus.h"
  12 #include "moveresize.h"
  13 #include "stacking.h"
  14 #include "extensions.h"
  15 #include "timer.h"
  16 #include "dispatch.h"
  17 #include "event.h"
  18
  19 #include <X11/Xlib.h>
  20 #include <X11/keysym.h>
  21 #include <X11/Xatom.h>
  22 #include <glib.h>
  23
  24 #ifdef USE_LIBSN
  25 #  include <libsn/sn.h>
  26 #endif
  27
  28 #ifdef HAVE_SYS_SELECT_H
  29 #  include <sys/select.h>
  30 #endif
  31
  32 static void event_process(XEvent *e);
  33 static void event_handle_root(XEvent *e);
  34 static void event_handle_dock(Dock *s, XEvent *e);
  35 static void event_handle_dockapp(DockApp *app, XEvent *e);
  36 static void event_handle_client(Client *c, XEvent *e);
  37 static void event_handle_menu(Menu *menu, Client *c, XEvent *e);
  38
  39 #define INVALID_FOCUSIN(e) ((e)->xfocus.detail == NotifyInferior || \
  40                             (e)->xfocus.detail == NotifyAncestor || \
  41                             (e)->xfocus.detail > NotifyNonlinearVirtual)
  42 #define INVALID_FOCUSOUT(e) ((e)->xfocus.mode == NotifyGrab || \
  43                              (e)->xfocus.detail == NotifyInferior || \
  44                              (e)->xfocus.detail == NotifyAncestor || \
  45                              (e)->xfocus.detail > NotifyNonlinearVirtual)
  46
  47 Time event_lasttime = 0;
  48
  49 /*! The value of the mask for the NumLock modifier */
  50 unsigned int NumLockMask;
  51 /*! The value of the mask for the ScrollLock modifier */
  52 unsigned int ScrollLockMask;
  53 /*! The key codes for the modifier keys */
  54 static XModifierKeymap *modmap;
  55 /*! Table of the constant modifier masks */
  56 static const int mask_table[] = {
  57     ShiftMask, LockMask, ControlMask, Mod1Mask,
  58     Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
  59 };
  60 static int mask_table_size;
  61
  62 static fd_set selset, allset;
  63 static int max_fd, x_fd;
  64 static GData *fd_handler_list;
  65
  66 void fd_event_handle();
  67
  68 void event_startup()
  69 {
  70     mask_table_size = sizeof(mask_table) / sizeof(mask_table[0]);
  71
  72     /* get lock masks that are defined by the display (not constant) */
  73     modmap = XGetModifierMapping(ob_display);
  74     g_assert(modmap);
  75     if (modmap && modmap->max_keypermod > 0) {
  76         size_t cnt;
  77         const size_t size = mask_table_size * modmap->max_keypermod;
  78         /* get the values of the keyboard lock modifiers
  79            Note: Caps lock is not retrieved the same way as Scroll and Num
  80            lock since it doesn't need to be. */
  81         const KeyCode num_lock = XKeysymToKeycode(ob_display, XK_Num_Lock);
  82         const KeyCode scroll_lock = XKeysymToKeycode(ob_display,
  83                                                      XK_Scroll_Lock);
  84
  85         for (cnt = 0; cnt < size; ++cnt) {
  86             if (! modmap->modifiermap[cnt]) continue;
  87
  88             if (num_lock == modmap->modifiermap[cnt])
  89                 NumLockMask = mask_table[cnt / modmap->max_keypermod];
  90             if (scroll_lock == modmap->modifiermap[cnt])
  91                 ScrollLockMask = mask_table[cnt / modmap->max_keypermod];
  92         }
  93     }
  94
  95     FD_ZERO(&allset);
  96     max_fd = x_fd = ConnectionNumber(ob_display);
  97     FD_SET(x_fd, &allset);
  98     g_datalist_init(&fd_handler_list);
  99 }
 100
 101 void event_shutdown()
 102 {
 103     XFreeModifiermap(modmap);
 104     g_datalist_clear(&fd_handler_list);
 105 }
 106
 107 void event_loop()
 108 {
 109     XEvent e;
 110     struct timeval *wait;
 111     gboolean had_event = FALSE;
 112
 113     while (TRUE) {
 114         /*
 115           There are slightly different event retrieval semantics here for
 116           local (or high bandwidth) versus remote (or low bandwidth)
 117           connections to the display/Xserver.
 118         */
 119         if (ob_remote) {
 120             if (!XPending(ob_display))
 121                 break;
 122         } else {
 123             /*
 124               This XSync allows for far more compression of events, which
 125               makes things like Motion events perform far far better. Since
 126               it also means network traffic for every event instead of every
 127               X events (where X is the number retrieved at a time), it
 128               probably should not be used for setups where Openbox is
 129               running on a remote/low bandwidth display/Xserver.
 130             */
 131             XSync(ob_display, FALSE);
 132             if (!XEventsQueued(ob_display, QueuedAlready))
 133                 break;
 134         }
 135         XNextEvent(ob_display, &e);
 136
 137 #ifdef USE_LIBSN
 138         sn_display_process_event(ob_sn_display, &e);
 139 #endif
 140
 141         event_process(&e);
 142         had_event = TRUE;
 143     }
 144
 145     if (!had_event) {
 146         timer_dispatch((GTimeVal**)&wait);
 147         selset = allset;
 148         select(max_fd + 1, &selset, NULL, NULL, wait);
 149
 150         /* handle the X events as soon as possible? */
 151         if (FD_ISSET(x_fd, &selset))
 152             return;
 153
 154         fd_event_handle();
 155     }
 156 }
 157
 158 static Window event_get_window(XEvent *e)
 159 {
 160     Window window;
 161
 162     /* pick a window */
 163     switch (e->type) {
 164     case MapRequest:
 165         window = e->xmap.window;
 166         break;
 167     case UnmapNotify:
 168         window = e->xunmap.window;
 169         break;
 170     case DestroyNotify:
 171         window = e->xdestroywindow.window;
 172         break;
 173     case ConfigureRequest:
 174         window = e->xconfigurerequest.window;
 175         break;
 176     case ConfigureNotify:
 177         window = e->xconfigure.window;
 178         break;
 179     default:
 180 #ifdef XKB
 181         if (extensions_xkb && e->type == extensions_xkb_event_basep) {
 182             switch (((XkbAnyEvent*)&e)->xkb_type) {
 183             case XkbBellNotify:
 184                 window = ((XkbBellNotifyEvent*)&e)->window;
 185             default:
 186                 window = None;
 187             }
 188         } else
 189 #endif
 190             window = e->xany.window;
 191     }
 192     return window;
 193 }
 194
 195 static void event_set_lasttime(XEvent *e)
 196 {
 197     /* grab the lasttime and hack up the state */
 198     switch (e->type) {
 199     case ButtonPress:
 200     case ButtonRelease:
 201         event_lasttime = e->xbutton.time;
 202         break;
 203     case KeyPress:
 204         event_lasttime = e->xkey.time;
 205         break;
 206     case KeyRelease:
 207         event_lasttime = e->xkey.time;
 208         break;
 209     case MotionNotify:
 210         event_lasttime = e->xmotion.time;
 211         break;
 212     case PropertyNotify:
 213         event_lasttime = e->xproperty.time;
 214         break;
 215     case EnterNotify:
 216     case LeaveNotify:
 217         event_lasttime = e->xcrossing.time;
 218         break;
 219     default:
 220         event_lasttime = CurrentTime;
 221         break;
 222     }
 223 }
 224
 225 #define STRIP_MODS(s) \
 226         s &= ~(LockMask | NumLockMask | ScrollLockMask), \
 227         /* kill off the Button1Mask etc, only want the modifiers */ \
 228         s &= (ControlMask | ShiftMask | Mod1Mask | \
 229               Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask) \
 230
 231 static void event_hack_mods(XEvent *e)
 232 {
 233     KeyCode *kp;
 234     int i, k;
 235
 236     switch (e->type) {
 237     case ButtonPress:
 238     case ButtonRelease:
 239         STRIP_MODS(e->xbutton.state);
 240         break;
 241     case KeyPress:
 242         STRIP_MODS(e->xkey.state);
 243         break;
 244     case KeyRelease:
 245         STRIP_MODS(e->xkey.state);
 246         /* remove from the state the mask of the modifier being released, if
 247            it is a modifier key being released (this is a little ugly..) */
 248         kp = modmap->modifiermap;
 249         for (i = 0; i < mask_table_size; ++i) {
 250             for (k = 0; k < modmap->max_keypermod; ++k) {
 251                 if (*kp == e->xkey.keycode) { /* found the keycode */
 252                     /* remove the mask for it */
 253                     e->xkey.state &= ~mask_table[i];
 254                     /* cause the first loop to break; */
 255                     i = mask_table_size;
 256                     break; /* get outta here! */
 257                 }
 258                 ++kp;
 259             }
 260         }
 261         break;
 262     case MotionNotify:
 263         STRIP_MODS(e->xmotion.state);
 264         /* compress events */
 265         {
 266             XEvent ce;
 267             while (XCheckTypedWindowEvent(ob_display, e->xmotion.window,
 268                                           e->type, &ce)) {
 269                 e->xmotion.x_root = ce.xmotion.x_root;
 270                 e->xmotion.y_root = ce.xmotion.y_root;
 271             }
 272         }
 273         break;
 274     }
 275 }
 276
 277 static gboolean event_ignore(XEvent *e, Client *client)
 278 {
 279     switch(e->type) {
 280     case FocusIn:
 281         /* NotifyAncestor is not ignored in FocusIn like it is in FocusOut
 282            because of RevertToPointerRoot. If the focus ends up reverting to
 283            pointer root on a workspace change, then the FocusIn event that we
 284            want will be of type NotifyAncestor. This situation does not occur
 285            for FocusOut, so it is safely ignored there.
 286         */
 287         if (INVALID_FOCUSIN(e) ||
 288             client == NULL) {
 289 #ifdef DEBUG_FOCUS
 290         g_message("FocusIn on %lx mode %d detail %d IGNORED", e->xfocus.window,
 291                   e->xfocus.mode, e->xfocus.detail);
 292 #endif
 293             /* says a client was not found for the event (or a valid FocusIn
 294                event was not found.
 295             */
 296             e->xfocus.window = None;
 297             return TRUE;
 298         }
 299
 300 #ifdef DEBUG_FOCUS
 301         g_message("FocusIn on %lx mode %d detail %d", e->xfocus.window,
 302                   e->xfocus.mode, e->xfocus.detail);
 303 #endif
 304         break;
 305     case FocusOut:
 306         if (INVALID_FOCUSOUT(e)) {
 307 #ifdef DEBUG_FOCUS
 308         g_message("FocusOut on %lx mode %d detail %d IGNORED",
 309                   e->xfocus.window, e->xfocus.mode, e->xfocus.detail);
 310 #endif
 311             return TRUE;
 312         }
 313
 314 #ifdef DEBUG_FOCUS
 315         g_message("FocusOut on %lx mode %d detail %d",
 316                   e->xfocus.window, e->xfocus.mode, e->xfocus.detail);
 317 #endif
 318
 319         {
 320             XEvent fe;
 321             gboolean fallback = TRUE;
 322
 323             while (TRUE) {
 324                 if (!XCheckTypedWindowEvent(ob_display, FocusOut,
 325                                             e->xfocus.window,&fe))
 326                     if (!XCheckTypedEvent(ob_display, FocusIn, &fe))
 327                         break;
 328                 if (fe.type == FocusOut) {
 329 #ifdef DEBUG_FOCUS
 330                     g_message("found pending FocusOut");
 331 #endif
 332                     if (!INVALID_FOCUSOUT(&fe)) {
 333                         /* if there is a VALID FocusOut still coming, don't
 334                            fallback focus yet, we'll deal with it then */
 335                         XPutBackEvent(ob_display, &fe);
 336                         fallback = FALSE;
 337                         break;
 338                     }
 339                 } else {
 340 #ifdef DEBUG_FOCUS
 341                     g_message("found pending FocusIn");
 342 #endif
 343                     /* is the focused window getting a FocusOut/In back to
 344                        itself? */
 345                     if (fe.xfocus.window == e->xfocus.window &&
 346                         !event_ignore(&fe, client)) {
 347 #ifdef DEBUG_FOCUS
 348                         g_message("focused window got an Out/In back to "
 349                                   "itself IGNORED both");
 350 #endif
 351                         return TRUE;
 352                     }
 353
 354                     /* once all the FocusOut's have been dealt with, if there
 355                        is a FocusIn still left and it is valid, then use it */
 356                     event_process(&fe);
 357                     /* secret magic way of event_process telling us that no
 358                        client was found for the FocusIn event. ^_^ */
 359                     if (fe.xfocus.window != None) {
 360                         fallback = FALSE;
 361                         break;
 362                     }
 363                 }
 364             }
 365             if (fallback) {
 366 #ifdef DEBUG_FOCUS
 367                 g_message("no valid FocusIn and no FocusOut events found, "
 368                           "falling back");
 369 #endif
 370                 focus_fallback(Fallback_NoFocus);
 371             }
 372         }
 373         break;
 374     case EnterNotify:
 375     case LeaveNotify:
 376         /* NotifyUngrab occurs when a mouse button is released and the event is
 377            caused, like when lowering a window */
 378         /* NotifyVirtual occurs when ungrabbing the pointer */
 379         if (e->xcrossing.mode == NotifyGrab ||
 380             e->xcrossing.detail == NotifyInferior ||
 381             (e->xcrossing.mode == NotifyUngrab &&
 382              e->xcrossing.detail == NotifyVirtual)) {
 383 #ifdef DEBUG_FOCUS
 384             g_message("%sNotify mode %d detail %d on %lx IGNORED",
 385                       (e->type == EnterNotify ? "Enter" : "Leave"),
 386                       e->xcrossing.mode,
 387                       e->xcrossing.detail, client?client->window:0);
 388 #endif
 389             return TRUE;
 390         }
 391 #ifdef DEBUG_FOCUS
 392         g_message("%sNotify mode %d detail %d on %lx",
 393                   (e->type == EnterNotify ? "Enter" : "Leave"),
 394                   e->xcrossing.mode,
 395                   e->xcrossing.detail, client?client->window:0);
 396 #endif
 397         break;
 398     }
 399     return FALSE;
 400 }
 401
 402 static void event_process(XEvent *e)
 403 {
 404     Window window;
 405     Client *client = NULL;
 406     Dock *dock = NULL;
 407     DockApp *dockapp = NULL;
 408     Menu *menu = NULL;
 409     ObWindow *obwin = NULL;
 410
 411     window = event_get_window(e);
 412     if ((obwin = g_hash_table_lookup(window_map, &window))) {
 413         switch (obwin->type) {
 414         case Window_Dock:
 415             dock = WINDOW_AS_DOCK(obwin);
 416             break;
 417         case Window_DockApp:
 418             dockapp = WINDOW_AS_DOCKAPP(obwin);
 419             break;
 420         case Window_Menu:
 421             menu = WINDOW_AS_MENU(obwin);
 422             break;
 423         case Window_Client:
 424             client = WINDOW_AS_CLIENT(obwin);
 425             break;
 426         case Window_Internal:
 427             /* not to be used for events */
 428             g_assert_not_reached();
 429             break;
 430         }
 431     }
 432
 433     event_set_lasttime(e);
 434     event_hack_mods(e);
 435     if (event_ignore(e, client))
 436         return;
 437
 438     /* deal with it in the kernel */
 439     if (menu) {
 440         event_handle_menu(menu, client, e);
 441         return;
 442     } else if (client)
 443         event_handle_client(client, e);
 444     else if (dockapp)
 445         event_handle_dockapp(dockapp, e);
 446     else if (dock)
 447         event_handle_dock(dock, e);
 448     else if (window == ob_root)
 449         event_handle_root(e);
 450     else if (e->type == MapRequest)
 451         client_manage(window);
 452     else if (e->type == ConfigureRequest) {
 453         /* unhandled configure requests must be used to configure the
 454            window directly */
 455         XWindowChanges xwc;
 456
 457         xwc.x = e->xconfigurerequest.x;
 458         xwc.y = e->xconfigurerequest.y;
 459         xwc.width = e->xconfigurerequest.width;
 460         xwc.height = e->xconfigurerequest.height;
 461         xwc.border_width = e->xconfigurerequest.border_width;
 462         xwc.sibling = e->xconfigurerequest.above;
 463         xwc.stack_mode = e->xconfigurerequest.detail;
 464
 465         /* we are not to be held responsible if someone sends us an
 466            invalid request! */
 467         xerror_set_ignore(TRUE);
 468         XConfigureWindow(ob_display, window,
 469                          e->xconfigurerequest.value_mask, &xwc);
 470         xerror_set_ignore(FALSE);
 471     }
 472
 473     if (moveresize_in_progress)
 474         if (e->type == MotionNotify || e->type == ButtonRelease ||
 475             e->type == ButtonPress ||
 476             e->type == KeyPress || e->type == KeyRelease) {
 477             moveresize_event(e);
 478
 479             return; /* no dispatch! */
 480
 481         }
 482
 483     /* user input (action-bound) events */
 484     /*
 485     if (e->type == ButtonPress || e->type == ButtonRelease ||
 486         e->type == MotionNotify)
 487         mouse_event(e, client);
 488     else if (e->type == KeyPress || e->type == KeyRelease)
 489         ;
 490     */
 491
 492     /* dispatch the event to registered handlers */
 493     dispatch_x(e, client);
 494 }
 495
 496 static void event_handle_root(XEvent *e)
 497 {
 498     Atom msgtype;
 499
 500     switch(e->type) {
 501     case ClientMessage:
 502         if (e->xclient.format != 32) break;
 503
 504         msgtype = e->xclient.message_type;
 505         if (msgtype == prop_atoms.net_current_desktop) {
 506             unsigned int d = e->xclient.data.l[0];
 507             if (d < screen_num_desktops)
 508                 screen_set_desktop(d);
 509         } else if (msgtype == prop_atoms.net_number_of_desktops) {
 510             unsigned int d = e->xclient.data.l[0];
 511             if (d > 0)
 512                 screen_set_num_desktops(d);
 513         } else if (msgtype == prop_atoms.net_showing_desktop) {
 514             screen_show_desktop(e->xclient.data.l[0] != 0);
 515         }
 516         break;
 517     case PropertyNotify:
 518         if (e->xproperty.atom == prop_atoms.net_desktop_names)
 519             screen_update_desktop_names();
 520         else if (e->xproperty.atom == prop_atoms.net_desktop_layout)
 521             screen_update_layout();
 522         break;
 523     case ConfigureNotify:
 524 #ifdef XRANDR
 525         XRRUpdateConfiguration(e);
 526 #endif
 527         if (e->xconfigure.width != screen_physical_size.width ||
 528             e->xconfigure.height != screen_physical_size.height)
 529             screen_resize(e->xconfigure.width, e->xconfigure.height);
 530         break;
 531     default:
 532         ;
 533 #ifdef VIDMODE
 534         if (extensions_vidmode && e->type == extensions_vidmode_event_basep) {
 535             g_message("VIDMODE EVENT");
 536         }
 537 #endif
 538     }
 539 }
 540
 541 static void event_handle_client(Client *client, XEvent *e)
 542 {
 543     XEvent ce;
 544     Atom msgtype;
 545     int i=0;
 546
 547     switch (e->type) {
 548     case ButtonPress:
 549     case ButtonRelease:
 550         /* Wheel buttons don't draw because they are an instant click, so it
 551            is a waste of resources to go drawing it. */
 552         if (!(e->xbutton.button == 4 || e->xbutton.button == 5)) {
 553             switch (frame_context(client, e->xbutton.window)) {
 554             case Context_Maximize:
 555                 client->frame->max_press = (e->type == ButtonPress);
 556                 framerender_frame(client->frame);
 557                 break;
 558             case Context_Close:
 559                 client->frame->close_press = (e->type == ButtonPress);
 560                 framerender_frame(client->frame);
 561                 break;
 562             case Context_Iconify:
 563                 client->frame->iconify_press = (e->type == ButtonPress);
 564                 framerender_frame(client->frame);
 565                 break;
 566             case Context_AllDesktops:
 567                 client->frame->desk_press = (e->type == ButtonPress);
 568                 framerender_frame(client->frame);
 569                 break;
 570             case Context_Shade:
 571                 client->frame->shade_press = (e->type == ButtonPress);
 572                 framerender_frame(client->frame);
 573                 break;
 574             default:
 575                 /* nothing changes with clicks for any other contexts */
 576                 break;
 577             }
 578         }
 579         break;
 580     case FocusIn:
 581 #ifdef DEBUG_FOCUS
 582         g_message("FocusIn on client for %lx", client->window);
 583 #endif
 584         if (client != focus_client) {
 585             focus_set_client(client);
 586             frame_adjust_focus(client->frame, TRUE);
 587         }
 588         break;
 589     case FocusOut:
 590 #ifdef DEBUG_FOCUS
 591         g_message("FocusOut on client for %lx", client->window);
 592 #endif
 593         /* are we a fullscreen window or a transient of one? (checks layer)
 594            if we are then we need to be iconified since we are losing focus
 595          */
 596         if (client->layer == Layer_Fullscreen && !client->iconic &&
 597             !client_search_focus_tree_full(client))
 598             /* iconify fullscreen windows when they and their transients
 599                aren't focused */
 600             client_iconify(client, TRUE, TRUE);
 601         frame_adjust_focus(client->frame, FALSE);
 602         break;
 603     case EnterNotify:
 604         if (client_normal(client)) {
 605             if (ob_state == State_Starting) {
 606                 /* move it to the top of the focus order */
 607                 guint desktop = client->desktop;
 608                 if (desktop == DESKTOP_ALL) desktop = screen_desktop;
 609                 focus_order[desktop] = g_list_remove(focus_order[desktop],
 610                                                      client);
 611                 focus_order[desktop] = g_list_prepend(focus_order[desktop],
 612                                                       client);
 613             } else if (config_focus_follow) {
 614 #ifdef DEBUG_FOCUS
 615                 g_message("EnterNotify on %lx, focusing window",
 616                           client->window);
 617 #endif
 618                 client_focus(client);
 619             }
 620         }
 621         break;
 622     case ConfigureRequest:
 623         /* compress these */
 624         while (XCheckTypedWindowEvent(ob_display, client->window,
 625                                       ConfigureRequest, &ce)) {
 626             ++i;
 627             /* XXX if this causes bad things.. we can compress config req's
 628                with the same mask. */
 629             e->xconfigurerequest.value_mask |=
 630                 ce.xconfigurerequest.value_mask;
 631             if (ce.xconfigurerequest.value_mask & CWX)
 632                 e->xconfigurerequest.x = ce.xconfigurerequest.x;
 633             if (ce.xconfigurerequest.value_mask & CWY)
 634                 e->xconfigurerequest.y = ce.xconfigurerequest.y;
 635             if (ce.xconfigurerequest.value_mask & CWWidth)
 636                 e->xconfigurerequest.width = ce.xconfigurerequest.width;
 637             if (ce.xconfigurerequest.value_mask & CWHeight)
 638                 e->xconfigurerequest.height = ce.xconfigurerequest.height;
 639             if (ce.xconfigurerequest.value_mask & CWBorderWidth)
 640                 e->xconfigurerequest.border_width =
 641                     ce.xconfigurerequest.border_width;
 642             if (ce.xconfigurerequest.value_mask & CWStackMode)
 643                 e->xconfigurerequest.detail = ce.xconfigurerequest.detail;
 644         }
 645
 646         /* if we are iconic (or shaded (fvwm does this)) ignore the event */
 647         if (client->iconic || client->shaded) return;
 648
 649         if (e->xconfigurerequest.value_mask & CWBorderWidth)
 650             client->border_width = e->xconfigurerequest.border_width;
 651
 652         /* resize, then move, as specified in the EWMH section 7.7 */
 653         if (e->xconfigurerequest.value_mask & (CWWidth | CWHeight |
 654                                                CWX | CWY)) {
 655             int x, y, w, h;
 656             Corner corner;
 657
 658             x = (e->xconfigurerequest.value_mask & CWX) ?
 659                 e->xconfigurerequest.x : client->area.x;
 660             y = (e->xconfigurerequest.value_mask & CWY) ?
 661                 e->xconfigurerequest.y : client->area.y;
 662             w = (e->xconfigurerequest.value_mask & CWWidth) ?
 663                 e->xconfigurerequest.width : client->area.width;
 664             h = (e->xconfigurerequest.value_mask & CWHeight) ?
 665                 e->xconfigurerequest.height : client->area.height;
 666
 667             switch (client->gravity) {
 668             case NorthEastGravity:
 669             case EastGravity:
 670                 corner = Corner_TopRight;
 671                 break;
 672             case SouthWestGravity:
 673             case SouthGravity:
 674                 corner = Corner_BottomLeft;
 675                 break;
 676             case SouthEastGravity:
 677                 corner = Corner_BottomRight;
 678                 break;
 679             default:     /* NorthWest, Static, etc */
 680                 corner = Corner_TopLeft;
 681             }
 682
 683             client_configure(client, corner, x, y, w, h, FALSE, FALSE);
 684         }
 685
 686         if (e->xconfigurerequest.value_mask & CWStackMode) {
 687             switch (e->xconfigurerequest.detail) {
 688             case Below:
 689             case BottomIf:
 690                 stacking_lower(CLIENT_AS_WINDOW(client));
 691                 break;
 692
 693             case Above:
 694             case TopIf:
 695             default:
 696                 stacking_raise(CLIENT_AS_WINDOW(client));
 697                 break;
 698             }
 699         }
 700         break;
 701     case UnmapNotify:
 702         if (client->ignore_unmaps) {
 703             client->ignore_unmaps--;
 704             break;
 705         }
 706         client_unmanage(client);
 707         break;
 708     case DestroyNotify:
 709         client_unmanage(client);
 710         break;
 711     case ReparentNotify:
 712         /* this is when the client is first taken captive in the frame */
 713         if (e->xreparent.parent == client->frame->plate) break;
 714
 715         /*
 716           This event is quite rare and is usually handled in unmapHandler.
 717           However, if the window is unmapped when the reparent event occurs,
 718           the window manager never sees it because an unmap event is not sent
 719           to an already unmapped window.
 720         */
 721
 722         /* we don't want the reparent event, put it back on the stack for the
 723            X server to deal with after we unmanage the window */
 724         XPutBackEvent(ob_display, e);
 725
 726         client_unmanage(client);
 727         break;
 728     case MapRequest:
 729         g_message("MapRequest for 0x%lx", client->window);
 730         if (!client->iconic) break; /* this normally doesn't happen, but if it
 731                                        does, we don't want it! */
 732         if (screen_showing_desktop)
 733             screen_show_desktop(FALSE);
 734         client_iconify(client, FALSE, TRUE);
 735         if (!client->frame->visible)
 736             /* if its not visible still, then don't mess with it */
 737             break;
 738         if (client->shaded)
 739             client_shade(client, FALSE);
 740         client_focus(client);
 741         stacking_raise(CLIENT_AS_WINDOW(client));
 742         break;
 743     case ClientMessage:
 744         /* validate cuz we query stuff off the client here */
 745         if (!client_validate(client)) break;
 746
 747         if (e->xclient.format != 32) return;
 748
 749         msgtype = e->xclient.message_type;
 750         if (msgtype == prop_atoms.wm_change_state) {
 751             /* compress changes into a single change */
 752             while (XCheckTypedWindowEvent(ob_display, e->type,
 753                                           client->window, &ce)) {
 754                 /* XXX: it would be nice to compress ALL messages of a
 755                    type, not just messages in a row without other
 756                    message types between. */
 757                 if (ce.xclient.message_type != msgtype) {
 758                     XPutBackEvent(ob_display, &ce);
 759                     break;
 760                 }
 761                 e->xclient = ce.xclient;
 762             }
 763             client_set_wm_state(client, e->xclient.data.l[0]);
 764         } else if (msgtype == prop_atoms.net_wm_desktop) {
 765             /* compress changes into a single change */
 766             while (XCheckTypedWindowEvent(ob_display, e->type,
 767                                           client->window, &ce)) {
 768                 /* XXX: it would be nice to compress ALL messages of a
 769                    type, not just messages in a row without other
 770                    message types between. */
 771                 if (ce.xclient.message_type != msgtype) {
 772                     XPutBackEvent(ob_display, &ce);
 773                     break;
 774                 }
 775                 e->xclient = ce.xclient;
 776             }
 777             if ((unsigned)e->xclient.data.l[0] < screen_num_desktops ||
 778                 (unsigned)e->xclient.data.l[0] == DESKTOP_ALL)
 779                 client_set_desktop(client, (unsigned)e->xclient.data.l[0],
 780                                    FALSE);
 781         } else if (msgtype == prop_atoms.net_wm_state) {
 782             /* can't compress these */
 783             g_message("net_wm_state %s %ld %ld for 0x%lx",
 784                       (e->xclient.data.l[0] == 0 ? "Remove" :
 785                        e->xclient.data.l[0] == 1 ? "Add" :
 786                        e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
 787                       e->xclient.data.l[1], e->xclient.data.l[2],
 788                       client->window);
 789             client_set_state(client, e->xclient.data.l[0],
 790                              e->xclient.data.l[1], e->xclient.data.l[2]);
 791         } else if (msgtype == prop_atoms.net_close_window) {
 792             g_message("net_close_window for 0x%lx", client->window);
 793             client_close(client);
 794         } else if (msgtype == prop_atoms.net_active_window) {
 795             g_message("net_active_window for 0x%lx", client->window);
 796             client_activate(client);
 797         } else if (msgtype == prop_atoms.net_wm_moveresize) {
 798             g_message("net_wm_moveresize for 0x%lx", client->window);
 799             if ((Atom)e->xclient.data.l[2] ==
 800                 prop_atoms.net_wm_moveresize_size_topleft ||
 801                 (Atom)e->xclient.data.l[2] ==
 802                 prop_atoms.net_wm_moveresize_size_top ||
 803                 (Atom)e->xclient.data.l[2] ==
 804                 prop_atoms.net_wm_moveresize_size_topright ||
 805                 (Atom)e->xclient.data.l[2] ==
 806                 prop_atoms.net_wm_moveresize_size_right ||
 807                 (Atom)e->xclient.data.l[2] ==
 808                 prop_atoms.net_wm_moveresize_size_right ||
 809                 (Atom)e->xclient.data.l[2] ==
 810                 prop_atoms.net_wm_moveresize_size_bottomright ||
 811                 (Atom)e->xclient.data.l[2] ==
 812                 prop_atoms.net_wm_moveresize_size_bottom ||
 813                 (Atom)e->xclient.data.l[2] ==
 814                 prop_atoms.net_wm_moveresize_size_bottomleft ||
 815                 (Atom)e->xclient.data.l[2] ==
 816                 prop_atoms.net_wm_moveresize_size_left ||
 817                 (Atom)e->xclient.data.l[2] ==
 818                 prop_atoms.net_wm_moveresize_move ||
 819                 (Atom)e->xclient.data.l[2] ==
 820                 prop_atoms.net_wm_moveresize_size_keyboard ||
 821                 (Atom)e->xclient.data.l[2] ==
 822                 prop_atoms.net_wm_moveresize_move_keyboard) {
 823
 824                 moveresize_start(client, e->xclient.data.l[0],
 825                                  e->xclient.data.l[1], e->xclient.data.l[3],
 826                                  e->xclient.data.l[2]);
 827             }
 828         } else if (msgtype == prop_atoms.net_moveresize_window) {
 829             int oldg = client->gravity;
 830             int tmpg, x, y, w, h;
 831
 832             if (e->xclient.data.l[0] & 0xff)
 833                 tmpg = e->xclient.data.l[0] & 0xff;
 834             else
 835                 tmpg = oldg;
 836
 837             if (e->xclient.data.l[0] & 1 << 8)
 838                 x = e->xclient.data.l[1];
 839             else
 840                 x = client->area.x;
 841             if (e->xclient.data.l[0] & 1 << 9)
 842                 y = e->xclient.data.l[2];
 843             else
 844                 y = client->area.y;
 845             if (e->xclient.data.l[0] & 1 << 10)
 846                 w = e->xclient.data.l[3];
 847             else
 848                 w = client->area.y;
 849             if (e->xclient.data.l[0] & 1 << 11)
 850                 h = e->xclient.data.l[4];
 851             else
 852                 h = client->area.y;
 853             client->gravity = tmpg;
 854             client_configure(client, Corner_TopLeft, x, y, w, h, TRUE, TRUE);
 855             client->gravity = oldg;
 856         }
 857         break;
 858     case PropertyNotify:
 859         /* validate cuz we query stuff off the client here */
 860         if (!client_validate(client)) break;
 861
 862         /* compress changes to a single property into a single change */
 863         while (XCheckTypedWindowEvent(ob_display, e->type,
 864                                       client->window, &ce)) {
 865             /* XXX: it would be nice to compress ALL changes to a property,
 866                not just changes in a row without other props between. */
 867             if (ce.xproperty.atom != e->xproperty.atom) {
 868                 XPutBackEvent(ob_display, &ce);
 869                 break;
 870             }
 871         }
 872
 873         msgtype = e->xproperty.atom;
 874         if (msgtype == XA_WM_NORMAL_HINTS) {
 875             client_update_normal_hints(client);
 876             /* normal hints can make a window non-resizable */
 877             client_setup_decor_and_functions(client);
 878         }
 879         else if (msgtype == XA_WM_HINTS)
 880             client_update_wmhints(client);
 881         else if (msgtype == XA_WM_TRANSIENT_FOR) {
 882             client_update_transient_for(client);
 883             client_get_type(client);
 884             /* type may have changed, so update the layer */
 885             client_calc_layer(client);
 886             client_setup_decor_and_functions(client);
 887         }
 888         else if (msgtype == prop_atoms.net_wm_name ||
 889                  msgtype == prop_atoms.wm_name ||
 890                  msgtype == prop_atoms.net_wm_icon_name ||
 891                  msgtype == prop_atoms.wm_icon_name)
 892             client_update_title(client);
 893         else if (msgtype == prop_atoms.wm_class)
 894             client_update_class(client);
 895         else if (msgtype == prop_atoms.wm_protocols) {
 896             client_update_protocols(client);
 897             client_setup_decor_and_functions(client);
 898         }
 899         else if (msgtype == prop_atoms.net_wm_strut)
 900             client_update_strut(client);
 901         else if (msgtype == prop_atoms.net_wm_icon ||
 902                  msgtype == prop_atoms.kwm_win_icon)
 903             client_update_icons(client);
 904     default:
 905         ;
 906 #ifdef SHAPE
 907         if (extensions_shape && e->type == extensions_shape_event_basep) {
 908             client->shaped = ((XShapeEvent*)e)->shaped;
 909             frame_adjust_shape(client->frame);
 910         }
 911 #endif
 912     }
 913 }
 914
 915 static void event_handle_menu(Menu *menu, Client *client, XEvent *e)
 916 {
 917     MenuEntry *entry;
 918
 919     g_message("EVENT %d", e->type);
 920     switch (e->type) {
 921     case ButtonPress:
 922         g_message("BUTTON PRESS");
 923         if (e->xbutton.button == 3)
 924             menu_hide(menu);
 925         else if (e->xbutton.button == 1) {
 926             entry = menu_find_entry(menu, e->xbutton.window);
 927             if (!entry)
 928                 stacking_raise(MENU_AS_WINDOW(menu));
 929         }
 930         break;
 931     case ButtonRelease:
 932         g_message("BUTTON RELEASED");
 933         if (!menu->shown) break;
 934
 935 /*        grab_pointer_window(FALSE, None, menu->frame);*/
 936
 937         if (e->xbutton.button == 1) {
 938             entry = menu_find_entry(menu, e->xbutton.window);
 939             if (entry) {
 940                 int junk;
 941                 Window wjunk;
 942                 guint ujunk, b, w, h;
 943                 XGetGeometry(ob_display, e->xbutton.window,
 944                              &wjunk, &junk, &junk, &w, &h, &b, &ujunk);
 945                 if (e->xbutton.x >= (signed)-b &&
 946                     e->xbutton.y >= (signed)-b &&
 947                     e->xbutton.x < (signed)(w+b) &&
 948                     e->xbutton.y < (signed)(h+b)) {
 949                     menu_entry_fire(entry);
 950                 }
 951             }
 952         }
 953
 954         break;
 955     case EnterNotify:
 956     case LeaveNotify:
 957         g_message("enter/leave");
 958         entry = menu_find_entry(menu, e->xcrossing.window);
 959         if (entry) {
 960             if (menu->mouseover)
 961                 menu->mouseover(entry, e->type == EnterNotify);
 962             else
 963                 menu_control_mouseover(entry, e->type == EnterNotify);
 964
 965             menu_entry_render(entry);
 966         }
 967         break;
 968     }
 969 }
 970
 971 void event_add_fd_handler(event_fd_handler *h) {
 972   g_datalist_id_set_data(&fd_handler_list, h->fd, h);
 973   FD_SET(h->fd, &allset);
 974   max_fd = MAX(max_fd, h->fd);
 975 }
 976
 977 void find_max_fd_foreach(GQuark n, gpointer data, gpointer max)
 978 {
 979   *((unsigned int *)max) = MAX(*((unsigned int *)max), n);
 980 }
 981
 982 void event_remove_fd(int n)
 983 {
 984   int tmpmax = 0;
 985   FD_CLR(n, &allset);
 986   g_datalist_id_remove_data(&fd_handler_list, (GQuark)n);
 987   g_datalist_foreach(&fd_handler_list, find_max_fd_foreach, (gpointer)&tmpmax);
 988   max_fd = MAX(x_fd, tmpmax);
 989 }
 990
 991 void fd_event_handle_foreach(GQuark n, gpointer data, gpointer user_data)
 992 {
 993     if (FD_ISSET( (int)n, &selset)) {
 994         event_fd_handler *h = (event_fd_handler *)data;
 995         g_assert(h->fd == (int)n);
 996         h->handler(h->fd, h->data);
 997     }
 998 }
 999
1000 void fd_event_handle()
1001 {
1002     g_datalist_foreach(&fd_handler_list, fd_event_handle_foreach, NULL);
1003 }
1004
1005 static void event_handle_dock(Dock *s, XEvent *e)
1006 {
1007     switch (e->type) {
1008     case ButtonPress:
1009         stacking_raise(DOCK_AS_WINDOW(s));
1010         break;
1011     case EnterNotify:
1012         dock_hide(FALSE);
1013         break;
1014     case LeaveNotify:
1015         dock_hide(TRUE);
1016         break;
1017     }
1018 }
1019
1020 static void event_handle_dockapp(DockApp *app, XEvent *e)
1021 {
1022     switch (e->type) {
1023     case MotionNotify:
1024         dock_app_drag(app, &e->xmotion);
1025         break;
1026     case UnmapNotify:
1027         if (app->ignore_unmaps) {
1028             app->ignore_unmaps--;
1029             break;
1030         }
1031         dock_remove(app, TRUE);
1032         break;
1033     case DestroyNotify:
1034         dock_remove(app, FALSE);
1035         break;
1036     case ReparentNotify:
1037         dock_remove(app, FALSE);
1038         break;
1039     case ConfigureNotify:
1040         dock_app_configure(app, e->xconfigure.width, e->xconfigure.height);
1041         break;
1042     }
1043 }