src/client.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997-2003 Alfredo K. Kojima
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19  *  USA.
  20  */
  21 #include "wconfig.h"
  22
  23 #include <X11/Xlib.h>
  24 #include <X11/Xutil.h>
  25 #include <X11/Xatom.h>
  26 #ifdef SHAPE
  27 #include <X11/extensions/shape.h>
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33
  34 #include "WindowMaker.h"
  35 #include "wcore.h"
  36 #include "framewin.h"
  37 #include "window.h"
  38 #include "properties.h"
  39 #include "actions.h"
  40 #include "icon.h"
  41 #include "client.h"
  42 #include "funcs.h"
  43 #include "stacking.h"
  44 #include "appicon.h"
  45 #include "appmenu.h"
  46 #ifdef NETWM_HINTS
  47 # include "wmspec.h"
  48 #endif
  49
  50
  51 /****** Global Variables ******/
  52
  53 /* contexts */
  54 extern XContext wWinContext;
  55
  56 extern Atom _XA_WM_STATE;
  57 extern Atom _XA_WM_PROTOCOLS;
  58 extern Atom _XA_WM_COLORMAP_WINDOWS;
  59
  60 extern Atom _XA_WINDOWMAKER_MENU;
  61
  62 extern Atom _XA_GNUSTEP_WM_ATTR;
  63 extern Atom _XA_GNUSTEP_WM_RESIZEBAR;
  64
  65 #ifdef SHAPE
  66 extern Bool wShapeSupported;
  67 #endif
  68
  69
  70 /*
  71  *--------------------------------------------------------------------
  72  * wClientRestore--
  73  *      Reparent the window back to the root window.
  74  *
  75  *--------------------------------------------------------------------
  76  */
  77 void
  78 wClientRestore(WWindow *wwin)
  79 {
  80 #if 0
  81     int gx, gy;
  82
  83     wClientGetGravityOffsets(wwin, &gx, &gy);
  84     /* set the positio of the frame on screen */
  85     wwin->frame_x -= gx * FRAME_BORDER_WIDTH;
  86     wwin->frame_y -= gy * FRAME_BORDER_WIDTH;
  87     /* if gravity is to the south, account for the border sizes */
  88     if (gy > 0)
  89         wwin->frame_y += (wwin->frame->top_width + wwin->frame->bottom_width);
  90 #endif
  91     XSetWindowBorderWidth(dpy, wwin->client_win, wwin->old_border_width);
  92     XReparentWindow(dpy, wwin->client_win, wwin->screen_ptr->root_win,
  93                     wwin->frame_x, wwin->frame_y);
  94
  95     /* don't let the window get iconified after restart */
  96     /*
  97      if (wwin->flags.shaded)
  98      wClientSetState(wwin, NormalState, None);
  99      */
 100 }
 101
 102
 103 /*
 104  *----------------------------------------------------------------------
 105  * wClientSetState--
 106  *      Set the state of the client window to one of the window
 107  * states defined in ICCCM (Iconic, Withdrawn, Normal)
 108  *
 109  * Side effects:
 110  *      The WM_STATE property of the window is updated as well as the
 111  * WWindow.state variable.
 112  *----------------------------------------------------------------------
 113  */
 114 void
 115 wClientSetState(WWindow *wwin, int state, Window icon_win)
 116 {
 117     CARD32 data[2];
 118
 119     wwin->state = state;
 120
 121     data[0] = (unsigned long) state;
 122     data[1] = (unsigned long) icon_win;
 123
 124     XChangeProperty(dpy, wwin->client_win, _XA_WM_STATE, _XA_WM_STATE, 32,
 125                     PropModeReplace, (unsigned char *) data, 2);
 126 }
 127
 128
 129 void
 130 wClientGetGravityOffsets(WWindow *wwin, int *ofs_x, int *ofs_y)
 131 {
 132     switch (wwin->normal_hints->win_gravity) {
 133     case ForgetGravity:
 134     case CenterGravity:
 135     case StaticGravity:
 136         *ofs_x = 0;
 137         *ofs_y = 0;
 138         break;
 139     case NorthWestGravity:
 140         *ofs_x = -1;
 141         *ofs_y = -1;
 142         break;
 143     case NorthGravity:
 144         *ofs_x = 0;
 145         *ofs_y = -1;
 146         break;
 147     case NorthEastGravity:
 148         *ofs_x = 1;
 149         *ofs_y = -1;
 150         break;
 151     case WestGravity:
 152         *ofs_x = -1;
 153         *ofs_y = 0;
 154         break;
 155     case EastGravity:
 156         *ofs_x = 1;
 157         *ofs_y = 0;
 158         break;
 159     case SouthWestGravity:
 160         *ofs_x = -1;
 161         *ofs_y = 1;
 162         break;
 163     case SouthGravity:
 164         *ofs_x = 0;
 165         *ofs_y = 1;
 166         break;
 167     case SouthEastGravity:
 168         *ofs_x = 1;
 169         *ofs_y = 1;
 170         break;
 171     }
 172 }
 173
 174
 175
 176 void
 177 wClientConfigure(WWindow *wwin, XConfigureRequestEvent *xcre)
 178 {
 179     XWindowChanges xwc;
 180     int nx, ny, nwidth, nheight;
 181     int ofs_x, ofs_y;
 182
 183     /*  printf("configure event: %d %d %d %d\n", xcre->x, xcre->y, xcre->width, xcre->height);*/
 184
 185     if (wwin==NULL) {
 186         /*
 187          * configure a window that was not mapped by us
 188          */
 189         xwc.x = xcre->x;
 190         xwc.y = xcre->y;
 191         xwc.width = xcre->width;
 192         xwc.height = xcre->height;
 193         xwc.border_width = xcre->border_width;
 194         xwc.stack_mode = xcre->detail;
 195         xwc.sibling = xcre->above;
 196         XConfigureWindow(dpy, xcre->window, xcre->value_mask, &xwc);
 197         return;
 198     }
 199 #ifdef SHAPE
 200     if (wShapeSupported) {
 201         int junk;
 202         unsigned int ujunk;
 203         int b_shaped;
 204
 205         XShapeSelectInput(dpy, wwin->client_win, ShapeNotifyMask);
 206         XShapeQueryExtents(dpy, wwin->client_win, &b_shaped, &junk, &junk,
 207                            &ujunk, &ujunk, &junk, &junk, &junk, &ujunk,
 208                            &ujunk);
 209         wwin->flags.shaped = b_shaped;
 210     }
 211 #endif
 212     if (xcre->value_mask & CWStackMode) {
 213         WObjDescriptor *desc;
 214         WWindow *sibling;
 215
 216         if ((xcre->value_mask & CWSibling) &&
 217             (XFindContext(dpy, xcre->above, wWinContext,
 218                           (XPointer *)&desc) == XCSUCCESS)
 219             && (desc->parent_type==WCLASS_WINDOW)) {
 220             sibling=desc->parent;
 221             xwc.sibling = sibling->frame->core->window;
 222         } else {
 223             xwc.sibling = xcre->above;
 224         }
 225         xwc.stack_mode = xcre->detail;
 226         XConfigureWindow(dpy, wwin->frame->core->window,
 227                          xcre->value_mask & (CWSibling | CWStackMode), &xwc);
 228         /* fix stacking order */
 229         RemakeStackList(wwin->screen_ptr);
 230     }
 231
 232     wClientGetGravityOffsets(wwin, &ofs_x, &ofs_y);
 233
 234     if (xcre->value_mask & CWBorderWidth) {
 235         wwin->old_border_width = xcre->border_width;
 236     }
 237
 238     if (!wwin->flags.shaded) {
 239         /* If the window is shaded, wrong height will be set for the window */
 240         if (xcre->value_mask & CWX) {
 241             nx = xcre->x;
 242             /* Subtracting the border makes the window shift by 1 pixel -Dan */
 243             /*if (HAS_BORDER(wwin)) {
 244                 nx -= FRAME_BORDER_WIDTH;
 245             }*/
 246         } else {
 247             nx = wwin->frame_x;
 248         }
 249
 250         if (xcre->value_mask & CWY) {
 251             ny = xcre->y - ((ofs_y < 0) ? 0 : wwin->frame->top_width);
 252             /* Subtracting the border makes the window shift by 1 pixel -Dan */
 253             /*if (HAS_BORDER(wwin)) {
 254                 ny -= FRAME_BORDER_WIDTH;
 255             }*/
 256         } else {
 257             ny = wwin->frame_y;
 258         }
 259
 260         if (xcre->value_mask & CWWidth)
 261             nwidth = xcre->width;
 262         else
 263             nwidth = wwin->frame->core->width;
 264
 265         if (xcre->value_mask & CWHeight)
 266             nheight = xcre->height;
 267         else
 268             nheight = wwin->frame->core->height - wwin->frame->top_width - wwin->frame->bottom_width;
 269
 270         wWindowConfigure(wwin, nx, ny, nwidth, nheight);
 271         wwin->old_geometry.x = nx;
 272         wwin->old_geometry.y = ny;
 273         wwin->old_geometry.width = nwidth;
 274         wwin->old_geometry.height = nheight;
 275     }
 276 }
 277
 278
 279 void
 280 wClientSendProtocol(WWindow *wwin, Atom protocol, Time time)
 281 {
 282     XEvent event;
 283
 284     event.xclient.type = ClientMessage;
 285     event.xclient.message_type = _XA_WM_PROTOCOLS;
 286     event.xclient.format = 32;
 287     event.xclient.display = dpy;
 288     event.xclient.window = wwin->client_win;
 289     event.xclient.data.l[0] = protocol;
 290     event.xclient.data.l[1] = time;
 291     event.xclient.data.l[2] = 0;
 292     event.xclient.data.l[3] = 0;
 293     XSendEvent(dpy, wwin->client_win, False, NoEventMask, &event);
 294     XSync(dpy, False);
 295 }
 296
 297
 298
 299 void
 300 wClientKill(WWindow *wwin)
 301 {
 302     XKillClient(dpy, wwin->client_win);
 303
 304     XFlush(dpy);
 305 }
 306
 307
 308
 309 /*
 310  *----------------------------------------------------------------------
 311  * wClientCheckProperty--
 312  *      Handles PropertyNotify'es, verifying which property was
 313  * changed and updating internal state according to that, like redrawing
 314  * the icon title when it is changed.
 315  *
 316  * Side effects:
 317  *      Depends on the changed property.
 318  *
 319  * TODO: _GNUSTEP_WM_ATTR
 320  *----------------------------------------------------------------------
 321  */
 322 void
 323 wClientCheckProperty(WWindow *wwin, XPropertyEvent *event)
 324 {
 325     XWindowAttributes attribs;
 326     XWMHints *new_hints;
 327     int i, g1, g2;
 328     char *tmp = NULL;
 329
 330     switch (event->atom) {
 331     case XA_WM_NAME:
 332         if (!wwin->flags.net_has_title)
 333         {
 334             /* window title was changed */
 335             if (!wFetchName(dpy, wwin->client_win, &tmp)) {
 336                 wWindowUpdateName(wwin, NULL);
 337             } else {
 338                 wWindowUpdateName(wwin, tmp);
 339             }
 340             if (tmp)
 341               XFree(tmp);
 342         }
 343         break;
 344
 345     case XA_WM_ICON_NAME:
 346         if (!wwin->flags.net_has_icon_title)
 347         {
 348             if (!wwin->icon)
 349               break;
 350             else {
 351                 char *new_title;
 352
 353                 /* icon title was changed */
 354                 wGetIconName(dpy, wwin->client_win, &new_title);
 355                 wIconChangeTitle(wwin->icon, new_title);
 356             }
 357         }
 358         break;
 359
 360     case XA_WM_COMMAND:
 361         if (wwin->main_window!=None) {
 362             WApplication *wapp = wApplicationOf(wwin->main_window);
 363             char *command;
 364
 365             if (!wapp || !wapp->app_icon || wapp->app_icon->docked)
 366                 break;
 367
 368             command = GetCommandForWindow(wwin->main_window);
 369             if (command) {
 370                 if (wapp->app_icon->command)
 371                     wfree(wapp->app_icon->command);
 372                 wapp->app_icon->command = command;
 373             }
 374         }
 375         break;
 376
 377     case XA_WM_HINTS:
 378         /* WM_HINTS */
 379
 380         new_hints = XGetWMHints(dpy, wwin->client_win);
 381
 382         /* group leader update
 383          *
 384          * This means that the window is setting the leader after
 385          * it was mapped, changing leaders or removing the leader.
 386          *
 387          * Valid state transitions are:
 388          *
 389          *          _1            __2
 390          *         / \           /  \
 391          *         v |           v  |
 392          *         (GC)         (GC')
 393          *        /  ^          /   ^
 394          *       3|  |4        5|   |6
 395          *        |  |          |   |
 396          *        v  /          v   /
 397          *        (G'C)        (G'C')
 398          *
 399          * Where G is the window_group hint, C is CLIENT_LEADER property
 400          * and ' indicates the hint is unset.
 401          *
 402          * 1,2 - change group leader to new value of window_group
 403          * 3 - change leader to value of CLIENT_LEADER
 404          * 4 - change leader to value of window_group
 405          * 5 - destroy application
 406          * 6 - create application
 407          */
 408         if (new_hints && (new_hints->flags & WindowGroupHint)
 409             && new_hints->window_group!=None) {
 410             g2 = 1;
 411         } else {
 412             g2 = 0;
 413         }
 414         if (wwin->wm_hints && (wwin->wm_hints->flags & WindowGroupHint)
 415             && wwin->wm_hints->window_group!=None) {
 416             g1 = 1;
 417         } else {
 418             g1 = 0;
 419         }
 420
 421         if (wwin->client_leader) {
 422             if (g1 && g2
 423                 && wwin->wm_hints->window_group!=new_hints->window_group) {
 424                 i = 1;
 425             } else if (g1 && !g2) {
 426                 i = 3;
 427             } else if (!g1 && g2) {
 428                 i = 4;
 429             } else {
 430                 i = 0;
 431             }
 432         } else {
 433             if (g1 && g2
 434                 && wwin->wm_hints->window_group!=new_hints->window_group) {
 435                 i = 2;
 436             } else if (g1 && !g2) {
 437                 i = 5;
 438             } else if (!g1 && g2) {
 439                 i = 6;
 440             } else {
 441                 i = 0;
 442             }
 443         }
 444
 445         /* Handling this may require more work. -Dan */
 446         if (wwin->fake_group!=NULL) {
 447             i = 7;
 448         }
 449
 450         if (wwin->wm_hints)
 451             XFree(wwin->wm_hints);
 452
 453         wwin->wm_hints = new_hints;
 454
 455         /* do action according to state transition */
 456         switch (i) {
 457             /* 3 - change leader to value of CLIENT_LEADER */
 458         case 3:
 459             wApplicationDestroy(wApplicationOf(wwin->main_window));
 460             wwin->main_window = wwin->client_leader;
 461             wwin->group_id = None;
 462             wApplicationCreate(wwin);
 463             break;
 464
 465             /* 1,2,4 - change leader to new value of window_group */
 466         case 1:
 467         case 2:
 468         case 4:
 469             wApplicationDestroy(wApplicationOf(wwin->main_window));
 470             wwin->main_window = new_hints->window_group;
 471             wwin->group_id = wwin->main_window;
 472             wApplicationCreate(wwin);
 473             break;
 474
 475             /* 5 - destroy application */
 476         case 5:
 477             wApplicationDestroy(wApplicationOf(wwin->main_window));
 478             wwin->main_window = None;
 479             wwin->group_id = None;
 480             break;
 481
 482             /* 6 - create application */
 483         case 6:
 484             wwin->main_window = new_hints->window_group;
 485             wwin->group_id = wwin->main_window;
 486             wApplicationCreate(wwin);
 487             break;
 488             /* 7 - we have a fake window group id, so just ignore anything else */
 489         case 7:
 490             break;
 491         }
 492 #ifdef DEBUG
 493         if (i) {
 494             printf("window leader update caused state transition %i\n",i);
 495         }
 496 #endif
 497
 498         if (wwin->wm_hints) {
 499             /* update icon */
 500             if ((wwin->wm_hints->flags & IconPixmapHint)
 501                 || (wwin->wm_hints->flags & IconWindowHint)) {
 502                 WApplication *wapp;
 503
 504                 if (wwin->flags.miniaturized && wwin->icon) {
 505                     wIconUpdate(wwin->icon);
 506                 }
 507                 wapp = wApplicationOf(wwin->main_window);
 508                 if (wapp && wapp->app_icon) {
 509                     wIconUpdate(wapp->app_icon->icon);
 510                 }
 511             }
 512
 513             if (wwin->wm_hints->flags & UrgencyHint)
 514                 wwin->flags.urgent = 1;
 515             else
 516                 wwin->flags.urgent = 0;
 517             /*} else if (wwin->fake_group!=NULL) {
 518              wwin->group_id = wwin->fake_group->leader;*/
 519         } else {
 520             wwin->group_id = None;
 521         }
 522         break;
 523
 524     case XA_WM_NORMAL_HINTS:
 525         /* normal (geometry) hints */
 526         {
 527             int foo;
 528             unsigned bar;
 529
 530             XGetWindowAttributes(dpy, wwin->client_win, &attribs);
 531             wClientGetNormalHints(wwin, &attribs, False, &foo, &foo,
 532                                   &bar, &bar);
 533             /* TODO: should we check for consistency of the current
 534              * size against the new geometry hints? */
 535         }
 536         break;
 537
 538     case XA_WM_TRANSIENT_FOR:
 539         {
 540             Window new_owner;
 541             WWindow *owner;
 542
 543             if (!XGetTransientForHint(dpy, wwin->client_win, &new_owner)) {
 544                 new_owner = None;
 545             } else {
 546                 if (new_owner==0 || new_owner == wwin->client_win) {
 547                     new_owner = wwin->screen_ptr->root_win;
 548                 }
 549             }
 550             if (new_owner!=wwin->transient_for) {
 551                 owner = wWindowFor(wwin->transient_for);
 552                 if (owner) {
 553                     if (owner->flags.semi_focused) {
 554                         owner->flags.semi_focused = 0;
 555                         if ((owner->flags.mapped || owner->flags.shaded)
 556                             && owner->frame)
 557                             wFrameWindowPaint(owner->frame);
 558                     }
 559                 }
 560                 owner = wWindowFor(new_owner);
 561                 if (owner) {
 562                     if (!owner->flags.semi_focused) {
 563                         owner->flags.semi_focused = 1;
 564                         if ((owner->flags.mapped || owner->flags.shaded)
 565                             && owner->frame)
 566                             wFrameWindowPaint(owner->frame);
 567                     }
 568                 }
 569                 wwin->transient_for = new_owner;
 570                 if (new_owner==None) {
 571                     if (WFLAGP(wwin, no_miniaturizable)) {
 572                         WSETUFLAG(wwin, no_miniaturizable, 0);
 573                         WSETUFLAG(wwin, no_miniaturize_button, 0);
 574                         if (wwin->frame)
 575                             wWindowConfigureBorders(wwin);
 576                     }
 577                 } else if (!WFLAGP(wwin, no_miniaturizable)) {
 578                     WSETUFLAG(wwin, no_miniaturizable, 1);
 579                     WSETUFLAG(wwin, no_miniaturize_button, 1);
 580                     if (wwin->frame)
 581                         wWindowConfigureBorders(wwin);
 582                 }
 583             }
 584         }
 585         break;
 586
 587     default:
 588         if (event->atom==_XA_WM_PROTOCOLS) {
 589
 590             PropGetProtocols(wwin->client_win, &wwin->protocols);
 591
 592             WSETUFLAG(wwin, kill_close, !wwin->protocols.DELETE_WINDOW);
 593
 594             if (wwin->frame)
 595                 wWindowUpdateButtonImages(wwin);
 596
 597         } else if (event->atom==_XA_WM_COLORMAP_WINDOWS) {
 598
 599             GetColormapWindows(wwin);
 600             wColormapInstallForWindow(wwin->screen_ptr, wwin);
 601
 602         } else if (event->atom==_XA_WINDOWMAKER_MENU) {
 603             WApplication *wapp;
 604
 605             wapp = wApplicationOf(wwin->main_window);
 606             if (wapp) {
 607                 if (wapp->menu) {
 608                     /* update menu */
 609                     /* TODO: remake appmenu update */
 610                     wAppMenuDestroy(wapp->menu);
 611                 }
 612                 if (wwin->fake_group) {
 613                     extern WPreferences wPreferences;
 614                     WScreen *scr = wwin->screen_ptr;
 615                     WWindow *foo = scr->focused_window;
 616                     WFakeGroupLeader *fPtr = wwin->fake_group;
 617
 618                     wApplicationDestroy(wapp);
 619                     while (foo) {
 620                         if (foo->fake_group && foo->fake_group==fPtr) {
 621                             WSETUFLAG(foo, shared_appicon, 0);
 622                             foo->fake_group = NULL;
 623                             if (foo->group_id!=None)
 624                                 foo->main_window = foo->group_id;
 625                             else if (foo->client_leader!=None)
 626                                 foo->main_window = foo->client_leader;
 627                             else if (WFLAGP(foo, emulate_appicon))
 628                                 foo->main_window = foo->client_win;
 629                             else
 630                                 foo->main_window = None;
 631                             if (foo->main_window) {
 632                                 wapp = wApplicationCreate(foo);
 633                             }
 634                         }
 635                         foo = foo->prev;
 636                     }
 637
 638                     if (fPtr->leader!=None)
 639                         XDestroyWindow(dpy, fPtr->leader);
 640                     fPtr->retainCount = 0;
 641                     fPtr->leader = None;
 642                     fPtr->origLeader = None;
 643
 644                     wapp = wApplicationOf(wwin->main_window);
 645                     if (wapp) {
 646                         wapp->menu = wAppMenuGet(scr, wwin->main_window);
 647                     }
 648                     if (wPreferences.auto_arrange_icons) {
 649                         wArrangeIcons(wwin->screen_ptr, True);
 650                     }
 651                 } else {
 652                     wapp->menu = wAppMenuGet(wwin->screen_ptr, wwin->main_window);
 653                 }
 654                 /* make the appmenu be mapped */
 655                 wSetFocusTo(wwin->screen_ptr, NULL);
 656                 wSetFocusTo(wwin->screen_ptr, wwin->screen_ptr->focused_window);
 657             }
 658         } else if (event->atom==_XA_GNUSTEP_WM_ATTR) {
 659             GNUstepWMAttributes *attr;
 660
 661             PropGetGNUstepWMAttr(wwin->client_win, &attr);
 662
 663             wWindowUpdateGNUstepAttr(wwin, attr);
 664
 665             XFree(attr);
 666         } else {
 667 #ifdef NETWM_HINTS
 668             wNETWMCheckClientHintChange(wwin, event);
 669 #endif
 670         }
 671     }
 672 }
 673
 674
 675 /*
 676  *----------------------------------------------------------------------
 677  * wClientGetNormalHints--
 678  *      Get size (normal) hints and a default geometry for the client
 679  * window. The hints are also checked for inconsistency. If geometry is
 680  * True, the returned data will account for client specified initial
 681  * geometry.
 682  *
 683  * Side effects:
 684  *      normal_hints is filled with valid data.
 685  *----------------------------------------------------------------------
 686  */
 687 void
 688 wClientGetNormalHints(WWindow *wwin, XWindowAttributes *wattribs, Bool geometry,
 689                       int *x, int *y, unsigned *width, unsigned *height)
 690 {
 691     int pre_icccm = 0;                 /* not used */
 692
 693     /* find a position for the window */
 694     if (!wwin->normal_hints)
 695         wwin->normal_hints = XAllocSizeHints();
 696
 697     if (!PropGetNormalHints(wwin->client_win, wwin->normal_hints, &pre_icccm)) {
 698         wwin->normal_hints->flags = 0;
 699     }
 700     *x = wattribs->x;
 701     *y = wattribs->y;
 702
 703     *width = wattribs->width;
 704     *height = wattribs->height;
 705
 706     if (!(wwin->normal_hints->flags & PWinGravity)) {
 707         wwin->normal_hints->win_gravity = NorthWestGravity;
 708     }
 709     if (!(wwin->normal_hints->flags & PMinSize)) {
 710         wwin->normal_hints->min_width = MIN_WINDOW_SIZE;
 711         wwin->normal_hints->min_height = MIN_WINDOW_SIZE;
 712     }
 713     if (!(wwin->normal_hints->flags & PBaseSize)) {
 714         wwin->normal_hints->base_width = 0;
 715         wwin->normal_hints->base_height = 0;
 716     }
 717     if (!(wwin->normal_hints->flags & PMaxSize)) {
 718         wwin->normal_hints->max_width = wwin->screen_ptr->scr_width*2;
 719         wwin->normal_hints->max_height = wwin->screen_ptr->scr_height*2;
 720     }
 721
 722     /* some buggy apps set weird hints.. */
 723     if (wwin->normal_hints->min_width <= 0)
 724         wwin->normal_hints->min_width = MIN_WINDOW_SIZE;
 725
 726     if (wwin->normal_hints->min_height <= 0)
 727         wwin->normal_hints->min_height = MIN_WINDOW_SIZE;
 728
 729
 730     if (wwin->normal_hints->max_width < wwin->normal_hints->min_width)
 731         wwin->normal_hints->max_width = wwin->normal_hints->min_width;
 732
 733     if (wwin->normal_hints->max_height < wwin->normal_hints->min_height)
 734         wwin->normal_hints->max_height = wwin->normal_hints->min_height;
 735
 736     if (!(wwin->normal_hints->flags & PResizeInc)) {
 737         wwin->normal_hints->width_inc = 1;
 738         wwin->normal_hints->height_inc = 1;
 739     } else {
 740         if (wwin->normal_hints->width_inc <= 0)
 741             wwin->normal_hints->width_inc = 1;
 742         if (wwin->normal_hints->height_inc <= 0)
 743             wwin->normal_hints->height_inc = 1;
 744     }
 745
 746     if (wwin->normal_hints->flags & PAspect) {
 747         if (wwin->normal_hints->min_aspect.x < 1)
 748             wwin->normal_hints->min_aspect.x = 1;
 749         if (wwin->normal_hints->min_aspect.y < 1)
 750             wwin->normal_hints->min_aspect.y = 1;
 751
 752         if (wwin->normal_hints->max_aspect.x < 1)
 753             wwin->normal_hints->max_aspect.x = 1;
 754         if (wwin->normal_hints->max_aspect.y < 1)
 755             wwin->normal_hints->max_aspect.y = 1;
 756     }
 757
 758     if (wwin->normal_hints->min_height > wwin->normal_hints->max_height) {
 759         wwin->normal_hints->min_height = wwin->normal_hints->max_height;
 760     }
 761     if (wwin->normal_hints->min_width > wwin->normal_hints->max_width) {
 762         wwin->normal_hints->min_width = wwin->normal_hints->max_width;
 763     }
 764
 765 #ifdef IGNORE_PPOSITION
 766     wwin->normal_hints->flags &= ~PPosition;
 767 #endif
 768
 769     if (pre_icccm && !wwin->screen_ptr->flags.startup && geometry) {
 770         if (wwin->normal_hints->flags & (USPosition|PPosition)) {
 771             *x = wwin->normal_hints->x;
 772             *y = wwin->normal_hints->y;
 773         }
 774         if (wwin->normal_hints->flags & (USSize|PSize)) {
 775             *width = wwin->normal_hints->width;
 776             *height = wwin->normal_hints->height;
 777         }
 778     }
 779 }
 780
 781
 782 void
 783 GetColormapWindows(WWindow *wwin)
 784 {
 785 #ifndef NO_CRASHES
 786     if (wwin->cmap_windows) {
 787         XFree(wwin->cmap_windows);
 788     }
 789
 790     wwin->cmap_windows = NULL;
 791     wwin->cmap_window_no = 0;
 792
 793     if (!XGetWMColormapWindows(dpy, wwin->client_win, &(wwin->cmap_windows),
 794                                &(wwin->cmap_window_no))
 795         || !wwin->cmap_windows) {
 796         wwin->cmap_window_no = 0;
 797         wwin->cmap_windows = NULL;
 798     }
 799
 800 #endif
 801 }