… | |
… | |
36 | }; |
36 | }; |
37 | |
37 | |
38 | static void |
38 | static void |
39 | output_string (rxvt_term *rt, const char *str) |
39 | output_string (rxvt_term *rt, const char *str) |
40 | { |
40 | { |
41 | assert (rt && str); |
|
|
42 | |
|
|
43 | if (strncmp (str, "proto:", 6) == 0) |
41 | if (strncmp (str, "proto:", 6) == 0) |
44 | rt->cmd_write ((unsigned char *)str + 6, strlen (str) - 6); |
42 | rt->cmd_write ((unsigned char *)str + 6, strlen (str) - 6); |
45 | else |
43 | else |
46 | rt->tt_write ((unsigned char *)str, strlen (str)); |
44 | rt->tt_write ((unsigned char *)str, strlen (str)); |
47 | } |
45 | } |
… | |
… | |
101 | |
99 | |
102 | // return: priority_of_a - priority_of_b |
100 | // return: priority_of_a - priority_of_b |
103 | static int |
101 | static int |
104 | compare_priority (keysym_t *a, keysym_t *b) |
102 | compare_priority (keysym_t *a, keysym_t *b) |
105 | { |
103 | { |
106 | assert (a && b); |
|
|
107 | |
|
|
108 | // (the more '1's in state; the less range): the greater priority |
104 | // (the more '1's in state; the less range): the greater priority |
109 | int ca = bitcount (a->state /* & OtherModMask */); |
105 | int ca = bitcount (a->state /* & OtherModMask */); |
110 | int cb = bitcount (b->state /* & OtherModMask */); |
106 | int cb = bitcount (b->state /* & OtherModMask */); |
111 | |
107 | |
112 | if (ca != cb) |
108 | if (ca != cb) |
… | |
… | |
157 | // the string 'trans' is copied to an internal managed buffer, |
153 | // the string 'trans' is copied to an internal managed buffer, |
158 | // so the caller can free memory of 'trans' at any time. |
154 | // so the caller can free memory of 'trans' at any time. |
159 | void |
155 | void |
160 | keyboard_manager::register_user_translation (KeySym keysym, unsigned int state, const char *trans) |
156 | keyboard_manager::register_user_translation (KeySym keysym, unsigned int state, const char *trans) |
161 | { |
157 | { |
162 | assert (trans); |
|
|
163 | |
|
|
164 | keysym_t *key = new keysym_t; |
158 | keysym_t *key = new keysym_t; |
165 | wchar_t *wc = rxvt_mbstowcs (trans); |
159 | wchar_t *wc = rxvt_mbstowcs (trans); |
166 | printf ("CONV <%s> %x %x %x %x\n", trans, (int)wc[0], (int)wc[1], (int)wc[2], (int)wc[3]); |
|
|
167 | const char *translation = rxvt_wcstoutf8 (wc); |
160 | const char *translation = rxvt_wcstoutf8 (wc); |
168 | free (wc); |
161 | free (wc); |
169 | |
162 | |
170 | if (key && translation) |
163 | if (key && translation) |
171 | { |
164 | { |
… | |
… | |
204 | } |
197 | } |
205 | |
198 | |
206 | void |
199 | void |
207 | keyboard_manager::register_keymap (keysym_t *key) |
200 | keyboard_manager::register_keymap (keysym_t *key) |
208 | { |
201 | { |
209 | assert (key); |
|
|
210 | assert (key->range >= 1); |
|
|
211 | |
|
|
212 | if (keymap.size () == keymap.capacity ()) |
202 | if (keymap.size () == keymap.capacity ()) |
213 | keymap.reserve (keymap.size () * 2); |
203 | keymap.reserve (keymap.size () * 2); |
214 | |
204 | |
215 | keymap.push_back (key); |
205 | keymap.push_back (key); |
216 | hash[0] = 3; |
206 | hash[0] = 3; |
… | |
… | |
347 | memset (hash_budget_counter, 0, sizeof (hash_budget_counter)); |
337 | memset (hash_budget_counter, 0, sizeof (hash_budget_counter)); |
348 | |
338 | |
349 | // count keysyms for corresponding hash budgets |
339 | // count keysyms for corresponding hash budgets |
350 | for (i = 0; i < keymap.size (); ++i) |
340 | for (i = 0; i < keymap.size (); ++i) |
351 | { |
341 | { |
352 | assert (keymap [i]); |
|
|
353 | hashkey = (keymap [i]->keysym & KEYSYM_HASH_MASK); |
342 | hashkey = keymap [i]->keysym & KEYSYM_HASH_MASK; |
354 | ++hash_budget_size [hashkey]; |
343 | ++hash_budget_size [hashkey]; |
355 | } |
344 | } |
356 | |
345 | |
357 | // keysym A with range>1 is counted one more time for |
346 | // a keysym_t with range>1 is counted one more time for every keysym that |
358 | // every keysym B lies in its range |
347 | // lies in its range |
359 | for (i = 0; i < keymap.size (); ++i) |
348 | for (i = 0; i < keymap.size (); ++i) |
360 | { |
349 | { |
361 | if (keymap[i]->range > 1) |
350 | if (keymap[i]->range > 1) |
362 | { |
351 | { |
363 | for (int j = min (keymap [i]->range, KEYSYM_HASH_BUDGETS) - 1; j > 0; --j) |
352 | for (int j = min (keymap [i]->range, KEYSYM_HASH_BUDGETS) - 1; j > 0; --j) |
… | |
… | |
449 | unsigned int index = hash [hashkey]; |
438 | unsigned int index = hash [hashkey]; |
450 | |
439 | |
451 | for (; index < keymap.size (); ++index) |
440 | for (; index < keymap.size (); ++index) |
452 | { |
441 | { |
453 | keysym_t *key = keymap [index]; |
442 | keysym_t *key = keymap [index]; |
454 | assert (key); |
|
|
455 | |
443 | |
456 | if (key->keysym <= keysym && key->keysym + key->range > keysym |
444 | if (key->keysym <= keysym && key->keysym + key->range > keysym |
457 | // match only the specified bits in state and ignore others |
445 | // match only the specified bits in state and ignore others |
458 | && (key->state & state) == key->state) |
446 | && (key->state & state) == key->state) |
459 | return index; |
447 | return index; |