Dogcows Code - chaz/openbox/blob - 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_top_layer(ObAction *a)
 236 {
 237     a->data.layer.layer = 1;
 238 }
 239
 240 void setup_action_normal_layer(ObAction *a)
 241 {
 242     a->data.layer.layer = 0;
 243 }
 244
 245 void setup_action_bottom_layer(ObAction *a)
 246 {
 247     a->data.layer.layer = -1;
 248 }
 249
 250 ActionString actionstrings[] =
 251 {
 252     {
 253         "execute",
 254         action_execute,
 255         NULL
 256     },
 257     {
 258         "directionalfocusnorth",
 259         action_directional_focus,
 260         setup_action_directional_focus_north
 261     },
 262     {
 263         "directionalfocuseast",
 264         action_directional_focus,
 265         setup_action_directional_focus_east
 266     },
 267     {
 268         "directionalfocussouth",
 269         action_directional_focus,
 270         setup_action_directional_focus_south
 271     },
 272     {
 273         "directionalfocuswest",
 274         action_directional_focus,
 275         setup_action_directional_focus_west
 276     },
 277     {
 278         "directionalfocusnortheast",
 279         action_directional_focus,
 280         setup_action_directional_focus_northeast
 281     },
 282     {
 283         "directionalfocussoutheast",
 284         action_directional_focus,
 285         setup_action_directional_focus_southeast
 286     },
 287     {
 288         "directionalfocussouthwest",
 289         action_directional_focus,
 290         setup_action_directional_focus_southwest
 291     },
 292     {
 293         "directionalfocusnorthwest",
 294         action_directional_focus,
 295         setup_action_directional_focus_northwest
 296     },
 297     {
 298         "focus",
 299         action_focus,
 300         NULL,
 301     },
 302     {
 303         "unfocus",
 304         action_unfocus,
 305         NULL
 306     },
 307     {
 308         "iconify",
 309         action_iconify,
 310         NULL
 311     },
 312     {
 313         "raise",
 314         action_raise,
 315         NULL
 316     },
 317     {
 318         "lower",
 319         action_lower,
 320         NULL
 321     },
 322     {
 323         "close",
 324         action_close,
 325         NULL
 326     },
 327     {
 328         "kill",
 329         action_kill,
 330         NULL
 331     },
 332     {
 333         "shadelower",
 334         action_shadelower,
 335         NULL
 336     },
 337     {
 338         "unshaderaise",
 339         action_unshaderaise,
 340         NULL
 341     },
 342     {
 343         "shade",
 344         action_shade,
 345         NULL
 346     },
 347     {
 348         "unshade",
 349         action_unshade,
 350         NULL
 351     },
 352     {
 353         "toggleshade",
 354         action_toggle_shade,
 355         NULL
 356     },
 357     {
 358         "toggleomnipresent",
 359         action_toggle_omnipresent,
 360         NULL
 361     },
 362     {
 363         "moverelativehorz",
 364         action_move_relative_horz,
 365         NULL
 366     },
 367     {
 368         "moverelativevert",
 369         action_move_relative_vert,
 370         NULL
 371     },
 372     {
 373         "resizerelativehorz",
 374         action_resize_relative_horz,
 375         NULL
 376     },
 377     {
 378         "resizerelativevert",
 379         action_resize_relative_vert,
 380         NULL
 381     },
 382     {
 383         "maximizefull",
 384         action_maximize_full,
 385         NULL
 386     },
 387     {
 388         "unmaximizefull",
 389         action_unmaximize_full,
 390         NULL
 391     },
 392     {
 393         "togglemaximizefull",
 394         action_toggle_maximize_full,
 395         NULL
 396     },
 397     {
 398         "maximizehorz",
 399         action_maximize_horz,
 400         NULL
 401     },
 402     {
 403         "unmaximizehorz",
 404         action_unmaximize_horz,
 405         NULL
 406     },
 407     {
 408         "togglemaximizehorz",
 409         action_toggle_maximize_horz,
 410         NULL
 411     },
 412     {
 413         "maximizevert",
 414         action_maximize_vert,
 415         NULL
 416     },
 417     {
 418         "unmaximizevert",
 419         action_unmaximize_vert,
 420         NULL
 421     },
 422     {
 423         "togglemaximizevert",
 424         action_toggle_maximize_vert,
 425         NULL
 426     },
 427     {
 428         "sendtodesktop",
 429         action_send_to_desktop,
 430         setup_action_send_to_desktop
 431     },
 432     {
 433         "sendtodesktopnext",
 434         action_send_to_desktop_dir,
 435         setup_action_send_to_desktop_next
 436     },
 437     {
 438         "sendtodesktopprevious",
 439         action_send_to_desktop_dir,
 440         setup_action_send_to_desktop_prev
 441     },
 442     {
 443         "sendtodesktopright",
 444         action_send_to_desktop_dir,
 445         setup_action_send_to_desktop_right
 446     },
 447     {
 448         "sendtodesktopleft",
 449         action_send_to_desktop_dir,
 450         setup_action_send_to_desktop_left
 451     },
 452     {
 453         "sendtodesktopup",
 454         action_send_to_desktop_dir,
 455         setup_action_send_to_desktop_up
 456     },
 457     {
 458         "sendtodesktopdown",
 459         action_send_to_desktop_dir,
 460         setup_action_send_to_desktop_down
 461     },
 462     {
 463         "desktop",
 464         action_desktop,
 465         NULL
 466     },
 467     {
 468         "desktopnext",
 469         action_desktop_dir,
 470         setup_action_desktop_next
 471     },
 472     {
 473         "desktopprevious",
 474         action_desktop_dir,
 475         setup_action_desktop_prev
 476     },
 477     {
 478         "desktopright",
 479         action_desktop_dir,
 480         setup_action_desktop_right
 481     },
 482     {
 483         "desktopleft",
 484         action_desktop_dir,
 485         setup_action_desktop_left
 486     },
 487     {
 488         "desktopup",
 489         action_desktop_dir,
 490         setup_action_desktop_up
 491     },
 492     {
 493         "desktopdown",
 494         action_desktop_dir,
 495         setup_action_desktop_down
 496     },
 497     {
 498         "toggledecorations",
 499         action_toggle_decorations,
 500         NULL
 501     },
 502     {
 503         "keyboardmove",
 504         action_moveresize,
 505         setup_action_move_keyboard
 506     },
 507     {
 508         "move",
 509         action_moveresize,
 510         setup_action_move
 511     },
 512     {
 513         "resize",
 514         action_moveresize,
 515         setup_action_resize
 516     },
 517     {
 518         "keyboardresize",
 519         action_moveresize,
 520         setup_action_resize_keyboard
 521     },
 522     {
 523         "toggleshowdesktop",
 524         action_toggle_show_desktop,
 525         NULL
 526     },
 527     {
 528         "showdesktop",
 529         action_show_desktop,
 530         NULL
 531     },
 532     {
 533         "unshowdesktop",
 534         action_unshow_desktop,
 535         NULL
 536     },
 537     {
 538         "restart",
 539         action_restart,
 540         NULL
 541     },
 542     {
 543         "exit",
 544         action_exit,
 545         NULL
 546     },
 547     {
 548         "showmenu",
 549         action_showmenu,
 550         NULL
 551     },
 552     {
 553         "sendtotoplayer",
 554         action_send_to_layer,
 555         setup_action_top_layer
 556     },
 557     {
 558         "togglealwaysontop",
 559         action_toggle_layer,
 560         setup_action_top_layer
 561     },
 562     {
 563         "sendtonormallayer",
 564         action_send_to_layer,
 565         setup_action_normal_layer
 566     },
 567     {
 568         "sendtobottomlayer",
 569         action_send_to_layer,
 570         setup_action_bottom_layer
 571     },
 572     {
 573         "togglealwaysonbottom",
 574         action_toggle_layer,
 575         setup_action_bottom_layer
 576     },
 577     {
 578         "nextwindowlinear",
 579         action_cycle_windows,
 580         setup_action_cycle_windows_linear_next
 581     },
 582     {
 583         "previouswindowlinear",
 584         action_cycle_windows,
 585         setup_action_cycle_windows_linear_previous
 586     },
 587     {
 588         "nextwindow",
 589         action_cycle_windows,
 590         setup_action_cycle_windows_next
 591     },
 592     {
 593         "previouswindow",
 594         action_cycle_windows,
 595         setup_action_cycle_windows_previous
 596     },
 597     {
 598         "movetoedgenorth",
 599         action_movetoedge,
 600         setup_action_movetoedge_north
 601     },
 602     {
 603         "movetoedgesouth",
 604         action_movetoedge,
 605         setup_action_movetoedge_south
 606     },
 607     {
 608         "movetoedgewest",
 609         action_movetoedge,
 610         setup_action_movetoedge_west
 611     },
 612     {
 613         "movetoedgeeast",
 614         action_movetoedge,
 615         setup_action_movetoedge_east
 616     },
 617     {
 618         NULL,
 619         NULL,
 620         NULL
 621     }
 622 };
 623
 624 ObAction *action_from_string(char *name)
 625 {
 626     ObAction *a = NULL;
 627     int i;
 628
 629     for (i = 0; actionstrings[i].name; i++)
 630         if (!g_ascii_strcasecmp(name, actionstrings[i].name)) {
 631             a = action_new(actionstrings[i].func);
 632             if (actionstrings[i].setup)
 633                 actionstrings[i].setup(a);
 634             break;
 635         }
 636     return a;
 637 }
 638
 639 ObAction *action_parse(xmlDocPtr doc, xmlNodePtr node)
 640 {
 641     char *actname;
 642     ObAction *act = NULL;
 643     xmlNodePtr n;
 644
 645     if (parse_attr_string("name", node, &actname)) {
 646         if ((act = action_from_string(actname))) {
 647             if (act->func == action_execute || act->func == action_restart) {
 648                 if ((n = parse_find_node("execute", node->xmlChildrenNode)))
 649                     act->data.execute.path = parse_string(doc, n);
 650             } else if (act->func == action_showmenu) {
 651                 if ((n = parse_find_node("menu", node->xmlChildrenNode)))
 652                     act->data.showmenu.name = parse_string(doc, n);
 653             } else if (act->func == action_desktop) {
 654                 if ((n = parse_find_node("desktop", node->xmlChildrenNode)))
 655                     act->data.desktop.desk = parse_int(doc, n);
 656                 if (act->data.desktop.desk > 0) act->data.desktop.desk--;
 657             } else if (act->func == action_send_to_desktop) {
 658                 if ((n = parse_find_node("desktop", node->xmlChildrenNode)))
 659                     act->data.sendto.desk = parse_int(doc, n);
 660                 if (act->data.sendto.desk > 0) act->data.sendto.desk--;
 661             } else if (act->func == action_move_relative_horz ||
 662                        act->func == action_move_relative_vert ||
 663                        act->func == action_resize_relative_horz ||
 664                        act->func == action_resize_relative_vert) {
 665                 if ((n = parse_find_node("delta", node->xmlChildrenNode)))
 666                     act->data.relative.delta = parse_int(doc, n);
 667             } else if (act->func == action_desktop_dir) {
 668                 if ((n = parse_find_node("wrap", node->xmlChildrenNode))) {
 669                     act->data.desktopdir.wrap = parse_bool(doc, n);
 670                 }
 671             } else if (act->func == action_send_to_desktop_dir) {
 672                 if ((n = parse_find_node("wrap", node->xmlChildrenNode)))
 673                     act->data.sendtodir.wrap = parse_bool(doc, n);
 674             }
 675         }
 676         g_free(actname);
 677     }
 678     return act;
 679 }
 680
 681 void action_execute(union ActionData *data)
 682 {
 683     GError *e = NULL;
 684     char *cmd;
 685     if (data->execute.path) {
 686         cmd = g_filename_from_utf8(data->execute.path, -1, NULL, NULL, NULL);
 687         if (cmd) {
 688             if (!g_spawn_command_line_async(cmd, &e)) {
 689                 g_warning("failed to execute '%s': %s",
 690                           cmd, e->message);
 691             }
 692         } else {
 693             g_warning("failed to convert '%s' from utf8", data->execute.path);
 694         }
 695     }
 696 }
 697
 698 void action_focus(union ActionData *data)
 699 {
 700     if (data->client.c)
 701         client_focus(data->client.c);
 702 }
 703
 704 void action_unfocus (union ActionData *data)
 705 {
 706     if (data->client.c)
 707         client_unfocus(data->client.c);
 708 }
 709
 710 void action_iconify(union ActionData *data)
 711 {
 712     if (data->client.c)
 713         client_iconify(data->client.c, TRUE, TRUE);
 714 }
 715
 716 void action_raise(union ActionData *data)
 717 {
 718     if (data->client.c)
 719         stacking_raise(CLIENT_AS_WINDOW(data->client.c));
 720 }
 721
 722 void action_unshaderaise(union ActionData *data)
 723 {
 724     if (data->client.c) {
 725         if (data->client.c->shaded)
 726             client_shade(data->client.c, FALSE);
 727         else
 728             stacking_raise(CLIENT_AS_WINDOW(data->client.c));
 729     }
 730 }
 731
 732 void action_shadelower(union ActionData *data)
 733 {
 734     if (data->client.c) {
 735         if (data->client.c->shaded)
 736             stacking_lower(CLIENT_AS_WINDOW(data->client.c));
 737         else
 738             client_shade(data->client.c, TRUE);
 739     }
 740 }
 741
 742 void action_lower(union ActionData *data)
 743 {
 744     if (data->client.c)
 745         stacking_lower(CLIENT_AS_WINDOW(data->client.c));
 746 }
 747
 748 void action_close(union ActionData *data)
 749 {
 750     if (data->client.c)
 751         client_close(data->client.c);
 752 }
 753
 754 void action_kill(union ActionData *data)
 755 {
 756     if (data->client.c)
 757         client_kill(data->client.c);
 758 }
 759
 760 void action_shade(union ActionData *data)
 761 {
 762     if (data->client.c)
 763         client_shade(data->client.c, TRUE);
 764 }
 765
 766 void action_unshade(union ActionData *data)
 767 {
 768     if (data->client.c)
 769         client_shade(data->client.c, FALSE);
 770 }
 771
 772 void action_toggle_shade(union ActionData *data)
 773 {
 774     if (data->client.c)
 775         client_shade(data->client.c, !data->client.c->shaded);
 776 }
 777
 778 void action_toggle_omnipresent(union ActionData *data)
 779 {
 780     if (data->client.c)
 781         client_set_desktop(data->client.c,
 782                            data->client.c->desktop == DESKTOP_ALL ?
 783                            screen_desktop : DESKTOP_ALL, FALSE);
 784 }
 785
 786 void action_move_relative_horz(union ActionData *data)
 787 {
 788     ObClient *c = data->relative.c;
 789     if (c)
 790         client_configure(c, OB_CORNER_TOPLEFT,
 791                          c->area.x + data->relative.delta, c->area.y,
 792                          c->area.width, c->area.height, TRUE, TRUE);
 793 }
 794
 795 void action_move_relative_vert(union ActionData *data)
 796 {
 797     ObClient *c = data->relative.c;
 798     if (c)
 799         client_configure(c, OB_CORNER_TOPLEFT,
 800                          c->area.x, c->area.y + data->relative.delta,
 801                          c->area.width, c->area.height, TRUE, TRUE);
 802 }
 803
 804 void action_resize_relative_horz(union ActionData *data)
 805 {
 806     ObClient *c = data->relative.c;
 807     if (c)
 808         client_configure(c, OB_CORNER_TOPLEFT, c->area.x, c->area.y,
 809                          c->area.width +
 810                          data->relative.delta * c->size_inc.width,
 811                          c->area.height, TRUE, TRUE);
 812 }
 813
 814 void action_resize_relative_vert(union ActionData *data)
 815 {
 816     ObClient *c = data->relative.c;
 817     if (c && !c->shaded)
 818         client_configure(c, OB_CORNER_TOPLEFT, c->area.x, c->area.y,
 819                          c->area.width, c->area.height +
 820                          data->relative.delta * c->size_inc.height,
 821                          TRUE, TRUE);
 822 }
 823
 824 void action_maximize_full(union ActionData *data)
 825 {
 826     if (data->client.c)
 827         client_maximize(data->client.c, TRUE, 0, TRUE);
 828 }
 829
 830 void action_unmaximize_full(union ActionData *data)
 831 {
 832     if (data->client.c)
 833         client_maximize(data->client.c, FALSE, 0, TRUE);
 834 }
 835
 836 void action_toggle_maximize_full(union ActionData *data)
 837 {
 838     if (data->client.c)
 839         client_maximize(data->client.c,
 840                         !(data->client.c->max_horz ||
 841                           data->client.c->max_vert),
 842                         0, TRUE);
 843 }
 844
 845 void action_maximize_horz(union ActionData *data)
 846 {
 847     if (data->client.c)
 848         client_maximize(data->client.c, TRUE, 1, TRUE);
 849 }
 850
 851 void action_unmaximize_horz(union ActionData *data)
 852 {
 853     if (data->client.c)
 854         client_maximize(data->client.c, FALSE, 1, TRUE);
 855 }
 856
 857 void action_toggle_maximize_horz(union ActionData *data)
 858 {
 859     if (data->client.c)
 860         client_maximize(data->client.c, !data->client.c->max_horz, 1, TRUE);
 861 }
 862
 863 void action_maximize_vert(union ActionData *data)
 864 {
 865     if (data->client.c)
 866         client_maximize(data->client.c, TRUE, 2, TRUE);
 867 }
 868
 869 void action_unmaximize_vert(union ActionData *data)
 870 {
 871     if (data->client.c)
 872         client_maximize(data->client.c, FALSE, 2, TRUE);
 873 }
 874
 875 void action_toggle_maximize_vert(union ActionData *data)
 876 {
 877     if (data->client.c)
 878         client_maximize(data->client.c, !data->client.c->max_vert, 2, TRUE);
 879 }
 880
 881 void action_send_to_desktop(union ActionData *data)
 882 {
 883     ObClient *c = data->sendto.c;
 884
 885     if (!c || !client_normal(c)) return;
 886
 887     if (data->sendto.desk < screen_num_desktops ||
 888         data->sendto.desk == DESKTOP_ALL) {
 889         client_set_desktop(c, data->sendto.desk, TRUE);
 890         screen_set_desktop(data->sendto.desk);
 891     }
 892 }
 893
 894 void action_desktop(union ActionData *data)
 895 {
 896     if (data->desktop.desk < screen_num_desktops ||
 897         data->desktop.desk == DESKTOP_ALL)
 898         screen_set_desktop(data->desktop.desk);
 899 }
 900
 901 void action_desktop_dir(union ActionData *data)
 902 {
 903     guint d;
 904
 905     d = screen_cycle_desktop(data->desktopdir.dir, data->desktopdir.wrap,
 906                              data->sendtodir.linear,
 907                              data->desktopdir.final, data->desktopdir.cancel);
 908     screen_set_desktop(d);
 909 }
 910
 911 void action_send_to_desktop_dir(union ActionData *data)
 912 {
 913     ObClient *c = data->sendtodir.c;
 914     guint d;
 915
 916     if (!c || !client_normal(c)) return;
 917
 918     d = screen_cycle_desktop(data->sendtodir.dir, data->sendtodir.wrap,
 919                              data->sendtodir.linear,
 920                              data->sendtodir.final, data->sendtodir.cancel);
 921     client_set_desktop(c, d, TRUE);
 922     screen_set_desktop(d);
 923 }
 924
 925 #if 0
 926 void action_desktop_right(union ActionData *data)
 927 {
 928     guint r, c, d;
 929
 930     cur_row_col(&r, &c);
 931     ++c;
 932     if (c >= screen_desktop_layout.columns) {
 933         if (!data->desktopdir.wrap) return;
 934         c = 0;
 935     }
 936     d = translate_row_col(r, c);
 937     if (d >= screen_num_desktops) {
 938         if (!data->desktopdir.wrap) return;
 939         ++c;
 940     }
 941     d = translate_row_col(r, c);
 942     if (d < screen_num_desktops)
 943         screen_cycle_desktop(d, data->desktopdir.final,
 944                              data->desktopdir.cancel);
 945 }
 946
 947 void action_send_to_desktop_right(union ActionData *data)
 948 {
 949     ObClient *cl = data->sendto.c;
 950     guint r, c, d;
 951
 952     if (!cl || !client_normal(cl)) return;
 953
 954     cur_row_col(&r, &c);
 955     ++c;
 956     if (c >= screen_desktop_layout.columns) {
 957         if (!data->sendtodir.wrap) return;
 958         c = 0;
 959     }
 960     d = translate_row_col(r, c);
 961     if (d >= screen_num_desktops) {
 962         if (!data->sendtodir.wrap) return;
 963         ++c;
 964     }
 965     d = translate_row_col(r, c);
 966     if (d < screen_num_desktops) {
 967         client_set_desktop(cl, d, data->sendtodir.follow);
 968         if (data->sendtodir.follow)
 969             screen_cycle_desktop(d, data->desktopdir.final,
 970                                  data->desktopdir.cancel);
 971     }
 972 }
 973
 974 void action_desktop_left(union ActionData *data)
 975 {
 976     guint r, c, d;
 977
 978     cur_row_col(&r, &c);
 979     --c;
 980     if (c >= screen_desktop_layout.columns) {
 981         if (!data->desktopdir.wrap) return;
 982         c = screen_desktop_layout.columns - 1;
 983     }
 984     d = translate_row_col(r, c);
 985     if (d >= screen_num_desktops) {
 986         if (!data->desktopdir.wrap) return;
 987         --c;
 988     }
 989     d = translate_row_col(r, c);
 990     if (d < screen_num_desktops)
 991         screen_cycle_desktop(d, data->desktopdir.final,
 992                              data->desktopdir.cancel);
 993 }
 994
 995 void action_send_to_desktop_left(union ActionData *data)
 996 {
 997     ObClient *cl = data->sendto.c;
 998     guint r, c, d;
 999
1000     if (!cl || !client_normal(cl)) return;
1001
1002     cur_row_col(&r, &c);
1003     --c;
1004     if (c >= screen_desktop_layout.columns) {
1005         if (!data->sendtodir.wrap) return;
1006         c = screen_desktop_layout.columns - 1;
1007     }
1008     d = translate_row_col(r, c);
1009     if (d >= screen_num_desktops) {
1010         if (!data->sendtodir.wrap) return;
1011         --c;
1012     }
1013     d = translate_row_col(r, c);
1014     if (d < screen_num_desktops) {
1015         client_set_desktop(cl, d, data->sendtodir.follow);
1016         if (data->sendtodir.follow)
1017             screen_cycle_desktop(d, data->desktopdir.final,
1018                                  data->desktopdir.cancel);
1019     }
1020 }
1021
1022 void action_desktop_down(union ActionData *data)
1023 {
1024     guint r, c, d;
1025
1026     cur_row_col(&r, &c);
1027     ++r;
1028     if (r >= screen_desktop_layout.rows) {
1029         if (!data->desktopdir.wrap) return;
1030         r = 0;
1031     }
1032     d = translate_row_col(r, c);
1033     if (d >= screen_num_desktops) {
1034         if (!data->desktopdir.wrap) return;
1035         ++r;
1036     }
1037     d = translate_row_col(r, c);
1038     if (d < screen_num_desktops)
1039         screen_cycle_desktop(d, data->desktopdir.final,
1040                              data->desktopdir.cancel);
1041 }
1042
1043 void action_send_to_desktop_down(union ActionData *data)
1044 {
1045     guint r, c, d;
1046
1047     if (data->sendtodir.c) {
1048         cur_row_col(&r, &c);
1049         ++r;
1050         if (r >= screen_desktop_layout.rows) {
1051             if (!data->sendtodir.wrap) return;
1052             r = 0;
1053         }
1054         d = translate_row_col(r, c);
1055         if (d >= screen_num_desktops) {
1056             if (!data->sendtodir.wrap) return;
1057             ++r;
1058         }
1059         d = translate_row_col(r, c);
1060         if (d < screen_num_desktops) {
1061             client_set_desktop(data->sendtodir.c, d, data->sendtodir.follow);
1062             if (data->sendtodir.follow)
1063                 screen_cycle_desktop(d, data->desktopdir.final,
1064                                      data->desktopdir.cancel);
1065         }
1066     }
1067 }
1068
1069 void action_desktop_up(union ActionData *data)
1070 {
1071     guint r, c, d;
1072
1073     cur_row_col(&r, &c);
1074     --r;
1075     if (r >= screen_desktop_layout.rows) {
1076         if (!data->desktopdir.wrap) return;
1077         r = screen_desktop_layout.rows - 1;
1078     }
1079     d = translate_row_col(r, c);
1080     if (d >= screen_num_desktops) {
1081         if (!data->desktopdir.wrap) return;
1082         --r;
1083     }
1084     d = translate_row_col(r, c);
1085     if (d < screen_num_desktops)
1086         screen_cycle_desktop(d, data->desktopdir.final,
1087                              data->desktopdir.cancel);
1088 }
1089
1090 void action_send_to_desktop_up(union ActionData *data)
1091 {
1092     guint r, c, d;
1093
1094     if (data->sendtodir.c) {
1095         cur_row_col(&r, &c);
1096         --r;
1097         if (r >= screen_desktop_layout.rows) {
1098             if (!data->sendtodir.wrap) return;
1099             r = screen_desktop_layout.rows - 1;
1100         }
1101         d = translate_row_col(r, c);
1102         if (d >= screen_num_desktops) {
1103             if (!data->sendtodir.wrap) return;
1104             --r;
1105         }
1106         d = translate_row_col(r, c);
1107         if (d < screen_num_desktops) {
1108             client_set_desktop(data->sendtodir.c, d, data->sendtodir.follow);
1109             if (data->sendtodir.follow)
1110                 screen_cycle_desktop(d, data->desktopdir.final,
1111                                      data->desktopdir.cancel);
1112         }
1113     }
1114 }
1115 #endif
1116
1117 void action_toggle_decorations(union ActionData *data)
1118 {
1119     ObClient *c = data->client.c;;
1120
1121     if (!c) return;
1122
1123     c->decorate = !c->decorate;
1124     client_setup_decor_and_functions(c);
1125 }
1126
1127 void action_moveresize(union ActionData *data)
1128 {
1129     ObClient *c = data->moveresize.c;
1130
1131     if (!c || !client_normal(c)) return;
1132
1133     moveresize_start(c, data->moveresize.x, data->moveresize.y,
1134                      data->moveresize.button, data->moveresize.corner);
1135 }
1136
1137 void action_restart(union ActionData *data)
1138 {
1139     ob_restart_other(data->execute.path);
1140 }
1141
1142 void action_exit(union ActionData *data)
1143 {
1144     ob_exit();
1145 }
1146
1147 void action_showmenu(union ActionData *data)
1148 {
1149     if (data->showmenu.name) {
1150         menu_show(data->showmenu.name, data->showmenu.x, data->showmenu.y,
1151                   data->showmenu.c);
1152     }
1153 }
1154
1155 void action_cycle_windows(union ActionData *data)
1156 {
1157     ObClient *c;
1158
1159     c = focus_cycle(data->cycle.forward, data->cycle.linear, data->cycle.final,
1160                     data->cycle.cancel);
1161 }
1162
1163 void action_directional_focus(union ActionData *data)
1164 {
1165     ObClient *nf;
1166
1167     if (!data->diraction.c)
1168         return;
1169     if ((nf = client_find_directional(data->diraction.c,
1170                                       data->diraction.direction)))
1171         client_activate(nf);
1172 }
1173
1174 void action_movetoedge(union ActionData *data)
1175 {
1176     int x, y, h, w;
1177     ObClient *c = data->diraction.c;
1178
1179     if (!c)
1180         return;
1181     x = c->frame->area.x;
1182     y = c->frame->area.y;
1183
1184     h = screen_area(c->desktop)->height;
1185     w = screen_area(c->desktop)->width;
1186     switch(data->diraction.direction) {
1187     case OB_DIRECTION_NORTH:
1188         y = 0;
1189         break;
1190     case OB_DIRECTION_WEST:
1191         x = 0;
1192         break;
1193     case OB_DIRECTION_SOUTH:
1194         y = h - c->frame->area.height;
1195         break;
1196     case OB_DIRECTION_EAST:
1197         x = w - c->frame->area.width;
1198         break;
1199     default:
1200         g_assert_not_reached();
1201     }
1202     frame_frame_gravity(c->frame, &x, &y);
1203     client_configure(c, OB_CORNER_TOPLEFT,
1204                      x, y, c->area.width, c->area.height, TRUE, TRUE);
1205
1206 }
1207
1208 void action_send_to_layer(union ActionData *data)
1209 {
1210     if (data->layer.c)
1211         client_set_layer(data->layer.c, data->layer.layer);
1212 }
1213
1214 void action_toggle_layer(union ActionData *data)
1215 {
1216     ObClient *c = data->layer.c;
1217
1218     if (c) {
1219         if (data->layer.layer < 0)
1220             client_set_layer(c, c->below ? 0 : -1);
1221         else if (data->layer.layer > 0)
1222             client_set_layer(c, c->above ? 0 : 1);
1223     }
1224 }
1225
1226 void action_toggle_show_desktop(union ActionData *data)
1227 {
1228     screen_show_desktop(!screen_showing_desktop);
1229 }
1230
1231 void action_show_desktop(union ActionData *data)
1232 {
1233     screen_show_desktop(TRUE);
1234 }
1235
1236 void action_unshow_desktop(union ActionData *data)
1237 {
1238     screen_show_desktop(FALSE);
1239 }