src/binding.c

   1 /*
   2  * ion/binding.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2001.
   5  * See the included file LICENSE for details.
   6  */
   7
   8 #include <string.h>
   9
  10 #ifndef CF_NO_LOCK_HACK
  11 #define CF_HACK_IGNORE_EVIL_LOCKS
  12 #endif
  13
  14 #ifdef CF_HACK_IGNORE_EVIL_LOCKS
  15 #define XK_MISCELLANY
  16 #include <X11/keysymdef.h>
  17 #endif
  18
  19 #include "common.h"
  20 #include "event.h"
  21 #include "binding.h"
  22 #include "global.h"
  23 #include "objp.h"
  24
  25
  26 /* */
  27
  28 #define N_MODS 8
  29
  30 static const uint modmasks[N_MODS]={
  31         ShiftMask, LockMask, ControlMask, Mod1Mask, Mod2Mask, Mod3Mask,
  32         Mod4Mask, Mod5Mask
  33 };
  34
  35 static XModifierKeymap *modmap=NULL;
  36
  37 #ifdef CF_HACK_IGNORE_EVIL_LOCKS
  38
  39 #define N_EVILLOCKS 3
  40 #define N_LOOKUPEVIL 2
  41
  42 static uint evillockmasks[N_EVILLOCKS]={
  43          0, 0, LockMask
  44 };
  45
  46 static const KeySym evillocks[N_LOOKUPEVIL]={
  47         XK_Num_Lock, XK_Scroll_Lock
  48 };
  49
  50 static uint evilignoremask=LockMask;
  51
  52 static void lookup_evil_locks();
  53
  54 static void evil_grab_key(Display *display, uint keycode, uint modifiers,
  55                                                   Window grab_window, bool owner_events,
  56                                                   int pointer_mode, int keyboard_mode);
  57
  58 static void evil_grab_button(Display *display, uint button, uint modifiers,
  59                                                          Window grab_window, bool owner_events,
  60                                                          uint event_mask, int pointer_mode,
  61                                                          int keyboard_mode, Window confine_to,
  62                                                          Cursor cursor);
  63
  64 #endif
  65
  66
  67 #define CVAL(A, B, V) ( A->V < B->V ? -1 : (A->V > B->V ? 1 : 0))
  68
  69 static int compare_bindings(const void *a_, const void *b_)
  70 {
  71         const WBinding *a=(WBinding*)a_, *b=(WBinding*)b_;
  72         int r=CVAL(a, b, act);
  73         if(r==0){
  74                 r=CVAL(a, b, kcb);
  75                 if(r==0){
  76                         r=CVAL(a, b, state);
  77                 }
  78         }
  79         return r;
  80 }
  81
  82 #undef CVAL
  83
  84
  85
  86 bool init_bindmap(WBindmap *bindmap)
  87 {
  88         bindmap->nbindings=0;
  89         bindmap->bindings=NULL;
  90         bindmap->parent=NULL;
  91         bindmap->confdefmod=0;
  92         return TRUE;
  93 }
  94
  95
  96 WBindmap *create_bindmap()
  97 {
  98         SIMPLECREATESTRUCT_IMPL(WBindmap, bindmap, (p));
  99 }
 100
 101
 102 void destroy_binding(WBinding *binding)
 103 {
 104         int i;
 105
 106         if(binding->submap!=NULL){
 107                 destroy_bindmap(binding->submap);
 108                 free(binding->submap);
 109         }
 110
 111         for(i=1; i<binding->nargs; i++)
 112                 tok_free(binding->args+i);
 113 }
 114
 115
 116 void destroy_bindmap(WBindmap *bindmap)
 117 {
 118         int i;
 119         WBinding *binding=bindmap->bindings;
 120
 121         for(i=0; i<bindmap->nbindings; i++, binding++)
 122                 destroy_binding(binding);
 123
 124         free(bindmap->bindings);
 125 }
 126
 127
 128
 129 bool add_binding(WBindmap *bindmap, const WBinding *b)
 130 {
 131         WBinding *binding;
 132         int i, j;
 133
 134         if(bindmap==NULL || (b->func==NULL && b->submap==NULL))
 135                 return FALSE;
 136
 137         binding=bindmap->bindings;
 138
 139         for(i=0; i<bindmap->nbindings; i++){
 140                 switch(compare_bindings((void*)b, (void*)(binding+i))){
 141                 case 1:
 142                         continue;
 143                 case 0:
 144                         destroy_binding(binding+i);
 145                         goto subst;
 146                 }
 147                 break;
 148         }
 149
 150         binding=REALLOC_N(binding, WBinding, bindmap->nbindings,
 151                                           bindmap->nbindings+1);
 152
 153         if(binding==NULL){
 154                 warn_err();
 155                 return FALSE;
 156         }
 157
 158         memmove(&(binding[i+1]), &(binding[i]),
 159                         sizeof(WBinding)*(bindmap->nbindings-i));
 160
 161         bindmap->bindings=binding;
 162         bindmap->nbindings++;
 163
 164 subst:
 165         memcpy(&(binding[i]), b, sizeof(WBinding));
 166
 167         return TRUE;
 168 }
 169
 170
 171 static void bind_simple(WBindmap *bindmap, int ftab,
 172                                                 int state, int key, char *fn)
 173 {
 174         WBinding binding;
 175
 176         binding.func=lookup_func(fn, ftab);
 177         binding.state=state;
 178         binding.kcb=XKeysymToKeycode(wglobal.dpy, key);
 179         binding.act=ACT_KEYPRESS;
 180         binding.nargs=0;
 181         binding.submap=NULL;
 182
 183         add_binding(bindmap, &binding);
 184 }
 185
 186
 187 void init_bindings()
 188 {
 189         modmap=XGetModifierMapping(wglobal.dpy);
 190
 191         assert(modmap!=NULL);
 192
 193         init_bindmap(&(wglobal.main_bindmap));
 194         init_bindmap(&(wglobal.tab_bindmap));
 195         init_bindmap(&(wglobal.input_bindmap));
 196         init_bindmap(&(wglobal.moveres_bindmap));
 197
 198         /* There must be a way to get out of resize mode */
 199         bind_simple(&(wglobal.moveres_bindmap), FUNTAB_MOVERES,
 200                                 0, XK_Escape, "cancel_resize");
 201
 202 #ifdef CF_HACK_IGNORE_EVIL_LOCKS
 203         lookup_evil_locks();
 204 #endif
 205 }
 206
 207
 208 void update_modmap()
 209 {
 210         XModifierKeymap *nm=XGetModifierMapping(wglobal.dpy);
 211
 212         if(nm!=NULL){
 213                 XFreeModifiermap(modmap);
 214                 modmap=nm;
 215         }
 216 }
 217
 218
 219 /* */
 220
 221
 222 void grab_bindings(WBindmap *bindmap, Window win)
 223 {
 224         WBinding *binding=bindmap->bindings;
 225         int i;
 226
 227         for(i=0; i<bindmap->nbindings; i++, binding++){
 228                 if(binding->act==ACT_KEYPRESS){
 229 #ifndef CF_HACK_IGNORE_EVIL_LOCKS
 230                         XGrabKey(wglobal.dpy, binding->kcb, binding->state, win, True,
 231                                          GrabModeAsync, GrabModeAsync);
 232 #else
 233                         evil_grab_key(wglobal.dpy, binding->kcb, binding->state, win, True,
 234                                                   GrabModeAsync, GrabModeAsync);
 235 #endif
 236                 }
 237
 238                 if(binding->act!=ACT_BUTTONPRESS && binding->act!=ACT_BUTTONCLICK &&
 239                    binding->act!=ACT_BUTTONDBLCLICK && binding->act!=ACT_BUTTONMOTION)
 240                         continue;
 241
 242                 if(binding->state==0)
 243                         continue;
 244
 245 #ifndef CF_HACK_IGNORE_EVIL_LOCKS
 246                 XGrabButton(wglobal.dpy, binding->kcb, binding->state, win, True,
 247                                         GRAB_POINTER_MASK, GrabModeAsync, GrabModeAsync,
 248                                         None, None);
 249 #else
 250                 evil_grab_button(wglobal.dpy, binding->kcb, binding->state, win, True,
 251                                                  GRAB_POINTER_MASK, GrabModeAsync, GrabModeAsync,
 252                                                  None, None);
 253 #endif
 254
 255         }
 256 }
 257
 258
 259 /* */
 260
 261
 262 static WBinding *search_binding(WBindmap *bindmap, WBinding *binding)
 263 {
 264         if(bindmap->bindings==NULL || bindmap->nbindings==0)
 265                 return NULL;
 266
 267         return (WBinding*)bsearch((void*)binding, (void*)(bindmap->bindings),
 268                                                           bindmap->nbindings, sizeof(WBinding),
 269                                                           compare_bindings);
 270 }
 271
 272
 273 WBinding *lookup_binding(WBindmap *bindmap, int act, uint state, uint kcb)
 274 {
 275         WBinding *binding, tmp;
 276
 277 #ifdef CF_HACK_IGNORE_EVIL_LOCKS
 278         state&=~evilignoremask;
 279 #endif
 280
 281         tmp.act=act;
 282         tmp.kcb=kcb;
 283         tmp.state=state;
 284
 285         binding=search_binding(bindmap, &tmp);
 286
 287         if(binding==NULL){
 288                 tmp.state=AnyModifier;
 289                 binding=search_binding(bindmap, &tmp);
 290
 291                 if(binding==NULL){
 292                         tmp.state=state;
 293                         tmp.kcb=(act==ACT_KEYPRESS ? AnyKey : AnyButton);
 294                         binding=search_binding(bindmap, &tmp);
 295
 296                         if(binding==NULL){
 297                                 tmp.state=AnyModifier;
 298                                 binding=search_binding(bindmap, &tmp);
 299                         }
 300                 }
 301         }
 302
 303         return binding;
 304 }
 305
 306
 307 void call_binding(WBinding *binding, WThing *thing)
 308 {
 309         if(binding->func==NULL)
 310                 return;
 311
 312         if(binding->func->callhnd==NULL)
 313                 return;
 314
 315         binding->func->callhnd(thing, binding->func,
 316                                                    binding->nargs, binding->args);
 317 }
 318
 319
 320 /*
 321  * A dirty hack to deal with (==ignore) evil locking modifier keys.
 322  */
 323
 324
 325 int unmod(int state, int keycode)
 326 {
 327         int j;
 328
 329 #ifdef CF_HACK_IGNORE_EVIL_LOCKS
 330         state&=~evilignoremask;
 331 #endif
 332
 333         for(j=0; j<N_MODS*modmap->max_keypermod; j++){
 334                 if(modmap->modifiermap[j]==keycode)
 335                         return state&~modmasks[j/modmap->max_keypermod];
 336         }
 337
 338         return state;
 339 }
 340
 341
 342 bool ismod(int keycode)
 343 {
 344         int j;
 345
 346         for(j=0; j<N_MODS*modmap->max_keypermod; j++){
 347                 if(modmap->modifiermap[j]==keycode)
 348                         return TRUE;
 349         }
 350
 351         return FALSE;
 352 }
 353
 354
 355 #ifdef CF_HACK_IGNORE_EVIL_LOCKS
 356
 357 static void lookup_evil_locks()
 358 {
 359         uint keycodes[N_LOOKUPEVIL];
 360         int i, j;
 361
 362         for(i=0; i<N_LOOKUPEVIL; i++)
 363                 keycodes[i]=XKeysymToKeycode(wglobal.dpy, evillocks[i]);
 364
 365         for(j=0; j<N_MODS*modmap->max_keypermod; j++){
 366                 for(i=0; i<N_LOOKUPEVIL; i++){
 367                         if(keycodes[i]==None)
 368                                 continue;
 369                         if(modmap->modifiermap[j]==keycodes[i]){
 370                                 evillockmasks[i]=modmasks[j/modmap->max_keypermod];
 371                                 evilignoremask|=evillockmasks[i];
 372                         }
 373                 }
 374         }
 375 }
 376
 377
 378 static void evil_grab_key(Display *display, uint keycode, uint modifiers,
 379                                                   Window grab_window, bool owner_events,
 380                                                   int pointer_mode, int keyboard_mode)
 381 {
 382         uint mods;
 383         int i, j;
 384
 385         XGrabKey(display, keycode, modifiers, grab_window, owner_events,
 386                          pointer_mode, keyboard_mode);
 387
 388         for(i=0; i<N_EVILLOCKS; i++){
 389                 if(evillockmasks[i]==0)
 390                         continue;
 391                 mods=modifiers;
 392                 for(j=i; j<N_EVILLOCKS; j++){
 393                         if(evillockmasks[j]==0)
 394                                 continue;
 395                         mods|=evillockmasks[j];
 396                         XGrabKey(display, keycode, mods,
 397                                          grab_window, owner_events, pointer_mode, keyboard_mode);
 398                         if(i==j)
 399                                 continue;
 400                         XGrabKey(display, keycode,
 401                                          modifiers|evillockmasks[i]|evillockmasks[j],
 402                                          grab_window, owner_events, pointer_mode, keyboard_mode);
 403                 }
 404         }
 405 }
 406
 407
 408 static void evil_grab_button(Display *display, uint button, uint modifiers,
 409                                                          Window grab_window, bool owner_events,
 410                                                          uint event_mask, int pointer_mode,
 411                                                          int keyboard_mode, Window confine_to,
 412                                                          Cursor cursor)
 413 {
 414         uint mods;
 415         int i, j;
 416
 417         XGrabButton(display, button, modifiers,
 418                                 grab_window, owner_events, event_mask, pointer_mode,
 419                                 keyboard_mode, confine_to, cursor);
 420
 421         for(i=0; i<N_EVILLOCKS; i++){
 422                 if(evillockmasks[i]==0)
 423                         continue;
 424                 mods=modifiers;
 425                 for(j=i; j<N_EVILLOCKS; j++){
 426                         if(evillockmasks[j]==0)
 427                                 continue;
 428                         mods|=evillockmasks[j];
 429                         XGrabButton(display, button, mods,
 430                                                 grab_window, owner_events, event_mask, pointer_mode,
 431                                                 keyboard_mode, confine_to, cursor);
 432                         if(i==j)
 433                                 continue;
 434                         XGrabButton(display, button,
 435                                                 modifiers|evillockmasks[i]|evillockmasks[j],
 436                                                 grab_window, owner_events, event_mask, pointer_mode,
 437                                                 keyboard_mode, confine_to, cursor);
 438                 }
 439         }
 440 }
 441
 442 #endif /* CF_HACK_IGNORE_EVIL_LOCKS */
 443