src/keyboard.C

   1 #include "../config.h"
   2 #include "rxvt.h"
   3 #include "keyboard.h"
   4 #include "command.h"
   5 #include <string.h>
   6 #include <X11/X.h>
   7
   8 #ifdef KEYSYM_RESOURCE
   9
  10 ////////////////////////////////////////////////////////////////////////////////
  11 // default keycode translation map and keyevent handlers
  12 keyevent_handler keysym_translator;
  13 keyevent_handler keyrange_translator;
  14 keyevent_handler keyrange_translator_meta8;
  15 keyevent_handler keylist_translator;
  16
  17 keysym_t keyboard_manager::stock_keymap_[] =
  18 {
  19   /* examples */
  20   /*        keysym,                state, range,                   handler,             str*/
  21 //{XK_ISO_Left_Tab,                    0,     1,         keysym_translator,           "\033[Z"},
  22 //{            'a',                    0,    26, keyrange_translator_meta8,           "a" "%c"},
  23 //{            'a',          ControlMask,    26, keyrange_translator_meta8,          "\ 1" "%c"},
  24 //{        XK_Left,                    0,     4,        keylist_translator,   "DACBZ" "\033[Z"},
  25 //{        XK_Left,            ShiftMask,     4,        keylist_translator,   "dacbZ" "\033[Z"},
  26 //{        XK_Left,          ControlMask,     4,        keylist_translator,   "dacbZ" "\033OZ"},
  27 //{         XK_Tab,          ControlMask,     1,         keysym_translator,      "\033<C-Tab>"},
  28 //{  XK_apostrophe,          ControlMask,     1,         keysym_translator,        "\033<C-'>"},
  29 //{       XK_slash,          ControlMask,     1,         keysym_translator,        "\033<C-/>"},
  30 //{   XK_semicolon,          ControlMask,     1,         keysym_translator,        "\033<C-;>"},
  31 //{       XK_grave,          ControlMask,     1,         keysym_translator,        "\033<C-`>"},
  32 //{       XK_comma,          ControlMask,     1,         keysym_translator,     "\033<C-\054>"},
  33 //{      XK_Return,          ControlMask,     1,         keysym_translator,    "\033<C-Return>"},
  34 //{      XK_Return,            ShiftMask,     1,         keysym_translator,    "\033<S-Return>"},
  35 //{            ' ',            ShiftMask,     1,         keysym_translator,    "\033<S-Space>"},
  36 //{            '.',          ControlMask,     1,         keysym_translator,        "\033<C-.>"},
  37 //{            '0',          ControlMask,    10,       keyrange_translator,   "0" "\033<C-%c>"},
  38 //{            '0', MetaMask|ControlMask,    10,       keyrange_translator, "0" "\033<M-C-%c>"},
  39 //{            'a', MetaMask|ControlMask,    26,       keyrange_translator, "a" "\033<M-C-%c>"},
  40 };
  41
  42 void output_string (rxvt_term *rt,
  43                     const char *str)
  44 {
  45   assert (rt && str);
  46   if (strncmp (str, "proto:", 6) == 0)
  47     rt->cmd_write ((unsigned char*)str + 6, strlen (str) - 6);
  48   else
  49     rt->tt_write ((unsigned char*)str, strlen (str));
  50 }
  51
  52 void output_string_meta8 (rxvt_term *rt,
  53                           unsigned int state,
  54                           char buf[],
  55                           int buflen)
  56 {
  57   if (state & rt->ModMetaMask)
  58     {
  59 #ifdef META8_OPTION
  60       if(rt->meta_char == 0x80) /* set 8-bit on */
  61         {
  62           for (char *ch = buf; ch < buf + buflen; ch++)
  63             *ch |= 0x80;
  64         }
  65       else if(rt->meta_char == C0_ESC) /* escape prefix */
  66 #endif
  67         {
  68           const unsigned char ch = C0_ESC;
  69           rt->tt_write (&ch, 1);
  70         }
  71     }
  72
  73   rt->tt_write ((unsigned char*)buf, buflen);
  74 }
  75
  76 int format_keyrange_string (keysym_t *key,
  77                             KeySym keysym,
  78                             char buf[],
  79                             int bufsize)
  80 {
  81   int len;
  82
  83   assert (key->str);
  84   len = snprintf (buf, bufsize, key->str + 1,
  85                   keysym - key->keysym + (int)(key->str[0]));
  86   if (len >= bufsize)
  87     {
  88       fprintf (stderr, "buffer overflowed!\n");
  89       buf[bufsize-1] = '\0';
  90     }
  91   else if (len < 0)
  92     {
  93       perror("keyrange_translator()");
  94     }
  95
  96   return len;
  97 }
  98
  99 bool format_keylist_string (keysym_t *key,
 100                             KeySym keysym,
 101                             char buf[],
 102                             int bufsize)
 103 {
 104   char *p;
 105
 106   assert (key->str);
 107   strncpy (buf, key->str + key->range + 1, bufsize);
 108   buf[bufsize-1] = '\0';
 109
 110   p = strchr (buf, key->str[key->range]);
 111   if (p)
 112     {
 113       *p = key->str[keysym - key->keysym];
 114       return true;
 115     }
 116   else
 117     {
 118       fprintf (stderr, "invalid str for keylist_translator()!\n");
 119       return false;
 120     }
 121 }
 122
 123 /////////////////////////////////////////////////////////////////
 124 void keysym_translator (rxvt_term *rt,
 125                         keysym_t *key,
 126                         KeySym keysym,
 127                         unsigned int state)
 128 {
 129   output_string (rt, key->str);
 130 }
 131
 132 void keyrange_translator (rxvt_term *rt,
 133                           keysym_t *key,
 134                           KeySym keysym,
 135                           unsigned int state)
 136 {
 137   char buf[STRING_MAX];
 138
 139   if (format_keyrange_string (key, keysym, buf, sizeof(buf)) > 0)
 140     output_string (rt, buf);
 141 }
 142
 143 void keyrange_translator_meta8 (rxvt_term *rt,
 144                                 keysym_t *key,
 145                                 KeySym keysym,
 146                                 unsigned int state)
 147 {
 148   int len;
 149   char buf[STRING_MAX];
 150
 151   len = format_keyrange_string (key, keysym, buf, sizeof(buf));
 152   if (len > 0)
 153     output_string_meta8 (rt, state, buf, len);
 154 }
 155
 156 void keylist_translator (rxvt_term *rt,
 157                          keysym_t *key,
 158                          KeySym keysym,
 159                          unsigned int state)
 160 {
 161   char buf[STRING_MAX];
 162
 163   format_keylist_string (key, keysym, buf, sizeof(buf));
 164   output_string (rt, buf);
 165 }
 166
 167 ////////////////////////////////////////////////////////////////////////////////
 168 // return: #bits of '1'
 169 int
 170 bitcount (unsigned int n)
 171 {
 172   int i;
 173   for (i = 0; n; ++i, n &= (n - 1));
 174   return i;
 175 }
 176
 177 // return: priority_of_a - priority_of_b
 178 int
 179 compare_priority (keysym_t *a, keysym_t *b)
 180 {
 181   assert (a && b);
 182
 183   // (the more '1's in state; the less range): the greater priority
 184   int ca = bitcount (a->state/* & AllModMask*/);
 185   int cb = bitcount (b->state/* & AllModMask*/);
 186   if (ca != cb)
 187     return ca - cb;
 188 //else if (a->state != b->state) // this behavior is to be disscussed
 189 //  return b->state - a->state;
 190   else
 191     return b->range - a->range;
 192 }
 193
 194 ////////////////////////////////////////////////////////////////////////////////
 195 keyboard_manager::keyboard_manager (rxvt_term *rt)
 196   :term_(rt)
 197 {
 198   keymap_.reserve (256);
 199   hash_[0] = 1; // hash_[0] != 0 indicates uninitialized data
 200 }
 201
 202 keyboard_manager::~keyboard_manager ()
 203 {
 204   clear ();
 205 }
 206
 207 void
 208 keyboard_manager::clear ()
 209 {
 210   keymap_.clear ();
 211   hash_[0] = 2;
 212
 213   for(unsigned int i = 0;i < user_translations_.size();++i)
 214     {
 215       delete[] user_translations_[i];
 216       user_translations_[i] = 0;
 217     }
 218
 219   for(unsigned int i = 0;i < user_keymap_.size();++i)
 220     {
 221       delete user_keymap_[i];
 222       user_keymap_[i] = 0;
 223     }
 224
 225   user_keymap_.clear();
 226   user_translations_.clear();
 227 }
 228
 229 // a wrapper for register_keymap,
 230 // so that outside codes don't have to know so much details.
 231 //
 232 // the string 'trans' is copied to an internal managed buffer,
 233 // so the caller can free memory of 'trans' at any time.
 234 void
 235 keyboard_manager::register_user_translation (KeySym keysym,
 236                                              unsigned int state,
 237                                              const char *trans)
 238 {
 239   assert(trans);
 240
 241   keysym_t *key = new keysym_t;
 242   const char *translation = new char[1+strlen(trans)];
 243
 244   if(key && translation)
 245     {
 246       key->keysym = keysym;
 247       key->state = state;
 248       key->range = 1;
 249       key->str = translation;
 250
 251       if (strncmp (trans, "list", 4) == 0)
 252         {
 253           const char *p = &trans[4];
 254           if (*p && (p = strchr (p+1, *p)))
 255             if ((p - trans - 5 > 1) && strchr (p+1, *p))
 256               {
 257                 strcpy (translation, trans+5);
 258                 key->range = p - trans - 5;
 259                 key->handler = keylist_translator;
 260               }
 261         }
 262       if (key->range == 1)
 263         {
 264           strcpy (translation, trans);
 265           key->handler = keysym_translator;
 266         }
 267
 268       user_keymap_.push_back (key);
 269       user_translations_.push_back (translation);
 270       register_keymap (key);
 271     }
 272   else
 273     {
 274       delete key;
 275       delete[] translation;
 276       rxvt_fatal ("out of memory, aborting.\n");
 277     }
 278 }
 279
 280 void
 281 keyboard_manager::register_keymap (keysym_t *key)
 282 {
 283   assert (key);
 284   assert (key->handler);
 285   assert (key->range >= 1);
 286
 287   if (keymap_.size () == keymap_.capacity ())
 288     keymap_.reserve (keymap_.size () * 2);
 289
 290   keymap_.push_back (key);
 291   hash_[0] = 3;
 292 }
 293
 294 void
 295 keyboard_manager::register_done ()
 296 {
 297   unsigned int i, n = sizeof(stock_keymap_)/sizeof(keysym_t);
 298
 299   if(keymap_.back() != &stock_keymap_[n-1])
 300     for(i = 0;i < n;++i)
 301       register_keymap(&stock_keymap_[i]);
 302
 303   purge_duplicate_keymap ();
 304
 305   for (i = 0; i < keymap_.size(); ++i)
 306     {
 307       keysym_t *key = keymap_[i];
 308
 309       assert (bitcount (term_->ModMetaMask) == 1
 310               && "call me after ModMetaMask was set!");
 311       if (key->state & MetaMask)
 312         {
 313           //key->state &= ~MetaMask;
 314           key->state |= term_->ModMetaMask;
 315         }
 316
 317       assert (bitcount (term_->ModNumLockMask) == 1
 318               && "call me after ModNumLockMask was set!");
 319       if (key->state & NumLockMask)
 320         {
 321           //key->state &= ~NumLockMask;
 322           key->state |= term_->ModNumLockMask;
 323         }
 324     }
 325
 326   setup_hash ();
 327 }
 328
 329 bool keyboard_manager::dispatch (KeySym keysym, unsigned int state)
 330 {
 331   assert(hash_[0] == 0 && "register_done() need to be called");
 332
 333   int index = find_keysym (keysym, state);
 334
 335   if (index >= 0)
 336     {
 337       assert (term_ && keymap_[index] && keymap_[index]->handler);
 338       keymap_[index]->handler (term_, keymap_[index], keysym, state);
 339       return true;
 340     }
 341   else
 342   {
 343     // fprintf(stderr,"[%x:%x]",state,keysym);
 344     return false;
 345   }
 346 }
 347
 348 // purge duplicate keymap_ entries
 349 void
 350 keyboard_manager::purge_duplicate_keymap ()
 351 {
 352   for (unsigned int i = 0; i < keymap_.size (); ++i)
 353     {
 354       for (unsigned int j = 0; j < i; ++j)
 355         {
 356           if (keymap_[i] == keymap_[j])
 357             {
 358               while (keymap_[i] == keymap_.back ())
 359                 keymap_.pop_back ();
 360               if (i < keymap_.size ())
 361                 {
 362                   keymap_[i] = keymap_.back ();
 363                   keymap_.pop_back ();
 364                 }
 365               break;
 366             }
 367         }
 368     }
 369 }
 370
 371 void
 372 keyboard_manager::setup_hash ()
 373 {
 374   unsigned int i, index, hashkey;
 375   vector<keysym_t *> sorted_keymap;
 376   u16 hash_budget_size[KEYSYM_HASH_BUDGETS];     // size of each budget
 377   u16 hash_budget_counter[KEYSYM_HASH_BUDGETS];  // #elements in each budget
 378
 379   memset (hash_budget_size, 0, sizeof (hash_budget_size));
 380   memset (hash_budget_counter, 0, sizeof (hash_budget_counter));
 381
 382   // count keysyms for corresponding hash budgets
 383   for (i = 0; i < keymap_.size (); ++i)
 384     {
 385       assert (keymap_[i]);
 386       hashkey = (keymap_[i]->keysym & KEYSYM_HASH_MASK);
 387       ++hash_budget_size[hashkey];
 388     }
 389
 390   // keysym A with range>1 is counted one more time for
 391   // every keysym B lies in its range
 392   for (i = 0; i < keymap_.size (); ++i)
 393     {
 394       if (keymap_[i]->range > 1)
 395         {
 396           for (int j = min (keymap_[i]->range, KEYSYM_HASH_BUDGETS) - 1;j > 0; --j)
 397             {
 398               hashkey = ((keymap_[i]->keysym + j) & KEYSYM_HASH_MASK);
 399               if (hash_budget_size[hashkey])
 400                 ++hash_budget_size[hashkey];
 401             }
 402         }
 403     }
 404
 405   // now we know the size of each budget
 406   // compute the index of each budget
 407   hash_[0] = 0;
 408   for (index = 0,i = 1; i < KEYSYM_HASH_BUDGETS; ++i)
 409     {
 410       index += hash_budget_size[i-1];
 411       hash_[i] = (hash_budget_size[i] ? index : hash_[i-1]);
 412     }
 413   // and allocate just enough space
 414   //sorted_keymap.reserve (hash_[i - 1] + hash_budget_size[i - 1]);
 415   sorted_keymap.insert (sorted_keymap.begin(), index + hash_budget_size[i - 1], 0);
 416
 417   // fill in sorted_keymap
 418   // it is sorted in each budget
 419   for (i = 0; i < keymap_.size (); ++i)
 420     {
 421       for (int j = min (keymap_[i]->range, KEYSYM_HASH_BUDGETS) - 1;j >= 0; --j)
 422         {
 423           hashkey = ((keymap_[i]->keysym + j) & KEYSYM_HASH_MASK);
 424           if (hash_budget_size[hashkey])
 425             {
 426               index = hash_[hashkey] + hash_budget_counter[hashkey];
 427               while (index > hash_[hashkey] &&
 428                      compare_priority (keymap_[i],
 429                                        sorted_keymap[index - 1]) > 0)
 430                 {
 431                   sorted_keymap[index] = sorted_keymap[index - 1];
 432                   --index;
 433                 }
 434               sorted_keymap[index] = keymap_[i];
 435               ++hash_budget_counter[hashkey];
 436             }
 437         }
 438     }
 439
 440   keymap_.swap (sorted_keymap);
 441
 442 #if defined (DEBUG_STRICT) || defined (DEBUG_KEYBOARD)
 443   // check for invariants
 444   for (i = 0; i < KEYSYM_HASH_BUDGETS; ++i)
 445     {
 446       index = hash_[i];
 447       for (int j = 0; j < hash_budget_size[i]; ++j)
 448         {
 449           if (keymap_[index + j]->range == 1)
 450             assert (i == (keymap_[index + j]->keysym & KEYSYM_HASH_MASK));
 451           if (j)
 452             assert (compare_priority (keymap_[index + j - 1],
 453                                       keymap_[index + j]) >= 0);
 454         }
 455     }
 456
 457   // this should be able to detect most possible bugs
 458   for (i = 0; i < sorted_keymap.size (); ++i)
 459     {
 460       keysym_t *a = sorted_keymap[i];
 461       for (int j = 0; j < a->range; ++j)
 462         {
 463           int index = find_keysym (a->keysym + j, a->state & AllModMask);
 464           assert (index >= 0);
 465           keysym_t *b = keymap_[index];
 466           assert (i == (signed)index || // the normally expected result
 467               (a->keysym + j) >= b->keysym &&
 468               (a->keysym + j) <= (b->keysym + b->range) &&
 469               compare_priority (a, b) <= 0); // is effectively the same
 470         }
 471     }
 472 #endif
 473 }
 474
 475 int
 476 keyboard_manager::find_keysym (KeySym keysym, unsigned int state)
 477 {
 478   int hashkey = (keysym & KEYSYM_HASH_MASK);
 479   unsigned int index = hash_[hashkey];
 480
 481   for (;index < keymap_.size(); ++index)
 482     {
 483       keysym_t *key = keymap_[index];
 484       assert (key);
 485       if (key->keysym <= keysym &&
 486           key->keysym + key->range > keysym &&
 487           // match only the specified bits in state and ignore others
 488           (key->state & (unsigned int)AllModMask) == (key->state & state))
 489         {
 490           return index;
 491         }
 492       else if (key->keysym > keysym &&
 493                key->range == 1)
 494         return -1;
 495     }
 496
 497   return -1;
 498 }
 499
 500 #endif /* KEYSYM_RESOURCE */
 501 // vim:et:ts=2:sw=2