void SDL_VIDEO_InitSDL(void)
{
if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
Log_print("SDL_INIT_VIDEO FAILED: %s", SDL_GetError());
Log_flushlog();
exit(-1);
}
/* SDL_WM_SetIcon("/usr/local/atari800/atarixe.ICO"), NULL); */
SDL_WM_SetCaption(Atari800_TITLE, "Atari800");
/* Get the desktop resolution */
{
SDL_VideoInfo const * const info = SDL_GetVideoInfo();
desktop_resolution.width = info->current_w;
desktop_resolution.height = info->current_h;
SDL_VIDEO_native_bpp = info->vfmt->BitsPerPixel;
}
#if HAVE_OPENGL
SDL_VIDEO_GL_InitSDL();
if (!SDL_VIDEO_opengl_available)
currently_opengl = SDL_VIDEO_opengl = FALSE;
#endif
SDL_EnableUNICODE(1);
}
int PLATFORM_Exit(int run_monitor)
{
Log_flushlog();
if (run_monitor && MONITOR_Run())
return TRUE;
#ifdef SOUND
Sound_Exit();
#endif
return FALSE;
}
int PLATFORM_Initialise(int *argc, char *argv[])
{
int i, j;
int help_only = FALSE;
for (i = j = 1; i < *argc; i++) {
if (strcmp(argv[i], "-help") == 0) {
help_only = TRUE;
}
argv[j++] = argv[i];
}
*argc = j;
if (!help_only) {
i = SDL_INIT_JOYSTICK
#ifdef SOUND
| SDL_INIT_AUDIO
#endif
#if HAVE_WINDOWS_H
/* Timers are used to avoid one Windows 7 glitch, see src/sdl/input.c */
| SDL_INIT_TIMER
#endif /* HAVE_WINDOWS_H */
;
if (SDL_Init(i) != 0) {
Log_print("SDL_Init FAILED: %s", SDL_GetError());
Log_flushlog();
exit(-1);
}
atexit(SDL_Quit);
}
if (!SDL_VIDEO_Initialise(argc, argv)
#ifdef SOUND
|| !SDL_SOUND_Initialise(argc, argv)
#endif
|| !SDL_INPUT_Initialise(argc, argv))
return FALSE;
return TRUE;
}
int PLATFORM_Exit(int run_monitor)
{
SDL_INPUT_Exit();
/* If the SDL window was left not closed, it would be unusable and hanging
for the time the monitor is active. Also, with SDL_VIDEODRIVER=directx all
keyboard presses in console would be still fetched by the SDL window after
leaving the monitor. To avoid the problems, close the video subsystem. */
SDL_VIDEO_Exit();
Log_flushlog();
if (run_monitor) {
#ifdef SOUND
Sound_Pause();
#endif
if (MONITOR_Run()) {
/* Reinitialise the SDL subsystem. */
#ifdef MONITOR_BREAK
if (!MONITOR_break_step) /*Do not initialise videomode when stepping through code */
#endif
{
SDL_VIDEO_InitSDL();
SDL_INPUT_Restart();
/* This call reopens the SDL window. */
VIDEOMODE_Update();
}
#ifdef SOUND
Sound_Continue();
#endif
return 1;
}
}
#ifdef SOUND
Sound_Exit();
#endif
return 0;
}
int PLATFORM_Exit(int run_monitor)
{
int restart;
SDL_INPUT_Exit();
/* If the SDL window was left not closed, it would be unusable and hanging
for the time the monitor is active. Also, with SDL_VIDEODRIVER=directx all
keyboard presses in console would be still fetched by the SDL window after
leaving the monitor. To avoid the problems, close the video subsystem. */
SDL_VIDEO_Exit();
if (run_monitor) {
#ifdef SOUND
Sound_Pause();
#endif
restart = MONITOR_Run();
#ifdef SOUND
Sound_Continue();
#endif
}
else {
restart = FALSE;
}
if (restart) {
/* Reinitialise the SDL subsystem. */
SDL_VIDEO_InitSDL();
SDL_INPUT_Restart();
/* This call reopens the SDL window. */
VIDEOMODE_Update();
return 1;
}
SDL_Quit();
Log_flushlog();
return restart;
}
int PLATFORM_Keyboard(void)
{
int shiftctrl = 0;
SDL_Event event;
#if HAVE_WINDOWS_H
/* Used to delay resize events on Windows 7, see above. */
enum { RESIZE_INTERVAL = 500 };
static int resize_delayed = FALSE;
static int resize_needed = FALSE;
static int resize_w, resize_h;
#endif /* HAVE_WINDOWS_H */
/* Very ugly fix for SDL CAPSLOCK brokenness. This will let the user
* press CAPSLOCK and get a brief keypress on the Atari but it is not
* possible to emulate holding down CAPSLOCK for longer periods with
* the broken SDL*/
if (lastkey == SDLK_CAPSLOCK) {
lastkey = SDLK_UNKNOWN;
key_pressed = 0;
lastuni = 0;
}
if (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
lastkey = event.key.keysym.sym;
lastuni = event.key.keysym.unicode;
key_pressed = 1;
break;
case SDL_KEYUP:
lastkey = event.key.keysym.sym;
lastuni = 0; /* event.key.keysym.unicode is not defined for KEYUP */
key_pressed = 0;
/* ugly hack to fix broken SDL CAPSLOCK*/
/* Because SDL is only sending Keydown and keyup for every change
* of state of the CAPSLOCK status, rather than the actual key.*/
if(lastkey == SDLK_CAPSLOCK) {
key_pressed = 1;
}
break;
case SDL_VIDEORESIZE:
#if HAVE_WINDOWS_H
/* Delay resize events on Windows 7, see above. */
if (resize_delayed) {
resize_w = event.resize.w;
resize_h = event.resize.h;
resize_needed = TRUE;
} else {
VIDEOMODE_SetWindowSize(event.resize.w, event.resize.h);
resize_delayed = TRUE;
if (SDL_AddTimer(RESIZE_INTERVAL, &ResizeDelayCallback, NULL) == NULL) {
Log_print("Error: SDL_AddTimer failed: %s", SDL_GetError());
Log_flushlog();
exit(-1);
}
}
#else
VIDEOMODE_SetWindowSize(event.resize.w, event.resize.h);
#endif /* HAVE_WINDOWS_H */
break;
case SDL_VIDEOEXPOSE:
/* When window is "uncovered", and we are in the emulator's menu,
we need to refresh display manually. */
PLATFORM_DisplayScreen();
break;
case SDL_QUIT:
return AKEY_EXIT;
break;
#if HAVE_WINDOWS_H
case SDL_USEREVENT:
/* Process delayed video resize on Windows 7, see above. */
if (event.user.code == USER_EVENT_RESIZE_DELAY) {
if (resize_needed) {
SDL_Event events[1];
resize_needed = FALSE;
/* If there's a resize event in the queue,
wait for it and don't resize now. */
if (SDL_PeepEvents(events, 1, SDL_PEEKEVENT, SDL_EVENTMASK(SDL_VIDEORESIZE)) != 0)
resize_delayed = FALSE;
else {
VIDEOMODE_SetWindowSize(resize_w, resize_h);
if (SDL_AddTimer(RESIZE_INTERVAL, &ResizeDelayCallback, NULL) == NULL) {
Log_print("Error: SDL_AddTimer failed: %s", SDL_GetError());
Log_flushlog();
exit(-1);
}
}
} else
resize_delayed = FALSE;
}
break;
#endif /* HAVE_WINDOWS_H */
}
}
else if (!key_pressed)
return AKEY_NONE;
kbhits = SDL_GetKeyState(NULL);
if (kbhits == NULL) {
Log_print("oops, kbhits is NULL!");
Log_flushlog();
exit(-1);
}
UI_alt_function = -1;
if (kbhits[SDLK_LALT]) {
if (key_pressed) {
switch (lastkey) {
case SDLK_f:
key_pressed = 0;
VIDEOMODE_ToggleWindowed();
break;
case SDLK_x:
if (INPUT_key_shift) {
key_pressed = 0;
VIDEOMODE_Toggle80Column();
}
break;
case SDLK_g:
key_pressed = 0;
VIDEOMODE_ToggleHorizontalArea();
break;
case SDLK_j:
key_pressed = 0;
SwapJoysticks();
break;
case SDLK_r:
UI_alt_function = UI_MENU_RUN;
break;
case SDLK_y:
UI_alt_function = UI_MENU_SYSTEM;
break;
case SDLK_o:
UI_alt_function = UI_MENU_SOUND;
break;
case SDLK_w:
UI_alt_function = UI_MENU_SOUND_RECORDING;
break;
case SDLK_a:
UI_alt_function = UI_MENU_ABOUT;
break;
case SDLK_s:
UI_alt_function = UI_MENU_SAVESTATE;
break;
case SDLK_d:
UI_alt_function = UI_MENU_DISK;
break;
case SDLK_l:
UI_alt_function = UI_MENU_LOADSTATE;
break;
case SDLK_c:
UI_alt_function = UI_MENU_CARTRIDGE;
break;
case SDLK_BACKSLASH:
return AKEY_PBI_BB_MENU;
case SDLK_m:
grab_mouse = !grab_mouse;
SDL_WM_GrabInput(grab_mouse ? SDL_GRAB_ON : SDL_GRAB_OFF);
key_pressed = 0;
break;
case SDLK_1:
key_pressed = 0;
if (Atari800_tv_mode == Atari800_TV_NTSC) {
if (kbhits[SDLK_LSHIFT]) {
if (COLOURS_NTSC_specific_setup.hue > COLOURS_NTSC_HUE_MIN)
COLOURS_NTSC_specific_setup.hue -= 0.02;
} else {
if (COLOURS_NTSC_specific_setup.hue < COLOURS_NTSC_HUE_MAX)
COLOURS_NTSC_specific_setup.hue += 0.02;
}
Colours_Update();
}
break;
case SDLK_2:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (Colours_setup->saturation > COLOURS_SATURATION_MIN)
Colours_setup->saturation -= 0.02;
} else {
if (Colours_setup->saturation < COLOURS_SATURATION_MAX)
Colours_setup->saturation += 0.02;
}
Colours_Update();
break;
case SDLK_3:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (Colours_setup->contrast > COLOURS_CONTRAST_MIN)
Colours_setup->contrast -= 0.04;
} else {
if (Colours_setup->contrast < COLOURS_CONTRAST_MAX)
Colours_setup->contrast += 0.04;
}
Colours_Update();
break;
case SDLK_4:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (Colours_setup->brightness > COLOURS_BRIGHTNESS_MIN)
Colours_setup->brightness -= 0.04;
} else {
if (Colours_setup->brightness < COLOURS_BRIGHTNESS_MAX)
Colours_setup->brightness += 0.04;
}
Colours_Update();
break;
case SDLK_5:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (Colours_setup->gamma > COLOURS_GAMMA_MIN)
Colours_setup->gamma -= 0.02;
} else {
if (Colours_setup->gamma < COLOURS_GAMMA_MAX)
Colours_setup->gamma += 0.02;
}
Colours_Update();
break;
case SDLK_6:
key_pressed = 0;
if (Atari800_tv_mode == Atari800_TV_NTSC) {
if (kbhits[SDLK_LSHIFT]) {
if (COLOURS_NTSC_specific_setup.color_delay > COLOURS_NTSC_DELAY_MIN)
COLOURS_NTSC_specific_setup.color_delay -= 0.1;
} else {
if (COLOURS_NTSC_specific_setup.color_delay < COLOURS_NTSC_DELAY_MAX)
COLOURS_NTSC_specific_setup.color_delay += 0.1;
}
Colours_Update();
}
break;
case SDLK_LEFTBRACKET:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT])
SDL_VIDEO_SetScanlinesPercentage(SDL_VIDEO_scanlines_percentage - 5);
else
SDL_VIDEO_SetScanlinesPercentage(SDL_VIDEO_scanlines_percentage + 5);
break;
default:
if(FILTER_NTSC_emu != NULL){
switch(lastkey){
case SDLK_7:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (FILTER_NTSC_setup.sharpness > FILTER_NTSC_SHARPNESS_MIN)
FILTER_NTSC_setup.sharpness -= 0.02;
} else {
if (FILTER_NTSC_setup.sharpness < FILTER_NTSC_SHARPNESS_MAX)
FILTER_NTSC_setup.sharpness += 0.02;
}
FILTER_NTSC_Update(FILTER_NTSC_emu);
break;
case SDLK_8:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (FILTER_NTSC_setup.resolution > FILTER_NTSC_RESOLUTION_MIN)
FILTER_NTSC_setup.resolution -= 0.02;
} else {
if (FILTER_NTSC_setup.resolution < FILTER_NTSC_RESOLUTION_MAX)
FILTER_NTSC_setup.resolution += 0.02;
}
FILTER_NTSC_Update(FILTER_NTSC_emu);
break;
case SDLK_9:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (FILTER_NTSC_setup.artifacts > FILTER_NTSC_ARTIFACTS_MIN)
FILTER_NTSC_setup.artifacts -= 0.02;
} else {
if (FILTER_NTSC_setup.artifacts < FILTER_NTSC_ARTIFACTS_MAX)
FILTER_NTSC_setup.artifacts += 0.02;
}
FILTER_NTSC_Update(FILTER_NTSC_emu);
break;
case SDLK_0:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (FILTER_NTSC_setup.fringing > FILTER_NTSC_FRINGING_MIN)
FILTER_NTSC_setup.fringing -= 0.02;
} else {
if (FILTER_NTSC_setup.fringing < FILTER_NTSC_FRINGING_MAX)
FILTER_NTSC_setup.fringing += 0.02;
}
FILTER_NTSC_Update(FILTER_NTSC_emu);
break;
case SDLK_MINUS:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (FILTER_NTSC_setup.bleed > FILTER_NTSC_BLEED_MIN)
FILTER_NTSC_setup.bleed -= 0.02;
} else {
if (FILTER_NTSC_setup.bleed < FILTER_NTSC_BLEED_MAX)
FILTER_NTSC_setup.bleed += 0.02;
}
FILTER_NTSC_Update(FILTER_NTSC_emu);
break;
case SDLK_EQUALS:
key_pressed = 0;
if (kbhits[SDLK_LSHIFT]) {
if (FILTER_NTSC_setup.burst_phase > FILTER_NTSC_BURST_PHASE_MIN)
FILTER_NTSC_setup.burst_phase -= 0.02;
} else {
if (FILTER_NTSC_setup.burst_phase < FILTER_NTSC_BURST_PHASE_MAX)
FILTER_NTSC_setup.burst_phase += 0.02;
}
FILTER_NTSC_Update(FILTER_NTSC_emu);
break;
case SDLK_RIGHTBRACKET:
key_pressed = 0;
FILTER_NTSC_NextPreset();
FILTER_NTSC_Update(FILTER_NTSC_emu);
break;
}
}
break;
}
}
}
/* SHIFT STATE */
if ((kbhits[SDLK_LSHIFT]) || (kbhits[SDLK_RSHIFT]))
INPUT_key_shift = 1;
else
INPUT_key_shift = 0;
/* CONTROL STATE */
if ((kbhits[SDLK_LCTRL]) || (kbhits[SDLK_RCTRL]))
key_control = 1;
else
key_control = 0;
/*
if (event.type == 2 || event.type == 3) {
Log_print("E:%x S:%x C:%x K:%x U:%x M:%x",event.type,INPUT_key_shift,key_control,lastkey,event.key.keysym.unicode,event.key.keysym.mod);
}
*/
/* OPTION / SELECT / START keys */
INPUT_key_consol = INPUT_CONSOL_NONE;
if (kbhits[SDLK_F2])
INPUT_key_consol &= (~INPUT_CONSOL_OPTION);
if (kbhits[SDLK_F3])
INPUT_key_consol &= (~INPUT_CONSOL_SELECT);
if (kbhits[SDLK_F4])
INPUT_key_consol &= (~INPUT_CONSOL_START);
if (key_pressed == 0)
return AKEY_NONE;
/* Handle movement and special keys. */
switch (lastkey) {
case SDLK_F1:
key_pressed = 0;
return AKEY_UI;
case SDLK_F5:
key_pressed = 0;
return INPUT_key_shift ? AKEY_COLDSTART : AKEY_WARMSTART;
case SDLK_F8:
UI_alt_function = UI_MENU_MONITOR;
break;
case SDLK_F9:
return AKEY_EXIT;
case SDLK_F10:
key_pressed = 0;
return INPUT_key_shift ? AKEY_SCREENSHOT_INTERLACE : AKEY_SCREENSHOT_INTERLACE;
case SDLK_F12:
key_pressed = 0;
return AKEY_TURBO;
}
if (UI_alt_function != -1) {
key_pressed = 0;
return AKEY_UI;
}
/* keyboard joysticks: don't pass the keypresses to emulation
* as some games pause on a keypress (River Raid, Bruce Lee)
*/
if (!UI_is_active && PLATFORM_kbd_joy_0_enabled) {
if (lastkey == KBD_STICK_0_LEFT || lastkey == KBD_STICK_0_RIGHT ||
lastkey == KBD_STICK_0_UP || lastkey == KBD_STICK_0_DOWN || lastkey == KBD_TRIG_0) {
key_pressed = 0;
return AKEY_NONE;
}
}
if (!UI_is_active && PLATFORM_kbd_joy_1_enabled) {
if (lastkey == KBD_STICK_1_LEFT || lastkey == KBD_STICK_1_RIGHT ||
lastkey == KBD_STICK_1_UP || lastkey == KBD_STICK_1_DOWN || lastkey == KBD_TRIG_1) {
key_pressed = 0;
return AKEY_NONE;
}
}
if (INPUT_key_shift)
shiftctrl ^= AKEY_SHFT;
if (Atari800_machine_type == Atari800_MACHINE_5200 && !UI_is_active) {
if (lastkey == SDLK_F4)
return AKEY_5200_START ^ shiftctrl;
switch (lastuni) {
case 'p':
return AKEY_5200_PAUSE ^ shiftctrl;
case 'r':
return AKEY_5200_RESET ^ shiftctrl;
case '0':
return AKEY_5200_0 ^ shiftctrl;
case '1':
return AKEY_5200_1 ^ shiftctrl;
case '2':
return AKEY_5200_2 ^ shiftctrl;
case '3':
return AKEY_5200_3 ^ shiftctrl;
case '4':
return AKEY_5200_4 ^ shiftctrl;
case '5':
return AKEY_5200_5 ^ shiftctrl;
case '6':
return AKEY_5200_6 ^ shiftctrl;
case '7':
return AKEY_5200_7 ^ shiftctrl;
case '8':
return AKEY_5200_8 ^ shiftctrl;
case '9':
return AKEY_5200_9 ^ shiftctrl;
case '#':
case '=':
return AKEY_5200_HASH ^ shiftctrl;
case '*':
return AKEY_5200_ASTERISK ^ shiftctrl;
}
return AKEY_NONE;
}
if (key_control)
shiftctrl ^= AKEY_CTRL;
switch (lastkey) {
case SDLK_BACKQUOTE: /* fallthrough */
/* These are the "Windows" keys, but they don't work on Windows*/
case SDLK_LSUPER:
return AKEY_ATARI ^ shiftctrl;
case SDLK_RSUPER:
if (INPUT_key_shift)
return AKEY_CAPSLOCK;
else
return AKEY_CAPSTOGGLE;
case SDLK_END:
case SDLK_F6:
return AKEY_HELP ^ shiftctrl;
case SDLK_PAGEDOWN:
return AKEY_F2 | AKEY_SHFT;
case SDLK_PAGEUP:
return AKEY_F1 | AKEY_SHFT;
case SDLK_HOME:
return key_control ? AKEY_LESS|shiftctrl : AKEY_CLEAR;
case SDLK_PAUSE:
case SDLK_F7:
return AKEY_BREAK;
case SDLK_CAPSLOCK:
if (INPUT_key_shift)
return AKEY_CAPSLOCK|shiftctrl;
else
return AKEY_CAPSTOGGLE|shiftctrl;
case SDLK_SPACE:
return AKEY_SPACE ^ shiftctrl;
case SDLK_BACKSPACE:
return AKEY_BACKSPACE|shiftctrl;
case SDLK_RETURN:
return AKEY_RETURN ^ shiftctrl;
case SDLK_LEFT:
return (INPUT_key_shift ? AKEY_PLUS : AKEY_LEFT) ^ shiftctrl;
case SDLK_RIGHT:
return (INPUT_key_shift ? AKEY_ASTERISK : AKEY_RIGHT) ^ shiftctrl;
case SDLK_UP:
return (INPUT_key_shift ? AKEY_MINUS : AKEY_UP) ^ shiftctrl;
case SDLK_DOWN:
return (INPUT_key_shift ? AKEY_EQUAL : AKEY_DOWN) ^ shiftctrl;
case SDLK_ESCAPE:
/* Windows takes ctrl+esc and ctrl+shift+esc */
return AKEY_ESCAPE ^ shiftctrl;
case SDLK_TAB:
#if HAVE_WINDOWS_H
/* On Windows, when an SDL window has focus and LAlt+Tab is pressed,
a window-switching menu appears, but the LAlt+Tab key sequence is
still forwarded to the SDL window. In the effect the user cannot
switch with LAlt+Tab without the emulator registering unwanted key
presses. On other operating systems (e.g. GNU/Linux/KDE) everything
is OK, the key sequence is not registered by the emulator. This
hack fixes the behaviour on Windows. */
if (kbhits[SDLK_LALT]) {
key_pressed = 0;
/* 1. In fullscreen software (non-OpenGL) mode, user presses LAlt, then presses Tab.
Atari800 window gets minimised and the window-switching menu appears.
2. User switches back to Atari800 without releasing LAlt.
3. User releases LAlt. Atari800 gets switched back to fullscreen.
In the above situation, the emulator would register pressing of LAlt but
would not register releasing of the key. It would think that LAlt is still
pressed. The hack below fixes the issue by causing SDL to assume LAlt is
not pressed. */
#if HAVE_OPENGL
if (!VIDEOMODE_windowed && !SDL_VIDEO_opengl)
#else
if (!VIDEOMODE_windowed)
#endif /* HAVE_OPENGL */
kbhits[SDLK_LALT] = 0;
return AKEY_NONE;
}
#endif /* HAVE_WINDOWS_H */
return AKEY_TAB ^ shiftctrl;
case SDLK_DELETE:
if (INPUT_key_shift)
return AKEY_DELETE_LINE|shiftctrl;
else
return AKEY_DELETE_CHAR;
case SDLK_INSERT:
if (INPUT_key_shift)
return AKEY_INSERT_LINE|shiftctrl;
else
return AKEY_INSERT_CHAR;
}
if (INPUT_cx85) switch (lastkey) {
case SDLK_KP1:
return AKEY_CX85_1;
case SDLK_KP2:
return AKEY_CX85_2;
case SDLK_KP3:
return AKEY_CX85_3;
case SDLK_KP4:
return AKEY_CX85_4;
case SDLK_KP5:
return AKEY_CX85_5;
case SDLK_KP6:
return AKEY_CX85_6;
case SDLK_KP7:
return AKEY_CX85_7;
case SDLK_KP8:
return AKEY_CX85_8;
case SDLK_KP9:
return AKEY_CX85_9;
case SDLK_KP0:
return AKEY_CX85_0;
case SDLK_KP_PERIOD:
return AKEY_CX85_PERIOD;
case SDLK_KP_MINUS:
return AKEY_CX85_MINUS;
case SDLK_KP_ENTER:
return AKEY_CX85_PLUS_ENTER;
case SDLK_KP_DIVIDE:
return (key_control ? AKEY_CX85_ESCAPE : AKEY_CX85_NO);
case SDLK_KP_MULTIPLY:
return AKEY_CX85_DELETE;
case SDLK_KP_PLUS:
return AKEY_CX85_YES;
}
/* Handle CTRL-0 to CTRL-9 and other control characters */
if (key_control) {
switch(lastuni) {
case '.':
return AKEY_FULLSTOP|shiftctrl;
case ',':
return AKEY_COMMA|shiftctrl;
case ';':
return AKEY_SEMICOLON|shiftctrl;
}
switch (lastkey) {
case SDLK_PERIOD:
return AKEY_FULLSTOP|shiftctrl;
case SDLK_COMMA:
return AKEY_COMMA|shiftctrl;
case SDLK_SEMICOLON:
return AKEY_SEMICOLON|shiftctrl;
case SDLK_SLASH:
return AKEY_SLASH|shiftctrl;
case SDLK_BACKSLASH:
/* work-around for Windows */
return AKEY_ESCAPE|shiftctrl;
case SDLK_0:
return AKEY_CTRL_0|shiftctrl;
case SDLK_1:
return AKEY_CTRL_1|shiftctrl;
case SDLK_2:
return AKEY_CTRL_2|shiftctrl;
case SDLK_3:
return AKEY_CTRL_3|shiftctrl;
case SDLK_4:
return AKEY_CTRL_4|shiftctrl;
case SDLK_5:
return AKEY_CTRL_5|shiftctrl;
case SDLK_6:
return AKEY_CTRL_6|shiftctrl;
case SDLK_7:
return AKEY_CTRL_7|shiftctrl;
case SDLK_8:
return AKEY_CTRL_8|shiftctrl;
case SDLK_9:
return AKEY_CTRL_9|shiftctrl;
}
}
/* Host Caps Lock will make lastuni switch case, so prevent this*/
if(lastuni>='A' && lastuni <= 'Z' && !INPUT_key_shift) lastuni += 0x20;
if(lastuni>='a' && lastuni <= 'z' && INPUT_key_shift) lastuni -= 0x20;
/* Uses only UNICODE translation, no shift states (this was added to
* support non-US keyboard layouts)*/
/* input.c takes care of removing invalid shift+control keys */
switch (lastuni) {
case 1:
return AKEY_CTRL_a|shiftctrl;
case 2:
return AKEY_CTRL_b|shiftctrl;
case 3:
return AKEY_CTRL_c|shiftctrl;
case 4:
return AKEY_CTRL_d|shiftctrl;
case 5:
return AKEY_CTRL_e|shiftctrl;
case 6:
return AKEY_CTRL_f|shiftctrl;
case 7:
return AKEY_CTRL_g|shiftctrl;
case 8:
return AKEY_CTRL_h|shiftctrl;
case 9:
return AKEY_CTRL_i|shiftctrl;
case 10:
return AKEY_CTRL_j|shiftctrl;
case 11:
return AKEY_CTRL_k|shiftctrl;
case 12:
return AKEY_CTRL_l|shiftctrl;
case 13:
return AKEY_CTRL_m|shiftctrl;
case 14:
return AKEY_CTRL_n|shiftctrl;
case 15:
return AKEY_CTRL_o|shiftctrl;
case 16:
return AKEY_CTRL_p|shiftctrl;
case 17:
return AKEY_CTRL_q|shiftctrl;
case 18:
return AKEY_CTRL_r|shiftctrl;
case 19:
return AKEY_CTRL_s|shiftctrl;
case 20:
return AKEY_CTRL_t|shiftctrl;
case 21:
return AKEY_CTRL_u|shiftctrl;
case 22:
return AKEY_CTRL_v|shiftctrl;
case 23:
return AKEY_CTRL_w|shiftctrl;
case 24:
return AKEY_CTRL_x|shiftctrl;
case 25:
return AKEY_CTRL_y|shiftctrl;
case 26:
return AKEY_CTRL_z|shiftctrl;
case 'A':
return AKEY_A;
case 'B':
return AKEY_B;
case 'C':
return AKEY_C;
case 'D':
return AKEY_D;
case 'E':
return AKEY_E;
case 'F':
return AKEY_F;
case 'G':
return AKEY_G;
case 'H':
return AKEY_H;
case 'I':
return AKEY_I;
case 'J':
return AKEY_J;
case 'K':
return AKEY_K;
case 'L':
return AKEY_L;
case 'M':
return AKEY_M;
case 'N':
return AKEY_N;
case 'O':
return AKEY_O;
case 'P':
return AKEY_P;
case 'Q':
return AKEY_Q;
case 'R':
return AKEY_R;
case 'S':
return AKEY_S;
case 'T':
return AKEY_T;
case 'U':
return AKEY_U;
case 'V':
return AKEY_V;
case 'W':
return AKEY_W;
case 'X':
return AKEY_X;
case 'Y':
return AKEY_Y;
case 'Z':
return AKEY_Z;
case ':':
return AKEY_COLON;
case '!':
return AKEY_EXCLAMATION;
case '@':
return AKEY_AT;
case '#':
return AKEY_HASH;
case '$':
return AKEY_DOLLAR;
case '%':
return AKEY_PERCENT;
case '^':
return AKEY_CARET;
case '&':
return AKEY_AMPERSAND;
case '*':
return AKEY_ASTERISK;
case '(':
return AKEY_PARENLEFT;
case ')':
return AKEY_PARENRIGHT;
case '+':
return AKEY_PLUS;
case '_':
return AKEY_UNDERSCORE;
case '"':
return AKEY_DBLQUOTE;
case '?':
return AKEY_QUESTION;
case '<':
return AKEY_LESS;
case '>':
return AKEY_GREATER;
case 'a':
return AKEY_a;
case 'b':
return AKEY_b;
case 'c':
return AKEY_c;
case 'd':
return AKEY_d;
case 'e':
return AKEY_e;
case 'f':
return AKEY_f;
case 'g':
return AKEY_g;
case 'h':
return AKEY_h;
case 'i':
return AKEY_i;
case 'j':
return AKEY_j;
case 'k':
return AKEY_k;
case 'l':
return AKEY_l;
case 'm':
return AKEY_m;
case 'n':
return AKEY_n;
case 'o':
return AKEY_o;
case 'p':
return AKEY_p;
case 'q':
return AKEY_q;
case 'r':
return AKEY_r;
case 's':
return AKEY_s;
case 't':
return AKEY_t;
case 'u':
return AKEY_u;
case 'v':
return AKEY_v;
case 'w':
return AKEY_w;
case 'x':
return AKEY_x;
case 'y':
return AKEY_y;
case 'z':
return AKEY_z;
case ';':
return AKEY_SEMICOLON;
case '0':
return AKEY_0;
case '1':
return AKEY_1;
case '2':
return AKEY_2;
case '3':
return AKEY_3;
case '4':
return AKEY_4;
case '5':
return AKEY_5;
case '6':
return AKEY_6;
case '7':
return AKEY_7;
case '8':
return AKEY_8;
case '9':
return AKEY_9;
case ',':
return AKEY_COMMA;
case '.':
return AKEY_FULLSTOP;
case '=':
return AKEY_EQUAL;
case '-':
return AKEY_MINUS;
case '\'':
return AKEY_QUOTE;
case '/':
return AKEY_SLASH;
case '\\':
return AKEY_BACKSLASH;
case '[':
return AKEY_BRACKETLEFT;
case ']':
return AKEY_BRACKETRIGHT;
case '|':
return AKEY_BAR;
}
return AKEY_NONE;
}
int SDL_INPUT_Initialise(int *argc, char *argv[])
{
/* TODO check for errors! */
#ifdef LPTJOY
char *lpt_joy0 = NULL;
char *lpt_joy1 = NULL;
#endif /* LPTJOY */
int i;
int j;
int no_joystick = FALSE;
int help_only = FALSE;
for (i = j = 1; i < *argc; i++) {
#ifdef LPTJOY
int i_a = (i + 1 < *argc); /* is argument available? */
#endif /* LPTJOY */
int a_m = FALSE; /* error, argument missing! */
if (strcmp(argv[i], "-nojoystick") == 0) {
no_joystick = TRUE;
Log_print("no joystick");
}
else if (strcmp(argv[i], "-grabmouse") == 0) {
grab_mouse = TRUE;
}
#ifdef LPTJOY
else if (strcmp(argv[i], "-joy0") == 0) {
if (i_a) {
lpt_joy0 = argv[++i];
}
else a_m = TRUE;
}
else if (!strcmp(argv[i], "-joy1")) {
if (i_a) {
lpt_joy1 = argv[++i];
}
else a_m = TRUE;
}
#endif /* LPTJOY */
else {
if (strcmp(argv[i], "-help") == 0) {
help_only = TRUE;
Log_print("\t-nojoystick Disable joystick");
#ifdef LPTJOY
Log_print("\t-joy0 <pathname> Select LPTjoy0 device");
Log_print("\t-joy1 <pathname> Select LPTjoy1 device");
#endif /* LPTJOY */
Log_print("\t-grabmouse Prevent mouse pointer from leaving window");
}
argv[j++] = argv[i];
}
if (a_m) {
Log_print("Missing argument for '%s'", argv[i]);
return FALSE;
}
}
*argc = j;
if (help_only || no_joystick)
return TRUE;
#ifdef LPTJOY
if (lpt_joy0 != NULL) { /* LPT1 joystick */
fd_joystick0 = open(lpt_joy0, O_RDONLY);
if (fd_joystick0 == -1)
perror(lpt_joy0);
}
if (lpt_joy1 != NULL) { /* LPT2 joystick */
fd_joystick1 = open(lpt_joy1, O_RDONLY);
if (fd_joystick1 == -1)
perror(lpt_joy1);
}
#endif /* LPTJOY */
Init_SDL_Joysticks(fd_joystick0 == -1, fd_joystick1 == -1);
if (INPUT_cx85) { /* disable keyboard joystick if using CX85 numpad */
PLATFORM_kbd_joy_0_enabled = 0;
}
if(grab_mouse)
SDL_WM_GrabInput(SDL_GRAB_ON);
kbhits = SDL_GetKeyState(NULL);
if (kbhits == NULL) {
Log_print("SDL_GetKeyState() failed");
Log_flushlog();
return FALSE;
}
return TRUE;
}
