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         "raiselower",
 339         action_raiselower,
 340         NULL
 341     },
 342     {
 343         "raise",
 344         action_raise,
 345         NULL
 346     },
 347     {
 348         "lower",
 349         action_lower,
 350         NULL
 351     },
 352     {
 353         "close",
 354         action_close,
 355         NULL
 356     },
 357     {
 358         "kill",
 359         action_kill,
 360         NULL
 361     },
 362     {
 363         "shadelower",
 364         action_shadelower,
 365         NULL
 366     },
 367     {
 368         "unshaderaise",
 369         action_unshaderaise,
 370         NULL
 371     },
 372     {
 373         "shade",
 374         action_shade,
 375         NULL
 376     },
 377     {
 378         "unshade",
 379         action_unshade,
 380         NULL
 381     },
 382     {
 383         "toggleshade",
 384         action_toggle_shade,
 385         NULL
 386     },
 387     {
 388         "toggleomnipresent",
 389         action_toggle_omnipresent,
 390         NULL
 391     },
 392     {
 393         "moverelativehorz",
 394         action_move_relative_horz,
 395         NULL
 396     },
 397     {
 398         "moverelativevert",
 399         action_move_relative_vert,
 400         NULL
 401     },
 402     {
 403         "resizerelativehorz",
 404         action_resize_relative_horz,
 405         NULL
 406     },
 407     {
 408         "resizerelativevert",
 409         action_resize_relative_vert,
 410         NULL
 411     },
 412     {
 413         "maximizefull",
 414         action_maximize_full,
 415         NULL
 416     },
 417     {
 418         "unmaximizefull",
 419         action_unmaximize_full,
 420         NULL
 421     },
 422     {
 423         "togglemaximizefull",
 424         action_toggle_maximize_full,
 425         NULL
 426     },
 427     {
 428         "maximizehorz",
 429         action_maximize_horz,
 430         NULL
 431     },
 432     {
 433         "unmaximizehorz",
 434         action_unmaximize_horz,
 435         NULL
 436     },
 437     {
 438         "togglemaximizehorz",
 439         action_toggle_maximize_horz,
 440         NULL
 441     },
 442     {
 443         "maximizevert",
 444         action_maximize_vert,
 445         NULL
 446     },
 447     {
 448         "unmaximizevert",
 449         action_unmaximize_vert,
 450         NULL
 451     },
 452     {
 453         "togglemaximizevert",
 454         action_toggle_maximize_vert,
 455         NULL
 456     },
 457     {
 458         "sendtodesktop",
 459         action_send_to_desktop,
 460         setup_action_send_to_desktop
 461     },
 462     {
 463         "sendtodesktopnext",
 464         action_send_to_desktop_dir,
 465         setup_action_send_to_desktop_next
 466     },
 467     {
 468         "sendtodesktopprevious",
 469         action_send_to_desktop_dir,
 470         setup_action_send_to_desktop_prev
 471     },
 472     {
 473         "sendtodesktopright",
 474         action_send_to_desktop_dir,
 475         setup_action_send_to_desktop_right
 476     },
 477     {
 478         "sendtodesktopleft",
 479         action_send_to_desktop_dir,
 480         setup_action_send_to_desktop_left
 481     },
 482     {
 483         "sendtodesktopup",
 484         action_send_to_desktop_dir,
 485         setup_action_send_to_desktop_up
 486     },
 487     {
 488         "sendtodesktopdown",
 489         action_send_to_desktop_dir,
 490         setup_action_send_to_desktop_down
 491     },
 492     {
 493         "desktop",
 494         action_desktop,
 495         NULL
 496     },
 497     {
 498         "desktopnext",
 499         action_desktop_dir,
 500         setup_action_desktop_next
 501     },
 502     {
 503         "desktopprevious",
 504         action_desktop_dir,
 505         setup_action_desktop_prev
 506     },
 507     {
 508         "desktopright",
 509         action_desktop_dir,
 510         setup_action_desktop_right
 511     },
 512     {
 513         "desktopleft",
 514         action_desktop_dir,
 515         setup_action_desktop_left
 516     },
 517     {
 518         "desktopup",
 519         action_desktop_dir,
 520         setup_action_desktop_up
 521     },
 522     {
 523         "desktopdown",
 524         action_desktop_dir,
 525         setup_action_desktop_down
 526     },
 527     {
 528         "toggledecorations",
 529         action_toggle_decorations,
 530         NULL
 531     },
 532     {
 533         "keyboardmove",
 534         action_moveresize,
 535         setup_action_move_keyboard
 536     },
 537     {
 538         "move",
 539         action_moveresize,
 540         setup_action_move
 541     },
 542     {
 543         "resize",
 544         action_moveresize,
 545         setup_action_resize
 546     },
 547     {
 548         "keyboardresize",
 549         action_moveresize,
 550         setup_action_resize_keyboard
 551     },
 552     {
 553         "toggleshowdesktop",
 554         action_toggle_show_desktop,
 555         NULL
 556     },
 557     {
 558         "showdesktop",
 559         action_show_desktop,
 560         NULL
 561     },
 562     {
 563         "unshowdesktop",
 564         action_unshow_desktop,
 565         NULL
 566     },
 567     {
 568         "restart",
 569         action_restart,
 570         NULL
 571     },
 572     {
 573         "exit",
 574         action_exit,
 575         NULL
 576     },
 577     {
 578         "showmenu",
 579         action_showmenu,
 580         NULL
 581     },
 582     {
 583         "sendtotoplayer",
 584         action_send_to_layer,
 585         setup_action_top_layer
 586     },
 587     {
 588         "togglealwaysontop",
 589         action_toggle_layer,
 590         setup_action_top_layer
 591     },
 592     {
 593         "sendtonormallayer",
 594         action_send_to_layer,
 595         setup_action_normal_layer
 596     },
 597     {
 598         "sendtobottomlayer",
 599         action_send_to_layer,
 600         setup_action_bottom_layer
 601     },
 602     {
 603         "togglealwaysonbottom",
 604         action_toggle_layer,
 605         setup_action_bottom_layer
 606     },
 607     {
 608         "nextwindowlinear",
 609         action_cycle_windows,
 610         setup_action_cycle_windows_linear_next
 611     },
 612     {
 613         "previouswindowlinear",
 614         action_cycle_windows,
 615         setup_action_cycle_windows_linear_previous
 616     },
 617     {
 618         "nextwindow",
 619         action_cycle_windows,
 620         setup_action_cycle_windows_next
 621     },
 622     {
 623         "previouswindow",
 624         action_cycle_windows,
 625         setup_action_cycle_windows_previous
 626     },
 627     {
 628         "movetoedgenorth",
 629         action_movetoedge,
 630         setup_action_movetoedge_north
 631     },
 632     {
 633         "movetoedgesouth",
 634         action_movetoedge,
 635         setup_action_movetoedge_south
 636     },
 637     {
 638         "movetoedgewest",
 639         action_movetoedge,
 640         setup_action_movetoedge_west
 641     },
 642     {
 643         "movetoedgeeast",
 644         action_movetoedge,
 645         setup_action_movetoedge_east
 646     },
 647     {
 648         "growtoedgenorth",
 649         action_growtoedge,
 650         setup_action_growtoedge_north
 651     },
 652     {
 653         "growtoedgesouth",
 654         action_growtoedge,
 655         setup_action_growtoedge_south
 656     },
 657     {
 658         "growtoedgewest",
 659         action_growtoedge,
 660         setup_action_growtoedge_west
 661     },
 662     {
 663         "growtoedgeeast",
 664         action_growtoedge,
 665         setup_action_growtoedge_east
 666     },
 667     {
 668         NULL,
 669         NULL,
 670         NULL
 671     }
 672 };
 673
 674 ObAction *action_from_string(char *name)
 675 {
 676     ObAction *a = NULL;
 677     int i;
 678
 679     for (i = 0; actionstrings[i].name; i++)
 680         if (!g_ascii_strcasecmp(name, actionstrings[i].name)) {
 681             a = action_new(actionstrings[i].func);
 682             if (actionstrings[i].setup)
 683                 actionstrings[i].setup(a);
 684             break;
 685         }
 686     return a;
 687 }
 688
 689 ObAction *action_parse(xmlDocPtr doc, xmlNodePtr node)
 690 {
 691     char *actname;
 692     ObAction *act = NULL;
 693     xmlNodePtr n;
 694
 695     if (parse_attr_string("name", node, &actname)) {
 696         if ((act = action_from_string(actname))) {
 697             if (act->func == action_execute || act->func == action_restart) {
 698                 if ((n = parse_find_node("execute", node->xmlChildrenNode)))
 699                     act->data.execute.path = parse_string(doc, n);
 700             } else if (act->func == action_showmenu) {
 701                 if ((n = parse_find_node("menu", node->xmlChildrenNode)))
 702                     act->data.showmenu.name = parse_string(doc, n);
 703             } else if (act->func == action_desktop) {
 704                 if ((n = parse_find_node("desktop", node->xmlChildrenNode)))
 705                     act->data.desktop.desk = parse_int(doc, n);
 706                 if (act->data.desktop.desk > 0) act->data.desktop.desk--;
 707             } else if (act->func == action_send_to_desktop) {
 708                 if ((n = parse_find_node("desktop", node->xmlChildrenNode)))
 709                     act->data.sendto.desk = parse_int(doc, n);
 710                 if (act->data.sendto.desk > 0) act->data.sendto.desk--;
 711             } else if (act->func == action_move_relative_horz ||
 712                        act->func == action_move_relative_vert ||
 713                        act->func == action_resize_relative_horz ||
 714                        act->func == action_resize_relative_vert) {
 715                 if ((n = parse_find_node("delta", node->xmlChildrenNode)))
 716                     act->data.relative.delta = parse_int(doc, n);
 717             } else if (act->func == action_desktop_dir) {
 718                 if ((n = parse_find_node("wrap", node->xmlChildrenNode))) {
 719                     act->data.desktopdir.wrap = parse_bool(doc, n);
 720                 }
 721             } else if (act->func == action_send_to_desktop_dir) {
 722                 if ((n = parse_find_node("wrap", node->xmlChildrenNode)))
 723                     act->data.sendtodir.wrap = parse_bool(doc, n);
 724             } else if (act->func == action_activate) {
 725                 if ((n = parse_find_node("here", node->xmlChildrenNode)))
 726                     act->data.activate.here = parse_bool(doc, n);
 727             }
 728         }
 729         g_free(actname);
 730     }
 731     return act;
 732 }
 733
 734 void action_execute(union ActionData *data)
 735 {
 736     GError *e = NULL;
 737     char *cmd;
 738     if (data->execute.path) {
 739         cmd = g_filename_from_utf8(data->execute.path, -1, NULL, NULL, NULL);
 740         if (cmd) {
 741             if (!g_spawn_command_line_async(cmd, &e)) {
 742                 g_warning("failed to execute '%s': %s",
 743                           cmd, e->message);
 744             }
 745         } else {
 746             g_warning("failed to convert '%s' from utf8", data->execute.path);
 747         }
 748     }
 749 }
 750
 751 void action_activate(union ActionData *data)
 752 {
 753     if (data->activate.c)
 754         client_activate(data->activate.c, data->activate.here);
 755 }
 756
 757 void action_focus(union ActionData *data)
 758 {
 759     if (data->client.c)
 760         client_focus(data->client.c);
 761 }
 762
 763 void action_unfocus (union ActionData *data)
 764 {
 765     if (data->client.c)
 766         client_unfocus(data->client.c);
 767 }
 768
 769 void action_iconify(union ActionData *data)
 770 {
 771     if (data->client.c)
 772         client_iconify(data->client.c, TRUE, TRUE);
 773 }
 774
 775 void action_raiselower(union ActionData *data)
 776 {
 777     ObClient *c = data->client.c;
 778     GList *it;
 779     gboolean raise = FALSE;
 780
 781     if (!c) return;
 782
 783     for (it = stacking_list; it; it = g_list_next(it)) {
 784         ObClient *cit = it->data;
 785
 786         if (cit == c) break;
 787         if (client_normal(cit) == client_normal(c) &&
 788             cit->layer == c->layer &&
 789             cit->frame->visible)
 790         {
 791             if (RECT_INTERSECTS_RECT(cit->frame->area, c->frame->area)) {
 792                 raise = TRUE;
 793                 break;
 794             }
 795         }
 796     }
 797
 798     if (raise)
 799         stacking_raise(CLIENT_AS_WINDOW(c));
 800     else
 801         stacking_lower(CLIENT_AS_WINDOW(c));
 802 }
 803
 804 void action_raise(union ActionData *data)
 805 {
 806     if (data->client.c)
 807         stacking_raise(CLIENT_AS_WINDOW(data->client.c));
 808 }
 809
 810 void action_unshaderaise(union ActionData *data)
 811 {
 812     if (data->client.c) {
 813         if (data->client.c->shaded)
 814             client_shade(data->client.c, FALSE);
 815         else
 816             stacking_raise(CLIENT_AS_WINDOW(data->client.c));
 817     }
 818 }
 819
 820 void action_shadelower(union ActionData *data)
 821 {
 822     if (data->client.c) {
 823         if (data->client.c->shaded)
 824             stacking_lower(CLIENT_AS_WINDOW(data->client.c));
 825         else
 826             client_shade(data->client.c, TRUE);
 827     }
 828 }
 829
 830 void action_lower(union ActionData *data)
 831 {
 832     if (data->client.c)
 833         stacking_lower(CLIENT_AS_WINDOW(data->client.c));
 834 }
 835
 836 void action_close(union ActionData *data)
 837 {
 838     if (data->client.c)
 839         client_close(data->client.c);
 840 }
 841
 842 void action_kill(union ActionData *data)
 843 {
 844     if (data->client.c)
 845         client_kill(data->client.c);
 846 }
 847
 848 void action_shade(union ActionData *data)
 849 {
 850     if (data->client.c)
 851         client_shade(data->client.c, TRUE);
 852 }
 853
 854 void action_unshade(union ActionData *data)
 855 {
 856     if (data->client.c)
 857         client_shade(data->client.c, FALSE);
 858 }
 859
 860 void action_toggle_shade(union ActionData *data)
 861 {
 862     if (data->client.c)
 863         client_shade(data->client.c, !data->client.c->shaded);
 864 }
 865
 866 void action_toggle_omnipresent(union ActionData *data)
 867 {
 868     if (data->client.c)
 869         client_set_desktop(data->client.c,
 870                            data->client.c->desktop == DESKTOP_ALL ?
 871                            screen_desktop : DESKTOP_ALL, FALSE);
 872 }
 873
 874 void action_move_relative_horz(union ActionData *data)
 875 {
 876     ObClient *c = data->relative.c;
 877     if (c)
 878         client_configure(c, OB_CORNER_TOPLEFT,
 879                          c->area.x + data->relative.delta, c->area.y,
 880                          c->area.width, c->area.height, TRUE, TRUE);
 881 }
 882
 883 void action_move_relative_vert(union ActionData *data)
 884 {
 885     ObClient *c = data->relative.c;
 886     if (c)
 887         client_configure(c, OB_CORNER_TOPLEFT,
 888                          c->area.x, c->area.y + data->relative.delta,
 889                          c->area.width, c->area.height, TRUE, TRUE);
 890 }
 891
 892 void action_resize_relative_horz(union ActionData *data)
 893 {
 894     ObClient *c = data->relative.c;
 895     if (c)
 896         client_configure(c, OB_CORNER_TOPLEFT, c->area.x, c->area.y,
 897                          c->area.width +
 898                          data->relative.delta * c->size_inc.width,
 899                          c->area.height, TRUE, TRUE);
 900 }
 901
 902 void action_resize_relative_vert(union ActionData *data)
 903 {
 904     ObClient *c = data->relative.c;
 905     if (c && !c->shaded)
 906         client_configure(c, OB_CORNER_TOPLEFT, c->area.x, c->area.y,
 907                          c->area.width, c->area.height +
 908                          data->relative.delta * c->size_inc.height,
 909                          TRUE, TRUE);
 910 }
 911
 912 void action_maximize_full(union ActionData *data)
 913 {
 914     if (data->client.c)
 915         client_maximize(data->client.c, TRUE, 0, TRUE);
 916 }
 917
 918 void action_unmaximize_full(union ActionData *data)
 919 {
 920     if (data->client.c)
 921         client_maximize(data->client.c, FALSE, 0, TRUE);
 922 }
 923
 924 void action_toggle_maximize_full(union ActionData *data)
 925 {
 926     if (data->client.c)
 927         client_maximize(data->client.c,
 928                         !(data->client.c->max_horz ||
 929                           data->client.c->max_vert),
 930                         0, TRUE);
 931 }
 932
 933 void action_maximize_horz(union ActionData *data)
 934 {
 935     if (data->client.c)
 936         client_maximize(data->client.c, TRUE, 1, TRUE);
 937 }
 938
 939 void action_unmaximize_horz(union ActionData *data)
 940 {
 941     if (data->client.c)
 942         client_maximize(data->client.c, FALSE, 1, TRUE);
 943 }
 944
 945 void action_toggle_maximize_horz(union ActionData *data)
 946 {
 947     if (data->client.c)
 948         client_maximize(data->client.c, !data->client.c->max_horz, 1, TRUE);
 949 }
 950
 951 void action_maximize_vert(union ActionData *data)
 952 {
 953     if (data->client.c)
 954         client_maximize(data->client.c, TRUE, 2, TRUE);
 955 }
 956
 957 void action_unmaximize_vert(union ActionData *data)
 958 {
 959     if (data->client.c)
 960         client_maximize(data->client.c, FALSE, 2, TRUE);
 961 }
 962
 963 void action_toggle_maximize_vert(union ActionData *data)
 964 {
 965     if (data->client.c)
 966         client_maximize(data->client.c, !data->client.c->max_vert, 2, TRUE);
 967 }
 968
 969 void action_send_to_desktop(union ActionData *data)
 970 {
 971     ObClient *c = data->sendto.c;
 972
 973     if (!c || !client_normal(c)) return;
 974
 975     if (data->sendto.desk < screen_num_desktops ||
 976         data->sendto.desk == DESKTOP_ALL) {
 977         client_set_desktop(c, data->sendto.desk, TRUE);
 978         screen_set_desktop(data->sendto.desk);
 979     }
 980 }
 981
 982 void action_desktop(union ActionData *data)
 983 {
 984     if (data->desktop.desk < screen_num_desktops ||
 985         data->desktop.desk == DESKTOP_ALL)
 986         screen_set_desktop(data->desktop.desk);
 987 }
 988
 989 void action_desktop_dir(union ActionData *data)
 990 {
 991     guint d;
 992
 993     d = screen_cycle_desktop(data->desktopdir.dir, data->desktopdir.wrap,
 994                              data->sendtodir.linear,
 995                              data->desktopdir.final, data->desktopdir.cancel);
 996     screen_set_desktop(d);
 997 }
 998
 999 void action_send_to_desktop_dir(union ActionData *data)
1000 {
1001     ObClient *c = data->sendtodir.c;
1002     guint d;
1003
1004     if (!c || !client_normal(c)) return;
1005
1006     d = screen_cycle_desktop(data->sendtodir.dir, data->sendtodir.wrap,
1007                              data->sendtodir.linear,
1008                              data->sendtodir.final, data->sendtodir.cancel);
1009     client_set_desktop(c, d, TRUE);
1010     screen_set_desktop(d);
1011 }
1012
1013 #if 0
1014 void action_desktop_right(union ActionData *data)
1015 {
1016     guint r, c, d;
1017
1018     cur_row_col(&r, &c);
1019     ++c;
1020     if (c >= screen_desktop_layout.columns) {
1021         if (!data->desktopdir.wrap) return;
1022         c = 0;
1023     }
1024     d = translate_row_col(r, c);
1025     if (d >= screen_num_desktops) {
1026         if (!data->desktopdir.wrap) return;
1027         ++c;
1028     }
1029     d = translate_row_col(r, c);
1030     if (d < screen_num_desktops)
1031         screen_cycle_desktop(d, data->desktopdir.final,
1032                              data->desktopdir.cancel);
1033 }
1034
1035 void action_send_to_desktop_right(union ActionData *data)
1036 {
1037     ObClient *cl = data->sendto.c;
1038     guint r, c, d;
1039
1040     if (!cl || !client_normal(cl)) return;
1041
1042     cur_row_col(&r, &c);
1043     ++c;
1044     if (c >= screen_desktop_layout.columns) {
1045         if (!data->sendtodir.wrap) return;
1046         c = 0;
1047     }
1048     d = translate_row_col(r, c);
1049     if (d >= screen_num_desktops) {
1050         if (!data->sendtodir.wrap) return;
1051         ++c;
1052     }
1053     d = translate_row_col(r, c);
1054     if (d < screen_num_desktops) {
1055         client_set_desktop(cl, d, data->sendtodir.follow);
1056         if (data->sendtodir.follow)
1057             screen_cycle_desktop(d, data->desktopdir.final,
1058                                  data->desktopdir.cancel);
1059     }
1060 }
1061
1062 void action_desktop_left(union ActionData *data)
1063 {
1064     guint r, c, d;
1065
1066     cur_row_col(&r, &c);
1067     --c;
1068     if (c >= screen_desktop_layout.columns) {
1069         if (!data->desktopdir.wrap) return;
1070         c = screen_desktop_layout.columns - 1;
1071     }
1072     d = translate_row_col(r, c);
1073     if (d >= screen_num_desktops) {
1074         if (!data->desktopdir.wrap) return;
1075         --c;
1076     }
1077     d = translate_row_col(r, c);
1078     if (d < screen_num_desktops)
1079         screen_cycle_desktop(d, data->desktopdir.final,
1080                              data->desktopdir.cancel);
1081 }
1082
1083 void action_send_to_desktop_left(union ActionData *data)
1084 {
1085     ObClient *cl = data->sendto.c;
1086     guint r, c, d;
1087
1088     if (!cl || !client_normal(cl)) return;
1089
1090     cur_row_col(&r, &c);
1091     --c;
1092     if (c >= screen_desktop_layout.columns) {
1093         if (!data->sendtodir.wrap) return;
1094         c = screen_desktop_layout.columns - 1;
1095     }
1096     d = translate_row_col(r, c);
1097     if (d >= screen_num_desktops) {
1098         if (!data->sendtodir.wrap) return;
1099         --c;
1100     }
1101     d = translate_row_col(r, c);
1102     if (d < screen_num_desktops) {
1103         client_set_desktop(cl, d, data->sendtodir.follow);
1104         if (data->sendtodir.follow)
1105             screen_cycle_desktop(d, data->desktopdir.final,
1106                                  data->desktopdir.cancel);
1107     }
1108 }
1109
1110 void action_desktop_down(union ActionData *data)
1111 {
1112     guint r, c, d;
1113
1114     cur_row_col(&r, &c);
1115     ++r;
1116     if (r >= screen_desktop_layout.rows) {
1117         if (!data->desktopdir.wrap) return;
1118         r = 0;
1119     }
1120     d = translate_row_col(r, c);
1121     if (d >= screen_num_desktops) {
1122         if (!data->desktopdir.wrap) return;
1123         ++r;
1124     }
1125     d = translate_row_col(r, c);
1126     if (d < screen_num_desktops)
1127         screen_cycle_desktop(d, data->desktopdir.final,
1128                              data->desktopdir.cancel);
1129 }
1130
1131 void action_send_to_desktop_down(union ActionData *data)
1132 {
1133     guint r, c, d;
1134
1135     if (data->sendtodir.c) {
1136         cur_row_col(&r, &c);
1137         ++r;
1138         if (r >= screen_desktop_layout.rows) {
1139             if (!data->sendtodir.wrap) return;
1140             r = 0;
1141         }
1142         d = translate_row_col(r, c);
1143         if (d >= screen_num_desktops) {
1144             if (!data->sendtodir.wrap) return;
1145             ++r;
1146         }
1147         d = translate_row_col(r, c);
1148         if (d < screen_num_desktops) {
1149             client_set_desktop(data->sendtodir.c, d, data->sendtodir.follow);
1150             if (data->sendtodir.follow)
1151                 screen_cycle_desktop(d, data->desktopdir.final,
1152                                      data->desktopdir.cancel);
1153         }
1154     }
1155 }
1156
1157 void action_desktop_up(union ActionData *data)
1158 {
1159     guint r, c, d;
1160
1161     cur_row_col(&r, &c);
1162     --r;
1163     if (r >= screen_desktop_layout.rows) {
1164         if (!data->desktopdir.wrap) return;
1165         r = screen_desktop_layout.rows - 1;
1166     }
1167     d = translate_row_col(r, c);
1168     if (d >= screen_num_desktops) {
1169         if (!data->desktopdir.wrap) return;
1170         --r;
1171     }
1172     d = translate_row_col(r, c);
1173     if (d < screen_num_desktops)
1174         screen_cycle_desktop(d, data->desktopdir.final,
1175                              data->desktopdir.cancel);
1176 }
1177
1178 void action_send_to_desktop_up(union ActionData *data)
1179 {
1180     guint r, c, d;
1181
1182     if (data->sendtodir.c) {
1183         cur_row_col(&r, &c);
1184         --r;
1185         if (r >= screen_desktop_layout.rows) {
1186             if (!data->sendtodir.wrap) return;
1187             r = screen_desktop_layout.rows - 1;
1188         }
1189         d = translate_row_col(r, c);
1190         if (d >= screen_num_desktops) {
1191             if (!data->sendtodir.wrap) return;
1192             --r;
1193         }
1194         d = translate_row_col(r, c);
1195         if (d < screen_num_desktops) {
1196             client_set_desktop(data->sendtodir.c, d, data->sendtodir.follow);
1197             if (data->sendtodir.follow)
1198                 screen_cycle_desktop(d, data->desktopdir.final,
1199                                      data->desktopdir.cancel);
1200         }
1201     }
1202 }
1203 #endif
1204
1205 void action_toggle_decorations(union ActionData *data)
1206 {
1207     ObClient *c = data->client.c;;
1208
1209     if (!c) return;
1210
1211     c->decorate = !c->decorate;
1212     client_setup_decor_and_functions(c);
1213 }
1214
1215 void action_moveresize(union ActionData *data)
1216 {
1217     ObClient *c = data->moveresize.c;
1218
1219     if (!c || !client_normal(c)) return;
1220
1221     moveresize_start(c, data->moveresize.x, data->moveresize.y,
1222                      data->moveresize.button, data->moveresize.corner);
1223 }
1224
1225 void action_restart(union ActionData *data)
1226 {
1227     ob_restart_other(data->execute.path);
1228 }
1229
1230 void action_exit(union ActionData *data)
1231 {
1232     ob_exit();
1233 }
1234
1235 void action_showmenu(union ActionData *data)
1236 {
1237     if (data->showmenu.name) {
1238         menu_show(data->showmenu.name, data->showmenu.x, data->showmenu.y,
1239                   data->showmenu.c);
1240     }
1241 }
1242
1243 void action_cycle_windows(union ActionData *data)
1244 {
1245     ObClient *c;
1246
1247     c = focus_cycle(data->cycle.forward, data->cycle.linear, data->cycle.final,
1248                     data->cycle.cancel);
1249 }
1250
1251 void action_directional_focus(union ActionData *data)
1252 {
1253     ObClient *nf;
1254
1255     if (!data->diraction.c)
1256         return;
1257     if ((nf = client_find_directional(data->diraction.c,
1258                                       data->diraction.direction)))
1259         client_activate(nf, FALSE);
1260 }
1261
1262 void action_movetoedge(union ActionData *data)
1263 {
1264     int x, y;
1265     ObClient *c = data->diraction.c;
1266
1267     if (!c)
1268         return;
1269     x = c->frame->area.x;
1270     y = c->frame->area.y;
1271
1272     switch(data->diraction.direction) {
1273     case OB_DIRECTION_NORTH:
1274         y = client_directional_edge_search(c, OB_DIRECTION_NORTH);
1275         break;
1276     case OB_DIRECTION_WEST:
1277         x = client_directional_edge_search(c, OB_DIRECTION_WEST);
1278         break;
1279     case OB_DIRECTION_SOUTH:
1280         y = client_directional_edge_search(c, OB_DIRECTION_SOUTH) -
1281             c->frame->area.height;
1282         break;
1283     case OB_DIRECTION_EAST:
1284         x = client_directional_edge_search(c, OB_DIRECTION_EAST) -
1285             c->frame->area.width;
1286         break;
1287     default:
1288         g_assert_not_reached();
1289     }
1290     frame_frame_gravity(c->frame, &x, &y);
1291     client_configure(c, OB_CORNER_TOPLEFT,
1292                      x, y, c->area.width, c->area.height, TRUE, TRUE);
1293
1294 }
1295
1296 void action_growtoedge(union ActionData *data)
1297 {
1298     int x, y, width, height, dest;
1299     ObClient *c = data->diraction.c;
1300     Rect *a = screen_area(c->desktop);
1301
1302     if (!c)
1303         return;
1304
1305     x = c->frame->area.x;
1306     y = c->frame->area.y;
1307     width = c->frame->area.width;
1308     height = c->frame->area.height;
1309
1310     switch(data->diraction.direction) {
1311     case OB_DIRECTION_NORTH:
1312         dest = client_directional_edge_search(c, OB_DIRECTION_NORTH);
1313         if (a->y == y)
1314             height = c->frame->area.height / 2;
1315         else {
1316             height = c->frame->area.y + c->frame->area.height - dest;
1317             y = dest;
1318         }
1319         break;
1320     case OB_DIRECTION_WEST:
1321         dest = client_directional_edge_search(c, OB_DIRECTION_WEST);
1322         if (a->x == x)
1323             width = c->frame->area.width / 2;
1324         else {
1325             width = c->frame->area.x + c->frame->area.width - dest;
1326             x = dest;
1327         }
1328         break;
1329     case OB_DIRECTION_SOUTH:
1330         dest = client_directional_edge_search(c, OB_DIRECTION_SOUTH);
1331         if (a->y + a->height == y + c->frame->area.height) {
1332             height = c->frame->area.height / 2;
1333             y = a->y + a->height - height;
1334         } else
1335             height = dest - c->frame->area.y;
1336         y += (height - c->frame->area.height) % c->size_inc.height;
1337         height -= (height - c->frame->area.height) % c->size_inc.height;
1338         break;
1339     case OB_DIRECTION_EAST:
1340         dest = client_directional_edge_search(c, OB_DIRECTION_EAST);
1341         if (a->x + a->width == x + c->frame->area.width) {
1342             width = c->frame->area.width / 2;
1343             x = a->x + a->width - width;
1344         } else
1345             width = dest - c->frame->area.x;
1346         x += (width - c->frame->area.width) % c->size_inc.width;
1347         width -= (width - c->frame->area.width) % c->size_inc.width;
1348         break;
1349     default:
1350         g_assert_not_reached();
1351     }
1352     frame_frame_gravity(c->frame, &x, &y);
1353     width -= c->frame->size.left + c->frame->size.right;
1354     height -= c->frame->size.top + c->frame->size.bottom;
1355     client_configure(c, OB_CORNER_TOPLEFT, x, y, width, height, TRUE, TRUE);
1356 }
1357
1358 void action_send_to_layer(union ActionData *data)
1359 {
1360     if (data->layer.c)
1361         client_set_layer(data->layer.c, data->layer.layer);
1362 }
1363
1364 void action_toggle_layer(union ActionData *data)
1365 {
1366     ObClient *c = data->layer.c;
1367
1368     if (c) {
1369         if (data->layer.layer < 0)
1370             client_set_layer(c, c->below ? 0 : -1);
1371         else if (data->layer.layer > 0)
1372             client_set_layer(c, c->above ? 0 : 1);
1373     }
1374 }
1375
1376 void action_toggle_show_desktop(union ActionData *data)
1377 {
1378     screen_show_desktop(!screen_showing_desktop);
1379 }
1380
1381 void action_show_desktop(union ActionData *data)
1382 {
1383     screen_show_desktop(TRUE);
1384 }
1385
1386 void action_unshow_desktop(union ActionData *data)
1387 {
1388     screen_show_desktop(FALSE);
1389 }