10b31acd535c9fc6b086e106a8a007a312333b71
[dana/openbox.git] / openbox / actions / desktop.c
1 #include "openbox/actions.h"
2 #include "openbox/screen.h"
3 #include "openbox/client.h"
4 #include "openbox/openbox.h"
5 #include "obt/keyboard.h"
6
7 typedef enum {
8     LAST,
9     RELATIVE,
10     ABSOLUTE
11 } SwitchType;
12
13 typedef struct {
14     SwitchType type;
15     union {
16         struct {
17             guint desktop;
18         } abs;
19
20         struct {
21             gboolean linear;
22             gboolean wrap;
23             ObDirection dir;
24         } rel;
25     } u;
26     gboolean send;
27     gboolean follow;
28     gboolean interactive;
29 } Options;
30
31 static gpointer setup_go_func(xmlNodePtr node,
32                               ObActionsIPreFunc *pre,
33                               ObActionsIInputFunc *input,
34                               ObActionsICancelFunc *cancel,
35                               ObActionsIPostFunc *post);
36 static gpointer setup_send_func(xmlNodePtr node,
37                                 ObActionsIPreFunc *pre,
38                                 ObActionsIInputFunc *input,
39                                 ObActionsICancelFunc *cancel,
40                                 ObActionsIPostFunc *post);
41 static void free_func(gpointer o);
42 static gboolean run_func(ObActionsData *data, gpointer options);
43
44 static gboolean i_pre_func(guint state, gpointer options);
45 static gboolean i_input_func(guint initial_state,
46                              XEvent *e,
47                              ObtIC *ic,
48                              gpointer options,
49                              gboolean *used);
50 static void i_post_func(gpointer options);
51
52 /* 3.4-compatibility */
53 static gpointer setup_go_last_func(xmlNodePtr node);
54 static gpointer setup_send_last_func(xmlNodePtr node);
55 static gpointer setup_go_abs_func(xmlNodePtr node);
56 static gpointer setup_send_abs_func(xmlNodePtr node);
57 static gpointer setup_go_next_func(xmlNodePtr node,
58                                    ObActionsIPreFunc *pre,
59                                    ObActionsIInputFunc *input,
60                                    ObActionsICancelFunc *cancel,
61                                    ObActionsIPostFunc *post);
62 static gpointer setup_send_next_func(xmlNodePtr node,
63                                      ObActionsIPreFunc *pre,
64                                      ObActionsIInputFunc *input,
65                                      ObActionsICancelFunc *cancel,
66                                      ObActionsIPostFunc *post);
67 static gpointer setup_go_prev_func(xmlNodePtr node,
68                                    ObActionsIPreFunc *pre,
69                                    ObActionsIInputFunc *input,
70                                    ObActionsICancelFunc *cancel,
71                                    ObActionsIPostFunc *post);
72 static gpointer setup_send_prev_func(xmlNodePtr node,
73                                      ObActionsIPreFunc *pre,
74                                      ObActionsIInputFunc *input,
75                                      ObActionsICancelFunc *cancel,
76                                      ObActionsIPostFunc *post);
77 static gpointer setup_go_left_func(xmlNodePtr node,
78                                    ObActionsIPreFunc *pre,
79                                    ObActionsIInputFunc *input,
80                                    ObActionsICancelFunc *cancel,
81                                    ObActionsIPostFunc *post);
82 static gpointer setup_send_left_func(xmlNodePtr node,
83                                      ObActionsIPreFunc *pre,
84                                      ObActionsIInputFunc *input,
85                                      ObActionsICancelFunc *cancel,
86                                      ObActionsIPostFunc *post);
87 static gpointer setup_go_right_func(xmlNodePtr node,
88                                     ObActionsIPreFunc *pre,
89                                     ObActionsIInputFunc *input,
90                                     ObActionsICancelFunc *cancel,
91                                     ObActionsIPostFunc *post);
92 static gpointer setup_send_right_func(xmlNodePtr node,
93                                       ObActionsIPreFunc *pre,
94                                       ObActionsIInputFunc *input,
95                                       ObActionsICancelFunc *cancel,
96                                       ObActionsIPostFunc *post);
97 static gpointer setup_go_up_func(xmlNodePtr node,
98                                  ObActionsIPreFunc *pre,
99                                  ObActionsIInputFunc *input,
100                                  ObActionsICancelFunc *cancel,
101                                  ObActionsIPostFunc *post);
102 static gpointer setup_send_up_func(xmlNodePtr node,
103                                    ObActionsIPreFunc *pre,
104                                    ObActionsIInputFunc *input,
105                                    ObActionsICancelFunc *cancel,
106                                    ObActionsIPostFunc *post);
107 static gpointer setup_go_down_func(xmlNodePtr node,
108                                    ObActionsIPreFunc *pre,
109                                    ObActionsIInputFunc *input,
110                                    ObActionsICancelFunc *cancel,
111                                    ObActionsIPostFunc *post);
112 static gpointer setup_send_down_func(xmlNodePtr node,
113                                      ObActionsIPreFunc *pre,
114                                      ObActionsIInputFunc *input,
115                                      ObActionsICancelFunc *cancel,
116                                      ObActionsIPostFunc *post);
117
118 void action_desktop_startup(void)
119 {
120     actions_register_i("GoToDesktop", setup_go_func, free_func, run_func);
121     actions_register_i("SendToDesktop", setup_send_func, free_func, run_func);
122     /* 3.4-compatibility */
123     actions_register("DesktopLast", setup_go_last_func, free_func, run_func);
124     actions_register("SendToDesktopLast", setup_send_last_func,
125                      free_func, run_func);
126     actions_register("Desktop", setup_go_abs_func, free_func, run_func);
127     actions_register("SendToDesktop", setup_send_abs_func,
128                      free_func, run_func);
129     actions_register_i("DesktopNext", setup_go_next_func, free_func, run_func);
130     actions_register_i("SendToDesktopNext", setup_send_next_func,
131                        free_func, run_func);
132     actions_register_i("DesktopPrevious", setup_go_prev_func,
133                        free_func, run_func);
134     actions_register_i("SendToDesktopPrevious", setup_send_prev_func,
135                        free_func, run_func);
136     actions_register_i("DesktopLeft", setup_go_left_func, free_func, run_func);
137     actions_register_i("SendToDesktopLeft", setup_send_left_func,
138                        free_func, run_func);
139     actions_register_i("DesktopRight", setup_go_right_func,
140                        free_func, run_func);
141     actions_register_i("SendToDesktopRight", setup_send_right_func,
142                        free_func, run_func);
143     actions_register_i("DesktopUp", setup_go_up_func, free_func, run_func);
144     actions_register_i("SendToDesktopUp", setup_send_up_func,
145                        free_func, run_func);
146     actions_register_i("DesktopDown", setup_go_down_func, free_func, run_func);
147     actions_register_i("SendToDesktopDown", setup_send_down_func,
148                        free_func, run_func);
149 }
150
151 static gpointer setup_func(xmlNodePtr node,
152                            ObActionsIPreFunc *pre,
153                            ObActionsIInputFunc *input,
154                            ObActionsICancelFunc *cancel,
155                            ObActionsIPostFunc *post)
156 {
157     xmlNodePtr n;
158     Options *o;
159
160     o = g_slice_new0(Options);
161     /* don't go anywhere if there are no options given */
162     o->type = ABSOLUTE;
163     o->u.abs.desktop = screen_desktop;
164     /* wrap by default - it's handy! */
165     o->u.rel.wrap = TRUE;
166
167     if ((n = obt_xml_find_node(node, "to"))) {
168         gchar *s = obt_xml_node_string(n);
169         if (!g_ascii_strcasecmp(s, "last"))
170             o->type = LAST;
171         else if (!g_ascii_strcasecmp(s, "next")) {
172             o->type = RELATIVE;
173             o->u.rel.linear = TRUE;
174             o->u.rel.dir = OB_DIRECTION_EAST;
175         }
176         else if (!g_ascii_strcasecmp(s, "previous")) {
177             o->type = RELATIVE;
178             o->u.rel.linear = TRUE;
179             o->u.rel.dir = OB_DIRECTION_WEST;
180         }
181         else if (!g_ascii_strcasecmp(s, "north") ||
182                  !g_ascii_strcasecmp(s, "up")) {
183             o->type = RELATIVE;
184             o->u.rel.dir = OB_DIRECTION_NORTH;
185         }
186         else if (!g_ascii_strcasecmp(s, "south") ||
187                  !g_ascii_strcasecmp(s, "down")) {
188             o->type = RELATIVE;
189             o->u.rel.dir = OB_DIRECTION_SOUTH;
190         }
191         else if (!g_ascii_strcasecmp(s, "west") ||
192                  !g_ascii_strcasecmp(s, "left")) {
193             o->type = RELATIVE;
194             o->u.rel.dir = OB_DIRECTION_WEST;
195         }
196         else if (!g_ascii_strcasecmp(s, "east") ||
197                  !g_ascii_strcasecmp(s, "right")) {
198             o->type = RELATIVE;
199             o->u.rel.dir = OB_DIRECTION_EAST;
200         }
201         else {
202             o->type = ABSOLUTE;
203             o->u.abs.desktop = atoi(s) - 1;
204         }
205         g_free(s);
206     }
207
208     if ((n = obt_xml_find_node(node, "wrap")))
209         o->u.rel.wrap = obt_xml_node_bool(n);
210
211     return o;
212 }
213
214
215 static gpointer setup_go_func(xmlNodePtr node,
216                               ObActionsIPreFunc *pre,
217                               ObActionsIInputFunc *input,
218                               ObActionsICancelFunc *cancel,
219                               ObActionsIPostFunc *post)
220 {
221     Options *o;
222
223     o = setup_func(node, pre, input, cancel, post);
224     if (o->type == RELATIVE) {
225         o->interactive = TRUE;
226         *pre = i_pre_func;
227         *input = i_input_func;
228         *post = i_post_func;
229     }
230
231     return o;
232 }
233
234 static gpointer setup_send_func(xmlNodePtr node,
235                                 ObActionsIPreFunc *pre,
236                                 ObActionsIInputFunc *input,
237                                 ObActionsICancelFunc *cancel,
238                                 ObActionsIPostFunc *post)
239 {
240     xmlNodePtr n;
241     Options *o;
242
243     o = setup_func(node, pre, input, cancel, post);
244     o->send = TRUE;
245     o->follow = TRUE;
246
247     if ((n = obt_xml_find_node(node, "follow")))
248         o->follow = obt_xml_node_bool(n);
249
250     if (o->type == RELATIVE && o->follow) {
251         o->interactive = TRUE;
252         *pre = i_pre_func;
253         *input = i_input_func;
254         *post = i_post_func;
255     }
256
257     return o;
258 }
259
260 static void free_func(gpointer o)
261 {
262     g_slice_free(Options, o);
263 }
264
265 /* Always return FALSE because its not interactive */
266 static gboolean run_func(ObActionsData *data, gpointer options)
267 {
268     Options *o = options;
269     guint d;
270
271     switch (o->type) {
272     case LAST:
273         d = screen_last_desktop;
274         break;
275     case ABSOLUTE:
276         d = o->u.abs.desktop;
277         break;
278     case RELATIVE:
279         d = screen_find_desktop(screen_desktop,
280                                 o->u.rel.dir, o->u.rel.wrap, o->u.rel.linear);
281         break;
282     default:
283         g_assert_not_reached();
284     }
285
286     if (d < screen_num_desktops && d != screen_desktop) {
287         gboolean go = TRUE;
288
289         actions_client_move(data, TRUE);
290         if (o->send && data->client && client_normal(data->client)) {
291             client_set_desktop(data->client, d, o->follow, FALSE);
292             go = o->follow;
293         }
294
295         if (go) {
296             screen_set_desktop(d, TRUE);
297             if (data->client)
298                 client_bring_helper_windows(data->client);
299         }
300
301         actions_client_move(data, FALSE);
302     }
303
304     return o->interactive;
305 }
306
307 static gboolean i_input_func(guint initial_state,
308                              XEvent *e,
309                              ObtIC *ic,
310                              gpointer options,
311                              gboolean *used)
312 {
313     guint mods;
314
315     mods = obt_keyboard_only_modmasks(e->xkey.state);
316     if (e->type == KeyRelease) {
317         /* remove from the state the mask of the modifier key being
318            released, if it is a modifier key being released that is */
319         mods &= ~obt_keyboard_keycode_to_modmask(e->xkey.keycode);
320     }
321
322     if (e->type == KeyPress) {
323         KeySym sym = obt_keyboard_keypress_to_keysym(e);
324
325         /* Escape cancels no matter what */
326         if (sym == XK_Escape)
327             return FALSE;
328
329         /* There were no modifiers and they pressed enter */
330         else if (sym == XK_Return && !initial_state)
331             return FALSE;
332     }
333     /* They released the modifiers */
334     else if (e->type == KeyRelease && initial_state && !(mods & initial_state))
335     {
336         return FALSE;
337     }
338
339     return TRUE;
340 }
341
342 static gboolean i_pre_func(guint initial_state, gpointer options)
343 {
344     if (!initial_state) {
345         Options *o = options;
346         o->interactive = FALSE;
347         return FALSE;
348     }
349     else {
350         screen_show_desktop_popup(screen_desktop, TRUE);
351         return TRUE;
352     }
353 }
354
355 static void i_post_func(gpointer options)
356 {
357     screen_hide_desktop_popup();
358 }
359
360 /* 3.4-compatilibity */
361 static gpointer setup_follow(xmlNodePtr node)
362 {
363     xmlNodePtr n;
364     Options *o = g_slice_new0(Options);
365     o->send = TRUE;
366     o->follow = TRUE;
367     if ((n = obt_xml_find_node(node, "follow")))
368         o->follow = obt_xml_node_bool(n);
369     return o;
370 }
371
372 static gpointer setup_go_last_func(xmlNodePtr node)
373 {
374     Options *o = g_slice_new0(Options);
375     o->type = LAST;
376     return o;
377 }
378
379 static gpointer setup_send_last_func(xmlNodePtr node)
380 {
381     Options *o = setup_follow(node);
382     o->type = LAST;
383     return o;
384 }
385
386 static gpointer setup_go_abs_func(xmlNodePtr node)
387 {
388     xmlNodePtr n;
389     Options *o = g_slice_new0(Options);
390     o->type = ABSOLUTE;
391     if ((n = obt_xml_find_node(node, "desktop")))
392         o->u.abs.desktop = obt_xml_node_int(n) - 1;
393     else
394         o->u.abs.desktop = screen_desktop;
395     return o;
396 }
397
398 static gpointer setup_send_abs_func(xmlNodePtr node)
399 {
400     xmlNodePtr n;
401     Options *o = setup_follow(node);
402     o->type = ABSOLUTE;
403     if ((n = obt_xml_find_node(node, "desktop")))
404         o->u.abs.desktop = obt_xml_node_int(n) - 1;
405     else
406         o->u.abs.desktop = screen_desktop;
407     return o;
408 }
409
410 static void setup_rel(Options *o, xmlNodePtr node, gboolean lin,
411                       ObDirection dir,
412                       ObActionsIPreFunc *pre,
413                       ObActionsIInputFunc *input,
414                       ObActionsIPostFunc *post)
415 {
416     xmlNodePtr n;
417
418     o->type = RELATIVE;
419     o->u.rel.linear = lin;
420     o->u.rel.dir = dir;
421     o->u.rel.wrap = TRUE;
422
423     if ((n = obt_xml_find_node(node, "wrap")))
424         o->u.rel.wrap = obt_xml_node_bool(n);
425
426     if (input) {
427         o->interactive = TRUE;
428         *pre = i_pre_func;
429         *input = i_input_func;
430         *post = i_post_func;
431     }
432 }
433
434 static gpointer setup_go_next_func(xmlNodePtr node,
435                                    ObActionsIPreFunc *pre,
436                                    ObActionsIInputFunc *input,
437                                    ObActionsICancelFunc *cancel,
438                                    ObActionsIPostFunc *post)
439 {
440     Options *o = g_slice_new0(Options);
441     setup_rel(o, node, TRUE, OB_DIRECTION_EAST, pre, input, post);
442     return o;
443 }
444
445 static gpointer setup_send_next_func(xmlNodePtr node,
446                                      ObActionsIPreFunc *pre,
447                                      ObActionsIInputFunc *input,
448                                      ObActionsICancelFunc *cancel,
449                                      ObActionsIPostFunc *post)
450 {
451     Options *o = setup_follow(node);
452     setup_rel(o, node, TRUE, OB_DIRECTION_EAST,
453               pre, (o->follow ? input : NULL), post);
454     return o;
455 }
456
457 static gpointer setup_go_prev_func(xmlNodePtr node,
458                                    ObActionsIPreFunc *pre,
459                                    ObActionsIInputFunc *input,
460                                    ObActionsICancelFunc *cancel,
461                                    ObActionsIPostFunc *post)
462 {
463     Options *o = g_slice_new0(Options);
464     setup_rel(o, node, TRUE, OB_DIRECTION_WEST, pre, input, post);
465     return o;
466 }
467
468 static gpointer setup_send_prev_func(xmlNodePtr node,
469                                      ObActionsIPreFunc *pre,
470                                      ObActionsIInputFunc *input,
471                                      ObActionsICancelFunc *cancel,
472                                      ObActionsIPostFunc *post)
473 {
474     Options *o = setup_follow(node);
475     setup_rel(o, node, TRUE, OB_DIRECTION_WEST,
476               pre, (o->follow ? input : NULL), post);
477     return o;
478 }
479
480 static gpointer setup_go_left_func(xmlNodePtr node,
481                                    ObActionsIPreFunc *pre,
482                                    ObActionsIInputFunc *input,
483                                    ObActionsICancelFunc *cancel,
484                                    ObActionsIPostFunc *post)
485 {
486     Options *o = g_slice_new0(Options);
487     setup_rel(o, node, FALSE, OB_DIRECTION_WEST, pre, input, post);
488     return o;
489 }
490
491 static gpointer setup_send_left_func(xmlNodePtr node,
492                                      ObActionsIPreFunc *pre,
493                                      ObActionsIInputFunc *input,
494                                      ObActionsICancelFunc *cancel,
495                                      ObActionsIPostFunc *post)
496 {
497     Options *o = setup_follow(node);
498     setup_rel(o, node, FALSE, OB_DIRECTION_WEST,
499               pre, (o->follow ? input : NULL), post);
500     return o;
501 }
502
503 static gpointer setup_go_right_func(xmlNodePtr node,
504                                     ObActionsIPreFunc *pre,
505                                     ObActionsIInputFunc *input,
506                                     ObActionsICancelFunc *cancel,
507                                     ObActionsIPostFunc *post)
508 {
509     Options *o = g_slice_new0(Options);
510     setup_rel(o, node, FALSE, OB_DIRECTION_EAST, pre, input, post);
511     return o;
512 }
513
514 static gpointer setup_send_right_func(xmlNodePtr node,
515                                       ObActionsIPreFunc *pre,
516                                       ObActionsIInputFunc *input,
517                                       ObActionsICancelFunc *cancel,
518                                       ObActionsIPostFunc *post)
519 {
520     Options *o = setup_follow(node);
521     setup_rel(o, node, FALSE, OB_DIRECTION_EAST,
522               pre, (o->follow ? input : NULL), post);
523     return o;
524 }
525
526 static gpointer setup_go_up_func(xmlNodePtr node,
527                                  ObActionsIPreFunc *pre,
528                                  ObActionsIInputFunc *input,
529                                  ObActionsICancelFunc *cancel,
530                                  ObActionsIPostFunc *post)
531 {
532     Options *o = g_slice_new0(Options);
533     setup_rel(o, node, FALSE, OB_DIRECTION_NORTH, pre, input, post);
534     return o;
535 }
536
537 static gpointer setup_send_up_func(xmlNodePtr node,
538                                    ObActionsIPreFunc *pre,
539                                    ObActionsIInputFunc *input,
540                                    ObActionsICancelFunc *cancel,
541                                    ObActionsIPostFunc *post)
542 {
543     Options *o = setup_follow(node);
544     setup_rel(o, node, FALSE, OB_DIRECTION_NORTH,
545               pre, (o->follow ? input : NULL), post);
546     return o;
547 }
548
549 static gpointer setup_go_down_func(xmlNodePtr node,
550                                    ObActionsIPreFunc *pre,
551                                    ObActionsIInputFunc *input,
552                                    ObActionsICancelFunc *cancel,
553                                    ObActionsIPostFunc *post)
554 {
555     Options *o = g_slice_new0(Options);
556     setup_rel(o, node, FALSE, OB_DIRECTION_SOUTH, pre, input, post);
557     return o;
558 }
559
560 static gpointer setup_send_down_func(xmlNodePtr node,
561                                      ObActionsIPreFunc *pre,
562                                      ObActionsIInputFunc *input,
563                                      ObActionsICancelFunc *cancel,
564                                      ObActionsIPostFunc *post)
565 {
566     Options *o = setup_follow(node);
567     setup_rel(o, node, FALSE, OB_DIRECTION_SOUTH,
568               pre, (o->follow ? input : NULL), post);
569     return o;
570 }