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     showWorkspaceName(scr, workspace);
 613
 614     WMPostNotificationName(WMNWorkspaceChanged, scr, (void*)workspace);
 615
 616 /*   XSync(dpy, False); */
 617 }
 618
 619 #ifdef VIRTUAL_DESKTOP
 620 /* TODO:
 621 * 1) Allow border around each window so the scrolling
 622 * won't just stop at the border.
 623 * 2) Make pager.
 624 */
 625
 626 void
 627 wWorkspaceManageEdge(WScreen *scr)
 628 {
 629     int w;
 630     int vmask;
 631     XSetWindowAttributes attribs;
 632
 633     /* puts("wWorkspaceManageEdge()"); */
 634     if (wPreferences.vedge_thickness) {
 635         initVDesk = True;
 636         for (w = 0; w < scr->workspace_count; w++) {
 637             /* puts("reset workspace"); */
 638             wWorkspaceSetViewPort(scr, w, 0, 0);
 639         }
 640
 641         vmask = CWEventMask|CWOverrideRedirect;
 642         attribs.event_mask = (EnterWindowMask | LeaveWindowMask | VisibilityChangeMask);
 643         attribs.override_redirect = True;
 644         scr->virtual_edge_u =
 645             XCreateWindow(dpy, scr->root_win, 0, 0,
 646                     scr->scr_width, wPreferences.vedge_thickness, 0,
 647                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 648         scr->virtual_edge_d =
 649             XCreateWindow(dpy, scr->root_win, 0, scr->scr_height-wPreferences.vedge_thickness,
 650                     scr->scr_width, wPreferences.vedge_thickness, 0,
 651                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 652         scr->virtual_edge_l =
 653             XCreateWindow(dpy, scr->root_win, 0, 0,
 654                     wPreferences.vedge_thickness, scr->scr_height, 0,
 655                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 656         scr->virtual_edge_r =
 657             XCreateWindow(dpy, scr->root_win, scr->scr_width-wPreferences.vedge_thickness, 0,
 658                     wPreferences.vedge_thickness, scr->scr_height, 0,
 659                     CopyFromParent, InputOnly, CopyFromParent, vmask, &attribs);
 660         XMapWindow(dpy, scr->virtual_edge_u);
 661         XMapWindow(dpy, scr->virtual_edge_d);
 662         XMapWindow(dpy, scr->virtual_edge_l);
 663         XMapWindow(dpy, scr->virtual_edge_r);
 664         wWorkspaceRaiseEdge(scr);
 665     }
 666 }
 667
 668 void
 669 wWorkspaceRaiseEdge(WScreen *scr)
 670 {
 671     puts("raise edge");
 672     if (wPreferences.vedge_thickness && initVDesk) {
 673         XRaiseWindow(dpy, scr->virtual_edge_u);
 674         XRaiseWindow(dpy, scr->virtual_edge_d);
 675         XRaiseWindow(dpy, scr->virtual_edge_l);
 676         XRaiseWindow(dpy, scr->virtual_edge_r);
 677     }
 678 }
 679
 680 void
 681 wWorkspaceLowerEdge(WScreen *scr)
 682 {
 683     puts("lower edge");
 684     if (wPreferences.vedge_thickness && initVDesk) {
 685         XLowerWindow(dpy, scr->virtual_edge_u);
 686         XLowerWindow(dpy, scr->virtual_edge_d);
 687         XLowerWindow(dpy, scr->virtual_edge_l);
 688         XLowerWindow(dpy, scr->virtual_edge_r);
 689     }
 690 }
 691
 692 void
 693 wWorkspaceResizeViewPort(WScreen *scr, int workspace, int width, int height)
 694 {
 695     scr->workspaces[workspace]->width = WMAX(width,scr->scr_width);
 696     scr->workspaces[workspace]->height = WMAX(height,scr->scr_height);
 697 }
 698
 699 void
 700 updateWorkspaceGeometry(WScreen *scr, int workspace, int *view_x, int *view_y)
 701 {
 702     int most_left, most_right, most_top, most_bottom;
 703     WWindow *wwin;
 704
 705     /* adjust workspace layout */
 706     wwin = scr->focused_window;
 707     most_right = scr->scr_width;
 708     most_bottom = scr->scr_height;
 709     most_left = 0;
 710     most_top = 0;
 711     for(;wwin; wwin = wwin->prev) {
 712         if (wwin->frame->workspace == workspace) {
 713             if (!wwin->flags.miniaturized
 714                     && !wwin->flags.hidden) {
 715                 if (wwin->frame_x < most_left) { /* record positions, should this be cached? */
 716                     most_left = wwin->frame_x;
 717                 }
 718                 if ((int)wwin->frame_x + (int)wwin->frame->core->width > most_right) {
 719                     most_right = wwin->frame_x + wwin->frame->core->width;
 720                 }
 721                 if (wwin->frame_y < most_top) {
 722                     most_top = wwin->frame_y;
 723                 }
 724                 if (wwin->frame_y + wwin->frame->core->height > most_bottom) {
 725                     most_bottom = wwin->frame_y + wwin->frame->core->height;
 726                 }
 727             }
 728         }
 729     }
 730
 731     scr->workspaces[workspace]->width = WMAX(most_right, scr->scr_width) - WMIN(most_left, 0);
 732     scr->workspaces[workspace]->height = WMAX(most_bottom, scr->scr_height) - WMIN(most_top, 0);
 733
 734     *view_x += -most_left - scr->workspaces[workspace]->view_x;
 735     scr->workspaces[workspace]->view_x = -most_left;
 736
 737     *view_y += -most_top - scr->workspaces[workspace]->view_y;
 738     scr->workspaces[workspace]->view_y = -most_top;
 739
 740 }
 741
 742
 743 typedef struct _delay_configure {
 744     WWindow *wwin;
 745     int delay_count;
 746 } _delay_configure;
 747
 748
 749 void
 750 sendConfigureNotify (_delay_configure *delay)
 751 {
 752     WWindow *wwin;
 753
 754     delay->delay_count--;
 755     if (!delay->delay_count) {
 756         for (wwin = delay->wwin; wwin; wwin = wwin->prev) {
 757             wWindowSynthConfigureNotify(wwin);
 758         }
 759     }
 760 }
 761
 762
 763 Bool
 764 wWorkspaceSetViewPort(WScreen *scr, int workspace, int view_x, int view_y)
 765 {
 766     Bool adjust_flag = False;
 767     int diff_x, diff_y;
 768     static _delay_configure delay_configure = {NULL, 0};
 769     WWindow *wwin;
 770
 771     /*printf("wWorkspaceSetViewPort %d %d\n", view_x, view_y);*/
 772
 773     updateWorkspaceGeometry(scr, workspace, &view_x, &view_y);
 774
 775     if (view_x + scr->scr_width > scr->workspaces[workspace]->width) {
 776         /* puts("right edge of vdesk"); */
 777         view_x = scr->workspaces[workspace]->width - scr->scr_width;
 778     }
 779     if (view_x < 0) {
 780         /* puts("left edge of vdesk"); */
 781         view_x = 0;
 782     }
 783     if (view_y + scr->scr_height > scr->workspaces[workspace]->height) {
 784         /* puts("right edge of vdesk"); */
 785         view_y = scr->workspaces[workspace]->height - scr->scr_height;
 786     }
 787     if (view_y < 0) {
 788         /* puts("left edge of vdesk"); */
 789         view_y = 0;
 790     }
 791
 792     diff_x = scr->workspaces[workspace]->view_x - view_x;
 793     diff_y = scr->workspaces[workspace]->view_y - view_y;
 794     if (!diff_x && !diff_y)
 795         return False;
 796
 797     scr->workspaces[workspace]->view_x = view_x;
 798     scr->workspaces[workspace]->view_y = view_y;
 799
 800
 801     for (wwin = scr->focused_window; wwin; wwin = wwin->prev) {
 802         if (wwin->frame->workspace == workspace) {
 803             wWindowMove(wwin, wwin->frame_x + diff_x, wwin->frame_y + diff_y);
 804         }
 805     }
 806     if (1) { /* if delay*/
 807         delay_configure.delay_count++;
 808         delay_configure.wwin = scr->focused_window;
 809         WMAddTimerHandler(200, (WMCallback *)sendConfigureNotify, &delay_configure);
 810     }
 811
 812     return adjust_flag;
 813 }
 814
 815
 816 void
 817 wWorkspaceGetViewPosition(WScreen *scr, int workspace, int *view_x, int *view_y)
 818 {
 819     if (view_x) *view_x = scr->workspaces[workspace]->view_x;
 820     if (view_y) *view_y = scr->workspaces[workspace]->view_y;
 821 }
 822 #endif
 823
 824
 825
 826 static void
 827 switchWSCommand(WMenu *menu, WMenuEntry *entry)
 828 {
 829     wWorkspaceChange(menu->frame->screen_ptr, (long)entry->clientdata);
 830 }
 831
 832
 833
 834 static void
 835 deleteWSCommand(WMenu *menu, WMenuEntry *entry)
 836 {
 837     wWorkspaceDelete(menu->frame->screen_ptr,
 838                      menu->frame->screen_ptr->workspace_count-1);
 839 }
 840
 841
 842
 843 static void
 844 newWSCommand(WMenu *menu, WMenuEntry *foo)
 845 {
 846     int ws;
 847
 848     ws = wWorkspaceNew(menu->frame->screen_ptr);
 849     /* autochange workspace*/
 850     if (ws>=0)
 851         wWorkspaceChange(menu->frame->screen_ptr, ws);
 852
 853
 854     /*
 855     if (ws<9) {
 856         int kcode;
 857         if (wKeyBindings[WKBD_WORKSPACE1+ws]) {
 858             kcode = wKeyBindings[WKBD_WORKSPACE1+ws]->keycode;
 859             entry->rtext =
 860               wstrdup(XKeysymToString(XKeycodeToKeysym(dpy, kcode, 0)));
 861         }
 862     }*/
 863 }
 864
 865
 866 static char*
 867 cropline(char *line)
 868 {
 869     char *start, *end;
 870
 871     if (strlen(line)==0)
 872         return line;
 873
 874     start = line;
 875     end = &(line[strlen(line)])-1;
 876     while (isspace(*line) && *line!=0) line++;
 877     while (isspace(*end) && end!=line) {
 878         *end=0;
 879         end--;
 880     }
 881     return line;
 882 }
 883
 884
 885 void
 886 wWorkspaceRename(WScreen *scr, int workspace, char *name)
 887 {
 888     char buf[MAX_WORKSPACENAME_WIDTH+1];
 889     char *tmp;
 890
 891     if (workspace >= scr->workspace_count)
 892         return;
 893
 894     /* trim white spaces */
 895     tmp = cropline(name);
 896
 897     if (strlen(tmp)==0) {
 898         sprintf(buf, _("Workspace %i"), workspace+1);
 899     } else {
 900         strncpy(buf, tmp, MAX_WORKSPACENAME_WIDTH);
 901     }
 902     buf[MAX_WORKSPACENAME_WIDTH] = 0;
 903
 904     /* update workspace */
 905     wfree(scr->workspaces[workspace]->name);
 906     scr->workspaces[workspace]->name = wstrdup(buf);
 907
 908     if (scr->clip_ws_menu) {
 909         if (strcmp(scr->clip_ws_menu->entries[workspace+2]->text, buf)!=0) {
 910             wfree(scr->clip_ws_menu->entries[workspace+2]->text);
 911             scr->clip_ws_menu->entries[workspace+2]->text = wstrdup(buf);
 912             wMenuRealize(scr->clip_ws_menu);
 913         }
 914     }
 915     if (scr->workspace_menu) {
 916         if (strcmp(scr->workspace_menu->entries[workspace+2]->text, buf)!=0) {
 917             wfree(scr->workspace_menu->entries[workspace+2]->text);
 918             scr->workspace_menu->entries[workspace+2]->text = wstrdup(buf);
 919             wMenuRealize(scr->workspace_menu);
 920         }
 921     }
 922
 923     if (scr->clip_icon)
 924         wClipIconPaint(scr->clip_icon);
 925
 926     WMPostNotificationName(WMNWorkspaceNameChanged, scr, (void*)workspace);
 927 }
 928
 929
 930
 931
 932 /* callback for when menu entry is edited */
 933 static void
 934 onMenuEntryEdited(WMenu *menu, WMenuEntry *entry)
 935 {
 936     char *tmp;
 937
 938     tmp = entry->text;
 939     wWorkspaceRename(menu->frame->screen_ptr, (long)entry->clientdata, tmp);
 940 }
 941
 942
 943 WMenu*
 944 wWorkspaceMenuMake(WScreen *scr, Bool titled)
 945 {
 946     WMenu *wsmenu;
 947
 948     wsmenu = wMenuCreate(scr, titled ? _("Workspaces") : NULL, False);
 949     if (!wsmenu) {
 950         wwarning(_("could not create Workspace menu"));
 951         return NULL;
 952     }
 953
 954     /* callback to be called when an entry is edited */
 955     wsmenu->on_edit = onMenuEntryEdited;
 956
 957     wMenuAddCallback(wsmenu, _("New"), newWSCommand, NULL);
 958     wMenuAddCallback(wsmenu, _("Destroy Last"), deleteWSCommand, NULL);
 959
 960     return wsmenu;
 961 }
 962
 963
 964
 965 void
 966 wWorkspaceMenuUpdate(WScreen *scr, WMenu *menu)
 967 {
 968     int i;
 969     long ws;
 970     char title[MAX_WORKSPACENAME_WIDTH+1];
 971     WMenuEntry *entry;
 972     int tmp;
 973
 974     if (!menu)
 975         return;
 976
 977     if (menu->entry_no < scr->workspace_count+2) {
 978         /* new workspace(s) added */
 979         i = scr->workspace_count-(menu->entry_no-2);
 980         ws = menu->entry_no - 2;
 981         while (i>0) {
 982             strcpy(title, scr->workspaces[ws]->name);
 983
 984             entry = wMenuAddCallback(menu, title, switchWSCommand, (void*)ws);
 985             entry->flags.indicator = 1;
 986             entry->flags.editable = 1;
 987
 988             i--;
 989             ws++;
 990         }
 991     } else if (menu->entry_no > scr->workspace_count+2) {
 992         /* removed workspace(s) */
 993         for (i = menu->entry_no-1; i >= scr->workspace_count+2; i--) {
 994             wMenuRemoveItem(menu, i);
 995         }
 996     }
 997     wMenuRealize(menu);
 998
 999     for (i=0; i<scr->workspace_count; i++) {
1000         menu->entries[i+2]->flags.indicator_on = 0;
1001     }
1002     menu->entries[scr->current_workspace+2]->flags.indicator_on = 1;
1003
1004     /* don't let user destroy current workspace */
1005     if (scr->current_workspace == scr->workspace_count-1) {
1006         wMenuSetEnabled(menu, 1, False);
1007     } else {
1008         wMenuSetEnabled(menu, 1, True);
1009     }
1010
1011     tmp = menu->frame->top_width + 5;
1012     /* if menu got unreachable, bring it to a visible place */
1013     if (menu->frame_x < tmp - (int)menu->frame->core->width)
1014         wMenuMove(menu, tmp - (int)menu->frame->core->width, menu->frame_y, False);
1015
1016     wMenuPaint(menu);
1017 }
1018
1019
1020 void
1021 wWorkspaceSaveState(WScreen *scr, WMPropList *old_state)
1022 {
1023     WMPropList *parr, *pstr, *wks_state, *old_wks_state, *foo, *bar;
1024     int i;
1025
1026     make_keys();
1027
1028     old_wks_state = WMGetFromPLDictionary(old_state, dWorkspaces);
1029     parr = WMCreatePLArray(NULL);
1030     for (i=0; i < scr->workspace_count; i++) {
1031         pstr = WMCreatePLString(scr->workspaces[i]->name);
1032         wks_state = WMCreatePLDictionary(dName, pstr, NULL);
1033         WMReleasePropList(pstr);
1034         if (!wPreferences.flags.noclip) {
1035             pstr = wClipSaveWorkspaceState(scr, i);
1036             WMPutInPLDictionary(wks_state, dClip, pstr);
1037             WMReleasePropList(pstr);
1038         } else if (old_wks_state!=NULL) {
1039             if ((foo = WMGetFromPLArray(old_wks_state, i))!=NULL) {
1040                 if ((bar = WMGetFromPLDictionary(foo, dClip))!=NULL) {
1041                     WMPutInPLDictionary(wks_state, dClip, bar);
1042                 }
1043             }
1044         }
1045         WMAddToPLArray(parr, wks_state);
1046         WMReleasePropList(wks_state);
1047     }
1048     WMPutInPLDictionary(scr->session_state, dWorkspaces, parr);
1049     WMReleasePropList(parr);
1050 }
1051
1052
1053 void
1054 wWorkspaceRestoreState(WScreen *scr)
1055 {
1056     WMPropList *parr, *pstr, *wks_state, *clip_state;
1057     int i, j, wscount;
1058
1059     make_keys();
1060
1061     if (scr->session_state == NULL)
1062         return;
1063
1064     parr = WMGetFromPLDictionary(scr->session_state, dWorkspaces);
1065
1066     if (!parr)
1067         return;
1068
1069     wscount = scr->workspace_count;
1070     for (i=0; i < WMIN(WMGetPropListItemCount(parr), MAX_WORKSPACES); i++) {
1071         wks_state = WMGetFromPLArray(parr, i);
1072         if (WMIsPLDictionary(wks_state))
1073             pstr = WMGetFromPLDictionary(wks_state, dName);
1074         else
1075             pstr = wks_state;
1076         if (i >= scr->workspace_count)
1077             wWorkspaceNew(scr);
1078         if (scr->workspace_menu) {
1079             wfree(scr->workspace_menu->entries[i+2]->text);
1080             scr->workspace_menu->entries[i+2]->text = wstrdup(WMGetFromPLString(pstr));
1081             scr->workspace_menu->flags.realized = 0;
1082         }
1083         wfree(scr->workspaces[i]->name);
1084         scr->workspaces[i]->name = wstrdup(WMGetFromPLString(pstr));
1085         if (!wPreferences.flags.noclip) {
1086             clip_state = WMGetFromPLDictionary(wks_state, dClip);
1087             if (scr->workspaces[i]->clip)
1088                 wDockDestroy(scr->workspaces[i]->clip);
1089             scr->workspaces[i]->clip = wDockRestoreState(scr, clip_state,
1090                                                          WM_CLIP);
1091             if (i>0)
1092                 wDockHideIcons(scr->workspaces[i]->clip);
1093
1094             /* We set the global icons here, because scr->workspaces[i]->clip
1095              * was not valid in wDockRestoreState().
1096              * There we only set icon->omnipresent to know which icons we
1097              * need to set here.
1098              */
1099             for (j=0; j<scr->workspaces[i]->clip->max_icons; j++) {
1100                 WAppIcon *aicon = scr->workspaces[i]->clip->icon_array[j];
1101
1102                 if (aicon && aicon->omnipresent) {
1103                     aicon->omnipresent = 0;
1104                     wClipMakeIconOmnipresent(aicon, True);
1105                     XMapWindow(dpy, aicon->icon->core->window);
1106                 }
1107             }
1108         }
1109
1110         WMPostNotificationName(WMNWorkspaceNameChanged, scr, (void*)i);
1111     }
1112 }
1113
1114