src/workspace.c

   1 /* workspace.c- Workspace management
   2  *
   3  *  Window Maker window manager
   4  *
   5  *  Copyright (c) 1997-2003 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 #include "wconfig.h"
  23
  24 #include <X11/Xlib.h>
  25 #include <X11/Xutil.h>
  26 #ifdef SHAPE
  27 #include <X11/extensions/shape.h>
  28 #endif
  29
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <unistd.h>
  33 #include <ctype.h>
  34 #include <string.h>
  35 #include <time.h>
  36
  37 #include "WindowMaker.h"
  38 #include "wcore.h"
  39 #include "framewin.h"
  40 #include "window.h"
  41 #include "icon.h"
  42 #include "funcs.h"
  43 #include "menu.h"
  44 #include "application.h"
  45 #include "dock.h"
  46 #include "actions.h"
  47 #include "workspace.h"
  48 #include "appicon.h"
  49 #ifdef KWM_HINTS
  50 #include "kwm.h"
  51 #endif
  52
  53
  54 extern WPreferences wPreferences;
  55 extern XContext wWinContext;
  56
  57
  58 static WMPropList *dWorkspaces=NULL;
  59 static WMPropList *dClip, *dName;
  60
  61 #ifdef VIRTUAL_DESKTOP
  62 static BOOL initVDesk = False;
  63 #endif
  64
  65 static void
  66 make_keys()
  67 {
  68     if (dWorkspaces!=NULL)
  69         return;
  70
  71     dWorkspaces = WMCreatePLString("Workspaces");
  72     dName = WMCreatePLString("Name");
  73     dClip = WMCreatePLString("Clip");
  74 }
  75
  76
  77 void
  78 wWorkspaceMake(WScreen *scr, int count)
  79 {
  80     while (count>0) {
  81         wWorkspaceNew(scr);
  82         count--;
  83     }
  84 }
  85
  86
  87 int
  88 wWorkspaceNew(WScreen *scr)
  89 {
  90     WWorkspace *wspace, **list;
  91     int i;
  92
  93     if (scr->workspace_count < MAX_WORKSPACES) {
  94         scr->workspace_count++;
  95
  96         wspace = wmalloc(sizeof(WWorkspace));
  97         wspace->name = NULL;
  98
  99 #ifdef KWM_HINTS
 100         if (scr->flags.kwm_syncing_count) {
 101             wspace->name = wKWMGetWorkspaceName(scr, scr->workspace_count-1);
 102         }
 103 #endif
 104         if (!wspace->name) {
 105             wspace->name = wmalloc(strlen(_("Workspace %i"))+8);
 106             sprintf(wspace->name, _("Workspace %i"), scr->workspace_count);
 107         }
 108
 109
 110     if (!wPreferences.flags.noclip) {
 111         wspace->clip = wDockCreate(scr, WM_CLIP);
 112     } else
 113         wspace->clip = NULL;
 114
 115         list = wmalloc(sizeof(WWorkspace*)*scr->workspace_count);
 116
 117         for (i=0; i<scr->workspace_count-1; i++) {
 118             list[i] = scr->workspaces[i];
 119         }
 120         list[i] = wspace;
 121         if (scr->workspaces)
 122             wfree(scr->workspaces);
 123         scr->workspaces = list;
 124
 125         wWorkspaceMenuUpdate(scr, scr->workspace_menu);
 126         wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
 127 #ifdef VIRTUAL_DESKTOP
 128     wspace->view_x = wspace->view_y = 0;
 129     wspace->height = scr->scr_height;
 130     wspace->width = scr->scr_width;
 131 #endif
 132         WMPostNotificationName(WMNWorkspaceCreated, scr,
 133                                (void*)(scr->workspace_count-1));
 134         XFlush(dpy);
 135
 136         return scr->workspace_count-1;
 137     }
 138     return -1;
 139 }
 140
 141
 142
 143 Bool
 144 wWorkspaceDelete(WScreen *scr, int workspace)
 145 {
 146     WWindow *tmp;
 147     WWorkspace **list;
 148     int i, j;
 149
 150
 151     if (workspace<=0)
 152         return False;
 153
 154     /* verify if workspace is in use by some window */
 155     tmp = scr->focused_window;
 156     while (tmp) {
 157         if (!IS_OMNIPRESENT(tmp) && tmp->frame->workspace==workspace)
 158             return False;
 159         tmp = tmp->prev;
 160     }
 161
 162     if (!wPreferences.flags.noclip) {
 163         wDockDestroy(scr->workspaces[workspace]->clip);
 164         scr->workspaces[workspace]->clip = NULL;
 165     }
 166
 167     list = wmalloc(sizeof(WWorkspace*)*(scr->workspace_count-1));
 168     j = 0;
 169     for (i=0; i<scr->workspace_count; i++) {
 170         if (i!=workspace)
 171             list[j++] = scr->workspaces[i];
 172         else {
 173             if (scr->workspaces[i]->name)
 174                 wfree(scr->workspaces[i]->name);
 175             wfree(scr->workspaces[i]);
 176         }
 177     }
 178     wfree(scr->workspaces);
 179     scr->workspaces = list;
 180
 181     scr->workspace_count--;
 182
 183
 184     /* update menu */
 185     wWorkspaceMenuUpdate(scr, scr->workspace_menu);
 186     /* clip workspace menu */
 187     wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
 188
 189     /* update also window menu */
 190     if (scr->workspace_submenu) {
 191         WMenu *menu = scr->workspace_submenu;
 192
 193         i = menu->entry_no;
 194         while (i>scr->workspace_count)
 195             wMenuRemoveItem(menu, --i);
 196         wMenuRealize(menu);
 197     }
 198     /* and clip menu */
 199     if (scr->clip_submenu) {
 200         WMenu *menu = scr->clip_submenu;
 201
 202         i = menu->entry_no;
 203         while (i>scr->workspace_count)
 204             wMenuRemoveItem(menu, --i);
 205         wMenuRealize(menu);
 206     }
 207
 208     WMPostNotificationName(WMNWorkspaceDestroyed, scr,
 209                            (void*)(scr->workspace_count-1));
 210
 211     if (scr->current_workspace >= scr->workspace_count)
 212         wWorkspaceChange(scr, scr->workspace_count-1);
 213
 214     return True;
 215 }
 216
 217
 218 typedef struct WorkspaceNameData {
 219     int count;
 220     RImage *back;
 221     RImage *text;
 222     time_t timeout;
 223 } WorkspaceNameData;
 224
 225
 226
 227 static void
 228 hideWorkspaceName(void *data)
 229 {
 230     WScreen *scr = (WScreen*)data;
 231
 232     if (!scr->workspace_name_data || scr->workspace_name_data->count == 0
 233         || time(NULL) > scr->workspace_name_data->timeout) {
 234         XUnmapWindow(dpy, scr->workspace_name);
 235
 236         if (scr->workspace_name_data) {
 237             RReleaseImage(scr->workspace_name_data->back);
 238             RReleaseImage(scr->workspace_name_data->text);
 239             wfree(scr->workspace_name_data);
 240
 241             scr->workspace_name_data = NULL;
 242         }
 243         scr->workspace_name_timer = NULL;
 244     } else {
 245         RImage *img = RCloneImage(scr->workspace_name_data->back);
 246         Pixmap pix;
 247
 248         scr->workspace_name_timer =
 249             WMAddTimerHandler(WORKSPACE_NAME_FADE_DELAY, hideWorkspaceName,
 250                               scr);
 251
 252         RCombineImagesWithOpaqueness(img, scr->workspace_name_data->text,
 253                                      scr->workspace_name_data->count*255/10);
 254
 255         RConvertImage(scr->rcontext, img, &pix);
 256
 257         RReleaseImage(img);
 258
 259         XSetWindowBackgroundPixmap(dpy, scr->workspace_name, pix);
 260         XClearWindow(dpy, scr->workspace_name);
 261         XFreePixmap(dpy, pix);
 262         XFlush(dpy);
 263
 264         scr->workspace_name_data->count--;
 265     }
 266 }
 267
 268
 269
 270 static void
 271 showWorkspaceName(WScreen *scr, int workspace)
 272 {
 273     WorkspaceNameData *data;
 274     RXImage *ximg;
 275     Pixmap text, mask;
 276     int w, h;
 277     int px, py;
 278     char *name = scr->workspaces[workspace]->name;
 279     int len = strlen(name);
 280     int x, y;
 281
 282     if (wPreferences.workspace_name_display_position == WD_NONE
 283         || scr->workspace_count < 2)
 284         return;
 285
 286     if (scr->workspace_name_timer) {
 287         WMDeleteTimerHandler(scr->workspace_name_timer);
 288         XUnmapWindow(dpy, scr->workspace_name);
 289         XFlush(dpy);
 290     }
 291     scr->workspace_name_timer = WMAddTimerHandler(WORKSPACE_NAME_DELAY,
 292                                                   hideWorkspaceName, scr);
 293
 294     if (scr->workspace_name_data) {
 295         RReleaseImage(scr->workspace_name_data->back);
 296         RReleaseImage(scr->workspace_name_data->text);
 297         wfree(scr->workspace_name_data);
 298     }
 299
 300     data = wmalloc(sizeof(WorkspaceNameData));
 301
 302     w = WMWidthOfString(scr->workspace_name_font, name, len);
 303     h = WMFontHeight(scr->workspace_name_font);
 304
 305     switch (wPreferences.workspace_name_display_position) {
 306      case WD_TOP:
 307         px = (scr->scr_width - (w+4))/2;
 308         py = 0;
 309         break;
 310      case WD_BOTTOM:
 311         px = (scr->scr_width - (w+4))/2;
 312         py = scr->scr_height - (h+4);
 313         break;
 314      case WD_TOPLEFT:
 315         px = 0;
 316         py = 0;
 317         break;
 318      case WD_TOPRIGHT:
 319         px = scr->scr_width - (w+4);
 320         py = 0;
 321         break;
 322      case WD_BOTTOMLEFT:
 323         px = 0;
 324         py = scr->scr_height - (h+4);
 325         break;
 326      case WD_BOTTOMRIGHT:
 327         px = scr->scr_width - (w+4);
 328         py = scr->scr_height - (h+4);
 329         break;
 330      case WD_CENTER:
 331      default:
 332         px = (scr->scr_width - (w+4))/2;
 333         py = (scr->scr_height - (h+4))/2;
 334         break;
 335     }
 336     XResizeWindow(dpy, scr->workspace_name, w+4, h+4);
 337     XMoveWindow(dpy, scr->workspace_name, px, py);
 338
 339     text = XCreatePixmap(dpy, scr->w_win, w+4, h+4, scr->w_depth);
 340     mask = XCreatePixmap(dpy, scr->w_win, w+4, h+4, 1);
 341
 342     /*XSetForeground(dpy, scr->mono_gc, 0);
 343     XFillRectangle(dpy, mask, scr->mono_gc, 0, 0, w+4, h+4);*/
 344
 345     XFillRectangle(dpy, text, WMColorGC(scr->black), 0, 0, w+4, h+4);
 346
 347     for (x = 0; x <= 4; x++) {
 348         for (y = 0; y <= 4; y++) {
 349             WMDrawString(scr->wmscreen, text, scr->white,
 350                          scr->workspace_name_font, x, y, name, len);
 351         }
 352     }
 353
 354     XSetForeground(dpy, scr->mono_gc, 1);
 355     XSetBackground(dpy, scr->mono_gc, 0);
 356
 357     XCopyPlane(dpy, text, mask, scr->mono_gc, 0, 0, w+4, h+4, 0, 0, 1<<(scr->w_depth-1));
 358
 359     /*XSetForeground(dpy, scr->mono_gc, 1);*/
 360     XSetBackground(dpy, scr->mono_gc, 1);
 361
 362     XFillRectangle(dpy, text, WMColorGC(scr->black), 0, 0, w+4, h+4);
 363
 364     WMDrawString(scr->wmscreen, text, scr->white, scr->workspace_name_font,
 365                  2, 2, name, len);
 366
 367 #ifdef SHAPE
 368     XShapeCombineMask(dpy, scr->workspace_name, ShapeBounding, 0, 0, mask,
 369                       ShapeSet);
 370 #endif
 371     XSetWindowBackgroundPixmap(dpy, scr->workspace_name, text);
 372     XClearWindow(dpy, scr->workspace_name);
 373
 374     data->text = RCreateImageFromDrawable(scr->rcontext, text, None);
 375
 376     XFreePixmap(dpy, text);
 377     XFreePixmap(dpy, mask);
 378
 379     if (!data->text) {
 380         XMapRaised(dpy, scr->workspace_name);
 381         XFlush(dpy);
 382
 383         goto erro;
 384     }
 385
 386     ximg = RGetXImage(scr->rcontext, scr->root_win, px, py,
 387                       data->text->width, data->text->height);
 388
 389     if (!ximg || !ximg->image) {
 390         goto erro;
 391     }
 392
 393     XMapRaised(dpy, scr->workspace_name);
 394     XFlush(dpy);
 395
 396     data->back = RCreateImageFromXImage(scr->rcontext, ximg->image, NULL);
 397     RDestroyXImage(scr->rcontext, ximg);
 398
 399     if (!data->back) {
 400         goto erro;
 401     }
 402
 403     data->count = 10;
 404
 405     /* set a timeout for the effect */
 406     data->timeout = time(NULL) + 2 +
 407         (WORKSPACE_NAME_DELAY + WORKSPACE_NAME_FADE_DELAY*data->count)/1000;
 408
 409     scr->workspace_name_data = data;
 410
 411
 412     return;
 413
 414 erro:
 415     if (scr->workspace_name_timer)
 416         WMDeleteTimerHandler(scr->workspace_name_timer);
 417
 418     if (data->text)
 419         RReleaseImage(data->text);
 420     if (data->back)
 421         RReleaseImage(data->back);
 422     wfree(data);
 423
 424     scr->workspace_name_data = NULL;
 425
 426     scr->workspace_name_timer = WMAddTimerHandler(WORKSPACE_NAME_DELAY +
 427                                                   10*WORKSPACE_NAME_FADE_DELAY,
 428                                                   hideWorkspaceName, scr);
 429 }
 430
 431
 432 void
 433 wWorkspaceChange(WScreen *scr, int workspace)
 434 {
 435     if (scr->flags.startup || scr->flags.startup2) {
 436         return;
 437     }
 438
 439     if (workspace != scr->current_workspace) {
 440         wWorkspaceForceChange(scr, workspace);
 441     } /*else {
 442         showWorkspaceName(scr, workspace);
 443     }*/
 444 }
 445
 446
 447 void
 448 wWorkspaceRelativeChange(WScreen *scr, int amount)
 449 {
 450     int w;
 451
 452     w = scr->current_workspace + amount;
 453
 454     if (amount < 0) {
 455
 456         if (w >= 0)
 457             wWorkspaceChange(scr, w);
 458         else if (wPreferences.ws_cycle)
 459             wWorkspaceChange(scr, scr->workspace_count + w);
 460
 461     } else if (amount > 0) {
 462
 463         if (w < scr->workspace_count)
 464             wWorkspaceChange(scr, w);
 465         else if (wPreferences.ws_advance)
 466             wWorkspaceChange(scr, WMIN(w, MAX_WORKSPACES-1));
 467         else if (wPreferences.ws_cycle)
 468             wWorkspaceChange(scr, w % scr->workspace_count);
 469     }
 470 }
 471
 472
 473
 474 void
 475 wWorkspaceForceChange(WScreen *scr, int workspace)
 476 {
 477     WWindow *tmp, *foc=NULL, *foc2=NULL;
 478
 479     if (workspace >= MAX_WORKSPACES || workspace < 0)
 480         return;
 481
 482     SendHelperMessage(scr, 'C', workspace+1, NULL);
 483
 484     if (workspace > scr->workspace_count-1) {
 485         wWorkspaceMake(scr, workspace - scr->workspace_count + 1);
 486     }
 487
 488     wClipUpdateForWorkspaceChange(scr, workspace);
 489
 490     scr->current_workspace = workspace;
 491
 492     wWorkspaceMenuUpdate(scr, scr->workspace_menu);
 493
 494     wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
 495
 496     if ((tmp = scr->focused_window)!= NULL) {
 497         if ((IS_OMNIPRESENT(tmp) && (tmp->flags.mapped || tmp->flags.shaded)
 498              && !WFLAGP(tmp, no_focusable))
 499             || tmp->flags.changing_workspace) {
 500             foc = tmp;
 501         }
 502
 503         /* foc2 = tmp; will fix annoyance with gnome panel
 504          * but will create annoyance for every other application
 505          */
 506
 507         while (tmp) {
 508             if (tmp->frame->workspace!=workspace && !tmp->flags.selected) {
 509                 /* unmap windows not on this workspace */
 510                 if ((tmp->flags.mapped||tmp->flags.shaded)
 511                     && !IS_OMNIPRESENT(tmp)
 512                     && !tmp->flags.changing_workspace) {
 513
 514                     wWindowUnmap(tmp);
 515                 }
 516                 /* also unmap miniwindows not on this workspace */
 517                 if (!wPreferences.sticky_icons && tmp->flags.miniaturized &&
 518                     tmp->icon && !IS_OMNIPRESENT(tmp)) {
 519
 520                     XUnmapWindow(dpy, tmp->icon->core->window);
 521                     tmp->icon->mapped = 0;
 522                 }
 523                 /* update current workspace of omnipresent windows */
 524                 if (IS_OMNIPRESENT(tmp)) {
 525                     WApplication *wapp = wApplicationOf(tmp->main_window);
 526
 527                     tmp->frame->workspace = workspace;
 528
 529                     if (wapp) {
 530                         wapp->last_workspace = workspace;
 531                     }
 532                     if (!foc2 && (tmp->flags.mapped || tmp->flags.shaded))
 533                         foc2 = tmp;
 534                 }
 535             } else {
 536                 /* change selected windows' workspace */
 537                 if (tmp->flags.selected) {
 538                     wWindowChangeWorkspace(tmp, workspace);
 539                     if (!tmp->flags.miniaturized && !foc) {
 540                         foc = tmp;
 541                     }
 542                 } else {
 543                     if (!tmp->flags.hidden) {
 544                         if (!(tmp->flags.mapped || tmp->flags.miniaturized)) {
 545                             /* remap windows that are on this workspace */
 546                             wWindowMap(tmp);
 547                             if (!foc && !WFLAGP(tmp, no_focusable))
 548                                 foc = tmp;
 549                         }
 550                         /* Also map miniwindow if not omnipresent */
 551                         if (!wPreferences.sticky_icons &&
 552                             tmp->flags.miniaturized &&
 553                             !IS_OMNIPRESENT(tmp) && tmp->icon) {
 554                             tmp->icon->mapped = 1;
 555                             XMapWindow(dpy, tmp->icon->core->window);
 556                         }
 557                     }
 558                 }
 559             }
 560             tmp = tmp->prev;
 561         }
 562
 563         if (!foc)
 564             foc = foc2;
 565
 566         if (scr->focused_window->flags.mapped && !foc) {
 567             foc = scr->focused_window;
 568         }
 569         if (wPreferences.focus_mode == WKF_CLICK) {
 570             wSetFocusTo(scr, foc);
 571         } else {
 572             unsigned int mask;
 573             int foo;
 574             Window bar, win;
 575             WWindow *tmp;
 576
 577             tmp = NULL;
 578             if (XQueryPointer(dpy, scr->root_win, &bar, &win,
 579                               &foo, &foo, &foo, &foo, &mask)) {
 580                 tmp = wWindowFor(win);
 581             }
 582             if (!tmp && wPreferences.focus_mode == WKF_SLOPPY) {
 583                 wSetFocusTo(scr, foc);
 584             } else {
 585                 wSetFocusTo(scr, tmp);
 586             }
 587         }
 588     }
 589
 590     /* We need to always arrange icons when changing workspace, even if
 591      * no autoarrange icons, because else the icons in different workspaces
 592      * can be superposed.
 593      * This can be avoided if appicons are also workspace specific.
 594      */
 595     if (!wPreferences.sticky_icons)
 596         wArrangeIcons(scr, False);
 597
 598     if (scr->dock)
 599         wAppIconPaint(scr->dock->icon_array[0]);
 600
 601     if (scr->clip_icon) {
 602         if (scr->workspaces[workspace]->clip->auto_collapse ||
 603             scr->workspaces[workspace]->clip->auto_raise_lower) {
 604             /* to handle enter notify. This will also */
 605             XUnmapWindow(dpy, scr->clip_icon->icon->core->window);
 606             XMapWindow(dpy, scr->clip_icon->icon->core->window);
 607         } else {
 608             wClipIconPaint(scr->clip_icon);
 609         }
 610     }
 611
 612 #ifdef KWM_HINTS
 613     wScreenUpdateUsableArea(scr);
 614 #endif
 615
 616     showWorkspaceName(scr, workspace);
 617
 618     WMPostNotificationName(WMNWorkspaceChanged, scr, (void*)workspace);
 619
 620 /*   XSync(dpy, False); */
 621 }
 622
 623 #ifdef VIRTUAL_DESKTOP
 624 /* TODO:
 625 * 1) Allow border around each window so the scrolling
 626 * won't just stop at the border.
 627 * 2) Make pager.
 628 */
 629
 630 void
 631 wWorkspaceManageEdge(WScreen *scr)
 632 {
 633     int w;
 634     int vmask;
 635     XSetWindowAttributes attribs;
 636
 637     /* puts("wWorkspaceManageEdge()"); */
 638     if (wPreferences.vedge_thickness) {
 639         initVDesk = True;
 640         for (w = 0; w < scr->workspace_count; w++) {
 641             /* puts("reset workspace"); */
 642             wWorkspaceSetViewPort(scr, w, 0, 0);
 643         }
 644
 645         vmask = CWEventMask|CWOverrideRedirect;
 646         attribs.event_mask = (EnterWindowMask | LeaveWindowMask | VisibilityChangeMask);
 647         attribs.override_redirect = True;
 648         scr->virtual_edge_u =
 649             XCreateWindow(dpy, scr->root_win, 0, 0,
 650                     scr->scr_width, wPreferences.vedge_thickness, 0,
 651                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 652         scr->virtual_edge_d =
 653             XCreateWindow(dpy, scr->root_win, 0, scr->scr_height-wPreferences.vedge_thickness,
 654                     scr->scr_width, wPreferences.vedge_thickness, 0,
 655                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 656         scr->virtual_edge_l =
 657             XCreateWindow(dpy, scr->root_win, 0, 0,
 658                     wPreferences.vedge_thickness, scr->scr_height, 0,
 659                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 660         scr->virtual_edge_r =
 661             XCreateWindow(dpy, scr->root_win, scr->scr_width-wPreferences.vedge_thickness, 0,
 662                     wPreferences.vedge_thickness, scr->scr_height, 0,
 663                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 664         XMapWindow(dpy, scr->virtual_edge_u);
 665         XMapWindow(dpy, scr->virtual_edge_d);
 666         XMapWindow(dpy, scr->virtual_edge_l);
 667         XMapWindow(dpy, scr->virtual_edge_r);
 668         wWorkspaceRaiseEdge(scr);
 669     }
 670 }
 671
 672 void
 673 wWorkspaceRaiseEdge(WScreen *scr)
 674 {
 675     puts("raise edge");
 676     if (wPreferences.vedge_thickness && initVDesk) {
 677         XRaiseWindow(dpy, scr->virtual_edge_u);
 678         XRaiseWindow(dpy, scr->virtual_edge_d);
 679         XRaiseWindow(dpy, scr->virtual_edge_l);
 680         XRaiseWindow(dpy, scr->virtual_edge_r);
 681     }
 682 }
 683
 684 void
 685 wWorkspaceLowerEdge(WScreen *scr)
 686 {
 687     puts("lower edge");
 688     if (wPreferences.vedge_thickness && initVDesk) {
 689         XLowerWindow(dpy, scr->virtual_edge_u);
 690         XLowerWindow(dpy, scr->virtual_edge_d);
 691         XLowerWindow(dpy, scr->virtual_edge_l);
 692         XLowerWindow(dpy, scr->virtual_edge_r);
 693     }
 694 }
 695
 696 void
 697 wWorkspaceResizeViewPort(WScreen *scr, int workspace, int width, int height)
 698 {
 699     scr->workspaces[workspace]->width = WMAX(width,scr->scr_width);
 700     scr->workspaces[workspace]->height = WMAX(height,scr->scr_height);
 701 }
 702
 703 void
 704 updateWorkspaceGeometry(WScreen *scr, int workspace, int *view_x, int *view_y)
 705 {
 706     int most_left, most_right, most_top, most_bottom;
 707     WWindow *wwin;
 708
 709     /* adjust workspace layout */
 710     wwin = scr->focused_window;
 711     most_right = scr->scr_width;
 712     most_bottom = scr->scr_height;
 713     most_left = 0;
 714     most_top = 0;
 715     for(;wwin; wwin = wwin->prev) {
 716         if (wwin->frame->workspace == workspace) {
 717             if (!wwin->flags.miniaturized
 718                     && !wwin->flags.hidden) {
 719                 if (wwin->frame_x < most_left) { /* record positions, should this be cached? */
 720                     most_left = wwin->frame_x;
 721                 }
 722                 if ((int)wwin->frame_x + (int)wwin->frame->core->width > most_right) {
 723                     most_right = wwin->frame_x + wwin->frame->core->width;
 724                 }
 725                 if (wwin->frame_y < most_top) {
 726                     most_top = wwin->frame_y;
 727                 }
 728                 if (wwin->frame_y + wwin->frame->core->height > most_bottom) {
 729                     most_bottom = wwin->frame_y + wwin->frame->core->height;
 730                 }
 731             }
 732         }
 733     }
 734
 735     scr->workspaces[workspace]->width = WMAX(most_right, scr->scr_width) - WMIN(most_left, 0);
 736     scr->workspaces[workspace]->height = WMAX(most_bottom, scr->scr_height) - WMIN(most_top, 0);
 737
 738     *view_x += -most_left - scr->workspaces[workspace]->view_x;
 739     scr->workspaces[workspace]->view_x = -most_left;
 740
 741     *view_y += -most_top - scr->workspaces[workspace]->view_y;
 742     scr->workspaces[workspace]->view_y = -most_top;
 743
 744 }
 745
 746
 747 typedef struct _delay_configure {
 748     WWindow *wwin;
 749     int delay_count;
 750 } _delay_configure;
 751
 752
 753 void
 754 sendConfigureNotify (_delay_configure *delay)
 755 {
 756     WWindow *wwin;
 757
 758     delay->delay_count--;
 759     if (!delay->delay_count) {
 760         for (wwin = delay->wwin; wwin; wwin = wwin->prev) {
 761             wWindowSynthConfigureNotify(wwin);
 762         }
 763     }
 764 }
 765
 766
 767 Bool
 768 wWorkspaceSetViewPort(WScreen *scr, int workspace, int view_x, int view_y)
 769 {
 770     Bool adjust_flag = False;
 771     int diff_x, diff_y;
 772     static _delay_configure delay_configure = {NULL, 0};
 773     WWindow *wwin;
 774
 775     /*printf("wWorkspaceSetViewPort %d %d\n", view_x, view_y);*/
 776
 777     updateWorkspaceGeometry(scr, workspace, &view_x, &view_y);
 778
 779     if (view_x + scr->scr_width > scr->workspaces[workspace]->width) {
 780         /* puts("right edge of vdesk"); */
 781         view_x = scr->workspaces[workspace]->width - scr->scr_width;
 782     }
 783     if (view_x < 0) {
 784         /* puts("left edge of vdesk"); */
 785         view_x = 0;
 786     }
 787     if (view_y + scr->scr_height > scr->workspaces[workspace]->height) {
 788         /* puts("right edge of vdesk"); */
 789         view_y = scr->workspaces[workspace]->height - scr->scr_height;
 790     }
 791     if (view_y < 0) {
 792         /* puts("left edge of vdesk"); */
 793         view_y = 0;
 794     }
 795
 796     diff_x = scr->workspaces[workspace]->view_x - view_x;
 797     diff_y = scr->workspaces[workspace]->view_y - view_y;
 798     if (!diff_x && !diff_y)
 799         return False;
 800
 801     scr->workspaces[workspace]->view_x = view_x;
 802     scr->workspaces[workspace]->view_y = view_y;
 803
 804
 805     for (wwin = scr->focused_window; wwin; wwin = wwin->prev) {
 806         if (wwin->frame->workspace == workspace) {
 807             wWindowMove(wwin, wwin->frame_x + diff_x, wwin->frame_y + diff_y);
 808         }
 809     }
 810     if (1) { /* if delay*/
 811         delay_configure.delay_count++;
 812         delay_configure.wwin = scr->focused_window;
 813         WMAddTimerHandler(200, (WMCallback *)sendConfigureNotify, &delay_configure);
 814     }
 815
 816     return adjust_flag;
 817 }
 818
 819
 820 void
 821 wWorkspaceGetViewPosition(WScreen *scr, int workspace, int *view_x, int *view_y)
 822 {
 823     if (view_x) *view_x = scr->workspaces[workspace]->view_x;
 824     if (view_y) *view_y = scr->workspaces[workspace]->view_y;
 825 }
 826 #endif
 827
 828
 829
 830 static void
 831 switchWSCommand(WMenu *menu, WMenuEntry *entry)
 832 {
 833     wWorkspaceChange(menu->frame->screen_ptr, (long)entry->clientdata);
 834 }
 835
 836
 837
 838 static void
 839 deleteWSCommand(WMenu *menu, WMenuEntry *entry)
 840 {
 841     wWorkspaceDelete(menu->frame->screen_ptr,
 842                      menu->frame->screen_ptr->workspace_count-1);
 843 }
 844
 845
 846
 847 static void
 848 newWSCommand(WMenu *menu, WMenuEntry *foo)
 849 {
 850     int ws;
 851
 852     ws = wWorkspaceNew(menu->frame->screen_ptr);
 853     /* autochange workspace*/
 854     if (ws>=0)
 855         wWorkspaceChange(menu->frame->screen_ptr, ws);
 856
 857
 858     /*
 859     if (ws<9) {
 860         int kcode;
 861         if (wKeyBindings[WKBD_WORKSPACE1+ws]) {
 862             kcode = wKeyBindings[WKBD_WORKSPACE1+ws]->keycode;
 863             entry->rtext =
 864               wstrdup(XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0)));
 865         }
 866     }*/
 867 }
 868
 869
 870 static char*
 871 cropline(char *line)
 872 {
 873     char *start, *end;
 874
 875     if (strlen(line)==0)
 876         return line;
 877
 878     start = line;
 879     end = &(line[strlen(line)])-1;
 880     while (isspace(*line) && *line!=0) line++;
 881     while (isspace(*end) && end!=line) {
 882         *end=0;
 883         end--;
 884     }
 885     return line;
 886 }
 887
 888
 889 void
 890 wWorkspaceRename(WScreen *scr, int workspace, char *name)
 891 {
 892     char buf[MAX_WORKSPACENAME_WIDTH+1];
 893     char *tmp;
 894
 895     if (workspace >= scr->workspace_count)
 896         return;
 897
 898     /* trim white spaces */
 899     tmp = cropline(name);
 900
 901     if (strlen(tmp)==0) {
 902         sprintf(buf, _("Workspace %i"), workspace+1);
 903     } else {
 904         strncpy(buf, tmp, MAX_WORKSPACENAME_WIDTH);
 905     }
 906     buf[MAX_WORKSPACENAME_WIDTH] = 0;
 907
 908     /* update workspace */
 909     wfree(scr->workspaces[workspace]->name);
 910     scr->workspaces[workspace]->name = wstrdup(buf);
 911
 912     if (scr->clip_ws_menu) {
 913         if (strcmp(scr->clip_ws_menu->entries[workspace+2]->text, buf)!=0) {
 914             wfree(scr->clip_ws_menu->entries[workspace+2]->text);
 915             scr->clip_ws_menu->entries[workspace+2]->text = wstrdup(buf);
 916             wMenuRealize(scr->clip_ws_menu);
 917         }
 918     }
 919     if (scr->workspace_menu) {
 920         if (strcmp(scr->workspace_menu->entries[workspace+2]->text, buf)!=0) {
 921             wfree(scr->workspace_menu->entries[workspace+2]->text);
 922             scr->workspace_menu->entries[workspace+2]->text = wstrdup(buf);
 923             wMenuRealize(scr->workspace_menu);
 924         }
 925     }
 926
 927     if (scr->clip_icon)
 928         wClipIconPaint(scr->clip_icon);
 929
 930     WMPostNotificationName(WMNWorkspaceNameChanged, scr, (void*)workspace);
 931 }
 932
 933
 934
 935
 936 /* callback for when menu entry is edited */
 937 static void
 938 onMenuEntryEdited(WMenu *menu, WMenuEntry *entry)
 939 {
 940     char *tmp;
 941
 942     tmp = entry->text;
 943     wWorkspaceRename(menu->frame->screen_ptr, (long)entry->clientdata, tmp);
 944 }
 945
 946
 947 WMenu*
 948 wWorkspaceMenuMake(WScreen *scr, Bool titled)
 949 {
 950     WMenu *wsmenu;
 951
 952     wsmenu = wMenuCreate(scr, titled ? _("Workspaces") : NULL, False);
 953     if (!wsmenu) {
 954         wwarning(_("could not create Workspace menu"));
 955         return NULL;
 956     }
 957
 958     /* callback to be called when an entry is edited */
 959     wsmenu->on_edit = onMenuEntryEdited;
 960
 961     wMenuAddCallback(wsmenu, _("New"), newWSCommand, NULL);
 962     wMenuAddCallback(wsmenu, _("Destroy Last"), deleteWSCommand, NULL);
 963
 964     return wsmenu;
 965 }
 966
 967
 968
 969 void
 970 wWorkspaceMenuUpdate(WScreen *scr, WMenu *menu)
 971 {
 972     int i;
 973     long ws;
 974     char title[MAX_WORKSPACENAME_WIDTH+1];
 975     WMenuEntry *entry;
 976     int tmp;
 977
 978     if (!menu)
 979         return;
 980
 981     if (menu->entry_no < scr->workspace_count+2) {
 982         /* new workspace(s) added */
 983         i = scr->workspace_count-(menu->entry_no-2);
 984         ws = menu->entry_no - 2;
 985         while (i>0) {
 986             strcpy(title, scr->workspaces[ws]->name);
 987
 988             entry = wMenuAddCallback(menu, title, switchWSCommand, (void*)ws);
 989             entry->flags.indicator = 1;
 990             entry->flags.editable = 1;
 991
 992             i--;
 993             ws++;
 994         }
 995     } else if (menu->entry_no > scr->workspace_count+2) {
 996         /* removed workspace(s) */
 997         for (i = menu->entry_no-1; i >= scr->workspace_count+2; i--) {
 998             wMenuRemoveItem(menu, i);
 999         }
1000     }
1001     wMenuRealize(menu);
1002
1003     for (i=0; i<scr->workspace_count; i++) {
1004         menu->entries[i+2]->flags.indicator_on = 0;
1005     }
1006     menu->entries[scr->current_workspace+2]->flags.indicator_on = 1;
1007
1008     /* don't let user destroy current workspace */
1009     if (scr->current_workspace == scr->workspace_count-1) {
1010         wMenuSetEnabled(menu, 1, False);
1011     } else {
1012         wMenuSetEnabled(menu, 1, True);
1013     }
1014
1015     tmp = menu->frame->top_width + 5;
1016     /* if menu got unreachable, bring it to a visible place */
1017     if (menu->frame_x < tmp - (int)menu->frame->core->width)
1018         wMenuMove(menu, tmp - (int)menu->frame->core->width, menu->frame_y, False);
1019
1020     wMenuPaint(menu);
1021 }
1022
1023
1024 void
1025 wWorkspaceSaveState(WScreen *scr, WMPropList *old_state)
1026 {
1027     WMPropList *parr, *pstr, *wks_state, *old_wks_state, *foo, *bar;
1028     int i;
1029
1030     make_keys();
1031
1032     old_wks_state = WMGetFromPLDictionary(old_state, dWorkspaces);
1033     parr = WMCreatePLArray(NULL);
1034     for (i=0; i < scr->workspace_count; i++) {
1035         pstr = WMCreatePLString(scr->workspaces[i]->name);
1036         wks_state = WMCreatePLDictionary(dName, pstr, NULL);
1037         WMReleasePropList(pstr);
1038         if (!wPreferences.flags.noclip) {
1039             pstr = wClipSaveWorkspaceState(scr, i);
1040             WMPutInPLDictionary(wks_state, dClip, pstr);
1041             WMReleasePropList(pstr);
1042         } else if (old_wks_state!=NULL) {
1043             if ((foo = WMGetFromPLArray(old_wks_state, i))!=NULL) {
1044                 if ((bar = WMGetFromPLDictionary(foo, dClip))!=NULL) {
1045                     WMPutInPLDictionary(wks_state, dClip, bar);
1046                 }
1047             }
1048         }
1049         WMAddToPLArray(parr, wks_state);
1050         WMReleasePropList(wks_state);
1051     }
1052     WMPutInPLDictionary(scr->session_state, dWorkspaces, parr);
1053     WMReleasePropList(parr);
1054 }
1055
1056
1057 void
1058 wWorkspaceRestoreState(WScreen *scr)
1059 {
1060     WMPropList *parr, *pstr, *wks_state, *clip_state;
1061     int i, j, wscount;
1062
1063     make_keys();
1064
1065     if (scr->session_state == NULL)
1066         return;
1067
1068     parr = WMGetFromPLDictionary(scr->session_state, dWorkspaces);
1069
1070     if (!parr)
1071         return;
1072
1073     wscount = scr->workspace_count;
1074     for (i=0; i < WMIN(WMGetPropListItemCount(parr), MAX_WORKSPACES); i++) {
1075         wks_state = WMGetFromPLArray(parr, i);
1076         if (WMIsPLDictionary(wks_state))
1077             pstr = WMGetFromPLDictionary(wks_state, dName);
1078         else
1079             pstr = wks_state;
1080         if (i >= scr->workspace_count)
1081             wWorkspaceNew(scr);
1082         if (scr->workspace_menu) {
1083             wfree(scr->workspace_menu->entries[i+2]->text);
1084             scr->workspace_menu->entries[i+2]->text = wstrdup(WMGetFromPLString(pstr));
1085             scr->workspace_menu->flags.realized = 0;
1086         }
1087         wfree(scr->workspaces[i]->name);
1088         scr->workspaces[i]->name = wstrdup(WMGetFromPLString(pstr));
1089         if (!wPreferences.flags.noclip) {
1090             clip_state = WMGetFromPLDictionary(wks_state, dClip);
1091             if (scr->workspaces[i]->clip)
1092                 wDockDestroy(scr->workspaces[i]->clip);
1093             scr->workspaces[i]->clip = wDockRestoreState(scr, clip_state,
1094                                                          WM_CLIP);
1095             if (i>0)
1096                 wDockHideIcons(scr->workspaces[i]->clip);
1097
1098             /* We set the global icons here, because scr->workspaces[i]->clip
1099              * was not valid in wDockRestoreState().
1100              * There we only set icon->omnipresent to know which icons we
1101              * need to set here.
1102              */
1103             for (j=0; j<scr->workspaces[i]->clip->max_icons; j++) {
1104                 WAppIcon *aicon = scr->workspaces[i]->clip->icon_array[j];
1105
1106                 if (aicon && aicon->omnipresent) {
1107                     aicon->omnipresent = 0;
1108                     wClipMakeIconOmnipresent(aicon, True);
1109                     XMapWindow(dpy, aicon->icon->core->window);
1110                 }
1111             }
1112         }
1113
1114         WMPostNotificationName(WMNWorkspaceNameChanged, scr, (void*)i);
1115     }
1116 }
1117
1118