Change to the linux kernel coding style
[wmaker-crm.git] / src / session.c
1 /* session.c - session state handling and R6 style session management
2 *
3 * Copyright (c) 1998-2003 Dan Pascu
4 * Copyright (c) 1998-2003 Alfredo Kojima
5 *
6 * Window Maker window manager
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
21 * USA.
22 */
23
24 /*
25 *
26 * If defined(XSMP_ENABLED) and session manager is running then
27 * do normal stuff
28 * else
29 * do pre-R6 session management stuff (save window state and relaunch)
30 *
31 * When doing a checkpoint:
32 *
33 * = Without XSMP
34 * Open "Stop"/status Dialog
35 * Send SAVE_YOURSELF to clients and wait for reply
36 * Save restart info
37 * Save state of clients
38 *
39 * = With XSMP
40 * Send checkpoint request to sm
41 *
42 * When exiting:
43 * -------------
44 *
45 * = Without XSMP
46 *
47 * Open "Exit Now"/status Dialog
48 * Send SAVE_YOURSELF to clients and wait for reply
49 * Save restart info
50 * Save state of clients
51 * Send DELETE to all clients
52 * When no more clients are left or user hit "Exit Now", exit
53 *
54 * = With XSMP
55 *
56 * Send Shutdown request to session manager
57 * if SaveYourself message received, save state of clients
58 * if the Die message is received, exit.
59 */
60
61 #include "wconfig.h"
62
63 #include <X11/Xlib.h>
64 #include <X11/Xutil.h>
65
66 #ifdef XSMP_ENABLED
67 #include <X11/SM/SMlib.h>
68 #endif
69
70 #include <stdlib.h>
71 #include <stdio.h>
72 #include <string.h>
73 #include <unistd.h>
74 #include <time.h>
75
76 #include "WindowMaker.h"
77 #include "screen.h"
78 #include "window.h"
79 #include "client.h"
80 #include "session.h"
81 #include "wcore.h"
82 #include "framewin.h"
83 #include "workspace.h"
84 #include "funcs.h"
85 #include "properties.h"
86 #include "application.h"
87 #include "appicon.h"
88
89 #include "dock.h"
90
91 #include <WINGs/WUtil.h>
92
93 /** Global **/
94
95 extern Atom _XA_WM_SAVE_YOURSELF;
96
97 extern Time LastTimestamp;
98
99 #ifdef XSMP_ENABLED
100
101 extern int wScreenCount;
102
103 /* requested for SaveYourselfPhase2 */
104 static Bool sWaitingPhase2 = False;
105
106 static SmcConn sSMCConn = NULL;
107
108 static WMHandlerID sSMInputHandler = NULL;
109
110 /* our SM client ID */
111 static char *sClientID = NULL;
112 #endif
113
114 static WMPropList *sApplications = NULL;
115 static WMPropList *sCommand;
116 static WMPropList *sName;
117 static WMPropList *sHost;
118 static WMPropList *sWorkspace;
119 static WMPropList *sShaded;
120 static WMPropList *sMiniaturized;
121 static WMPropList *sHidden;
122 static WMPropList *sGeometry;
123 static WMPropList *sShortcutMask;
124
125 static WMPropList *sDock;
126
127 static WMPropList *sYes, *sNo;
128
129 static void make_keys()
130 {
131 if (sApplications != NULL)
132 return;
133
134 sApplications = WMCreatePLString("Applications");
135 sCommand = WMCreatePLString("Command");
136 sName = WMCreatePLString("Name");
137 sHost = WMCreatePLString("Host");
138 sWorkspace = WMCreatePLString("Workspace");
139 sShaded = WMCreatePLString("Shaded");
140 sMiniaturized = WMCreatePLString("Miniaturized");
141 sHidden = WMCreatePLString("Hidden");
142 sGeometry = WMCreatePLString("Geometry");
143 sDock = WMCreatePLString("Dock");
144 sShortcutMask = WMCreatePLString("ShortcutMask");
145
146 sYes = WMCreatePLString("Yes");
147 sNo = WMCreatePLString("No");
148 }
149
150 static int getBool(WMPropList * value)
151 {
152 char *val;
153
154 if (!WMIsPLString(value)) {
155 return 0;
156 }
157 if (!(val = WMGetFromPLString(value))) {
158 return 0;
159 }
160
161 if ((val[1] == '\0' && (val[0] == 'y' || val[0] == 'Y'))
162 || strcasecmp(val, "YES") == 0) {
163
164 return 1;
165 } else if ((val[1] == '\0' && (val[0] == 'n' || val[0] == 'N'))
166 || strcasecmp(val, "NO") == 0) {
167 return 0;
168 } else {
169 int i;
170 if (sscanf(val, "%i", &i) == 1) {
171 return (i != 0);
172 } else {
173 wwarning(_("can't convert \"%s\" to boolean"), val);
174 return 0;
175 }
176 }
177 }
178
179 static unsigned getInt(WMPropList * value)
180 {
181 char *val;
182 unsigned n;
183
184 if (!WMIsPLString(value))
185 return 0;
186 val = WMGetFromPLString(value);
187 if (!val)
188 return 0;
189 if (sscanf(val, "%u", &n) != 1)
190 return 0;
191
192 return n;
193 }
194
195 static WMPropList *makeWindowState(WWindow * wwin, WApplication * wapp)
196 {
197 WScreen *scr = wwin->screen_ptr;
198 Window win;
199 int i;
200 unsigned mask;
201 char *class, *instance, *command = NULL, buffer[512];
202 WMPropList *win_state, *cmd, *name, *workspace;
203 WMPropList *shaded, *miniaturized, *hidden, *geometry;
204 WMPropList *dock, *shortcut;
205
206 if (wwin->orig_main_window != None && wwin->orig_main_window != wwin->client_win)
207 win = wwin->orig_main_window;
208 else
209 win = wwin->client_win;
210
211 command = GetCommandForWindow(win);
212 if (!command)
213 return NULL;
214
215 if (PropGetWMClass(win, &class, &instance)) {
216 if (class && instance)
217 snprintf(buffer, sizeof(buffer), "%s.%s", instance, class);
218 else if (instance)
219 snprintf(buffer, sizeof(buffer), "%s", instance);
220 else if (class)
221 snprintf(buffer, sizeof(buffer), ".%s", class);
222 else
223 snprintf(buffer, sizeof(buffer), ".");
224
225 name = WMCreatePLString(buffer);
226 cmd = WMCreatePLString(command);
227 /*sprintf(buffer, "%d", wwin->frame->workspace+1);
228 workspace = WMCreatePLString(buffer); */
229 workspace = WMCreatePLString(scr->workspaces[wwin->frame->workspace]->name);
230 shaded = wwin->flags.shaded ? sYes : sNo;
231 miniaturized = wwin->flags.miniaturized ? sYes : sNo;
232 hidden = wwin->flags.hidden ? sYes : sNo;
233 snprintf(buffer, sizeof(buffer), "%ix%i+%i+%i",
234 wwin->client.width, wwin->client.height, wwin->frame_x, wwin->frame_y);
235 geometry = WMCreatePLString(buffer);
236
237 for (mask = 0, i = 0; i < MAX_WINDOW_SHORTCUTS; i++) {
238 if (scr->shortcutWindows[i] != NULL &&
239 WMGetFirstInArray(scr->shortcutWindows[i], wwin) != WANotFound) {
240 mask |= 1 << i;
241 }
242 }
243
244 snprintf(buffer, sizeof(buffer), "%u", mask);
245 shortcut = WMCreatePLString(buffer);
246
247 win_state = WMCreatePLDictionary(sName, name,
248 sCommand, cmd,
249 sWorkspace, workspace,
250 sShaded, shaded,
251 sMiniaturized, miniaturized,
252 sHidden, hidden,
253 sShortcutMask, shortcut, sGeometry, geometry, NULL);
254
255 WMReleasePropList(name);
256 WMReleasePropList(cmd);
257 WMReleasePropList(workspace);
258 WMReleasePropList(geometry);
259 WMReleasePropList(shortcut);
260 if (wapp && wapp->app_icon && wapp->app_icon->dock) {
261 int i;
262 char *name;
263 if (wapp->app_icon->dock == scr->dock) {
264 name = "Dock";
265 } else {
266 for (i = 0; i < scr->workspace_count; i++)
267 if (scr->workspaces[i]->clip == wapp->app_icon->dock)
268 break;
269 assert(i < scr->workspace_count);
270 /*n = i+1; */
271 name = scr->workspaces[i]->name;
272 }
273 dock = WMCreatePLString(name);
274 WMPutInPLDictionary(win_state, sDock, dock);
275 WMReleasePropList(dock);
276 }
277 } else {
278 win_state = NULL;
279 }
280
281 if (instance)
282 XFree(instance);
283 if (class)
284 XFree(class);
285 if (command)
286 wfree(command);
287
288 return win_state;
289 }
290
291 void wSessionSaveState(WScreen * scr)
292 {
293 WWindow *wwin = scr->focused_window;
294 WMPropList *win_info, *wks;
295 WMPropList *list = NULL;
296 WMArray *wapp_list = NULL;
297
298 make_keys();
299
300 if (!scr->session_state) {
301 scr->session_state = WMCreatePLDictionary(NULL, NULL);
302 if (!scr->session_state)
303 return;
304 }
305
306 list = WMCreatePLArray(NULL);
307
308 wapp_list = WMCreateArray(16);
309
310 while (wwin) {
311 WApplication *wapp = wApplicationOf(wwin->main_window);
312 Window appId = wwin->orig_main_window;
313
314 if ((wwin->transient_for == None || wwin->transient_for == wwin->screen_ptr->root_win)
315 && WMGetFirstInArray(wapp_list, (void *)appId) == WANotFound
316 && !WFLAGP(wwin, dont_save_session)) {
317 /* A entry for this application was not yet saved. Save one. */
318 if ((win_info = makeWindowState(wwin, wapp)) != NULL) {
319 WMAddToPLArray(list, win_info);
320 WMReleasePropList(win_info);
321 /* If we were succesful in saving the info for this window
322 * add the application the window belongs to, to the
323 * application list, so no multiple entries for the same
324 * application are saved.
325 */
326 WMAddToArray(wapp_list, (void *)appId);
327 }
328 }
329 wwin = wwin->prev;
330 }
331 WMRemoveFromPLDictionary(scr->session_state, sApplications);
332 WMPutInPLDictionary(scr->session_state, sApplications, list);
333 WMReleasePropList(list);
334
335 wks = WMCreatePLString(scr->workspaces[scr->current_workspace]->name);
336 WMPutInPLDictionary(scr->session_state, sWorkspace, wks);
337 WMReleasePropList(wks);
338
339 WMFreeArray(wapp_list);
340 }
341
342 void wSessionClearState(WScreen * scr)
343 {
344 make_keys();
345
346 if (!scr->session_state)
347 return;
348
349 WMRemoveFromPLDictionary(scr->session_state, sApplications);
350 WMRemoveFromPLDictionary(scr->session_state, sWorkspace);
351 }
352
353 static pid_t execCommand(WScreen * scr, char *command, char *host)
354 {
355 pid_t pid;
356 char **argv;
357 int argc;
358
359 wtokensplit(command, &argv, &argc);
360
361 if (!argc) {
362 return 0;
363 }
364
365 if ((pid = fork()) == 0) {
366 char **args;
367 int i;
368
369 SetupEnvironment(scr);
370
371 args = malloc(sizeof(char *) * (argc + 1));
372 if (!args)
373 exit(111);
374 for (i = 0; i < argc; i++) {
375 args[i] = argv[i];
376 }
377 args[argc] = NULL;
378 execvp(argv[0], args);
379 exit(111);
380 }
381 while (argc > 0)
382 wfree(argv[--argc]);
383 wfree(argv);
384 return pid;
385 }
386
387 static WSavedState *getWindowState(WScreen * scr, WMPropList * win_state)
388 {
389 WSavedState *state = wmalloc(sizeof(WSavedState));
390 WMPropList *value;
391 char *tmp;
392 unsigned mask;
393 int i;
394
395 memset(state, 0, sizeof(WSavedState));
396 state->workspace = -1;
397 value = WMGetFromPLDictionary(win_state, sWorkspace);
398 if (value && WMIsPLString(value)) {
399 tmp = WMGetFromPLString(value);
400 if (sscanf(tmp, "%i", &state->workspace) != 1) {
401 state->workspace = -1;
402 for (i = 0; i < scr->workspace_count; i++) {
403 if (strcmp(scr->workspaces[i]->name, tmp) == 0) {
404 state->workspace = i;
405 break;
406 }
407 }
408 } else {
409 state->workspace--;
410 }
411 }
412 if ((value = WMGetFromPLDictionary(win_state, sShaded)) != NULL)
413 state->shaded = getBool(value);
414 if ((value = WMGetFromPLDictionary(win_state, sMiniaturized)) != NULL)
415 state->miniaturized = getBool(value);
416 if ((value = WMGetFromPLDictionary(win_state, sHidden)) != NULL)
417 state->hidden = getBool(value);
418 if ((value = WMGetFromPLDictionary(win_state, sShortcutMask)) != NULL) {
419 mask = getInt(value);
420 state->window_shortcuts = mask;
421 }
422
423 value = WMGetFromPLDictionary(win_state, sGeometry);
424 if (value && WMIsPLString(value)) {
425 if (!(sscanf(WMGetFromPLString(value), "%ix%i+%i+%i",
426 &state->w, &state->h, &state->x, &state->y) == 4 && (state->w > 0 && state->h > 0))) {
427 state->w = 0;
428 state->h = 0;
429 }
430 }
431
432 return state;
433 }
434
435 #define SAME(x, y) (((x) && (y) && !strcmp((x), (y))) || (!(x) && !(y)))
436
437 void wSessionRestoreState(WScreen * scr)
438 {
439 WSavedState *state;
440 char *instance, *class, *command, *host;
441 WMPropList *win_info, *apps, *cmd, *value;
442 pid_t pid;
443 int i, count;
444 WDock *dock;
445 WAppIcon *btn = NULL;
446 int j, n, found;
447 char *tmp;
448
449 make_keys();
450
451 if (!scr->session_state)
452 return;
453
454 WMPLSetCaseSensitive(True);
455
456 apps = WMGetFromPLDictionary(scr->session_state, sApplications);
457 if (!apps)
458 return;
459
460 count = WMGetPropListItemCount(apps);
461 if (count == 0)
462 return;
463
464 for (i = 0; i < count; i++) {
465 win_info = WMGetFromPLArray(apps, i);
466
467 cmd = WMGetFromPLDictionary(win_info, sCommand);
468 if (!cmd || !WMIsPLString(cmd) || !(command = WMGetFromPLString(cmd))) {
469 continue;
470 }
471
472 value = WMGetFromPLDictionary(win_info, sName);
473 if (!value)
474 continue;
475
476 ParseWindowName(value, &instance, &class, "session");
477 if (!instance && !class)
478 continue;
479
480 value = WMGetFromPLDictionary(win_info, sHost);
481 if (value && WMIsPLString(value))
482 host = WMGetFromPLString(value);
483 else
484 host = NULL;
485
486 state = getWindowState(scr, win_info);
487
488 dock = NULL;
489 value = WMGetFromPLDictionary(win_info, sDock);
490 if (value && WMIsPLString(value) && (tmp = WMGetFromPLString(value)) != NULL) {
491 if (sscanf(tmp, "%i", &n) != 1) {
492 if (!strcasecmp(tmp, "DOCK")) {
493 dock = scr->dock;
494 } else {
495 for (j = 0; j < scr->workspace_count; j++) {
496 if (strcmp(scr->workspaces[j]->name, tmp) == 0) {
497 dock = scr->workspaces[j]->clip;
498 break;
499 }
500 }
501 }
502 } else {
503 if (n == 0) {
504 dock = scr->dock;
505 } else if (n > 0 && n <= scr->workspace_count) {
506 dock = scr->workspaces[n - 1]->clip;
507 }
508 }
509 }
510
511 found = 0;
512 if (dock != NULL) {
513 for (j = 0; j < dock->max_icons; j++) {
514 btn = dock->icon_array[j];
515 if (btn && SAME(instance, btn->wm_instance) &&
516 SAME(class, btn->wm_class) && SAME(command, btn->command) && !btn->launching) {
517 found = 1;
518 break;
519 }
520 }
521 }
522
523 if (found) {
524 wDockLaunchWithState(dock, btn, state);
525 } else if ((pid = execCommand(scr, command, host)) > 0) {
526 wWindowAddSavedState(instance, class, command, pid, state);
527 } else {
528 wfree(state);
529 }
530
531 if (instance)
532 wfree(instance);
533 if (class)
534 wfree(class);
535 }
536 /* clean up */
537 WMPLSetCaseSensitive(False);
538 }
539
540 void wSessionRestoreLastWorkspace(WScreen * scr)
541 {
542 WMPropList *wks;
543 int w, i;
544 char *tmp;
545
546 make_keys();
547
548 if (!scr->session_state)
549 return;
550
551 WMPLSetCaseSensitive(True);
552
553 wks = WMGetFromPLDictionary(scr->session_state, sWorkspace);
554 if (!wks || !WMIsPLString(wks))
555 return;
556
557 tmp = WMGetFromPLString(wks);
558
559 /* clean up */
560 WMPLSetCaseSensitive(False);
561
562 if (sscanf(tmp, "%i", &w) != 1) {
563 w = -1;
564 for (i = 0; i < scr->workspace_count; i++) {
565 if (strcmp(scr->workspaces[i]->name, tmp) == 0) {
566 w = i;
567 break;
568 }
569 }
570 } else {
571 w--;
572 }
573
574 if (w != scr->current_workspace && w < scr->workspace_count) {
575 wWorkspaceChange(scr, w);
576 }
577 }
578
579 static void clearWaitingAckState(WScreen * scr)
580 {
581 WWindow *wwin;
582 WApplication *wapp;
583
584 for (wwin = scr->focused_window; wwin != NULL; wwin = wwin->prev) {
585 wwin->flags.waiting_save_ack = 0;
586 if (wwin->main_window != None) {
587 wapp = wApplicationOf(wwin->main_window);
588 if (wapp)
589 wapp->main_window_desc->flags.waiting_save_ack = 0;
590 }
591 }
592 }
593
594 void wSessionSaveClients(WScreen * scr)
595 {
596
597 }
598
599 /*
600 * With XSMP, this job is done by smproxy
601 */
602 void wSessionSendSaveYourself(WScreen * scr)
603 {
604 WWindow *wwin;
605 int count;
606
607 /* freeze client interaction with clients */
608 XGrabKeyboard(dpy, scr->root_win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
609 XGrabPointer(dpy, scr->root_win, False, ButtonPressMask | ButtonReleaseMask,
610 GrabModeAsync, GrabModeAsync, scr->root_win, None, CurrentTime);
611
612 clearWaitingAckState(scr);
613
614 count = 0;
615
616 /* first send SAVE_YOURSELF for everybody */
617 for (wwin = scr->focused_window; wwin != NULL; wwin = wwin->prev) {
618 WWindow *mainWin;
619
620 mainWin = wWindowFor(wwin->main_window);
621
622 if (mainWin) {
623 /* if the client is a multi-window client, only send message
624 * to the main window */
625 wwin = mainWin;
626 }
627
628 /* make sure the SAVE_YOURSELF flag is up-to-date */
629 PropGetProtocols(wwin->client_win, &wwin->protocols);
630
631 if (wwin->protocols.SAVE_YOURSELF) {
632 if (!wwin->flags.waiting_save_ack) {
633 wClientSendProtocol(wwin, _XA_WM_SAVE_YOURSELF, LastTimestamp);
634
635 wwin->flags.waiting_save_ack = 1;
636 count++;
637 }
638 } else {
639 wwin->flags.waiting_save_ack = 0;
640 }
641 }
642
643 /* then wait for acknowledge */
644 while (count > 0) {
645
646 }
647
648 XUngrabPointer(dpy, CurrentTime);
649 XUngrabKeyboard(dpy, CurrentTime);
650 XFlush(dpy);
651 }
652
653 #ifdef XSMP_ENABLED
654 /*
655 * With full session management support, the part of WMState
656 * that store client window state will become obsolete (maybe we can reuse
657 * the old code too),
658 * but we still need to store state info like the dock and workspaces.
659 * It is better to keep dock/wspace info in WMState because the user
660 * might want to keep the dock configuration while not wanting to
661 * resume a previously saved session.
662 * So, wmaker specific state info can be saved in
663 * ~/GNUstep/Library/WindowMaker/statename.state
664 * Its better to not put it in the defaults directory because:
665 * - its not a defaults file (having domain names like wmaker0089504baa
666 * in the defaults directory wouldn't be very neat)
667 * - this state file is not meant to be edited by users
668 *
669 * The old session code will become obsolete. When wmaker is
670 * compiled with R6 sm support compiled in, it'll be better to
671 * use a totally rewritten state saving code, but we can keep
672 * the current code for when XSMP_ENABLED is not compiled in.
673 *
674 * This will be confusing to old users (well get lots of "SAVE_SESSION broke!"
675 * messages), but it'll be better.
676 *
677 * -readme
678 */
679
680 static char *getWindowRole(Window window)
681 {
682 XTextProperty prop;
683 static Atom atom = 0;
684
685 if (!atom)
686 atom = XInternAtom(dpy, "WM_WINDOW_ROLE", False);
687
688 if (XGetTextProperty(dpy, window, &prop, atom)) {
689 if (prop.encoding == XA_STRING && prop.format == 8 && prop.nitems > 0)
690 return prop.value;
691 }
692
693 return NULL;
694 }
695
696 /*
697 *
698 * Saved Info:
699 *
700 * WM_WINDOW_ROLE
701 *
702 * WM_CLASS.instance
703 * WM_CLASS.class
704 * WM_NAME
705 * WM_COMMAND
706 *
707 * geometry
708 * state = (miniaturized, shaded, etc)
709 * attribute
710 * workspace #
711 * app state = (which dock, hidden)
712 * window shortcut #
713 */
714
715 static WMPropList *makeAppState(WWindow * wwin)
716 {
717 WApplication *wapp;
718 WMPropList *state;
719 WScreen *scr = wwin->screen_ptr;
720
721 state = WMCreatePLArray(NULL, NULL);
722
723 wapp = wApplicationOf(wwin->main_window);
724
725 if (wapp) {
726 if (wapp->app_icon && wapp->app_icon->dock) {
727
728 if (wapp->app_icon->dock == scr->dock) {
729 WMAddToPLArray(state, WMCreatePLString("Dock"));
730 } else {
731 int i;
732
733 for (i = 0; i < scr->workspace_count; i++)
734 if (scr->workspaces[i]->clip == wapp->app_icon->dock)
735 break;
736
737 assert(i < scr->workspace_count);
738
739 WMAddToPLArray(state, WMCreatePLString(scr->workspaces[i]->name));
740 }
741 }
742
743 WMAddToPLArray(state, WMCreatePLString(wapp->hidden ? "1" : "0"));
744 }
745
746 return state;
747 }
748
749 Bool wSessionGetStateFor(WWindow * wwin, WSessionData * state)
750 {
751 char *str;
752 WMPropList *slist;
753 WMPropList *elem;
754 WMPropList *value;
755 int index = 0;
756
757 index = 3;
758
759 /* geometry */
760 value = WMGetFromPLArray(slist, index++);
761 str = WMGetFromPLString(value);
762
763 sscanf(str, "%i %i %i %i %i %i", &state->x, &state->y,
764 &state->width, &state->height, &state->user_changed_width, &state->user_changed_height);
765
766 /* state */
767 value = WMGetFromPLArray(slist, index++);
768 str = WMGetFromPLString(value);
769
770 sscanf(str, "%i %i %i", &state->miniaturized, &state->shaded, &state->maximized);
771
772 /* attributes */
773 value = WMGetFromPLArray(slist, index++);
774 str = WMGetFromPLString(value);
775
776 getAttributeState(str, &state->mflags, &state->flags);
777
778 /* workspace */
779 value = WMGetFromPLArray(slist, index++);
780 str = WMGetFromPLString(value);
781
782 sscanf(str, "%i", &state->workspace);
783
784 /* app state (repeated for all windows of the app) */
785 value = WMGetFromPLArray(slist, index++);
786 str = WMGetFromPLString(value);
787
788 /* ???? */
789
790 /* shortcuts */
791 value = WMGetFromPLArray(slist, index++);
792 str = WMGetFromPLString(value);
793
794 sscanf(str, "%i", &state->shortcuts);
795 }
796
797 static WMPropList *makeAttributeState(WWindow * wwin)
798 {
799 unsigned int data1, data2;
800 char buffer[256];
801
802 #define W_FLAG(wwin, FLAG) ((wwin)->defined_user_flags.FLAG \
803 ? (wwin)->user_flags.FLAG : -1)
804
805 snprintf(buffer, sizeof(buffer),
806 "%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
807 W_FLAG(no_titlebar),
808 W_FLAG(no_resizable),
809 W_FLAG(no_closable),
810 W_FLAG(no_miniaturizable),
811 W_FLAG(no_resizebar), W_FLAG(no_close_button), W_FLAG(no_miniaturize_button),
812 /*
813 W_FLAG(broken_close),
814 W_FLAG(kill_close),
815 */
816 W_FLAG(no_shadeable),
817 W_FLAG(omnipresent),
818 W_FLAG(skip_window_list),
819 W_FLAG(floating),
820 W_FLAG(sunken),
821 W_FLAG(no_bind_keys),
822 W_FLAG(no_bind_mouse),
823 W_FLAG(no_hide_others),
824 W_FLAG(no_appicon),
825 W_FLAG(dont_move_off),
826 W_FLAG(no_focusable),
827 W_FLAG(always_user_icon),
828 W_FLAG(start_miniaturized),
829 W_FLAG(start_hidden),
830 W_FLAG(start_maximized), W_FLAG(dont_save_session), W_FLAG(emulate_appicon));
831
832 return WMCreatePLString(buffer);
833 }
834
835 static void appendStringInArray(WMPropList * array, char *str)
836 {
837 WMPropList *val;
838
839 val = WMCreatePLString(str);
840 WMAddToPLArray(array, val);
841 WMReleasePropList(val);
842 }
843
844 static WMPropList *makeClientState(WWindow * wwin)
845 {
846 WMPropList *state;
847 WMPropList *tmp;
848 char *str;
849 char buffer[512];
850 int i;
851 unsigned shortcuts;
852
853 state = WMCreatePLArray(NULL, NULL);
854
855 /* WM_WINDOW_ROLE */
856 str = getWindowRole(wwin->client_win);
857 if (!str)
858 appendStringInArray(state, "");
859 else {
860 appendStringInArray(state, str);
861 XFree(str);
862 }
863
864 /* WM_CLASS.instance */
865 appendStringInArray(state, wwin->wm_instance);
866
867 /* WM_CLASS.class */
868 appendStringInArray(state, wwin->wm_class);
869
870 /* WM_NAME */
871 if (wwin->flags.wm_name_changed)
872 appendStringInArray(state, "");
873 else
874 appendStringInArray(state, wwin->frame->name);
875
876 /* geometry */
877 snprintf(buffer, sizeof(buffer), "%i %i %i %i %i %i", wwin->frame_x, wwin->frame_y,
878 wwin->client.width, wwin->client.height,
879 wwin->flags.user_changed_width, wwin->flags.user_changed_height);
880 appendStringInArray(state, buffer);
881
882 /* state */
883 snprintf(buffer, sizeof(buffer), "%i %i %i", wwin->flags.miniaturized,
884 wwin->flags.shaded, wwin->flags.maximized);
885 appendStringInArray(state, buffer);
886
887 /* attributes */
888 tmp = makeAttributeState(wwin);
889 WMAddToPLArray(state, tmp);
890 WMReleasePropList(tmp);
891
892 /* workspace */
893 snprintf(buffer, sizeof(buffer), "%i", wwin->frame->workspace);
894 appendStringInArray(state, buffer);
895
896 /* app state (repeated for all windows of the app) */
897 tmp = makeAppState(wwin);
898 WMAddToPLArray(state, tmp);
899 WMReleasePropList(tmp);
900
901 /* shortcuts */
902 shortcuts = 0;
903 for (i = 0; i < MAX_WINDOW_SHORTCUTS; i++) {
904 if (scr->shortcutWindow[i] == wwin) {
905 shortcuts |= 1 << i;
906 }
907 }
908 snprintf(buffer, sizeof(buffer), "%ui", shortcuts);
909 appendStringInArray(tmp, buffer);
910
911 return state;
912 }
913
914 static void smSaveYourselfPhase2Proc(SmcConn smc_conn, SmPointer client_data)
915 {
916 SmProp props[4];
917 SmPropValue prop1val, prop2val, prop3val, prop4val;
918 char **argv = (char **)client_data;
919 int argc;
920 int i, j;
921 Bool ok = False;
922 char *statefile = NULL;
923 char *prefix;
924 Bool gsPrefix = False;
925 char *discardCmd = NULL;
926 time_t t;
927 WMPropList *state, *plState;
928 int len;
929
930 #ifdef DEBUG1
931 puts("received SaveYourselfPhase2 SM message");
932 #endif
933
934 /* save session state */
935
936 /* the file that will contain the state */
937 prefix = getenv("SM_SAVE_DIR");
938 if (!prefix) {
939 prefix = wusergnusteppath();
940 if (prefix)
941 gsPrefix = True;
942 }
943 if (!prefix) {
944 prefix = getenv("HOME");
945 }
946 if (!prefix)
947 prefix = ".";
948
949 len = strlen(prefix) + 64;
950 statefile = malloc(len);
951 if (!statefile) {
952 wwarning(_("out of memory while saving session state"));
953 goto fail;
954 }
955
956 t = time();
957 i = 0;
958 do {
959 if (gsPrefix)
960 snprintf(statefile, len, "%s/Library/WindowMaker/wmaker.%l%i.state", prefix, t, i);
961 else
962 snprintf(statefile, len, "%s/wmaker.%l%i.state", prefix, t, i);
963 i++;
964 } while (access(F_OK, statefile) != -1);
965
966 /* save the states of all windows we're managing */
967 state = WMCreatePLArray(NULL, NULL);
968
969 /*
970 * Format:
971 *
972 * state_file ::= dictionary with version_info ; state
973 * version_info ::= 'version' = '1';
974 * state ::= 'state' = array of screen_info
975 * screen_info ::= array of (screen number, window_info, window_info, ...)
976 * window_info ::=
977 */
978 for (i = 0; i < wScreenCount; i++) {
979 WScreen *scr;
980 WWindow *wwin;
981 char buf[32];
982 WMPropList *pscreen;
983
984 scr = wScreenWithNumber(i);
985
986 snprintf(buf, sizeof(buf), "%i", scr->screen);
987 pscreen = WMCreatePLArray(WMCreatePLString(buf), NULL);
988
989 wwin = scr->focused_window;
990 while (wwin) {
991 WMPropList *pwindow;
992
993 pwindow = makeClientState(wwin);
994 WMAddToPLArray(pscreen, pwindow);
995
996 wwin = wwin->prev;
997 }
998
999 WMAddToPLArray(state, pscreen);
1000 }
1001
1002 plState = WMCreatePLDictionary(WMCreatePLString("Version"),
1003 WMCreatePLString("1.0"), WMCreatePLString("Screens"), state, NULL);
1004
1005 WMWritePropListToFile(plState, statefile, False);
1006
1007 WMReleasePropList(plState);
1008
1009 /* set the remaining properties that we didn't set at
1010 * startup time */
1011
1012 for (argc = 0, i = 0; argv[i] != NULL; i++) {
1013 if (strcmp(argv[i], "-clientid") == 0 || strcmp(argv[i], "-restore") == 0) {
1014 i++;
1015 } else {
1016 argc++;
1017 }
1018 }
1019
1020 prop[0].name = SmRestartCommand;
1021 prop[0].type = SmLISTofARRAY8;
1022 prop[0].vals = malloc(sizeof(SmPropValue) * (argc + 4));
1023 prop[0].num_vals = argc + 4;
1024
1025 prop[1].name = SmCloneCommand;
1026 prop[1].type = SmLISTofARRAY8;
1027 prop[1].vals = malloc(sizeof(SmPropValue) * (argc));
1028 prop[1].num_vals = argc;
1029
1030 if (!prop[0].vals || !prop[1].vals) {
1031 wwarning(_("end of memory while saving session state"));
1032 goto fail;
1033 }
1034
1035 for (j = 0, i = 0; i < argc + 4; i++) {
1036 if (strcmp(argv[i], "-clientid") == 0 || strcmp(argv[i], "-restore") == 0) {
1037 i++;
1038 } else {
1039 prop[0].vals[j].value = argv[i];
1040 prop[0].vals[j].length = strlen(argv[i]);
1041 prop[1].vals[j].value = argv[i];
1042 prop[1].vals[j].length = strlen(argv[i]);
1043 j++;
1044 }
1045 }
1046 prop[0].vals[j].value = "-clientid";
1047 prop[0].vals[j].length = 9;
1048 j++;
1049 prop[0].vals[j].value = sClientID;
1050 prop[0].vals[j].length = strlen(sClientID);
1051 j++;
1052 prop[0].vals[j].value = "-restore";
1053 prop[0].vals[j].length = 11;
1054 j++;
1055 prop[0].vals[j].value = statefile;
1056 prop[0].vals[j].length = strlen(statefile);
1057
1058 {
1059 int len = strlen(statefile) + 8;
1060
1061 discardCmd = malloc(len);
1062 if (!discardCmd)
1063 goto fail;
1064 snprintf(discardCmd, len, "rm %s", statefile);
1065 }
1066 prop[2].name = SmDiscardCommand;
1067 prop[2].type = SmARRAY8;
1068 prop[2].vals[0] = discardCmd;
1069 prop[2].num_vals = 1;
1070
1071 SmcSetProperties(sSMCConn, 3, prop);
1072
1073 ok = True;
1074 fail:
1075 SmcSaveYourselfDone(smc_conn, ok);
1076
1077 if (prop[0].vals)
1078 wfree(prop[0].vals);
1079 if (prop[1].vals)
1080 wfree(prop[1].vals);
1081 if (discardCmd)
1082 wfree(discardCmd);
1083
1084 if (!ok) {
1085 remove(statefile);
1086 }
1087 if (statefile)
1088 wfree(statefile);
1089 }
1090
1091 static void
1092 smSaveYourselfProc(SmcConn smc_conn, SmPointer client_data, int save_type,
1093 Bool shutdown, int interact_style, Bool fast)
1094 {
1095 #ifdef DEBUG1
1096 puts("received SaveYourself SM message");
1097 #endif
1098
1099 if (!SmcRequestSaveYourselfPhase2(smc_conn, smSaveYourselfPhase2Proc, client_data)) {
1100
1101 SmcSaveYourselfDone(smc_conn, False);
1102 sWaitingPhase2 = False;
1103 } else {
1104 #ifdef DEBUG1
1105 puts("successfull request of SYS phase 2");
1106 #endif
1107 sWaitingPhase2 = True;
1108 }
1109 }
1110
1111 static void smDieProc(SmcConn smc_conn, SmPointer client_data)
1112 {
1113 #ifdef DEBUG1
1114 puts("received Die SM message");
1115 #endif
1116
1117 wSessionDisconnectManager();
1118
1119 Shutdown(WSExitMode, True);
1120 }
1121
1122 static void smSaveCompleteProc(SmcConn smc_conn)
1123 {
1124 /* it means that we can resume doing things that can change our state */
1125 #ifdef DEBUG1
1126 puts("received SaveComplete SM message");
1127 #endif
1128 }
1129
1130 static void smShutdownCancelledProc(SmcConn smc_conn, SmPointer client_data)
1131 {
1132 if (sWaitingPhase2) {
1133
1134 sWaitingPhase2 = False;
1135
1136 SmcSaveYourselfDone(smc_conn, False);
1137 }
1138 }
1139
1140 static void iceMessageProc(int fd, int mask, void *clientData)
1141 {
1142 IceConn iceConn = (IceConn) clientData;
1143
1144 IceProcessMessages(iceConn, NULL, NULL);
1145 }
1146
1147 static void iceIOErrorHandler(IceConnection ice_conn)
1148 {
1149 /* This is not fatal but can mean the session manager exited.
1150 * If the session manager exited normally we would get a
1151 * Die message, so this probably means an abnormal exit.
1152 * If the sm was the last client of session, then we'll die
1153 * anyway, otherwise we can continue doing our stuff.
1154 */
1155 wwarning(_("connection to the session manager was lost"));
1156 wSessionDisconnectManager();
1157 }
1158
1159 void wSessionConnectManager(char **argv, int argc)
1160 {
1161 IceConn iceConn;
1162 char *previous_id = NULL;
1163 char buffer[256];
1164 SmcCallbacks callbacks;
1165 unsigned long mask;
1166 char uid[32];
1167 char pid[32];
1168 SmProp props[4];
1169 SmPropValue prop1val, prop2val, prop3val, prop4val;
1170 char restartStyle;
1171 int i;
1172
1173 mask = SmcSaveYourselfProcMask | SmcDieProcMask | SmcSaveCompleteProcMask | SmcShutdownCancelledProcMask;
1174
1175 callbacks.save_yourself.callback = smSaveYourselfProc;
1176 callbacks.save_yourself.client_data = argv;
1177
1178 callbacks.die.callback = smDieProc;
1179 callbacks.die.client_data = NULL;
1180
1181 callbacks.save_complete.callback = smSaveCompleteProc;
1182 callbacks.save_complete.client_data = NULL;
1183
1184 callbacks.shutdown_cancelled.callback = smShutdownCancelledProc;
1185 callbacks.shutdown_cancelled.client_data = NULL;
1186
1187 for (i = 0; i < argc; i++) {
1188 if (strcmp(argv[i], "-clientid") == 0) {
1189 previous_id = argv[i + 1];
1190 break;
1191 }
1192 }
1193
1194 /* connect to the session manager */
1195 sSMCConn = SmcOpenConnection(NULL, NULL, SmProtoMajor, SmProtoMinor,
1196 mask, &callbacks, previous_id, &sClientID, 255, buffer);
1197 if (!sSMCConn) {
1198 return;
1199 }
1200 #ifdef DEBUG1
1201 puts("connected to the session manager");
1202 #endif
1203
1204 /* IceSetIOErrorHandler(iceIOErrorHandler); */
1205
1206 /* check for session manager clients */
1207 iceConn = SmcGetIceConnection(smcConn);
1208
1209 if (fcntl(IceConnectionNumber(iceConn), F_SETFD, FD_CLOEXEC) < 0) {
1210 wsyserror("error setting close-on-exec flag for ICE connection");
1211 }
1212
1213 sSMInputHandler = WMAddInputHandler(IceConnectionNumber(iceConn), WIReadMask, iceMessageProc, iceConn);
1214
1215 /* setup information about ourselves */
1216
1217 /* program name */
1218 prop1val.value = argv[0];
1219 prop1val.length = strlen(argv[0]);
1220 prop[0].name = SmProgram;
1221 prop[0].type = SmARRAY8;
1222 prop[0].num_vals = 1;
1223 prop[0].vals = &prop1val;
1224
1225 /* The XSMP doc from X11R6.1 says it contains the user name,
1226 * but every client implementation I saw places the uid # */
1227 snprintf(uid, sizeof(uid), "%i", getuid());
1228 prop2val.value = uid;
1229 prop2val.length = strlen(uid);
1230 prop[1].name = SmUserID;
1231 prop[1].type = SmARRAY8;
1232 prop[1].num_vals = 1;
1233 prop[1].vals = &prop2val;
1234
1235 /* Restart style. We should restart only if we were running when
1236 * the previous session finished. */
1237 restartStyle = SmRestartIfRunning;
1238 prop3val.value = &restartStyle;
1239 prop3val.length = 1;
1240 prop[2].name = SmRestartStyleHint;
1241 prop[2].type = SmCARD8;
1242 prop[2].num_vals = 1;
1243 prop[2].vals = &prop3val;
1244
1245 /* Our PID. Not required but might be usefull */
1246 snprintf(pid, sizeof(pid), "%i", getpid());
1247 prop4val.value = pid;
1248 prop4val.length = strlen(pid);
1249 prop[3].name = SmProcessID;
1250 prop[3].type = SmARRAY8;
1251 prop[3].num_vals = 1;
1252 prop[3].vals = &prop4val;
1253
1254 /* we'll set the rest of the hints later */
1255
1256 SmcSetProperties(sSMCConn, 4, props);
1257
1258 }
1259
1260 void wSessionDisconnectManager(void)
1261 {
1262 if (sSMCConn) {
1263 WMDeleteInputHandler(sSMInputHandler);
1264 sSMInputHandler = NULL;
1265
1266 SmcCloseConnection(sSMCConn, 0, NULL);
1267 sSMCConn = NULL;
1268 }
1269 }
1270
1271 void wSessionRequestShutdown(void)
1272 {
1273 /* request a shutdown to the session manager */
1274 if (sSMCConn)
1275 SmcRequestSaveYourself(sSMCConn, SmSaveBoth, True, SmInteractStyleAny, False, True);
1276 }
1277
1278 Bool wSessionIsManaged(void)
1279 {
1280 return sSMCConn != NULL;
1281 }
1282
1283 #endif /* !XSMP_ENABLED */