![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to keymaps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / ui|
Return to keymaps.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / ui |
1.1 root 1: /*
2: * QEMU keysym to keycode conversion using rdesktop keymaps
3: *
4: * Copyright (c) 2004 Johannes Schindelin
5: *
6: * Permission is hereby granted, free of charge, to any person obtaining a copy
7: * of this software and associated documentation files (the "Software"), to deal
8: * in the Software without restriction, including without limitation the rights
9: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10: * copies of the Software, and to permit persons to whom the Software is
11: * furnished to do so, subject to the following conditions:
12: *
13: * The above copyright notice and this permission notice shall be included in
14: * all copies or substantial portions of the Software.
15: *
16: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22: * THE SOFTWARE.
23: */
24:
25: #include "keymaps.h"
26: #include "sysemu.h"
27:
28: static int get_keysym(const name2keysym_t *table,
29: const char *name)
30: {
31: const name2keysym_t *p;
32: for(p = table; p->name != NULL; p++) {
33: if (!strcmp(p->name, name))
34: return p->keysym;
35: }
36: return 0;
37: }
38:
39:
40: static void add_to_key_range(struct key_range **krp, int code) {
41: struct key_range *kr;
42: for (kr = *krp; kr; kr = kr->next) {
43: if (code >= kr->start && code <= kr->end)
44: break;
45: if (code == kr->start - 1) {
46: kr->start--;
47: break;
48: }
49: if (code == kr->end + 1) {
50: kr->end++;
51: break;
52: }
53: }
54: if (kr == NULL) {
1.1.1.2 ! root 55: kr = g_malloc0(sizeof(*kr));
1.1 root 56: kr->start = kr->end = code;
57: kr->next = *krp;
58: *krp = kr;
59: }
60: }
61:
62: static void add_keysym(char *line, int keysym, int keycode, kbd_layout_t *k) {
63: if (keysym < MAX_NORMAL_KEYCODE) {
64: //fprintf(stderr,"Setting keysym %s (%d) to %d\n",line,keysym,keycode);
65: k->keysym2keycode[keysym] = keycode;
66: } else {
67: if (k->extra_count >= MAX_EXTRA_COUNT) {
68: fprintf(stderr,
69: "Warning: Could not assign keysym %s (0x%x) because of memory constraints.\n",
70: line, keysym);
71: } else {
72: #if 0
73: fprintf(stderr, "Setting %d: %d,%d\n",
74: k->extra_count, keysym, keycode);
75: #endif
76: k->keysym2keycode_extra[k->extra_count].
77: keysym = keysym;
78: k->keysym2keycode_extra[k->extra_count].
79: keycode = keycode;
80: k->extra_count++;
81: }
82: }
83: }
84:
85: static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table,
86: const char *language,
87: kbd_layout_t * k)
88: {
89: FILE *f;
90: char * filename;
91: char line[1024];
92: int len;
93:
94: filename = qemu_find_file(QEMU_FILE_TYPE_KEYMAP, language);
1.1.1.2 ! root 95: f = filename ? fopen(filename, "r") : NULL;
! 96: g_free(filename);
! 97: if (!f) {
1.1 root 98: fprintf(stderr,
99: "Could not read keymap file: '%s'\n", language);
100: return NULL;
101: }
1.1.1.2 ! root 102:
! 103: if (!k)
! 104: k = g_malloc0(sizeof(kbd_layout_t));
! 105:
1.1 root 106: for(;;) {
107: if (fgets(line, 1024, f) == NULL)
108: break;
109: len = strlen(line);
110: if (len > 0 && line[len - 1] == '\n')
111: line[len - 1] = '\0';
112: if (line[0] == '#')
113: continue;
114: if (!strncmp(line, "map ", 4))
115: continue;
116: if (!strncmp(line, "include ", 8)) {
117: parse_keyboard_layout(table, line + 8, k);
118: } else {
119: char *end_of_keysym = line;
120: while (*end_of_keysym != 0 && *end_of_keysym != ' ')
121: end_of_keysym++;
122: if (*end_of_keysym) {
123: int keysym;
124: *end_of_keysym = 0;
125: keysym = get_keysym(table, line);
126: if (keysym == 0) {
127: // fprintf(stderr, "Warning: unknown keysym %s\n", line);
128: } else {
129: const char *rest = end_of_keysym + 1;
130: char *rest2;
131: int keycode = strtol(rest, &rest2, 0);
132:
133: if (rest && strstr(rest, "numlock")) {
134: add_to_key_range(&k->keypad_range, keycode);
135: add_to_key_range(&k->numlock_range, keysym);
136: //fprintf(stderr, "keypad keysym %04x keycode %d\n", keysym, keycode);
137: }
138:
139: if (rest && strstr(rest, "shift"))
140: keycode |= SCANCODE_SHIFT;
141: if (rest && strstr(rest, "altgr"))
142: keycode |= SCANCODE_ALTGR;
143: if (rest && strstr(rest, "ctrl"))
144: keycode |= SCANCODE_CTRL;
145:
146: add_keysym(line, keysym, keycode, k);
147:
148: if (rest && strstr(rest, "addupper")) {
149: char *c;
150: for (c = line; *c; c++)
1.1.1.2 ! root 151: *c = qemu_toupper(*c);
1.1 root 152: keysym = get_keysym(table, line);
153: if (keysym)
154: add_keysym(line, keysym, keycode | SCANCODE_SHIFT, k);
155: }
156: }
157: }
158: }
159: }
160: fclose(f);
161: return k;
162: }
163:
164:
165: void *init_keyboard_layout(const name2keysym_t *table, const char *language)
166: {
167: return parse_keyboard_layout(table, language, NULL);
168: }
169:
170:
171: int keysym2scancode(void *kbd_layout, int keysym)
172: {
173: kbd_layout_t *k = kbd_layout;
174: if (keysym < MAX_NORMAL_KEYCODE) {
175: if (k->keysym2keycode[keysym] == 0)
176: fprintf(stderr, "Warning: no scancode found for keysym %d\n",
177: keysym);
178: return k->keysym2keycode[keysym];
179: } else {
180: int i;
181: #ifdef XK_ISO_Left_Tab
182: if (keysym == XK_ISO_Left_Tab)
183: keysym = XK_Tab;
184: #endif
185: for (i = 0; i < k->extra_count; i++)
186: if (k->keysym2keycode_extra[i].keysym == keysym)
187: return k->keysym2keycode_extra[i].keycode;
188: }
189: return 0;
190: }
191:
192: int keycode_is_keypad(void *kbd_layout, int keycode)
193: {
194: kbd_layout_t *k = kbd_layout;
195: struct key_range *kr;
196:
197: for (kr = k->keypad_range; kr; kr = kr->next)
198: if (keycode >= kr->start && keycode <= kr->end)
199: return 1;
200: return 0;
201: }
202:
203: int keysym_is_numlock(void *kbd_layout, int keysym)
204: {
205: kbd_layout_t *k = kbd_layout;
206: struct key_range *kr;
207:
208: for (kr = k->numlock_range; kr; kr = kr->next)
209: if (keysym >= kr->start && keysym <= kr->end)
210: return 1;
211: return 0;
212: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.