Mercurial > sdl-ios-xcode
annotate src/video/bwindow/SDL_sysevents.cc @ 571:8e3ce997621c
Date: Thu, 16 Jan 2003 13:48:31 +0200
From: "Mike Gorchak"
Subject: All QNX patches
whole patches concerning QNX. Almost all code has been rewritten by Julian
and me. Added initial support for hw overlays in QNX and many many others
fixes.
P.S. This patches has been reviewed by Dave Rempel from QSSL and included in
SDL 1.2.5 distribution, which coming on 3rd party CD for newest 6.2.1
version of QNX, which will be available soon.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Mon, 20 Jan 2003 01:38:37 +0000 |
| parents | eed579d059ef |
| children | b8d311d90021 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
297
f6ffac90895c
Updated copyright information for 2002
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
| 6 modify it under the terms of the GNU Library General Public | |
| 7 License as published by the Free Software Foundation; either | |
| 8 version 2 of the License, or (at your option) any later version. | |
| 9 | |
| 10 This library is distributed in the hope that it will be useful, | |
| 11 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 13 Library General Public License for more details. | |
| 14 | |
| 15 You should have received a copy of the GNU Library General Public | |
| 16 License along with this library; if not, write to the Free | |
| 17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
| 18 | |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
1
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
| 22 | |
| 23 #ifdef SAVE_RCSID | |
| 24 static char rcsid = | |
| 25 "@(#) $Id$"; | |
| 26 #endif | |
| 27 | |
| 28 #include <support/UTF8.h> | |
| 29 #include <stdio.h> | |
| 30 #include <string.h> | |
| 31 #include "SDL_error.h" | |
| 32 #include "SDL_events.h" | |
| 33 #include "SDL_BWin.h" | |
| 34 #include "SDL_lowvideo.h" | |
| 35 | |
| 36 extern "C" { | |
| 37 | |
| 38 #include "SDL_events_c.h" | |
| 39 #include "SDL_sysevents.h" | |
| 40 #include "SDL_sysevents_c.h" | |
| 41 | |
| 42 /* A note on why the polling loops are necessary. | |
| 43 The BeOS Preview 2 implementation of BView->MouseMoved() only notifies | |
| 44 the view when the mouse enters or leaves the view. The documentation | |
| 45 says that you should loop and use GetMouse() to detect mouse motion. | |
| 46 The BeOS Preview 2 implementation of BView->KeyDown() and BView->KeyUp() | |
| 47 are only called for keys that generate ASCII characters. Since we want | |
| 48 to act like a low level raw keyboard, we need to poll the state of the | |
| 49 keys instead of catching the keys in callbacks. | |
| 50 These are documented portions of the BeBook for Preview Release 2 | |
| 51 */ | |
| 52 | |
| 53 /* Table to convert scancodes to SDL virtual keys */ | |
| 54 static SDLKey keymap[128]; | |
| 55 | |
| 56 /* Function to convert from a key scancode to a UNICODE character */ | |
| 57 static key_map *be_keymap; | |
| 58 static int32 *option_caps_map[2], *option_map[2], *caps_map[2], *normal_map[2]; | |
| 59 static char *unicode_map; | |
| 60 static Uint16 TranslateScancode(int scancode) | |
| 61 { | |
| 62 SDLMod modstate; | |
| 63 int shifted; | |
| 64 int32 index; /* Index into system unicode map */ | |
| 65 Uint16 unicode; | |
| 66 | |
| 67 /* Set the default character -- no character */ | |
| 68 unicode = 0; | |
| 69 | |
| 70 /* See whether or not the shift state is set */ | |
| 71 modstate = SDL_GetModState(); | |
| 72 if ( modstate & KMOD_SHIFT ) { | |
| 73 shifted = 1; | |
| 74 } else { | |
| 75 shifted = 0; | |
| 76 } | |
| 77 | |
| 78 if ( modstate & KMOD_NUM ) { | |
| 79 /* If numlock is on, numeric keypad keys have shift state inverted */ | |
| 80 switch (keymap[scancode]) { | |
| 81 case SDLK_KP0: | |
| 82 case SDLK_KP1: | |
| 83 case SDLK_KP2: | |
| 84 case SDLK_KP3: | |
| 85 case SDLK_KP4: | |
| 86 case SDLK_KP5: | |
| 87 case SDLK_KP6: | |
| 88 case SDLK_KP7: | |
| 89 case SDLK_KP8: | |
| 90 case SDLK_KP9: | |
| 91 case SDLK_KP_PERIOD: | |
| 92 case SDLK_KP_DIVIDE: | |
| 93 case SDLK_KP_MULTIPLY: | |
| 94 case SDLK_KP_MINUS: | |
| 95 case SDLK_KP_PLUS: | |
| 96 case SDLK_KP_ENTER: | |
| 97 case SDLK_KP_EQUALS: | |
| 98 shifted = !shifted; | |
| 99 break; | |
| 100 default: | |
| 101 break; | |
| 102 } | |
| 103 } | |
| 104 | |
| 105 /* Get the index based on modifier state */ | |
| 106 if ( modstate & KMOD_CTRL ) | |
| 107 index = be_keymap->control_map[scancode]; | |
| 108 else | |
| 109 if ( (modstate & KMOD_META) && (modstate & KMOD_CAPS) ) | |
| 110 index = option_caps_map[shifted][scancode]; | |
| 111 else | |
| 112 if ( modstate & KMOD_META ) | |
| 113 index = option_map[shifted][scancode]; | |
| 114 else | |
| 115 if ( modstate & KMOD_CAPS ) | |
| 116 index = caps_map[shifted][scancode]; | |
| 117 else | |
| 118 index = normal_map[shifted][scancode]; | |
| 119 | |
| 120 /* If there is a mapping, convert character from UTF-8 to UNICODE */ | |
| 121 if ( unicode_map[index] ) { | |
| 122 int32 state, srclen, dstlen; | |
| 123 unsigned char destbuf[2]; | |
| 124 | |
| 125 state = 0; | |
| 126 srclen = unicode_map[index++]; | |
| 127 dstlen = sizeof(destbuf); | |
| 128 convert_from_utf8(B_UNICODE_CONVERSION, | |
| 129 &unicode_map[index], &srclen, (char *)destbuf, &dstlen, | |
| 130 &state); | |
| 131 unicode = destbuf[0]; | |
| 132 unicode <<= 8; | |
| 133 unicode |= destbuf[1]; | |
| 134 | |
| 135 /* Keyboard input maps newline to carriage return */ | |
| 136 if ( unicode == '\n' ) { | |
| 137 unicode = '\r'; | |
| 138 } | |
| 139 | |
| 140 /* For some reason function keys map to control characters */ | |
| 141 # define CTRL(X) ((X)-'@') | |
| 142 switch (unicode) { | |
| 143 case CTRL('A'): | |
| 144 case CTRL('B'): | |
| 145 case CTRL('C'): | |
| 146 case CTRL('D'): | |
| 147 case CTRL('E'): | |
| 148 case CTRL('K'): | |
| 149 case CTRL('L'): | |
| 150 case CTRL('P'): | |
| 151 if ( ! (modstate & KMOD_CTRL) ) | |
| 152 unicode = 0; | |
| 153 break; | |
| 154 default: | |
| 155 break; | |
| 156 } | |
| 157 } | |
| 158 return(unicode); | |
| 159 } | |
| 160 | |
| 161 /* Function to translate a keyboard transition and queue the key event */ | |
| 162 static void QueueKey(int scancode, int pressed) | |
| 163 { | |
| 164 SDL_keysym keysym; | |
| 165 | |
| 166 /* Set the keysym information */ | |
| 167 keysym.scancode = scancode; | |
| 168 keysym.sym = keymap[scancode]; | |
| 169 keysym.mod = KMOD_NONE; | |
| 170 if ( SDL_TranslateUNICODE ) { | |
| 171 keysym.unicode = TranslateScancode(scancode); | |
| 172 } else { | |
| 173 keysym.unicode = 0; | |
| 174 } | |
| 175 | |
| 176 /* NUMLOCK and CAPSLOCK are implemented as double-presses in reality */ | |
| 177 if ( (keysym.sym == SDLK_NUMLOCK) || (keysym.sym == SDLK_CAPSLOCK) ) { | |
| 178 pressed = 1; | |
| 179 } | |
| 180 | |
| 181 /* Queue the key event */ | |
| 182 if ( pressed ) { | |
| 183 SDL_PrivateKeyboard(SDL_PRESSED, &keysym); | |
| 184 } else { | |
| 185 SDL_PrivateKeyboard(SDL_RELEASED, &keysym); | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 /* This is special because we know it will be run in a loop in a separate | |
| 190 thread. Normally this function should loop as long as there are input | |
| 191 states changing, i.e. new events arriving. | |
| 192 */ | |
| 193 void BE_PumpEvents(_THIS) | |
| 194 { | |
| 195 BView *view; | |
| 196 BRect bounds; | |
| 197 BPoint point; | |
| 198 uint32 buttons; | |
| 199 const uint32 button_masks[3] = { | |
| 200 B_PRIMARY_MOUSE_BUTTON, | |
| 201 B_TERTIARY_MOUSE_BUTTON, | |
| 202 B_SECONDARY_MOUSE_BUTTON, | |
| 203 }; | |
| 204 unsigned int i, j; | |
| 205 | |
| 206 /* Check out the mouse buttons and position (slight race condition) */ | |
| 207 if ( SDL_Win->Lock() ) { | |
| 208 /* Don't do anything if we have no view */ | |
| 209 view = SDL_Win->View(); | |
| 210 if ( ! view ) { | |
| 211 SDL_Win->Unlock(); | |
| 212 return; | |
| 213 } | |
| 214 bounds = view->Bounds(); | |
| 215 /* Get new input state, if still active */ | |
| 216 if ( SDL_Win->IsActive() ) { | |
| 217 key_flip = !key_flip; | |
| 218 get_key_info(&keyinfo[key_flip]); | |
| 219 view->GetMouse(&point, &buttons, true); | |
| 220 } else { | |
| 221 key_flip = key_flip; | |
| 222 point = last_point; | |
| 223 buttons = last_buttons; | |
| 224 } | |
| 225 SDL_Win->Unlock(); | |
| 226 } else { | |
| 227 return; | |
| 228 } | |
| 229 | |
| 230 /* If our view is active, we'll find key changes here */ | |
| 231 if ( memcmp(keyinfo[0].key_states, keyinfo[1].key_states, 16) != 0 ) { | |
| 232 for ( i=0; i<16; ++i ) { | |
| 233 Uint8 new_state, transition; | |
| 234 | |
| 235 new_state = keyinfo[key_flip].key_states[i]; | |
| 236 transition = keyinfo[!key_flip].key_states[i] ^ | |
| 237 keyinfo[ key_flip].key_states[i]; | |
| 238 for ( j=0; j<8; ++j ) { | |
| 239 if ( transition&0x80 ) | |
| 240 QueueKey(i*8+j, new_state&0x80); | |
| 241 transition <<= 1; | |
| 242 new_state <<= 1; | |
| 243 } | |
| 244 } | |
| 245 } | |
| 246 | |
| 247 /* We check keyboard, but not mouse if mouse isn't in window */ | |
| 248 if ( ! bounds.Contains(point) ) { | |
| 249 /* Mouse moved outside our view? */ | |
| 250 if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) { | |
| 251 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); | |
| 252 be_app->SetCursor(B_HAND_CURSOR); | |
| 253 } | |
| 254 return; | |
| 255 } | |
| 256 /* Has the mouse moved back into our view? */ | |
| 257 if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) { | |
| 258 /* Reset the B_HAND_CURSOR to our own */ | |
| 259 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); | |
| 260 SDL_SetCursor(NULL); | |
| 261 } | |
| 262 | |
| 263 /* Check for mouse motion */ | |
| 264 if ( point != last_point ) { | |
|
1
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
265 int x, y; |
|
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
266 |
|
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
267 SDL_Win->GetXYOffset(x, y); |
|
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
268 x = (int)point.x - x; |
|
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
269 y = (int)point.y - y; |
|
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
270 SDL_PrivateMouseMotion(0, 0, x, y); |
| 0 | 271 } |
| 272 last_point = point; | |
| 273 | |
| 274 /* Add any mouse button events */ | |
| 275 for ( i=0; i<SDL_TABLESIZE(button_masks); ++i ) { | |
| 276 if ( (buttons ^ last_buttons) & button_masks[i] ) { | |
| 277 if ( buttons & button_masks[i] ) { | |
| 278 SDL_PrivateMouseButton(SDL_PRESSED, 1+i, 0, 0); | |
| 279 } else { | |
| 280 SDL_PrivateMouseButton(SDL_RELEASED, 1+i, 0, 0); | |
| 281 } | |
| 282 } | |
| 283 } | |
| 284 last_buttons = buttons; | |
| 285 } | |
| 286 | |
| 287 void BE_InitOSKeymap(_THIS) | |
| 288 { | |
| 289 unsigned int i; | |
| 290 | |
|
339
eed579d059ef
Fixed spurious keypress at startup on BeOS
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
291 /* Initialize the keyboard state */ |
| 0 | 292 key_flip = 0; |
|
339
eed579d059ef
Fixed spurious keypress at startup on BeOS
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
293 get_key_info(&keyinfo[key_flip]); |
|
eed579d059ef
Fixed spurious keypress at startup on BeOS
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
294 memcpy(keyinfo[!key_flip].key_states, |
|
eed579d059ef
Fixed spurious keypress at startup on BeOS
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
295 keyinfo[key_flip].key_states, |
|
eed579d059ef
Fixed spurious keypress at startup on BeOS
Sam Lantinga <slouken@libsdl.org>
parents:
297
diff
changeset
|
296 SDL_TABLESIZE(keyinfo[key_flip].key_states)); |
| 0 | 297 |
| 298 /* Initialize the BeOS key translation table */ | |
| 299 /* Source: <be/interface/InterfaceDefs.h> and BeOS keyboard info */ | |
| 300 for ( i=0; i<SDL_TABLESIZE(keymap); ++i ) | |
| 301 keymap[i] = SDLK_UNKNOWN; | |
| 302 | |
| 303 keymap[0x01] = SDLK_ESCAPE; | |
| 304 keymap[B_F1_KEY] = SDLK_F1; | |
| 305 keymap[B_F2_KEY] = SDLK_F2; | |
| 306 keymap[B_F3_KEY] = SDLK_F3; | |
| 307 keymap[B_F4_KEY] = SDLK_F4; | |
| 308 keymap[B_F5_KEY] = SDLK_F5; | |
| 309 keymap[B_F6_KEY] = SDLK_F6; | |
| 310 keymap[B_F7_KEY] = SDLK_F7; | |
| 311 keymap[B_F8_KEY] = SDLK_F8; | |
| 312 keymap[B_F9_KEY] = SDLK_F9; | |
| 313 keymap[B_F10_KEY] = SDLK_F10; | |
| 314 keymap[B_F11_KEY] = SDLK_F11; | |
| 315 keymap[B_F12_KEY] = SDLK_F12; | |
| 316 keymap[B_PRINT_KEY] = SDLK_PRINT; | |
| 317 //keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK; | |
| 318 keymap[B_PAUSE_KEY] = SDLK_PAUSE; | |
| 319 keymap[0x11] = SDLK_BACKQUOTE; | |
| 320 keymap[0x12] = SDLK_1; | |
| 321 keymap[0x13] = SDLK_2; | |
| 322 keymap[0x14] = SDLK_3; | |
| 323 keymap[0x15] = SDLK_4; | |
| 324 keymap[0x16] = SDLK_5; | |
| 325 keymap[0x17] = SDLK_6; | |
| 326 keymap[0x18] = SDLK_7; | |
| 327 keymap[0x19] = SDLK_8; | |
| 328 keymap[0x1a] = SDLK_9; | |
| 329 keymap[0x1b] = SDLK_0; | |
| 330 keymap[0x1c] = SDLK_MINUS; | |
| 331 keymap[0x1d] = SDLK_EQUALS; | |
| 332 keymap[0x1e] = SDLK_BACKSPACE; | |
| 333 keymap[0x1f] = SDLK_INSERT; | |
| 334 keymap[0x20] = SDLK_HOME; | |
| 335 keymap[0x21] = SDLK_PAGEUP; | |
| 336 //keymap[0x22] = SDLK_NUMLOCK; | |
| 337 keymap[0x23] = SDLK_KP_DIVIDE; | |
| 338 keymap[0x24] = SDLK_KP_MULTIPLY; | |
| 339 keymap[0x25] = SDLK_KP_MINUS; | |
| 340 keymap[0x26] = SDLK_TAB; | |
| 341 keymap[0x27] = SDLK_q; | |
| 342 keymap[0x28] = SDLK_w; | |
| 343 keymap[0x29] = SDLK_e; | |
| 344 keymap[0x2a] = SDLK_r; | |
| 345 keymap[0x2b] = SDLK_t; | |
| 346 keymap[0x2c] = SDLK_y; | |
| 347 keymap[0x2d] = SDLK_u; | |
| 348 keymap[0x2e] = SDLK_i; | |
| 349 keymap[0x2f] = SDLK_o; | |
| 350 keymap[0x30] = SDLK_p; | |
| 351 keymap[0x31] = SDLK_LEFTBRACKET; | |
| 352 keymap[0x32] = SDLK_RIGHTBRACKET; | |
| 353 keymap[0x33] = SDLK_BACKSLASH; | |
| 354 keymap[0x34] = SDLK_DELETE; | |
| 355 keymap[0x35] = SDLK_END; | |
| 356 keymap[0x36] = SDLK_PAGEDOWN; | |
| 357 keymap[0x37] = SDLK_KP7; | |
| 358 keymap[0x38] = SDLK_KP8; | |
| 359 keymap[0x39] = SDLK_KP9; | |
| 360 keymap[0x3a] = SDLK_KP_PLUS; | |
| 361 //keymap[0x3b] = SDLK_CAPSLOCK; | |
| 362 keymap[0x3c] = SDLK_a; | |
| 363 keymap[0x3d] = SDLK_s; | |
| 364 keymap[0x3e] = SDLK_d; | |
| 365 keymap[0x3f] = SDLK_f; | |
| 366 keymap[0x40] = SDLK_g; | |
| 367 keymap[0x41] = SDLK_h; | |
| 368 keymap[0x42] = SDLK_j; | |
| 369 keymap[0x43] = SDLK_k; | |
| 370 keymap[0x44] = SDLK_l; | |
| 371 keymap[0x45] = SDLK_SEMICOLON; | |
| 372 keymap[0x46] = SDLK_QUOTE; | |
| 373 keymap[0x47] = SDLK_RETURN; | |
| 374 keymap[0x48] = SDLK_KP4; | |
| 375 keymap[0x49] = SDLK_KP5; | |
| 376 keymap[0x4a] = SDLK_KP6; | |
| 377 keymap[0x4b] = SDLK_LSHIFT; | |
| 378 keymap[0x4c] = SDLK_z; | |
| 379 keymap[0x4d] = SDLK_x; | |
| 380 keymap[0x4e] = SDLK_c; | |
| 381 keymap[0x4f] = SDLK_v; | |
| 382 keymap[0x50] = SDLK_b; | |
| 383 keymap[0x51] = SDLK_n; | |
| 384 keymap[0x52] = SDLK_m; | |
| 385 keymap[0x53] = SDLK_COMMA; | |
| 386 keymap[0x54] = SDLK_PERIOD; | |
| 387 keymap[0x55] = SDLK_SLASH; | |
| 388 keymap[0x56] = SDLK_RSHIFT; | |
| 389 keymap[0x57] = SDLK_UP; | |
| 390 keymap[0x58] = SDLK_KP1; | |
| 391 keymap[0x59] = SDLK_KP2; | |
| 392 keymap[0x5a] = SDLK_KP3; | |
| 393 keymap[0x5b] = SDLK_KP_ENTER; | |
| 394 //keymap[0x5c] = SDLK_LCTRL; | |
| 395 //keymap[0x5d] = SDLK_LALT; | |
| 396 keymap[0x5e] = SDLK_SPACE; | |
| 397 //keymap[0x5f] = SDLK_RALT; | |
| 398 //keymap[0x60] = SDLK_RCTRL; | |
| 399 keymap[0x61] = SDLK_LEFT; | |
| 400 keymap[0x62] = SDLK_DOWN; | |
| 401 keymap[0x63] = SDLK_RIGHT; | |
| 402 keymap[0x64] = SDLK_KP0; | |
| 403 keymap[0x65] = SDLK_KP_PERIOD; | |
| 404 //keymap[0x66] = SDLK_LMETA; | |
| 405 //keymap[0x67] = SDLK_RMETA; | |
| 406 //keymap[0x68] = SDLK_MENU; | |
| 407 keymap[0x69] = SDLK_EURO; | |
| 408 keymap[0x6a] = SDLK_KP_EQUALS; | |
| 409 keymap[0x6b] = SDLK_POWER; | |
| 410 | |
| 411 /* Get the system keymap and UNICODE table. | |
| 412 Note that this leaks memory since the maps are never freed. | |
| 413 */ | |
| 414 get_key_map(&be_keymap, &unicode_map); | |
| 415 | |
| 416 /* Set the modifier keys from the system keymap */ | |
| 417 keymap[be_keymap->caps_key] = SDLK_CAPSLOCK; | |
| 418 keymap[be_keymap->scroll_key] = SDLK_SCROLLOCK; | |
| 419 keymap[be_keymap->num_key] = SDLK_NUMLOCK; | |
| 420 keymap[be_keymap->left_shift_key] = SDLK_LSHIFT; | |
| 421 keymap[be_keymap->right_shift_key] = SDLK_RSHIFT; | |
| 422 keymap[be_keymap->left_command_key] = SDLK_LALT; | |
| 423 keymap[be_keymap->right_command_key] = SDLK_RALT; | |
| 424 keymap[be_keymap->left_control_key] = SDLK_LCTRL; | |
| 425 keymap[be_keymap->right_control_key] = SDLK_RCTRL; | |
| 426 keymap[be_keymap->left_option_key] = SDLK_LMETA; | |
| 427 keymap[be_keymap->right_option_key] = SDLK_RMETA; | |
| 428 keymap[be_keymap->menu_key] = SDLK_MENU; | |
| 429 | |
| 430 /* Set the modifier map pointers */ | |
| 431 option_caps_map[0] = be_keymap->option_caps_map; | |
| 432 option_caps_map[1] = be_keymap->option_caps_shift_map; | |
| 433 option_map[0] = be_keymap->option_map; | |
| 434 option_map[1] = be_keymap->option_shift_map; | |
| 435 caps_map[0] = be_keymap->caps_map; | |
| 436 caps_map[1] = be_keymap->caps_shift_map; | |
| 437 normal_map[0] = be_keymap->normal_map; | |
| 438 normal_map[1] = be_keymap->shift_map; | |
| 439 } | |
| 440 | |
| 441 }; /* Extern C */ |