Debian Codegraph @

src/win/wkeyboard.c

raw
1 /* ______ ___ ___
2 * /\ _ \ /\_ \ /\_ \
3 * \ \ \L\ \\//\ \ \//\ \ __ __ _ __ ___
4 * \ \ __ \ \ \ \ \ \ \ /'__`\ /'_ `\/\`'__\/ __`\
5 * \ \ \/\ \ \_\ \_ \_\ \_/\ __//\ \L\ \ \ \//\ \L\ \
6 * \ \_\ \_\/\____\/\____\ \____\ \____ \ \_\\ \____/
7 * \/_/\/_/\/____/\/____/\/____/\/___L\ \/_/ \/___/
8 * /\____/
9 * \_/__/
10 *
11 * Windows keyboard driver.
12 *
13 * By Milan Mimica.
14 *
15 * See readme.txt for copyright information.
16 *
17 */
18
19 #include "allegro5/allegro.h"
20 #include "allegro5/internal/aintern.h"
21 #include "allegro5/internal/aintern_driver.h"
22 #include "allegro5/internal/aintern_events.h"
23 #include "allegro5/internal/aintern_keyboard.h"
24 #include "allegro5/platform/aintwin.h"
25
26 /* Missing from MSVC 2005 headers. */
27 #ifndef MAPVK_VSC_TO_VK_EX
28 #define MAPVK_VSC_TO_VK_EX 3
29 #endif
30
31 static bool installed = false;
32 static ALLEGRO_KEYBOARD the_keyboard;
33 static ALLEGRO_KEYBOARD_STATE the_state;
34 static int modifiers = 0;
35
36 /* lookup table for converting virtualkey VK_* codes into Allegro ALLEGRO_KEY_* codes */
37 /* For handling of extended keys, extkey_to_keycode() takes priority over this. */
38 /* Last unknown key sequence: 39*/
39 static const unsigned char hw_to_mycode[256] =
40 {
41 /* 0x00 */ 0, ALLEGRO_KEY_UNKNOWN+0, ALLEGRO_KEY_UNKNOWN+1, ALLEGRO_KEY_UNKNOWN+2,
42 /* 0x04 */ ALLEGRO_KEY_UNKNOWN+3, ALLEGRO_KEY_UNKNOWN+4, ALLEGRO_KEY_UNKNOWN+5, 0,
43 /* 0x08 */ ALLEGRO_KEY_BACKSPACE, ALLEGRO_KEY_TAB, 0, 0,
44 /* 0x0C */ ALLEGRO_KEY_PAD_5, ALLEGRO_KEY_ENTER, 0, 0,
45 /* 0x10 */ 0/*L or R shift*/, ALLEGRO_KEY_LCTRL, ALLEGRO_KEY_ALT, ALLEGRO_KEY_PAUSE,
46 /* 0x14 */ ALLEGRO_KEY_CAPSLOCK, ALLEGRO_KEY_KANA, 0, ALLEGRO_KEY_UNKNOWN+6,
47 /* 0x18 */ ALLEGRO_KEY_UNKNOWN+7, ALLEGRO_KEY_KANJI, 0, ALLEGRO_KEY_ESCAPE,
48 /* 0x1C */ ALLEGRO_KEY_CONVERT, ALLEGRO_KEY_NOCONVERT, ALLEGRO_KEY_UNKNOWN+8, ALLEGRO_KEY_UNKNOWN+9,
49 /* 0x20 */ ALLEGRO_KEY_SPACE, ALLEGRO_KEY_PAD_9, ALLEGRO_KEY_PAD_3, ALLEGRO_KEY_PAD_1,
50 /* 0x24 */ ALLEGRO_KEY_PAD_7, ALLEGRO_KEY_PAD_4, ALLEGRO_KEY_PAD_8, ALLEGRO_KEY_PAD_6,
51 /* 0x28 */ ALLEGRO_KEY_PAD_2, ALLEGRO_KEY_UNKNOWN+10, ALLEGRO_KEY_UNKNOWN+11, ALLEGRO_KEY_UNKNOWN+12,
52 /* 0x2C */ ALLEGRO_KEY_PRINTSCREEN, ALLEGRO_KEY_PAD_0, ALLEGRO_KEY_PAD_DELETE, ALLEGRO_KEY_UNKNOWN+13,
53 /* 0x30 */ ALLEGRO_KEY_0, ALLEGRO_KEY_1, ALLEGRO_KEY_2, ALLEGRO_KEY_3,
54 /* 0x34 */ ALLEGRO_KEY_4, ALLEGRO_KEY_5, ALLEGRO_KEY_6, ALLEGRO_KEY_7,
55 /* 0x38 */ ALLEGRO_KEY_8, ALLEGRO_KEY_9, 0, 0,
56 /* 0x3C */ 0, 0, 0, 0,
57 /* 0x40 */ 0, ALLEGRO_KEY_A, ALLEGRO_KEY_B, ALLEGRO_KEY_C,
58 /* 0x44 */ ALLEGRO_KEY_D, ALLEGRO_KEY_E, ALLEGRO_KEY_F, ALLEGRO_KEY_G,
59 /* 0x48 */ ALLEGRO_KEY_H, ALLEGRO_KEY_I, ALLEGRO_KEY_J, ALLEGRO_KEY_K,
60 /* 0x4C */ ALLEGRO_KEY_L, ALLEGRO_KEY_M, ALLEGRO_KEY_N, ALLEGRO_KEY_O,
61 /* 0x50 */ ALLEGRO_KEY_P, ALLEGRO_KEY_Q, ALLEGRO_KEY_R, ALLEGRO_KEY_S,
62 /* 0x54 */ ALLEGRO_KEY_T, ALLEGRO_KEY_U, ALLEGRO_KEY_V, ALLEGRO_KEY_W,
63 /* 0x58 */ ALLEGRO_KEY_X, ALLEGRO_KEY_Y, ALLEGRO_KEY_Z, ALLEGRO_KEY_LWIN,
64 /* 0x5C */ ALLEGRO_KEY_RWIN, ALLEGRO_KEY_MENU, 0, 0,
65 /* 0x60 */ ALLEGRO_KEY_PAD_0, ALLEGRO_KEY_PAD_1, ALLEGRO_KEY_PAD_2, ALLEGRO_KEY_PAD_3,
66 /* 0x64 */ ALLEGRO_KEY_PAD_4, ALLEGRO_KEY_PAD_5, ALLEGRO_KEY_PAD_6, ALLEGRO_KEY_PAD_7,
67 /* 0x68 */ ALLEGRO_KEY_PAD_8, ALLEGRO_KEY_PAD_9, ALLEGRO_KEY_PAD_ASTERISK, ALLEGRO_KEY_PAD_PLUS,
68 /* 0x6C */ ALLEGRO_KEY_UNKNOWN+15, ALLEGRO_KEY_PAD_MINUS, ALLEGRO_KEY_PAD_DELETE, ALLEGRO_KEY_PAD_SLASH,
69 /* 0x70 */ ALLEGRO_KEY_F1, ALLEGRO_KEY_F2, ALLEGRO_KEY_F3, ALLEGRO_KEY_F4,
70 /* 0x74 */ ALLEGRO_KEY_F5, ALLEGRO_KEY_F6, ALLEGRO_KEY_F7, ALLEGRO_KEY_F8,
71 /* 0x78 */ ALLEGRO_KEY_F9, ALLEGRO_KEY_F10, ALLEGRO_KEY_F11, ALLEGRO_KEY_F12,
72 /* 0x7C */ ALLEGRO_KEY_UNKNOWN+17, ALLEGRO_KEY_UNKNOWN+18, ALLEGRO_KEY_UNKNOWN+19, ALLEGRO_KEY_UNKNOWN+20,
73 /* 0x80 */ ALLEGRO_KEY_UNKNOWN+21, ALLEGRO_KEY_UNKNOWN+22, ALLEGRO_KEY_UNKNOWN+23, ALLEGRO_KEY_UNKNOWN+24,
74 /* 0x84 */ ALLEGRO_KEY_UNKNOWN+25, ALLEGRO_KEY_UNKNOWN+26, ALLEGRO_KEY_UNKNOWN+27, ALLEGRO_KEY_UNKNOWN+28,
75 /* 0x88 */ 0, 0, 0, 0,
76 /* 0x8C */ 0, 0, 0, 0,
77 /* 0x90 */ ALLEGRO_KEY_NUMLOCK, ALLEGRO_KEY_SCROLLLOCK, 0, 0,
78 /* 0x94 */ 0, 0, 0, 0,
79 /* 0x98 */ 0, 0, 0, 0,
80 /* 0x9C */ 0, 0, 0, 0,
81 /* 0xA0 */ ALLEGRO_KEY_LSHIFT, ALLEGRO_KEY_RSHIFT, ALLEGRO_KEY_LCTRL, ALLEGRO_KEY_RCTRL,
82 /* 0xA4 */ ALLEGRO_KEY_ALT, ALLEGRO_KEY_ALTGR, 0, 0,
83 /* 0xA8 */ 0, 0, 0, 0,
84 /* 0xAC */ 0, 0, 0, 0,
85 /* 0xB0 */ 0, 0, 0, 0,
86 /* 0xB4 */ 0, 0, 0, 0,
87 /* 0xB8 */ 0, 0, ALLEGRO_KEY_SEMICOLON, ALLEGRO_KEY_EQUALS,
88 /* 0xBC */ ALLEGRO_KEY_COMMA, ALLEGRO_KEY_MINUS, ALLEGRO_KEY_FULLSTOP, ALLEGRO_KEY_SLASH,
89 /* 0xC0 */ ALLEGRO_KEY_TILDE, 0, 0, 0,
90 /* 0xC4 */ 0, 0, 0, 0,
91 /* 0xC8 */ 0, 0, 0, 0,
92 /* 0xCC */ 0, 0, 0, 0,
93 /* 0xD0 */ 0, 0, 0, 0,
94 /* 0xD4 */ 0, 0, 0, 0,
95 /* 0xD8 */ 0, 0, 0, ALLEGRO_KEY_OPENBRACE,
96 /* 0xDC */ ALLEGRO_KEY_BACKSLASH, ALLEGRO_KEY_CLOSEBRACE, ALLEGRO_KEY_QUOTE, 0,
97 /* 0xE0 */ 0, 0, ALLEGRO_KEY_BACKSLASH2, 0,
98 /* 0xE4 */ 0, ALLEGRO_KEY_UNKNOWN+29, 0, 0,
99 /* 0xE8 */ 0, 0, 0, 0,
100 /* 0xEC */ 0, 0, 0, 0,
101 /* 0xF0 */ 0, 0, 0, 0,
102 /* 0xF4 */ 0, 0, ALLEGRO_KEY_UNKNOWN+30, ALLEGRO_KEY_UNKNOWN+31,
103 /* 0xF8 */ ALLEGRO_KEY_UNKNOWN+32, ALLEGRO_KEY_UNKNOWN+33, ALLEGRO_KEY_UNKNOWN+34, ALLEGRO_KEY_UNKNOWN+35,
104 /* 0xFC */ ALLEGRO_KEY_UNKNOWN+36, ALLEGRO_KEY_UNKNOWN+37, ALLEGRO_KEY_UNKNOWN+38, 0
105 };
106
107
108 /* forward declarations */
109 static bool init_keyboard(void);
110 static void exit_keyboard(void);
111 static void get_keyboard_state(ALLEGRO_KEYBOARD_STATE *ret_state);
112 static void clear_keyboard_state(void);
113 static ALLEGRO_KEYBOARD *get_keyboard(void);
114
115
116 /* the driver vtable */
117 #define KEYBOARD_WINAPI AL_ID('W','A','P','I')
118
119 static ALLEGRO_KEYBOARD_DRIVER keyboard_winapi =
120 {
121 KEYBOARD_WINAPI,
122 0,
123 0,
124 "WinAPI keyboard",
125 init_keyboard,
126 exit_keyboard,
127 get_keyboard,
128 NULL, /* bool set_leds(int leds) */
129 NULL, /* const char* keycode_to_name(int keycode)*/
130 get_keyboard_state,
131 clear_keyboard_state,
132 };
133
134
135
136 /* list the available drivers */
137 _AL_DRIVER_INFO _al_keyboard_driver_list[] =
138 {
139 { KEYBOARD_WINAPI, &keyboard_winapi, true },
140 { 0, NULL, 0 }
141 };
142
143
144 /* init_keyboard:
145 * Initialise the keyboard driver.
146 */
147 static bool init_keyboard(void)
148 {
149 memset(&the_keyboard, 0, sizeof the_keyboard);
150 memset(&the_state, 0, sizeof the_state);
151 modifiers = 0;
152
153 /* Initialise the keyboard object for use as an event source. */
154 _al_event_source_init(&the_keyboard.es);
155
156 installed = true;
157 return true;
158 }
159
160
161
162 /* exit_keyboard:
163 * Shut down the keyboard driver.
164 */
165 static void exit_keyboard(void)
166 {
167 _al_event_source_free(&the_keyboard.es);
168
169 /* This may help catch bugs in the user program, since the pointer
170 * we return to the user is always the same.
171 */
172 memset(&the_keyboard, 0, sizeof the_keyboard);
173
174 installed = false;
175 }
176
177
178
179 /* _al_win_fix_modifiers:
180 * Fix the modifiers.
181 */
182 void _al_win_fix_modifiers(void)
183 {
184 modifiers = 0;
185 }
186
187
188
189 /* get_keyboard:
190 * Returns the address of a ALLEGRO_KEYBOARD structure representing the keyboard.
191 */
192 static ALLEGRO_KEYBOARD *get_keyboard(void)
193 {
194 return &the_keyboard;
195 }
196
197
198
199 /* get_keyboard_state:
200 * Copy the current keyboard state into RET_STATE.
201 */
202 static void get_keyboard_state(ALLEGRO_KEYBOARD_STATE *ret_state)
203 {
204 unsigned int i;
205 ALLEGRO_DISPLAY *disp = NULL;
206 ALLEGRO_SYSTEM *sys;
207
208 sys = al_get_system_driver();
209 for (i = 0; i < sys->displays._size; i++) {
210 ALLEGRO_DISPLAY_WIN **d = (void*)_al_vector_ref(&sys->displays, i);
211 if ((*d)->window == GetForegroundWindow()) {
212 disp = (void*)*d;
213 break;
214 }
215 }
216 the_state.display = disp;
217 *ret_state = the_state;
218 }
219
220
221
222 /* clear_keyboard_state:
223 * Clear the current keyboard state.
224 */
225 static void clear_keyboard_state(void)
226 {
227 memset(&the_state, 0, sizeof(the_state));
228 }
229
230
231
232 /* extkey_to_keycode:
233 * Given a VK code, returns the Allegro keycode for the corresponding extended
234 * key. If no code is found, returns zero.
235 */
236 static int extkey_to_keycode(int vcode)
237 {
238 switch (vcode) {
239 /* These are ordered by VK value, lowest first. */
240 case VK_CANCEL: return ALLEGRO_KEY_PAUSE;
241 case VK_RETURN: return ALLEGRO_KEY_PAD_ENTER;
242 case VK_CONTROL: return ALLEGRO_KEY_RCTRL;
243 case VK_MENU: return ALLEGRO_KEY_ALTGR;
244 case VK_PRIOR: return ALLEGRO_KEY_PGUP;
245 case VK_NEXT: return ALLEGRO_KEY_PGDN;
246 case VK_END: return ALLEGRO_KEY_END;
247 case VK_HOME: return ALLEGRO_KEY_HOME;
248 case VK_LEFT: return ALLEGRO_KEY_LEFT;
249 case VK_UP: return ALLEGRO_KEY_UP;
250 case VK_RIGHT: return ALLEGRO_KEY_RIGHT;
251 case VK_DOWN: return ALLEGRO_KEY_DOWN;
252 case VK_SNAPSHOT: return ALLEGRO_KEY_PRINTSCREEN;
253 case VK_INSERT: return ALLEGRO_KEY_INSERT;
254 case VK_DELETE: return ALLEGRO_KEY_DELETE;
255 case VK_LWIN: return ALLEGRO_KEY_LWIN;
256 case VK_RWIN: return ALLEGRO_KEY_RWIN;
257 case VK_APPS: return ALLEGRO_KEY_MENU;
258 case VK_DIVIDE: return ALLEGRO_KEY_PAD_SLASH;
259 case VK_NUMLOCK: return ALLEGRO_KEY_NUMLOCK;
260 default: return 0;
261 }
262 }
263
264 static void update_modifiers(int code, bool pressed)
265 {
266 #define ON_OFF2(code) \
267 { \
268 if (!pressed) \
269 modifiers &= ~code; \
270 else \
271 modifiers |= code; \
272 break; \
273 }
274
275 switch (code) {
276 case ALLEGRO_KEY_LSHIFT:
277 ON_OFF2(ALLEGRO_KEYMOD_SHIFT);
278 case ALLEGRO_KEY_RSHIFT:
279 ON_OFF2(ALLEGRO_KEYMOD_SHIFT);
280 case ALLEGRO_KEY_RCTRL:
281 ON_OFF2(ALLEGRO_KEYMOD_CTRL);
282 case ALLEGRO_KEY_LCTRL:
283 ON_OFF2(ALLEGRO_KEYMOD_CTRL);
284 case ALLEGRO_KEY_ALT:
285 ON_OFF2(ALLEGRO_KEYMOD_ALT);
286 case ALLEGRO_KEY_ALTGR:
287 ON_OFF2(ALLEGRO_KEYMOD_ALTGR);
288 case ALLEGRO_KEY_LWIN:
289 ON_OFF2(ALLEGRO_KEYMOD_LWIN);
290 case ALLEGRO_KEY_RWIN:
291 ON_OFF2(ALLEGRO_KEYMOD_RWIN);
292 case ALLEGRO_KEY_MENU:
293 ON_OFF2(ALLEGRO_KEYMOD_MENU);
294 }
295
296 #undef ON_OFF2
297 }
298
299
300
301 /* update_toggle_modifiers:
302 * Update the state of Num Lock, Caps Lock, and Scroll Lock.
303 */
304 static void update_toggle_modifiers(void)
305 {
306 #define ON_OFF(code, on) \
307 { \
308 if (on) \
309 modifiers |= code; \
310 else \
311 modifiers &= ~code; \
312 }
313 /* GetKeyState appears to be the only reliable way of doing this. GetKeyboardState
314 * is updated a bit too late in some cases. Maybe it would work if WM_CHARs were
315 * used, since they arrive after the WM_KEYDOWNs that trigger them.
316 */
317 ON_OFF(ALLEGRO_KEYMOD_NUMLOCK, GetKeyState(VK_NUMLOCK) & 1);
318 ON_OFF(ALLEGRO_KEYMOD_CAPSLOCK, GetKeyState(VK_CAPITAL) & 1);
319 ON_OFF(ALLEGRO_KEYMOD_SCROLLLOCK, GetKeyState(VK_SCROLL) & 1);
320
321 #undef ON_OFF
322 }
323
324
325
326 /* _al_win_kbd_handle_key_press:
327 * Does stuff when a key is pressed.
328 */
329 void _al_win_kbd_handle_key_press(int scode, int vcode, bool extended,
330 bool repeated, ALLEGRO_DISPLAY_WIN *win_disp)
331 {
332 ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY *)win_disp;
333 ALLEGRO_EVENT event;
334 int my_code;
335 bool actual_repeat;
336 int char_count;
337 int event_count;
338 int i;
339 BYTE ks[256];
340 WCHAR buf[8] = { 0 };
341
342 if (!installed)
343 return;
344
345 /* Check for an extended key first. */
346 my_code = 0;
347 if (extended)
348 my_code = extkey_to_keycode(vcode);
349
350 /* Map a non-extended key. This also works as a fallback in case
351 the key was extended, but no extended mapping was found. */
352 if (my_code == 0) {
353 if (vcode == VK_SHIFT) /* Left or right Shift key? */
354 vcode = MapVirtualKey(scode, MAPVK_VSC_TO_VK_EX);
355 my_code = hw_to_mycode[vcode];
356 }
357 update_modifiers(my_code, true);
358
359 actual_repeat = repeated && _AL_KEYBOARD_STATE_KEY_DOWN(the_state, my_code);
360 _AL_KEYBOARD_STATE_SET_KEY_DOWN(the_state, my_code);
361
362 if (!_al_event_source_needs_to_generate_event(&the_keyboard.es))
363 return;
364
365 event.keyboard.type = ALLEGRO_EVENT_KEY_DOWN;
366 event.keyboard.timestamp = al_get_time();
367 event.keyboard.display = display;
368 event.keyboard.keycode = my_code;
369 event.keyboard.unichar = 0;
370 update_toggle_modifiers();
371 event.keyboard.modifiers = modifiers;
372 event.keyboard.repeat = false;
373
374 _al_event_source_lock(&the_keyboard.es);
375
376 if (my_code > 0 && !actual_repeat) {
377 _al_event_source_emit_event(&the_keyboard.es, &event);
378 }
379
380 /* Send char events, but not for modifier keys or dead keys. */
381 if (my_code < ALLEGRO_KEY_MODIFIERS) {
382 char_count = ToUnicode(vcode, scode, GetKeyboardState(ks) ? ks : NULL, buf, 8, 0);
383 /* Send ASCII code 127 for both Del keys. */
384 if (char_count == 0 && vcode == VK_DELETE) {
385 char_count = 1;
386 buf[0] = 127;
387 }
388 if (char_count != -1) { /* -1 means it was a dead key. */
389 event_count = char_count ? char_count : 1;
390 event.keyboard.type = ALLEGRO_EVENT_KEY_CHAR;
391 update_toggle_modifiers();
392 event.keyboard.modifiers = modifiers;
393 event.keyboard.repeat = actual_repeat;
394 for (i = 0; i < event_count; i++) {
395 event.keyboard.unichar = buf[i];
396 _al_event_source_emit_event(&the_keyboard.es, &event);
397 }
398 }
399 }
400 _al_event_source_unlock(&the_keyboard.es);
401
402 /* Toggle mouse grab key. */
403 if (my_code && !repeated) {
404 ALLEGRO_SYSTEM_WIN *system = (void *)al_get_system_driver();
405 if (system->toggle_mouse_grab_keycode && my_code == system->toggle_mouse_grab_keycode &&
406 (modifiers & system->toggle_mouse_grab_modifiers) == system->toggle_mouse_grab_modifiers)
407 {
408 if (system->mouse_grab_display == display) {
409 al_ungrab_mouse();
410 }
411 else {
412 al_grab_mouse(display);
413 }
414 }
415 }
416 }
417
418
419
420 /* _al_win_kbd_handle_key_release:
421 * Does stuff when a key is released.
422 */
423 void _al_win_kbd_handle_key_release(int scode, int vcode, bool extended, ALLEGRO_DISPLAY_WIN *win_disp)
424 {
425 ALLEGRO_EVENT event;
426 int my_code;
427
428 if (!installed)
429 return;
430
431 my_code = 0;
432 if (extended)
433 my_code = extkey_to_keycode(vcode);
434
435 if (my_code == 0) {
436 if (vcode == VK_SHIFT)
437 vcode = MapVirtualKey(scode, MAPVK_VSC_TO_VK_EX);
438 my_code = hw_to_mycode[vcode];
439 }
440 update_modifiers(my_code, false);
441
442 _AL_KEYBOARD_STATE_CLEAR_KEY_DOWN(the_state, my_code);
443
444 /* Windows only sends a WM_KEYUP message for the Shift keys when
445 both have been released. If one of the Shift keys is still reported
446 as down, we need to release it as well. */
447 if (my_code == ALLEGRO_KEY_LSHIFT && _AL_KEYBOARD_STATE_KEY_DOWN(the_state, ALLEGRO_KEY_RSHIFT))
448 _al_win_kbd_handle_key_release(scode, VK_RSHIFT, extended, win_disp);
449 else if (my_code == ALLEGRO_KEY_RSHIFT && _AL_KEYBOARD_STATE_KEY_DOWN(the_state, ALLEGRO_KEY_LSHIFT))
450 _al_win_kbd_handle_key_release(scode, VK_LSHIFT, extended, win_disp);
451
452 if (!_al_event_source_needs_to_generate_event(&the_keyboard.es))
453 return;
454
455 event.keyboard.type = ALLEGRO_EVENT_KEY_UP;
456 event.keyboard.timestamp = al_get_time();
457 event.keyboard.display = (void*)win_disp;
458 event.keyboard.keycode = my_code;
459 event.keyboard.unichar = 0;
460 update_toggle_modifiers();
461 event.keyboard.modifiers = modifiers;
462
463 _al_event_source_lock(&the_keyboard.es);
464 _al_event_source_emit_event(&the_keyboard.es, &event);
465 _al_event_source_unlock(&the_keyboard.es);
466 }
467
468
469 /*
470 * Local Variables:
471 * c-basic-offset: 3
472 * indent-tabs-mode: nil
473 * End:
474 */
475 /* vim: set sts=3 sw=3 et: */