ioncore/conf-bindings.c

   1 /*
   2  * ion/ioncore/conf-bindings.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2009.
   5  *
   6  * See the included file LICENSE for details.
   7  */
   8
   9 #include <string.h>
  10
  11 #define XK_MISCELLANY
  12 #include <X11/keysymdef.h>
  13
  14 #ifdef CF_SUN_F1X_REMAP
  15 #include <X11/Sunkeysym.h>
  16 #endif
  17
  18 #include <libtu/map.h>
  19
  20 #include "common.h"
  21 #include "binding.h"
  22 #include <libextl/readconfig.h>
  23 #include "global.h"
  24 #include <libextl/extl.h>
  25 #include "conf-bindings.h"
  26 #include "bindmaps.h"
  27 #include "ioncore.h"
  28
  29
  30 /*{{{ parse_keybut */
  31
  32
  33 #define MOD5_NDX 7
  34
  35 static StringIntMap state_map[]={
  36     {"Shift",       ShiftMask},
  37     {"Lock",        LockMask},
  38     {"Control",     ControlMask},
  39     {"Mod1",        Mod1Mask},
  40     {"Mod2",        Mod2Mask},
  41     {"Mod3",        Mod3Mask},
  42     {"Mod4",        Mod4Mask},
  43     {"Mod5",        Mod5Mask},
  44     {"AnyModifier", AnyModifier},
  45     {"NoModifier",  0},
  46     {NULL,          0},
  47 };
  48
  49 static StringIntMap button_map[]={
  50     {"Button1",     Button1},
  51     {"Button2",     Button2},
  52     {"Button3",     Button3},
  53     {"Button4",     Button4},
  54     {"Button5",     Button5},
  55     {"Button6",     6},
  56     {"Button7",     7},
  57     {"AnyButton",   AnyButton},
  58     {NULL,          0},
  59 };
  60
  61
  62 bool ioncore_parse_keybut(const char *str, uint *mod_ret, uint *ksb_ret,
  63                           bool button, bool init_any)
  64 {
  65     char *str2, *p, *p2;
  66     int keysym=NoSymbol, i;
  67     bool ret=FALSE;
  68
  69     *ksb_ret=NoSymbol;
  70     *mod_ret=(init_any && !button ? AnyModifier : 0);
  71
  72     str2=scopy(str);
  73
  74     if(str2==NULL)
  75         return FALSE;
  76
  77     p=str2;
  78
  79     while(*p!='\0'){
  80         p2=strchr(p, '+');
  81
  82         if(p2!=NULL)
  83             *p2='\0';
  84
  85         if(!button){
  86             keysym=XStringToKeysym(p);
  87 #ifdef CF_SUN_F1X_REMAP
  88             if(keysym==XK_F11)
  89                 keysym=SunXK_F36;
  90             else if(keysym==XK_F12)
  91                 keysym=SunXK_F37;
  92 #endif
  93         }
  94
  95         if(!button && keysym!=NoSymbol){
  96             int tmp;
  97             if(*ksb_ret!=NoSymbol){
  98                 warn_obj(str, TR("Insane key combination."));
  99                 break;
 100             }
 101             if(XKeysymToKeycode(ioncore_g.dpy, keysym)==0){
 102                 ioncore_warn_nolog("%s: %s", str,
 103                                    TR("Could not convert keysym to keycode."));
 104                 break;
 105             }
 106             *ksb_ret=keysym;
 107         }else{
 108             i=stringintmap_ndx(state_map, p);
 109
 110             if(i<0){
 111                 i=stringintmap_ndx(button_map, p);
 112
 113                 if(i<0){
 114                     warn(TR("Unknown button \"%s\"."), p);
 115                     break;
 116                 }
 117
 118                 if(!button || *ksb_ret!=NoSymbol){
 119                     warn_obj(str, TR("Insane button combination."));
 120                     break;
 121                 }
 122                 *ksb_ret=button_map[i].value;
 123             }else{
 124                 if(*mod_ret==AnyModifier){
 125                     if(!init_any){
 126                         warn_obj(str, TR("Insane modifier combination."));
 127                         break;
 128                     }else{
 129                         *mod_ret=state_map[i].value;
 130                     }
 131                 }else{
 132                     if(*mod_ret!=0 && state_map[i].value==AnyModifier){
 133                         warn_obj(str, TR("Insane modifier combination."));
 134                         break;
 135                     }else{
 136                         *mod_ret|=state_map[i].value;
 137                     }
 138                 }
 139             }
 140         }
 141
 142         if(p2==NULL){
 143             ret=TRUE;
 144             break;
 145         }
 146
 147         p=p2+1;
 148     }
 149
 150     free(str2);
 151
 152     return ret;
 153 }
 154
 155 #undef BUTTON1_NDX
 156
 157
 158 /*}}}*/
 159
 160
 161 /*{{{ bindmap_defbindings */
 162
 163
 164 static bool do_action(WBindmap *bindmap, const char *str,
 165                       ExtlFn func, uint act, uint mod, uint ksb,
 166                       int area, bool wr)
 167 {
 168     WBinding binding;
 169
 170     if(wr && mod==0){
 171         warn(TR("Can not wait on modifiers when no modifiers set in \"%s\"."),
 172              str);
 173         wr=FALSE;
 174     }
 175
 176     binding.wait=wr;
 177     binding.act=act;
 178     binding.state=mod;
 179     binding.ksb=ksb;
 180     binding.kcb=(act==BINDING_KEYPRESS ? XKeysymToKeycode(ioncore_g.dpy, ksb) : ksb);
 181     binding.area=area;
 182     binding.submap=NULL;
 183
 184     if(func!=extl_fn_none()){
 185         binding.func=extl_ref_fn(func);
 186         if(bindmap_add_binding(bindmap, &binding))
 187             return TRUE;
 188         extl_unref_fn(binding.func);
 189         warn(TR("Unable to add binding %s."), str);
 190     }else{
 191         binding.func=func;
 192         if(bindmap_remove_binding(bindmap, &binding))
 193             return TRUE;
 194         /*warn(TR("Unable to remove binding %s."), str);*/
 195     }
 196
 197     return FALSE;
 198 }
 199
 200
 201 static bool do_submap(WBindmap *bindmap, const char *str,
 202                       ExtlTab subtab, uint action, uint mod, uint ksb)
 203 {
 204     WBinding binding, *bnd;
 205     uint kcb=0;
 206
 207     if(action!=BINDING_KEYPRESS)
 208         return FALSE;
 209
 210     kcb=XKeysymToKeycode(ioncore_g.dpy, ksb);
 211
 212     bnd=bindmap_lookup_binding(bindmap, action, mod, kcb);
 213
 214     if(bnd!=NULL && bnd->submap!=NULL && bnd->state==mod)
 215         return bindmap_defbindings(bnd->submap, subtab, TRUE);
 216
 217     binding.wait=FALSE;
 218     binding.act=BINDING_KEYPRESS;
 219     binding.state=mod;
 220     binding.ksb=ksb;
 221     binding.kcb=kcb;
 222     binding.area=0;
 223     binding.func=extl_fn_none();
 224     binding.submap=create_bindmap();
 225
 226     if(binding.submap==NULL)
 227         return FALSE;
 228
 229     if(bindmap_add_binding(bindmap, &binding))
 230         return bindmap_defbindings(binding.submap, subtab, TRUE);
 231
 232     binding_deinit(&binding);
 233
 234     warn(TR("Unable to add submap for binding %s."), str);
 235
 236     return FALSE;
 237 }
 238
 239
 240 static StringIntMap action_map[]={
 241     {"kpress", BINDING_KEYPRESS},
 242     {"mpress", BINDING_BUTTONPRESS},
 243     {"mclick", BINDING_BUTTONCLICK},
 244     {"mdblclick", BINDING_BUTTONDBLCLICK},
 245     {"mdrag", BINDING_BUTTONMOTION},
 246     {"submap_enter", BINDING_SUBMAP_ENTER},
 247     {"submap_wait", BINDING_SUBMAP_RELEASEMOD},
 248     /*{"submap_leave", BINDING_SUBMAP_LEAVE},*/
 249     {NULL, 0}
 250 };
 251
 252
 253 static bool do_entry(WBindmap *bindmap, ExtlTab tab,
 254                      const StringIntMap *areamap, bool init_any)
 255 {
 256     bool ret=FALSE;
 257     char *action_str=NULL, *ksb_str=NULL, *area_str=NULL;
 258     int action=0;
 259     uint ksb=0, mod=0;
 260     WBinding *bnd=NULL;
 261     ExtlTab subtab;
 262     ExtlFn func;
 263     bool wr=FALSE;
 264     int area=0;
 265
 266     if(!extl_table_gets_s(tab, "action", &action_str)){
 267         warn(TR("Binding type not set."));
 268         goto fail;
 269     }
 270
 271     if(strcmp(action_str, "kpress_wait")==0){
 272         action=BINDING_KEYPRESS;
 273         wr=TRUE;
 274     }else{
 275         action=stringintmap_value(action_map, action_str, -1);
 276         if(action<0){
 277             warn(TR("Unknown binding type \"%s\"."), action_str);
 278             goto fail;
 279         }
 280     }
 281
 282     if(!BINDING_IS_PSEUDO(action)){
 283         if(!extl_table_gets_s(tab, "kcb", &ksb_str))
 284             goto fail;
 285
 286         if(!ioncore_parse_keybut(ksb_str, &mod, &ksb,
 287                                  (action!=BINDING_KEYPRESS && action!=-1),
 288                                  init_any)){
 289             goto fail;
 290         }
 291     }
 292
 293     if(extl_table_gets_t(tab, "submap", &subtab)){
 294         ret=do_submap(bindmap, ksb_str, subtab, action, mod, ksb);
 295         extl_unref_table(subtab);
 296     }else{
 297         if(areamap!=NULL){
 298             if(extl_table_gets_s(tab, "area", &area_str)){
 299                 area=stringintmap_value(areamap, area_str, -1);
 300                 if(area<0){
 301                     warn(TR("Unknown area \"%s\" for binding %s."),
 302                          area_str, ksb_str);
 303                     area=0;
 304                 }
 305             }
 306         }
 307
 308         if(!extl_table_gets_f(tab, "func", &func)){
 309             /*warn("Function for binding %s not set/nil/undefined.", ksb_str);
 310             goto fail;*/
 311             func=extl_fn_none();
 312         }
 313         ret=do_action(bindmap, ksb_str, func, action, mod, ksb, area, wr);
 314         if(!ret)
 315             extl_unref_fn(func);
 316     }
 317
 318 fail:
 319     if(action_str!=NULL)
 320         free(action_str);
 321     if(ksb_str!=NULL)
 322         free(ksb_str);
 323     if(area_str!=NULL)
 324         free(area_str);
 325     return ret;
 326 }
 327
 328
 329 bool bindmap_defbindings(WBindmap *bindmap, ExtlTab tab, bool submap)
 330 {
 331     int i, n, nok=0;
 332     ExtlTab ent;
 333
 334     n=extl_table_get_n(tab);
 335
 336     for(i=1; i<=n; i++){
 337         if(extl_table_geti_t(tab, i, &ent)){
 338             nok+=do_entry(bindmap, ent, bindmap->areamap, submap);
 339             extl_unref_table(ent);
 340             continue;
 341         }
 342         warn(TR("Unable to get bindmap entry %d."), i);
 343     }
 344     return (nok!=0);
 345 }
 346
 347
 348 /*}}}*/
 349
 350
 351 /*{{{ bindmap_getbindings */
 352
 353
 354 static char *get_mods(uint state)
 355 {
 356     char *ret=NULL;
 357     int i;
 358
 359     if(state==AnyModifier){
 360         ret=scopy("AnyModifier+");
 361     }else{
 362         ret=scopy("");
 363         for(i=0; i<=MOD5_NDX; i++){
 364             if(ret==NULL)
 365                 break;
 366             if((int)(state&state_map[i].value)==state_map[i].value){
 367                 char *ret2=ret;
 368                 ret=scat3(ret, state_map[i].string, "+");
 369                 free(ret2);
 370             }
 371         }
 372     }
 373
 374     return ret;
 375 }
 376
 377
 378 static char *get_key(char *mods, uint ksb)
 379 {
 380     const char *s=XKeysymToString(ksb);
 381     char *ret=NULL;
 382
 383     if(s==NULL){
 384         warn(TR("Unable to convert keysym to string."));
 385         return NULL;
 386     }
 387
 388     return scat(mods, s);
 389 }
 390
 391
 392 static char *get_button(char *mods, uint ksb)
 393 {
 394     const char *s=stringintmap_key(button_map, ksb, NULL);
 395     char *ret=NULL;
 396
 397     if(s==NULL){
 398         warn(TR("Unable to convert button to string."));
 399         return NULL;
 400     }
 401
 402     return scat(mods, s);
 403 }
 404
 405
 406 static bool get_kpress(WBindmap *bindmap, WBinding *b, ExtlTab t)
 407 {
 408     char *mods;
 409     char *key;
 410
 411     if(b->wait)
 412         extl_table_sets_s(t, "action", "kpress_wait");
 413     else
 414         extl_table_sets_s(t, "action", "kpress");
 415
 416     mods=get_mods(b->state);
 417
 418     if(mods==NULL)
 419         return FALSE;
 420
 421     key=get_key(mods, b->ksb);
 422
 423     free(mods);
 424
 425     if(key==NULL)
 426         return FALSE;
 427
 428     extl_table_sets_s(t, "kcb", key);
 429
 430     free(key);
 431
 432     if(b->submap!=NULL){
 433         ExtlTab stab=bindmap_getbindings(b->submap);
 434         extl_table_sets_t(t, "submap", stab);
 435     }else{
 436         extl_table_sets_f(t, "func", b->func);
 437     }
 438
 439     return TRUE;
 440 }
 441
 442
 443 static bool get_mact(WBindmap *bindmap, WBinding *b, ExtlTab t)
 444 {
 445     char *mods;
 446     char *button;
 447
 448     extl_table_sets_s(t, "action", stringintmap_key(action_map, b->act, NULL));
 449
 450     mods=get_mods(b->state);
 451
 452     if(mods==NULL)
 453         return FALSE;
 454
 455     button=get_button(mods, b->ksb);
 456
 457     free(mods);
 458
 459     if(button==NULL)
 460         return FALSE;
 461
 462     extl_table_sets_s(t, "kcb", button);
 463
 464     free(button);
 465
 466     if(b->area!=0 && bindmap->areamap!=NULL)
 467         extl_table_sets_s(t, "area",
 468                           stringintmap_key(bindmap->areamap, b->area, NULL));
 469
 470     extl_table_sets_f(t, "func", b->func);
 471
 472     return TRUE;
 473 }
 474
 475
 476 static ExtlTab getbinding(WBindmap *bindmap, WBinding *b)
 477 {
 478     ExtlTab t=extl_create_table();
 479
 480     if(b->act==BINDING_KEYPRESS){
 481         if(get_kpress(bindmap, b, t))
 482             return t;
 483     }else{
 484         if(get_mact(bindmap, b, t))
 485             return t;
 486     }
 487
 488     return extl_unref_table(t);
 489 }
 490
 491
 492 ExtlTab bindmap_getbindings(WBindmap *bindmap)
 493 {
 494     Rb_node node;
 495     WBinding *b;
 496     ExtlTab tab;
 497     ExtlTab btab;
 498     int n=0;
 499
 500     tab=extl_create_table();
 501
 502     FOR_ALL_BINDINGS(b, node, bindmap->bindings){
 503         btab=getbinding(bindmap, b);
 504         extl_table_seti_t(tab, n+1, btab);
 505         extl_unref_table(btab);
 506         n++;
 507     }
 508
 509     return tab;
 510 }
 511
 512
 513 /*}}}*/
 514