Dogcows Code - chaz/openbox/blob - openbox/event.c

   1 #include "openbox.h"
   2 #include "client.h"
   3 #include "xerror.h"
   4 #include "prop.h"
   5 #include "config.h"
   6 #include "screen.h"
   7 #include "frame.h"
   8 #include "framerender.h"
   9 #include "focus.h"
  10 #include "stacking.h"
  11 #include "extensions.h"
  12 #include "timer.h"
  13 #include "dispatch.h"
  14
  15 #include <X11/Xlib.h>
  16 #include <X11/keysym.h>
  17 #include <X11/Xatom.h>
  18 #ifdef HAVE_SYS_SELECT_H
  19 #  include <sys/select.h>
  20 #endif
  21
  22 static void event_process(XEvent *e);
  23 static void event_handle_root(XEvent *e);
  24 static void event_handle_client(Client *c, XEvent *e);
  25
  26 Time event_lasttime = 0;
  27
  28 /*! The value of the mask for the NumLock modifier */
  29 unsigned int NumLockMask;
  30 /*! The value of the mask for the ScrollLock modifier */
  31 unsigned int ScrollLockMask;
  32 /*! The key codes for the modifier keys */
  33 static XModifierKeymap *modmap;
  34 /*! Table of the constant modifier masks */
  35 static const int mask_table[] = {
  36     ShiftMask, LockMask, ControlMask, Mod1Mask,
  37     Mod2Mask, Mod3Mask, Mod4Mask, Mod5Mask
  38 };
  39 static int mask_table_size;
  40
  41 void event_startup()
  42 {
  43     mask_table_size = sizeof(mask_table) / sizeof(mask_table[0]);
  44
  45     /* get lock masks that are defined by the display (not constant) */
  46     modmap = XGetModifierMapping(ob_display);
  47     g_assert(modmap);
  48     if (modmap && modmap->max_keypermod > 0) {
  49         size_t cnt;
  50         const size_t size = mask_table_size * modmap->max_keypermod;
  51         /* get the values of the keyboard lock modifiers
  52            Note: Caps lock is not retrieved the same way as Scroll and Num
  53            lock since it doesn't need to be. */
  54         const KeyCode num_lock = XKeysymToKeycode(ob_display, XK_Num_Lock);
  55         const KeyCode scroll_lock = XKeysymToKeycode(ob_display,
  56                                                      XK_Scroll_Lock);
  57
  58         for (cnt = 0; cnt < size; ++cnt) {
  59             if (! modmap->modifiermap[cnt]) continue;
  60
  61             if (num_lock == modmap->modifiermap[cnt])
  62                 NumLockMask = mask_table[cnt / modmap->max_keypermod];
  63             if (scroll_lock == modmap->modifiermap[cnt])
  64                 ScrollLockMask = mask_table[cnt / modmap->max_keypermod];
  65         }
  66     }
  67 }
  68
  69 void event_shutdown()
  70 {
  71     XFreeModifiermap(modmap);
  72 }
  73
  74 void event_loop()
  75 {
  76     fd_set selset;
  77     XEvent e;
  78     int x_fd;
  79     struct timeval *wait;
  80
  81     while (TRUE) {
  82         /*
  83           There are slightly different event retrieval semantics here for
  84           local (or high bandwidth) versus remote (or low bandwidth)
  85           connections to the display/Xserver.
  86         */
  87         if (ob_remote) {
  88             if (!XPending(ob_display))
  89                 break;
  90         } else {
  91             /*
  92               This XSync allows for far more compression of events, which
  93               makes things like Motion events perform far far better. Since
  94               it also means network traffic for every event instead of every
  95               X events (where X is the number retrieved at a time), it
  96               probably should not be used for setups where Openbox is
  97               running on a remote/low bandwidth display/Xserver.
  98             */
  99             XSync(ob_display, FALSE);
 100             if (!XEventsQueued(ob_display, QueuedAlready))
 101                 break;
 102         }
 103         XNextEvent(ob_display, &e);
 104
 105         event_process(&e);
 106     }
 107
 108     timer_dispatch((GTimeVal**)&wait);
 109     x_fd = ConnectionNumber(ob_display);
 110     FD_ZERO(&selset);
 111     FD_SET(x_fd, &selset);
 112     select(x_fd + 1, &selset, NULL, NULL, wait);
 113 }
 114
 115 static Window event_get_window(XEvent *e)
 116 {
 117     Window window;
 118
 119     /* pick a window */
 120     switch (e->type) {
 121     case MapRequest:
 122         window = e->xmap.window;
 123         break;
 124     case UnmapNotify:
 125         window = e->xunmap.window;
 126         break;
 127     case DestroyNotify:
 128         window = e->xdestroywindow.window;
 129         break;
 130     case ConfigureRequest:
 131         window = e->xconfigurerequest.window;
 132         break;
 133     default:
 134 #ifdef XKB
 135         if (extensions_xkb && e->type == extensions_xkb_event_basep) {
 136             switch (((XkbAnyEvent*)&e)->xkb_type) {
 137             case XkbBellNotify:
 138                 window = ((XkbBellNotifyEvent*)&e)->window;
 139             default:
 140                 window = None;
 141             }
 142         } else
 143 #endif
 144             window = e->xany.window;
 145     }
 146     return window;
 147 }
 148
 149 static void event_set_lasttime(XEvent *e)
 150 {
 151     /* grab the lasttime and hack up the state */
 152     switch (e->type) {
 153     case ButtonPress:
 154     case ButtonRelease:
 155         event_lasttime = e->xbutton.time;
 156         break;
 157     case KeyPress:
 158         event_lasttime = e->xkey.time;
 159         break;
 160     case KeyRelease:
 161         event_lasttime = e->xkey.time;
 162         break;
 163     case MotionNotify:
 164         event_lasttime = e->xmotion.time;
 165         break;
 166     case PropertyNotify:
 167         event_lasttime = e->xproperty.time;
 168         break;
 169     case EnterNotify:
 170     case LeaveNotify:
 171         event_lasttime = e->xcrossing.time;
 172         break;
 173     default:
 174         event_lasttime = CurrentTime;
 175         break;
 176     }
 177 }
 178
 179 #define STRIP_MODS(s) \
 180         s &= ~(LockMask | NumLockMask | ScrollLockMask), \
 181         /* kill off the Button1Mask etc, only want the modifiers */ \
 182         s &= (ControlMask | ShiftMask | Mod1Mask | \
 183               Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask) \
 184
 185 static void event_hack_mods(XEvent *e)
 186 {
 187     KeyCode *kp;
 188     int i, k;
 189
 190     switch (e->type) {
 191     case ButtonPress:
 192     case ButtonRelease:
 193         STRIP_MODS(e->xbutton.state);
 194         break;
 195     case KeyPress:
 196         STRIP_MODS(e->xkey.state);
 197         break;
 198     case KeyRelease:
 199         STRIP_MODS(e->xkey.state);
 200         /* remove from the state the mask of the modifier being released, if
 201            it is a modifier key being released (this is a little ugly..) */
 202         kp = modmap->modifiermap;
 203         for (i = 0; i < mask_table_size; ++i) {
 204             for (k = 0; k < modmap->max_keypermod; ++k) {
 205                 if (*kp == e->xkey.keycode) { /* found the keycode */
 206                     /* remove the mask for it */
 207                     e->xkey.state &= ~mask_table[i];
 208                     /* cause the first loop to break; */
 209                     i = mask_table_size;
 210                     break; /* get outta here! */
 211                 }
 212                 ++kp;
 213             }
 214         }
 215         break;
 216     case MotionNotify:
 217         STRIP_MODS(e->xmotion.state);
 218         /* compress events */
 219         {
 220             XEvent ce;
 221             while (XCheckTypedWindowEvent(ob_display, e->xmotion.window,
 222                                           e->type, &ce)) {
 223                 e->xmotion.x_root = ce.xmotion.x_root;
 224                 e->xmotion.y_root = ce.xmotion.y_root;
 225             }
 226         }
 227         break;
 228     }
 229 }
 230
 231 static gboolean event_ignore(XEvent *e, Client *client)
 232 {
 233     switch(e->type) {
 234     case FocusIn:
 235 #ifdef DEBUG_FOCUS
 236         g_message("FocusIn on %lx mode %d detail %d", window,
 237                   e->xfocus.mode, e->xfocus.detail);
 238 #endif
 239         /* NotifyAncestor is not ignored in FocusIn like it is in FocusOut
 240            because of RevertToPointerRoot. If the focus ends up reverting to
 241            pointer root on a workspace change, then the FocusIn event that we
 242            want will be of type NotifyAncestor. This situation does not occur
 243            for FocusOut, so it is safely ignored there.
 244         */
 245         if (e->xfocus.detail == NotifyInferior ||
 246             e->xfocus.detail > NotifyNonlinearVirtual ||
 247             client == NULL) {
 248             /* says a client was not found for the event (or a valid FocusIn
 249                event was not found.
 250             */
 251             e->xfocus.window = None;
 252             return TRUE;
 253         }
 254
 255 #ifdef DEBUG_FOCUS
 256         g_message("FocusIn on %lx", window);
 257 #endif
 258         break;
 259     case FocusOut:
 260 #ifdef DEBUG_FOCUS
 261         g_message("FocusOut on %lx mode %d detail %d", window,
 262                   e->xfocus.mode, e->xfocus.detail);
 263 #endif
 264         if (e->xfocus.mode == NotifyGrab ||
 265             e->xfocus.detail == NotifyInferior ||
 266             e->xfocus.detail == NotifyAncestor ||
 267             e->xfocus.detail > NotifyNonlinearVirtual) return TRUE;
 268
 269 #ifdef DEBUG_FOCUS
 270        g_message("FocusOut on %lx", window);
 271 #endif
 272         /* Try process a FocusIn first, and if a legit one isn't found, then
 273            do the fallback shiznit. */
 274         {
 275             XEvent fi, fo;
 276             gboolean isfo = FALSE;
 277
 278             if (XCheckTypedEvent(ob_display, FocusIn, &fi)) {
 279                 event_process(&fi);
 280
 281                 /* when we have gotten a fi/fo pair, then see if there are any
 282                    more fo's coming. if there are, then don't fallback just yet
 283                 */
 284                 if ((isfo = XCheckTypedEvent(ob_display, FocusOut, &fo)))
 285                     XPutBackEvent(ob_display, &fo);
 286
 287                 /* secret magic way of event_process telling us that no client
 288                    was found for the FocusIn event. ^_^ */
 289                 if (!isfo && fi.xfocus.window == None)
 290                     focus_fallback(Fallback_NoFocus);
 291                 if (fi.xfocus.window == e->xfocus.window)
 292                     return TRUE;
 293             } else
 294                 focus_fallback(Fallback_NoFocus);
 295         }
 296         break;
 297     case EnterNotify:
 298     case LeaveNotify:
 299         /* NotifyUngrab occurs when a mouse button is released and the event is
 300            caused, like when lowering a window */
 301         if (e->xcrossing.mode == NotifyGrab ||
 302             e->xcrossing.detail == NotifyInferior)
 303             return TRUE;
 304         break;
 305     }
 306     return FALSE;
 307 }
 308
 309 static void event_process(XEvent *e)
 310 {
 311     Window window;
 312     Client *client;
 313
 314     window = event_get_window(e);
 315     client = g_hash_table_lookup(client_map, &window);
 316     event_set_lasttime(e);
 317     event_hack_mods(e);
 318     if (event_ignore(e, client))
 319         return;
 320
 321     /* deal with it in the kernel */
 322     if (client)
 323         event_handle_client(client, e);
 324     else if (window == ob_root)
 325         event_handle_root(e);
 326     else if (e->type == MapRequest)
 327         client_manage(window);
 328     else if (e->type == ConfigureRequest) {
 329         /* unhandled configure requests must be used to configure the
 330            window directly */
 331         XWindowChanges xwc;
 332
 333         xwc.x = e->xconfigurerequest.x;
 334         xwc.y = e->xconfigurerequest.y;
 335         xwc.width = e->xconfigurerequest.width;
 336         xwc.height = e->xconfigurerequest.height;
 337         xwc.border_width = e->xconfigurerequest.border_width;
 338         xwc.sibling = e->xconfigurerequest.above;
 339         xwc.stack_mode = e->xconfigurerequest.detail;
 340
 341         /* we are not to be held responsible if someone sends us an
 342            invalid request! */
 343         xerror_set_ignore(TRUE);
 344         XConfigureWindow(ob_display, window,
 345                          e->xconfigurerequest.value_mask, &xwc);
 346         xerror_set_ignore(FALSE);
 347     }
 348
 349     /* user input (action-bound) events */
 350     /*
 351     if (e->type == ButtonPress || e->type == ButtonRelease ||
 352         e->type == MotionNotify)
 353         mouse_event(e, client);
 354     else if (e->type == KeyPress || e->type == KeyRelease)
 355         ;
 356     */
 357
 358     /* dispatch the event to registered handlers */
 359     dispatch_x(e, client);
 360 }
 361
 362 static void event_handle_root(XEvent *e)
 363 {
 364     Atom msgtype;
 365
 366     switch(e->type) {
 367     case ClientMessage:
 368         if (e->xclient.format != 32) break;
 369
 370         msgtype = e->xclient.message_type;
 371         if (msgtype == prop_atoms.net_current_desktop) {
 372             unsigned int d = e->xclient.data.l[0];
 373             if (d < screen_num_desktops)
 374                 screen_set_desktop(d);
 375         } else if (msgtype == prop_atoms.net_number_of_desktops) {
 376             unsigned int d = e->xclient.data.l[0];
 377             if (d > 0)
 378                 screen_set_num_desktops(d);
 379         } else if (msgtype == prop_atoms.net_showing_desktop) {
 380             screen_show_desktop(e->xclient.data.l[0] != 0);
 381         }
 382         break;
 383     case PropertyNotify:
 384         if (e->xproperty.atom == prop_atoms.net_desktop_names)
 385             screen_update_desktop_names();
 386         else if (e->xproperty.atom == prop_atoms.net_desktop_layout)
 387             screen_update_layout();
 388         break;
 389     }
 390 }
 391
 392 static void event_handle_client(Client *client, XEvent *e)
 393 {
 394     XEvent ce;
 395     Atom msgtype;
 396     int i=0;
 397
 398     switch (e->type) {
 399     case ButtonPress:
 400     case ButtonRelease:
 401         switch (frame_context(client, e->xbutton.window)) {
 402         case Context_Maximize:
 403             client->frame->max_press = (e->type == ButtonPress);
 404             framerender_frame(client->frame);
 405             break;
 406         case Context_Close:
 407             client->frame->close_press = (e->type == ButtonPress);
 408             framerender_frame(client->frame);
 409             break;
 410         case Context_Iconify:
 411             client->frame->iconify_press = (e->type == ButtonPress);
 412             framerender_frame(client->frame);
 413             break;
 414         case Context_AllDesktops:
 415             client->frame->desk_press = (e->type == ButtonPress);
 416             framerender_frame(client->frame);
 417             break;
 418         case Context_Shade:
 419             client->frame->shade_press = (e->type == ButtonPress);
 420             framerender_frame(client->frame);
 421             break;
 422         default:
 423             /* nothing changes with clicks for any other contexts */
 424             break;
 425         }
 426         break;
 427     case FocusIn:
 428         focus_set_client(client);
 429     case FocusOut:
 430 #ifdef DEBUG_FOCUS
 431         g_message("Focus%s on client for %lx", (e->type==FocusIn?"In":"Out"),
 432                   client->window);
 433 #endif
 434         /* focus state can affect the stacking layer */
 435         client_calc_layer(client);
 436         frame_adjust_focus(client->frame);
 437         break;
 438     case EnterNotify:
 439         if (client_normal(client)) {
 440             if (ob_state == State_Starting) {
 441                 /* move it to the top of the focus order */
 442                 guint desktop = client->desktop;
 443                 if (desktop == DESKTOP_ALL) desktop = screen_desktop;
 444                 focus_order[desktop] = g_list_remove(focus_order[desktop],
 445                                                      client);
 446                 focus_order[desktop] = g_list_prepend(focus_order[desktop],
 447                                                       client);
 448             } else if (config_focus_follow) {
 449 #ifdef DEBUG_FOCUS
 450                 g_message("EnterNotify on %lx, focusing window",
 451                           client->window);
 452 #endif
 453                 client_focus(client);
 454             }
 455         }
 456         break;
 457     case ConfigureRequest:
 458         /* compress these */
 459         while (XCheckTypedWindowEvent(ob_display, client->window,
 460                                       ConfigureRequest, &ce)) {
 461             ++i;
 462             /* XXX if this causes bad things.. we can compress config req's
 463                with the same mask. */
 464             e->xconfigurerequest.value_mask |=
 465                 ce.xconfigurerequest.value_mask;
 466             if (ce.xconfigurerequest.value_mask & CWX)
 467                 e->xconfigurerequest.x = ce.xconfigurerequest.x;
 468             if (ce.xconfigurerequest.value_mask & CWY)
 469                 e->xconfigurerequest.y = ce.xconfigurerequest.y;
 470             if (ce.xconfigurerequest.value_mask & CWWidth)
 471                 e->xconfigurerequest.width = ce.xconfigurerequest.width;
 472             if (ce.xconfigurerequest.value_mask & CWHeight)
 473                 e->xconfigurerequest.height = ce.xconfigurerequest.height;
 474             if (ce.xconfigurerequest.value_mask & CWBorderWidth)
 475                 e->xconfigurerequest.border_width =
 476                     ce.xconfigurerequest.border_width;
 477             if (ce.xconfigurerequest.value_mask & CWStackMode)
 478                 e->xconfigurerequest.detail = ce.xconfigurerequest.detail;
 479         }
 480
 481         /* if we are iconic (or shaded (fvwm does this)) ignore the event */
 482         if (client->iconic || client->shaded) return;
 483
 484         if (e->xconfigurerequest.value_mask & CWBorderWidth)
 485             client->border_width = e->xconfigurerequest.border_width;
 486
 487         /* resize, then move, as specified in the EWMH section 7.7 */
 488         if (e->xconfigurerequest.value_mask & (CWWidth | CWHeight |
 489                                                CWX | CWY)) {
 490             int x, y, w, h;
 491             Corner corner;
 492
 493             x = (e->xconfigurerequest.value_mask & CWX) ?
 494                 e->xconfigurerequest.x : client->area.x;
 495             y = (e->xconfigurerequest.value_mask & CWY) ?
 496                 e->xconfigurerequest.y : client->area.y;
 497             w = (e->xconfigurerequest.value_mask & CWWidth) ?
 498                 e->xconfigurerequest.width : client->area.width;
 499             h = (e->xconfigurerequest.value_mask & CWHeight) ?
 500                 e->xconfigurerequest.height : client->area.height;
 501
 502             switch (client->gravity) {
 503             case NorthEastGravity:
 504             case EastGravity:
 505                 corner = Corner_TopRight;
 506                 break;
 507             case SouthWestGravity:
 508             case SouthGravity:
 509                 corner = Corner_BottomLeft;
 510                 break;
 511             case SouthEastGravity:
 512                 corner = Corner_BottomRight;
 513                 break;
 514             default:     /* NorthWest, Static, etc */
 515                 corner = Corner_TopLeft;
 516             }
 517
 518             client_configure(client, corner, x, y, w, h, FALSE, FALSE);
 519         }
 520
 521         if (e->xconfigurerequest.value_mask & CWStackMode) {
 522             switch (e->xconfigurerequest.detail) {
 523             case Below:
 524             case BottomIf:
 525                 stacking_lower(client);
 526                 break;
 527
 528             case Above:
 529             case TopIf:
 530             default:
 531                 stacking_raise(client);
 532                 break;
 533             }
 534         }
 535         break;
 536     case UnmapNotify:
 537         if (client->ignore_unmaps) {
 538             client->ignore_unmaps--;
 539             break;
 540         }
 541         client_unmanage(client);
 542         break;
 543     case DestroyNotify:
 544         client_unmanage(client);
 545         break;
 546     case ReparentNotify:
 547         /* this is when the client is first taken captive in the frame */
 548         if (e->xreparent.parent == client->frame->plate) break;
 549
 550         /*
 551           This event is quite rare and is usually handled in unmapHandler.
 552           However, if the window is unmapped when the reparent event occurs,
 553           the window manager never sees it because an unmap event is not sent
 554           to an already unmapped window.
 555         */
 556
 557         /* we don't want the reparent event, put it back on the stack for the
 558            X server to deal with after we unmanage the window */
 559         XPutBackEvent(ob_display, e);
 560
 561         client_unmanage(client);
 562         break;
 563     case MapRequest:
 564         g_message("MapRequest for 0x%lx", client->window);
 565         if (!client->iconic) break; /* this normally doesn't happen, but if it
 566                                        does, we don't want it! */
 567         if (screen_showing_desktop)
 568             screen_show_desktop(FALSE);
 569         client_iconify(client, FALSE, TRUE);
 570         if (!client->frame->visible)
 571             /* if its not visible still, then don't mess with it */
 572             break;
 573         if (client->shaded)
 574             client_shade(client, FALSE);
 575         client_focus(client);
 576         stacking_raise(client);
 577         break;
 578     case ClientMessage:
 579         /* validate cuz we query stuff off the client here */
 580         if (!client_validate(client)) break;
 581
 582         if (e->xclient.format != 32) return;
 583
 584         msgtype = e->xclient.message_type;
 585         if (msgtype == prop_atoms.wm_change_state) {
 586             /* compress changes into a single change */
 587             while (XCheckTypedWindowEvent(ob_display, e->type,
 588                                           client->window, &ce)) {
 589                 /* XXX: it would be nice to compress ALL messages of a
 590                    type, not just messages in a row without other
 591                    message types between. */
 592                 if (ce.xclient.message_type != msgtype) {
 593                     XPutBackEvent(ob_display, &ce);
 594                     break;
 595                 }
 596                 e->xclient = ce.xclient;
 597             }
 598             client_set_wm_state(client, e->xclient.data.l[0]);
 599         } else if (msgtype == prop_atoms.net_wm_desktop) {
 600             /* compress changes into a single change */
 601             while (XCheckTypedWindowEvent(ob_display, e->type,
 602                                           client->window, &ce)) {
 603                 /* XXX: it would be nice to compress ALL messages of a
 604                    type, not just messages in a row without other
 605                    message types between. */
 606                 if (ce.xclient.message_type != msgtype) {
 607                     XPutBackEvent(ob_display, &ce);
 608                     break;
 609                 }
 610                 e->xclient = ce.xclient;
 611             }
 612             if ((unsigned)e->xclient.data.l[0] < screen_num_desktops ||
 613                 (unsigned)e->xclient.data.l[0] == DESKTOP_ALL)
 614                 client_set_desktop(client, (unsigned)e->xclient.data.l[0],
 615                                    FALSE);
 616         } else if (msgtype == prop_atoms.net_wm_state) {
 617             /* can't compress these */
 618             g_message("net_wm_state %s %ld %ld for 0x%lx",
 619                       (e->xclient.data.l[0] == 0 ? "Remove" :
 620                        e->xclient.data.l[0] == 1 ? "Add" :
 621                        e->xclient.data.l[0] == 2 ? "Toggle" : "INVALID"),
 622                       e->xclient.data.l[1], e->xclient.data.l[2],
 623                       client->window);
 624             client_set_state(client, e->xclient.data.l[0],
 625                              e->xclient.data.l[1], e->xclient.data.l[2]);
 626         } else if (msgtype == prop_atoms.net_close_window) {
 627             g_message("net_close_window for 0x%lx", client->window);
 628             client_close(client);
 629         } else if (msgtype == prop_atoms.net_active_window) {
 630             g_message("net_active_window for 0x%lx", client->window);
 631             if (screen_showing_desktop)
 632                 screen_show_desktop(FALSE);
 633             if (client->iconic)
 634                 client_iconify(client, FALSE, TRUE);
 635             else if (!client->frame->visible)
 636                 /* if its not visible for other reasons, then don't mess
 637                    with it */
 638                 break;
 639             if (client->shaded)
 640                 client_shade(client, FALSE);
 641             client_focus(client);
 642             stacking_raise(client);
 643         }
 644         break;
 645     case PropertyNotify:
 646         /* validate cuz we query stuff off the client here */
 647         if (!client_validate(client)) break;
 648
 649         /* compress changes to a single property into a single change */
 650         while (XCheckTypedWindowEvent(ob_display, e->type,
 651                                       client->window, &ce)) {
 652             /* XXX: it would be nice to compress ALL changes to a property,
 653                not just changes in a row without other props between. */
 654             if (ce.xproperty.atom != e->xproperty.atom) {
 655                 XPutBackEvent(ob_display, &ce);
 656                 break;
 657             }
 658         }
 659
 660         msgtype = e->xproperty.atom;
 661         if (msgtype == XA_WM_NORMAL_HINTS) {
 662             client_update_normal_hints(client);
 663             /* normal hints can make a window non-resizable */
 664             client_setup_decor_and_functions(client);
 665         }
 666         else if (msgtype == XA_WM_HINTS)
 667             client_update_wmhints(client);
 668         else if (msgtype == XA_WM_TRANSIENT_FOR) {
 669             client_update_transient_for(client);
 670             client_get_type(client);
 671             /* type may have changed, so update the layer */
 672             client_calc_layer(client);
 673             client_setup_decor_and_functions(client);
 674         }
 675         else if (msgtype == prop_atoms.net_wm_name ||
 676                  msgtype == prop_atoms.wm_name)
 677             client_update_title(client);
 678         else if (msgtype == prop_atoms.net_wm_icon_name ||
 679                  msgtype == prop_atoms.wm_icon_name)
 680             client_update_icon_title(client);
 681         else if (msgtype == prop_atoms.wm_class)
 682             client_update_class(client);
 683         else if (msgtype == prop_atoms.wm_protocols) {
 684             client_update_protocols(client);
 685             client_setup_decor_and_functions(client);
 686         }
 687         else if (msgtype == prop_atoms.net_wm_strut)
 688             client_update_strut(client);
 689         else if (msgtype == prop_atoms.net_wm_icon)
 690             client_update_icons(client);
 691         else if (msgtype == prop_atoms.kwm_win_icon)
 692             client_update_kwm_icon(client);
 693     default:
 694         ;
 695 #ifdef SHAPE
 696         if (extensions_shape && e->type == extensions_shape_event_basep) {
 697             client->shaped = ((XShapeEvent*)e)->shaped;
 698             frame_adjust_shape(client->frame);
 699         }
 700 #endif
 701     }
 702 }