1 /* workspace.c- Workspace management
3 * Window Maker window manager
5 * Copyright (c) 1997-2003 Alfredo K. Kojima
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.
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.
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.
24 #include <X11/Xutil.h>
26 #include <X11/extensions/shape.h>
38 #include "WindowMaker.h"
44 #include "application.h"
47 #include "workspace.h"
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
59 #define MAX_SHORTCUT_LENGTH 32
60 #define WORKSPACE_NAME_DISPLAY_PADDING 32
63 static WMPropList
*dWorkspaces
= NULL
;
64 static WMPropList
*dClip
, *dName
;
66 static void make_keys(void)
68 if (dWorkspaces
!= NULL
)
71 dWorkspaces
= WMCreatePLString("Workspaces");
72 dName
= WMCreatePLString("Name");
73 dClip
= WMCreatePLString("Clip");
76 void wWorkspaceMake(WScreen
* scr
, int count
)
84 int wWorkspaceNew(WScreen
*scr
)
86 WWorkspace
*wspace
, **list
;
89 if (w_global
.workspace
.count
< MAX_WORKSPACES
) {
90 w_global
.workspace
.count
++;
92 wspace
= wmalloc(sizeof(WWorkspace
));
97 wspace
->name
= wmalloc(strlen(_("Workspace %i")) + 8);
98 sprintf(wspace
->name
, _("Workspace %i"), w_global
.workspace
.count
);
101 if (!wPreferences
.flags
.noclip
)
102 wspace
->clip
= wDockCreate(scr
, WM_CLIP
, NULL
);
104 list
= wmalloc(sizeof(WWorkspace
*) * w_global
.workspace
.count
);
106 for (i
= 0; i
< w_global
.workspace
.count
- 1; i
++)
107 list
[i
] = w_global
.workspace
.array
[i
];
110 if (w_global
.workspace
.array
)
111 wfree(w_global
.workspace
.array
);
113 w_global
.workspace
.array
= list
;
115 wWorkspaceMenuUpdate(w_global
.workspace
.menu
);
116 wWorkspaceMenuUpdate(w_global
.clip
.ws_menu
);
117 wNETWMUpdateDesktop(scr
);
118 WMPostNotificationName(WMNWorkspaceCreated
, scr
, (void *)(uintptr_t) (w_global
.workspace
.count
- 1));
121 return w_global
.workspace
.count
- 1;
127 Bool
wWorkspaceDelete(WScreen
* scr
, int workspace
)
136 /* verify if workspace is in use by some window */
137 tmp
= scr
->focused_window
;
139 if (!IS_OMNIPRESENT(tmp
) && tmp
->frame
->workspace
== workspace
)
144 if (!wPreferences
.flags
.noclip
) {
145 wDockDestroy(w_global
.workspace
.array
[workspace
]->clip
);
146 w_global
.workspace
.array
[workspace
]->clip
= NULL
;
149 list
= wmalloc(sizeof(WWorkspace
*) * (w_global
.workspace
.count
- 1));
151 for (i
= 0; i
< w_global
.workspace
.count
; i
++) {
152 if (i
!= workspace
) {
153 list
[j
++] = w_global
.workspace
.array
[i
];
155 if (w_global
.workspace
.array
[i
]->name
)
156 wfree(w_global
.workspace
.array
[i
]->name
);
157 wfree(w_global
.workspace
.array
[i
]);
160 wfree(w_global
.workspace
.array
);
161 w_global
.workspace
.array
= list
;
163 w_global
.workspace
.count
--;
166 wWorkspaceMenuUpdate(w_global
.workspace
.menu
);
167 /* clip workspace menu */
168 wWorkspaceMenuUpdate(w_global
.clip
.ws_menu
);
170 /* update also window menu */
171 if (w_global
.workspace
.submenu
) {
172 WMenu
*menu
= w_global
.workspace
.submenu
;
175 while (i
> w_global
.workspace
.count
)
176 wMenuRemoveItem(menu
, --i
);
180 if (w_global
.clip
.submenu
) {
181 WMenu
*menu
= w_global
.clip
.submenu
;
184 while (i
> w_global
.workspace
.count
)
185 wMenuRemoveItem(menu
, --i
);
188 wNETWMUpdateDesktop(scr
);
189 WMPostNotificationName(WMNWorkspaceDestroyed
, scr
, (void *)(uintptr_t) (w_global
.workspace
.count
- 1));
191 if (w_global
.workspace
.current
>= w_global
.workspace
.count
)
192 wWorkspaceChange(scr
, w_global
.workspace
.count
- 1);
193 if (w_global
.workspace
.last_used
>= w_global
.workspace
.count
)
194 w_global
.workspace
.last_used
= 0;
199 typedef struct WorkspaceNameData
{
206 static void hideWorkspaceName(void *data
)
208 WScreen
*scr
= (WScreen
*) data
;
210 if (!scr
->workspace_name_data
|| scr
->workspace_name_data
->count
== 0
211 || time(NULL
) > scr
->workspace_name_data
->timeout
) {
212 XUnmapWindow(dpy
, scr
->workspace_name
);
214 if (scr
->workspace_name_data
) {
215 RReleaseImage(scr
->workspace_name_data
->back
);
216 RReleaseImage(scr
->workspace_name_data
->text
);
217 wfree(scr
->workspace_name_data
);
219 scr
->workspace_name_data
= NULL
;
221 scr
->workspace_name_timer
= NULL
;
223 RImage
*img
= RCloneImage(scr
->workspace_name_data
->back
);
226 scr
->workspace_name_timer
= WMAddTimerHandler(WORKSPACE_NAME_FADE_DELAY
, hideWorkspaceName
, scr
);
228 RCombineImagesWithOpaqueness(img
, scr
->workspace_name_data
->text
,
229 scr
->workspace_name_data
->count
* 255 / 10);
231 RConvertImage(scr
->rcontext
, img
, &pix
);
235 XSetWindowBackgroundPixmap(dpy
, scr
->workspace_name
, pix
);
236 XClearWindow(dpy
, scr
->workspace_name
);
237 XFreePixmap(dpy
, pix
);
240 scr
->workspace_name_data
->count
--;
244 static void showWorkspaceName(WScreen
* scr
, int workspace
)
246 WorkspaceNameData
*data
;
251 char *name
= w_global
.workspace
.array
[workspace
]->name
;
252 int len
= strlen(name
);
260 if (wPreferences
.workspace_name_display_position
== WD_NONE
|| w_global
.workspace
.count
< 2)
263 if (scr
->workspace_name_timer
) {
264 WMDeleteTimerHandler(scr
->workspace_name_timer
);
265 XUnmapWindow(dpy
, scr
->workspace_name
);
268 scr
->workspace_name_timer
= WMAddTimerHandler(WORKSPACE_NAME_DELAY
, hideWorkspaceName
, scr
);
270 if (scr
->workspace_name_data
) {
271 RReleaseImage(scr
->workspace_name_data
->back
);
272 RReleaseImage(scr
->workspace_name_data
->text
);
273 wfree(scr
->workspace_name_data
);
276 data
= wmalloc(sizeof(WorkspaceNameData
));
279 w
= WMWidthOfString(w_global
.workspace
.font_for_name
, name
, len
);
280 h
= WMFontHeight(w_global
.workspace
.font_for_name
);
283 head
= wGetHeadForPointerLocation(scr
);
284 rect
= wGetRectForHead(scr
, head
);
285 if (scr
->xine_info
.count
) {
286 xx
= rect
.pos
.x
+ (scr
->xine_info
.screens
[head
].size
.width
- (w
+ 4)) / 2;
287 yy
= rect
.pos
.y
+ (scr
->xine_info
.screens
[head
].size
.height
- (h
+ 4)) / 2;
290 xx
= (scr
->scr_width
- (w
+ 4)) / 2;
291 yy
= (scr
->scr_height
- (h
+ 4)) / 2;
295 switch (wPreferences
.workspace_name_display_position
) {
300 px
= (scr
->scr_width
- (w
+ 4)) / 2;
302 py
= WORKSPACE_NAME_DISPLAY_PADDING
;
308 px
= (scr
->scr_width
- (w
+ 4)) / 2;
310 py
= scr
->scr_height
- (h
+ 4 + WORKSPACE_NAME_DISPLAY_PADDING
);
313 px
= WORKSPACE_NAME_DISPLAY_PADDING
;
314 py
= WORKSPACE_NAME_DISPLAY_PADDING
;
317 px
= scr
->scr_width
- (w
+ 4 + WORKSPACE_NAME_DISPLAY_PADDING
);
318 py
= WORKSPACE_NAME_DISPLAY_PADDING
;
321 px
= WORKSPACE_NAME_DISPLAY_PADDING
;
322 py
= scr
->scr_height
- (h
+ 4 + WORKSPACE_NAME_DISPLAY_PADDING
);
325 px
= scr
->scr_width
- (w
+ 4 + WORKSPACE_NAME_DISPLAY_PADDING
);
326 py
= scr
->scr_height
- (h
+ 4 + WORKSPACE_NAME_DISPLAY_PADDING
);
334 px
= (scr
->scr_width
- (w
+ 4)) / 2;
335 py
= (scr
->scr_height
- (h
+ 4)) / 2;
339 XResizeWindow(dpy
, scr
->workspace_name
, w
+ 4, h
+ 4);
340 XMoveWindow(dpy
, scr
->workspace_name
, px
, py
);
342 text
= XCreatePixmap(dpy
, scr
->w_win
, w
+ 4, h
+ 4, scr
->w_depth
);
343 mask
= XCreatePixmap(dpy
, scr
->w_win
, w
+ 4, h
+ 4, 1);
345 /*XSetForeground(dpy, scr->mono_gc, 0);
346 XFillRectangle(dpy, mask, scr->mono_gc, 0, 0, w+4, h+4); */
348 XFillRectangle(dpy
, text
, WMColorGC(scr
->black
), 0, 0, w
+ 4, h
+ 4);
350 for (x
= 0; x
<= 4; x
++)
351 for (y
= 0; y
<= 4; y
++)
352 WMDrawString(scr
->wmscreen
, text
, scr
->white
, w_global
.workspace
.font_for_name
, x
, y
, name
, len
);
354 XSetForeground(dpy
, scr
->mono_gc
, 1);
355 XSetBackground(dpy
, scr
->mono_gc
, 0);
357 XCopyPlane(dpy
, text
, mask
, scr
->mono_gc
, 0, 0, w
+ 4, h
+ 4, 0, 0, 1 << (scr
->w_depth
- 1));
359 /*XSetForeground(dpy, scr->mono_gc, 1); */
360 XSetBackground(dpy
, scr
->mono_gc
, 1);
362 XFillRectangle(dpy
, text
, WMColorGC(scr
->black
), 0, 0, w
+ 4, h
+ 4);
364 WMDrawString(scr
->wmscreen
, text
, scr
->white
, w_global
.workspace
.font_for_name
, 2, 2, name
, len
);
367 XShapeCombineMask(dpy
, scr
->workspace_name
, ShapeBounding
, 0, 0, mask
, ShapeSet
);
369 XSetWindowBackgroundPixmap(dpy
, scr
->workspace_name
, text
);
370 XClearWindow(dpy
, scr
->workspace_name
);
372 data
->text
= RCreateImageFromDrawable(scr
->rcontext
, text
, None
);
374 XFreePixmap(dpy
, text
);
375 XFreePixmap(dpy
, mask
);
378 XMapRaised(dpy
, scr
->workspace_name
);
384 ximg
= RGetXImage(scr
->rcontext
, scr
->root_win
, px
, py
, data
->text
->width
, data
->text
->height
);
386 if (!ximg
|| !ximg
->image
) {
390 XMapRaised(dpy
, scr
->workspace_name
);
393 data
->back
= RCreateImageFromXImage(scr
->rcontext
, ximg
->image
, NULL
);
394 RDestroyXImage(scr
->rcontext
, ximg
);
402 /* set a timeout for the effect */
403 data
->timeout
= time(NULL
) + 2 + (WORKSPACE_NAME_DELAY
+ WORKSPACE_NAME_FADE_DELAY
* data
->count
) / 1000;
405 scr
->workspace_name_data
= data
;
410 if (scr
->workspace_name_timer
)
411 WMDeleteTimerHandler(scr
->workspace_name_timer
);
414 RReleaseImage(data
->text
);
416 RReleaseImage(data
->back
);
419 scr
->workspace_name_data
= NULL
;
421 scr
->workspace_name_timer
= WMAddTimerHandler(WORKSPACE_NAME_DELAY
+
422 10 * WORKSPACE_NAME_FADE_DELAY
, hideWorkspaceName
, scr
);
425 void wWorkspaceChange(WScreen
*scr
, int workspace
)
427 if (scr
->flags
.startup
|| scr
->flags
.startup2
|| scr
->flags
.ignore_focus_events
)
430 if (workspace
!= w_global
.workspace
.current
)
431 wWorkspaceForceChange(scr
, workspace
);
434 void wWorkspaceRelativeChange(WScreen
* scr
, int amount
)
438 /* While the deiconify animation is going on the window is
439 * still "flying" to its final position and we don't want to
440 * change workspace before the animation finishes, otherwise
441 * the window will land in the new workspace */
442 if (w_global
.workspace
.ignore_change
)
445 w
= w_global
.workspace
.current
+ amount
;
449 wWorkspaceChange(scr
, w
);
450 } else if (wPreferences
.ws_cycle
) {
451 wWorkspaceChange(scr
, w_global
.workspace
.count
+ w
);
453 } else if (amount
> 0) {
454 if (w
< w_global
.workspace
.count
) {
455 wWorkspaceChange(scr
, w
);
456 } else if (wPreferences
.ws_advance
) {
457 wWorkspaceChange(scr
, WMIN(w
, MAX_WORKSPACES
- 1));
458 } else if (wPreferences
.ws_cycle
) {
459 wWorkspaceChange(scr
, w
% w_global
.workspace
.count
);
464 void wWorkspaceForceChange(WScreen
* scr
, int workspace
)
466 WWindow
*tmp
, *foc
= NULL
, *foc2
= NULL
;
468 int toUnmapSize
, toUnmapCount
;
470 if (workspace
>= MAX_WORKSPACES
|| workspace
< 0)
473 SendHelperMessage(scr
, 'C', workspace
+ 1, NULL
);
475 if (workspace
> w_global
.workspace
.count
- 1)
476 wWorkspaceMake(scr
, workspace
- w_global
.workspace
.count
+ 1);
478 wClipUpdateForWorkspaceChange(scr
, workspace
);
480 w_global
.workspace
.last_used
= w_global
.workspace
.current
;
481 w_global
.workspace
.current
= workspace
;
483 wWorkspaceMenuUpdate(w_global
.workspace
.menu
);
485 wWorkspaceMenuUpdate(w_global
.clip
.ws_menu
);
489 toUnmap
= wmalloc(toUnmapSize
* sizeof(WWindow
*));
491 if ((tmp
= scr
->focused_window
) != NULL
) {
492 if ((IS_OMNIPRESENT(tmp
) && (tmp
->flags
.mapped
|| tmp
->flags
.shaded
) &&
493 !WFLAGP(tmp
, no_focusable
)) || tmp
->flags
.changing_workspace
) {
497 /* foc2 = tmp; will fix annoyance with gnome panel
498 * but will create annoyance for every other application
501 if (tmp
->frame
->workspace
!= workspace
&& !tmp
->flags
.selected
) {
502 /* unmap windows not on this workspace */
503 if ((tmp
->flags
.mapped
|| tmp
->flags
.shaded
) &&
504 !IS_OMNIPRESENT(tmp
) && !tmp
->flags
.changing_workspace
) {
505 if (toUnmapCount
== toUnmapSize
)
508 toUnmap
= wrealloc(toUnmap
, toUnmapSize
* sizeof(WWindow
*));
510 toUnmap
[toUnmapCount
++] = tmp
;
512 /* also unmap miniwindows not on this workspace */
513 if (!wPreferences
.sticky_icons
&& tmp
->flags
.miniaturized
&&
514 tmp
->icon
&& !IS_OMNIPRESENT(tmp
)) {
515 XUnmapWindow(dpy
, tmp
->icon
->core
->window
);
516 tmp
->icon
->mapped
= 0;
518 /* update current workspace of omnipresent windows */
519 if (IS_OMNIPRESENT(tmp
)) {
520 WApplication
*wapp
= wApplicationOf(tmp
->main_window
);
522 tmp
->frame
->workspace
= workspace
;
525 wapp
->last_workspace
= workspace
;
527 if (!foc2
&& (tmp
->flags
.mapped
|| tmp
->flags
.shaded
)) {
532 /* change selected windows' workspace */
533 if (tmp
->flags
.selected
) {
534 wWindowChangeWorkspace(tmp
, workspace
);
535 if (!tmp
->flags
.miniaturized
&& !foc
) {
539 if (!tmp
->flags
.hidden
) {
540 if (!(tmp
->flags
.mapped
|| tmp
->flags
.miniaturized
)) {
541 /* remap windows that are on this workspace */
543 if (!foc
&& !WFLAGP(tmp
, no_focusable
)) {
547 /* Also map miniwindow if not omnipresent */
548 if (!wPreferences
.sticky_icons
&&
549 tmp
->flags
.miniaturized
&& !IS_OMNIPRESENT(tmp
) && tmp
->icon
) {
550 tmp
->icon
->mapped
= 1;
551 XMapWindow(dpy
, tmp
->icon
->core
->window
);
559 while (toUnmapCount
> 0)
561 wWindowUnmap(toUnmap
[--toUnmapCount
]);
565 /* Gobble up events unleashed by our mapping & unmapping.
566 * These may trigger various grab-initiated focus &
567 * crossing events. However, we don't care about them,
568 * and ignore their focus implications altogether to avoid
571 scr
->flags
.ignore_focus_events
= 1;
572 ProcessPendingEvents();
573 scr
->flags
.ignore_focus_events
= 0;
578 if (scr
->focused_window
->flags
.mapped
&& !foc
) {
579 foc
= scr
->focused_window
;
581 if (wPreferences
.focus_mode
== WKF_CLICK
) {
582 wSetFocusTo(scr
, foc
);
590 if (XQueryPointer(dpy
, scr
->root_win
, &bar
, &win
, &foo
, &foo
, &foo
, &foo
, &mask
)) {
591 tmp
= wWindowFor(win
);
594 /* If there's a window under the pointer, focus it.
595 * (we ate all other focus events above, so it's
596 * certainly not focused). Otherwise focus last
597 * focused, or the root (depending on sloppiness)
599 if (!tmp
&& wPreferences
.focus_mode
== WKF_SLOPPY
) {
600 wSetFocusTo(scr
, foc
);
602 wSetFocusTo(scr
, tmp
);
607 /* We need to always arrange icons when changing workspace, even if
608 * no autoarrange icons, because else the icons in different workspaces
610 * This can be avoided if appicons are also workspace specific.
612 if (!wPreferences
.sticky_icons
)
613 wArrangeIcons(scr
, False
);
616 wAppIconPaint(scr
->dock
->icon_array
[0]);
618 if (!wPreferences
.flags
.noclip
&& (w_global
.workspace
.array
[workspace
]->clip
->auto_collapse
||
619 w_global
.workspace
.array
[workspace
]->clip
->auto_raise_lower
)) {
620 /* to handle enter notify. This will also */
621 XUnmapWindow(dpy
, w_global
.clip
.icon
->icon
->core
->window
);
622 XMapWindow(dpy
, w_global
.clip
.icon
->icon
->core
->window
);
624 else if (w_global
.clip
.icon
!= NULL
) {
627 wScreenUpdateUsableArea(scr
);
628 wNETWMUpdateDesktop(scr
);
629 showWorkspaceName(scr
, workspace
);
631 WMPostNotificationName(WMNWorkspaceChanged
, scr
, (void *)(uintptr_t) workspace
);
633 /* XSync(dpy, False); */
636 static void switchWSCommand(WMenu
* menu
, WMenuEntry
* entry
)
638 wWorkspaceChange(menu
->frame
->screen_ptr
, (long)entry
->clientdata
);
641 static void lastWSCommand(WMenu
*menu
, WMenuEntry
*entry
)
643 wWorkspaceChange(menu
->frame
->screen_ptr
, w_global
.workspace
.last_used
);
646 static void deleteWSCommand(WMenu
*menu
, WMenuEntry
*entry
)
648 wWorkspaceDelete(menu
->frame
->screen_ptr
, w_global
.workspace
.count
- 1);
651 static void newWSCommand(WMenu
*menu
, WMenuEntry
*foo
)
655 ws
= wWorkspaceNew(menu
->frame
->screen_ptr
);
657 /* autochange workspace */
659 wWorkspaceChange(menu
->frame
->screen_ptr
, ws
);
662 void wWorkspaceRename(WScreen
*scr
, int workspace
, const char *name
)
664 char buf
[MAX_WORKSPACENAME_WIDTH
+ 1];
667 if (workspace
>= w_global
.workspace
.count
)
670 /* trim white spaces */
671 tmp
= wtrimspace(name
);
673 if (strlen(tmp
) == 0) {
674 snprintf(buf
, sizeof(buf
), _("Workspace %i"), workspace
+ 1);
676 strncpy(buf
, tmp
, MAX_WORKSPACENAME_WIDTH
);
678 buf
[MAX_WORKSPACENAME_WIDTH
] = 0;
681 /* update workspace */
682 wfree(w_global
.workspace
.array
[workspace
]->name
);
683 w_global
.workspace
.array
[workspace
]->name
= wstrdup(buf
);
685 if (w_global
.clip
.ws_menu
) {
686 if (strcmp(w_global
.clip
.ws_menu
->entries
[workspace
+ MC_WORKSPACE1
]->text
, buf
) != 0) {
687 wfree(w_global
.clip
.ws_menu
->entries
[workspace
+ MC_WORKSPACE1
]->text
);
688 w_global
.clip
.ws_menu
->entries
[workspace
+ MC_WORKSPACE1
]->text
= wstrdup(buf
);
689 wMenuRealize(w_global
.clip
.ws_menu
);
692 if (w_global
.workspace
.menu
) {
693 if (strcmp(w_global
.workspace
.menu
->entries
[workspace
+ MC_WORKSPACE1
]->text
, buf
) != 0) {
694 wfree(w_global
.workspace
.menu
->entries
[workspace
+ MC_WORKSPACE1
]->text
);
695 w_global
.workspace
.menu
->entries
[workspace
+ MC_WORKSPACE1
]->text
= wstrdup(buf
);
696 wMenuRealize(w_global
.workspace
.menu
);
700 if (w_global
.clip
.icon
)
703 WMPostNotificationName(WMNWorkspaceNameChanged
, scr
, (void *)(uintptr_t) workspace
);
706 /* callback for when menu entry is edited */
707 static void onMenuEntryEdited(WMenu
* menu
, WMenuEntry
* entry
)
712 wWorkspaceRename(menu
->frame
->screen_ptr
, (long)entry
->clientdata
, tmp
);
715 WMenu
*wWorkspaceMenuMake(WScreen
* scr
, Bool titled
)
720 wsmenu
= wMenuCreate(scr
, titled
? _("Workspaces") : NULL
, False
);
722 wwarning(_("could not create Workspace menu"));
726 /* callback to be called when an entry is edited */
727 wsmenu
->on_edit
= onMenuEntryEdited
;
729 wMenuAddCallback(wsmenu
, _("New"), newWSCommand
, NULL
);
730 wMenuAddCallback(wsmenu
, _("Destroy Last"), deleteWSCommand
, NULL
);
732 entry
= wMenuAddCallback(wsmenu
, _("Last Used"), lastWSCommand
, NULL
);
733 entry
->rtext
= GetShortcutKey(wKeyBindings
[WKBD_LASTWORKSPACE
]);
738 void wWorkspaceMenuUpdate(WMenu
*menu
)
742 char title
[MAX_WORKSPACENAME_WIDTH
+ 1];
749 if (menu
->entry_no
< w_global
.workspace
.count
+ MC_WORKSPACE1
) {
750 /* new workspace(s) added */
751 i
= w_global
.workspace
.count
- (menu
->entry_no
- MC_WORKSPACE1
);
752 ws
= menu
->entry_no
- MC_WORKSPACE1
;
754 wstrlcpy(title
, w_global
.workspace
.array
[ws
]->name
, MAX_WORKSPACENAME_WIDTH
);
756 entry
= wMenuAddCallback(menu
, title
, switchWSCommand
, (void *)ws
);
757 entry
->flags
.indicator
= 1;
758 entry
->flags
.editable
= 1;
763 } else if (menu
->entry_no
> w_global
.workspace
.count
+ MC_WORKSPACE1
) {
764 /* removed workspace(s) */
765 for (i
= menu
->entry_no
- 1; i
>= w_global
.workspace
.count
+ MC_WORKSPACE1
; i
--)
766 wMenuRemoveItem(menu
, i
);
769 for (i
= 0; i
< w_global
.workspace
.count
; i
++) {
770 /* workspace shortcut labels */
771 if (i
/ 10 == w_global
.workspace
.current
/ 10)
772 menu
->entries
[i
+ MC_WORKSPACE1
]->rtext
= GetShortcutKey(wKeyBindings
[WKBD_WORKSPACE1
+ (i
% 10)]);
774 menu
->entries
[i
+ MC_WORKSPACE1
]->rtext
= NULL
;
776 menu
->entries
[i
+ MC_WORKSPACE1
]->flags
.indicator_on
= 0;
778 menu
->entries
[w_global
.workspace
.current
+ MC_WORKSPACE1
]->flags
.indicator_on
= 1;
781 /* don't let user destroy current workspace */
782 if (w_global
.workspace
.current
== w_global
.workspace
.count
- 1)
783 wMenuSetEnabled(menu
, MC_DESTROY_LAST
, False
);
785 wMenuSetEnabled(menu
, MC_DESTROY_LAST
, True
);
787 /* back to last workspace */
788 if (w_global
.workspace
.count
&& w_global
.workspace
.last_used
!= w_global
.workspace
.current
)
789 wMenuSetEnabled(menu
, MC_LAST_USED
, True
);
791 wMenuSetEnabled(menu
, MC_LAST_USED
, False
);
793 tmp
= menu
->frame
->top_width
+ 5;
794 /* if menu got unreachable, bring it to a visible place */
795 if (menu
->frame_x
< tmp
- (int)menu
->frame
->core
->width
)
796 wMenuMove(menu
, tmp
- (int)menu
->frame
->core
->width
, menu
->frame_y
, False
);
801 void wWorkspaceSaveState(WMPropList
* old_state
)
803 WMPropList
*parr
, *pstr
, *wks_state
, *old_wks_state
, *foo
, *bar
;
808 old_wks_state
= WMGetFromPLDictionary(old_state
, dWorkspaces
);
809 parr
= WMCreatePLArray(NULL
);
810 for (i
= 0; i
< w_global
.workspace
.count
; i
++) {
811 pstr
= WMCreatePLString(w_global
.workspace
.array
[i
]->name
);
812 wks_state
= WMCreatePLDictionary(dName
, pstr
, NULL
);
813 WMReleasePropList(pstr
);
814 if (!wPreferences
.flags
.noclip
) {
815 pstr
= wClipSaveWorkspaceState(i
);
816 WMPutInPLDictionary(wks_state
, dClip
, pstr
);
817 WMReleasePropList(pstr
);
818 } else if (old_wks_state
!= NULL
) {
819 if ((foo
= WMGetFromPLArray(old_wks_state
, i
)) != NULL
) {
820 if ((bar
= WMGetFromPLDictionary(foo
, dClip
)) != NULL
) {
821 WMPutInPLDictionary(wks_state
, dClip
, bar
);
825 WMAddToPLArray(parr
, wks_state
);
826 WMReleasePropList(wks_state
);
828 WMPutInPLDictionary(w_global
.session_state
, dWorkspaces
, parr
);
829 WMReleasePropList(parr
);
832 void wWorkspaceRestoreState(WScreen
*scr
)
834 WMPropList
*parr
, *pstr
, *wks_state
, *clip_state
;
839 if (w_global
.session_state
== NULL
)
842 parr
= WMGetFromPLDictionary(w_global
.session_state
, dWorkspaces
);
847 for (i
= 0; i
< WMIN(WMGetPropListItemCount(parr
), MAX_WORKSPACES
); i
++) {
848 wks_state
= WMGetFromPLArray(parr
, i
);
849 if (WMIsPLDictionary(wks_state
))
850 pstr
= WMGetFromPLDictionary(wks_state
, dName
);
854 if (i
>= w_global
.workspace
.count
)
857 if (w_global
.workspace
.menu
) {
858 wfree(w_global
.workspace
.menu
->entries
[i
+ MC_WORKSPACE1
]->text
);
859 w_global
.workspace
.menu
->entries
[i
+ MC_WORKSPACE1
]->text
= wstrdup(WMGetFromPLString(pstr
));
860 w_global
.workspace
.menu
->flags
.realized
= 0;
863 wfree(w_global
.workspace
.array
[i
]->name
);
864 w_global
.workspace
.array
[i
]->name
= wstrdup(WMGetFromPLString(pstr
));
865 if (!wPreferences
.flags
.noclip
) {
866 int added_omnipresent_icons
= 0;
868 clip_state
= WMGetFromPLDictionary(wks_state
, dClip
);
869 if (w_global
.workspace
.array
[i
]->clip
)
870 wDockDestroy(w_global
.workspace
.array
[i
]->clip
);
872 w_global
.workspace
.array
[i
]->clip
= wDockRestoreState(scr
, clip_state
, WM_CLIP
);
874 wDockHideIcons(w_global
.workspace
.array
[i
]->clip
);
876 /* We set the global icons here, because scr->workspaces[i]->clip
877 * was not valid in wDockRestoreState().
878 * There we only set icon->omnipresent to know which icons we
881 for (j
= 0; j
< w_global
.workspace
.array
[i
]->clip
->max_icons
; j
++) {
882 WAppIcon
*aicon
= w_global
.workspace
.array
[i
]->clip
->icon_array
[j
];
885 if (!aicon
|| !aicon
->omnipresent
)
887 aicon
->omnipresent
= 0;
888 if (wClipMakeIconOmnipresent(aicon
, True
) != WO_SUCCESS
)
893 /* Move this appicon from workspace i to workspace 0 */
894 w_global
.workspace
.array
[i
]->clip
->icon_array
[j
] = NULL
;
895 w_global
.workspace
.array
[i
]->clip
->icon_count
--;
897 added_omnipresent_icons
++;
898 /* If there are too many omnipresent appicons, we are in trouble */
899 assert(w_global
.workspace
.array
[0]->clip
->icon_count
+ added_omnipresent_icons
900 <= w_global
.workspace
.array
[0]->clip
->max_icons
);
901 /* Find first free spot on workspace 0 */
902 for (k
= 0; k
< w_global
.workspace
.array
[0]->clip
->max_icons
; k
++)
903 if (w_global
.workspace
.array
[0]->clip
->icon_array
[k
] == NULL
)
905 w_global
.workspace
.array
[0]->clip
->icon_array
[k
] = aicon
;
906 aicon
->dock
= w_global
.workspace
.array
[0]->clip
;
908 w_global
.workspace
.array
[0]->clip
->icon_count
+= added_omnipresent_icons
;
911 WMPostNotificationName(WMNWorkspaceNameChanged
, scr
, (void *)(uintptr_t) i
);
915 /* Returns the workspace number for a given workspace name */
916 int wGetWorkspaceNumber(const char *value
)
920 if (sscanf(value
, "%i", &w
) != 1) {
922 for (i
= 0; i
< w_global
.workspace
.count
; i
++) {
923 if (strcmp(w_global
.workspace
.array
[i
]->name
, value
) == 0) {