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
  28 #ifndef USE_SM
  29 void session_startup(gint argc, gchar **argv) {}
  30 void session_shutdown(gboolean permanent) {}
  31 GList* session_state_find(struct _ObClient *c) { return NULL; }
  32 #else
  33
  34 #include "debug.h"
  35 #include "openbox.h"
  36 #include "client.h"
  37 #include "prop.h"
  38 #include "focus.h"
  39 #include "screen.h"
  40 #include "gettext.h"
  41 #include "parser/parse.h"
  42
  43 #include <time.h>
  44 #include <errno.h>
  45 #include <stdio.h>
  46
  47 #ifdef HAVE_UNISTD_H
  48 #  include <sys/types.h>
  49 #  include <unistd.h>
  50 #endif
  51
  52 #include <X11/SM/SMlib.h>
  53
  54 #define SM_ERR_LEN 1024
  55
  56 static SmcConn  sm_conn;
  57 static gint     sm_argc;
  58 static gchar  **sm_argv;
  59
  60 /* Data saved from the first level save yourself */
  61 typedef struct {
  62     ObClient *focus_client;
  63     gint      desktop;
  64 } ObSMSaveData;
  65
  66 static gboolean session_connect();
  67
  68 static void session_load_file(const gchar *path);
  69 static gboolean session_save_to_file(const ObSMSaveData *savedata);
  70
  71 static void session_setup_program();
  72 static void session_setup_user();
  73 static void session_setup_restart_style(gboolean restart);
  74 static void session_setup_pid();
  75 static void session_setup_priority();
  76 static void session_setup_clone_command();
  77 static void session_setup_restart_command();
  78
  79 static void sm_save_yourself(SmcConn conn, SmPointer data, gint save_type,
  80                              Bool shutdown, gint interact_style, Bool fast);
  81 static void sm_die(SmcConn conn, SmPointer data);
  82 static void sm_save_complete(SmcConn conn, SmPointer data);
  83 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data);
  84
  85 static gboolean session_state_cmp(ObSessionState *s, ObClient *c);
  86 static void session_state_free(ObSessionState *state);
  87
  88 void session_startup(gint argc, gchar **argv)
  89 {
  90     gchar *dir;
  91
  92     if (!ob_sm_use) return;
  93
  94     sm_argc = argc;
  95     sm_argv = argv;
  96
  97     dir = g_build_filename(parse_xdg_data_home_path(),
  98                            "openbox", "sessions", NULL);
  99     if (!parse_mkdir_path(dir, 0700)) {
 100         g_message(_("Unable to make directory '%s': %s"),
 101                   dir, g_strerror(errno));
 102     }
 103
 104     if (ob_sm_save_file != NULL) {
 105         ob_debug_type(OB_DEBUG_SM, "Loading from session file %s\n",
 106                       ob_sm_save_file);
 107         session_load_file(ob_sm_save_file);
 108     } else {
 109         gchar *filename;
 110
 111         /* this algo is from metacity */
 112         filename = g_strdup_printf("%u-%u-%u.obs",
 113                                    (guint)time(NULL),
 114                                    (guint)getpid(),
 115                                    g_random_int());
 116         ob_sm_save_file = g_build_filename(dir, filename, NULL);
 117         g_free(filename);
 118     }
 119
 120     if (session_connect()) {
 121         session_setup_program();
 122         session_setup_user();
 123         session_setup_restart_style(TRUE);
 124         session_setup_pid();
 125         session_setup_priority();
 126         session_setup_clone_command();
 127     }
 128
 129     g_free(dir);
 130 }
 131
 132 void session_shutdown(gboolean permanent)
 133 {
 134     if (!ob_sm_use) return;
 135
 136     if (sm_conn) {
 137         /* if permanent is true then we will change our session state so that
 138            the SM won't run us again */
 139         if (permanent)
 140             session_setup_restart_style(FALSE);
 141
 142         SmcCloseConnection(sm_conn, 0, NULL);
 143
 144         while (session_saved_state) {
 145             session_state_free(session_saved_state->data);
 146             session_saved_state = g_list_delete_link(session_saved_state,
 147                                                      session_saved_state);
 148         }
 149     }
 150 }
 151
 152 /*! Connect to the session manager and set up our callback functions */
 153 static gboolean session_connect()
 154 {
 155     SmcCallbacks cb;
 156     gchar *oldid;
 157     gchar sm_err[SM_ERR_LEN];
 158
 159     /* set up our callback functions */
 160     cb.save_yourself.callback = sm_save_yourself;
 161     cb.save_yourself.client_data = NULL;
 162     cb.die.callback = sm_die;
 163     cb.die.client_data = NULL;
 164     cb.save_complete.callback = sm_save_complete;
 165     cb.save_complete.client_data = NULL;
 166     cb.shutdown_cancelled.callback = sm_shutdown_cancelled;
 167     cb.shutdown_cancelled.client_data = NULL;
 168
 169     /* connect to the server */
 170     oldid = ob_sm_id;
 171     ob_debug_type(OB_DEBUG_SM, "Connecting to SM with id: %s\n",
 172                   oldid ? oldid : "(null)");
 173     sm_conn = SmcOpenConnection(NULL, NULL, 1, 0,
 174                                 SmcSaveYourselfProcMask |
 175                                 SmcDieProcMask |
 176                                 SmcSaveCompleteProcMask |
 177                                 SmcShutdownCancelledProcMask,
 178                                 &cb, oldid, &ob_sm_id,
 179                                 SM_ERR_LEN-1, sm_err);
 180     g_free(oldid);
 181     ob_debug_type(OB_DEBUG_SM, "Connected to SM with id: %s\n", ob_sm_id);
 182     if (sm_conn == NULL)
 183         ob_debug("Failed to connect to session manager: %s\n", sm_err);
 184     return sm_conn != NULL;
 185 }
 186
 187 static void session_setup_program()
 188 {
 189     SmPropValue vals = {
 190         .value = sm_argv[0],
 191         .length = strlen(sm_argv[0]) + 1
 192     };
 193     SmProp prop = {
 194         .name = g_strdup(SmProgram),
 195         .type = g_strdup(SmARRAY8),
 196         .num_vals = 1,
 197         .vals = &vals
 198     };
 199     SmProp *list = &prop;
 200     ob_debug_type(OB_DEBUG_SM, "Setting program: %s\n", sm_argv[0]);
 201     SmcSetProperties(sm_conn, 1, &list);
 202     g_free(prop.name);
 203     g_free(prop.type);
 204 }
 205
 206 static void session_setup_user()
 207 {
 208     char *user = g_strdup(g_get_user_name());
 209
 210     SmPropValue vals = {
 211         .value = user,
 212         .length = strlen(user) + 1
 213     };
 214     SmProp prop = {
 215         .name = g_strdup(SmUserID),
 216         .type = g_strdup(SmARRAY8),
 217         .num_vals = 1,
 218         .vals = &vals
 219     };
 220     SmProp *list = &prop;
 221     ob_debug_type(OB_DEBUG_SM, "Setting user: %s\n", user);
 222     SmcSetProperties(sm_conn, 1, &list);
 223     g_free(prop.name);
 224     g_free(prop.type);
 225     g_free(user);
 226 }
 227
 228 static void session_setup_restart_style(gboolean restart)
 229 {
 230     gchar restart_hint = restart ? SmRestartImmediately : SmRestartIfRunning;
 231
 232     SmPropValue vals = {
 233         .value = &restart_hint,
 234         .length = 1
 235     };
 236     SmProp prop = {
 237         .name = g_strdup(SmRestartStyleHint),
 238         .type = g_strdup(SmCARD8),
 239         .num_vals = 1,
 240         .vals = &vals
 241     };
 242     SmProp *list = &prop;
 243     ob_debug_type(OB_DEBUG_SM, "Setting restart: %d\n", restart);
 244     SmcSetProperties(sm_conn, 1, &list);
 245     g_free(prop.name);
 246     g_free(prop.type);
 247 }
 248
 249 static void session_setup_pid()
 250 {
 251     gchar *pid = g_strdup_printf("%ld", (glong) getpid());
 252
 253     SmPropValue vals = {
 254         .value = pid,
 255         .length = strlen(pid) + 1
 256     };
 257     SmProp prop = {
 258         .name = g_strdup(SmProcessID),
 259         .type = g_strdup(SmARRAY8),
 260         .num_vals = 1,
 261         .vals = &vals
 262     };
 263     SmProp *list = &prop;
 264     ob_debug_type(OB_DEBUG_SM, "Setting pid: %s\n", pid);
 265     SmcSetProperties(sm_conn, 1, &list);
 266     g_free(prop.name);
 267     g_free(prop.type);
 268     g_free(pid);
 269 }
 270
 271 /*! This is a gnome-session-manager extension */
 272 static void session_setup_priority()
 273 {
 274     gchar priority = 20; /* 20 is a lower prioity to run before other apps */
 275
 276     SmPropValue vals = {
 277         .value = &priority,
 278         .length = 1
 279     };
 280     SmProp prop = {
 281         .name = g_strdup("_GSM_Priority"),
 282         .type = g_strdup(SmCARD8),
 283         .num_vals = 1,
 284         .vals = &vals
 285     };
 286     SmProp *list = &prop;
 287     ob_debug_type(OB_DEBUG_SM, "Setting priority: %d\n", priority);
 288     SmcSetProperties(sm_conn, 1, &list);
 289     g_free(prop.name);
 290     g_free(prop.type);
 291 }
 292
 293 static void session_setup_clone_command()
 294 {
 295     gint i;
 296
 297     SmPropValue *vals = g_new(SmPropValue, sm_argc);
 298     SmProp prop = {
 299         .name = g_strdup(SmCloneCommand),
 300         .type = g_strdup(SmLISTofARRAY8),
 301         .num_vals = sm_argc,
 302         .vals = vals
 303     };
 304     SmProp *list = &prop;
 305
 306     ob_debug_type(OB_DEBUG_SM, "Setting clone command: (%d)\n", sm_argc);
 307     for (i = 0; i < sm_argc; ++i) {
 308         vals[i].value = sm_argv[i];
 309         vals[i].length = strlen(sm_argv[i]) + 1;
 310         ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i].value);
 311     }
 312
 313     SmcSetProperties(sm_conn, 1, &list);
 314     g_free(prop.name);
 315     g_free(prop.type);
 316     g_free(vals);
 317 }
 318
 319 static void session_setup_restart_command()
 320 {
 321     gint i;
 322     gint num = 4;
 323
 324     if (ob_config_type) num += 2;
 325
 326     SmPropValue *vals = g_new(SmPropValue, sm_argc + num);
 327     SmProp prop = {
 328         .name = g_strdup(SmRestartCommand),
 329         .type = g_strdup(SmLISTofARRAY8),
 330         .num_vals = sm_argc + num,
 331         .vals = vals
 332     };
 333     SmProp *list = &prop;
 334
 335     ob_debug_type(OB_DEBUG_SM, "Setting restart command: (%d)\n", sm_argc+4);
 336     for (i = 0; i < sm_argc; ++i) {
 337         vals[i].value = sm_argv[i];
 338         vals[i].length = strlen(sm_argv[i]) + 1;
 339         ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i].value);
 340     }
 341
 342     vals[i].value = g_strdup("--sm-client-id");
 343     vals[i].length = strlen("--sm-client-id") + 1;
 344     vals[i+1].value = ob_sm_id;
 345     vals[i+1].length = strlen(ob_sm_id) + 1;
 346     ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i].value);
 347     ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i+1].value);
 348
 349     vals[i+2].value = g_strdup("--sm-save-file");
 350     vals[i+2].length = strlen("--sm-save-file") + 1;
 351     vals[i+3].value = ob_sm_save_file;
 352     vals[i+3].length = strlen(ob_sm_save_file) + 1;
 353     ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i+2].value);
 354     ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i+3].value);
 355
 356     if (ob_config_type) {
 357         vals[i+4].value = g_strdup("--config-namespace");
 358         vals[i+4].length = strlen("--config-namespace") + 1;
 359         vals[i+5].value = ob_config_type;
 360         vals[i+5].length = strlen(ob_config_type) + 1;
 361         ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i+4].value);
 362         ob_debug_type(OB_DEBUG_SM, "    %s\n", vals[i+5].value);
 363     }
 364
 365     SmcSetProperties(sm_conn, 1, &list);
 366     g_free(prop.name);
 367     g_free(prop.type);
 368     g_free(vals[i].value);
 369     g_free(vals[i+2].value);
 370     if (ob_config_type)
 371         g_free(vals[i+4].value);
 372     g_free(vals);
 373 }
 374
 375 static ObSMSaveData *sm_save_get_data()
 376 {
 377     ObSMSaveData *savedata = g_new0(ObSMSaveData, 1);
 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\n");
 390     ob_debug_type(OB_DEBUG_SM,
 391                   "  Saving session to file '%s'\n", 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)\n", 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\n");
 412
 413     vendor = SmcVendor(sm_conn);
 414     ob_debug_type(OB_DEBUG_SM, "Session manager's vendor: %s\n", 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\n");
 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\n");
 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\n");
 440 }
 441
 442 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data)
 443 {
 444     ob_debug_type(OB_DEBUG_SM, "Shutdown cancelled\n");
 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         /* they are ordered top to bottom in stacking order */
 465         for (it = stacking_list; it; it = g_list_next(it)) {
 466             gint prex, prey, prew, preh;
 467             ObClient *c;
 468             gchar *t;
 469
 470             if (WINDOW_IS_CLIENT(it->data))
 471                 c = WINDOW_AS_CLIENT(it->data);
 472             else
 473                 continue;
 474
 475             if (!client_normal(c))
 476                 continue;
 477
 478             if (!c->sm_client_id) {
 479                 ob_debug_type(OB_DEBUG_SM, "Client %s does not have a "
 480                               "session id set\n",
 481                               c->title);
 482                 if (!c->wm_command) {
 483                     ob_debug_type(OB_DEBUG_SM, "Client %s does not have an "
 484                                   "oldskool wm_command set either. We won't "
 485                                   "be saving its data\n",
 486                                   c->title);
 487                     continue;
 488                 }
 489             }
 490
 491             ob_debug_type(OB_DEBUG_SM, "Saving state for client %s\n",
 492                           c->title);
 493
 494             prex = c->area.x;
 495             prey = c->area.y;
 496             prew = c->area.width;
 497             preh = c->area.height;
 498             if (c->fullscreen) {
 499                 prex = c->pre_fullscreen_area.x;
 500                 prey = c->pre_fullscreen_area.x;
 501                 prew = c->pre_fullscreen_area.width;
 502                 preh = c->pre_fullscreen_area.height;
 503             }
 504             if (c->max_horz) {
 505                 prex = c->pre_max_area.x;
 506                 prew = c->pre_max_area.width;
 507             }
 508             if (c->max_vert) {
 509                 prey = c->pre_max_area.y;
 510                 preh = c->pre_max_area.height;
 511             }
 512
 513             if (c->sm_client_id)
 514                 fprintf(f, "<window id=\"%s\">\n", c->sm_client_id);
 515             else
 516                 fprintf(f, "<window command=\"%s\">\n", c->wm_command);
 517
 518             t = g_markup_escape_text(c->name, -1);
 519             fprintf(f, "\t<name>%s</name>\n", t);
 520             g_free(t);
 521
 522             t = g_markup_escape_text(c->class, -1);
 523             fprintf(f, "\t<class>%s</class>\n", t);
 524             g_free(t);
 525
 526             t = g_markup_escape_text(c->role, -1);
 527             fprintf(f, "\t<role>%s</role>\n", t);
 528             g_free(t);
 529
 530             fprintf(f, "\t<desktop>%d</desktop>\n", c->desktop);
 531             fprintf(f, "\t<x>%d</x>\n", prex);
 532             fprintf(f, "\t<y>%d</y>\n", prey);
 533             fprintf(f, "\t<width>%d</width>\n", prew);
 534             fprintf(f, "\t<height>%d</height>\n", preh);
 535             if (c->shaded)
 536                 fprintf(f, "\t<shaded />\n");
 537             if (c->iconic)
 538                 fprintf(f, "\t<iconic />\n");
 539             if (c->skip_pager)
 540                 fprintf(f, "\t<skip_pager />\n");
 541             if (c->skip_taskbar)
 542                 fprintf(f, "\t<skip_taskbar />\n");
 543             if (c->fullscreen)
 544                 fprintf(f, "\t<fullscreen />\n");
 545             if (c->above)
 546                 fprintf(f, "\t<above />\n");
 547             if (c->below)
 548                 fprintf(f, "\t<below />\n");
 549             if (c->max_horz)
 550                 fprintf(f, "\t<max_horz />\n");
 551             if (c->max_vert)
 552                 fprintf(f, "\t<max_vert />\n");
 553             if (c->undecorated)
 554                 fprintf(f, "\t<undecorated />\n");
 555             if (savedata->focus_client == c)
 556                 fprintf(f, "\t<focused />\n");
 557             fprintf(f, "</window>\n\n");
 558         }
 559
 560         fprintf(f, "</openbox_session>\n");
 561
 562         if (fflush(f)) {
 563             success = FALSE;
 564             g_message(_("Error while saving the session to '%s': %s"),
 565                       ob_sm_save_file, g_strerror(errno));
 566         }
 567         fclose(f);
 568     }
 569
 570     return success;
 571 }
 572
 573 static void session_state_free(ObSessionState *state)
 574 {
 575     if (state) {
 576         g_free(state->id);
 577         g_free(state->command);
 578         g_free(state->name);
 579         g_free(state->class);
 580         g_free(state->role);
 581
 582         g_free(state);
 583     }
 584 }
 585
 586 static gboolean session_state_cmp(ObSessionState *s, ObClient *c)
 587 {
 588     ob_debug_type(OB_DEBUG_SM, "Comparing client against saved state: \n");
 589     ob_debug_type(OB_DEBUG_SM, "  client id: %s \n", c->sm_client_id);
 590     ob_debug_type(OB_DEBUG_SM, "  client name: %s \n", c->name);
 591     ob_debug_type(OB_DEBUG_SM, "  client class: %s \n", c->class);
 592     ob_debug_type(OB_DEBUG_SM, "  client role: %s \n", c->role);
 593     ob_debug_type(OB_DEBUG_SM, "  client command: %s \n",
 594                   c->wm_command ? c->wm_command : "(null)");
 595     ob_debug_type(OB_DEBUG_SM, "  state id: %s \n", s->id);
 596     ob_debug_type(OB_DEBUG_SM, "  state name: %s \n", s->name);
 597     ob_debug_type(OB_DEBUG_SM, "  state class: %s \n", s->class);
 598     ob_debug_type(OB_DEBUG_SM, "  state role: %s \n", s->role);
 599     ob_debug_type(OB_DEBUG_SM, "  state command: %s \n",
 600                   s->command ? s->command : "(null)");
 601
 602     if ((c->sm_client_id && s->id && !strcmp(c->sm_client_id, s->id)) ||
 603         (c->wm_command && s->command && !strcmp(c->wm_command, s->command)))
 604     {
 605         return (!strcmp(s->name, c->name) &&
 606                 !strcmp(s->class, c->class) &&
 607                 !strcmp(s->role, c->role));
 608     }
 609     return FALSE;
 610 }
 611
 612 GList* session_state_find(ObClient *c)
 613 {
 614     GList *it;
 615
 616     for (it = session_saved_state; it; it = g_list_next(it)) {
 617         ObSessionState *s = it->data;
 618         if (!s->matched && session_state_cmp(s, c)) {
 619             s->matched = TRUE;
 620             break;
 621         }
 622     }
 623     return it;
 624 }
 625
 626 static void session_load_file(const gchar *path)
 627 {
 628     xmlDocPtr doc;
 629     xmlNodePtr node, n;
 630
 631     if (!parse_load(path, "openbox_session", &doc, &node))
 632         return;
 633
 634     if ((n = parse_find_node("desktop", node->children)))
 635         session_desktop = parse_int(doc, n);
 636
 637     for (node = parse_find_node("window", node->children); node != NULL;
 638          node = parse_find_node("window", node->next))
 639     {
 640         ObSessionState *state;
 641
 642         state = g_new0(ObSessionState, 1);
 643
 644         if (!parse_attr_string("id", node, &state->id))
 645             if (!parse_attr_string("command", node, &state->command))
 646             goto session_load_bail;
 647         if (!(n = parse_find_node("name", node->children)))
 648             goto session_load_bail;
 649         state->name = parse_string(doc, n);
 650         if (!(n = parse_find_node("class", node->children)))
 651             goto session_load_bail;
 652         state->class = parse_string(doc, n);
 653         if (!(n = parse_find_node("role", node->children)))
 654             goto session_load_bail;
 655         state->role = parse_string(doc, n);
 656         if (!(n = parse_find_node("desktop", node->children)))
 657             goto session_load_bail;
 658         state->desktop = parse_int(doc, n);
 659         if (!(n = parse_find_node("x", node->children)))
 660             goto session_load_bail;
 661         state->x = parse_int(doc, n);
 662         if (!(n = parse_find_node("y", node->children)))
 663             goto session_load_bail;
 664         state->y = parse_int(doc, n);
 665         if (!(n = parse_find_node("width", node->children)))
 666             goto session_load_bail;
 667         state->w = parse_int(doc, n);
 668         if (!(n = parse_find_node("height", node->children)))
 669             goto session_load_bail;
 670         state->h = parse_int(doc, n);
 671
 672         state->shaded =
 673             parse_find_node("shaded", node->children) != NULL;
 674         state->iconic =
 675             parse_find_node("iconic", node->children) != NULL;
 676         state->skip_pager =
 677             parse_find_node("skip_pager", node->children) != NULL;
 678         state->skip_taskbar =
 679             parse_find_node("skip_taskbar", node->children) != NULL;
 680         state->fullscreen =
 681             parse_find_node("fullscreen", node->children) != NULL;
 682         state->above =
 683             parse_find_node("above", node->children) != NULL;
 684         state->below =
 685             parse_find_node("below", node->children) != NULL;
 686         state->max_horz =
 687             parse_find_node("max_horz", node->children) != NULL;
 688         state->max_vert =
 689             parse_find_node("max_vert", node->children) != NULL;
 690         state->undecorated =
 691             parse_find_node("undecorated", node->children) != NULL;
 692         state->focused =
 693             parse_find_node("focused", node->children) != NULL;
 694
 695         /* save this. they are in the file in stacking order, so preserve
 696            that order here */
 697         session_saved_state = g_list_append(session_saved_state, state);
 698         continue;
 699
 700     session_load_bail:
 701         session_state_free(state);
 702     }
 703
 704     xmlFreeDoc(doc);
 705 }
 706
 707 #endif