make openbox base-dir spec compliant, and change the theme dir structure, so that...
[mikachu/openbox.git] / openbox / action.c
1 #include "debug.h"
2 #include "client.h"
3 #include "focus.h"
4 #include "moveresize.h"
5 #include "menu.h"
6 #include "prop.h"
7 #include "stacking.h"
8 #include "screen.h"
9 #include "action.h"
10 #include "openbox.h"
11 #include "grab.h"
12 #include "keyboard.h"
13
14 #include <glib.h>
15
16 typedef struct ActionString {
17     char *name;
18     void (*func)(union ActionData *);
19     void (*setup)(ObAction **, ObUserAction uact);
20 } ActionString;
21
22 static ObAction *action_new(void (*func)(union ActionData *data),
23                             ObUserAction uact)
24 {
25     ObAction *a = g_new0(ObAction, 1);
26     a->func = func;
27
28     return a;
29 }
30
31 void action_free(ObAction *a)
32 {
33     if (a == NULL) return;
34
35     /* deal with pointers */
36     if (a->func == action_execute || a->func == action_restart)
37         g_free(a->data.execute.path);
38     else if (a->func == action_showmenu)
39         g_free(a->data.showmenu.name);
40
41     g_free(a);
42 }
43
44 void setup_action_directional_focus_north(ObAction **a, ObUserAction uact)
45
46     (*a)->data.interdiraction.inter.any.interactive = TRUE;
47     (*a)->data.interdiraction.direction = OB_DIRECTION_NORTH;
48 }
49
50 void setup_action_directional_focus_east(ObAction **a, ObUserAction uact)
51 {
52     (*a)->data.interdiraction.inter.any.interactive = TRUE;
53     (*a)->data.interdiraction.direction = OB_DIRECTION_EAST;
54 }
55
56 void setup_action_directional_focus_south(ObAction **a, ObUserAction uact)
57 {
58     (*a)->data.interdiraction.inter.any.interactive = TRUE;
59     (*a)->data.interdiraction.direction = OB_DIRECTION_SOUTH;
60 }
61
62 void setup_action_directional_focus_west(ObAction **a, ObUserAction uact)
63 {
64     (*a)->data.interdiraction.inter.any.interactive = TRUE;
65     (*a)->data.interdiraction.direction = OB_DIRECTION_WEST;
66 }
67
68 void setup_action_directional_focus_northeast(ObAction **a, ObUserAction uact)
69 {
70     (*a)->data.interdiraction.inter.any.interactive = TRUE;
71     (*a)->data.interdiraction.direction = OB_DIRECTION_NORTHEAST;
72 }
73
74 void setup_action_directional_focus_southeast(ObAction **a, ObUserAction uact)
75 {
76     (*a)->data.interdiraction.inter.any.interactive = TRUE;
77     (*a)->data.interdiraction.direction = OB_DIRECTION_SOUTHEAST;
78 }
79
80 void setup_action_directional_focus_southwest(ObAction **a, ObUserAction uact)
81 {
82     (*a)->data.interdiraction.inter.any.interactive = TRUE;
83     (*a)->data.interdiraction.direction = OB_DIRECTION_SOUTHWEST;
84 }
85
86 void setup_action_directional_focus_northwest(ObAction **a, ObUserAction uact)
87 {
88     (*a)->data.interdiraction.inter.any.interactive = TRUE;
89     (*a)->data.interdiraction.direction = OB_DIRECTION_NORTHWEST;
90 }
91
92 void setup_action_send_to_desktop(ObAction **a, ObUserAction uact)
93 {
94     (*a)->data.sendto.follow = TRUE;
95 }
96
97 void setup_action_send_to_desktop_prev(ObAction **a, ObUserAction uact)
98 {
99     (*a)->data.sendtodir.inter.any.interactive = TRUE;
100     (*a)->data.sendtodir.dir = OB_DIRECTION_WEST;
101     (*a)->data.sendtodir.linear = TRUE;
102     (*a)->data.sendtodir.wrap = TRUE;
103     (*a)->data.sendtodir.follow = TRUE;
104 }
105
106 void setup_action_send_to_desktop_next(ObAction **a, ObUserAction uact)
107 {
108     (*a)->data.sendtodir.inter.any.interactive = TRUE;
109     (*a)->data.sendtodir.dir = OB_DIRECTION_EAST;
110     (*a)->data.sendtodir.linear = TRUE;
111     (*a)->data.sendtodir.wrap = TRUE;
112     (*a)->data.sendtodir.follow = TRUE;
113 }
114
115 void setup_action_send_to_desktop_left(ObAction **a, ObUserAction uact)
116 {
117     (*a)->data.sendtodir.inter.any.interactive = TRUE;
118     (*a)->data.sendtodir.dir = OB_DIRECTION_WEST;
119     (*a)->data.sendtodir.linear = FALSE;
120     (*a)->data.sendtodir.wrap = TRUE;
121     (*a)->data.sendtodir.follow = TRUE;
122 }
123
124 void setup_action_send_to_desktop_right(ObAction **a, ObUserAction uact)
125 {
126     (*a)->data.sendtodir.inter.any.interactive = TRUE;
127     (*a)->data.sendtodir.dir = OB_DIRECTION_EAST;
128     (*a)->data.sendtodir.linear = FALSE;
129     (*a)->data.sendtodir.wrap = TRUE;
130     (*a)->data.sendtodir.follow = TRUE;
131 }
132
133 void setup_action_send_to_desktop_up(ObAction **a, ObUserAction uact)
134 {
135     (*a)->data.sendtodir.inter.any.interactive = TRUE;
136     (*a)->data.sendtodir.dir = OB_DIRECTION_NORTH;
137     (*a)->data.sendtodir.linear = FALSE;
138     (*a)->data.sendtodir.wrap = TRUE;
139     (*a)->data.sendtodir.follow = TRUE;
140 }
141
142 void setup_action_send_to_desktop_down(ObAction **a, ObUserAction uact)
143 {
144     (*a)->data.sendtodir.inter.any.interactive = TRUE;
145     (*a)->data.sendtodir.dir = OB_DIRECTION_SOUTH;
146     (*a)->data.sendtodir.linear = FALSE;
147     (*a)->data.sendtodir.wrap = TRUE;
148     (*a)->data.sendtodir.follow = TRUE;
149 }
150
151 void setup_action_desktop_prev(ObAction **a, ObUserAction uact)
152 {
153     (*a)->data.desktopdir.inter.any.interactive = TRUE;
154     (*a)->data.desktopdir.dir = OB_DIRECTION_WEST;
155     (*a)->data.desktopdir.linear = TRUE;
156     (*a)->data.desktopdir.wrap = TRUE;
157 }
158
159 void setup_action_desktop_next(ObAction **a, ObUserAction uact)
160 {
161     (*a)->data.desktopdir.inter.any.interactive = TRUE;
162     (*a)->data.desktopdir.dir = OB_DIRECTION_EAST;
163     (*a)->data.desktopdir.linear = TRUE;
164     (*a)->data.desktopdir.wrap = TRUE;
165 }
166
167 void setup_action_desktop_left(ObAction **a, ObUserAction uact)
168 {
169     (*a)->data.desktopdir.inter.any.interactive = TRUE;
170     (*a)->data.desktopdir.dir = OB_DIRECTION_WEST;
171     (*a)->data.desktopdir.linear = FALSE;
172     (*a)->data.desktopdir.wrap = TRUE;
173 }
174
175 void setup_action_desktop_right(ObAction **a, ObUserAction uact)
176 {
177     (*a)->data.desktopdir.inter.any.interactive = TRUE;
178     (*a)->data.desktopdir.dir = OB_DIRECTION_EAST;
179     (*a)->data.desktopdir.linear = FALSE;
180     (*a)->data.desktopdir.wrap = TRUE;
181 }
182
183 void setup_action_desktop_up(ObAction **a, ObUserAction uact)
184 {
185     (*a)->data.desktopdir.inter.any.interactive = TRUE;
186     (*a)->data.desktopdir.dir = OB_DIRECTION_NORTH;
187     (*a)->data.desktopdir.linear = FALSE;
188     (*a)->data.desktopdir.wrap = TRUE;
189 }
190
191 void setup_action_desktop_down(ObAction **a, ObUserAction uact)
192 {
193     (*a)->data.desktopdir.inter.any.interactive = TRUE;
194     (*a)->data.desktopdir.dir = OB_DIRECTION_SOUTH;
195     (*a)->data.desktopdir.linear = FALSE;
196     (*a)->data.desktopdir.wrap = TRUE;
197 }
198
199 void setup_action_cycle_windows_next(ObAction **a, ObUserAction uact)
200 {
201     (*a)->data.cycle.inter.any.interactive = TRUE;
202     (*a)->data.cycle.linear = FALSE;
203     (*a)->data.cycle.forward = TRUE;
204 }
205
206 void setup_action_cycle_windows_previous(ObAction **a, ObUserAction uact)
207 {
208     (*a)->data.cycle.inter.any.interactive = TRUE;
209     (*a)->data.cycle.linear = FALSE;
210     (*a)->data.cycle.forward = FALSE;
211 }
212
213 void setup_action_movetoedge_north(ObAction **a, ObUserAction uact)
214 {
215     (*a)->data.diraction.direction = OB_DIRECTION_NORTH;
216 }
217
218 void setup_action_movetoedge_south(ObAction **a, ObUserAction uact)
219 {
220     (*a)->data.diraction.direction = OB_DIRECTION_SOUTH;
221 }
222
223 void setup_action_movetoedge_east(ObAction **a, ObUserAction uact)
224 {
225     (*a)->data.diraction.direction = OB_DIRECTION_EAST;
226 }
227
228 void setup_action_movetoedge_west(ObAction **a, ObUserAction uact)
229 {
230     (*a)->data.diraction.direction = OB_DIRECTION_WEST;
231 }
232
233 void setup_action_growtoedge_north(ObAction **a, ObUserAction uact)
234 {
235     (*a)->data.diraction.direction = OB_DIRECTION_NORTH;
236 }
237
238 void setup_action_growtoedge_south(ObAction **a, ObUserAction uact)
239 {
240     (*a)->data.diraction.direction = OB_DIRECTION_SOUTH;
241 }
242
243 void setup_action_growtoedge_east(ObAction **a, ObUserAction uact)
244 {
245     (*a)->data.diraction.direction = OB_DIRECTION_EAST;
246 }
247
248 void setup_action_growtoedge_west(ObAction **a, ObUserAction uact)
249 {
250     (*a)->data.diraction.direction = OB_DIRECTION_WEST;
251 }
252
253 void setup_action_top_layer(ObAction **a, ObUserAction uact)
254 {
255     (*a)->data.layer.layer = 1;
256 }
257
258 void setup_action_normal_layer(ObAction **a, ObUserAction uact)
259 {
260     (*a)->data.layer.layer = 0;
261 }
262
263 void setup_action_bottom_layer(ObAction **a, ObUserAction uact)
264 {
265     (*a)->data.layer.layer = -1;
266 }
267
268 void setup_action_move(ObAction **a, ObUserAction uact)
269 {
270     (*a)->data.moveresize.move = TRUE;
271     (*a)->data.moveresize.keyboard =
272         (uact == OB_USER_ACTION_KEYBOARD_KEY ||
273          uact == OB_USER_ACTION_MENU_SELECTION);
274 }
275
276 void setup_action_resize(ObAction **a, ObUserAction uact)
277 {
278     (*a)->data.moveresize.move = FALSE;
279     (*a)->data.moveresize.keyboard =
280         (uact == OB_USER_ACTION_KEYBOARD_KEY ||
281          uact == OB_USER_ACTION_MENU_SELECTION);
282 }
283
284 void setup_action_showmenu(ObAction **a, ObUserAction uact)
285 {
286     /* you cannot call ShowMenu from inside a menu, cuz the menu code makes
287        assumptions that there is only one menu (and submenus) open at
288        a time! */
289     if (uact == OB_USER_ACTION_MENU_SELECTION) {
290         action_free(*a);
291         a = NULL;
292     }
293 }
294
295 ActionString actionstrings[] =
296 {
297     {
298         "execute", 
299         action_execute, 
300         NULL
301     },
302     {
303         "directionalfocusnorth", 
304         action_directional_focus, 
305         setup_action_directional_focus_north
306     },
307     {
308         "directionalfocuseast", 
309         action_directional_focus, 
310         setup_action_directional_focus_east
311     },
312     {
313         "directionalfocussouth", 
314         action_directional_focus, 
315         setup_action_directional_focus_south
316     },
317     {
318         "directionalfocuswest",
319         action_directional_focus,
320         setup_action_directional_focus_west
321     },
322     {
323         "directionalfocusnortheast",
324         action_directional_focus,
325         setup_action_directional_focus_northeast
326     },
327     {
328         "directionalfocussoutheast",
329         action_directional_focus,
330         setup_action_directional_focus_southeast
331     },
332     {
333         "directionalfocussouthwest",
334         action_directional_focus,
335         setup_action_directional_focus_southwest
336     },
337     {
338         "directionalfocusnorthwest",
339         action_directional_focus,
340         setup_action_directional_focus_northwest
341     },
342     {
343         "activate",
344         action_activate,
345         NULL
346     },
347     {
348         "focus",
349         action_focus,
350         NULL
351     },
352     {
353         "unfocus",
354         action_unfocus,
355         NULL
356     },
357     {
358         "iconify",
359         action_iconify,
360         NULL
361     },
362     {
363         "raiselower",
364         action_raiselower,
365         NULL
366     },
367     {
368         "raise",
369         action_raise,
370         NULL
371     },
372     {
373         "lower",
374         action_lower,
375         NULL
376     },
377     {
378         "close",
379         action_close,
380         NULL
381     },
382     {
383         "kill",
384         action_kill,
385         NULL
386     },
387     {
388         "shadelower",
389         action_shadelower,
390         NULL
391     },
392     {
393         "unshaderaise",
394         action_unshaderaise,
395         NULL
396     },
397     {
398         "shade",
399         action_shade,
400         NULL
401     },
402     {
403         "unshade",
404         action_unshade,
405         NULL
406     },
407     {
408         "toggleshade",
409         action_toggle_shade,
410         NULL
411     },
412     {
413         "toggleomnipresent",
414         action_toggle_omnipresent,
415         NULL
416     },
417     {
418         "moverelativehorz",
419         action_move_relative_horz,
420         NULL
421     },
422     {
423         "moverelativevert",
424         action_move_relative_vert,
425         NULL
426     },
427     {
428         "resizerelativehorz",
429         action_resize_relative_horz,
430         NULL
431     },
432     {
433         "resizerelativevert",
434         action_resize_relative_vert,
435         NULL
436     },
437     {
438         "maximizefull",
439         action_maximize_full,
440         NULL
441     },
442     {
443         "unmaximizefull",
444         action_unmaximize_full,
445         NULL
446     },
447     {
448         "togglemaximizefull",
449         action_toggle_maximize_full,
450         NULL
451     },
452     {
453         "maximizehorz",
454         action_maximize_horz,
455         NULL
456     },
457     {
458         "unmaximizehorz",
459         action_unmaximize_horz,
460         NULL
461     },
462     {
463         "togglemaximizehorz",
464         action_toggle_maximize_horz,
465         NULL
466     },
467     {
468         "maximizevert",
469         action_maximize_vert,
470         NULL
471     },
472     {
473         "unmaximizevert",
474         action_unmaximize_vert,
475         NULL
476     },
477     {
478         "togglemaximizevert",
479         action_toggle_maximize_vert,
480         NULL
481     },
482     {
483         "sendtodesktop",
484         action_send_to_desktop,
485         setup_action_send_to_desktop
486     },
487     {
488         "sendtodesktopnext",
489         action_send_to_desktop_dir,
490         setup_action_send_to_desktop_next
491     },
492     {
493         "sendtodesktopprevious",
494         action_send_to_desktop_dir,
495         setup_action_send_to_desktop_prev
496     },
497     {
498         "sendtodesktopright",
499         action_send_to_desktop_dir,
500         setup_action_send_to_desktop_right
501     },
502     {
503         "sendtodesktopleft",
504         action_send_to_desktop_dir,
505         setup_action_send_to_desktop_left
506     },
507     {
508         "sendtodesktopup",
509         action_send_to_desktop_dir,
510         setup_action_send_to_desktop_up
511     },
512     {
513         "sendtodesktopdown",
514         action_send_to_desktop_dir,
515         setup_action_send_to_desktop_down
516     },
517     {
518         "desktop",
519         action_desktop,
520         NULL
521     },
522     {
523         "desktopnext",
524         action_desktop_dir,
525         setup_action_desktop_next
526     },
527     {
528         "desktopprevious",
529         action_desktop_dir,
530         setup_action_desktop_prev
531     },
532     {
533         "desktopright",
534         action_desktop_dir,
535         setup_action_desktop_right
536     },
537     {
538         "desktopleft",
539         action_desktop_dir,
540         setup_action_desktop_left
541     },
542     {
543         "desktopup",
544         action_desktop_dir,
545         setup_action_desktop_up
546     },
547     {
548         "desktopdown",
549         action_desktop_dir,
550         setup_action_desktop_down
551     },
552     {
553         "toggledecorations",
554         action_toggle_decorations,
555         NULL
556     },
557     {
558         "move",
559         action_moveresize,
560         setup_action_move
561     },
562     {
563         "resize",
564         action_moveresize,
565         setup_action_resize
566     },
567     {
568         "toggleshowdesktop",
569         action_toggle_show_desktop,
570         NULL
571     },
572     {
573         "showdesktop",
574         action_show_desktop,
575         NULL
576     },
577     {
578         "unshowdesktop",
579         action_unshow_desktop,
580         NULL
581     },
582     {
583         "desktoplast",
584         action_desktop_last,
585         NULL
586     },
587     {
588         "reconfigure",
589         action_reconfigure,
590         NULL
591     },
592     {
593         "restart",
594         action_restart,
595         NULL
596     },
597     {
598         "exit",
599         action_exit,
600         NULL
601     },
602     {
603         "showmenu",
604         action_showmenu,
605         setup_action_showmenu
606     },
607     {
608         "sendtotoplayer",
609         action_send_to_layer,
610         setup_action_top_layer
611     },
612     {
613         "togglealwaysontop",
614         action_toggle_layer,
615         setup_action_top_layer
616     },
617     {
618         "sendtonormallayer",
619         action_send_to_layer,
620         setup_action_normal_layer
621     },
622     {
623         "sendtobottomlayer",
624         action_send_to_layer,
625         setup_action_bottom_layer
626     },
627     {
628         "togglealwaysonbottom",
629         action_toggle_layer,
630         setup_action_bottom_layer
631     },
632     {
633         "nextwindow",
634         action_cycle_windows,
635         setup_action_cycle_windows_next
636     },
637     {
638         "previouswindow",
639         action_cycle_windows,
640         setup_action_cycle_windows_previous
641     },
642     {
643         "movetoedgenorth",
644         action_movetoedge,
645         setup_action_movetoedge_north
646     },
647     {
648         "movetoedgesouth",
649         action_movetoedge,
650         setup_action_movetoedge_south
651     },
652     {
653         "movetoedgewest",
654         action_movetoedge,
655         setup_action_movetoedge_west
656     },
657     {
658         "movetoedgeeast",
659         action_movetoedge,
660         setup_action_movetoedge_east
661     },
662     {
663         "growtoedgenorth",
664         action_growtoedge,
665         setup_action_growtoedge_north
666     },
667     {
668         "growtoedgesouth",
669         action_growtoedge,
670         setup_action_growtoedge_south
671     },
672     {
673         "growtoedgewest",
674         action_growtoedge,
675         setup_action_growtoedge_west
676     },
677     {
678         "growtoedgeeast",
679         action_growtoedge,
680         setup_action_growtoedge_east
681     },
682     {
683         NULL,
684         NULL,
685         NULL
686     }
687 };
688
689 ObAction *action_from_string(char *name, ObUserAction uact)
690 {
691     ObAction *a = NULL;
692     gboolean exist = FALSE;
693     int i;
694
695     for (i = 0; actionstrings[i].name; i++)
696         if (!g_ascii_strcasecmp(name, actionstrings[i].name)) {
697             exist = TRUE;
698             a = action_new(actionstrings[i].func, uact);
699             if (actionstrings[i].setup)
700                 actionstrings[i].setup(&a, uact);
701             /* only key bindings can be interactive. thus saith the xor. */
702             if (uact != OB_USER_ACTION_KEYBOARD_KEY)
703                 a->data.any.interactive = FALSE;
704             break;
705         }
706     if (!exist)
707         g_warning("Invalid action '%s' requested. No such action exists.",
708                   name);
709     if (!a)
710         g_warning("Invalid use of action '%s'. Action will be ignored.", name);
711     return a;
712 }
713
714 ObAction *action_parse(ObParseInst *i, xmlDocPtr doc, xmlNodePtr node,
715                        ObUserAction uact)
716 {
717     char *actname;
718     ObAction *act = NULL;
719     xmlNodePtr n;
720
721     if (parse_attr_string("name", node, &actname)) {
722         if ((act = action_from_string(actname, uact))) {
723             if (act->func == action_execute || act->func == action_restart) {
724                 if ((n = parse_find_node("execute", node->xmlChildrenNode))) {
725                     gchar *s = parse_string(doc, n);
726                     act->data.execute.path = parse_expand_tilde(s);
727                     g_free(s);
728                 }
729             } else if (act->func == action_showmenu) {
730                 if ((n = parse_find_node("menu", node->xmlChildrenNode)))
731                     act->data.showmenu.name = parse_string(doc, n);
732             } else if (act->func == action_move_relative_horz ||
733                        act->func == action_move_relative_vert ||
734                        act->func == action_resize_relative_horz ||
735                        act->func == action_resize_relative_vert) {
736                 if ((n = parse_find_node("delta", node->xmlChildrenNode)))
737                     act->data.relative.delta = parse_int(doc, n);
738             } else if (act->func == action_desktop) {
739                 if ((n = parse_find_node("desktop", node->xmlChildrenNode)))
740                     act->data.desktop.desk = parse_int(doc, n);
741                 if (act->data.desktop.desk > 0) act->data.desktop.desk--;
742            } else if (act->func == action_send_to_desktop) {
743                 if ((n = parse_find_node("desktop", node->xmlChildrenNode)))
744                     act->data.sendto.desk = parse_int(doc, n);
745                 if (act->data.sendto.desk > 0) act->data.sendto.desk--;
746                 if ((n = parse_find_node("follow", node->xmlChildrenNode)))
747                     act->data.sendto.follow = parse_bool(doc, n);
748             } else if (act->func == action_desktop_dir) {
749                 if ((n = parse_find_node("wrap", node->xmlChildrenNode)))
750                     act->data.desktopdir.wrap = parse_bool(doc, n); 
751             } else if (act->func == action_send_to_desktop_dir) {
752                 if ((n = parse_find_node("wrap", node->xmlChildrenNode)))
753                     act->data.sendtodir.wrap = parse_bool(doc, n);
754                 if ((n = parse_find_node("follow", node->xmlChildrenNode)))
755                     act->data.sendtodir.follow = parse_bool(doc, n);
756             } else if (act->func == action_activate) {
757                 if ((n = parse_find_node("here", node->xmlChildrenNode)))
758                     act->data.activate.here = parse_bool(doc, n);
759             } else if (act->func == action_cycle_windows) {
760                 if ((n = parse_find_node("linear", node->xmlChildrenNode)))
761                     act->data.cycle.linear = parse_bool(doc, n);
762             }
763         }
764         g_free(actname);
765     }
766     return act;
767 }
768
769 void action_run_full(ObAction *a, struct _ObClient *c,
770                      guint state, guint button, gint x, gint y,
771                      gboolean cancel, gboolean done)
772 {
773     if (x < 0 && y < 0)
774         screen_pointer_pos(&x, &y);
775
776     a->data.any.c = c;
777     a->data.any.x = x;
778     a->data.any.y = y;
779
780     a->data.any.button = button;
781
782     if (a->data.any.interactive) {
783         a->data.inter.cancel = cancel;
784         a->data.inter.final = done;
785         if (!(cancel || done))
786             keyboard_interactive_grab(state, c, a);
787     }
788
789     a->func(&a->data);
790 }
791
792 void action_execute(union ActionData *data)
793 {
794     GError *e = NULL;
795     char *cmd;
796     if (data->execute.path) {
797         cmd = g_filename_from_utf8(data->execute.path, -1, NULL, NULL, NULL);
798         if (cmd) {
799             if (!g_spawn_command_line_async(cmd, &e)) {
800                 g_warning("failed to execute '%s': %s",
801                           cmd, e->message);
802             }
803             g_free(cmd);
804         } else {
805             g_warning("failed to convert '%s' from utf8", data->execute.path);
806         }
807     }
808 }
809
810 void action_activate(union ActionData *data)
811 {
812     if (data->activate.any.c)
813         client_activate(data->activate.any.c, data->activate.here);
814 }
815
816 void action_focus(union ActionData *data)
817 {
818     if (data->client.any.c)
819         client_focus(data->client.any.c);
820 }
821
822 void action_unfocus (union ActionData *data)
823 {
824     if (data->client.any.c)
825         client_unfocus(data->client.any.c);
826 }
827
828 void action_iconify(union ActionData *data)
829 {
830     if (data->client.any.c)
831         client_iconify(data->client.any.c, TRUE, TRUE);
832 }
833
834 void action_raiselower(union ActionData *data)
835 {
836     ObClient *c = data->client.any.c;
837     GList *it;
838     gboolean raise = FALSE;
839
840     if (!c) return;
841
842     for (it = stacking_list; it; it = g_list_next(it)) {
843         ObClient *cit = it->data;
844
845         if (cit == c) break;
846         if (client_normal(cit) == client_normal(c) &&
847             cit->layer == c->layer &&
848             cit->frame->visible)
849         {
850             if (RECT_INTERSECTS_RECT(cit->frame->area, c->frame->area)) {
851                 raise = TRUE;
852                 break;
853             }
854         }
855     }
856
857     if (raise)
858         stacking_raise(CLIENT_AS_WINDOW(c));
859     else
860         stacking_lower(CLIENT_AS_WINDOW(c));
861 }
862
863 void action_raise(union ActionData *data)
864 {
865     if (data->client.any.c)
866         stacking_raise(CLIENT_AS_WINDOW(data->client.any.c));
867 }
868
869 void action_unshaderaise(union ActionData *data)
870 {
871     if (data->client.any.c) {
872         if (data->client.any.c->shaded) {
873             grab_pointer(TRUE, OB_CURSOR_NONE);
874             client_shade(data->client.any.c, FALSE);
875             grab_pointer(FALSE, OB_CURSOR_NONE);
876         } else
877             stacking_raise(CLIENT_AS_WINDOW(data->client.any.c));
878     }
879 }
880
881 void action_shadelower(union ActionData *data)
882 {
883     if (data->client.any.c) {
884         if (data->client.any.c->shaded)
885             stacking_lower(CLIENT_AS_WINDOW(data->client.any.c));
886         else {
887             grab_pointer(TRUE, OB_CURSOR_NONE);
888             client_shade(data->client.any.c, TRUE);
889             grab_pointer(FALSE, OB_CURSOR_NONE);
890         }
891     }
892 }
893
894 void action_lower(union ActionData *data)
895 {
896     if (data->client.any.c)
897         stacking_lower(CLIENT_AS_WINDOW(data->client.any.c));
898 }
899
900 void action_close(union ActionData *data)
901 {
902     if (data->client.any.c)
903         client_close(data->client.any.c);
904 }
905
906 void action_kill(union ActionData *data)
907 {
908     if (data->client.any.c)
909         client_kill(data->client.any.c);
910 }
911
912 void action_shade(union ActionData *data)
913 {
914     if (data->client.any.c) { 
915         grab_pointer(TRUE, OB_CURSOR_NONE);
916         client_shade(data->client.any.c, TRUE);
917         grab_pointer(FALSE, OB_CURSOR_NONE);
918     }
919 }
920
921 void action_unshade(union ActionData *data)
922 {
923     if (data->client.any.c) {
924         grab_pointer(TRUE, OB_CURSOR_NONE);
925         client_shade(data->client.any.c, FALSE);
926         grab_pointer(FALSE, OB_CURSOR_NONE);
927     }
928 }
929
930 void action_toggle_shade(union ActionData *data)
931 {
932     if (data->client.any.c) {
933         grab_pointer(TRUE, OB_CURSOR_NONE);
934         client_shade(data->client.any.c, !data->client.any.c->shaded);
935         grab_pointer(FALSE, OB_CURSOR_NONE);
936     }
937 }
938
939 void action_toggle_omnipresent(union ActionData *data)
940
941     if (data->client.any.c)
942         client_set_desktop(data->client.any.c,
943                            data->client.any.c->desktop == DESKTOP_ALL ?
944                            screen_desktop : DESKTOP_ALL, FALSE);
945 }
946
947 void action_move_relative_horz(union ActionData *data)
948 {
949     ObClient *c = data->relative.any.c;
950     if (c) {
951         grab_pointer(TRUE, OB_CURSOR_NONE);
952         client_move(c, c->area.x + data->relative.delta, c->area.y);
953         grab_pointer(FALSE, OB_CURSOR_NONE);
954     }
955 }
956
957 void action_move_relative_vert(union ActionData *data)
958 {
959     ObClient *c = data->relative.any.c;
960     if (c) {
961         grab_pointer(TRUE, OB_CURSOR_NONE);
962         client_move(c, c->area.x, c->area.y + data->relative.delta);
963         grab_pointer(FALSE, OB_CURSOR_NONE);
964     }
965 }
966
967 void action_resize_relative_horz(union ActionData *data)
968 {
969     ObClient *c = data->relative.any.c;
970     if (c) {
971         grab_pointer(TRUE, OB_CURSOR_NONE);
972         client_resize(c,
973                       c->area.width + data->relative.delta * c->size_inc.width,
974                       c->area.height);
975         grab_pointer(FALSE, OB_CURSOR_NONE);
976     }
977 }
978
979 void action_resize_relative_vert(union ActionData *data)
980 {
981     ObClient *c = data->relative.any.c;
982     if (c && !c->shaded) {
983         grab_pointer(TRUE, OB_CURSOR_NONE);
984         client_resize(c, c->area.width, c->area.height +
985                       data->relative.delta * c->size_inc.height);
986         grab_pointer(FALSE, OB_CURSOR_NONE);
987     }
988 }
989
990 void action_maximize_full(union ActionData *data)
991 {
992     if (data->client.any.c)
993         client_maximize(data->client.any.c, TRUE, 0, TRUE);
994 }
995
996 void action_unmaximize_full(union ActionData *data)
997 {
998     if (data->client.any.c)
999         client_maximize(data->client.any.c, FALSE, 0, TRUE);
1000 }
1001
1002 void action_toggle_maximize_full(union ActionData *data)
1003 {
1004     if (data->client.any.c)
1005         client_maximize(data->client.any.c,
1006                         !(data->client.any.c->max_horz ||
1007                           data->client.any.c->max_vert),
1008                         0, TRUE);
1009 }
1010
1011 void action_maximize_horz(union ActionData *data)
1012 {
1013     if (data->client.any.c)
1014         client_maximize(data->client.any.c, TRUE, 1, TRUE);
1015 }
1016
1017 void action_unmaximize_horz(union ActionData *data)
1018 {
1019     if (data->client.any.c)
1020         client_maximize(data->client.any.c, FALSE, 1, TRUE);
1021 }
1022
1023 void action_toggle_maximize_horz(union ActionData *data)
1024 {
1025     if (data->client.any.c)
1026         client_maximize(data->client.any.c,
1027                         !data->client.any.c->max_horz, 1, TRUE);
1028 }
1029
1030 void action_maximize_vert(union ActionData *data)
1031 {
1032     if (data->client.any.c)
1033         client_maximize(data->client.any.c, TRUE, 2, TRUE);
1034 }
1035
1036 void action_unmaximize_vert(union ActionData *data)
1037 {
1038     if (data->client.any.c)
1039         client_maximize(data->client.any.c, FALSE, 2, TRUE);
1040 }
1041
1042 void action_toggle_maximize_vert(union ActionData *data)
1043 {
1044     if (data->client.any.c)
1045         client_maximize(data->client.any.c, !data->client.any.c->max_vert, 2, TRUE);
1046 }
1047
1048 void action_send_to_desktop(union ActionData *data)
1049 {
1050     ObClient *c = data->sendto.any.c;
1051
1052     if (!c || !client_normal(c)) return;
1053
1054     if (data->sendto.desk < screen_num_desktops ||
1055         data->sendto.desk == DESKTOP_ALL) {
1056         client_set_desktop(c, data->sendto.desk, data->sendto.follow);
1057         if (data->sendto.follow)
1058             screen_set_desktop(data->sendto.desk);
1059     }
1060 }
1061
1062 void action_desktop(union ActionData *data)
1063 {
1064     if (data->desktop.desk < screen_num_desktops ||
1065         data->desktop.desk == DESKTOP_ALL)
1066         screen_set_desktop(data->desktop.desk);
1067 }
1068
1069 void action_desktop_dir(union ActionData *data)
1070 {
1071     guint d;
1072
1073     d = screen_cycle_desktop(data->desktopdir.dir,
1074                              data->desktopdir.wrap,
1075                              data->sendtodir.linear,
1076                              data->desktopdir.inter.any.interactive,
1077                              data->desktopdir.inter.final,
1078                              data->desktopdir.inter.cancel);
1079     screen_set_desktop(d);
1080 }
1081
1082 void action_send_to_desktop_dir(union ActionData *data)
1083 {
1084     ObClient *c = data->sendtodir.inter.any.c;
1085     guint d;
1086
1087     if (!c || !client_normal(c)) return;
1088
1089     d = screen_cycle_desktop(data->sendtodir.dir, data->sendtodir.wrap,
1090                              data->sendtodir.linear,
1091                              data->sendtodir.inter.any.interactive,
1092                              data->sendtodir.inter.final,
1093                              data->sendtodir.inter.cancel);
1094     client_set_desktop(c, d, data->sendtodir.follow);
1095     if (data->sendtodir.follow)
1096         screen_set_desktop(d);
1097 }
1098
1099 void action_desktop_last(union ActionData *data)
1100 {
1101     screen_set_desktop(screen_last_desktop);
1102 }
1103
1104 void action_toggle_decorations(union ActionData *data)
1105 {
1106     ObClient *c = data->client.any.c;
1107
1108     if (!c) return;
1109
1110     c->decorate = !c->decorate;
1111     client_setup_decor_and_functions(c);
1112 }
1113
1114 static guint32 pick_corner(int x, int y, int cx, int cy, int cw, int ch)
1115 {
1116     if (x - cx > cw / 2) {
1117         if (y - cy > ch / 2)
1118             return prop_atoms.net_wm_moveresize_size_bottomright;
1119         else
1120             return prop_atoms.net_wm_moveresize_size_topright;
1121     } else {
1122         if (y - cy > ch / 2)
1123             return prop_atoms.net_wm_moveresize_size_bottomleft;
1124         else
1125             return prop_atoms.net_wm_moveresize_size_topleft;
1126     }
1127 }
1128
1129 void action_moveresize(union ActionData *data)
1130 {
1131     ObClient *c = data->moveresize.any.c;
1132     guint32 corner;
1133
1134     if (!c || !client_normal(c)) return;
1135
1136     if (data->moveresize.keyboard) {
1137         corner = (data->moveresize.move ?
1138                   prop_atoms.net_wm_moveresize_move_keyboard :
1139                   prop_atoms.net_wm_moveresize_size_keyboard);
1140     } else {
1141         corner = (data->moveresize.move ?
1142                   prop_atoms.net_wm_moveresize_move :
1143                   pick_corner(data->any.x, data->any.y,
1144                               c->frame->area.x, c->frame->area.y,
1145                               /* use the client size because the frame
1146                                  can be differently sized (shaded
1147                                  windows) and we want this based on the
1148                                  clients size */
1149                               c->area.width + c->frame->size.left +
1150                               c->frame->size.right,
1151                               c->area.height + c->frame->size.top +
1152                               c->frame->size.bottom));
1153     }
1154
1155     moveresize_start(c, data->any.x, data->any.y, data->any.button, corner);
1156 }
1157
1158 void action_reconfigure(union ActionData *data)
1159 {
1160     ob_reconfigure();
1161 }
1162
1163 void action_restart(union ActionData *data)
1164 {
1165     ob_restart_other(data->execute.path);
1166 }
1167
1168 void action_exit(union ActionData *data)
1169 {
1170     ob_exit();
1171 }
1172
1173 void action_showmenu(union ActionData *data)
1174 {
1175     if (data->showmenu.name) {
1176         menu_show(data->showmenu.name, data->any.x, data->any.y,
1177                   data->showmenu.any.c);
1178     }
1179 }
1180
1181 void action_cycle_windows(union ActionData *data)
1182 {
1183     focus_cycle(data->cycle.forward, data->cycle.linear,
1184                 data->cycle.inter.any.interactive,
1185                 data->cycle.inter.final, data->cycle.inter.cancel);
1186 }
1187
1188 void action_directional_focus(union ActionData *data)
1189 {
1190     focus_directional_cycle(data->interdiraction.direction,
1191                             data->interdiraction.inter.any.interactive,
1192                             data->interdiraction.inter.final,
1193                             data->interdiraction.inter.cancel);
1194 }
1195
1196 void action_movetoedge(union ActionData *data)
1197 {
1198     int x, y;
1199     ObClient *c = data->diraction.any.c;
1200
1201     if (!c)
1202         return;
1203     x = c->frame->area.x;
1204     y = c->frame->area.y;
1205     
1206     switch(data->diraction.direction) {
1207     case OB_DIRECTION_NORTH:
1208         y = client_directional_edge_search(c, OB_DIRECTION_NORTH);
1209         break;
1210     case OB_DIRECTION_WEST:
1211         x = client_directional_edge_search(c, OB_DIRECTION_WEST);
1212         break;
1213     case OB_DIRECTION_SOUTH:
1214         y = client_directional_edge_search(c, OB_DIRECTION_SOUTH) -
1215             c->frame->area.height;
1216         break;
1217     case OB_DIRECTION_EAST:
1218         x = client_directional_edge_search(c, OB_DIRECTION_EAST) -
1219             c->frame->area.width;
1220         break;
1221     default:
1222         g_assert_not_reached();
1223     }
1224     frame_frame_gravity(c->frame, &x, &y);
1225     grab_pointer(TRUE, OB_CURSOR_NONE);
1226     client_move(c, x, y);
1227     grab_pointer(FALSE, OB_CURSOR_NONE);
1228
1229 }
1230
1231 void action_growtoedge(union ActionData *data)
1232 {
1233     int x, y, width, height, dest;
1234     ObClient *c = data->diraction.any.c;
1235     Rect *a;
1236
1237     if (!c)
1238         return;
1239     
1240     a = screen_area(c->desktop);
1241     x = c->frame->area.x;
1242     y = c->frame->area.y;
1243     width = c->frame->area.width;
1244     height = c->frame->area.height;
1245
1246     switch(data->diraction.direction) {
1247     case OB_DIRECTION_NORTH:
1248         dest = client_directional_edge_search(c, OB_DIRECTION_NORTH);
1249         if (a->y == y)
1250             height = c->frame->area.height / 2;
1251         else {
1252             height = c->frame->area.y + c->frame->area.height - dest;
1253             y = dest;
1254         }
1255         break;
1256     case OB_DIRECTION_WEST:
1257         dest = client_directional_edge_search(c, OB_DIRECTION_WEST);
1258         if (a->x == x)
1259             width = c->frame->area.width / 2;
1260         else {
1261             width = c->frame->area.x + c->frame->area.width - dest;
1262             x = dest;
1263         }
1264         break;
1265     case OB_DIRECTION_SOUTH:
1266         dest = client_directional_edge_search(c, OB_DIRECTION_SOUTH);
1267         if (a->y + a->height == y + c->frame->area.height) {
1268             height = c->frame->area.height / 2;
1269             y = a->y + a->height - height;
1270         } else
1271             height = dest - c->frame->area.y;
1272         y += (height - c->frame->area.height) % c->size_inc.height;
1273         height -= (height - c->frame->area.height) % c->size_inc.height;
1274         break;
1275     case OB_DIRECTION_EAST:
1276         dest = client_directional_edge_search(c, OB_DIRECTION_EAST);
1277         if (a->x + a->width == x + c->frame->area.width) {
1278             width = c->frame->area.width / 2;
1279             x = a->x + a->width - width;
1280         } else
1281             width = dest - c->frame->area.x;
1282         x += (width - c->frame->area.width) % c->size_inc.width;
1283         width -= (width - c->frame->area.width) % c->size_inc.width;
1284         break;
1285     default:
1286         g_assert_not_reached();
1287     }
1288     frame_frame_gravity(c->frame, &x, &y);
1289     width -= c->frame->size.left + c->frame->size.right;
1290     height -= c->frame->size.top + c->frame->size.bottom;
1291     grab_pointer(TRUE, OB_CURSOR_NONE);
1292     client_move_resize(c, x, y, width, height);
1293     grab_pointer(FALSE, OB_CURSOR_NONE);
1294 }
1295
1296 void action_send_to_layer(union ActionData *data)
1297 {
1298     if (data->layer.any.c)
1299         client_set_layer(data->layer.any.c, data->layer.layer);
1300 }
1301
1302 void action_toggle_layer(union ActionData *data)
1303 {
1304     ObClient *c = data->layer.any.c;
1305
1306     if (c) {
1307         if (data->layer.layer < 0)
1308             client_set_layer(c, c->below ? 0 : -1);
1309         else if (data->layer.layer > 0)
1310             client_set_layer(c, c->above ? 0 : 1);
1311     }
1312 }
1313
1314 void action_toggle_show_desktop(union ActionData *data)
1315 {
1316     screen_show_desktop(!screen_showing_desktop);
1317 }
1318
1319 void action_show_desktop(union ActionData *data)
1320 {
1321     screen_show_desktop(TRUE);
1322 }
1323
1324 void action_unshow_desktop(union ActionData *data)
1325 {
1326     screen_show_desktop(FALSE);
1327 }