Subversion Repositories HelenOS

Rev

Rev 4344 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 4344 Rev 4346
Line 37... Line 37...
37 
 
 37 
 
38 
#include <kbd.h>
 38 
#include <kbd.h>
39 
#include <kbd/kbd.h>
 39 
#include <kbd/kbd.h>
40 
#include <kbd/keycode.h>
 40 
#include <kbd/keycode.h>
41 
#include <kbd_ctl.h>
 41 
#include <kbd_ctl.h>
- 
 
 42 
#include <gsp.h>
- 
 
 43 
#include <stroke.h>
42 
 
 44 
 
43 
static void parse_ds_start(int scancode);
 - 
 
44 
static void parse_ds_e(int scancode);
 - 
 
45 
static void parse_ds_e1(int scancode);
 - 
 
46 
static void parse_ds_e1a(int scancode);
 - 
 
47 
static void parse_ds_e1b(int scancode);
 - 
 
48 
static void parse_ds_e1c(int scancode);
 - 
 
49 
 
 - 
 
50 
static void parse_leaf(int scancode, int (*map)[2], size_t map_length);
 - 
 
51 
 
 - 
 
52 
enum dec_state {
 45 
/** Scancode parser */
53 
    ds_start,
 - 
 
54 
    ds_e,
 - 
 
55 
    ds_e1,
 - 
 
56 
    ds_e1a,
 - 
 
57 
    ds_e1b,
 - 
 
58 
    ds_e1c
 - 
 
59 
};
 - 
 
60 
 
 - 
 
61 
static int map_start[][2] = {
 46 
static gsp_t sp;
62 
 
 47 
 
63 
    [0x60] = { 0, KC_BACKTICK },
 48 
/** Current parser state */
- 
 
 49 
static int ds;
64 
 
 50 
 
65 
    [0x31] = { 0, KC_1 },
 51 
#include <stdio.h>
66 
    [0x32] = { 0, KC_2 },
 52 
 
67 
    [0x33] = { 0, KC_3 },
 53 
int seq_defs[] = {
68 
    [0x34] = { 0, KC_4 },
 54 
    /* Not shifted */
69 
    [0x35] = { 0, KC_5 },
 55 
 
70 
    [0x36] = { 0, KC_6 },
 56 
    0,  KC_BACKTICK,    0x60, GSP_END,
71 
    [0x37] = { 0, KC_7 },
 57 
 
72 
    [0x38] = { 0, KC_8 },
 58 
    0,  KC_1,       0x31, GSP_END,
73 
    [0x39] = { 0, KC_9 },
 59 
    0,  KC_2,       0x32, GSP_END,
74 
    [0x30] = { 0, KC_0 },
 60 
    0,  KC_3,       0x33, GSP_END,
75 
 
 61 
    0,  KC_4,       0x34, GSP_END,
76 
    [0x2d] = { 0, KC_MINUS },
 62 
    0,  KC_5,       0x35, GSP_END,
77 
    [0x3d] = { 0, KC_EQUALS },
 63 
    0,  KC_6,       0x36, GSP_END,
78 
    [0x08] = { 0, KC_BACKSPACE },
 64 
    0,  KC_7,       0x37, GSP_END,
79 
 
 65 
    0,  KC_8,       0x38, GSP_END,
80 
    [0x0f] = { 0, KC_TAB },
 66 
    0,  KC_9,       0x39, GSP_END,
81 
 
 67 
    0,  KC_0,       0x30, GSP_END,
82 
    [0x71] = { 0, KC_Q },
 68 
 
83 
    [0x77] = { 0, KC_W },
 69 
    0,  KC_MINUS,   0x2d, GSP_END,
84 
    [0x65] = { 0, KC_E },
 70 
    0,  KC_EQUALS,  0x3d, GSP_END,
85 
    [0x72] = { 0, KC_R },
 71 
    0,  KC_BACKSPACE,   0x08, GSP_END,
86 
    [0x74] = { 0, KC_T },
 72 
 
87 
    [0x79] = { 0, KC_Y },
 73 
    0,  KC_TAB,     0x09, GSP_END,
88 
    [0x75] = { 0, KC_U },
 74 
 
89 
    [0x69] = { 0, KC_I },
 75 
    0,  KC_Q,       0x71, GSP_END,
90 
    [0x6f] = { 0, KC_O },
 76 
    0,  KC_W,       0x77, GSP_END,
91 
    [0x70] = { 0, KC_P },
 77 
    0,  KC_E,       0x65, GSP_END,
92 
 
 78 
    0,  KC_R,       0x72, GSP_END,
93 
    [0x5b] = { 0, KC_LBRACKET },
 79 
    0,  KC_T,       0x74, GSP_END,
94 
    [0x5d] = { 0, KC_RBRACKET },
 80 
    0,  KC_Y,       0x79, GSP_END,
95 
 
 81 
    0,  KC_U,       0x75, GSP_END,
96 
    [0x61] = { 0, KC_A },
 82 
    0,  KC_I,       0x69, GSP_END,
97 
    [0x73] = { 0, KC_S },
 83 
    0,  KC_O,       0x6f, GSP_END,
98 
    [0x64] = { 0, KC_D },
 84 
    0,  KC_P,       0x70, GSP_END,
99 
    [0x66] = { 0, KC_F },
 85 
 
100 
    [0x67] = { 0, KC_G },
 86 
    0,  KC_LBRACKET,    0x5b, GSP_END,
101 
    [0x68] = { 0, KC_H },
 87 
    0,  KC_RBRACKET,    0x5d, GSP_END,
102 
    [0x6a] = { 0, KC_J },
 88 
 
103 
    [0x6b] = { 0, KC_K },
 89 
    0,  KC_A,       0x61, GSP_END,
104 
    [0x6c] = { 0, KC_L },
 90 
    0,  KC_S,       0x73, GSP_END,
105 
 
 91 
    0,  KC_D,       0x64, GSP_END,
106 
    [0x3b] = { 0, KC_SEMICOLON },
 92 
    0,  KC_F,       0x66, GSP_END,
107 
    [0x27] = { 0, KC_QUOTE },
 93 
    0,  KC_G,       0x67, GSP_END,
108 
    [0x5c] = { 0, KC_BACKSLASH },
 94 
    0,  KC_H,       0x68, GSP_END,
109 
 
 95 
    0,  KC_J,       0x6a, GSP_END,
110 
    [0x7a] = { 0, KC_Z },
 96 
    0,  KC_K,       0x6b, GSP_END,
111 
    [0x78] = { 0, KC_X },
 97 
    0,  KC_L,       0x6c, GSP_END,
112 
    [0x63] = { 0, KC_C },
 98 
 
113 
    [0x76] = { 0, KC_V },
 99 
    0,  KC_SEMICOLON,   0x3b, GSP_END,
114 
    [0x62] = { 0, KC_B },
 100 
    0,  KC_QUOTE,   0x27, GSP_END,
115 
    [0x6e] = { 0, KC_N },
 101 
    0,  KC_BACKSLASH,   0x5c, GSP_END,
116 
    [0x6d] = { 0, KC_M },
 102 
 
117 
 
 103 
    0,  KC_Z,       0x7a, GSP_END,
118 
    [0x2c] = { 0, KC_COMMA },
 104 
    0,  KC_X,       0x78, GSP_END,
119 
    [0x2e] = { 0, KC_PERIOD },
 105 
    0,  KC_C,       0x63, GSP_END,
120 
    [0x2f] = { 0, KC_SLASH },
 106 
    0,  KC_V,       0x76, GSP_END,
121 
 
 107 
    0,  KC_B,       0x62, GSP_END,
122 
    [0x20] = { 0, KC_SPACE },
 108 
    0,  KC_N,       0x6e, GSP_END,
123 
 
 109 
    0,  KC_M,       0x6d, GSP_END,
124 
    [0x1b] = { 0, KC_ESCAPE },
 110 
 
125 
 
 111 
    0,  KC_COMMA,   0x2c, GSP_END,
126 
    [0x0a] = { 0, KC_ENTER },
 112 
    0,  KC_PERIOD,  0x2e, GSP_END,
127 
    [0x0d] = { 0, KC_ENTER },
 113 
    0,  KC_SLASH,   0x2f, GSP_END,
128 
 
 114 
 
129 
    /* with Shift pressed */
 115 
    /* Shifted */
130 
 
 116 
 
131 
    [0x7e] = { KM_LSHIFT, KC_BACKTICK },
 117 
    KM_SHIFT,   KC_BACKTICK,    0x7e, GSP_END,
132 
 
 118 
 
133 
    [0x21] = { KM_LSHIFT, KC_1 },
 119 
    KM_SHIFT,   KC_1,       0x21, GSP_END,
134 
    [0x40] = { KM_LSHIFT, KC_2 },
 120 
    KM_SHIFT,   KC_2,       0x40, GSP_END,
135 
    [0x23] = { KM_LSHIFT, KC_3 },
 121 
    KM_SHIFT,   KC_3,       0x23, GSP_END,
136 
    [0x24] = { KM_LSHIFT, KC_4 },
 122 
    KM_SHIFT,   KC_4,       0x24, GSP_END,
137 
    [0x25] = { KM_LSHIFT, KC_5 },
 123 
    KM_SHIFT,   KC_5,       0x25, GSP_END,
138 
    [0x5e] = { KM_LSHIFT, KC_6 },
 124 
    KM_SHIFT,   KC_6,       0x5e, GSP_END,
139 
    [0x26] = { KM_LSHIFT, KC_7 },
 125 
    KM_SHIFT,   KC_7,       0x26, GSP_END,
140 
    [0x2a] = { KM_LSHIFT, KC_8 },
 126 
    KM_SHIFT,   KC_8,       0x2a, GSP_END,
141 
    [0x28] = { KM_LSHIFT, KC_9 },
 127 
    KM_SHIFT,   KC_9,       0x28, GSP_END,
142 
    [0x29] = { KM_LSHIFT, KC_0 },
 128 
    KM_SHIFT,   KC_0,       0x29, GSP_END,
143 
 
 129 
 
144 
    [0x5f] = { KM_LSHIFT, KC_MINUS },
 130 
    KM_SHIFT,   KC_MINUS,   0x5f, GSP_END,
145 
    [0x2b] = { KM_LSHIFT, KC_EQUALS },
 131 
    KM_SHIFT,   KC_EQUALS,  0x2b, GSP_END,
146 
 
 132 
 
147 
    [0x51] = { KM_LSHIFT, KC_Q },
 133 
    KM_SHIFT,   KC_Q,       0x51, GSP_END,
148 
    [0x57] = { KM_LSHIFT, KC_W },
 134 
    KM_SHIFT,   KC_W,       0x57, GSP_END,
149 
    [0x45] = { KM_LSHIFT, KC_E },
 135 
    KM_SHIFT,   KC_E,       0x45, GSP_END,
150 
    [0x52] = { KM_LSHIFT, KC_R },
 136 
    KM_SHIFT,   KC_R,       0x52, GSP_END,
151 
    [0x54] = { KM_LSHIFT, KC_T },
 137 
    KM_SHIFT,   KC_T,       0x54, GSP_END,
152 
    [0x59] = { KM_LSHIFT, KC_Y },
 138 
    KM_SHIFT,   KC_Y,       0x59, GSP_END,
153 
    [0x55] = { KM_LSHIFT, KC_U },
 139 
    KM_SHIFT,   KC_U,       0x55, GSP_END,
154 
    [0x49] = { KM_LSHIFT, KC_I },
 140 
    KM_SHIFT,   KC_I,       0x49, GSP_END,
155 
    [0x4f] = { KM_LSHIFT, KC_O },
 141 
    KM_SHIFT,   KC_O,       0x4f, GSP_END,
156 
    [0x50] = { KM_LSHIFT, KC_P },
 142 
    KM_SHIFT,   KC_P,       0x50, GSP_END,
157 
 
 143 
 
158 
    [0x7b] = { KM_LSHIFT, KC_LBRACKET },
 144 
    KM_SHIFT,   KC_LBRACKET,    0x7b, GSP_END,
159 
    [0x7d] = { KM_LSHIFT, KC_RBRACKET },
 145 
    KM_SHIFT,   KC_RBRACKET,    0x7d, GSP_END,
160 
 
 146 
 
161 
    [0x41] = { KM_LSHIFT, KC_A },
 147 
    KM_SHIFT,   KC_A,       0x41, GSP_END,
162 
    [0x53] = { KM_LSHIFT, KC_S },
 148 
    KM_SHIFT,   KC_S,       0x53, GSP_END,
163 
    [0x44] = { KM_LSHIFT, KC_D },
 149 
    KM_SHIFT,   KC_D,       0x44, GSP_END,
164 
    [0x46] = { KM_LSHIFT, KC_F },
 150 
    KM_SHIFT,   KC_F,       0x46, GSP_END,
165 
    [0x47] = { KM_LSHIFT, KC_G },
 151 
    KM_SHIFT,   KC_G,       0x47, GSP_END,
166 
    [0x48] = { KM_LSHIFT, KC_H },
 152 
    KM_SHIFT,   KC_H,       0x48, GSP_END,
167 
    [0x4a] = { KM_LSHIFT, KC_J },
 153 
    KM_SHIFT,   KC_J,       0x4a, GSP_END,
168 
    [0x4b] = { KM_LSHIFT, KC_K },
 154 
    KM_SHIFT,   KC_K,       0x4b, GSP_END,
169 
    [0x4c] = { KM_LSHIFT, KC_L },
 155 
    KM_SHIFT,   KC_L,       0x4c, GSP_END,
170 
 
 156 
 
171 
    [0x3a] = { KM_LSHIFT, KC_SEMICOLON },
 157 
    KM_SHIFT,   KC_SEMICOLON,   0x3a, GSP_END,
172 
    [0x22] = { KM_LSHIFT, KC_QUOTE },
 158 
    KM_SHIFT,   KC_QUOTE,   0x22, GSP_END,
173 
    [0x7c] = { KM_LSHIFT, KC_BACKSLASH },
 159 
    KM_SHIFT,   KC_BACKSLASH,   0x7c, GSP_END,
174 
 
 160 
 
175 
    [0x5a] = { KM_LSHIFT, KC_Z },
 161 
    KM_SHIFT,   KC_Z,       0x5a, GSP_END,
176 
    [0x58] = { KM_LSHIFT, KC_X },
 162 
    KM_SHIFT,   KC_X,       0x58, GSP_END,
177 
    [0x43] = { KM_LSHIFT, KC_C },
 163 
    KM_SHIFT,   KC_C,       0x43, GSP_END,
178 
    [0x56] = { KM_LSHIFT, KC_V },
 164 
    KM_SHIFT,   KC_V,       0x56, GSP_END,
179 
    [0x42] = { KM_LSHIFT, KC_B },
 165 
    KM_SHIFT,   KC_B,       0x42, GSP_END,
180 
    [0x4e] = { KM_LSHIFT, KC_N },
 166 
    KM_SHIFT,   KC_N,       0x4e, GSP_END,
181 
    [0x4d] = { KM_LSHIFT, KC_M },
 167 
    KM_SHIFT,   KC_M,       0x4d, GSP_END,
182 
 
 168 
 
183 
    [0x3c] = { KM_LSHIFT, KC_COMMA },
 169 
    KM_SHIFT,   KC_COMMA,   0x3c, GSP_END,
184 
    [0x3e] = { KM_LSHIFT, KC_PERIOD },
 170 
    KM_SHIFT,   KC_PERIOD,  0x3e, GSP_END,
185 
    [0x3f] = { KM_LSHIFT, KC_SLASH }
 171 
    KM_SHIFT,   KC_SLASH,   0x3f, GSP_END,
- 
 
 172 
 
- 
 
 173 
    /* ... */
- 
 
 174 
 
- 
 
 175 
    0,  KC_SPACE,   0x20, GSP_END,
- 
 
 176 
    0,  KC_ENTER,   0x0a, GSP_END,
- 
 
 177 
    0,  KC_ENTER,   0x0d, GSP_END,
- 
 
 178 
 
- 
 
 179 
    0,  KC_ESCAPE,  0x1b, 0x1b, GSP_END,
- 
 
 180 
 
- 
 
 181 
    0,  KC_F1,      0x1b, 0x5b, 0x4f, 0x50, GSP_END,
- 
 
 182 
    0,  KC_F2,      0x1b, 0x5b, 0x4f, 0x51, GSP_END,
- 
 
 183 
    0,  KC_F3,      0x1b, 0x5b, 0x4f, 0x52, GSP_END,
- 
 
 184 
    0,  KC_F4,      0x1b, 0x5b, 0x4f, 0x53, GSP_END,
- 
 
 185 
    0,  KC_F5,      0x1b, 0x5b, 0x31, 0x35, GSP_END,
- 
 
 186 
    0,  KC_F6,      0x1b, 0x5b, 0x31, 0x37, GSP_END,
- 
 
 187 
    0,  KC_F7,      0x1b, 0x5b, 0x31, 0x38, GSP_END,
- 
 
 188 
    0,  KC_F8,      0x1b, 0x5b, 0x31, 0x39, GSP_END,
- 
 
 189 
    0,  KC_F9,      0x1b, 0x5b, 0x32, 0x38, GSP_END,
- 
 
 190 
    0,  KC_F10,     0x1b, 0x5b, 0x32, 0x39, GSP_END,
- 
 
 191 
    0,  KC_F11,     0x1b, 0x5b, 0x32, 0x33, GSP_END,
- 
 
 192 
    0,  KC_F12,     0x1b, 0x5b, 0x32, 0x34, GSP_END,
- 
 
 193 
 
- 
 
 194 
    0,  KC_INSERT,  0x1b, 0x5b, 0x32, 0x7e, GSP_END,
- 
 
 195 
    0,  KC_HOME,    0x1b, 0x5b, 0x48, GSP_END,
- 
 
 196 
    0,  KC_PAGE_UP, 0x1b, 0x5b, 0x35, 0x7e, GSP_END,
- 
 
 197 
    0,  KC_DELETE,  0x1b, 0x5b, 0x33, 0x7e, GSP_END,
- 
 
 198 
    0,  KC_END,     0x1b, 0x5b, 0x46, GSP_END,
- 
 
 199 
    0,  KC_PAGE_DOWN,   0x1b, 0x5b, 0x36, 0x7e, GSP_END,
- 
 
 200 
 
- 
 
 201 
    0,  KC_UP,      0x1b, 0x5b, 0x41, GSP_END,
- 
 
 202 
    0,  KC_LEFT,    0x1b, 0x5b, 0x44, GSP_END,
- 
 
 203 
    0,  KC_DOWN,    0x1b, 0x5b, 0x42, GSP_END,
- 
 
 204 
    0,  KC_RIGHT,   0x1b, 0x5b, 0x43, GSP_END,
- 
 
 205 
 
- 
 
 206 
    0,  0
186 
};
 207 
};
187 
 
 208 
 
188 
static int map_e1[][2] =
 209 
int kbd_ctl_init(void)
189 
{
 210 
{
190 
};
 211 
    ds = 0;
191 
 
 212 
 
192 
static int map_e1a[][2] =
 - 
 
193 
{
 - 
 
194 
    [0x50] = { 0, KC_F1 },
 - 
 
195 
    [0x51] = { 0, KC_F2 },
 - 
 
196 
    [0x52] = { 0, KC_F3 },
 - 
 
197 
    [0x53] = { 0, KC_F4 },
 - 
 
198 
};
 - 
 
199 
 
 - 
 
200 
static int map_e1b[][2] =
 - 
 
201 
{
 - 
 
202 
    [0x33] = { 0, KC_F5 },
 - 
 
203 
    [0x37] = { 0, KC_F6 },
 - 
 
204 
    [0x38] = { 0, KC_F7 },
 - 
 
205 
    [0x39] = { 0, KC_F8 },
 - 
 
206 
};
 - 
 
207 
 
 - 
 
208 
static int map_e1c[][2] =
 - 
 
209 
{
 - 
 
210 
    [0x38] = { 0, KC_F9 },
 - 
 
211 
    [0x39] = { 0, KC_F10 },
 - 
 
212 
    [0x33] = { 0, KC_F11 },
 - 
 
213 
    [0x34] = { 0, KC_F12 },
 - 
 
214 
};
 - 
 
215 
 
 - 
 
216 
static unsigned int mods_keys[][2] = {
 - 
 
217 
    { KM_LSHIFT, KC_LSHIFT },
 - 
 
218 
    { 0, 0 }
 - 
 
219 
};
 - 
 
220 
 
 - 
 
221 
static enum dec_state ds = ds_start;
 - 
 
222 
 
 - 
 
223 
void kbd_ctl_parse_scancode(int scancode)
 - 
 
224 
{
 - 
 
225 
    switch (ds) {
 213 
    gsp_init(&sp);
226 
    case ds_start:  parse_ds_start(scancode); break;
 - 
 
227 
    case ds_e:  parse_ds_e(scancode); break;
 214 
    return gsp_insert_defs(&sp, seq_defs);
228 
    case ds_e1: parse_ds_e1(scancode); break;
 - 
 
229 
    case ds_e1a:    parse_ds_e1a(scancode); break;
 - 
 
230 
    case ds_e1b:    parse_ds_e1b(scancode); break;
 - 
 
231 
    case ds_e1c:    parse_ds_e1c(scancode); break;
 - 
 
232 
    }
 - 
 
233 
}
 - 
 
234 
 
 - 
 
235 
static void parse_ds_start(int scancode)
 - 
 
236 
{
 - 
 
237 
    if (scancode == 0x1b) {
 - 
 
238 
        ds = ds_e;
 - 
 
239 
        return;
 - 
 
240 
    }
 - 
 
241 
 
 - 
 
242 
    parse_leaf(scancode, map_start, sizeof(map_start) / (2 * sizeof(int)));
 - 
 
243 
}
 215 
}
244 
 
 216 
 
245 
static void parse_ds_e(int scancode)
 - 
 
246 
{
 - 
 
247 
    switch (scancode) {
 - 
 
248 
    case 0x5b: ds = ds_e1; return;
 - 
 
249 
    case 0x1b: ds = ds_start; break;
 - 
 
250 
    default: ds = ds_start; return;
 - 
 
251 
    }
 - 
 
252 
 
 - 
 
253 
    kbd_push_ev(KE_PRESS, KC_ESCAPE);
 - 
 
254 
}
 - 
 
255 
 
 - 
 
256 
static void parse_ds_e1(int scancode)
 - 
 
257 
{
 - 
 
258 
    switch (scancode) {
 - 
 
259 
    case 0x4f: ds = ds_e1a; return;
 - 
 
260 
    case 0x31: ds = ds_e1b; return;
 - 
 
261 
    case 0x32: ds = ds_e1c; return;
 - 
 
262 
    default: ds = ds_start; break;
 - 
 
263 
    }
 - 
 
264 
 
 - 
 
265 
    parse_leaf(scancode, map_e1, sizeof(map_e1) / (2 * sizeof(int)));
 - 
 
266 
}
 - 
 
267 
 
 - 
 
268 
static void parse_ds_e1a(int scancode)
 - 
 
269 
{
 - 
 
270 
    parse_leaf(scancode, map_e1a, sizeof(map_e1a) / (2 * sizeof(int)));
 - 
 
271 
}
 - 
 
272 
 
 - 
 
273 
static void parse_ds_e1b(int scancode)
 - 
 
274 
{
 - 
 
275 
    parse_leaf(scancode, map_e1b, sizeof(map_e1b) / (2 * sizeof(int)));
 - 
 
276 
}
 - 
 
277 
 
 - 
 
278 
static void parse_ds_e1c(int scancode)
 217 
void kbd_ctl_parse_scancode(int scancode)
279 
{
 - 
 
280 
    parse_leaf(scancode, map_e1c, sizeof(map_e1c) / (2 * sizeof(int)));
 - 
 
281 
}
 - 
 
282 
 
 - 
 
283 
static void parse_leaf(int scancode, int (*map)[2], size_t map_length)
 - 
 
284 
{
 218 
{
285 
    unsigned int key, mod;
 219 
    unsigned mods, key;
286 
    int i;
 - 
 
287 
 
 - 
 
288 
    ds = ds_start;
 - 
 
289 
 
 - 
 
290 
    if (scancode < 0 || scancode >= map_length)
 - 
 
291 
        return;
 - 
 
292 
 
 - 
 
293 
    mod = map[scancode][0];
 - 
 
294 
    key = map[scancode][1];
 - 
 
295 
 
 - 
 
296 
    /* Simulate modifier pressing. */
 - 
 
297 
    i = 0;
 - 
 
298 
    while (mods_keys[i][0] != 0) {
 - 
 
299 
        if (mod & mods_keys[i][0]) {
 - 
 
300 
            kbd_push_ev(KE_PRESS, mods_keys[i][1]);
 - 
 
301 
        }
 - 
 
302 
        ++i;
 - 
 
303 
    }
 - 
 
304 
 
 220 
 
- 
 
 221 
    ds = gsp_step(&sp, ds, scancode, &mods, &key);
305 
    if (key != 0) {
 222 
    if (key != 0) {
306 
        kbd_push_ev(KE_PRESS, key);
 223 
        stroke_sim(mods, key);
307 
        kbd_push_ev(KE_RELEASE, key);
 - 
 
308 
    }
 - 
 
309 
 
 - 
 
310 
    /* Simulate modifier releasing. */
 - 
 
311 
    i = 0;
 - 
 
312 
    while (mods_keys[i][0] != 0) {
 - 
 
313 
        if (mod & mods_keys[i][0]) {
 - 
 
314 
            kbd_push_ev(KE_RELEASE, mods_keys[i][1]);
 - 
 
315 
        }
 - 
 
316 
        ++i;
 - 
 
317 
    }
 224 
    }
318 
}
 225 
}
319 
 
 226 
 
320 
/**
 227 
/**
321 
 * @}
 228 
 * @}