src/client.c

   1 /*
   2  *  Window Maker window manager
   3  *
   4  *  Copyright (c) 1997-2002 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 KWM_HINTS
  47 #include "kwm.h"
  48 #endif
  49
  50 /****** Global Variables ******/
  51
  52 /* contexts */
  53 extern XContext wWinContext;
  54
  55 extern Atom _XA_WM_STATE;
  56 extern Atom _XA_WM_PROTOCOLS;
  57 extern Atom _XA_WM_COLORMAP_WINDOWS;
  58
  59 extern Atom _XA_WINDOWMAKER_MENU;
  60
  61 extern Atom _XA_GNUSTEP_WM_ATTR;
  62 extern Atom _XA_GNUSTEP_WM_RESIZEBAR;
  63
  64 #ifdef SHAPE
  65 extern Bool wShapeSupported;
  66 #endif
  67
  68
  69 /*
  70  *--------------------------------------------------------------------
  71  * wClientRestore--
  72  *      Reparent the window back to the root window.
  73  *
  74  *--------------------------------------------------------------------
  75  */
  76 void
  77 wClientRestore(WWindow *wwin)
  78 {
  79 #if 0
  80     int gx, gy;
  81
  82     wClientGetGravityOffsets(wwin, &gx, &gy);
  83     /* set the positio of the frame on screen */
  84     wwin->frame_x -= gx * FRAME_BORDER_WIDTH;
  85     wwin->frame_y -= gy * FRAME_BORDER_WIDTH;
  86     /* if gravity is to the south, account for the border sizes */
  87     if (gy > 0)
  88         wwin->frame_y += (wwin->frame->top_width + wwin->frame->bottom_width);
  89 #endif
  90     XSetWindowBorderWidth(dpy, wwin->client_win, wwin->old_border_width);
  91     XReparentWindow(dpy, wwin->client_win, wwin->screen_ptr->root_win,
  92                     wwin->frame_x, wwin->frame_y);
  93
  94     /* don't let the window get iconified after restart */
  95     /*
  96     if (wwin->flags.shaded)
  97         wClientSetState(wwin, NormalState, None);
  98      */
  99 }
 100
 101
 102 /*
 103  *----------------------------------------------------------------------
 104  * wClientSetState--
 105  *      Set the state of the client window to one of the window
 106  * states defined in ICCCM (Iconic, Withdrawn, Normal)
 107  *
 108  * Side effects:
 109  *      The WM_STATE property of the window is updated as well as the
 110  * WWindow.state variable.
 111  *----------------------------------------------------------------------
 112  */
 113 void
 114 wClientSetState(WWindow *wwin, int state, Window icon_win)
 115 {
 116     CARD32 data[2];
 117
 118     wwin->state = state;
 119
 120     data[0] = (unsigned long) state;
 121     data[1] = (unsigned long) icon_win;
 122
 123     XChangeProperty(dpy, wwin->client_win, _XA_WM_STATE, _XA_WM_STATE, 32,
 124                     PropModeReplace, (unsigned char *) data, 2);
 125 }
 126
 127
 128 void
 129 wClientGetGravityOffsets(WWindow *wwin, int *ofs_x, int *ofs_y)
 130 {
 131     switch (wwin->normal_hints->win_gravity) {
 132      case ForgetGravity:
 133      case CenterGravity:
 134      case StaticGravity:
 135         *ofs_x = 0;
 136         *ofs_y = 0;
 137         break;
 138      case NorthWestGravity:
 139         *ofs_x = -1;
 140         *ofs_y = -1;
 141         break;
 142      case NorthGravity:
 143         *ofs_x = 0;
 144         *ofs_y = -1;
 145         break;
 146      case NorthEastGravity:
 147         *ofs_x = 1;
 148         *ofs_y = -1;
 149         break;
 150      case WestGravity:
 151         *ofs_x = -1;
 152         *ofs_y = 0;
 153         break;
 154      case EastGravity:
 155         *ofs_x = 1;
 156         *ofs_y = 0;
 157         break;
 158      case SouthWestGravity:
 159         *ofs_x = -1;
 160         *ofs_y = 1;
 161         break;
 162      case SouthGravity:
 163         *ofs_x = 0;
 164         *ofs_y = 1;
 165         break;
 166      case SouthEastGravity:
 167         *ofs_x = 1;
 168         *ofs_y = 1;
 169         break;
 170     }
 171 }
 172
 173
 174
 175 void
 176 wClientConfigure(WWindow *wwin, XConfigureRequestEvent *xcre)
 177 {
 178     XWindowChanges xwc;
 179     int nx, ny, nwidth, nheight;
 180     int ofs_x, ofs_y;
 181
 182     if (wwin==NULL) {
 183         /*
 184          * configure a window that was not mapped by us
 185          */
 186         xwc.x = xcre->x;
 187         xwc.y = xcre->y;
 188         xwc.width = xcre->width;
 189         xwc.height = xcre->height;
 190         xwc.border_width = xcre->border_width;
 191         xwc.stack_mode = xcre->detail;
 192         xwc.sibling = xcre->above;
 193         XConfigureWindow(dpy, xcre->window, xcre->value_mask, &xwc);
 194         return;
 195     }
 196 #ifdef SHAPE
 197     if (wShapeSupported) {
 198         int junk;
 199         unsigned int ujunk;
 200         int b_shaped;
 201
 202         XShapeSelectInput(dpy, wwin->client_win, ShapeNotifyMask);
 203         XShapeQueryExtents(dpy, wwin->client_win, &b_shaped, &junk, &junk,
 204                            &ujunk, &ujunk, &junk, &junk, &junk, &ujunk,
 205                            &ujunk);
 206         wwin->flags.shaped = b_shaped;
 207     }
 208 #endif
 209     if (xcre->value_mask & CWStackMode) {
 210         WObjDescriptor *desc;
 211         WWindow *sibling;
 212
 213         if ((xcre->value_mask & CWSibling) &&
 214             (XFindContext(dpy, xcre->above, wWinContext,
 215                           (XPointer *)&desc) == XCSUCCESS)
 216             && (desc->parent_type==WCLASS_WINDOW)) {
 217             sibling=desc->parent;
 218             xwc.sibling = sibling->frame->core->window;
 219         } else {
 220             xwc.sibling = xcre->above;
 221         }
 222         xwc.stack_mode = xcre->detail;
 223         XConfigureWindow(dpy, wwin->frame->core->window,
 224                          xcre->value_mask & (CWSibling | CWStackMode), &xwc);
 225         /* fix stacking order */
 226         RemakeStackList(wwin->screen_ptr);
 227     }
 228
 229     wClientGetGravityOffsets(wwin, &ofs_x, &ofs_y);
 230
 231     if (xcre->value_mask & CWBorderWidth) {
 232         wwin->old_border_width = xcre->border_width;
 233     }
 234
 235     if (!wwin->flags.shaded) {
 236         /* If the window is shaded, wrong height will be set for the window */
 237         if (xcre->value_mask & CWX) {
 238             nx = xcre->x;
 239             if (!WFLAGP(wwin, no_border))
 240               nx -= FRAME_BORDER_WIDTH;
 241         }
 242         else
 243             nx = wwin->frame_x;
 244
 245         if (xcre->value_mask & CWY) {
 246             ny = xcre->y - ((ofs_y < 0) ? 0 : wwin->frame->top_width);
 247             if (!WFLAGP(wwin, no_border))
 248               ny -= FRAME_BORDER_WIDTH;
 249         }
 250         else
 251             ny = wwin->frame_y;
 252
 253         if (xcre->value_mask & CWWidth)
 254             nwidth = xcre->width;
 255         else
 256             nwidth = wwin->frame->core->width;
 257
 258         if (xcre->value_mask & CWHeight)
 259             nheight = xcre->height;
 260         else
 261             nheight = wwin->frame->core->height - wwin->frame->top_width - wwin->frame->bottom_width;
 262
 263         wWindowConfigure(wwin, nx, ny, nwidth, nheight);
 264         wwin->old_geometry.x = nx;
 265         wwin->old_geometry.y = ny;
 266         wwin->old_geometry.width = nwidth;
 267         wwin->old_geometry.height = nheight;
 268     }
 269 }
 270
 271
 272 void
 273 wClientSendProtocol(WWindow *wwin, Atom protocol, Time time)
 274 {
 275     XEvent event;
 276
 277     event.xclient.type = ClientMessage;
 278     event.xclient.message_type = _XA_WM_PROTOCOLS;
 279     event.xclient.format = 32;
 280     event.xclient.display = dpy;
 281     event.xclient.window = wwin->client_win;
 282     event.xclient.data.l[0] = protocol;
 283     event.xclient.data.l[1] = time;
 284     event.xclient.data.l[2] = 0;
 285     event.xclient.data.l[3] = 0;
 286     XSendEvent(dpy, wwin->client_win, False, NoEventMask, &event);
 287     XSync(dpy, False);
 288 }
 289
 290
 291
 292 void
 293 wClientKill(WWindow *wwin)
 294 {
 295     XKillClient(dpy, wwin->client_win);
 296
 297     XFlush(dpy);
 298 }
 299
 300
 301
 302 /*
 303  *----------------------------------------------------------------------
 304  * wClientCheckProperty--
 305  *      Handles PropertyNotify'es, verifying which property was
 306  * changed and updating internal state according to that, like redrawing
 307  * the icon title when it is changed.
 308  *
 309  * Side effects:
 310  *      Depends on the changed property.
 311  *
 312  * TODO: _GNUSTEP_WM_ATTR
 313  *----------------------------------------------------------------------
 314  */
 315 void
 316 wClientCheckProperty(WWindow *wwin, XPropertyEvent *event)
 317 {
 318     XWindowAttributes attribs;
 319     XWMHints *new_hints;
 320     int i, g1, g2;
 321     char *tmp = NULL;
 322
 323     switch (event->atom) {
 324      case XA_WM_NAME:
 325         /* window title was changed */
 326         if (!wFetchName(dpy, wwin->client_win, &tmp)) {
 327             wWindowUpdateName(wwin, NULL);
 328         } else {
 329             wWindowUpdateName(wwin, tmp);
 330         }
 331         if (tmp)
 332             XFree(tmp);
 333         break;
 334
 335      case XA_WM_ICON_NAME:
 336 #ifdef KWM_HINTS
 337         wKWMSendEventMessage(wwin, WKWMChangedClient);
 338 #endif
 339         if (!wwin->icon)
 340             break;
 341         else {
 342             char *new_title;
 343
 344             /* icon title was changed */
 345             wGetIconName(dpy, wwin->client_win, &new_title);
 346             wIconChangeTitle(wwin->icon, new_title);
 347         }
 348         break;
 349
 350      case XA_WM_COMMAND:
 351         if (wwin->main_window!=None) {
 352             WApplication *wapp = wApplicationOf(wwin->main_window);
 353             char **argv;
 354             int argc;
 355
 356             if (!wapp || !wapp->app_icon)
 357                 break;
 358
 359             if (XGetCommand(dpy, wwin->main_window, &argv, &argc)) {
 360                 if (argc > 0 && argv != NULL) {
 361                     if (wapp->app_icon->command)
 362                         wfree(wapp->app_icon->command);
 363                     wapp->app_icon->command = wtokenjoin(argv, argc);
 364                 }
 365                 if (argv) {
 366                     XFreeStringList(argv);
 367                 }
 368             }
 369         }
 370         break;
 371
 372      case XA_WM_HINTS:
 373         /* WM_HINTS */
 374
 375         new_hints = XGetWMHints(dpy, wwin->client_win);
 376
 377         /* group leader update
 378          *
 379          * This means that the window is setting the leader after
 380          * it was mapped, changing leaders or removing the leader.
 381          *
 382          * Valid state transitions are:
 383          *
 384          *          _1            __2
 385          *         / \           /  \
 386          *         v |           v  |
 387          *         (GC)         (GC')
 388          *        /  ^          /   ^
 389          *       3|  |4        5|   |6
 390          *        |  |          |   |
 391          *        v  /          v   /
 392          *        (G'C)        (G'C')
 393          *
 394          * Where G is the window_group hint, C is CLIENT_LEADER property
 395          * and ' indicates the hint is unset.
 396          *
 397          * 1,2 - change group leader to new value of window_group
 398          * 3 - change leader to value of CLIENT_LEADER
 399          * 4 - change leader to value of window_group
 400          * 5 - destroy application
 401          * 6 - create application
 402          */
 403         if (new_hints && (new_hints->flags & WindowGroupHint)
 404             && new_hints->window_group!=None) {
 405             g2 = 1;
 406         } else {
 407             g2 = 0;
 408         }
 409         if (wwin->wm_hints && (wwin->wm_hints->flags & WindowGroupHint)
 410             && wwin->wm_hints->window_group!=None) {
 411             g1 = 1;
 412         } else {
 413             g1 = 0;
 414         }
 415
 416         if (wwin->client_leader) {
 417             if (g1 && g2
 418                 && wwin->wm_hints->window_group!=new_hints->window_group) {
 419                 i = 1;
 420             } else if (g1 && !g2) {
 421                 i = 3;
 422             } else if (!g1 && g2) {
 423                 i = 4;
 424             } else {
 425                 i = 0;
 426             }
 427         } else {
 428             if (g1 && g2
 429                 && wwin->wm_hints->window_group!=new_hints->window_group) {
 430                 i = 2;
 431             } else if (g1 && !g2) {
 432                 i = 5;
 433             } else if (!g1 && g2) {
 434                 i = 6;
 435             } else {
 436                 i = 0;
 437             }
 438         }
 439
 440         /* Handling this may require more work. -Dan */
 441         if (wwin->fake_group!=NULL) {
 442             i = 7;
 443         }
 444
 445         if (wwin->wm_hints)
 446           XFree(wwin->wm_hints);
 447
 448         wwin->wm_hints = new_hints;
 449
 450         /* do action according to state transition */
 451         switch (i) {
 452          /* 3 - change leader to value of CLIENT_LEADER */
 453          case 3:
 454             wApplicationDestroy(wApplicationOf(wwin->main_window));
 455             wwin->main_window = wwin->client_leader;
 456             wwin->group_id = None;
 457             wApplicationCreate(wwin->screen_ptr, wwin->main_window);
 458             break;
 459
 460          /* 1,2,4 - change leader to new value of window_group */
 461          case 1:
 462          case 2:
 463          case 4:
 464             wApplicationDestroy(wApplicationOf(wwin->main_window));
 465             wwin->main_window = new_hints->window_group;
 466             wwin->group_id = wwin->main_window;
 467             wApplicationCreate(wwin->screen_ptr, wwin->main_window);
 468             break;
 469
 470          /* 5 - destroy application */
 471          case 5:
 472             wApplicationDestroy(wApplicationOf(wwin->main_window));
 473             wwin->main_window = None;
 474             wwin->group_id = None;
 475             break;
 476
 477          /* 6 - create application */
 478          case 6:
 479             wwin->main_window = new_hints->window_group;
 480             wwin->group_id = wwin->main_window;
 481             wApplicationCreate(wwin->screen_ptr, wwin->main_window);
 482             break;
 483          /* 7 - we have a fake window group id, so just ignore anything else */
 484          case 7:
 485             break;
 486         }
 487 #ifdef DEBUG
 488         if (i) {
 489             printf("window leader update caused state transition %i\n",i);
 490         }
 491 #endif
 492
 493         if (wwin->wm_hints) {
 494             /* update icon */
 495             if ((wwin->wm_hints->flags & IconPixmapHint)
 496                 || (wwin->wm_hints->flags & IconWindowHint)) {
 497                 WApplication *wapp;
 498
 499                 if (wwin->flags.miniaturized && wwin->icon) {
 500                     wIconUpdate(wwin->icon);
 501                 }
 502                 wapp = wApplicationOf(wwin->main_window);
 503                 if (wapp && wapp->app_icon) {
 504                     wIconUpdate(wapp->app_icon->icon);
 505                 }
 506 #ifdef KWM_HINTS
 507                 wKWMSendEventMessage(wwin, WKWMIconChange);
 508 #endif
 509             }
 510
 511             if (wwin->wm_hints->flags & UrgencyHint)
 512               wwin->flags.urgent = 1;
 513             else
 514               wwin->flags.urgent = 0;
 515         /*} else if (wwin->fake_group!=NULL) {
 516             wwin->group_id = wwin->fake_group->leader;*/
 517         } else {
 518             wwin->group_id = None;
 519         }
 520         break;
 521
 522      case XA_WM_NORMAL_HINTS:
 523         /* normal (geometry) hints */
 524         {
 525             int foo;
 526             unsigned bar;
 527
 528             XGetWindowAttributes(dpy, wwin->client_win, &attribs);
 529             wClientGetNormalHints(wwin, &attribs, False, &foo, &foo,
 530                                   &bar, &bar);
 531             /* TODO: should we check for consistency of the current
 532              * size against the new geometry hints? */
 533         }
 534         break;
 535
 536      case XA_WM_TRANSIENT_FOR:
 537         {
 538             Window new_owner;
 539             WWindow *owner;
 540
 541             if (!XGetTransientForHint(dpy, wwin->client_win, &new_owner)) {
 542                 new_owner = None;
 543             } else {
 544                 if (new_owner==0 || new_owner == wwin->client_win) {
 545                     new_owner = wwin->screen_ptr->root_win;
 546                 }
 547             }
 548             if (new_owner!=wwin->transient_for) {
 549                 owner = wWindowFor(wwin->transient_for);
 550                 if (owner) {
 551                     if (owner->flags.semi_focused) {
 552                         owner->flags.semi_focused = 0;
 553                         if ((owner->flags.mapped || owner->flags.shaded)
 554                             && owner->frame)
 555                           wFrameWindowPaint(owner->frame);
 556                     }
 557                 }
 558                 owner = wWindowFor(new_owner);
 559                 if (owner) {
 560                     if (!owner->flags.semi_focused) {
 561                         owner->flags.semi_focused = 1;
 562                         if ((owner->flags.mapped || owner->flags.shaded)
 563                             && owner->frame)
 564                           wFrameWindowPaint(owner->frame);
 565                     }
 566                 }
 567                 wwin->transient_for = new_owner;
 568                 if (new_owner==None) {
 569                     if (WFLAGP(wwin, no_miniaturizable)) {
 570                         WSETUFLAG(wwin, no_miniaturizable, 0);
 571                         WSETUFLAG(wwin, no_miniaturize_button, 0);
 572                         if (wwin->frame)
 573                             wWindowConfigureBorders(wwin);
 574                     }
 575                 } else if (!WFLAGP(wwin, no_miniaturizable)) {
 576                     WSETUFLAG(wwin, no_miniaturizable, 1);
 577                     WSETUFLAG(wwin, no_miniaturize_button, 1);
 578                     if (wwin->frame)
 579                         wWindowConfigureBorders(wwin);
 580                 }
 581             }
 582         }
 583         break;
 584
 585      default:
 586         if (event->atom==_XA_WM_PROTOCOLS) {
 587
 588             PropGetProtocols(wwin->client_win, &wwin->protocols);
 589
 590             WSETUFLAG(wwin, kill_close, !wwin->protocols.DELETE_WINDOW);
 591
 592             if (wwin->frame)
 593                 wWindowUpdateButtonImages(wwin);
 594
 595         } else if (event->atom==_XA_WM_COLORMAP_WINDOWS) {
 596
 597             GetColormapWindows(wwin);
 598             wColormapInstallForWindow(wwin->screen_ptr, wwin);
 599
 600         } else if (event->atom==_XA_WINDOWMAKER_MENU) {
 601             WApplication *wapp;
 602
 603             wapp = wApplicationOf(wwin->main_window);
 604             if (wapp) {
 605                 if (wapp->menu) {
 606                     /* update menu */
 607                     /* TODO: remake appmenu update */
 608                     wAppMenuDestroy(wapp->menu);
 609                 }
 610                 if (wwin->fake_group) {
 611                     extern WPreferences wPreferences;
 612                     WScreen *scr = wwin->screen_ptr;
 613                     WWindow *foo = scr->focused_window;
 614                     WFakeGroupLeader *fPtr = wwin->fake_group;
 615
 616                     wApplicationDestroy(wapp);
 617                     while (foo) {
 618                         if (foo->fake_group && foo->fake_group==fPtr) {
 619                             WSETUFLAG(foo, shared_appicon, 0);
 620                             foo->fake_group = NULL;
 621                             if (foo->group_id!=None)
 622                                 foo->main_window = foo->group_id;
 623                             else if (foo->client_leader!=None)
 624                                 foo->main_window = foo->client_leader;
 625                             else if (WFLAGP(foo, emulate_appicon))
 626                                 foo->main_window = foo->client_win;
 627                             else
 628                                 foo->main_window = None;
 629                             if (foo->main_window) {
 630                                 wapp = wApplicationCreate(scr, foo->main_window);
 631                             }
 632                         }
 633                         foo = foo->prev;
 634                     }
 635
 636                     if (fPtr->leader!=None)
 637                         XDestroyWindow(dpy, fPtr->leader);
 638                     fPtr->retainCount = 0;
 639                     fPtr->leader = None;
 640                     fPtr->origLeader = None;
 641
 642                     wapp = wApplicationOf(wwin->main_window);
 643                     if (wapp) {
 644                         wapp->menu = wAppMenuGet(scr, wwin->main_window);
 645                     }
 646                     if (wPreferences.auto_arrange_icons) {
 647                         wArrangeIcons(wwin->screen_ptr, True);
 648                     }
 649                 } else {
 650                     wapp->menu = wAppMenuGet(wwin->screen_ptr, wwin->main_window);
 651                 }
 652                 /* make the appmenu be mapped */
 653                 wSetFocusTo(wwin->screen_ptr, NULL);
 654                 wSetFocusTo(wwin->screen_ptr, wwin->screen_ptr->focused_window);
 655             }
 656         } else if (event->atom==_XA_GNUSTEP_WM_ATTR) {
 657             GNUstepWMAttributes *attr;
 658
 659             PropGetGNUstepWMAttr(wwin->client_win, &attr);
 660
 661             wWindowUpdateGNUstepAttr(wwin, attr);
 662
 663             XFree(attr);
 664         } else {
 665 #ifdef KWM_HINTS
 666             Bool done;
 667
 668             done = wKWMCheckClientHintChange(wwin, event);
 669 #endif /* KWM_HINTS */
 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 }