1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
3 session.c for the Openbox window manager
4 Copyright (c) 2003-2007 Dana Jansens
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.
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.
16 See the COPYING file for a copy of the GNU General Public License.
19 /* This session code is largely inspired by metacity code. */
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;
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) {}
44 #include "obt/parse.h"
45 #include "obt/paths.h"
52 # include <sys/types.h>
56 #include <X11/SM/SMlib.h>
58 #define SM_ERR_LEN 1024
60 static SmcConn sm_conn;
62 static gchar **sm_argv;
64 /* Data saved from the first level save yourself */
66 ObClient *focus_client;
70 static gboolean session_connect();
72 static void session_load_file(const gchar *path);
73 static gboolean session_save_to_file(const ObSMSaveData *savedata);
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();
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);
89 static gboolean session_state_cmp(ObSessionState *s, ObClient *c);
90 static void session_state_free(ObSessionState *state);
92 void session_startup(gint argc, gchar **argv)
97 if (!ob_sm_use) return;
103 dir = g_build_filename(obt_paths_cache_home(p),
104 "openbox", "sessions", NULL);
105 obt_paths_unref(p), p = NULL;
107 if (!obt_paths_mkdir_path(dir, 0700)) {
108 g_message(_("Unable to make directory \"%s\": %s"),
109 dir, g_strerror(errno));
112 if (ob_sm_save_file != NULL) {
114 ob_debug_type(OB_DEBUG_SM, "Loading from session file %s",
116 session_load_file(ob_sm_save_file);
121 /* this algo is from metacity */
122 filename = g_strdup_printf("%u-%u-%u.obs",
126 ob_sm_save_file = g_build_filename(dir, filename, NULL);
130 if (session_connect()) {
131 session_setup_program();
132 session_setup_user();
133 session_setup_restart_style(TRUE);
135 session_setup_priority();
136 session_setup_clone_command();
142 void session_shutdown(gboolean permanent)
144 if (!ob_sm_use) return;
147 /* if permanent is true then we will change our session state so that
148 the SM won't run us again */
150 session_setup_restart_style(FALSE);
152 SmcCloseConnection(sm_conn, 0, NULL);
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);
162 /*! Connect to the session manager and set up our callback functions */
163 static gboolean session_connect(void)
167 gchar sm_err[SM_ERR_LEN];
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;
179 /* connect to the server */
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 |
186 SmcSaveCompleteProcMask |
187 SmcShutdownCancelledProcMask,
188 &cb, oldid, &ob_sm_id,
189 SM_ERR_LEN-1, sm_err);
191 ob_debug_type(OB_DEBUG_SM, "Connected to SM with id: %s", ob_sm_id);
193 ob_debug("Failed to connect to session manager: %s", sm_err);
194 return sm_conn != NULL;
197 static void session_setup_program(void)
201 .length = strlen(sm_argv[0]) + 1
204 .name = g_strdup(SmProgram),
205 .type = g_strdup(SmARRAY8),
209 SmProp *list = ∝
210 ob_debug_type(OB_DEBUG_SM, "Setting program: %s", sm_argv[0]);
211 SmcSetProperties(sm_conn, 1, &list);
216 static void session_setup_user(void)
218 char *user = g_strdup(g_get_user_name());
222 .length = strlen(user) + 1
225 .name = g_strdup(SmUserID),
226 .type = g_strdup(SmARRAY8),
230 SmProp *list = ∝
231 ob_debug_type(OB_DEBUG_SM, "Setting user: %s", user);
232 SmcSetProperties(sm_conn, 1, &list);
238 static void session_setup_restart_style(gboolean restart)
240 gchar restart_hint = restart ? SmRestartImmediately : SmRestartIfRunning;
243 .value = &restart_hint,
247 .name = g_strdup(SmRestartStyleHint),
248 .type = g_strdup(SmCARD8),
252 SmProp *list = ∝
253 ob_debug_type(OB_DEBUG_SM, "Setting restart: %d", restart);
254 SmcSetProperties(sm_conn, 1, &list);
259 static void session_setup_pid(void)
261 gchar *pid = g_strdup_printf("%ld", (glong) getpid());
265 .length = strlen(pid) + 1
268 .name = g_strdup(SmProcessID),
269 .type = g_strdup(SmARRAY8),
273 SmProp *list = ∝
274 ob_debug_type(OB_DEBUG_SM, "Setting pid: %s", pid);
275 SmcSetProperties(sm_conn, 1, &list);
281 /*! This is a gnome-session-manager extension */
282 static void session_setup_priority(void)
284 gchar priority = 20; /* 20 is a lower prioity to run before other apps */
291 .name = g_strdup("_GSM_Priority"),
292 .type = g_strdup(SmCARD8),
296 SmProp *list = ∝
297 ob_debug_type(OB_DEBUG_SM, "Setting priority: %d", priority);
298 SmcSetProperties(sm_conn, 1, &list);
303 static void session_setup_clone_command(void)
307 SmPropValue *vals = g_new(SmPropValue, sm_argc);
309 .name = g_strdup(SmCloneCommand),
310 .type = g_strdup(SmLISTofARRAY8),
314 SmProp *list = ∝
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);
323 SmcSetProperties(sm_conn, 1, &list);
329 static void session_setup_restart_command(void)
333 SmPropValue *vals = g_new(SmPropValue, sm_argc + 4);
335 .name = g_strdup(SmRestartCommand),
336 .type = g_strdup(SmLISTofARRAY8),
337 .num_vals = sm_argc + 4,
340 SmProp *list = ∝
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);
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);
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);
363 SmcSetProperties(sm_conn, 1, &list);
366 g_free(vals[i].value);
367 g_free(vals[i+2].value);
371 static ObSMSaveData *sm_save_get_data(void)
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
378 savedata->focus_client = focus_client;
379 savedata->desktop = screen_desktop;
383 static void sm_save_yourself_2(SmcConn conn, SmPointer data)
386 ObSMSaveData *savedata = data;
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);
397 /* tell the session manager how to restore this state */
398 if (success) session_setup_restart_command();
400 ob_debug_type(OB_DEBUG_SM, "Saving is done (success = %d)", success);
401 SmcSaveYourselfDone(conn, success);
404 static void sm_save_yourself(SmcConn conn, SmPointer data, gint save_type,
405 Bool shutdown, gint interact_style, Bool fast)
407 ObSMSaveData *savedata = NULL;
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);
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);
427 vendor = SmcVendor(sm_conn);
428 ob_debug_type(OB_DEBUG_SM, "Session manager's vendor: %s", vendor);
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();
438 if (!SmcRequestSaveYourselfPhase2(conn, sm_save_yourself_2, savedata)) {
439 ob_debug_type(OB_DEBUG_SM, "Requst for phase 2 failed");
441 SmcSaveYourselfDone(conn, FALSE);
445 static void sm_die(SmcConn conn, SmPointer data)
447 ob_debug_type(OB_DEBUG_SM, "Die requested");
451 static void sm_save_complete(SmcConn conn, SmPointer data)
453 ob_debug_type(OB_DEBUG_SM, "Save complete");
456 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data)
458 ob_debug_type(OB_DEBUG_SM, "Shutdown cancelled");
461 static gboolean session_save_to_file(const ObSMSaveData *savedata)
465 gboolean success = TRUE;
467 f = fopen(ob_sm_save_file, "w");
470 g_message(_("Unable to save the session to \"%s\": %s"),
471 ob_sm_save_file, g_strerror(errno));
473 fprintf(f, "<?xml version=\"1.0\"?>\n\n");
474 fprintf(f, "<openbox_session>\n\n");
476 fprintf(f, "<desktop>%d</desktop>\n", savedata->desktop);
478 fprintf(f, "<numdesktops>%d</numdesktops>\n", screen_num_desktops);
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");
491 if (screen_desktop_names) {
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");
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;
506 if (WINDOW_IS_CLIENT(it->data))
507 c = WINDOW_AS_CLIENT(it->data);
511 if (!client_normal(c))
514 if (!c->sm_client_id) {
515 ob_debug_type(OB_DEBUG_SM, "Client %s does not have a "
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",
527 ob_debug_type(OB_DEBUG_SM, "Saving state for client %s",
532 prew = c->area.width;
533 preh = c->area.height;
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;
541 prex = c->pre_max_area.x;
542 prew = c->pre_max_area.width;
545 prey = c->pre_max_area.y;
546 preh = c->pre_max_area.height;
550 fprintf(f, "<window id=\"%s\">\n", c->sm_client_id);
552 fprintf(f, "<window command=\"%s\">\n", c->wm_command);
554 t = g_markup_escape_text(c->name, -1);
555 fprintf(f, "\t<name>%s</name>\n", t);
558 t = g_markup_escape_text(c->class, -1);
559 fprintf(f, "\t<class>%s</class>\n", t);
562 t = g_markup_escape_text(c->role, -1);
563 fprintf(f, "\t<role>%s</role>\n", t);
566 fprintf(f, "\t<windowtype>%d</windowtype>\n", c->type);
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);
574 fprintf(f, "\t<shaded />\n");
576 fprintf(f, "\t<iconic />\n");
578 fprintf(f, "\t<skip_pager />\n");
580 fprintf(f, "\t<skip_taskbar />\n");
582 fprintf(f, "\t<fullscreen />\n");
584 fprintf(f, "\t<above />\n");
586 fprintf(f, "\t<below />\n");
588 fprintf(f, "\t<max_horz />\n");
590 fprintf(f, "\t<max_vert />\n");
592 fprintf(f, "\t<undecorated />\n");
593 if (savedata->focus_client == c)
594 fprintf(f, "\t<focused />\n");
595 fprintf(f, "</window>\n\n");
598 fprintf(f, "</openbox_session>\n");
602 g_message(_("Error while saving the session to \"%s\": %s"),
603 ob_sm_save_file, g_strerror(errno));
611 static void session_state_free(ObSessionState *state)
615 g_free(state->command);
617 g_free(state->class);
624 static gboolean session_state_cmp(ObSessionState *s, ObClient *c)
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)");
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)))
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
653 (!s->command || c->type == s->type));
658 GList* session_state_find(ObClient *c)
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)) {
672 static void session_load_file(const gchar *path)
675 xmlNodePtr node, n, m;
678 i = obt_parse_instance_new();
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);
685 node = obt_parse_root(i);
687 if ((n = obt_parse_find_node(node->children, "desktop")))
688 session_desktop = obt_parse_node_int(n);
690 if ((n = obt_parse_find_node(node->children, "numdesktops")))
691 session_num_desktops = obt_parse_node_int(n);
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;
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"))
710 session_desktop_names = g_slist_append(session_desktop_names,
711 obt_parse_node_string(m));
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"))
719 ObSessionState *state;
721 state = g_new0(ObSessionState, 1);
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);
755 obt_parse_find_node(node->children, "shaded") != NULL;
757 obt_parse_find_node(node->children, "iconic") != NULL;
759 obt_parse_find_node(node->children, "skip_pager") != NULL;
760 state->skip_taskbar =
761 obt_parse_find_node(node->children, "skip_taskbar") != NULL;
763 obt_parse_find_node(node->children, "fullscreen") != NULL;
765 obt_parse_find_node(node->children, "above") != NULL;
767 obt_parse_find_node(node->children, "below") != NULL;
769 obt_parse_find_node(node->children, "max_horz") != NULL;
771 obt_parse_find_node(node->children, "max_vert") != NULL;
773 obt_parse_find_node(node->children, "undecorated") != NULL;
775 obt_parse_find_node(node->children, "focused") != NULL;
777 /* save this. they are in the file in stacking order, so preserve
779 session_saved_state = g_list_append(session_saved_state, state);
780 ob_debug_type(OB_DEBUG_SM, "loaded %s", state->name);
784 ob_debug_type(OB_DEBUG_SM, "loading FAILED");
785 session_state_free(state);
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.
792 This is going to be an O(2^n) kind of operation unfortunately.
794 for (it = session_saved_state; it; it = inext) {
796 gboolean founddup = FALSE;
797 ObSessionState *s1 = it->data;
799 inext = g_list_next(it);
801 for (jt = g_list_next(it); jt; jt = jnext) {
802 ObSessionState *s2 = jt->data;
805 jnext = g_list_next(jt);
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;
815 !strcmp(s1->name, s2->name) &&
816 !strcmp(s1->class, s2->class) &&
817 !strcmp(s1->role, s2->role))
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);
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);
834 obt_parse_instance_unref(i);
837 void session_request_logout(gboolean silent)
840 SmcRequestSaveYourself(sm_conn,
844 SmInteractStyleNone : SmInteractStyleAny),
845 TRUE, /* if false, with GSM, it shows the old
850 g_message(_("Not connected to a session manager"));