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 along
  18  *  with this program; if not, write to the Free Software Foundation, Inc.,
  19  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21 #include "wconfig.h"
  22
  23 #include <X11/Xlib.h>
  24 #include <X11/Xutil.h>
  25 #ifdef SHAPE
  26 #include <X11/extensions/shape.h>
  27 #endif
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <stdint.h>
  32 #include <unistd.h>
  33 #include <ctype.h>
  34 #include <string.h>
  35 #include <time.h>
  36 #include <sys/time.h>
  37
  38 #include "WindowMaker.h"
  39 #include "framewin.h"
  40 #include "window.h"
  41 #include "icon.h"
  42 #include "misc.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 #include "wmspec.h"
  50 #include "xinerama.h"
  51 #include "event.h"
  52
  53 #define MC_NEW          0
  54 #define MC_DESTROY_LAST 1
  55 #define MC_LAST_USED    2
  56 /* index of the first workspace menu entry */
  57 #define MC_WORKSPACE1   3
  58
  59 #define MAX_SHORTCUT_LENGTH 32
  60 #define WORKSPACE_NAME_DISPLAY_PADDING 32
  61
  62 extern int ignore_wks_change;
  63 extern WShortKey wKeyBindings[WKBD_LAST];
  64
  65 static WMPropList *dWorkspaces = NULL;
  66 static WMPropList *dClip, *dName;
  67
  68 static void make_keys(void)
  69 {
  70         if (dWorkspaces != NULL)
  71                 return;
  72
  73         dWorkspaces = WMCreatePLString("Workspaces");
  74         dName = WMCreatePLString("Name");
  75         dClip = WMCreatePLString("Clip");
  76 }
  77
  78 void wWorkspaceMake(WScreen * scr, int count)
  79 {
  80         while (count > 0) {
  81                 wWorkspaceNew(scr);
  82                 count--;
  83         }
  84 }
  85
  86 int wWorkspaceNew(WScreen *scr)
  87 {
  88         WWorkspace *wspace, **list;
  89         int i;
  90
  91         if (w_global.workspace.count < MAX_WORKSPACES) {
  92                 w_global.workspace.count++;
  93
  94                 wspace = wmalloc(sizeof(WWorkspace));
  95                 wspace->name = NULL;
  96                 wspace->clip = NULL;
  97
  98                 if (!wspace->name) {
  99                         wspace->name = wmalloc(strlen(_("Workspace %i")) + 8);
 100                         sprintf(wspace->name, _("Workspace %i"), w_global.workspace.count);
 101                 }
 102
 103                 if (!wPreferences.flags.noclip)
 104                         wspace->clip = wDockCreate(scr, WM_CLIP, NULL);
 105
 106                 list = wmalloc(sizeof(WWorkspace *) * w_global.workspace.count);
 107
 108                 for (i = 0; i < w_global.workspace.count - 1; i++)
 109                         list[i] = w_global.workspace.array[i];
 110
 111                 list[i] = wspace;
 112                 if (w_global.workspace.array)
 113                         wfree(w_global.workspace.array);
 114
 115                 w_global.workspace.array = list;
 116
 117                 wWorkspaceMenuUpdate(scr, scr->workspace_menu);
 118                 wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
 119                 wNETWMUpdateDesktop(scr);
 120                 WMPostNotificationName(WMNWorkspaceCreated, scr, (void *)(uintptr_t) (w_global.workspace.count - 1));
 121                 XFlush(dpy);
 122
 123                 return w_global.workspace.count - 1;
 124         }
 125
 126         return -1;
 127 }
 128
 129 Bool wWorkspaceDelete(WScreen * scr, int workspace)
 130 {
 131         WWindow *tmp;
 132         WWorkspace **list;
 133         int i, j;
 134
 135         if (workspace <= 0)
 136                 return False;
 137
 138         /* verify if workspace is in use by some window */
 139         tmp = scr->focused_window;
 140         while (tmp) {
 141                 if (!IS_OMNIPRESENT(tmp) && tmp->frame->workspace == workspace)
 142                         return False;
 143                 tmp = tmp->prev;
 144         }
 145
 146         if (!wPreferences.flags.noclip) {
 147                 wDockDestroy(w_global.workspace.array[workspace]->clip);
 148                 w_global.workspace.array[workspace]->clip = NULL;
 149         }
 150
 151         list = wmalloc(sizeof(WWorkspace *) * (w_global.workspace.count - 1));
 152         j = 0;
 153         for (i = 0; i < w_global.workspace.count; i++) {
 154                 if (i != workspace) {
 155                         list[j++] = w_global.workspace.array[i];
 156                 } else {
 157                         if (w_global.workspace.array[i]->name)
 158                                 wfree(w_global.workspace.array[i]->name);
 159                         wfree(w_global.workspace.array[i]);
 160                 }
 161         }
 162         wfree(w_global.workspace.array);
 163         w_global.workspace.array = list;
 164
 165         w_global.workspace.count--;
 166
 167         /* update menu */
 168         wWorkspaceMenuUpdate(scr, scr->workspace_menu);
 169         /* clip workspace menu */
 170         wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
 171
 172         /* update also window menu */
 173         if (scr->workspace_submenu) {
 174                 WMenu *menu = scr->workspace_submenu;
 175
 176                 i = menu->entry_no;
 177                 while (i > w_global.workspace.count)
 178                         wMenuRemoveItem(menu, --i);
 179                 wMenuRealize(menu);
 180         }
 181         /* and clip menu */
 182         if (scr->clip_submenu) {
 183                 WMenu *menu = scr->clip_submenu;
 184
 185                 i = menu->entry_no;
 186                 while (i > w_global.workspace.count)
 187                         wMenuRemoveItem(menu, --i);
 188                 wMenuRealize(menu);
 189         }
 190         wNETWMUpdateDesktop(scr);
 191         WMPostNotificationName(WMNWorkspaceDestroyed, scr, (void *)(uintptr_t) (w_global.workspace.count - 1));
 192
 193         if (w_global.workspace.current >= w_global.workspace.count)
 194                 wWorkspaceChange(scr, w_global.workspace.count - 1);
 195         if (w_global.workspace.last_used >= w_global.workspace.count)
 196                 w_global.workspace.last_used = 0;
 197
 198         return True;
 199 }
 200
 201 typedef struct WorkspaceNameData {
 202         int count;
 203         RImage *back;
 204         RImage *text;
 205         time_t timeout;
 206 } WorkspaceNameData;
 207
 208 static void hideWorkspaceName(void *data)
 209 {
 210         WScreen *scr = (WScreen *) data;
 211
 212         if (!scr->workspace_name_data || scr->workspace_name_data->count == 0
 213             || time(NULL) > scr->workspace_name_data->timeout) {
 214                 XUnmapWindow(dpy, scr->workspace_name);
 215
 216                 if (scr->workspace_name_data) {
 217                         RReleaseImage(scr->workspace_name_data->back);
 218                         RReleaseImage(scr->workspace_name_data->text);
 219                         wfree(scr->workspace_name_data);
 220
 221                         scr->workspace_name_data = NULL;
 222                 }
 223                 scr->workspace_name_timer = NULL;
 224         } else {
 225                 RImage *img = RCloneImage(scr->workspace_name_data->back);
 226                 Pixmap pix;
 227
 228                 scr->workspace_name_timer = WMAddTimerHandler(WORKSPACE_NAME_FADE_DELAY, hideWorkspaceName, scr);
 229
 230                 RCombineImagesWithOpaqueness(img, scr->workspace_name_data->text,
 231                                              scr->workspace_name_data->count * 255 / 10);
 232
 233                 RConvertImage(scr->rcontext, img, &pix);
 234
 235                 RReleaseImage(img);
 236
 237                 XSetWindowBackgroundPixmap(dpy, scr->workspace_name, pix);
 238                 XClearWindow(dpy, scr->workspace_name);
 239                 XFreePixmap(dpy, pix);
 240                 XFlush(dpy);
 241
 242                 scr->workspace_name_data->count--;
 243         }
 244 }
 245
 246 static void showWorkspaceName(WScreen * scr, int workspace)
 247 {
 248         WorkspaceNameData *data;
 249         RXImage *ximg;
 250         Pixmap text, mask;
 251         int w, h;
 252         int px, py;
 253         char *name = w_global.workspace.array[workspace]->name;
 254         int len = strlen(name);
 255         int x, y;
 256 #ifdef XINERAMA
 257         int head;
 258         WMRect rect;
 259         int xx, yy;
 260 #endif
 261
 262         if (wPreferences.workspace_name_display_position == WD_NONE || w_global.workspace.count < 2)
 263                 return;
 264
 265         if (scr->workspace_name_timer) {
 266                 WMDeleteTimerHandler(scr->workspace_name_timer);
 267                 XUnmapWindow(dpy, scr->workspace_name);
 268                 XFlush(dpy);
 269         }
 270         scr->workspace_name_timer = WMAddTimerHandler(WORKSPACE_NAME_DELAY, hideWorkspaceName, scr);
 271
 272         if (scr->workspace_name_data) {
 273                 RReleaseImage(scr->workspace_name_data->back);
 274                 RReleaseImage(scr->workspace_name_data->text);
 275                 wfree(scr->workspace_name_data);
 276         }
 277
 278         data = wmalloc(sizeof(WorkspaceNameData));
 279         data->back = NULL;
 280
 281         w = WMWidthOfString(w_global.workspace.font_for_name, name, len);
 282         h = WMFontHeight(w_global.workspace.font_for_name);
 283
 284 #ifdef XINERAMA
 285         head = wGetHeadForPointerLocation(scr);
 286         rect = wGetRectForHead(scr, head);
 287         if (scr->xine_info.count) {
 288                 xx = rect.pos.x + (scr->xine_info.screens[head].size.width - (w + 4)) / 2;
 289                 yy = rect.pos.y + (scr->xine_info.screens[head].size.height - (h + 4)) / 2;
 290         }
 291         else {
 292                 xx = (scr->scr_width - (w + 4)) / 2;
 293                 yy = (scr->scr_height - (h + 4)) / 2;
 294         }
 295 #endif
 296
 297         switch (wPreferences.workspace_name_display_position) {
 298         case WD_TOP:
 299 #ifdef XINERAMA
 300                 px = xx;
 301 #else
 302                 px = (scr->scr_width - (w + 4)) / 2;
 303 #endif
 304                 py = WORKSPACE_NAME_DISPLAY_PADDING;
 305                 break;
 306         case WD_BOTTOM:
 307 #ifdef XINERAMA
 308                 px = xx;
 309 #else
 310                 px = (scr->scr_width - (w + 4)) / 2;
 311 #endif
 312                 py = scr->scr_height - (h + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
 313                 break;
 314         case WD_TOPLEFT:
 315                 px = WORKSPACE_NAME_DISPLAY_PADDING;
 316                 py = WORKSPACE_NAME_DISPLAY_PADDING;
 317                 break;
 318         case WD_TOPRIGHT:
 319                 px = scr->scr_width - (w + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
 320                 py = WORKSPACE_NAME_DISPLAY_PADDING;
 321                 break;
 322         case WD_BOTTOMLEFT:
 323                 px = WORKSPACE_NAME_DISPLAY_PADDING;
 324                 py = scr->scr_height - (h + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
 325                 break;
 326         case WD_BOTTOMRIGHT:
 327                 px = scr->scr_width - (w + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
 328                 py = scr->scr_height - (h + 4 + WORKSPACE_NAME_DISPLAY_PADDING);
 329                 break;
 330         case WD_CENTER:
 331         default:
 332 #ifdef XINERAMA
 333                 px = xx;
 334                 py = yy;
 335 #else
 336                 px = (scr->scr_width - (w + 4)) / 2;
 337                 py = (scr->scr_height - (h + 4)) / 2;
 338 #endif
 339                 break;
 340         }
 341         XResizeWindow(dpy, scr->workspace_name, w + 4, h + 4);
 342         XMoveWindow(dpy, scr->workspace_name, px, py);
 343
 344         text = XCreatePixmap(dpy, scr->w_win, w + 4, h + 4, scr->w_depth);
 345         mask = XCreatePixmap(dpy, scr->w_win, w + 4, h + 4, 1);
 346
 347         /*XSetForeground(dpy, scr->mono_gc, 0);
 348            XFillRectangle(dpy, mask, scr->mono_gc, 0, 0, w+4, h+4); */
 349
 350         XFillRectangle(dpy, text, WMColorGC(scr->black), 0, 0, w + 4, h + 4);
 351
 352         for (x = 0; x <= 4; x++)
 353                 for (y = 0; y <= 4; y++)
 354                         WMDrawString(scr->wmscreen, text, scr->white, w_global.workspace.font_for_name, x, y, name, len);
 355
 356         XSetForeground(dpy, scr->mono_gc, 1);
 357         XSetBackground(dpy, scr->mono_gc, 0);
 358
 359         XCopyPlane(dpy, text, mask, scr->mono_gc, 0, 0, w + 4, h + 4, 0, 0, 1 << (scr->w_depth - 1));
 360
 361         /*XSetForeground(dpy, scr->mono_gc, 1); */
 362         XSetBackground(dpy, scr->mono_gc, 1);
 363
 364         XFillRectangle(dpy, text, WMColorGC(scr->black), 0, 0, w + 4, h + 4);
 365
 366         WMDrawString(scr->wmscreen, text, scr->white, w_global.workspace.font_for_name, 2, 2, name, len);
 367
 368 #ifdef SHAPE
 369         XShapeCombineMask(dpy, scr->workspace_name, ShapeBounding, 0, 0, mask, 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, data->text->width, data->text->height);
 387
 388         if (!ximg || !ximg->image) {
 389                 goto erro;
 390         }
 391
 392         XMapRaised(dpy, scr->workspace_name);
 393         XFlush(dpy);
 394
 395         data->back = RCreateImageFromXImage(scr->rcontext, ximg->image, NULL);
 396         RDestroyXImage(scr->rcontext, ximg);
 397
 398         if (!data->back) {
 399                 goto erro;
 400         }
 401
 402         data->count = 10;
 403
 404         /* set a timeout for the effect */
 405         data->timeout = time(NULL) + 2 + (WORKSPACE_NAME_DELAY + WORKSPACE_NAME_FADE_DELAY * data->count) / 1000;
 406
 407         scr->workspace_name_data = data;
 408
 409         return;
 410
 411  erro:
 412         if (scr->workspace_name_timer)
 413                 WMDeleteTimerHandler(scr->workspace_name_timer);
 414
 415         if (data->text)
 416                 RReleaseImage(data->text);
 417         if (data->back)
 418                 RReleaseImage(data->back);
 419         wfree(data);
 420
 421         scr->workspace_name_data = NULL;
 422
 423         scr->workspace_name_timer = WMAddTimerHandler(WORKSPACE_NAME_DELAY +
 424                                                       10 * WORKSPACE_NAME_FADE_DELAY, hideWorkspaceName, scr);
 425 }
 426
 427 void wWorkspaceChange(WScreen *scr, int workspace)
 428 {
 429         if (scr->flags.startup || scr->flags.startup2 || scr->flags.ignore_focus_events)
 430                 return;
 431
 432         if (workspace != w_global.workspace.current)
 433                 wWorkspaceForceChange(scr, workspace);
 434 }
 435
 436 void wWorkspaceRelativeChange(WScreen * scr, int amount)
 437 {
 438         int w;
 439
 440         /* While the deiconify animation is going on the window is
 441          * still "flying" to its final position and we don't want to
 442          * change workspace before the animation finishes, otherwise
 443          * the window will land in the new workspace */
 444         if (ignore_wks_change)
 445                 return;
 446
 447         w = w_global.workspace.current + amount;
 448
 449         if (amount < 0) {
 450                 if (w >= 0) {
 451                         wWorkspaceChange(scr, w);
 452                 } else if (wPreferences.ws_cycle) {
 453                         wWorkspaceChange(scr, w_global.workspace.count + w);
 454                 }
 455         } else if (amount > 0) {
 456                 if (w < w_global.workspace.count) {
 457                         wWorkspaceChange(scr, w);
 458                 } else if (wPreferences.ws_advance) {
 459                         wWorkspaceChange(scr, WMIN(w, MAX_WORKSPACES - 1));
 460                 } else if (wPreferences.ws_cycle) {
 461                         wWorkspaceChange(scr, w % w_global.workspace.count);
 462                 }
 463         }
 464 }
 465
 466 void wWorkspaceForceChange(WScreen * scr, int workspace)
 467 {
 468         WWindow *tmp, *foc = NULL, *foc2 = NULL;
 469         WWindow **toUnmap;
 470         int toUnmapSize, toUnmapCount;
 471
 472         if (workspace >= MAX_WORKSPACES || workspace < 0)
 473                 return;
 474
 475         SendHelperMessage(scr, 'C', workspace + 1, NULL);
 476
 477         if (workspace > w_global.workspace.count - 1)
 478                 wWorkspaceMake(scr, workspace - w_global.workspace.count + 1);
 479
 480         wClipUpdateForWorkspaceChange(scr, workspace);
 481
 482         w_global.workspace.last_used = w_global.workspace.current;
 483         w_global.workspace.current = workspace;
 484
 485         wWorkspaceMenuUpdate(scr, scr->workspace_menu);
 486
 487         wWorkspaceMenuUpdate(scr, scr->clip_ws_menu);
 488
 489         toUnmapSize = 16;
 490         toUnmapCount = 0;
 491         toUnmap = wmalloc(toUnmapSize * sizeof(WWindow *));
 492
 493         if ((tmp = scr->focused_window) != NULL) {
 494                 if ((IS_OMNIPRESENT(tmp) && (tmp->flags.mapped || tmp->flags.shaded) &&
 495                      !WFLAGP(tmp, no_focusable)) || tmp->flags.changing_workspace) {
 496                         foc = tmp;
 497                 }
 498
 499                 /* foc2 = tmp; will fix annoyance with gnome panel
 500                  * but will create annoyance for every other application
 501                  */
 502                 while (tmp) {
 503                         if (tmp->frame->workspace != workspace && !tmp->flags.selected) {
 504                                 /* unmap windows not on this workspace */
 505                                 if ((tmp->flags.mapped || tmp->flags.shaded) &&
 506                                     !IS_OMNIPRESENT(tmp) && !tmp->flags.changing_workspace) {
 507                                         if (toUnmapCount == toUnmapSize)
 508                                         {
 509                                                 toUnmapSize *= 2;
 510                                                 toUnmap = wrealloc(toUnmap, toUnmapSize * sizeof(WWindow *));
 511                                         }
 512                                         toUnmap[toUnmapCount++] = tmp;
 513                                 }
 514                                 /* also unmap miniwindows not on this workspace */
 515                                 if (!wPreferences.sticky_icons && tmp->flags.miniaturized &&
 516                                     tmp->icon && !IS_OMNIPRESENT(tmp)) {
 517                                         XUnmapWindow(dpy, tmp->icon->core->window);
 518                                         tmp->icon->mapped = 0;
 519                                 }
 520                                 /* update current workspace of omnipresent windows */
 521                                 if (IS_OMNIPRESENT(tmp)) {
 522                                         WApplication *wapp = wApplicationOf(tmp->main_window);
 523
 524                                         tmp->frame->workspace = workspace;
 525
 526                                         if (wapp) {
 527                                                 wapp->last_workspace = workspace;
 528                                         }
 529                                         if (!foc2 && (tmp->flags.mapped || tmp->flags.shaded)) {
 530                                                 foc2 = tmp;
 531                                         }
 532                                 }
 533                         } else {
 534                                 /* change selected windows' workspace */
 535                                 if (tmp->flags.selected) {
 536                                         wWindowChangeWorkspace(tmp, workspace);
 537                                         if (!tmp->flags.miniaturized && !foc) {
 538                                                 foc = tmp;
 539                                         }
 540                                 } else {
 541                                         if (!tmp->flags.hidden) {
 542                                                 if (!(tmp->flags.mapped || tmp->flags.miniaturized)) {
 543                                                         /* remap windows that are on this workspace */
 544                                                         wWindowMap(tmp);
 545                                                         if (!foc && !WFLAGP(tmp, no_focusable)) {
 546                                                                 foc = tmp;
 547                                                         }
 548                                                 }
 549                                                 /* Also map miniwindow if not omnipresent */
 550                                                 if (!wPreferences.sticky_icons &&
 551                                                     tmp->flags.miniaturized && !IS_OMNIPRESENT(tmp) && tmp->icon) {
 552                                                         tmp->icon->mapped = 1;
 553                                                         XMapWindow(dpy, tmp->icon->core->window);
 554                                                 }
 555                                         }
 556                                 }
 557                         }
 558                         tmp = tmp->prev;
 559                 }
 560
 561                 while (toUnmapCount > 0)
 562                 {
 563                         wWindowUnmap(toUnmap[--toUnmapCount]);
 564                 }
 565                 wfree(toUnmap);
 566
 567                 /* Gobble up events unleashed by our mapping & unmapping.
 568                  * These may trigger various grab-initiated focus &
 569                  * crossing events. However, we don't care about them,
 570                  * and ignore their focus implications altogether to avoid
 571                  * flicker.
 572                  */
 573                 scr->flags.ignore_focus_events = 1;
 574                 ProcessPendingEvents();
 575                 scr->flags.ignore_focus_events = 0;
 576
 577                 if (!foc)
 578                         foc = foc2;
 579
 580                 if (scr->focused_window->flags.mapped && !foc) {
 581                         foc = scr->focused_window;
 582                 }
 583                 if (wPreferences.focus_mode == WKF_CLICK) {
 584                         wSetFocusTo(scr, foc);
 585                 } else {
 586                         unsigned int mask;
 587                         int foo;
 588                         Window bar, win;
 589                         WWindow *tmp;
 590
 591                         tmp = NULL;
 592                         if (XQueryPointer(dpy, scr->root_win, &bar, &win, &foo, &foo, &foo, &foo, &mask)) {
 593                                 tmp = wWindowFor(win);
 594                         }
 595
 596                         /* If there's a window under the pointer, focus it.
 597                          * (we ate all other focus events above, so it's
 598                          * certainly not focused). Otherwise focus last
 599                          * focused, or the root (depending on sloppiness)
 600                          */
 601                         if (!tmp && wPreferences.focus_mode == WKF_SLOPPY) {
 602                                 wSetFocusTo(scr, foc);
 603                         } else {
 604                                 wSetFocusTo(scr, tmp);
 605                         }
 606                 }
 607         }
 608
 609         /* We need to always arrange icons when changing workspace, even if
 610          * no autoarrange icons, because else the icons in different workspaces
 611          * can be superposed.
 612          * This can be avoided if appicons are also workspace specific.
 613          */
 614         if (!wPreferences.sticky_icons)
 615                 wArrangeIcons(scr, False);
 616
 617         if (scr->dock)
 618                 wAppIconPaint(scr->dock->icon_array[0]);
 619
 620         if (!wPreferences.flags.noclip && (w_global.workspace.array[workspace]->clip->auto_collapse ||
 621                                            w_global.workspace.array[workspace]->clip->auto_raise_lower)) {
 622                 /* to handle enter notify. This will also */
 623                 XUnmapWindow(dpy, scr->clip_icon->icon->core->window);
 624                 XMapWindow(dpy, scr->clip_icon->icon->core->window);
 625         }
 626         else if (scr->clip_icon != NULL) {
 627                 wClipIconPaint(scr->clip_icon);
 628         }
 629         wScreenUpdateUsableArea(scr);
 630         wNETWMUpdateDesktop(scr);
 631         showWorkspaceName(scr, workspace);
 632
 633         WMPostNotificationName(WMNWorkspaceChanged, scr, (void *)(uintptr_t) workspace);
 634
 635         /*   XSync(dpy, False); */
 636 }
 637
 638 static void switchWSCommand(WMenu * menu, WMenuEntry * entry)
 639 {
 640         wWorkspaceChange(menu->frame->screen_ptr, (long)entry->clientdata);
 641 }
 642
 643 static void lastWSCommand(WMenu *menu, WMenuEntry *entry)
 644 {
 645         wWorkspaceChange(menu->frame->screen_ptr, w_global.workspace.last_used);
 646 }
 647
 648 static void deleteWSCommand(WMenu *menu, WMenuEntry *entry)
 649 {
 650         wWorkspaceDelete(menu->frame->screen_ptr, w_global.workspace.count - 1);
 651 }
 652
 653 static void newWSCommand(WMenu *menu, WMenuEntry *foo)
 654 {
 655         int ws;
 656
 657         ws = wWorkspaceNew(menu->frame->screen_ptr);
 658
 659         /* autochange workspace */
 660         if (ws >= 0)
 661                 wWorkspaceChange(menu->frame->screen_ptr, ws);
 662 }
 663
 664 void wWorkspaceRename(WScreen *scr, int workspace, const char *name)
 665 {
 666         char buf[MAX_WORKSPACENAME_WIDTH + 1];
 667         char *tmp;
 668
 669         if (workspace >= w_global.workspace.count)
 670                 return;
 671
 672         /* trim white spaces */
 673         tmp = wtrimspace(name);
 674
 675         if (strlen(tmp) == 0) {
 676                 snprintf(buf, sizeof(buf), _("Workspace %i"), workspace + 1);
 677         } else {
 678                 strncpy(buf, tmp, MAX_WORKSPACENAME_WIDTH);
 679         }
 680         buf[MAX_WORKSPACENAME_WIDTH] = 0;
 681         wfree(tmp);
 682
 683         /* update workspace */
 684         wfree(w_global.workspace.array[workspace]->name);
 685         w_global.workspace.array[workspace]->name = wstrdup(buf);
 686
 687         if (scr->clip_ws_menu) {
 688                 if (strcmp(scr->clip_ws_menu->entries[workspace + MC_WORKSPACE1]->text, buf) != 0) {
 689                         wfree(scr->clip_ws_menu->entries[workspace + MC_WORKSPACE1]->text);
 690                         scr->clip_ws_menu->entries[workspace + MC_WORKSPACE1]->text = wstrdup(buf);
 691                         wMenuRealize(scr->clip_ws_menu);
 692                 }
 693         }
 694         if (scr->workspace_menu) {
 695                 if (strcmp(scr->workspace_menu->entries[workspace + MC_WORKSPACE1]->text, buf) != 0) {
 696                         wfree(scr->workspace_menu->entries[workspace + MC_WORKSPACE1]->text);
 697                         scr->workspace_menu->entries[workspace + MC_WORKSPACE1]->text = wstrdup(buf);
 698                         wMenuRealize(scr->workspace_menu);
 699                 }
 700         }
 701
 702         if (scr->clip_icon)
 703                 wClipIconPaint(scr->clip_icon);
 704
 705         WMPostNotificationName(WMNWorkspaceNameChanged, scr, (void *)(uintptr_t) workspace);
 706 }
 707
 708 /* callback for when menu entry is edited */
 709 static void onMenuEntryEdited(WMenu * menu, WMenuEntry * entry)
 710 {
 711         char *tmp;
 712
 713         tmp = entry->text;
 714         wWorkspaceRename(menu->frame->screen_ptr, (long)entry->clientdata, tmp);
 715 }
 716
 717 WMenu *wWorkspaceMenuMake(WScreen * scr, Bool titled)
 718 {
 719         WMenu *wsmenu;
 720         WMenuEntry *entry;
 721
 722         wsmenu = wMenuCreate(scr, titled ? _("Workspaces") : NULL, False);
 723         if (!wsmenu) {
 724                 wwarning(_("could not create Workspace menu"));
 725                 return NULL;
 726         }
 727
 728         /* callback to be called when an entry is edited */
 729         wsmenu->on_edit = onMenuEntryEdited;
 730
 731         wMenuAddCallback(wsmenu, _("New"), newWSCommand, NULL);
 732         wMenuAddCallback(wsmenu, _("Destroy Last"), deleteWSCommand, NULL);
 733
 734         entry = wMenuAddCallback(wsmenu, _("Last Used"), lastWSCommand, NULL);
 735         entry->rtext = GetShortcutKey(wKeyBindings[WKBD_LASTWORKSPACE]);
 736
 737         return wsmenu;
 738 }
 739
 740 void wWorkspaceMenuUpdate(WScreen * scr, WMenu * menu)
 741 {
 742         int i;
 743         long ws;
 744         char title[MAX_WORKSPACENAME_WIDTH + 1];
 745         WMenuEntry *entry;
 746         int tmp;
 747
 748         if (!menu)
 749                 return;
 750
 751         if (menu->entry_no < w_global.workspace.count + MC_WORKSPACE1) {
 752                 /* new workspace(s) added */
 753                 i = w_global.workspace.count - (menu->entry_no - MC_WORKSPACE1);
 754                 ws = menu->entry_no - MC_WORKSPACE1;
 755                 while (i > 0) {
 756                         wstrlcpy(title, w_global.workspace.array[ws]->name, MAX_WORKSPACENAME_WIDTH);
 757
 758                         entry = wMenuAddCallback(menu, title, switchWSCommand, (void *)ws);
 759                         entry->flags.indicator = 1;
 760                         entry->flags.editable = 1;
 761
 762                         i--;
 763                         ws++;
 764                 }
 765         } else if (menu->entry_no > w_global.workspace.count + MC_WORKSPACE1) {
 766                 /* removed workspace(s) */
 767                 for (i = menu->entry_no - 1; i >= w_global.workspace.count + MC_WORKSPACE1; i--)
 768                         wMenuRemoveItem(menu, i);
 769         }
 770
 771         for (i = 0; i < w_global.workspace.count; i++) {
 772                 /* workspace shortcut labels */
 773                 if (i / 10 == w_global.workspace.current / 10)
 774                         menu->entries[i + MC_WORKSPACE1]->rtext = GetShortcutKey(wKeyBindings[WKBD_WORKSPACE1 + (i % 10)]);
 775                 else
 776                         menu->entries[i + MC_WORKSPACE1]->rtext = NULL;
 777
 778                 menu->entries[i + MC_WORKSPACE1]->flags.indicator_on = 0;
 779         }
 780         menu->entries[w_global.workspace.current + MC_WORKSPACE1]->flags.indicator_on = 1;
 781         wMenuRealize(menu);
 782
 783         /* don't let user destroy current workspace */
 784         if (w_global.workspace.current == w_global.workspace.count - 1)
 785                 wMenuSetEnabled(menu, MC_DESTROY_LAST, False);
 786         else
 787                 wMenuSetEnabled(menu, MC_DESTROY_LAST, True);
 788
 789         /* back to last workspace */
 790         if (w_global.workspace.count && w_global.workspace.last_used != w_global.workspace.current)
 791                 wMenuSetEnabled(menu, MC_LAST_USED, True);
 792         else
 793                 wMenuSetEnabled(menu, MC_LAST_USED, False);
 794
 795         tmp = menu->frame->top_width + 5;
 796         /* if menu got unreachable, bring it to a visible place */
 797         if (menu->frame_x < tmp - (int)menu->frame->core->width)
 798                 wMenuMove(menu, tmp - (int)menu->frame->core->width, menu->frame_y, False);
 799
 800         wMenuPaint(menu);
 801 }
 802
 803 void wWorkspaceSaveState(WScreen * scr, WMPropList * old_state)
 804 {
 805         WMPropList *parr, *pstr, *wks_state, *old_wks_state, *foo, *bar;
 806         int i;
 807
 808         make_keys();
 809
 810         old_wks_state = WMGetFromPLDictionary(old_state, dWorkspaces);
 811         parr = WMCreatePLArray(NULL);
 812         for (i = 0; i < w_global.workspace.count; i++) {
 813                 pstr = WMCreatePLString(w_global.workspace.array[i]->name);
 814                 wks_state = WMCreatePLDictionary(dName, pstr, NULL);
 815                 WMReleasePropList(pstr);
 816                 if (!wPreferences.flags.noclip) {
 817                         pstr = wClipSaveWorkspaceState(scr, i);
 818                         WMPutInPLDictionary(wks_state, dClip, pstr);
 819                         WMReleasePropList(pstr);
 820                 } else if (old_wks_state != NULL) {
 821                         if ((foo = WMGetFromPLArray(old_wks_state, i)) != NULL) {
 822                                 if ((bar = WMGetFromPLDictionary(foo, dClip)) != NULL) {
 823                                         WMPutInPLDictionary(wks_state, dClip, bar);
 824                                 }
 825                         }
 826                 }
 827                 WMAddToPLArray(parr, wks_state);
 828                 WMReleasePropList(wks_state);
 829         }
 830         WMPutInPLDictionary(scr->session_state, dWorkspaces, parr);
 831         WMReleasePropList(parr);
 832 }
 833
 834 void wWorkspaceRestoreState(WScreen *scr)
 835 {
 836         WMPropList *parr, *pstr, *wks_state, *clip_state;
 837         int i, j;
 838
 839         make_keys();
 840
 841         if (scr->session_state == NULL)
 842                 return;
 843
 844         parr = WMGetFromPLDictionary(scr->session_state, dWorkspaces);
 845
 846         if (!parr)
 847                 return;
 848
 849         for (i = 0; i < WMIN(WMGetPropListItemCount(parr), MAX_WORKSPACES); i++) {
 850                 wks_state = WMGetFromPLArray(parr, i);
 851                 if (WMIsPLDictionary(wks_state))
 852                         pstr = WMGetFromPLDictionary(wks_state, dName);
 853                 else
 854                         pstr = wks_state;
 855
 856                 if (i >= w_global.workspace.count)
 857                         wWorkspaceNew(scr);
 858
 859                 if (scr->workspace_menu) {
 860                         wfree(scr->workspace_menu->entries[i + MC_WORKSPACE1]->text);
 861                         scr->workspace_menu->entries[i + MC_WORKSPACE1]->text = wstrdup(WMGetFromPLString(pstr));
 862                         scr->workspace_menu->flags.realized = 0;
 863                 }
 864
 865                 wfree(w_global.workspace.array[i]->name);
 866                 w_global.workspace.array[i]->name = wstrdup(WMGetFromPLString(pstr));
 867                 if (!wPreferences.flags.noclip) {
 868                         int added_omnipresent_icons = 0;
 869
 870                         clip_state = WMGetFromPLDictionary(wks_state, dClip);
 871                         if (w_global.workspace.array[i]->clip)
 872                                 wDockDestroy(w_global.workspace.array[i]->clip);
 873
 874                         w_global.workspace.array[i]->clip = wDockRestoreState(scr, clip_state, WM_CLIP);
 875                         if (i > 0)
 876                                 wDockHideIcons(w_global.workspace.array[i]->clip);
 877
 878                         /* We set the global icons here, because scr->workspaces[i]->clip
 879                          * was not valid in wDockRestoreState().
 880                          * There we only set icon->omnipresent to know which icons we
 881                          * need to set here.
 882                          */
 883                         for (j = 0; j < w_global.workspace.array[i]->clip->max_icons; j++) {
 884                                 WAppIcon *aicon = w_global.workspace.array[i]->clip->icon_array[j];
 885                                 int k;
 886
 887                                 if (!aicon || !aicon->omnipresent)
 888                                         continue;
 889                                 aicon->omnipresent = 0;
 890                                 if (wClipMakeIconOmnipresent(aicon, True) != WO_SUCCESS)
 891                                         continue;
 892                                 if (i == 0)
 893                                         continue;
 894
 895                                 /* Move this appicon from workspace i to workspace 0 */
 896                                 w_global.workspace.array[i]->clip->icon_array[j] = NULL;
 897                                 w_global.workspace.array[i]->clip->icon_count--;
 898
 899                                 added_omnipresent_icons++;
 900                                 /* If there are too many omnipresent appicons, we are in trouble */
 901                                 assert(w_global.workspace.array[0]->clip->icon_count + added_omnipresent_icons
 902                                        <= w_global.workspace.array[0]->clip->max_icons);
 903                                 /* Find first free spot on workspace 0 */
 904                                 for (k = 0; k < w_global.workspace.array[0]->clip->max_icons; k++)
 905                                         if (w_global.workspace.array[0]->clip->icon_array[k] == NULL)
 906                                                 break;
 907                                 w_global.workspace.array[0]->clip->icon_array[k] = aicon;
 908                                 aicon->dock = w_global.workspace.array[0]->clip;
 909                         }
 910                         w_global.workspace.array[0]->clip->icon_count += added_omnipresent_icons;
 911                 }
 912
 913                 WMPostNotificationName(WMNWorkspaceNameChanged, scr, (void *)(uintptr_t) i);
 914         }
 915 }
 916
 917 /* Returns the workspace number for a given workspace name */
 918 int wGetWorkspaceNumber(WScreen *scr, const char *value)
 919 {
 920         int w, i;
 921
 922         if (sscanf(value, "%i", &w) != 1) {
 923                 w = -1;
 924                 for (i = 0; i < w_global.workspace.count; i++) {
 925                         if (strcmp(w_global.workspace.array[i]->name, value) == 0) {
 926                                 w = i;
 927                                 break;
 928                         }
 929                 }
 930         } else {
 931                 w--;
 932         }
 933
 934         return w;
 935 }