src/gnome.c

   1 /* gnome.c-- support for the GNOME Hints
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1998, 1999 Alfredo K. Kojima
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  20  *  USA.
  21  */
  22
  23 /*
  24  * According to the author of this thing, it should not be taken seriously.
  25  * IMHO, there are lot's of weirdnesses and it's quite unelegant. I'd
  26  * rather not support it, but here it goes anyway.
  27  */
  28
  29 #include "wconfig.h"
  30
  31 #ifdef GNOME_STUFF
  32
  33 #include <X11/Xlib.h>
  34 #include <X11/Xutil.h>
  35 #include <X11/Xatom.h>
  36
  37 #include <stdlib.h>
  38 #include <stdio.h>
  39 #include <string.h>
  40
  41
  42 #include "WindowMaker.h"
  43 #include "screen.h"
  44 #include "wcore.h"
  45 #include "framewin.h"
  46 #include "window.h"
  47 #include "workspace.h"
  48 #include "funcs.h"
  49 #include "actions.h"
  50 #include "stacking.h"
  51
  52 #include "gnome.h"
  53
  54
  55
  56
  57
  58
  59 #define WIN_HINTS_SKIP_FOCUS      (1<<0) /*"alt-tab" skips this win*/
  60 #define WIN_HINTS_SKIP_WINLIST    (1<<1) /*do not show in window list*/
  61 #define WIN_HINTS_SKIP_TASKBAR    (1<<2) /*do not show on taskbar*/
  62 #define WIN_HINTS_GROUP_TRANSIENT (1<<3) /*Reserved - definition is unclear*/
  63 #define WIN_HINTS_FOCUS_ON_CLICK  (1<<4) /*app only accepts focus if clicked*/
  64 #define WIN_HINTS_DO_NOT_COVER    (1<<5) /* attempt to not cover this window */
  65
  66
  67 #define WIN_STATE_STICKY          (1<<0) /*everyone knows sticky*/
  68 #define WIN_STATE_MINIMIZED       (1<<1) /*Reserved - definition is unclear*/
  69 #define WIN_STATE_MAXIMIZED_VERT  (1<<2) /*window in maximized V state*/
  70 #define WIN_STATE_MAXIMIZED_HORIZ (1<<3) /*window in maximized H state*/
  71 #define WIN_STATE_HIDDEN          (1<<4) /*not on taskbar but window visible*/
  72 #define WIN_STATE_SHADED          (1<<5) /*shaded (MacOS / Afterstep style)*/
  73 /* these are bogus states defined in "the spec" */
  74 #define WIN_STATE_HID_WORKSPACE   (1<<6) /*not on current desktop*/
  75 #define WIN_STATE_HID_TRANSIENT   (1<<7) /*owner of transient is hidden*/
  76 #define WIN_STATE_FIXED_POSITION  (1<<8) /*window is fixed in position even*/
  77 #define WIN_STATE_ARRANGE_IGNORE  (1<<9) /*ignore for auto arranging*/
  78
  79
  80 #define WIN_LAYER_DESKTOP                0
  81 #define WIN_LAYER_BELOW                  2
  82 #define WIN_LAYER_NORMAL                 4
  83 #define WIN_LAYER_ONTOP                  6
  84 #define WIN_LAYER_DOCK                   8
  85 #define WIN_LAYER_ABOVE_DOCK             10
  86 #define WIN_LAYER_MENU                   12
  87
  88
  89
  90 static Atom _XA_WIN_SUPPORTING_WM_CHECK = 0;
  91 static Atom _XA_WIN_PROTOCOLS;
  92 static Atom _XA_WIN_LAYER;
  93 static Atom _XA_WIN_STATE;
  94 static Atom _XA_WIN_HINTS;
  95 static Atom _XA_WIN_APP_STATE;
  96 static Atom _XA_WIN_EXPANDED_SIZE;
  97 static Atom _XA_WIN_ICONS;
  98 static Atom _XA_WIN_WORKSPACE;
  99 static Atom _XA_WIN_WORKSPACE_COUNT;
 100 static Atom _XA_WIN_WORKSPACE_NAMES;
 101 static Atom _XA_WIN_CLIENT_LIST;
 102 static Atom _XA_WIN_DESKTOP_BUTTON_PROXY;
 103
 104
 105 void
 106 wGNOMEInitStuff(WScreen *scr)
 107 {
 108     Atom supportedStuff[10];
 109     int count;
 110
 111     if (!_XA_WIN_SUPPORTING_WM_CHECK) {
 112
 113         _XA_WIN_SUPPORTING_WM_CHECK =
 114             XInternAtom(dpy, "_WIN_SUPPORTING_WM_CHECK", False);
 115
 116         _XA_WIN_PROTOCOLS = XInternAtom(dpy, "_WIN_PROTOCOLS", False);
 117
 118         _XA_WIN_LAYER = XInternAtom(dpy, "_WIN_LAYER", False);
 119
 120         _XA_WIN_STATE = XInternAtom(dpy, "_WIN_STATE", False);
 121
 122         _XA_WIN_HINTS = XInternAtom(dpy, "_WIN_HINTS", False);
 123
 124         _XA_WIN_APP_STATE = XInternAtom(dpy, "_WIN_APP_STATE", False);
 125
 126         _XA_WIN_EXPANDED_SIZE = XInternAtom(dpy, "_WIN_EXPANDED_SIZE", False);
 127
 128         _XA_WIN_ICONS = XInternAtom(dpy, "_WIN_ICONS", False);
 129
 130         _XA_WIN_WORKSPACE = XInternAtom(dpy, "_WIN_WORKSPACE", False);
 131
 132         _XA_WIN_WORKSPACE_COUNT =
 133             XInternAtom(dpy, "_WIN_WORKSPACE_COUNT", False);
 134
 135         _XA_WIN_WORKSPACE_NAMES =
 136             XInternAtom(dpy, "_WIN_WORKSPACE_NAMES", False);
 137
 138         _XA_WIN_CLIENT_LIST = XInternAtom(dpy, "_WIN_CLIENT_LIST", False);
 139
 140         _XA_WIN_DESKTOP_BUTTON_PROXY =
 141             XInternAtom(dpy, "_WIN_DESKTOP_BUTTON_PROXY", False);
 142     }
 143
 144     /* I'd rather use the ICCCM 2.0 mechanisms, but
 145      * since some people prefer to reinvent the wheel instead of
 146      * conforming to standards... */
 147
 148     /* setup the "We're compliant, you idiot!" hint */
 149
 150     /* why XA_CARDINAL instead of XA_WINDOW? */
 151     XChangeProperty(dpy, scr->root_win, _XA_WIN_SUPPORTING_WM_CHECK,
 152                     XA_CARDINAL, 32, PropModeReplace,
 153                     (unsigned char*)&scr->no_focus_win, 1);
 154
 155     XChangeProperty(dpy, scr->no_focus_win, _XA_WIN_SUPPORTING_WM_CHECK,
 156                     XA_CARDINAL, 32, PropModeReplace,
 157                     (unsigned char*)&scr->no_focus_win, 1);
 158
 159
 160     /* setup the "desktop button proxy" thing */
 161     XChangeProperty(dpy, scr->root_win, _XA_WIN_DESKTOP_BUTTON_PROXY,
 162                     XA_CARDINAL, 32, PropModeReplace,
 163                     (unsigned char*)&scr->no_focus_win, 1);
 164     XChangeProperty(dpy, scr->no_focus_win, _XA_WIN_DESKTOP_BUTTON_PROXY,
 165                     XA_CARDINAL, 32, PropModeReplace,
 166                     (unsigned char*)&scr->no_focus_win, 1);
 167
 168
 169     /* setup the list of supported protocols */
 170     count = 0;
 171     supportedStuff[count++] = _XA_WIN_LAYER;
 172     supportedStuff[count++] = _XA_WIN_STATE;
 173     supportedStuff[count++] = _XA_WIN_HINTS;
 174     supportedStuff[count++] = _XA_WIN_APP_STATE;
 175     supportedStuff[count++] = _XA_WIN_EXPANDED_SIZE;
 176     supportedStuff[count++] = _XA_WIN_ICONS;
 177     supportedStuff[count++] = _XA_WIN_WORKSPACE;
 178     supportedStuff[count++] = _XA_WIN_WORKSPACE_COUNT;
 179     supportedStuff[count++] = _XA_WIN_WORKSPACE_NAMES;
 180     supportedStuff[count++] = _XA_WIN_CLIENT_LIST;
 181
 182     XChangeProperty(dpy, scr->root_win, _XA_WIN_PROTOCOLS, XA_ATOM, 32,
 183                     PropModeReplace, (unsigned char*)supportedStuff, count);
 184
 185     XFlush(dpy);
 186 }
 187
 188
 189 void
 190 wGNOMEUpdateClientListHint(WScreen *scr)
 191 {
 192     WWindow *wwin;
 193     Window *windows;
 194     int count;
 195
 196     windows = malloc(sizeof(Window)*scr->window_count);
 197     if (!windows) {
 198         wwarning(_("out of memory while updating GNOME hints"));
 199         return;
 200     }
 201
 202     count = 0;
 203     wwin = scr->focused_window;
 204     while (wwin) {
 205         if (!wwin->flags.internal_window) {
 206
 207             windows[count++] = wwin->client_win;
 208         }
 209
 210         wwin = wwin->prev;
 211     }
 212
 213     XChangeProperty(dpy, scr->root_win, _XA_WIN_CLIENT_LIST, XA_CARDINAL, 32,
 214                     PropModeReplace, (unsigned char *)windows, count);
 215
 216     wfree(windows);
 217     XFlush(dpy);
 218 }
 219
 220
 221 void
 222 wGNOMEUpdateWorkspaceHints(WScreen *scr)
 223 {
 224     long val;
 225
 226     val = scr->workspace_count;
 227
 228     XChangeProperty(dpy, scr->root_win, _XA_WIN_WORKSPACE_COUNT, XA_CARDINAL,
 229                     32, PropModeReplace, (unsigned char*)&val, 1);
 230
 231     wGNOMEUpdateWorkspaceNamesHint(scr);
 232 }
 233
 234
 235 void
 236 wGNOMEUpdateWorkspaceNamesHint(WScreen *scr)
 237 {
 238     char *wsNames[MAX_WORKSPACES];
 239     XTextProperty textProp;
 240     int i;
 241
 242     for (i = 0; i < scr->workspace_count; i++) {
 243         wsNames[i] = scr->workspaces[i]->name;
 244     }
 245
 246     if (XStringListToTextProperty(wsNames, scr->workspace_count, &textProp)) {
 247         XSetTextProperty(dpy, scr->root_win, &textProp,
 248                          _XA_WIN_WORKSPACE_NAMES);
 249         XFree(textProp.value);
 250     }
 251 }
 252
 253
 254 void
 255 wGNOMEUpdateCurrentWorkspaceHint(WScreen *scr)
 256 {
 257     long val;
 258
 259     val = scr->current_workspace;
 260
 261     XChangeProperty(dpy, scr->root_win, _XA_WIN_WORKSPACE, XA_CARDINAL,
 262                     32, PropModeReplace, (unsigned char*)&val, 1);
 263 }
 264
 265
 266 static int
 267 getWindowLevel(int layer)
 268 {
 269     int level;
 270
 271     if (layer <= WIN_LAYER_DESKTOP)
 272         level = WMDesktopLevel;
 273     else if (layer <= WIN_LAYER_BELOW)
 274         level = WMSunkenLevel;
 275     else if (layer <= WIN_LAYER_NORMAL)
 276         level = WMNormalLevel;
 277     else if (layer <= WIN_LAYER_ONTOP)
 278         level = WMFloatingLevel;
 279     else if (layer <= WIN_LAYER_DOCK)
 280         level = WMDockLevel;
 281     else if (layer <= WIN_LAYER_ABOVE_DOCK)
 282         level = WMSubmenuLevel;
 283     else if (layer <= WIN_LAYER_MENU)
 284         level = WMMainMenuLevel;
 285     else
 286         level = WMOuterSpaceLevel;
 287
 288     return level;
 289 }
 290
 291
 292 Bool
 293 wGNOMECheckClientHints(WWindow *wwin, int *layer, int *workspace)
 294 {
 295     Atom type_ret;
 296     int fmt_ret;
 297     unsigned long nitems_ret;
 298     unsigned long bytes_after_ret;
 299     long flags, val, *data = 0;
 300     Bool hasHints = False;
 301
 302     /* hints */
 303
 304     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_HINTS, 0, 1, False,
 305                            /* should be XA_INTEGER, but spec is broken */
 306                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 307                            &bytes_after_ret,
 308                            (unsigned char**)&data)==Success && data) {
 309         flags = *data;
 310
 311         XFree(data);
 312
 313         if (flags & (WIN_HINTS_SKIP_FOCUS|WIN_HINTS_SKIP_WINLIST)) {
 314             wwin->client_flags.skip_window_list = 1;
 315         }
 316
 317         /* client reserved area, for the panel */
 318         if (flags & (WIN_HINTS_DO_NOT_COVER)) {
 319                 WReservedArea *area;
 320
 321                 area = malloc(sizeof(WReservedArea));
 322                 if (!area) {
 323                         wwarning(_("out of memory while updating GNOME hints"));
 324                 } else {
 325                         XWindowAttributes wattribs;
 326
 327                         XGetWindowAttributes(dpy, wwin->client_win, &wattribs);
 328                         wClientGetNormalHints(wwin, &wattribs, False,
 329                                         &area->area.x1, &area->area.y1,
 330                                         &area->area.x2, &area->area.y2);
 331                         area->area.x2 = area->area.x2 + area->area.x1;
 332                         area->area.y2 = area->area.y2 + area->area.y1;
 333
 334                         area->window = wwin->client_win;
 335                 }
 336                 area->next = wwin->screen_ptr->reservedAreas;
 337                 wwin->screen_ptr->reservedAreas = area;
 338
 339                 wScreenUpdateUsableArea(wwin->screen_ptr);
 340         }
 341
 342         hasHints = True;
 343     }
 344
 345     /* layer */
 346     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_LAYER, 0, 1, False,
 347                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 348                            &bytes_after_ret,
 349                            (unsigned char**)&data)==Success  && data) {
 350         val = *data;
 351
 352         XFree(data);
 353
 354         *layer = getWindowLevel(val);
 355         hasHints = True;
 356     }
 357
 358     /* workspace */
 359     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_WORKSPACE, 0, 1,
 360                            False, XA_CARDINAL, &type_ret, &fmt_ret,
 361                            &nitems_ret, &bytes_after_ret,
 362                            (unsigned char**)&data)==Success && data) {
 363         val = *data;
 364
 365         XFree(data);
 366
 367         if (val > 0)
 368             *workspace = val;
 369         hasHints = True;
 370     }
 371
 372     /* reserved area */
 373     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_EXPANDED_SIZE, 0, 1,
 374                            False, XA_CARDINAL, &type_ret, &fmt_ret,
 375                            &nitems_ret, &bytes_after_ret,
 376                            (unsigned char**)&data)==Success && data) {
 377         WReservedArea *area;
 378
 379         area = malloc(sizeof(WReservedArea));
 380         if (!area) {
 381             wwarning(_("out of memory while updating GNOME hints"));
 382         } else {
 383             area->area.x1 = data[0];
 384             area->area.y1 = data[1];
 385             area->area.x2 = data[2] - data[0];
 386             area->area.y2 = data[3] - data[1];
 387             XFree(data);
 388
 389             area->window = wwin->client_win;
 390         }
 391
 392         area->next = wwin->screen_ptr->reservedAreas;
 393         wwin->screen_ptr->reservedAreas = area;
 394
 395         wScreenUpdateUsableArea(wwin->screen_ptr);
 396         hasHints = True;
 397     }
 398
 399     return hasHints;
 400 }
 401
 402
 403 Bool
 404 wGNOMECheckInitialClientState(WWindow *wwin)
 405 {
 406     Atom type_ret;
 407     int fmt_ret;
 408     unsigned long nitems_ret;
 409     unsigned long bytes_after_ret;
 410     long flags, *data = 0;
 411
 412     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_STATE, 0, 1, False,
 413                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 414                            &bytes_after_ret,
 415                            (unsigned char**)&data)!=Success || !data)
 416         return False;
 417
 418     flags = *data;
 419
 420     XFree(data);
 421
 422     if (flags & WIN_STATE_STICKY)
 423         wwin->client_flags.omnipresent = 1;
 424
 425     if (flags & (WIN_STATE_MAXIMIZED_VERT|WIN_STATE_MAXIMIZED_HORIZ)) {
 426
 427         if (flags & WIN_STATE_MAXIMIZED_VERT)
 428             wwin->flags.maximized |= MAX_VERTICAL;
 429
 430         if (flags & WIN_STATE_MAXIMIZED_HORIZ)
 431             wwin->flags.maximized |= MAX_HORIZONTAL;
 432     }
 433
 434     if (flags & WIN_STATE_SHADED)
 435         wwin->flags.shaded = 1;
 436
 437     return True;
 438 }
 439
 440
 441 void
 442 wGNOMEUpdateClientStateHint(WWindow *wwin, Bool changedWorkspace)
 443 {
 444     long val;
 445     long flags = 0;
 446
 447     if (changedWorkspace) {
 448         val = wwin->frame->workspace;
 449
 450         XChangeProperty(dpy, wwin->client_win, _XA_WIN_WORKSPACE, XA_CARDINAL,
 451                         32, PropModeReplace, (unsigned char*)&val, 1);
 452
 453         if (val != wwin->screen_ptr->current_workspace)
 454             flags |= WIN_STATE_HID_WORKSPACE;
 455     }
 456
 457     if (IS_OMNIPRESENT(wwin))
 458         flags |= WIN_STATE_STICKY;
 459
 460     if (wwin->flags.miniaturized)
 461         flags |= WIN_STATE_MINIMIZED;
 462
 463     if (wwin->flags.maximized & MAX_VERTICAL)
 464         flags |= WIN_STATE_MAXIMIZED_VERT;
 465
 466     if (wwin->flags.maximized & MAX_HORIZONTAL)
 467         flags |= WIN_STATE_MAXIMIZED_HORIZ;
 468
 469     if (wwin->flags.shaded)
 470         flags |= WIN_STATE_SHADED;
 471
 472     if (wwin->transient_for != None) {
 473         WWindow *owner = wWindowFor(wwin->transient_for);
 474
 475         if (owner && !owner->flags.mapped)
 476             flags |= WIN_STATE_HID_TRANSIENT;
 477     }
 478
 479     /* ? */
 480     if (wwin->flags.hidden)
 481         flags |= WIN_STATE_HIDDEN;
 482
 483     XChangeProperty(dpy, wwin->client_win, _XA_WIN_STATE, XA_CARDINAL,
 484                     32, PropModeReplace, (unsigned char*)&flags, 1);
 485 }
 486
 487
 488 Bool
 489 wGNOMEProcessClientMessage(XClientMessageEvent *event)
 490 {
 491     WScreen *scr;
 492     WWindow *wwin;
 493     Bool done = True;
 494
 495     scr = wScreenForWindow(event->window);
 496     if (scr) {
 497         /* generic client messages */
 498         if (event->message_type == _XA_WIN_WORKSPACE) {
 499             wWorkspaceChange(scr, event->data.l[0]);
 500         } else {
 501             done = False;
 502         }
 503
 504         if (done)
 505             return True;
 506     }
 507
 508     /* window specific client messages */
 509
 510     wwin = wWindowFor(event->window);
 511     if (!wwin)
 512         return False;
 513
 514     if (event->message_type == _XA_WIN_LAYER) {
 515         int level = getWindowLevel(event->data.l[0]);
 516
 517         if (WINDOW_LEVEL(wwin) != level) {
 518             ChangeStackingLevel(wwin->frame->core, level);
 519         }
 520     } else if (event->message_type == _XA_WIN_STATE) {
 521         int flags, mask;
 522         Bool updateWindowList = False;
 523         int maximize = 0;
 524
 525         mask = event->data.l[0];
 526         flags = event->data.l[1];
 527
 528         if (mask & WIN_STATE_STICKY) {
 529             if ((flags & WIN_STATE_STICKY) != WFLAGP(wwin, omnipresent)) {
 530                 wwin->client_flags.omnipresent = (flags & WIN_STATE_STICKY)!=0;
 531                 wGNOMEUpdateClientStateHint(wwin, False);
 532                 updateWindowList = True;
 533             }
 534         }
 535
 536         if (mask & WIN_STATE_MAXIMIZED_VERT) {
 537             if (flags & WIN_STATE_MAXIMIZED_VERT)
 538                 maximize = MAX_VERTICAL;
 539             else
 540                 maximize = 0;
 541         } else {
 542             maximize = wwin->flags.maximized & MAX_VERTICAL;
 543         }
 544
 545         if (mask & WIN_STATE_MAXIMIZED_HORIZ) {
 546             if (flags & WIN_STATE_MAXIMIZED_HORIZ)
 547                 maximize |= MAX_HORIZONTAL;
 548             else
 549                 maximize |= 0;
 550         } else {
 551             maximize |= wwin->flags.maximized & MAX_HORIZONTAL;
 552         }
 553
 554         if (maximize != wwin->flags.maximized) {
 555 #define both (MAX_HORIZONTAL|MAX_VERTICAL)
 556             if (!(maximize & both) && (wwin->flags.maximized & both)) {
 557                 wUnmaximizeWindow(wwin);
 558             }
 559             if ((maximize & both) && !(wwin->flags.maximized & both)) {
 560                 wMaximizeWindow(wwin, maximize);
 561             }
 562             updateWindowList = False;
 563 #undef both
 564         }
 565
 566         if (mask & WIN_STATE_SHADED) {
 567             if ((flags & WIN_STATE_SHADED) != wwin->flags.shaded) {
 568                 if (wwin->flags.shaded)
 569                     wUnshadeWindow(wwin);
 570                 else
 571                     wShadeWindow(wwin);
 572                 updateWindowList = False;
 573             }
 574         }
 575
 576         if (updateWindowList) {
 577             UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
 578         }
 579     } else if (event->message_type == _XA_WIN_WORKSPACE) {
 580
 581         if (event->data.l[0] != wwin->frame->workspace) {
 582             wWindowChangeWorkspace(wwin, event->data.l[0]);
 583         }
 584     } else {
 585         done = False;
 586     }
 587
 588     return done;
 589 }
 590
 591
 592 Bool
 593 wGNOMEProxyizeButtonEvent(WScreen *scr, XEvent *event)
 594 {
 595     if (event->type == ButtonPress)
 596         XUngrabPointer(dpy, CurrentTime);
 597     XSendEvent(dpy, scr->no_focus_win, False, SubstructureNotifyMask, event);
 598
 599     return True;
 600 }
 601
 602
 603 void
 604 wGNOMERemoveClient(WWindow *wwin)
 605 {
 606     int flag = 0;
 607     WReservedArea *area;
 608
 609     wGNOMEUpdateClientListHint(wwin->screen_ptr);
 610
 611     area = wwin->screen_ptr->reservedAreas;
 612
 613     if (area) {
 614         if (area->window == wwin->client_win) {
 615             wwin->screen_ptr->reservedAreas = area->next;
 616             wfree(area);
 617             flag = 1;
 618         } else {
 619             while (area->next && area->next->window != wwin->client_win)
 620                 area = area->next;
 621
 622             if (area->next) {
 623                 WReservedArea *next;
 624
 625                 next = area->next->next;
 626                 wfree(area->next);
 627                 area->next = next;
 628
 629                 flag = 1;
 630             }
 631         }
 632     }
 633
 634     if (flag) {
 635         wScreenUpdateUsableArea(wwin->screen_ptr);
 636     }
 637 }
 638
 639
 640 #endif /* GNOME_STUFF */