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