Merge branch 'backport' into work
[mikachu/openbox.git] / openbox / session.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    session.c for the Openbox window manager
4    Copyright (c) 2003-2007   Dana Jansens
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 /* This session code is largely inspired by metacity code. */
20
21 #include "session.h"
22
23 struct _ObClient;
24
25 GList *session_saved_state = NULL;
26 gint session_desktop = -1;
27 gint session_num_desktops = 0;
28 gboolean session_desktop_layout_present = FALSE;
29 ObDesktopLayout session_desktop_layout;
30 GSList *session_desktop_names = NULL;
31
32 #ifndef USE_SM
33 void session_startup(gint argc, gchar **argv) {}
34 void session_shutdown(gboolean permanent) {}
35 GList* session_state_find(struct _ObClient *c) { return NULL; }
36 void session_request_logout(gboolean silent) {}
37 #else
38
39 #include "debug.h"
40 #include "openbox.h"
41 #include "client.h"
42 #include "focus.h"
43 #include "gettext.h"
44 #include "obt/parse.h"
45 #include "obt/paths.h"
46
47 #include <time.h>
48 #include <errno.h>
49 #include <stdio.h>
50
51 #ifdef HAVE_UNISTD_H
52 #  include <sys/types.h>
53 #  include <unistd.h>
54 #endif
55
56 #include <X11/SM/SMlib.h>
57
58 #define SM_ERR_LEN 1024
59
60 static SmcConn  sm_conn;
61 static gint     sm_argc;
62 static gchar  **sm_argv;
63
64 /* Data saved from the first level save yourself */
65 typedef struct {
66     ObClient *focus_client;
67     gint      desktop;
68 } ObSMSaveData;
69
70 static gboolean session_connect();
71
72 static void session_load_file(const gchar *path);
73 static gboolean session_save_to_file(const ObSMSaveData *savedata);
74
75 static void session_setup_program();
76 static void session_setup_user();
77 static void session_setup_restart_style(gboolean restart);
78 static void session_setup_pid();
79 static void session_setup_priority();
80 static void session_setup_clone_command();
81 static void session_setup_restart_command();
82
83 static void sm_save_yourself(SmcConn conn, SmPointer data, gint save_type,
84                              Bool shutdown, gint interact_style, Bool fast);
85 static void sm_die(SmcConn conn, SmPointer data);
86 static void sm_save_complete(SmcConn conn, SmPointer data);
87 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data);
88
89 static gboolean session_state_cmp(ObSessionState *s, ObClient *c);
90 static void session_state_free(ObSessionState *state);
91
92 void session_startup(gint argc, gchar **argv)
93 {
94     gchar *dir;
95     ObtPaths *p;
96
97     if (!ob_sm_use) return;
98
99     sm_argc = argc;
100     sm_argv = argv;
101
102     p = obt_paths_new();
103     dir = g_build_filename(obt_paths_cache_home(p),
104                            "openbox", "sessions", NULL);
105     obt_paths_unref(p), p = NULL;
106
107     if (!obt_paths_mkdir_path(dir, 0700)) {
108         g_message(_("Unable to make directory \"%s\": %s"),
109                   dir, g_strerror(errno));
110     }
111
112     if (ob_sm_save_file != NULL) {
113         if (ob_sm_restore) {
114             ob_debug_type(OB_DEBUG_SM, "Loading from session file %s",
115                           ob_sm_save_file);
116             session_load_file(ob_sm_save_file);
117         }
118     } else {
119         gchar *filename;
120
121         /* this algo is from metacity */
122         filename = g_strdup_printf("%u-%u-%u.obs",
123                                    (guint)time(NULL),
124                                    (guint)getpid(),
125                                    g_random_int());
126         ob_sm_save_file = g_build_filename(dir, filename, NULL);
127         g_free(filename);
128     }
129
130     if (session_connect()) {
131         session_setup_program();
132         session_setup_user();
133         session_setup_restart_style(TRUE);
134         session_setup_pid();
135         session_setup_priority();
136         session_setup_clone_command();
137     }
138
139     g_free(dir);
140 }
141
142 void session_shutdown(gboolean permanent)
143 {
144     if (!ob_sm_use) return;
145
146     if (sm_conn) {
147         /* if permanent is true then we will change our session state so that
148            the SM won't run us again */
149         if (permanent)
150             session_setup_restart_style(FALSE);
151
152         SmcCloseConnection(sm_conn, 0, NULL);
153
154         while (session_saved_state) {
155             session_state_free(session_saved_state->data);
156             session_saved_state = g_list_delete_link(session_saved_state,
157                                                      session_saved_state);
158         }
159     }
160 }
161
162 /*! Connect to the session manager and set up our callback functions */
163 static gboolean session_connect(void)
164 {
165     SmcCallbacks cb;
166     gchar *oldid;
167     gchar sm_err[SM_ERR_LEN];
168
169     /* set up our callback functions */
170     cb.save_yourself.callback = sm_save_yourself;
171     cb.save_yourself.client_data = NULL;
172     cb.die.callback = sm_die;
173     cb.die.client_data = NULL;
174     cb.save_complete.callback = sm_save_complete;
175     cb.save_complete.client_data = NULL;
176     cb.shutdown_cancelled.callback = sm_shutdown_cancelled;
177     cb.shutdown_cancelled.client_data = NULL;
178
179     /* connect to the server */
180     oldid = ob_sm_id;
181     ob_debug_type(OB_DEBUG_SM, "Connecting to SM with id: %s",
182                   oldid ? oldid : "(null)");
183     sm_conn = SmcOpenConnection(NULL, NULL, 1, 0,
184                                 SmcSaveYourselfProcMask |
185                                 SmcDieProcMask |
186                                 SmcSaveCompleteProcMask |
187                                 SmcShutdownCancelledProcMask,
188                                 &cb, oldid, &ob_sm_id,
189                                 SM_ERR_LEN-1, sm_err);
190     g_free(oldid);
191     ob_debug_type(OB_DEBUG_SM, "Connected to SM with id: %s", ob_sm_id);
192     if (sm_conn == NULL)
193         ob_debug("Failed to connect to session manager: %s", sm_err);
194     return sm_conn != NULL;
195 }
196
197 static void session_setup_program(void)
198 {
199     SmPropValue vals = {
200         .value = sm_argv[0],
201         .length = strlen(sm_argv[0]) + 1
202     };
203     SmProp prop = {
204         .name = g_strdup(SmProgram),
205         .type = g_strdup(SmARRAY8),
206         .num_vals = 1,
207         .vals = &vals
208     };
209     SmProp *list = &prop;
210     ob_debug_type(OB_DEBUG_SM, "Setting program: %s", sm_argv[0]);
211     SmcSetProperties(sm_conn, 1, &list);
212     g_free(prop.name);
213     g_free(prop.type);
214 }
215
216 static void session_setup_user(void)
217 {
218     char *user = g_strdup(g_get_user_name());
219
220     SmPropValue vals = {
221         .value = user,
222         .length = strlen(user) + 1
223     };
224     SmProp prop = {
225         .name = g_strdup(SmUserID),
226         .type = g_strdup(SmARRAY8),
227         .num_vals = 1,
228         .vals = &vals
229     };
230     SmProp *list = &prop;
231     ob_debug_type(OB_DEBUG_SM, "Setting user: %s", user);
232     SmcSetProperties(sm_conn, 1, &list);
233     g_free(prop.name);
234     g_free(prop.type);
235     g_free(user);
236 }
237
238 static void session_setup_restart_style(gboolean restart)
239 {
240     gchar restart_hint = restart ? SmRestartImmediately : SmRestartIfRunning;
241
242     SmPropValue vals = {
243         .value = &restart_hint,
244         .length = 1
245     };
246     SmProp prop = {
247         .name = g_strdup(SmRestartStyleHint),
248         .type = g_strdup(SmCARD8),
249         .num_vals = 1,
250         .vals = &vals
251     };
252     SmProp *list = &prop;
253     ob_debug_type(OB_DEBUG_SM, "Setting restart: %d", restart);
254     SmcSetProperties(sm_conn, 1, &list);
255     g_free(prop.name);
256     g_free(prop.type);
257 }
258
259 static void session_setup_pid(void)
260 {
261     gchar *pid = g_strdup_printf("%ld", (glong) getpid());
262
263     SmPropValue vals = {
264         .value = pid,
265         .length = strlen(pid) + 1
266     };
267     SmProp prop = {
268         .name = g_strdup(SmProcessID),
269         .type = g_strdup(SmARRAY8),
270         .num_vals = 1,
271         .vals = &vals
272     };
273     SmProp *list = &prop;
274     ob_debug_type(OB_DEBUG_SM, "Setting pid: %s", pid);
275     SmcSetProperties(sm_conn, 1, &list);
276     g_free(prop.name);
277     g_free(prop.type);
278     g_free(pid);
279 }
280
281 /*! This is a gnome-session-manager extension */
282 static void session_setup_priority(void)
283 {
284     gchar priority = 20; /* 20 is a lower prioity to run before other apps */
285
286     SmPropValue vals = {
287         .value = &priority,
288         .length = 1
289     };
290     SmProp prop = {
291         .name = g_strdup("_GSM_Priority"),
292         .type = g_strdup(SmCARD8),
293         .num_vals = 1,
294         .vals = &vals
295     };
296     SmProp *list = &prop;
297     ob_debug_type(OB_DEBUG_SM, "Setting priority: %d", priority);
298     SmcSetProperties(sm_conn, 1, &list);
299     g_free(prop.name);
300     g_free(prop.type);
301 }
302
303 static void session_setup_clone_command(void)
304 {
305     gint i;
306
307     SmPropValue *vals = g_new(SmPropValue, sm_argc);
308     SmProp prop = {
309         .name = g_strdup(SmCloneCommand),
310         .type = g_strdup(SmLISTofARRAY8),
311         .num_vals = sm_argc,
312         .vals = vals
313     };
314     SmProp *list = &prop;
315
316     ob_debug_type(OB_DEBUG_SM, "Setting clone command: (%d)", sm_argc);
317     for (i = 0; i < sm_argc; ++i) {
318         vals[i].value = sm_argv[i];
319         vals[i].length = strlen(sm_argv[i]) + 1;
320         ob_debug_type(OB_DEBUG_SM, "    %s", vals[i].value);
321     }
322
323     SmcSetProperties(sm_conn, 1, &list);
324     g_free(prop.name);
325     g_free(prop.type);
326     g_free(vals);
327 }
328
329 static void session_setup_restart_command(void)
330 {
331     gint i;
332
333     SmPropValue *vals = g_new(SmPropValue, sm_argc + 4);
334     SmProp prop = {
335         .name = g_strdup(SmRestartCommand),
336         .type = g_strdup(SmLISTofARRAY8),
337         .num_vals = sm_argc + 4,
338         .vals = vals
339     };
340     SmProp *list = &prop;
341
342     ob_debug_type(OB_DEBUG_SM, "Setting restart command: (%d)", sm_argc+4);
343     for (i = 0; i < sm_argc; ++i) {
344         vals[i].value = sm_argv[i];
345         vals[i].length = strlen(sm_argv[i]) + 1;
346         ob_debug_type(OB_DEBUG_SM, "    %s", vals[i].value);
347     }
348
349     vals[i].value = g_strdup("--sm-client-id");
350     vals[i].length = strlen("--sm-client-id") + 1;
351     vals[i+1].value = ob_sm_id;
352     vals[i+1].length = strlen(ob_sm_id) + 1;
353     ob_debug_type(OB_DEBUG_SM, "    %s", vals[i].value);
354     ob_debug_type(OB_DEBUG_SM, "    %s", vals[i+1].value);
355
356     vals[i+2].value = g_strdup("--sm-save-file");
357     vals[i+2].length = strlen("--sm-save-file") + 1;
358     vals[i+3].value = ob_sm_save_file;
359     vals[i+3].length = strlen(ob_sm_save_file) + 1;
360     ob_debug_type(OB_DEBUG_SM, "    %s", vals[i+2].value);
361     ob_debug_type(OB_DEBUG_SM, "    %s", vals[i+3].value);
362
363     SmcSetProperties(sm_conn, 1, &list);
364     g_free(prop.name);
365     g_free(prop.type);
366     g_free(vals[i].value);
367     g_free(vals[i+2].value);
368     g_free(vals);
369 }
370
371 static ObSMSaveData *sm_save_get_data(void)
372 {
373     ObSMSaveData *savedata = g_new0(ObSMSaveData, 1);
374     /* save the active desktop and client.
375        we don't bother to preemptively save the other desktop state like
376        number and names of desktops, cuz those shouldn't be changing during
377        the save.. */
378     savedata->focus_client = focus_client;
379     savedata->desktop = screen_desktop;
380     return savedata;
381 }
382
383 static void sm_save_yourself_2(SmcConn conn, SmPointer data)
384 {
385     gboolean success;
386     ObSMSaveData *savedata = data;
387
388     /* save the current state */
389     ob_debug_type(OB_DEBUG_SM, "Session save phase 2 requested");
390     ob_debug_type(OB_DEBUG_SM,
391                   "  Saving session to file '%s'", ob_sm_save_file);
392     if (savedata == NULL)
393         savedata = sm_save_get_data();
394     success = session_save_to_file(savedata);
395     g_free(savedata);
396
397     /* tell the session manager how to restore this state */
398     if (success) session_setup_restart_command();
399
400     ob_debug_type(OB_DEBUG_SM, "Saving is done (success = %d)", success);
401     SmcSaveYourselfDone(conn, success);
402 }
403
404
405 static void sm_save_yourself(SmcConn conn, SmPointer data, gint save_type,
406                              Bool shutdown, gint interact_style, Bool fast)
407 {
408     ObSMSaveData *savedata = NULL;
409     gchar *vendor;
410
411     ob_debug_type(OB_DEBUG_SM, "Session save requested");
412
413     vendor = SmcVendor(sm_conn);
414     ob_debug_type(OB_DEBUG_SM, "Session manager's vendor: %s", vendor);
415
416     if (!strcmp(vendor, "KDE")) {
417         /* ksmserver guarantees that phase 1 will complete before allowing any
418            clients interaction, so we can save this sanely here before they
419            get messed up from interaction */
420         savedata = sm_save_get_data();
421     }
422     free(vendor);
423
424     if (!SmcRequestSaveYourselfPhase2(conn, sm_save_yourself_2, savedata)) {
425         ob_debug_type(OB_DEBUG_SM, "Requst for phase 2 failed");
426         g_free(savedata);
427         SmcSaveYourselfDone(conn, FALSE);
428     }
429 }
430
431 static void sm_die(SmcConn conn, SmPointer data)
432 {
433     ob_debug_type(OB_DEBUG_SM, "Die requested");
434     ob_exit(0);
435 }
436
437 static void sm_save_complete(SmcConn conn, SmPointer data)
438 {
439     ob_debug_type(OB_DEBUG_SM, "Save complete");
440 }
441
442 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data)
443 {
444     ob_debug_type(OB_DEBUG_SM, "Shutdown cancelled");
445 }
446
447 static gboolean session_save_to_file(const ObSMSaveData *savedata)
448 {
449     FILE *f;
450     GList *it;
451     gboolean success = TRUE;
452
453     f = fopen(ob_sm_save_file, "w");
454     if (!f) {
455         success = FALSE;
456         g_message(_("Unable to save the session to \"%s\": %s"),
457                   ob_sm_save_file, g_strerror(errno));
458     } else {
459         fprintf(f, "<?xml version=\"1.0\"?>\n\n");
460         fprintf(f, "<openbox_session>\n\n");
461
462         fprintf(f, "<desktop>%d</desktop>\n", savedata->desktop);
463
464         fprintf(f, "<numdesktops>%d</numdesktops>\n", screen_num_desktops);
465
466         fprintf(f, "<desktoplayout>\n");
467         fprintf(f, "  <orientation>%d</orientation>\n",
468                 screen_desktop_layout.orientation);
469         fprintf(f, "  <startcorner>%d</startcorner>\n",
470                 screen_desktop_layout.start_corner);
471         fprintf(f, "  <columns>%d</columns>\n",
472                 screen_desktop_layout.columns);
473         fprintf(f, "  <rows>%d</rows>\n",
474                 screen_desktop_layout.rows);
475         fprintf(f, "</desktoplayout>\n");
476
477         if (screen_desktop_names) {
478             gint i;
479
480             fprintf(f, "<desktopnames>\n");
481             for (i = 0; screen_desktop_names[i]; ++i)
482                 fprintf(f, "  <name>%s</name>\n", screen_desktop_names[i]);
483             fprintf(f, "</desktopnames>\n");
484         }
485
486         /* they are ordered top to bottom in stacking order */
487         for (it = stacking_list; it; it = g_list_next(it)) {
488             gint prex, prey, prew, preh;
489             ObClient *c;
490             gchar *t;
491
492             if (WINDOW_IS_CLIENT(it->data))
493                 c = WINDOW_AS_CLIENT(it->data);
494             else
495                 continue;
496
497             if (!client_normal(c))
498                 continue;
499
500             if (!c->sm_client_id) {
501                 ob_debug_type(OB_DEBUG_SM, "Client %s does not have a "
502                               "session id set",
503                               c->title);
504                 if (!c->wm_command) {
505                     ob_debug_type(OB_DEBUG_SM, "Client %s does not have an "
506                                   "oldskool wm_command set either. We won't "
507                                   "be saving its data",
508                                   c->title);
509                     continue;
510                 }
511             }
512
513             ob_debug_type(OB_DEBUG_SM, "Saving state for client %s",
514                           c->title);
515
516             prex = c->area.x;
517             prey = c->area.y;
518             prew = c->area.width;
519             preh = c->area.height;
520             if (c->fullscreen) {
521                 prex = c->pre_fullscreen_area.x;
522                 prey = c->pre_fullscreen_area.x;
523                 prew = c->pre_fullscreen_area.width;
524                 preh = c->pre_fullscreen_area.height;
525             }
526             if (c->max_horz) {
527                 prex = c->pre_max_area.x;
528                 prew = c->pre_max_area.width;
529             }
530             if (c->max_vert) {
531                 prey = c->pre_max_area.y;
532                 preh = c->pre_max_area.height;
533             }
534
535             if (c->sm_client_id)
536                 fprintf(f, "<window id=\"%s\">\n", c->sm_client_id);
537             else
538                 fprintf(f, "<window command=\"%s\">\n", c->wm_command);
539
540             t = g_markup_escape_text(c->name, -1);
541             fprintf(f, "\t<name>%s</name>\n", t);
542             g_free(t);
543
544             t = g_markup_escape_text(c->class, -1);
545             fprintf(f, "\t<class>%s</class>\n", t);
546             g_free(t);
547
548             t = g_markup_escape_text(c->role, -1);
549             fprintf(f, "\t<role>%s</role>\n", t);
550             g_free(t);
551
552             fprintf(f, "\t<windowtype>%d</windowtype>\n", c->type);
553
554             fprintf(f, "\t<desktop>%d</desktop>\n", c->desktop);
555             fprintf(f, "\t<x>%d</x>\n", prex);
556             fprintf(f, "\t<y>%d</y>\n", prey);
557             fprintf(f, "\t<width>%d</width>\n", prew);
558             fprintf(f, "\t<height>%d</height>\n", preh);
559             if (c->shaded)
560                 fprintf(f, "\t<shaded />\n");
561             if (c->iconic)
562                 fprintf(f, "\t<iconic />\n");
563             if (c->skip_pager)
564                 fprintf(f, "\t<skip_pager />\n");
565             if (c->skip_taskbar)
566                 fprintf(f, "\t<skip_taskbar />\n");
567             if (c->fullscreen)
568                 fprintf(f, "\t<fullscreen />\n");
569             if (c->above)
570                 fprintf(f, "\t<above />\n");
571             if (c->below)
572                 fprintf(f, "\t<below />\n");
573             if (c->max_horz)
574                 fprintf(f, "\t<max_horz />\n");
575             if (c->max_vert)
576                 fprintf(f, "\t<max_vert />\n");
577             if (c->undecorated)
578                 fprintf(f, "\t<undecorated />\n");
579             if (savedata->focus_client == c)
580                 fprintf(f, "\t<focused />\n");
581             fprintf(f, "</window>\n\n");
582         }
583
584         fprintf(f, "</openbox_session>\n");
585
586         if (fflush(f)) {
587             success = FALSE;
588             g_message(_("Error while saving the session to \"%s\": %s"),
589                       ob_sm_save_file, g_strerror(errno));
590         }
591         fclose(f);
592     }
593
594     return success;
595 }
596
597 static void session_state_free(ObSessionState *state)
598 {
599     if (state) {
600         g_free(state->id);
601         g_free(state->command);
602         g_free(state->name);
603         g_free(state->class);
604         g_free(state->role);
605
606         g_free(state);
607     }
608 }
609
610 static gboolean session_state_cmp(ObSessionState *s, ObClient *c)
611 {
612     ob_debug_type(OB_DEBUG_SM, "Comparing client against saved state: ");
613     ob_debug_type(OB_DEBUG_SM, "  client id: %s ", c->sm_client_id);
614     ob_debug_type(OB_DEBUG_SM, "  client name: %s ", c->name);
615     ob_debug_type(OB_DEBUG_SM, "  client class: %s ", c->class);
616     ob_debug_type(OB_DEBUG_SM, "  client role: %s ", c->role);
617     ob_debug_type(OB_DEBUG_SM, "  client type: %d ", c->type);
618     ob_debug_type(OB_DEBUG_SM, "  client command: %s ",
619                   c->wm_command ? c->wm_command : "(null)");
620     ob_debug_type(OB_DEBUG_SM, "  state id: %s ", s->id);
621     ob_debug_type(OB_DEBUG_SM, "  state name: %s ", s->name);
622     ob_debug_type(OB_DEBUG_SM, "  state class: %s ", s->class);
623     ob_debug_type(OB_DEBUG_SM, "  state role: %s ", s->role);
624     ob_debug_type(OB_DEBUG_SM, "  state type: %d ", s->type);
625     ob_debug_type(OB_DEBUG_SM, "  state command: %s ",
626                   s->command ? s->command : "(null)");
627
628     if ((c->sm_client_id && s->id && !strcmp(c->sm_client_id, s->id)) ||
629         (c->wm_command && s->command && !strcmp(c->wm_command, s->command)))
630     {
631         return (!strcmp(s->name, c->name) &&
632                 !strcmp(s->class, c->class) &&
633                 !strcmp(s->role, c->role) &&
634                 /* the check for type is to catch broken clients, like
635                    firefox, which open a different window on startup
636                    with the same info as the one we saved. only do this
637                    check for old windows that dont use xsmp, others should
638                    know better ! */
639                 (!s->command || c->type == s->type));
640     }
641     return FALSE;
642 }
643
644 GList* session_state_find(ObClient *c)
645 {
646     GList *it;
647
648     for (it = session_saved_state; it; it = g_list_next(it)) {
649         ObSessionState *s = it->data;
650         if (!s->matched && session_state_cmp(s, c)) {
651             s->matched = TRUE;
652             break;
653         }
654     }
655     return it;
656 }
657
658 static void session_load_file(const gchar *path)
659 {
660     ObtParseInst *i;
661     xmlNodePtr node, n, m;
662     GList *it, *inext;
663
664     i = obt_parse_instance_new();
665
666     if (!obt_parse_load_file(i, path, "openbox_session")) {
667         obt_parse_instance_unref(i);
668         return;
669     }
670     node = obt_parse_root(i);
671
672     if ((n = obt_parse_find_node(node->children, "desktop")))
673         session_desktop = obt_parse_node_int(n);
674
675     if ((n = obt_parse_find_node(node->children, "numdesktops")))
676         session_num_desktops = obt_parse_node_int(n);
677
678     if ((n = obt_parse_find_node(node->children, "desktoplayout"))) {
679         /* make sure they are all there for it to be valid */
680         if ((m = obt_parse_find_node(n->children, "orientation")))
681             session_desktop_layout.orientation = obt_parse_node_int(m);
682         if (m && (m = obt_parse_find_node(n->children, "startcorner")))
683             session_desktop_layout.start_corner = obt_parse_node_int(m);
684         if (m && (m = obt_parse_find_node(n->children, "columns")))
685             session_desktop_layout.columns = obt_parse_node_int(m);
686         if (m && (m = obt_parse_find_node(n->children, "rows")))
687             session_desktop_layout.rows = obt_parse_node_int(m);
688         session_desktop_layout_present = m != NULL;
689     }
690
691     if ((n = obt_parse_find_node(node->children, "desktopnames"))) {
692         for (m = obt_parse_find_node(n->children, "name"); m;
693              m = obt_parse_find_node(m->next, "name"))
694         {
695             session_desktop_names = g_slist_append(session_desktop_names,
696                                                    obt_parse_node_string(m));
697         }
698     }
699
700     for (node = obt_parse_find_node(node->children, "window"); node != NULL;
701          node = obt_parse_find_node(node->next, "window"))
702     {
703         ObSessionState *state;
704
705         state = g_new0(ObSessionState, 1);
706
707         if (!obt_parse_attr_string(node, "id", &state->id))
708             if (!obt_parse_attr_string(node, "command", &state->command))
709             goto session_load_bail;
710         if (!(n = obt_parse_find_node(node->children, "name")))
711             goto session_load_bail;
712         state->name = obt_parse_node_string(n);
713         if (!(n = obt_parse_find_node(node->children, "class")))
714             goto session_load_bail;
715         state->class = obt_parse_node_string(n);
716         if (!(n = obt_parse_find_node(node->children, "role")))
717             goto session_load_bail;
718         state->role = obt_parse_node_string(n);
719         if (!(n = obt_parse_find_node(node->children, "windowtype")))
720             goto session_load_bail;
721         state->type = obt_parse_node_int(n);
722         if (!(n = obt_parse_find_node(node->children, "desktop")))
723             goto session_load_bail;
724         state->desktop = obt_parse_node_int(n);
725         if (!(n = obt_parse_find_node(node->children, "x")))
726             goto session_load_bail;
727         state->x = obt_parse_node_int(n);
728         if (!(n = obt_parse_find_node(node->children, "y")))
729             goto session_load_bail;
730         state->y = obt_parse_node_int(n);
731         if (!(n = obt_parse_find_node(node->children, "width")))
732             goto session_load_bail;
733         state->w = obt_parse_node_int(n);
734         if (!(n = obt_parse_find_node(node->children, "height")))
735             goto session_load_bail;
736         state->h = obt_parse_node_int(n);
737
738         state->shaded =
739             obt_parse_find_node(node->children, "shaded") != NULL;
740         state->iconic =
741             obt_parse_find_node(node->children, "iconic") != NULL;
742         state->skip_pager =
743             obt_parse_find_node(node->children, "skip_pager") != NULL;
744         state->skip_taskbar =
745             obt_parse_find_node(node->children, "skip_taskbar") != NULL;
746         state->fullscreen =
747             obt_parse_find_node(node->children, "fullscreen") != NULL;
748         state->above =
749             obt_parse_find_node(node->children, "above") != NULL;
750         state->below =
751             obt_parse_find_node(node->children, "below") != NULL;
752         state->max_horz =
753             obt_parse_find_node(node->children, "max_horz") != NULL;
754         state->max_vert =
755             obt_parse_find_node(node->children, "max_vert") != NULL;
756         state->undecorated =
757             obt_parse_find_node(node->children, "undecorated") != NULL;
758         state->focused =
759             obt_parse_find_node(node->children, "focused") != NULL;
760
761         /* save this. they are in the file in stacking order, so preserve
762            that order here */
763         session_saved_state = g_list_append(session_saved_state, state);
764         continue;
765
766     session_load_bail:
767         session_state_free(state);
768     }
769
770     /* Remove any duplicates.  This means that if two windows (or more) are
771        saved with the same session state, we won't restore a session for any
772        of them because we don't know what window to put what on. AHEM FIREFOX.
773
774        This is going to be an O(2^n) kind of operation unfortunately.
775     */
776     for (it = session_saved_state; it; it = inext) {
777         GList *jt, *jnext;
778         gboolean founddup = FALSE;
779         ObSessionState *s1 = it->data;
780
781         inext = g_list_next(it);
782
783         for (jt = g_list_next(it); jt; jt = jnext) {
784             ObSessionState *s2 = jt->data;
785             gboolean match;
786
787             jnext = g_list_next(jt);
788
789             if (s1->id && s2->id)
790                 match = strcmp(s1->id, s2->id) == 0;
791             else if (s1->command && s2->command)
792                 match = strcmp(s1->command, s2->command) == 0;
793             else
794                 match = FALSE;
795
796             if (match &&
797                 !strcmp(s1->name, s2->name) &&
798                 !strcmp(s1->class, s2->class) &&
799                 !strcmp(s1->role, s2->role))
800             {
801                 session_state_free(s2);
802                 session_saved_state =
803                     g_list_delete_link(session_saved_state, jt);
804                 founddup = TRUE;
805             }
806         }
807
808         if (founddup) {
809             session_state_free(s1);
810             session_saved_state = g_list_delete_link(session_saved_state, it);
811         }
812     }
813
814     obt_parse_instance_unref(i);
815 }
816
817 void session_request_logout(gboolean silent)
818 {
819     if (sm_conn) {
820         SmcRequestSaveYourself(sm_conn,
821                                SmSaveBoth,
822                                TRUE, /* logout */
823                                (silent ?
824                                 SmInteractStyleNone : SmInteractStyleAny),
825                                TRUE,  /* if false, with GSM, it shows the old
826                                          logout prompt */
827                                TRUE); /* global */
828     }
829     else
830         g_message(_("Not connected to a session manager"));
831 }
832
833 #endif