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                                 |WIN_HINTS_SKIP_TASKBAR)) {
 315             wwin->client_flags.skip_window_list = 1;
 316         }
 317
 318         /* client reserved area, for the panel */
 319         if (flags & (WIN_HINTS_DO_NOT_COVER)) {
 320                 WReservedArea *area;
 321
 322                 area = malloc(sizeof(WReservedArea));
 323                 if (!area) {
 324                         wwarning(_("out of memory while updating GNOME hints"));
 325                 } else {
 326                         XWindowAttributes wattribs;
 327
 328                         XGetWindowAttributes(dpy, wwin->client_win, &wattribs);
 329                         wClientGetNormalHints(wwin, &wattribs, False,
 330                                         &area->area.x1, &area->area.y1,
 331                                         &area->area.x2, &area->area.y2);
 332                         area->area.x2 = area->area.x2 + area->area.x1;
 333                         area->area.y2 = area->area.y2 + area->area.y1;
 334
 335                         area->window = wwin->client_win;
 336                 }
 337                 area->next = wwin->screen_ptr->reservedAreas;
 338                 wwin->screen_ptr->reservedAreas = area;
 339
 340                 wScreenUpdateUsableArea(wwin->screen_ptr);
 341         }
 342
 343         hasHints = True;
 344     }
 345
 346     /* layer */
 347     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_LAYER, 0, 1, False,
 348                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 349                            &bytes_after_ret,
 350                            (unsigned char**)&data)==Success  && data) {
 351         val = *data;
 352
 353         XFree(data);
 354
 355         *layer = getWindowLevel(val);
 356         hasHints = True;
 357     }
 358
 359     /* workspace */
 360     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_WORKSPACE, 0, 1,
 361                            False, XA_CARDINAL, &type_ret, &fmt_ret,
 362                            &nitems_ret, &bytes_after_ret,
 363                            (unsigned char**)&data)==Success && data) {
 364         val = *data;
 365
 366         XFree(data);
 367
 368         if (val > 0)
 369             *workspace = val;
 370         hasHints = True;
 371     }
 372
 373     /* reserved area */
 374     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_EXPANDED_SIZE, 0, 1,
 375                            False, XA_CARDINAL, &type_ret, &fmt_ret,
 376                            &nitems_ret, &bytes_after_ret,
 377                            (unsigned char**)&data)==Success && data) {
 378         WReservedArea *area;
 379
 380         area = malloc(sizeof(WReservedArea));
 381         if (!area) {
 382             wwarning(_("out of memory while updating GNOME hints"));
 383         } else {
 384             area->area.x1 = data[0];
 385             area->area.y1 = data[1];
 386             area->area.x2 = data[2] - data[0];
 387             area->area.y2 = data[3] - data[1];
 388             XFree(data);
 389
 390             area->window = wwin->client_win;
 391         }
 392
 393         area->next = wwin->screen_ptr->reservedAreas;
 394         wwin->screen_ptr->reservedAreas = area;
 395
 396         wScreenUpdateUsableArea(wwin->screen_ptr);
 397         hasHints = True;
 398     }
 399
 400     return hasHints;
 401 }
 402
 403
 404 Bool
 405 wGNOMECheckInitialClientState(WWindow *wwin)
 406 {
 407     Atom type_ret;
 408     int fmt_ret;
 409     unsigned long nitems_ret;
 410     unsigned long bytes_after_ret;
 411     long flags, *data = 0;
 412
 413     if (XGetWindowProperty(dpy, wwin->client_win, _XA_WIN_STATE, 0, 1, False,
 414                            XA_CARDINAL, &type_ret, &fmt_ret, &nitems_ret,
 415                            &bytes_after_ret,
 416                            (unsigned char**)&data)!=Success || !data)
 417         return False;
 418
 419     flags = *data;
 420
 421     XFree(data);
 422
 423     if (flags & WIN_STATE_STICKY)
 424         wwin->client_flags.omnipresent = 1;
 425
 426     if (flags & (WIN_STATE_MAXIMIZED_VERT|WIN_STATE_MAXIMIZED_HORIZ)) {
 427
 428         if (flags & WIN_STATE_MAXIMIZED_VERT)
 429             wwin->flags.maximized |= MAX_VERTICAL;
 430
 431         if (flags & WIN_STATE_MAXIMIZED_HORIZ)
 432             wwin->flags.maximized |= MAX_HORIZONTAL;
 433     }
 434
 435     if (flags & WIN_STATE_SHADED)
 436         wwin->flags.shaded = 1;
 437
 438     return True;
 439 }
 440
 441
 442 void
 443 wGNOMEUpdateClientStateHint(WWindow *wwin, Bool changedWorkspace)
 444 {
 445     long val;
 446     long flags = 0;
 447
 448     if (changedWorkspace) {
 449         val = wwin->frame->workspace;
 450
 451         XChangeProperty(dpy, wwin->client_win, _XA_WIN_WORKSPACE, XA_CARDINAL,
 452                         32, PropModeReplace, (unsigned char*)&val, 1);
 453
 454         if (val != wwin->screen_ptr->current_workspace)
 455             flags |= WIN_STATE_HID_WORKSPACE;
 456     }
 457
 458     if (IS_OMNIPRESENT(wwin))
 459         flags |= WIN_STATE_STICKY;
 460
 461     if (wwin->flags.miniaturized)
 462         flags |= WIN_STATE_MINIMIZED;
 463
 464     if (wwin->flags.maximized & MAX_VERTICAL)
 465         flags |= WIN_STATE_MAXIMIZED_VERT;
 466
 467     if (wwin->flags.maximized & MAX_HORIZONTAL)
 468         flags |= WIN_STATE_MAXIMIZED_HORIZ;
 469
 470     if (wwin->flags.shaded)
 471         flags |= WIN_STATE_SHADED;
 472
 473     if (wwin->transient_for != None) {
 474         WWindow *owner = wWindowFor(wwin->transient_for);
 475
 476         if (owner && !owner->flags.mapped)
 477             flags |= WIN_STATE_HID_TRANSIENT;
 478     }
 479
 480     /* ? */
 481     if (wwin->flags.hidden)
 482         flags |= WIN_STATE_HIDDEN;
 483
 484     XChangeProperty(dpy, wwin->client_win, _XA_WIN_STATE, XA_CARDINAL,
 485                     32, PropModeReplace, (unsigned char*)&flags, 1);
 486 }
 487
 488
 489 Bool
 490 wGNOMEProcessClientMessage(XClientMessageEvent *event)
 491 {
 492     WScreen *scr;
 493     WWindow *wwin;
 494     Bool done = True;
 495
 496     scr = wScreenForWindow(event->window);
 497     if (scr) {
 498         /* generic client messages */
 499         if (event->message_type == _XA_WIN_WORKSPACE) {
 500             wWorkspaceChange(scr, event->data.l[0]);
 501         } else {
 502             done = False;
 503         }
 504
 505         if (done)
 506             return True;
 507     }
 508
 509     /* window specific client messages */
 510
 511     wwin = wWindowFor(event->window);
 512     if (!wwin)
 513         return False;
 514
 515     if (event->message_type == _XA_WIN_LAYER) {
 516         int level = getWindowLevel(event->data.l[0]);
 517
 518         if (WINDOW_LEVEL(wwin) != level) {
 519             ChangeStackingLevel(wwin->frame->core, level);
 520         }
 521     } else if (event->message_type == _XA_WIN_STATE) {
 522         int flags, mask;
 523         Bool updateWindowList = False;
 524         int maximize = 0;
 525
 526         mask = event->data.l[0];
 527         flags = event->data.l[1];
 528
 529         if (mask & WIN_STATE_STICKY) {
 530             if ((flags & WIN_STATE_STICKY) != WFLAGP(wwin, omnipresent)) {
 531                 wwin->client_flags.omnipresent = (flags & WIN_STATE_STICKY)!=0;
 532                 wGNOMEUpdateClientStateHint(wwin, False);
 533                 updateWindowList = True;
 534             }
 535         }
 536
 537         if (mask & WIN_STATE_MAXIMIZED_VERT) {
 538             if (flags & WIN_STATE_MAXIMIZED_VERT)
 539                 maximize = MAX_VERTICAL;
 540             else
 541                 maximize = 0;
 542         } else {
 543             maximize = wwin->flags.maximized & MAX_VERTICAL;
 544         }
 545
 546         if (mask & WIN_STATE_MAXIMIZED_HORIZ) {
 547             if (flags & WIN_STATE_MAXIMIZED_HORIZ)
 548                 maximize |= MAX_HORIZONTAL;
 549             else
 550                 maximize |= 0;
 551         } else {
 552             maximize |= wwin->flags.maximized & MAX_HORIZONTAL;
 553         }
 554
 555         if (maximize != wwin->flags.maximized) {
 556 #define both (MAX_HORIZONTAL|MAX_VERTICAL)
 557             if (!(maximize & both) && (wwin->flags.maximized & both)) {
 558                 wUnmaximizeWindow(wwin);
 559             }
 560             if ((maximize & both) && !(wwin->flags.maximized & both)) {
 561                 wMaximizeWindow(wwin, maximize);
 562             }
 563             updateWindowList = False;
 564 #undef both
 565         }
 566
 567         if (mask & WIN_STATE_SHADED) {
 568             if ((flags & WIN_STATE_SHADED) != wwin->flags.shaded) {
 569                 if (wwin->flags.shaded)
 570                     wUnshadeWindow(wwin);
 571                 else
 572                     wShadeWindow(wwin);
 573                 updateWindowList = False;
 574             }
 575         }
 576
 577         if (updateWindowList) {
 578             UpdateSwitchMenu(wwin->screen_ptr, wwin, ACTION_CHANGE_STATE);
 579         }
 580     } else if (event->message_type == _XA_WIN_WORKSPACE) {
 581
 582         if (event->data.l[0] != wwin->frame->workspace) {
 583             wWindowChangeWorkspace(wwin, event->data.l[0]);
 584         }
 585     } else {
 586         done = False;
 587     }
 588
 589     return done;
 590 }
 591
 592
 593 Bool
 594 wGNOMEProxyizeButtonEvent(WScreen *scr, XEvent *event)
 595 {
 596     if (event->type == ButtonPress)
 597         XUngrabPointer(dpy, CurrentTime);
 598     XSendEvent(dpy, scr->no_focus_win, False, SubstructureNotifyMask, event);
 599
 600     return True;
 601 }
 602
 603
 604 void
 605 wGNOMERemoveClient(WWindow *wwin)
 606 {
 607     int flag = 0;
 608     WReservedArea *area;
 609
 610     wGNOMEUpdateClientListHint(wwin->screen_ptr);
 611
 612     area = wwin->screen_ptr->reservedAreas;
 613
 614     if (area) {
 615         if (area->window == wwin->client_win) {
 616             wwin->screen_ptr->reservedAreas = area->next;
 617             wfree(area);
 618             flag = 1;
 619         } else {
 620             while (area->next && area->next->window != wwin->client_win)
 621                 area = area->next;
 622
 623             if (area->next) {
 624                 WReservedArea *next;
 625
 626                 next = area->next->next;
 627                 wfree(area->next);
 628                 area->next = next;
 629
 630                 flag = 1;
 631             }
 632         }
 633     }
 634
 635     if (flag) {
 636         wScreenUpdateUsableArea(wwin->screen_ptr);
 637     }
 638 }
 639
 640
 641 #endif /* GNOME_STUFF */