Skip to content

L
libSDL
Commit b84dba57 authored by Sam Lantinga's avatar Sam Lantinga
Browse files
Options

Date: Mon, 21 Jun 2004 16:52:47 +0200 

From: Marcin Konicki
Subject: SDL 1.2.7 patch for BeOS (new input handling code)

I rewrote input handling code for BeOS. It should be faster now (i got
report that mouse is faster, keyboard should be too, but it's harder to
observe).

I'll try to add mouse wheel support too, soon.

Stefano Ceccherini (a.k.a Jack Burton) helped me beautify code (working
version was less clean), and it was he who asked me to write this thing ;).

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%40908
parent 3eaf8adb
Hide whitespace changes
Inline Side-by-side
Showing with 329 additions and 403 deletions
src/video/bwindow/SDL_BWin.h
View file @ b84dba57
...@@ -35,6 +35,7 @@ static char rcsid = ...@@ -35,6 +35,7 @@ static char rcsid =
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
#include <be/opengl/GLView.h> #include <be/opengl/GLView.h>
#endif #endif
#include <support/UTF8.h>
#include "SDL_BeApp.h" #include "SDL_BeApp.h"
#include "SDL_events.h" #include "SDL_events.h"
...@@ -49,6 +50,9 @@ class SDL_BWin : public BDirectWindow ...@@ -49,6 +50,9 @@ class SDL_BWin : public BDirectWindow
public: public:
SDL_BWin(BRect bounds) : SDL_BWin(BRect bounds) :
BDirectWindow(bounds, "Untitled", B_TITLED_WINDOW, 0) { BDirectWindow(bounds, "Untitled", B_TITLED_WINDOW, 0) {
InitKeyboard();
last_buttons = 0;
the_view = NULL; the_view = NULL;
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
SDL_GLView = NULL; SDL_GLView = NULL;
...@@ -58,6 +62,7 @@ public: ...@@ -58,6 +62,7 @@ public:
shown = false; shown = false;
inhibit_resize = false; inhibit_resize = false;
} }
virtual ~SDL_BWin() { virtual ~SDL_BWin() {
Lock(); Lock();
if ( the_view ) { if ( the_view ) {
...@@ -79,6 +84,119 @@ public: ...@@ -79,6 +84,119 @@ public:
delete SDL_View; delete SDL_View;
} }
} }
virtual void InitKeyboard(void) {
for ( uint i=0; i<SDL_TABLESIZE(keymap); ++i )
keymap[i] = SDLK_UNKNOWN;
keymap[0x01] = SDLK_ESCAPE;
keymap[B_F1_KEY] = SDLK_F1;
keymap[B_F2_KEY] = SDLK_F2;
keymap[B_F3_KEY] = SDLK_F3;
keymap[B_F4_KEY] = SDLK_F4;
keymap[B_F5_KEY] = SDLK_F5;
keymap[B_F6_KEY] = SDLK_F6;
keymap[B_F7_KEY] = SDLK_F7;
keymap[B_F8_KEY] = SDLK_F8;
keymap[B_F9_KEY] = SDLK_F9;
keymap[B_F10_KEY] = SDLK_F10;
keymap[B_F11_KEY] = SDLK_F11;
keymap[B_F12_KEY] = SDLK_F12;
keymap[B_PRINT_KEY] = SDLK_PRINT;
keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK;
keymap[B_PAUSE_KEY] = SDLK_PAUSE;
keymap[0x11] = SDLK_BACKQUOTE;
keymap[0x12] = SDLK_1;
keymap[0x13] = SDLK_2;
keymap[0x14] = SDLK_3;
keymap[0x15] = SDLK_4;
keymap[0x16] = SDLK_5;
keymap[0x17] = SDLK_6;
keymap[0x18] = SDLK_7;
keymap[0x19] = SDLK_8;
keymap[0x1a] = SDLK_9;
keymap[0x1b] = SDLK_0;
keymap[0x1c] = SDLK_MINUS;
keymap[0x1d] = SDLK_EQUALS;
keymap[0x1e] = SDLK_BACKSPACE;
keymap[0x1f] = SDLK_INSERT;
keymap[0x20] = SDLK_HOME;
keymap[0x21] = SDLK_PAGEUP;
keymap[0x22] = SDLK_NUMLOCK;
keymap[0x23] = SDLK_KP_DIVIDE;
keymap[0x24] = SDLK_KP_MULTIPLY;
keymap[0x25] = SDLK_KP_MINUS;
keymap[0x26] = SDLK_TAB;
keymap[0x27] = SDLK_q;
keymap[0x28] = SDLK_w;
keymap[0x29] = SDLK_e;
keymap[0x2a] = SDLK_r;
keymap[0x2b] = SDLK_t;
keymap[0x2c] = SDLK_y;
keymap[0x2d] = SDLK_u;
keymap[0x2e] = SDLK_i;
keymap[0x2f] = SDLK_o;
keymap[0x30] = SDLK_p;
keymap[0x31] = SDLK_LEFTBRACKET;
keymap[0x32] = SDLK_RIGHTBRACKET;
keymap[0x33] = SDLK_BACKSLASH;
keymap[0x34] = SDLK_DELETE;
keymap[0x35] = SDLK_END;
keymap[0x36] = SDLK_PAGEDOWN;
keymap[0x37] = SDLK_KP7;
keymap[0x38] = SDLK_KP8;
keymap[0x39] = SDLK_KP9;
keymap[0x3a] = SDLK_KP_PLUS;
keymap[0x3b] = SDLK_CAPSLOCK;
keymap[0x3c] = SDLK_a;
keymap[0x3d] = SDLK_s;
keymap[0x3e] = SDLK_d;
keymap[0x3f] = SDLK_f;
keymap[0x40] = SDLK_g;
keymap[0x41] = SDLK_h;
keymap[0x42] = SDLK_j;
keymap[0x43] = SDLK_k;
keymap[0x44] = SDLK_l;
keymap[0x45] = SDLK_SEMICOLON;
keymap[0x46] = SDLK_QUOTE;
keymap[0x47] = SDLK_RETURN;
keymap[0x48] = SDLK_KP4;
keymap[0x49] = SDLK_KP5;
keymap[0x4a] = SDLK_KP6;
keymap[0x4b] = SDLK_LSHIFT;
keymap[0x4c] = SDLK_z;
keymap[0x4d] = SDLK_x;
keymap[0x4e] = SDLK_c;
keymap[0x4f] = SDLK_v;
keymap[0x50] = SDLK_b;
keymap[0x51] = SDLK_n;
keymap[0x52] = SDLK_m;
keymap[0x53] = SDLK_COMMA;
keymap[0x54] = SDLK_PERIOD;
keymap[0x55] = SDLK_SLASH;
keymap[0x56] = SDLK_RSHIFT;
keymap[0x57] = SDLK_UP;
keymap[0x58] = SDLK_KP1;
keymap[0x59] = SDLK_KP2;
keymap[0x5a] = SDLK_KP3;
keymap[0x5b] = SDLK_KP_ENTER;
keymap[0x5c] = SDLK_LCTRL;
keymap[0x5d] = SDLK_LALT;
keymap[0x5e] = SDLK_SPACE;
keymap[0x5f] = SDLK_RALT;
keymap[0x60] = SDLK_RCTRL;
keymap[0x61] = SDLK_LEFT;
keymap[0x62] = SDLK_DOWN;
keymap[0x63] = SDLK_RIGHT;
keymap[0x64] = SDLK_KP0;
keymap[0x65] = SDLK_KP_PERIOD;
keymap[0x66] = SDLK_LMETA;
keymap[0x67] = SDLK_RMETA;
keymap[0x68] = SDLK_MENU;
keymap[0x69] = SDLK_EURO;
keymap[0x6a] = SDLK_KP_EQUALS;
keymap[0x6b] = SDLK_POWER;
}
/* Override the Show() method so we can tell when we've been shown */ /* Override the Show() method so we can tell when we've been shown */
virtual void Show(void) { virtual void Show(void) {
...@@ -211,6 +329,214 @@ public: ...@@ -211,6 +329,214 @@ public:
BDirectWindow::Quit(); BDirectWindow::Quit();
} }
virtual int16 Translate2Unicode(const char *buf) {
int32 state, srclen, dstlen;
unsigned char destbuf[2];
Uint16 unicode = 0;
if ((uchar)buf[0] > 127) {
state = 0;
srclen = strlen(buf);
dstlen = sizeof(destbuf);
convert_from_utf8(B_UNICODE_CONVERSION, buf, &srclen, (char *)destbuf, &dstlen, &state);
unicode = destbuf[0];
unicode <<= 8;
unicode |= destbuf[1];
} else
unicode = buf[0];
/* For some reason function keys map to control characters */
# define CTRL(X) ((X)-'@')
switch (unicode) {
case CTRL('A'):
case CTRL('B'):
case CTRL('C'):
case CTRL('D'):
case CTRL('E'):
case CTRL('K'):
case CTRL('L'):
case CTRL('P'):
if ( ! (SDL_GetModState() & KMOD_CTRL) )
unicode = 0;
break;
/* Keyboard input maps newline to carriage return */
case '\n':
unicode = '\r';
break;
default:
break;
}
return unicode;
}
virtual void DispatchMessage(BMessage *msg, BHandler *target) {
switch (msg->what) {
case B_MOUSE_MOVED:
{
BPoint where;
int32 transit;
if (msg->FindPoint("where", &where) == B_OK && msg->FindInt32("be:transit", &transit) == B_OK) {
if (transit == B_EXITED_VIEW) {
if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {
SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
be_app->SetCursor(B_HAND_CURSOR);
}
} else {
int x, y;
if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
SDL_SetCursor(NULL);
}
GetXYOffset(x, y);
x = (int)where.x - x;
y = (int)where.y - y;
SDL_PrivateMouseMotion(0, 0, x, y);
}
}
break;
}
case B_MOUSE_DOWN:
{
/* it looks like mouse down is send only for first clicked
button, each next is not send while last one is holded */
int32 buttons;
int sdl_buttons = 0;
if (msg->FindInt32("buttons", &buttons) == B_OK) {
/* Add any mouse button events */
if (buttons & B_PRIMARY_MOUSE_BUTTON) {
sdl_buttons |= SDL_BUTTON_LEFT;
}
if (buttons & B_SECONDARY_MOUSE_BUTTON) {
sdl_buttons |= SDL_BUTTON_RIGHT;
}
if (buttons & B_TERTIARY_MOUSE_BUTTON) {
sdl_buttons |= SDL_BUTTON_MIDDLE;
}
SDL_PrivateMouseButton(SDL_PRESSED, sdl_buttons, 0, 0);
last_buttons = buttons;
}
break;
}
case B_MOUSE_UP:
{
/* mouse up doesn't give which button was released,
only state of buttons (after release, so it's always = 0),
which is is not what we need ;]
So we need to store button in mouse down, and restore
in mouse up :(
mouse up is (similarly to mouse down) send only when
no more buttons are down */
int32 buttons;
int sdl_buttons = 0;
if (msg->FindInt32("buttons", &buttons) == B_OK) {
/* Add any mouse button events */
if ((buttons ^ B_PRIMARY_MOUSE_BUTTON) & last_buttons) {
sdl_buttons |= SDL_BUTTON_LEFT;
}
if ((buttons ^ B_SECONDARY_MOUSE_BUTTON) & last_buttons) {
sdl_buttons |= SDL_BUTTON_RIGHT;
}
if ((buttons ^ B_TERTIARY_MOUSE_BUTTON) & last_buttons) {
sdl_buttons |= SDL_BUTTON_MIDDLE;
}
SDL_PrivateMouseButton(SDL_RELEASED, sdl_buttons, 0, 0);
last_buttons = buttons;
}
break;
}
case B_MOUSE_WHEEL_CHANGED:
{
float x, y;
x = y = 0;
if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK && msg->FindFloat("be:wheel_delta_y", &y) == B_OK) {
if (x < 0 || y < 0) {
SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0);
SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0);
} else if (x > 0 || y > 0) {
SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0);
SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0);
}
}
break;
}
case B_KEY_DOWN:
case B_UNMAPPED_KEY_DOWN: /* modifier keys are unmapped */
{
int32 key;
int32 modifiers;
if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
SDL_keysym keysym;
keysym.scancode = key;
if (key < 128) {
keysym.sym = keymap[key];
} else {
keysym.sym = SDLK_UNKNOWN;
}
/* FIX THIS?
it seems SDL_PrivateKeyboard() changes mod value
anyway, and doesn't care about what we setup here */
keysym.mod = KMOD_NONE;
keysym.unicode = 0;
if (SDL_TranslateUNICODE) {
const char *bytes;
if (msg->FindString("bytes", &bytes) == B_OK) {
/* FIX THIS?
this cares only about first "letter",
so if someone maps some key to print
"BeOS rulez!" only "B" will be used. */
keysym.unicode = Translate2Unicode(bytes);
}
}
SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
}
break;
}
case B_KEY_UP:
case B_UNMAPPED_KEY_UP: /* modifier keys are unmapped */
{
int32 key;
int32 modifiers;
if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
SDL_keysym keysym;
keysym.scancode = key;
if (key < 128) {
keysym.sym = keymap[key];
} else {
keysym.sym = SDLK_UNKNOWN;
}
keysym.mod = KMOD_NONE; /* FIX THIS? */
keysym.unicode = 0;
if (SDL_TranslateUNICODE) {
const char *bytes;
if (msg->FindString("bytes", &bytes) == B_OK) {
keysym.unicode = Translate2Unicode(bytes);
}
}
SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
}
break;
}
default:
/* move it after switch{} so it's always handled
that way we keep BeOS feautures like:
- CTRL+Q to close window (and other shortcuts)
- PrintScreen to make screenshot into /boot/home
- etc.. */
//BDirectWindow::DispatchMessage(msg, target);
break;
}
BDirectWindow::DispatchMessage(msg, target);
}
private: private:
#ifdef HAVE_OPENGL #ifdef HAVE_OPENGL
BGLView *SDL_GLView; BGLView *SDL_GLView;
...@@ -220,6 +546,9 @@ private: ...@@ -220,6 +546,9 @@ private:
bool shown; bool shown;
bool inhibit_resize; bool inhibit_resize;
int32 last_buttons;
SDLKey keymap[128];
}; };
#endif /* _SDL_BWin_h */ #endif /* _SDL_BWin_h */
src/video/bwindow/SDL_lowvideo.h
View file @ b84dba57
...@@ -49,14 +49,6 @@ struct SDL_PrivateVideoData { ...@@ -49,14 +49,6 @@ struct SDL_PrivateVideoData {
/* A completely clear cursor */ /* A completely clear cursor */
WMcursor *BlankCursor; WMcursor *BlankCursor;
/* Mouse state variables */
uint32 last_buttons;
BPoint last_point;
/* Keyboard state variables */
int key_flip;
struct key_info keyinfo[2];
SDL_Overlay *overlay; SDL_Overlay *overlay;
}; };
/* Old variable names */ /* Old variable names */
...@@ -65,10 +57,6 @@ struct SDL_PrivateVideoData { ...@@ -65,10 +57,6 @@ struct SDL_PrivateVideoData {
#define SDL_nummodes (_this->hidden->SDL_nummodes) #define SDL_nummodes (_this->hidden->SDL_nummodes)
#define SDL_modelist (_this->hidden->SDL_modelist) #define SDL_modelist (_this->hidden->SDL_modelist)
#define SDL_BlankCursor (_this->hidden->BlankCursor) #define SDL_BlankCursor (_this->hidden->BlankCursor)
#define last_buttons (_this->hidden->last_buttons)
#define last_point (_this->hidden->last_point)
#define key_flip (_this->hidden->key_flip)
#define keyinfo (_this->hidden->keyinfo)
#define current_overlay (_this->hidden->overlay) #define current_overlay (_this->hidden->overlay)
#endif /* _SDL_lowvideo_h */ #endif /* _SDL_lowvideo_h */
src/video/bwindow/SDL_sysevents.cc
View file @ b84dba57
...@@ -39,403 +39,12 @@ extern "C" { ...@@ -39,403 +39,12 @@ extern "C" {
#include "SDL_sysevents.h" #include "SDL_sysevents.h"
#include "SDL_sysevents_c.h" #include "SDL_sysevents_c.h"
/* A note on why the polling loops are necessary.
The BeOS Preview 2 implementation of BView->MouseMoved() only notifies
the view when the mouse enters or leaves the view. The documentation
says that you should loop and use GetMouse() to detect mouse motion.
The BeOS Preview 2 implementation of BView->KeyDown() and BView->KeyUp()
are only called for keys that generate ASCII characters. Since we want
to act like a low level raw keyboard, we need to poll the state of the
keys instead of catching the keys in callbacks.
These are documented portions of the BeBook for Preview Release 2
*/
/* Table to convert scancodes to SDL virtual keys */
static SDLKey keymap[128];
/* Function to convert from a key scancode to a UNICODE character */
static key_map *be_keymap;
static int32 *option_caps_map[2], *option_map[2], *caps_map[2], *normal_map[2];
static char *unicode_map;
static Uint16 TranslateScancode(int scancode)
{
SDLMod modstate;
int shifted;
int32 index; /* Index into system unicode map */
Uint16 unicode;
/* Set the default character -- no character */
unicode = 0;
/* See whether or not the shift state is set */
modstate = SDL_GetModState();
if ( modstate & KMOD_SHIFT ) {
shifted = 1;
} else {
shifted = 0;
}
if ( modstate & KMOD_NUM ) {
/* If numlock is on, numeric keypad keys have shift state inverted */
switch (keymap[scancode]) {
case SDLK_KP0:
case SDLK_KP1:
case SDLK_KP2:
case SDLK_KP3:
case SDLK_KP4:
case SDLK_KP5:
case SDLK_KP6:
case SDLK_KP7:
case SDLK_KP8:
case SDLK_KP9:
case SDLK_KP_PERIOD:
case SDLK_KP_DIVIDE:
case SDLK_KP_MULTIPLY:
case SDLK_KP_MINUS:
case SDLK_KP_PLUS:
case SDLK_KP_ENTER:
case SDLK_KP_EQUALS:
shifted = !shifted;
break;
default:
break;
}
}
/* Get the index based on modifier state */
if ( modstate & KMOD_CTRL )
index = be_keymap->control_map[scancode];
else
if ( (modstate & KMOD_META) && (modstate & KMOD_CAPS) )
index = option_caps_map[shifted][scancode];
else
if ( modstate & KMOD_META )
index = option_map[shifted][scancode];
else
if ( modstate & KMOD_CAPS )
index = caps_map[shifted][scancode];
else
index = normal_map[shifted][scancode];
/* If there is a mapping, convert character from UTF-8 to UNICODE */
if ( unicode_map[index] ) {
int32 state, srclen, dstlen;
unsigned char destbuf[2];
state = 0;
srclen = unicode_map[index++];
dstlen = sizeof(destbuf);
convert_from_utf8(B_UNICODE_CONVERSION,
&unicode_map[index], &srclen, (char *)destbuf, &dstlen,
&state);
unicode = destbuf[0];
unicode <<= 8;
unicode |= destbuf[1];
/* Keyboard input maps newline to carriage return */
if ( unicode == '\n' ) {
unicode = '\r';
}
/* For some reason function keys map to control characters */
# define CTRL(X) ((X)-'@')
switch (unicode) {
case CTRL('A'):
case CTRL('B'):
case CTRL('C'):
case CTRL('D'):
case CTRL('E'):
case CTRL('K'):
case CTRL('L'):
case CTRL('P'):
if ( ! (modstate & KMOD_CTRL) )
unicode = 0;
break;
default:
break;
}
}
return(unicode);
}
/* Function to translate a keyboard transition and queue the key event */
static void QueueKey(int scancode, int pressed)
{
SDL_keysym keysym;
/* Set the keysym information */
keysym.scancode = scancode;
keysym.sym = keymap[scancode];
keysym.mod = KMOD_NONE;
if ( SDL_TranslateUNICODE ) {
keysym.unicode = TranslateScancode(scancode);
} else {
keysym.unicode = 0;
}
/* NUMLOCK and CAPSLOCK are implemented as double-presses in reality */
if ( (keysym.sym == SDLK_NUMLOCK) || (keysym.sym == SDLK_CAPSLOCK) ) {
pressed = 1;
}
/* Queue the key event */
if ( pressed ) {
SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
} else {
SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
}
}
/* This is special because we know it will be run in a loop in a separate
thread. Normally this function should loop as long as there are input
states changing, i.e. new events arriving.
*/
void BE_PumpEvents(_THIS) void BE_PumpEvents(_THIS)
{ {
BView *view;
BRect bounds;
BPoint point;
uint32 buttons;
const uint32 button_masks[3] = {
B_PRIMARY_MOUSE_BUTTON,
B_TERTIARY_MOUSE_BUTTON,
B_SECONDARY_MOUSE_BUTTON,
};
unsigned int i, j;
/* Check out the mouse buttons and position (slight race condition) */
if ( SDL_Win->Lock() ) {
/* Don't do anything if we have no view */
view = SDL_Win->View();
if ( ! view ) {
SDL_Win->Unlock();
return;
}
bounds = view->Bounds();
/* Get new input state, if still active */
if ( SDL_Win->IsActive() ) {
key_flip = !key_flip;
get_key_info(&keyinfo[key_flip]);
view->GetMouse(&point, &buttons, true);
} else {
key_flip = key_flip;
point = last_point;
buttons = last_buttons;
}
SDL_Win->Unlock();
} else {
return;
}
/* If our view is active, we'll find key changes here */
if ( memcmp(keyinfo[0].key_states, keyinfo[1].key_states, 16) != 0 ) {
for ( i=0; i<16; ++i ) {
Uint8 new_state, transition;
new_state = keyinfo[key_flip].key_states[i];
transition = keyinfo[!key_flip].key_states[i] ^
keyinfo[ key_flip].key_states[i];
for ( j=0; j<8; ++j ) {
if ( transition&0x80 )
QueueKey(i*8+j, new_state&0x80);
transition <<= 1;
new_state <<= 1;
}
}
}
/* We check keyboard, but not mouse if mouse isn't in window */
if ( ! bounds.Contains(point) ) {
/* Mouse moved outside our view? */
if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {
SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
be_app->SetCursor(B_HAND_CURSOR);
}
return;
}
/* Has the mouse moved back into our view? */
if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
/* Reset the B_HAND_CURSOR to our own */
SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
SDL_SetCursor(NULL);
}
/* Check for mouse motion */
if ( point != last_point ) {
int x, y;
SDL_Win->GetXYOffset(x, y);
x = (int)point.x - x;
y = (int)point.y - y;
SDL_PrivateMouseMotion(0, 0, x, y);
}
last_point = point;
/* Add any mouse button events */
for ( i=0; i<SDL_TABLESIZE(button_masks); ++i ) {
if ( (buttons ^ last_buttons) & button_masks[i] ) {
if ( buttons & button_masks[i] ) {
SDL_PrivateMouseButton(SDL_PRESSED, 1+i, 0, 0);
} else {
SDL_PrivateMouseButton(SDL_RELEASED, 1+i, 0, 0);
}
}
}
last_buttons = buttons;
} }
void BE_InitOSKeymap(_THIS) void BE_InitOSKeymap(_THIS)
{ {
unsigned int i;
/* Initialize the keyboard state */
key_flip = 0;
get_key_info(&keyinfo[key_flip]);
memcpy(keyinfo[!key_flip].key_states,
keyinfo[key_flip].key_states,
SDL_TABLESIZE(keyinfo[key_flip].key_states));
/* Initialize the BeOS key translation table */
/* Source: <be/interface/InterfaceDefs.h> and BeOS keyboard info */
for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
keymap[i] = SDLK_UNKNOWN;
keymap[0x01] = SDLK_ESCAPE;
keymap[B_F1_KEY] = SDLK_F1;
keymap[B_F2_KEY] = SDLK_F2;
keymap[B_F3_KEY] = SDLK_F3;
keymap[B_F4_KEY] = SDLK_F4;
keymap[B_F5_KEY] = SDLK_F5;
keymap[B_F6_KEY] = SDLK_F6;
keymap[B_F7_KEY] = SDLK_F7;
keymap[B_F8_KEY] = SDLK_F8;
keymap[B_F9_KEY] = SDLK_F9;
keymap[B_F10_KEY] = SDLK_F10;
keymap[B_F11_KEY] = SDLK_F11;
keymap[B_F12_KEY] = SDLK_F12;
keymap[B_PRINT_KEY] = SDLK_PRINT;
//keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK;
keymap[B_PAUSE_KEY] = SDLK_PAUSE;
keymap[0x11] = SDLK_BACKQUOTE;
keymap[0x12] = SDLK_1;
keymap[0x13] = SDLK_2;
keymap[0x14] = SDLK_3;
keymap[0x15] = SDLK_4;
keymap[0x16] = SDLK_5;
keymap[0x17] = SDLK_6;
keymap[0x18] = SDLK_7;
keymap[0x19] = SDLK_8;
keymap[0x1a] = SDLK_9;
keymap[0x1b] = SDLK_0;
keymap[0x1c] = SDLK_MINUS;
keymap[0x1d] = SDLK_EQUALS;
keymap[0x1e] = SDLK_BACKSPACE;
keymap[0x1f] = SDLK_INSERT;
keymap[0x20] = SDLK_HOME;
keymap[0x21] = SDLK_PAGEUP;
//keymap[0x22] = SDLK_NUMLOCK;
keymap[0x23] = SDLK_KP_DIVIDE;
keymap[0x24] = SDLK_KP_MULTIPLY;
keymap[0x25] = SDLK_KP_MINUS;
keymap[0x26] = SDLK_TAB;
keymap[0x27] = SDLK_q;
keymap[0x28] = SDLK_w;
keymap[0x29] = SDLK_e;
keymap[0x2a] = SDLK_r;
keymap[0x2b] = SDLK_t;
keymap[0x2c] = SDLK_y;
keymap[0x2d] = SDLK_u;
keymap[0x2e] = SDLK_i;
keymap[0x2f] = SDLK_o;
keymap[0x30] = SDLK_p;
keymap[0x31] = SDLK_LEFTBRACKET;
keymap[0x32] = SDLK_RIGHTBRACKET;
keymap[0x33] = SDLK_BACKSLASH;
keymap[0x34] = SDLK_DELETE;
keymap[0x35] = SDLK_END;
keymap[0x36] = SDLK_PAGEDOWN;
keymap[0x37] = SDLK_KP7;
keymap[0x38] = SDLK_KP8;
keymap[0x39] = SDLK_KP9;
keymap[0x3a] = SDLK_KP_PLUS;
//keymap[0x3b] = SDLK_CAPSLOCK;
keymap[0x3c] = SDLK_a;
keymap[0x3d] = SDLK_s;
keymap[0x3e] = SDLK_d;
keymap[0x3f] = SDLK_f;
keymap[0x40] = SDLK_g;
keymap[0x41] = SDLK_h;
keymap[0x42] = SDLK_j;
keymap[0x43] = SDLK_k;
keymap[0x44] = SDLK_l;
keymap[0x45] = SDLK_SEMICOLON;
keymap[0x46] = SDLK_QUOTE;
keymap[0x47] = SDLK_RETURN;
keymap[0x48] = SDLK_KP4;
keymap[0x49] = SDLK_KP5;
keymap[0x4a] = SDLK_KP6;
keymap[0x4b] = SDLK_LSHIFT;
keymap[0x4c] = SDLK_z;
keymap[0x4d] = SDLK_x;
keymap[0x4e] = SDLK_c;
keymap[0x4f] = SDLK_v;
keymap[0x50] = SDLK_b;
keymap[0x51] = SDLK_n;
keymap[0x52] = SDLK_m;
keymap[0x53] = SDLK_COMMA;
keymap[0x54] = SDLK_PERIOD;
keymap[0x55] = SDLK_SLASH;
keymap[0x56] = SDLK_RSHIFT;
keymap[0x57] = SDLK_UP;
keymap[0x58] = SDLK_KP1;
keymap[0x59] = SDLK_KP2;
keymap[0x5a] = SDLK_KP3;
keymap[0x5b] = SDLK_KP_ENTER;
//keymap[0x5c] = SDLK_LCTRL;
//keymap[0x5d] = SDLK_LALT;
keymap[0x5e] = SDLK_SPACE;
//keymap[0x5f] = SDLK_RALT;
//keymap[0x60] = SDLK_RCTRL;
keymap[0x61] = SDLK_LEFT;
keymap[0x62] = SDLK_DOWN;
keymap[0x63] = SDLK_RIGHT;
keymap[0x64] = SDLK_KP0;
keymap[0x65] = SDLK_KP_PERIOD;
//keymap[0x66] = SDLK_LMETA;
//keymap[0x67] = SDLK_RMETA;
//keymap[0x68] = SDLK_MENU;
keymap[0x69] = SDLK_EURO;
keymap[0x6a] = SDLK_KP_EQUALS;
keymap[0x6b] = SDLK_POWER;
/* Get the system keymap and UNICODE table.
Note that this leaks memory since the maps are never freed.
*/
get_key_map(&be_keymap, &unicode_map);
/* Set the modifier keys from the system keymap */
keymap[be_keymap->caps_key] = SDLK_CAPSLOCK;
keymap[be_keymap->scroll_key] = SDLK_SCROLLOCK;
keymap[be_keymap->num_key] = SDLK_NUMLOCK;
keymap[be_keymap->left_shift_key] = SDLK_LSHIFT;
keymap[be_keymap->right_shift_key] = SDLK_RSHIFT;
keymap[be_keymap->left_command_key] = SDLK_LALT;
keymap[be_keymap->right_command_key] = SDLK_RALT;
keymap[be_keymap->left_control_key] = SDLK_LCTRL;
keymap[be_keymap->right_control_key] = SDLK_RCTRL;
keymap[be_keymap->left_option_key] = SDLK_LMETA;
keymap[be_keymap->right_option_key] = SDLK_RMETA;
keymap[be_keymap->menu_key] = SDLK_MENU;
/* Set the modifier map pointers */
option_caps_map[0] = be_keymap->option_caps_map;
option_caps_map[1] = be_keymap->option_caps_shift_map;
option_map[0] = be_keymap->option_map;
option_map[1] = be_keymap->option_shift_map;
caps_map[0] = be_keymap->caps_map;
caps_map[1] = be_keymap->caps_shift_map;
normal_map[0] = be_keymap->normal_map;
normal_map[1] = be_keymap->shift_map;
} }
}; /* Extern C */ }; /* Extern C */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment