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