use the new sm_client_id function so all windows who should save state do. session...
[dana/openbox.git] / openbox / session.c
1 /* This session code is largely inspired by metacity code. */
2
3 #ifndef USE_SM
4
5 void session_load(char *path) {}
6 void session_startup(int argc, char **argv) {}
7 void session_shutdown() {}
8
9 #else
10
11 #include "debug.h"
12 #include "openbox.h"
13 #include "session.h"
14 #include "client.h"
15 #include "prop.h"
16 #include "parser/parse.h"
17
18 #include <time.h>
19 #include <errno.h>
20 #include <stdio.h>
21
22 #ifdef HAVE_UNISTD_H
23 #  include <sys/types.h>
24 #  include <unistd.h>
25 #endif
26
27 #include <X11/SM/SMlib.h>
28
29 static SmcConn     sm_conn;
30 static gchar      *save_file;
31 static gint        sm_argc;
32 static gchar     **sm_argv;
33 static GSList     *sm_saved_state;
34
35 static gboolean session_save();
36
37 static void sm_save_yourself(SmcConn conn, SmPointer data, int save_type,
38                              Bool shutdown, int interact_style, Bool fast);
39 static void sm_die(SmcConn conn, SmPointer data);
40 static void sm_save_complete(SmcConn conn, SmPointer data);
41 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data);
42
43 static void save_commands()
44 {
45     SmProp *props[2];
46     SmProp prop_cmd = { SmCloneCommand, SmLISTofARRAY8, 1, };
47     SmProp prop_res = { SmRestartCommand, SmLISTofARRAY8, };
48     gint i, j, n;
49     gboolean has_id = FALSE, has_file = FALSE;
50
51     for (i = 1; !has_id && !has_file && i < sm_argc - 1; ++i) {
52         if (!has_id && strcmp(sm_argv[i], "--sm-client-id") == 0)
53             has_id = TRUE;
54         if (!has_file && strcmp(sm_argv[i], "--sm-save-file") == 0)
55             has_file = TRUE;
56     }
57
58     n = (has_file ? sm_argc-2 : sm_argc);
59     n = (has_id ? n-2 : n);
60     prop_cmd.vals = g_new(SmPropValue, n);
61     prop_cmd.num_vals = n;
62     for (i = 0, j = 0; i < sm_argc; ++i, ++j) {
63         if (strcmp (sm_argv[i], "--sm-client-id") == 0 ||
64             strcmp (sm_argv[i], "--sm-save-file") == 0) {
65             ++i, --j; /* skip the next as well, keep j where it is */
66         } else {
67             prop_cmd.vals[j].value = sm_argv[i];
68             prop_cmd.vals[j].length = strlen(sm_argv[i]);
69         }
70     }
71
72     n = (has_file ? sm_argc : sm_argc+2);
73     n = (has_id ? n-2 : n);
74     prop_res.vals = g_new(SmPropValue, n);
75     prop_res.num_vals = n;
76     for (i = 0, j = 0; i < sm_argc; ++i, ++j) { 
77         if (strcmp (sm_argv[i], "--sm-client-id") == 0 ||
78             strcmp (sm_argv[i], "--sm-save-file") == 0) {
79             ++i, --j; /* skip the next as well, keep j where it is */
80         } else {
81             prop_res.vals[j].value = sm_argv[i];
82             prop_res.vals[j].length = strlen(sm_argv[i]);
83         }
84     }
85
86     if (save_file) {
87         prop_res.vals[j].value = "--sm-save-file";
88         prop_res.vals[j++].length = strlen("--sm-save-file");
89         prop_res.vals[j].value = save_file;
90         prop_res.vals[j++].length = strlen(save_file);
91     } else {
92         prop_res.vals[j].value = "--sm-client-id";
93         prop_res.vals[j++].length = strlen("--sm-client-id");
94         prop_res.vals[j].value = ob_sm_id;
95         prop_res.vals[j++].length = strlen(ob_sm_id);
96     }
97
98     props[0] = &prop_res;
99     props[1] = &prop_cmd;
100     SmcSetProperties(sm_conn, 2, props);
101
102     g_free(prop_res.vals);
103     g_free(prop_cmd.vals);
104 }
105
106 void session_startup(int argc, char **argv)
107 {
108 #define SM_ERR_LEN 1024
109
110     SmcCallbacks cb;
111     char sm_err[SM_ERR_LEN];
112
113     sm_argc = argc;
114     sm_argv = argv;
115
116     cb.save_yourself.callback = sm_save_yourself;
117     cb.save_yourself.client_data = NULL;
118
119     cb.die.callback = sm_die;
120     cb.die.client_data = NULL;
121
122     cb.save_complete.callback = sm_save_complete;
123     cb.save_complete.client_data = NULL;
124
125     cb.shutdown_cancelled.callback = sm_shutdown_cancelled;
126     cb.shutdown_cancelled.client_data = NULL;
127
128     sm_conn = SmcOpenConnection(NULL, NULL, 1, 0,
129                                 SmcSaveYourselfProcMask |
130                                 SmcDieProcMask |
131                                 SmcSaveCompleteProcMask |
132                                 SmcShutdownCancelledProcMask,
133                                 &cb, ob_sm_id, &ob_sm_id,
134                                 SM_ERR_LEN, sm_err);
135     if (sm_conn == NULL)
136         g_warning("Failed to connect to session manager: %s", sm_err);
137     else {
138         SmPropValue val_prog;
139         SmPropValue val_uid;
140         SmPropValue val_hint; 
141         SmPropValue val_pri;
142         SmPropValue val_pid;
143         SmProp prop_prog = { SmProgram, SmARRAY8, 1, };
144         SmProp prop_uid = { SmUserID, SmARRAY8, 1, };
145         SmProp prop_hint = { SmRestartStyleHint, SmCARD8, 1, };
146         SmProp prop_pid = { SmProcessID, SmARRAY8, 1, };
147         SmProp prop_pri = { "_GSM_Priority", SmCARD8, 1, };
148         SmProp *props[6];
149         gchar hint, pri;
150         gchar pid[32];
151
152         val_prog.value = argv[0];
153         val_prog.length = strlen(argv[0]);
154
155         val_uid.value = g_strdup(g_get_user_name());
156         val_uid.length = strlen(val_uid.value);
157
158         hint = SmRestartImmediately;
159         val_hint.value = &hint;
160         val_hint.length = 1;
161
162         sprintf(pid, "%ld", (long)getpid());
163         val_pid.value = pid;
164         val_pid.length = strlen(pid);
165
166         /* priority with gnome-session-manager, low to run before other apps */
167         pri = 20;
168         val_pri.value = &pri;
169         val_pri.length = 1;
170
171         prop_prog.vals = &val_prog;
172         prop_uid.vals = &val_uid;
173         prop_hint.vals = &val_hint;
174         prop_pid.vals = &val_pid;
175         prop_pri.vals = &val_pri;
176
177         props[0] = &prop_prog;
178         props[1] = &prop_uid;
179         props[2] = &prop_hint;
180         props[3] = &prop_pid;
181         props[4] = &prop_pri;
182
183         SmcSetProperties(sm_conn, 5, props);
184
185         g_free(val_uid.value);
186
187         save_commands();
188
189         ob_debug("Connected to session manager with id %s\n", ob_sm_id);
190     }
191 }
192
193 void session_shutdown()
194 {
195     g_free(save_file);
196
197     if (sm_conn) {
198         SmPropValue val_hint;
199         SmProp prop_hint = { SmRestartStyleHint, SmCARD8, 1, };
200         SmProp *props[1];
201         gulong hint;
202
203         /* when we exit, we want to reset this to a more friendly state */
204         hint = SmRestartIfRunning;
205         val_hint.value = &hint;
206         val_hint.length = 1;
207
208         prop_hint.vals = &val_hint;
209
210         props[0] = &prop_hint;
211
212         SmcSetProperties(sm_conn, 1, props);
213
214         SmcCloseConnection(sm_conn, 0, NULL);
215     }
216 }
217
218 static void sm_save_yourself_phase2(SmcConn conn, SmPointer data)
219 {
220     gboolean success;
221
222     ob_debug("got SAVE YOURSELF PHASE 2 from session manager\n");
223
224     success = session_save();
225     save_commands();
226
227     SmcSaveYourselfDone(conn, success);
228 }
229
230 static void sm_save_yourself(SmcConn conn, SmPointer data, int save_type,
231                              Bool shutdown, int interact_style, Bool fast)
232 {
233     ob_debug("got SAVE YOURSELF from session manager\n");
234
235     if (!SmcRequestSaveYourselfPhase2(conn, sm_save_yourself_phase2, data)) {
236         ob_debug("SAVE YOURSELF PHASE 2 failed\n");
237         SmcSaveYourselfDone(conn, FALSE);
238     }
239 }
240
241 static void sm_die(SmcConn conn, SmPointer data)
242 {
243     ob_exit();
244     ob_debug("got DIE from session manager\n");
245 }
246
247 static void sm_save_complete(SmcConn conn, SmPointer data)
248 {
249     ob_debug("got SAVE COMPLETE from session manager\n");
250 }
251
252 static void sm_shutdown_cancelled(SmcConn conn, SmPointer data)
253 {
254     ob_debug("got SHUTDOWN CANCELLED from session manager\n");
255 }
256
257 static gboolean session_save()
258 {
259     gchar *filename;
260     FILE *f;
261     GList *it;
262     gboolean success = TRUE;
263
264     /* this algo is from metacity */
265     filename = g_strdup_printf("%d-%d-%u.obs",
266                                (int) time(NULL),
267                                (int) getpid(),
268                                g_random_int());
269     save_file = g_build_filename(g_get_home_dir(), ".openbox", "sessions",
270                                  filename, NULL);
271     g_free(filename);
272
273     f = fopen(save_file, "w");
274     if (!f) {
275         success = FALSE;
276         g_warning("unable to save the session to %s: %s",
277                   save_file, strerror(errno));
278     } else {
279         fprintf(f, "<?xml version=\"1.0\"?>\n\n");
280         fprintf(f, "<openbox_session id=\"%s\">\n\n", ob_sm_id);
281
282         for (it = client_list; it; it = g_list_next(it)) {
283             guint num;
284             gint32 *dimensions;
285             gint prex, prey, prew, preh;
286             ObClient *c = it->data;
287             gchar *client_id, *t;
288
289             if (!client_normal(c))
290                 continue;
291
292             if (!(client_id = client_get_sm_client_id(c)))
293                 continue;
294
295             prex = c->area.x;
296             prey = c->area.y;
297             prew = c->area.width;
298             preh = c->area.height;
299             if (PROP_GETA32(c->window, openbox_premax, cardinal,
300                             (guint32**)&dimensions, &num)) {
301                 if (num == 4) {
302                     prex = dimensions[0];
303                     prey = dimensions[1];
304                     prew = dimensions[2];
305                     preh = dimensions[3];
306                 }
307                 g_free(dimensions);
308             }
309
310             fprintf(f, "<window id=\"%s\">\n", client_id);
311
312             t = g_markup_escape_text(c->name, -1);
313             fprintf(f, "\t<name>%s</name>\n", t);
314             g_free(t);
315
316             t = g_markup_escape_text(c->class, -1);
317             fprintf(f, "\t<class>%s</class>\n", t);
318             g_free(t);
319
320             t = g_markup_escape_text(c->role, -1);
321             fprintf(f, "\t<role>%s</role>\n", t);
322             g_free(t);
323
324             fprintf(f, "\t<desktop>%d</desktop>\n", c->desktop);
325             fprintf(f, "\t<x>%d</x>\n", prex);
326             fprintf(f, "\t<y>%d</y>\n", prey);
327             fprintf(f, "\t<width>%d</width>\n", prew);
328             fprintf(f, "\t<height>%d</height>\n", preh);
329             if (c->shaded)
330                 fprintf(f, "\t<shaded />\n");
331             if (c->iconic)
332                 fprintf(f, "\t<iconic />\n");
333             if (c->skip_pager)
334                 fprintf(f, "\t<skip_pager />\n");
335             if (c->skip_taskbar)
336                 fprintf(f, "\t<skip_taskbar />\n");
337             if (c->fullscreen)
338                 fprintf(f, "\t<fullscreen />\n");
339             if (c->above)
340                 fprintf(f, "\t<above />\n");
341             if (c->below)
342                 fprintf(f, "\t<below />\n");
343             if (c->max_horz)
344                 fprintf(f, "\t<max_horz />\n");
345             if (c->max_vert)
346                 fprintf(f, "\t<max_vert />\n");
347             fprintf(f, "</window>\n\n");
348
349             g_free(client_id);
350         }
351
352         fprintf(f, "</openbox_session>\n");
353
354         if (fflush(f)) {
355             success = FALSE;
356             g_warning("error while saving the session to %s: %s",
357                       save_file, strerror(errno));
358         }
359         fclose(f);
360     }
361
362     return success;
363 }
364
365 void session_state_free(ObSessionState *state)
366 {
367     if (state) {
368         g_free(state->id);
369         g_free(state->name);
370         g_free(state->class);
371         g_free(state->role);
372
373         g_free(state);
374     }
375 }
376
377 static gboolean session_state_cmp(ObSessionState *s, ObClient *c)
378 {
379     gchar *client_id;
380
381     if (!(client_id = client_get_sm_client_id(c)))
382         return FALSE;
383     g_print("\nsaved %s\nnow %s\n", s->id, client_id);
384     if (strcmp(s->id, client_id)) {
385         g_free(client_id);
386         return FALSE;
387     }
388     g_free(client_id);
389     g_print("saved %s\nnow %s\n", s->name, c->name);
390     if (strcmp(s->name, c->name))
391         return FALSE;
392     g_print("saved %s\nnow %s\n", s->class, c->class);
393     if (strcmp(s->class, c->class))
394         return FALSE;
395     g_print("saved %s\nnow %s\n\n", s->role, c->role);
396     if (strcmp(s->role, c->role))
397         return FALSE;
398     return TRUE;
399 }
400
401 ObSessionState* session_state_find(ObClient *c)
402 {
403     GSList *it;
404
405     for (it = sm_saved_state; it; it = g_slist_next(it))
406         if (session_state_cmp(it->data, c)) {
407             ObSessionState *s = it->data;
408             sm_saved_state = g_slist_remove(sm_saved_state, s);
409             return s;
410         }
411     return NULL;
412 }
413
414 void session_load(char *path)
415 {
416     xmlDocPtr doc;
417     xmlNodePtr node, n;
418     gchar *sm_id;
419
420     g_message("loading session from %s", path);
421
422     if (!parse_load(path, "openbox_session", &doc, &node))
423         return;
424
425     if (!parse_attr_string("id", node, &sm_id))
426         return;
427     ob_sm_id = g_strdup(sm_id);
428
429     node = parse_find_node("window", node->xmlChildrenNode);
430     while (node) {
431         ObSessionState *state;
432
433         state = g_new0(ObSessionState, 1);
434
435         if (!parse_attr_string("id", node, &state->id))
436             goto session_load_bail;
437         if (!(n = parse_find_node("name", node->xmlChildrenNode)))
438             goto session_load_bail;
439         state->name = parse_string(doc, n);
440         if (!(n = parse_find_node("class", node->xmlChildrenNode)))
441             goto session_load_bail;
442         state->class = parse_string(doc, n);
443         if (!(n = parse_find_node("role", node->xmlChildrenNode)))
444             goto session_load_bail;
445         state->role = parse_string(doc, n);
446         if (!(n = parse_find_node("desktop", node->xmlChildrenNode)))
447             goto session_load_bail;
448         state->desktop = parse_int(doc, n);
449         if (!(n = parse_find_node("x", node->xmlChildrenNode)))
450             goto session_load_bail;
451         state->x = parse_int(doc, n);
452         if (!(n = parse_find_node("y", node->xmlChildrenNode)))
453             goto session_load_bail;
454         state->y = parse_int(doc, n);
455         if (!(n = parse_find_node("width", node->xmlChildrenNode)))
456             goto session_load_bail;
457         state->w = parse_int(doc, n);
458         if (!(n = parse_find_node("height", node->xmlChildrenNode)))
459             goto session_load_bail;
460         state->h = parse_int(doc, n);
461
462         state->shaded =
463             parse_find_node("shaded", node->xmlChildrenNode) != NULL;
464         state->iconic =
465             parse_find_node("iconic", node->xmlChildrenNode) != NULL;
466         state->skip_pager =
467             parse_find_node("skip_pager", node->xmlChildrenNode) != NULL;
468         state->skip_taskbar =
469             parse_find_node("skip_taskbar", node->xmlChildrenNode) != NULL;
470         state->fullscreen =
471             parse_find_node("fullscreen", node->xmlChildrenNode) != NULL;
472         state->above =
473             parse_find_node("above", node->xmlChildrenNode) != NULL;
474         state->below =
475             parse_find_node("below", node->xmlChildrenNode) != NULL;
476         state->max_horz =
477             parse_find_node("max_horz", node->xmlChildrenNode) != NULL;
478         state->max_vert =
479             parse_find_node("max_vert", node->xmlChildrenNode) != NULL;
480         
481         g_message("read session window %s", state->name);
482
483         /* save this */
484         g_message("saved state for %s %s", state->name, state->id);
485         sm_saved_state = g_slist_prepend(sm_saved_state, state);
486         goto session_load_ok;
487
488     session_load_bail:
489         session_state_free(state);
490
491     session_load_ok:
492
493         node = parse_find_node("window", node->next);
494     }
495
496     xmlFreeDoc(doc);
497 }
498
499 #endif