openbox/event.c

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