openbox/action.c

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