Don't need to explicitly check for xft.
[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 static void sm_save_yourself(SmcConn conn, SmPointer data, gint save_type,
405                              Bool shutdown, gint interact_style, Bool fast)
406 {
407     ObSMSaveData *savedata = NULL;
408     gchar *vendor;
409
410 #ifdef DEBUG
411     {
412         const gchar *sname =
413             (save_type == SmSaveLocal ? "SmSaveLocal" :
414              (save_type == SmSaveGlobal ? "SmSaveGlobal" :
415               (save_type == SmSaveBoth ? "SmSaveBoth" : "INVALID!!")));
416         ob_debug_type(OB_DEBUG_SM, "Session save requested, type %s\n", sname);
417     }
418 #endif
419
420     if (save_type == SmSaveGlobal) {
421         /* we have no data to save.  we only store state to get back to where
422            we were, we don't keep open writable files or anything */
423         SmcSaveYourselfDone(conn, TRUE);
424         return;
425     }
426
427     vendor = SmcVendor(sm_conn);
428     ob_debug_type(OB_DEBUG_SM, "Session manager's vendor: %s", vendor);
429
430     if (!strcmp(vendor, "KDE")) {
431         /* ksmserver guarantees that phase 1 will complete before allowing any
432            clients interaction, so we can save this sanely here before they
433            get messed up from interaction */
434         savedata = sm_save_get_data();
435     }
436     free(vendor);
437
438     if (!SmcRequestSaveYourselfPhase2(conn, sm_save_yourself_2, savedata)) {
439         ob_debug_type(OB_DEBUG_SM, "Requst for phase 2 failed");
440         g_free(savedata);
441         SmcSaveYourselfDone(conn, FALSE);
442     }
443 }
444
445 static void sm_die(SmcConn conn, SmPointer data)
446 {
447     ob_debug_type(OB_DEBUG_SM, "Die requested");
448     ob_exit(0);
449 }
450
451 static void sm_save_complete(SmcConn conn, SmPointer data)
452 {
453     ob_debug_type(OB_DEBUG_SM, "Save complete");
454 }
455
456 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data)
457 {
458     ob_debug_type(OB_DEBUG_SM, "Shutdown cancelled");
459 }
460
461 static gboolean session_save_to_file(const ObSMSaveData *savedata)
462 {
463     FILE *f;
464     GList *it;
465     gboolean success = TRUE;
466
467     f = fopen(ob_sm_save_file, "w");
468     if (!f) {
469         success = FALSE;
470         g_message(_("Unable to save the session to \"%s\": %s"),
471                   ob_sm_save_file, g_strerror(errno));
472     } else {
473         fprintf(f, "<?xml version=\"1.0\"?>\n\n");
474         fprintf(f, "<openbox_session>\n\n");
475
476         fprintf(f, "<desktop>%d</desktop>\n", savedata->desktop);
477
478         fprintf(f, "<numdesktops>%d</numdesktops>\n", screen_num_desktops);
479
480         fprintf(f, "<desktoplayout>\n");
481         fprintf(f, "  <orientation>%d</orientation>\n",
482                 screen_desktop_layout.orientation);
483         fprintf(f, "  <startcorner>%d</startcorner>\n",
484                 screen_desktop_layout.start_corner);
485         fprintf(f, "  <columns>%d</columns>\n",
486                 screen_desktop_layout.columns);
487         fprintf(f, "  <rows>%d</rows>\n",
488                 screen_desktop_layout.rows);
489         fprintf(f, "</desktoplayout>\n");
490
491         if (screen_desktop_names) {
492             gint i;
493
494             fprintf(f, "<desktopnames>\n");
495             for (i = 0; screen_desktop_names[i]; ++i)
496                 fprintf(f, "  <name>%s</name>\n", screen_desktop_names[i]);
497             fprintf(f, "</desktopnames>\n");
498         }
499
500         /* they are ordered top to bottom in stacking order */
501         for (it = stacking_list; it; it = g_list_next(it)) {
502             gint prex, prey, prew, preh;
503             ObClient *c;
504             gchar *t;
505
506             if (WINDOW_IS_CLIENT(it->data))
507                 c = WINDOW_AS_CLIENT(it->data);
508             else
509                 continue;
510
511             if (!client_normal(c))
512                 continue;
513
514             if (!c->sm_client_id) {
515                 ob_debug_type(OB_DEBUG_SM, "Client %s does not have a "
516                               "session id set",
517                               c->title);
518                 if (!c->wm_command) {
519                     ob_debug_type(OB_DEBUG_SM, "Client %s does not have an "
520                                   "oldskool wm_command set either. We won't "
521                                   "be saving its data",
522                                   c->title);
523                     continue;
524                 }
525             }
526
527             ob_debug_type(OB_DEBUG_SM, "Saving state for client %s",
528                           c->title);
529
530             prex = c->area.x;
531             prey = c->area.y;
532             prew = c->area.width;
533             preh = c->area.height;
534             if (c->fullscreen) {
535                 prex = c->pre_fullscreen_area.x;
536                 prey = c->pre_fullscreen_area.x;
537                 prew = c->pre_fullscreen_area.width;
538                 preh = c->pre_fullscreen_area.height;
539             }
540             if (c->max_horz) {
541                 prex = c->pre_max_area.x;
542                 prew = c->pre_max_area.width;
543             }
544             if (c->max_vert) {
545                 prey = c->pre_max_area.y;
546                 preh = c->pre_max_area.height;
547             }
548
549             if (c->sm_client_id)
550                 fprintf(f, "<window id=\"%s\">\n", c->sm_client_id);
551             else
552                 fprintf(f, "<window command=\"%s\">\n", c->wm_command);
553
554             t = g_markup_escape_text(c->name, -1);
555             fprintf(f, "\t<name>%s</name>\n", t);
556             g_free(t);
557
558             t = g_markup_escape_text(c->class, -1);
559             fprintf(f, "\t<class>%s</class>\n", t);
560             g_free(t);
561
562             t = g_markup_escape_text(c->role, -1);
563             fprintf(f, "\t<role>%s</role>\n", t);
564             g_free(t);
565
566             fprintf(f, "\t<windowtype>%d</windowtype>\n", c->type);
567
568             fprintf(f, "\t<desktop>%d</desktop>\n", c->desktop);
569             fprintf(f, "\t<x>%d</x>\n", prex);
570             fprintf(f, "\t<y>%d</y>\n", prey);
571             fprintf(f, "\t<width>%d</width>\n", prew);
572             fprintf(f, "\t<height>%d</height>\n", preh);
573             if (c->shaded)
574                 fprintf(f, "\t<shaded />\n");
575             if (c->iconic)
576                 fprintf(f, "\t<iconic />\n");
577             if (c->skip_pager)
578                 fprintf(f, "\t<skip_pager />\n");
579             if (c->skip_taskbar)
580                 fprintf(f, "\t<skip_taskbar />\n");
581             if (c->fullscreen)
582                 fprintf(f, "\t<fullscreen />\n");
583             if (c->above)
584                 fprintf(f, "\t<above />\n");
585             if (c->below)
586                 fprintf(f, "\t<below />\n");
587             if (c->max_horz)
588                 fprintf(f, "\t<max_horz />\n");
589             if (c->max_vert)
590                 fprintf(f, "\t<max_vert />\n");
591             if (c->undecorated)
592                 fprintf(f, "\t<undecorated />\n");
593             if (savedata->focus_client == c)
594                 fprintf(f, "\t<focused />\n");
595             fprintf(f, "</window>\n\n");
596         }
597
598         fprintf(f, "</openbox_session>\n");
599
600         if (fflush(f)) {
601             success = FALSE;
602             g_message(_("Error while saving the session to \"%s\": %s"),
603                       ob_sm_save_file, g_strerror(errno));
604         }
605         fclose(f);
606     }
607
608     return success;
609 }
610
611 static void session_state_free(ObSessionState *state)
612 {
613     if (state) {
614         g_free(state->id);
615         g_free(state->command);
616         g_free(state->name);
617         g_free(state->class);
618         g_free(state->role);
619
620         g_free(state);
621     }
622 }
623
624 static gboolean session_state_cmp(ObSessionState *s, ObClient *c)
625 {
626     ob_debug_type(OB_DEBUG_SM, "Comparing client against saved state: ");
627     ob_debug_type(OB_DEBUG_SM, "  client id: %s ", c->sm_client_id);
628     ob_debug_type(OB_DEBUG_SM, "  client name: %s ", c->name);
629     ob_debug_type(OB_DEBUG_SM, "  client class: %s ", c->class);
630     ob_debug_type(OB_DEBUG_SM, "  client role: %s ", c->role);
631     ob_debug_type(OB_DEBUG_SM, "  client type: %d ", c->type);
632     ob_debug_type(OB_DEBUG_SM, "  client command: %s ",
633                   c->wm_command ? c->wm_command : "(null)");
634     ob_debug_type(OB_DEBUG_SM, "  state id: %s ", s->id);
635     ob_debug_type(OB_DEBUG_SM, "  state name: %s ", s->name);
636     ob_debug_type(OB_DEBUG_SM, "  state class: %s ", s->class);
637     ob_debug_type(OB_DEBUG_SM, "  state role: %s ", s->role);
638     ob_debug_type(OB_DEBUG_SM, "  state type: %d ", s->type);
639     ob_debug_type(OB_DEBUG_SM, "  state command: %s ",
640                   s->command ? s->command : "(null)");
641
642     if ((c->sm_client_id && s->id && !strcmp(c->sm_client_id, s->id)) ||
643         (c->wm_command && s->command && !strcmp(c->wm_command, s->command)))
644     {
645         return (!strcmp(s->name, c->name) &&
646                 !strcmp(s->class, c->class) &&
647                 !strcmp(s->role, c->role) &&
648                 /* the check for type is to catch broken clients, like
649                    firefox, which open a different window on startup
650                    with the same info as the one we saved. only do this
651                    check for old windows that dont use xsmp, others should
652                    know better ! */
653                 (!s->command || c->type == s->type));
654     }
655     return FALSE;
656 }
657
658 GList* session_state_find(ObClient *c)
659 {
660     GList *it;
661
662     for (it = session_saved_state; it; it = g_list_next(it)) {
663         ObSessionState *s = it->data;
664         if (!s->matched && session_state_cmp(s, c)) {
665             s->matched = TRUE;
666             break;
667         }
668     }
669     return it;
670 }
671
672 static void session_load_file(const gchar *path)
673 {
674     ObtParseInst *i;
675     xmlNodePtr node, n, m;
676     GList *it, *inext;
677
678     i = obt_parse_instance_new();
679
680     if (!obt_parse_load_file(i, path, "openbox_session")) {
681         ob_debug_type(OB_DEBUG_SM, "ERROR: session file is missing root node");
682         obt_parse_instance_unref(i);
683         return;
684     }
685     node = obt_parse_root(i);
686
687     if ((n = obt_parse_find_node(node->children, "desktop")))
688         session_desktop = obt_parse_node_int(n);
689
690     if ((n = obt_parse_find_node(node->children, "numdesktops")))
691         session_num_desktops = obt_parse_node_int(n);
692
693     if ((n = obt_parse_find_node(node->children, "desktoplayout"))) {
694         /* make sure they are all there for it to be valid */
695         if ((m = obt_parse_find_node(n->children, "orientation")))
696             session_desktop_layout.orientation = obt_parse_node_int(m);
697         if (m && (m = obt_parse_find_node(n->children, "startcorner")))
698             session_desktop_layout.start_corner = obt_parse_node_int(m);
699         if (m && (m = obt_parse_find_node(n->children, "columns")))
700             session_desktop_layout.columns = obt_parse_node_int(m);
701         if (m && (m = obt_parse_find_node(n->children, "rows")))
702             session_desktop_layout.rows = obt_parse_node_int(m);
703         session_desktop_layout_present = m != NULL;
704     }
705
706     if ((n = obt_parse_find_node(node->children, "desktopnames"))) {
707         for (m = obt_parse_find_node(n->children, "name"); m;
708              m = obt_parse_find_node(m->next, "name"))
709         {
710             session_desktop_names = g_slist_append(session_desktop_names,
711                                                    obt_parse_node_string(m));
712         }
713     }
714
715     ob_debug_type(OB_DEBUG_SM, "loading windows");
716     for (node = obt_parse_find_node(node->children, "window"); node != NULL;
717          node = obt_parse_find_node(node->next, "window"))
718     {
719         ObSessionState *state;
720
721         state = g_new0(ObSessionState, 1);
722
723         if (!obt_parse_attr_string(node, "id", &state->id))
724             if (!obt_parse_attr_string(node, "command", &state->command))
725             goto session_load_bail;
726         if (!(n = obt_parse_find_node(node->children, "name")))
727             goto session_load_bail;
728         state->name = obt_parse_node_string(n);
729         if (!(n = obt_parse_find_node(node->children, "class")))
730             goto session_load_bail;
731         state->class = obt_parse_node_string(n);
732         if (!(n = obt_parse_find_node(node->children, "role")))
733             goto session_load_bail;
734         state->role = obt_parse_node_string(n);
735         if (!(n = obt_parse_find_node(node->children, "windowtype")))
736             goto session_load_bail;
737         state->type = obt_parse_node_int(n);
738         if (!(n = obt_parse_find_node(node->children, "desktop")))
739             goto session_load_bail;
740         state->desktop = obt_parse_node_int(n);
741         if (!(n = obt_parse_find_node(node->children, "x")))
742             goto session_load_bail;
743         state->x = obt_parse_node_int(n);
744         if (!(n = obt_parse_find_node(node->children, "y")))
745             goto session_load_bail;
746         state->y = obt_parse_node_int(n);
747         if (!(n = obt_parse_find_node(node->children, "width")))
748             goto session_load_bail;
749         state->w = obt_parse_node_int(n);
750         if (!(n = obt_parse_find_node(node->children, "height")))
751             goto session_load_bail;
752         state->h = obt_parse_node_int(n);
753
754         state->shaded =
755             obt_parse_find_node(node->children, "shaded") != NULL;
756         state->iconic =
757             obt_parse_find_node(node->children, "iconic") != NULL;
758         state->skip_pager =
759             obt_parse_find_node(node->children, "skip_pager") != NULL;
760         state->skip_taskbar =
761             obt_parse_find_node(node->children, "skip_taskbar") != NULL;
762         state->fullscreen =
763             obt_parse_find_node(node->children, "fullscreen") != NULL;
764         state->above =
765             obt_parse_find_node(node->children, "above") != NULL;
766         state->below =
767             obt_parse_find_node(node->children, "below") != NULL;
768         state->max_horz =
769             obt_parse_find_node(node->children, "max_horz") != NULL;
770         state->max_vert =
771             obt_parse_find_node(node->children, "max_vert") != NULL;
772         state->undecorated =
773             obt_parse_find_node(node->children, "undecorated") != NULL;
774         state->focused =
775             obt_parse_find_node(node->children, "focused") != NULL;
776
777         /* save this. they are in the file in stacking order, so preserve
778            that order here */
779         session_saved_state = g_list_append(session_saved_state, state);
780         ob_debug_type(OB_DEBUG_SM, "loaded %s", state->name);
781         continue;
782
783     session_load_bail:
784         ob_debug_type(OB_DEBUG_SM, "loading FAILED");
785         session_state_free(state);
786     }
787
788     /* Remove any duplicates.  This means that if two windows (or more) are
789        saved with the same session state, we won't restore a session for any
790        of them because we don't know what window to put what on. AHEM FIREFOX.
791
792        This is going to be an O(2^n) kind of operation unfortunately.
793     */
794     for (it = session_saved_state; it; it = inext) {
795         GList *jt, *jnext;
796         gboolean founddup = FALSE;
797         ObSessionState *s1 = it->data;
798
799         inext = g_list_next(it);
800
801         for (jt = g_list_next(it); jt; jt = jnext) {
802             ObSessionState *s2 = jt->data;
803             gboolean match;
804
805             jnext = g_list_next(jt);
806
807             if (s1->id && s2->id)
808                 match = strcmp(s1->id, s2->id) == 0;
809             else if (s1->command && s2->command)
810                 match = strcmp(s1->command, s2->command) == 0;
811             else
812                 match = FALSE;
813
814             if (match &&
815                 !strcmp(s1->name, s2->name) &&
816                 !strcmp(s1->class, s2->class) &&
817                 !strcmp(s1->role, s2->role))
818             {
819                 ob_debug_type(OB_DEBUG_SM, "removing duplicate %s", s2->name);
820                 session_state_free(s2);
821                 session_saved_state =
822                     g_list_delete_link(session_saved_state, jt);
823                 founddup = TRUE;
824             }
825         }
826
827         if (founddup) {
828             ob_debug_type(OB_DEBUG_SM, "removing duplicate %s", s1->name);
829             session_state_free(s1);
830             session_saved_state = g_list_delete_link(session_saved_state, it);
831         }
832     }
833
834     obt_parse_instance_unref(i);
835 }
836
837 void session_request_logout(gboolean silent)
838 {
839     if (sm_conn) {
840         SmcRequestSaveYourself(sm_conn,
841                                SmSaveGlobal,
842                                TRUE, /* logout */
843                                (silent ?
844                                 SmInteractStyleNone : SmInteractStyleAny),
845                                TRUE,  /* if false, with GSM, it shows the old
846                                          logout prompt */
847                                TRUE); /* global */
848     }
849     else
850         g_message(_("Not connected to a session manager"));
851 }
852
853 #endif