fvwm/bindings.c

   1 /* -*-c-*- */
   2 /* This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 2 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program; if not, write to the Free Software
  14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /* ---------------------------- included header files ---------------------- */
  18
  19 #include "config.h"
  20
  21 #include <stdio.h>
  22
  23 #include "libs/fvwmlib.h"
  24 #include "libs/charmap.h"
  25 #include "libs/wcontext.h"
  26 #include "libs/modifiers.h"
  27 #include "libs/Parse.h"
  28 #include "libs/Strings.h"
  29 #include "libs/defaults.h"
  30 #include "fvwm.h"
  31 #include "externs.h"
  32 #include "cursor.h"
  33 #include "functions.h"
  34 #include "bindings.h"
  35 #include "module_interface.h"
  36 #include "misc.h"
  37 #include "screen.h"
  38 #include "focus.h"
  39 #include "menubindings.h"
  40 #include "move_resize.h"        /* for placement_binding */
  41 #ifdef HAVE_STROKE
  42 #include "stroke.h"
  43 #endif /* HAVE_STROKE */
  44
  45 /* ---------------------------- local definitions -------------------------- */
  46
  47 /* ---------------------------- local macros ------------------------------- */
  48
  49 /* ---------------------------- imports ------------------------------------ */
  50
  51 /* ---------------------------- included code files ------------------------ */
  52
  53 /* ---------------------------- local types -------------------------------- */
  54
  55 /* ---------------------------- forward declarations ----------------------- */
  56
  57 /* ---------------------------- local variables ---------------------------- */
  58
  59 static int mods_unused = DEFAULT_MODS_UNUSED;
  60
  61 /* ---------------------------- exported variables (globals) --------------- */
  62
  63 /* ---------------------------- local functions ---------------------------- */
  64
  65 static void update_nr_buttons(
  66         int contexts, int *nr_left_buttons, int *nr_right_buttons, Bool do_set)
  67 {
  68         int i;
  69         int l = *nr_left_buttons;
  70         int r = *nr_right_buttons;
  71
  72         if (contexts == C_ALL)
  73         {
  74                 return;
  75         }
  76         /* check for nr_left_buttons */
  77         for (i = 0; i < NUMBER_OF_TITLE_BUTTONS; i += 2)
  78         {
  79                 if ((contexts & (C_L1 << i)))
  80                 {
  81                         if (do_set || *nr_left_buttons <= i / 2)
  82                         {
  83                                 *nr_left_buttons = i / 2 + 1;
  84                         }
  85                 }
  86         }
  87         /* check for nr_right_buttons */
  88         for (i = 1; i < NUMBER_OF_TITLE_BUTTONS; i += 2)
  89         {
  90                 if ((contexts & (C_L1 << i)))
  91                 {
  92                         if (do_set || *nr_right_buttons <= i / 2)
  93                         {
  94                                 *nr_right_buttons = i / 2 + 1;
  95                         }
  96                 }
  97         }
  98         if (*nr_left_buttons != l || *nr_right_buttons != r)
  99         {
 100                 Scr.flags.do_need_window_update = 1;
 101                 Scr.flags.has_nr_buttons_changed = 1;
 102         }
 103
 104         return;
 105 }
 106
 107 static int activate_binding(Binding *binding, binding_t type, Bool do_grab)
 108 {
 109         FvwmWindow *t;
 110         Bool rc = 0;
 111
 112         if (binding == NULL)
 113         {
 114                 return rc;
 115         }
 116         if (BIND_IS_PKEY_BINDING(type) || binding->Context == C_ALL)
 117         {
 118                 /* necessary for key bindings that work over unfocused windows
 119                  */
 120                 GrabWindowKeyOrButton(
 121                         dpy, Scr.Root, binding,
 122                         C_WINDOW | C_DECOR | C_ROOT | C_ICON | C_EWMH_DESKTOP,
 123                         GetUnusedModifiers(), None, do_grab);
 124                 if (do_grab == False)
 125                 {
 126                         rc = 1;
 127                 }
 128         }
 129         if (do_grab == False && BIND_IS_KEY_BINDING(type) &&
 130             (binding->Context & C_ROOT))
 131         {
 132                 rc = 1;
 133         }
 134         if (fFvwmInStartup == True)
 135         {
 136                 return rc;
 137         }
 138
 139         /* grab keys immediately */
 140         for (t = Scr.FvwmRoot.next; t != NULL; t = t->next)
 141         {
 142                 if (!IS_EWMH_DESKTOP(FW_W(t)) &&
 143                     (binding->Context & (C_WINDOW | C_DECOR)) &&
 144                     BIND_IS_KEY_BINDING(type))
 145                 {
 146                         GrabWindowKey(
 147                                 dpy, FW_W_FRAME(t), binding,
 148                                 C_WINDOW | C_DECOR, GetUnusedModifiers(),
 149                                 do_grab);
 150                 }
 151                 if (binding->Context & C_ICON)
 152                 {
 153                         if (FW_W_ICON_TITLE(t) != None)
 154                         {
 155                                 GrabWindowKeyOrButton(
 156                                         dpy, FW_W_ICON_TITLE(t), binding,
 157                                         C_ICON, GetUnusedModifiers(), None,
 158                                         do_grab);
 159                         }
 160                         if (FW_W_ICON_PIXMAP(t) != None)
 161                         {
 162                                 GrabWindowKeyOrButton(
 163                                         dpy, FW_W_ICON_PIXMAP(t), binding,
 164                                         C_ICON, GetUnusedModifiers(), None,
 165                                         do_grab);
 166                         }
 167                 }
 168                 if (IS_EWMH_DESKTOP(FW_W(t)) &&
 169                     (binding->Context & C_EWMH_DESKTOP))
 170                 {
 171                         GrabWindowKeyOrButton(
 172                                 dpy, FW_W_PARENT(t), binding, C_EWMH_DESKTOP,
 173                                 GetUnusedModifiers(), None, do_grab);
 174                 }
 175         }
 176
 177         return rc;
 178 }
 179
 180 static int bind_get_bound_button_contexts(
 181         Binding **pblist, unsigned short *buttons_grabbed)
 182 {
 183         int bcontext = 0;
 184         Binding *b;
 185
 186         if (buttons_grabbed)
 187         {
 188                 *buttons_grabbed = 0;
 189         }
 190         for (b = *pblist; b != NULL; b = b->NextBinding)
 191         {
 192                 if (!BIND_IS_MOUSE_BINDING(b->type) &&
 193                     !BIND_IS_STROKE_BINDING(b->type))
 194                 {
 195                         continue;
 196                 }
 197                 if ((b->Context & (C_WINDOW | C_EWMH_DESKTOP)) &&
 198                     !(BIND_IS_STROKE_BINDING(b->type) && b->Button_Key == 0) &&
 199                     buttons_grabbed != NULL)
 200                 {
 201                         if (b->Button_Key == 0)
 202                         {
 203                                 *buttons_grabbed |=
 204                                         ((1 <<
 205                                           NUMBER_OF_EXTENDED_MOUSE_BUTTONS) -
 206                                          1);
 207                         }
 208                         else
 209                         {
 210                                 *buttons_grabbed |= (1 << (b->Button_Key - 1));
 211                         }
 212                 }
 213                 if (b->Context != C_ALL && (b->Context & (C_LALL | C_RALL)))
 214                 {
 215                         bcontext |= b->Context;
 216                 }
 217         }
 218
 219         return bcontext;
 220 }
 221
 222 static void __rebind_global_key(Binding **pblist, int Button_Key)
 223 {
 224         Binding *b;
 225
 226         for (b = *pblist; b != NULL; b = b->NextBinding)
 227         {
 228                 if (b->Button_Key == Button_Key &&
 229                     (BIND_IS_PKEY_BINDING(b->type) || b->Context == C_ALL))
 230                 {
 231                         activate_binding(b, b->type, True);
 232                         return;
 233                 }
 234         }
 235
 236         return;
 237 }
 238
 239 /* Parses a mouse or key binding */
 240 static int ParseBinding(
 241         Display *dpy, Binding **pblist, char *tline, binding_t type,
 242         int *nr_left_buttons, int *nr_right_buttons,
 243         unsigned short *buttons_grabbed, Bool is_silent)
 244 {
 245         char *action, context_string[20], modifier_string[20], *ptr, *token;
 246         char key_string[201] = "", buffer[80], *windowName = NULL, *p;
 247         int button = 0;
 248         int n1=0,n2=0,n3=0;
 249         int context;
 250         int modifier;
 251         int rc;
 252         KeySym keysym = NoSymbol;
 253         Bool is_unbind_request = False;
 254         Bool is_pass_through = False;
 255         Bool is_binding_removed = False;
 256         Binding *b;
 257         Binding *rmlist = NULL;
 258         STROKE_CODE(char stroke[STROKE_MAX_SEQUENCE + 1] = "");
 259         STROKE_CODE(int n4=0);
 260         STROKE_CODE(int i);
 261
 262         /* tline points after the key word "Mouse" or "Key" */
 263         token = p = PeekToken(tline, &ptr);
 264         /* check to see if a window name has been specified. */
 265         if (p == NULL)
 266         {
 267                 fvwm_msg(
 268                         ERR, "ParseBinding", "empty %s binding, ignored\n",tline);
 269                 return 0;
 270         }
 271         if (*p == '(')
 272         {
 273                 /* A window name has been specified for the binding. */
 274                 sscanf(p+1, "%79s",buffer);
 275                 p = buffer;
 276                 while (*p != ')')
 277                 {
 278                         if (*p == '\0')
 279                         {
 280                                 if (!is_silent)
 281                                 {
 282                                         fvwm_msg(
 283                                                 ERR, "ParseBinding",
 284                                                 "Syntax error in line %s -"
 285                                                 " missing ')'", tline);
 286                                 }
 287                                 return 0;
 288                         }
 289                         ++p;
 290                 }
 291                 *p++ = '\0';
 292                 windowName = buffer;
 293                 if (*p != '\0')
 294                 {
 295                         if (!is_silent)
 296                         {
 297                                 fvwm_msg(
 298                                         ERR, "ParseBinding",
 299                                         "Syntax error in line %s - trailing"
 300                                         " text after specified window", tline);
 301                         }
 302                         return 0;
 303                 }
 304                 token = PeekToken(ptr, &ptr);
 305         }
 306
 307         if (token != NULL)
 308         {
 309                 if (BIND_IS_KEY_BINDING(type))
 310                 {
 311                         /* see len of key_string above */
 312                         n1 = sscanf(token,"%200s", key_string);
 313                 }
 314 #ifdef HAVE_STROKE
 315                 else if (BIND_IS_STROKE_BINDING(type))
 316                 {
 317                         int num = 0;
 318                         int j;
 319
 320                         n1 = 1;
 321                         i = 0;
 322                         if (token[0] == 'N' && token[1] != '\0')
 323                         {
 324                                 num = 1;
 325                         }
 326                         j=i+num;
 327                         while (n1 && token[j] != '\0' &&
 328                                i < STROKE_MAX_SEQUENCE)
 329                         {
 330                                 if (!isdigit(token[j]))
 331                                 {
 332                                         n1 = 0;
 333                                 }
 334                                 if (num)
 335                                 {
 336                                         /* Numeric pad to Telephone  */
 337                                         if ('7' <= token[j] && token[j] <= '9')
 338                                         {
 339                                                 token[j] -= 6;
 340                                         }
 341                                         else if ('1' <= token[j] &&
 342                                                  token[j] <= '3')
 343                                         {
 344                                                 token[j] += 6;
 345                                         }
 346                                 }
 347                                 stroke[i] = token[j];
 348                                 i++;
 349                                 j=i+num;
 350                         }
 351                         stroke[i] = '\0';
 352                         if (strlen(token) > STROKE_MAX_SEQUENCE + num)
 353                         {
 354                                 if (!is_silent)
 355                                 {
 356                                         fvwm_msg(
 357                                                 WARN, "ParseBinding",
 358                                                 "Too long stroke sequence in"
 359                                                 " line %s.  Only %i elements"
 360                                                 " will be taken into"
 361                                                 " account.\n",
 362                                                  tline, STROKE_MAX_SEQUENCE);
 363                                 }
 364                         }
 365                 }
 366 #endif /* HAVE_STROKE */
 367                 else
 368                 {
 369                         n1 = sscanf(token, "%d", &button);
 370                         if (button < 0)
 371                         {
 372                                 if (!is_silent)
 373                                 {
 374                                         fvwm_msg(
 375                                                 ERR, "ParseBinding",
 376                                                 "Illegal mouse button in line"
 377                                                 " %s", tline);
 378                                 }
 379                                 return 0;
 380                         }
 381                         if (button > NUMBER_OF_MOUSE_BUTTONS)
 382                         {
 383                                 if (!is_silent)
 384                                 {
 385                                         fvwm_msg(
 386                                                 WARN, "ParseBinding",
 387                                                 "Got mouse button %d when the"
 388                                                 " maximum is %d.\n  You can't"
 389                                                 " bind complex functions to"
 390                                                 " this button.  To suppress"
 391                                                 " this warning, use:\n"
 392                                                 "  Silent Mouse %s", button,
 393                                                 NUMBER_OF_MOUSE_BUTTONS, tline);
 394                                 }
 395                         }
 396                 }
 397         }
 398
 399 #ifdef HAVE_STROKE
 400         if (BIND_IS_STROKE_BINDING(type))
 401         {
 402                 token = PeekToken(ptr, &ptr);
 403                 if (token != NULL)
 404                 {
 405                         n4 = sscanf(token,"%d", &button);
 406                 }
 407         }
 408 #endif /* HAVE_STROKE */
 409
 410         token = PeekToken(ptr, &ptr);
 411         if (token != NULL)
 412         {
 413                 n2 = sscanf(token, "%19s", context_string);
 414         }
 415         token = PeekToken(ptr, &action);
 416         if (token != NULL)
 417         {
 418                 n3 = sscanf(token, "%19s", modifier_string);
 419         }
 420
 421         if (n1 != 1 || n2 != 1 || n3 != 1
 422             STROKE_CODE(|| (BIND_IS_STROKE_BINDING(type) && n4 != 1)))
 423         {
 424                 if (!is_silent)
 425                 {
 426                         fvwm_msg(
 427                                 ERR, "ParseBinding", "Syntax error in line %s",
 428                                 tline);
 429                 }
 430                 return 0;
 431         }
 432
 433         if (wcontext_string_to_wcontext(
 434                     context_string, &context) && !is_silent)
 435         {
 436                 fvwm_msg(
 437                         WARN, "ParseBinding", "Illegal context in line %s",
 438                         tline);
 439         }
 440         if (modifiers_string_to_modmask(modifier_string, &modifier) &&
 441             !is_silent)
 442         {
 443                 fvwm_msg(
 444                         WARN, "ParseBinding", "Illegal modifier in line %s",
 445                         tline);
 446         }
 447
 448         if (BIND_IS_KEY_BINDING(type))
 449         {
 450                 keysym = FvwmStringToKeysym(dpy, key_string);
 451                 /* Don't let a 0 keycode go through, since that means AnyKey
 452                  * to the XGrabKey call. */
 453                 if (keysym == 0)
 454                 {
 455                         if (!is_silent)
 456                         {
 457                                 fvwm_msg(
 458                                         ERR, "ParseBinding", "No such key: %s",
 459                                         key_string);
 460                         }
 461                         return 0;
 462                 }
 463         }
 464
 465         /*
 466         ** strip leading whitespace from action if necessary
 467         */
 468         while (*action && (*action == ' ' || *action == '\t'))
 469         {
 470                 action++;
 471         }
 472
 473         if (action)
 474         {
 475                 is_pass_through = is_pass_through_action(action);
 476                 if (is_pass_through)
 477                 {
 478                         /* pass-through actions indicate that the event be
 479                          * allowed to pass through to the underlying window. */
 480                         if (windowName == NULL)
 481                         {
 482                                 /* It doesn't make sense to have a pass-through
 483                                  * action on global bindings. */
 484                                 if (!is_silent)
 485                                         fvwm_msg(ERR, "ParseBinding",
 486                                                  "Illegal action for global "
 487                                                  "binding: %s", tline);
 488                                 return 0;
 489                         }
 490                 }
 491         }
 492         /* see if it is an unbind request */
 493         if (!action || (action[0] == '-' && !is_pass_through))
 494         {
 495                 is_unbind_request = True;
 496         }
 497
 498         /* short circuit menu bindings for now. */
 499         if ((context & C_MENU) == C_MENU)
 500         {
 501                 menu_binding(dpy, type, button, keysym, context,
 502                                     modifier, action, windowName);
 503                 /* ParseBinding returns the number of new bindings in pblist
 504                  * menu bindings does not add to pblist, and should return 0 */
 505                 return 0;
 506         }
 507         /* short circuit placement bindings for now. */
 508         if ((context & C_PLACEMENT) == C_PLACEMENT)
 509         {
 510                 placement_binding(button,keysym,modifier,action);
 511                 /* ParseBinding returns the number of new bindings in pblist
 512                  * placement bindings does not add to pblist, and should
 513                  * return 0 */
 514                 return 0;
 515         }
 516         /*
 517         ** Remove the "old" bindings if any
 518         */
 519         /* BEGIN remove */
 520         CollectBindingList(
 521                 dpy, pblist, &rmlist, type, STROKE_ARG((void *)stroke)
 522                 button, keysym, modifier, context, windowName);
 523         if (rmlist != NULL)
 524         {
 525                 is_binding_removed = True;
 526                 if (is_unbind_request)
 527                 {
 528                         int rc = 0;
 529
 530                         /* remove the grabs for the key for unbind
 531                          * requests */
 532                         for (b = rmlist; b != NULL; b = b->NextBinding)
 533                         {
 534                                 /* release the grab */
 535                                 rc |= activate_binding(b, type, False);
 536                         }
 537                         if (rc)
 538                         {
 539                                 __rebind_global_key(pblist, rmlist->Button_Key);
 540                         }
 541                 }
 542                 FreeBindingList(rmlist);
 543         }
 544         if (is_binding_removed)
 545         {
 546                 int bcontext;
 547
 548                 bcontext = bind_get_bound_button_contexts(
 549                         pblist, buttons_grabbed);
 550                 update_nr_buttons(
 551                         bcontext, nr_left_buttons, nr_right_buttons,
 552                         True);
 553         }
 554         /* return if it is an unbind request */
 555         if (is_unbind_request)
 556         {
 557                 return 0;
 558         }
 559         /* END remove */
 560
 561         update_nr_buttons(context, nr_left_buttons, nr_right_buttons, False);
 562         if ((modifier & AnyModifier)&&(modifier&(~AnyModifier)))
 563         {
 564                 fvwm_msg(
 565                         WARN, "ParseBinding", "Binding specified AnyModifier"
 566                         " and other modifers too. Excess modifiers are"
 567                         " ignored.");
 568                 modifier = AnyModifier;
 569         }
 570         if ((BIND_IS_MOUSE_BINDING(type) ||
 571              (BIND_IS_STROKE_BINDING(type) && button != 0)) &&
 572             (context & (C_WINDOW | C_EWMH_DESKTOP)) && buttons_grabbed != NULL)
 573         {
 574                 if (button == 0)
 575                 {
 576                         *buttons_grabbed |=
 577                                 ((1 << NUMBER_OF_EXTENDED_MOUSE_BUTTONS) - 1);
 578                 }
 579                 else
 580                 {
 581                         *buttons_grabbed |= (1 << (button - 1));
 582                 }
 583         }
 584         rc = AddBinding(
 585                 dpy, pblist, type, STROKE_ARG((void *)stroke)
 586                 button, keysym, key_string, modifier, context, (void *)action,
 587                 NULL, windowName);
 588
 589         return rc;
 590 }
 591
 592 static void binding_cmd(F_CMD_ARGS, binding_t type)
 593 {
 594         Binding *b;
 595         int count;
 596         unsigned short btg = Scr.buttons2grab;
 597
 598         count = ParseBinding(
 599                 dpy, &Scr.AllBindings, action, type, &Scr.nr_left_buttons,
 600                 &Scr.nr_right_buttons, &btg, Scr.flags.are_functions_silent);
 601         if (btg != Scr.buttons2grab)
 602         {
 603                 Scr.flags.do_need_window_update = 1;
 604                 Scr.flags.has_mouse_binding_changed = 1;
 605                 Scr.buttons2grab = btg;
 606         }
 607         for (b = Scr.AllBindings; count > 0 && b != NULL;
 608              count--, b = b->NextBinding)
 609         {
 610                 activate_binding(b, type, True);
 611         }
 612
 613         return;
 614 }
 615
 616 /* ---------------------------- interface functions ------------------------ */
 617
 618 /* Removes all unused modifiers from in_modifiers */
 619 unsigned int MaskUsedModifiers(unsigned int in_modifiers)
 620 {
 621         return in_modifiers & ~mods_unused;
 622 }
 623
 624 unsigned int GetUnusedModifiers(void)
 625 {
 626         return mods_unused;
 627 }
 628
 629 /* ---------------------------- builtin commands --------------------------- */
 630
 631 void CMD_Key(F_CMD_ARGS)
 632 {
 633         binding_cmd(F_PASS_ARGS, BIND_KEYPRESS);
 634
 635         return;
 636 }
 637
 638 void CMD_PointerKey(F_CMD_ARGS)
 639 {
 640         binding_cmd(F_PASS_ARGS, BIND_PKEYPRESS);
 641
 642         return;
 643 }
 644
 645 void CMD_Mouse(F_CMD_ARGS)
 646 {
 647         binding_cmd(F_PASS_ARGS, BIND_BUTTONPRESS);
 648
 649         return;
 650 }
 651
 652 #ifdef HAVE_STROKE
 653 void CMD_Stroke(F_CMD_ARGS)
 654 {
 655         binding_cmd(F_PASS_ARGS, BIND_STROKE);
 656
 657         return;
 658 }
 659 #endif /* HAVE_STROKE */
 660
 661 /* Declares which X modifiers are actually locks and should be ignored when
 662  * testing mouse/key binding modifiers. */
 663 void CMD_IgnoreModifiers(F_CMD_ARGS)
 664 {
 665         char *token;
 666         int mods_unused_old = mods_unused;
 667
 668         token = PeekToken(action, &action);
 669         if (!token)
 670         {
 671                 mods_unused = 0;
 672         }
 673         else if (StrEquals(token, "default"))
 674         {
 675                 mods_unused = DEFAULT_MODS_UNUSED;
 676         }
 677         else if (modifiers_string_to_modmask(token, &mods_unused))
 678         {
 679                 fvwm_msg(
 680                         ERR, "ignore_modifiers",
 681                         "illegal modifier in line %s\n", action);
 682         }
 683         if (mods_unused != mods_unused_old)
 684         {
 685                 /* broadcast config to modules */
 686                 broadcast_ignore_modifiers();
 687         }
 688
 689         return;
 690 }