1379 lines
31 KiB
C++
1379 lines
31 KiB
C++
#include <algorithm>
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <sstream>
|
|
#include <guichan.hpp>
|
|
#include <guichan/sdl.hpp>
|
|
#include "sysconfig.h"
|
|
#include "sysdeps.h"
|
|
#include "config.h"
|
|
#include "uae.h"
|
|
#include "options.h"
|
|
#include "keybuf.h"
|
|
#include "inputdevice.h"
|
|
#include "memory.h"
|
|
#include "zfile.h"
|
|
#include "gui.h"
|
|
#include "od-pandora/gui/SelectorEntry.hpp"
|
|
#include "gui/gui_handling.h"
|
|
#include "custom.h"
|
|
#include "memory.h"
|
|
#include "xwin.h"
|
|
#include "drawing.h"
|
|
#include "sd-pandora/sound.h"
|
|
#include "audio.h"
|
|
#include "keybuf.h"
|
|
#include "keyboard.h"
|
|
#include "disk.h"
|
|
#include "savestate.h"
|
|
#include <SDL.h>
|
|
|
|
|
|
int emulating = 0;
|
|
extern bool switch_autofire;
|
|
static int justMovedUp=0, justMovedDown=0, justMovedLeft=0, justMovedRight=0;
|
|
static int justPressedA=0, justPressedB=0, justPressedX=0, justPressedY=0;
|
|
static int justPressedL=0, justPressedR=0;
|
|
int stylusClickOverride=0;
|
|
int stylusAdjustX=0, stylusAdjustY=0;
|
|
|
|
|
|
extern SDL_Surface *prSDLScreen;
|
|
|
|
int dpadUp=0;
|
|
int dpadDown=0;
|
|
int dpadLeft=0;
|
|
int dpadRight=0;
|
|
int buttonA=0;
|
|
int buttonB=0;
|
|
int buttonX=0;
|
|
int buttonY=0;
|
|
int triggerL=0;
|
|
int triggerR=0;
|
|
|
|
struct gui_msg {
|
|
int num;
|
|
const char *msg;
|
|
};
|
|
struct gui_msg gui_msglist[] = {
|
|
{ NUMSG_NOROM, "Could not load system ROM, trying system ROM replacement." },
|
|
{ NUMSG_NOROMKEY, "Could not find system ROM key file." },
|
|
{ NUMSG_KSROMCRCERROR, "System ROM checksum incorrect. The system ROM image file may be corrupt." },
|
|
{ NUMSG_KSROMREADERROR, "Error while reading system ROM." },
|
|
{ NUMSG_NOEXTROM, "No extended ROM found." },
|
|
{ NUMSG_KS68EC020, "The selected system ROM requires a 68EC020 or later CPU." },
|
|
{ NUMSG_KS68020, "The selected system ROM requires a 68020 or later CPU." },
|
|
{ NUMSG_KS68030, "The selected system ROM requires a 68030 CPU." },
|
|
{ NUMSG_STATEHD, "WARNING: Current configuration is not fully compatible with state saves." },
|
|
{ NUMSG_KICKREP, "You need to have a floppy disk (image file) in DF0: to use the system ROM replacement." },
|
|
{ NUMSG_KICKREPNO, "The floppy disk (image file) in DF0: is not compatible with the system ROM replacement functionality." },
|
|
{ -1, "" }
|
|
};
|
|
|
|
std::vector<ConfigFileInfo*> ConfigFilesList;
|
|
std::vector<AvailableROM*> lstAvailableROMs;
|
|
std::vector<std::string> lstMRUDiskList;
|
|
|
|
|
|
void AddFileToDiskList(const char *file, int moveToTop)
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i<lstMRUDiskList.size(); ++i)
|
|
{
|
|
if(!strcasecmp(lstMRUDiskList[i].c_str(), file))
|
|
{
|
|
if(moveToTop)
|
|
{
|
|
lstMRUDiskList.erase(lstMRUDiskList.begin() + i);
|
|
lstMRUDiskList.insert(lstMRUDiskList.begin(), file);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if(i >= lstMRUDiskList.size())
|
|
lstMRUDiskList.insert(lstMRUDiskList.begin(), file);
|
|
|
|
while(lstMRUDiskList.size() > MAX_MRU_DISKLIST)
|
|
lstMRUDiskList.pop_back();
|
|
}
|
|
|
|
|
|
static void ClearAvailableROMList(void)
|
|
{
|
|
while(lstAvailableROMs.size() > 0)
|
|
{
|
|
AvailableROM *tmp = lstAvailableROMs[0];
|
|
lstAvailableROMs.erase(lstAvailableROMs.begin());
|
|
delete tmp;
|
|
}
|
|
}
|
|
|
|
static void addrom(struct romdata *rd, char *path)
|
|
{
|
|
AvailableROM *tmp;
|
|
tmp = new AvailableROM();
|
|
strncpy(tmp->Name, rd->name, MAX_PATH);
|
|
strncpy(tmp->Path, path, MAX_PATH);
|
|
tmp->ROMType = rd->type;
|
|
lstAvailableROMs.push_back(tmp);
|
|
}
|
|
|
|
struct romscandata {
|
|
uae_u8 *keybuf;
|
|
int keysize;
|
|
};
|
|
|
|
static struct romdata *scan_single_rom_2 (struct zfile *f, uae_u8 *keybuf, int keysize)
|
|
{
|
|
uae_u8 buffer[20] = { 0 };
|
|
uae_u8 *rombuf;
|
|
int cl = 0, size;
|
|
struct romdata *rd = 0;
|
|
|
|
zfile_fseek (f, 0, SEEK_END);
|
|
size = zfile_ftell (f);
|
|
zfile_fseek (f, 0, SEEK_SET);
|
|
if (size > 524288 * 2) /* don't skip KICK disks or 1M ROMs */
|
|
return 0;
|
|
zfile_fread (buffer, 1, 11, f);
|
|
if (!memcmp (buffer, "KICK", 4)) {
|
|
zfile_fseek (f, 512, SEEK_SET);
|
|
if (size > 262144)
|
|
size = 262144;
|
|
} else if (!memcmp (buffer, "AMIROMTYPE1", 11)) {
|
|
cl = 1;
|
|
if (keybuf == 0)
|
|
cl = -1;
|
|
size -= 11;
|
|
} else {
|
|
zfile_fseek (f, 0, SEEK_SET);
|
|
}
|
|
rombuf = (uae_u8 *) xcalloc (size, 1);
|
|
if (!rombuf)
|
|
return 0;
|
|
zfile_fread (rombuf, 1, size, f);
|
|
if (cl > 0) {
|
|
decode_cloanto_rom_do (rombuf, size, size, keybuf, keysize);
|
|
cl = 0;
|
|
}
|
|
if (!cl)
|
|
rd = getromdatabydata (rombuf, size);
|
|
free (rombuf);
|
|
return rd;
|
|
}
|
|
|
|
static int isromext(char *path)
|
|
{
|
|
char *ext = strrchr (path, '.');
|
|
int i;
|
|
|
|
if (!ext)
|
|
return 0;
|
|
ext++;
|
|
|
|
if (!stricmp (ext, "rom") || !stricmp (ext, "adf") || !stricmp (ext, "key")
|
|
|| !stricmp (ext, "a500") || !stricmp (ext, "a1200") || !stricmp (ext, "a4000"))
|
|
return 1;
|
|
for (i = 0; uae_archive_extensions[i]; i++) {
|
|
if (!stricmp (ext, uae_archive_extensions[i]))
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int scan_rom_2 (struct zfile *f, void *rsd)
|
|
{
|
|
char *path = zfile_getname(f);
|
|
struct romdata *rd;
|
|
|
|
if (!isromext(path))
|
|
return 0;
|
|
rd = scan_single_rom_2(f, ((struct romscandata *)rsd)->keybuf, ((struct romscandata *)rsd)->keysize);
|
|
if (rd)
|
|
addrom (rd, path);
|
|
return 0;
|
|
}
|
|
|
|
static void scan_rom(char *path, uae_u8 *keybuf, int keysize)
|
|
{
|
|
struct romdata *rd;
|
|
struct romscandata rsd = { keybuf, keysize };
|
|
|
|
if (!isromext(path)) {
|
|
//write_log("ROMSCAN: skipping file '%s', unknown extension\n", path);
|
|
return;
|
|
}
|
|
rd = getarcadiarombyname(path);
|
|
if (rd)
|
|
addrom(rd, path);
|
|
else
|
|
zfile_zopen (path, scan_rom_2, &rsd);
|
|
}
|
|
|
|
|
|
void RescanROMs(void)
|
|
{
|
|
int keysize;
|
|
uae_u8 *keybuf;
|
|
std::vector<std::string> files;
|
|
char path[MAX_DPATH];
|
|
|
|
ClearAvailableROMList();
|
|
fetch_rompath(path, MAX_DPATH);
|
|
|
|
keybuf = load_keyfile (&changed_prefs, path, &keysize);
|
|
ReadDirectory(path, NULL, &files);
|
|
for(int i=0; i<files.size(); ++i)
|
|
{
|
|
char tmppath[MAX_PATH];
|
|
strncpy(tmppath, path, MAX_PATH);
|
|
strncat(tmppath, files[i].c_str(), MAX_PATH);
|
|
scan_rom (tmppath, keybuf, keysize);
|
|
}
|
|
free_keyfile (keybuf);
|
|
}
|
|
|
|
static void ClearConfigFileList(void)
|
|
{
|
|
while(ConfigFilesList.size() > 0)
|
|
{
|
|
ConfigFileInfo *tmp = ConfigFilesList[0];
|
|
ConfigFilesList.erase(ConfigFilesList.begin());
|
|
delete tmp;
|
|
}
|
|
}
|
|
|
|
|
|
void ReadConfigFileList(void)
|
|
{
|
|
char path[MAX_PATH];
|
|
std::vector<std::string> files;
|
|
const char *filter_uae[] = { ".uae", "\0" };
|
|
const char *filter_conf[] = { ".conf", "\0" };
|
|
|
|
ClearConfigFileList();
|
|
|
|
fetch_configurationpath(path, MAX_PATH);
|
|
ReadDirectory(path, NULL, &files);
|
|
FilterFiles(&files, filter_uae);
|
|
for (int i=0; i<files.size(); ++i)
|
|
{
|
|
ConfigFileInfo *tmp = new ConfigFileInfo();
|
|
strncpy(tmp->FullPath, path, MAX_DPATH);
|
|
strcat(tmp->FullPath, files[i].c_str());
|
|
strncpy(tmp->Name, files[i].c_str(), MAX_DPATH);
|
|
removeFileExtension(tmp->Name);
|
|
cfgfile_get_description(tmp->FullPath, tmp->Description);
|
|
ConfigFilesList.push_back(tmp);
|
|
}
|
|
|
|
// Read also old style configs
|
|
ReadDirectory(path, NULL, &files);
|
|
FilterFiles(&files, filter_conf);
|
|
for (int i=0; i<files.size(); ++i)
|
|
{
|
|
if(strcmp(files[i].c_str(), "adfdir.conf"))
|
|
{
|
|
ConfigFileInfo *tmp = new ConfigFileInfo();
|
|
strncpy(tmp->FullPath, path, MAX_DPATH);
|
|
strcat(tmp->FullPath, files[i].c_str());
|
|
strncpy(tmp->Name, files[i].c_str(), MAX_DPATH);
|
|
removeFileExtension(tmp->Name);
|
|
strcpy(tmp->Description, "Old style configuration file");
|
|
for(int j=0; j<ConfigFilesList.size(); ++j)
|
|
{
|
|
if(!strcmp(ConfigFilesList[j]->Name, tmp->Name))
|
|
{
|
|
// Config in new style already in list
|
|
delete tmp;
|
|
tmp = NULL;
|
|
break;
|
|
}
|
|
}
|
|
if(tmp != NULL)
|
|
ConfigFilesList.push_back(tmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
ConfigFileInfo* SearchConfigInList(const char *name)
|
|
{
|
|
for(int i=0; i<ConfigFilesList.size(); ++i)
|
|
{
|
|
if(!strncasecmp(ConfigFilesList[i]->Name, name, MAX_DPATH))
|
|
return ConfigFilesList[i];
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static void prefs_to_gui()
|
|
{
|
|
/* filesys hack */
|
|
changed_prefs.mountitems = currprefs.mountitems;
|
|
memcpy(&changed_prefs.mountconfig, &currprefs.mountconfig, MOUNT_CONFIG_SIZE * sizeof (struct uaedev_config_info));
|
|
}
|
|
|
|
|
|
static void gui_to_prefs (void)
|
|
{
|
|
/* filesys hack */
|
|
currprefs.mountitems = changed_prefs.mountitems;
|
|
memcpy(&currprefs.mountconfig, &changed_prefs.mountconfig, MOUNT_CONFIG_SIZE * sizeof (struct uaedev_config_info));
|
|
}
|
|
|
|
|
|
int gui_init (void)
|
|
{
|
|
int ret = 0;
|
|
|
|
#ifndef ANDROIDSDL
|
|
SDL_JoystickEventState(SDL_ENABLE);
|
|
SDL_JoystickOpen(0);
|
|
#endif
|
|
|
|
emulating=0;
|
|
|
|
if(lstAvailableROMs.size() == 0)
|
|
RescanROMs();
|
|
|
|
graphics_subshutdown();
|
|
prefs_to_gui();
|
|
run_gui();
|
|
gui_to_prefs();
|
|
if(quit_program < 0)
|
|
quit_program = -quit_program;
|
|
if(quit_program == 1)
|
|
ret = -2; // Quit without start of emulator
|
|
|
|
setCpuSpeed();
|
|
update_display(&changed_prefs);
|
|
|
|
inputmode_init();
|
|
inputdevice_copyconfig (&changed_prefs, &currprefs);
|
|
inputdevice_config_change_test();
|
|
emulating=1;
|
|
return ret;
|
|
}
|
|
|
|
void gui_exit(void)
|
|
{
|
|
resetCpuSpeed();
|
|
sync();
|
|
pandora_stop_sound();
|
|
saveAdfDir();
|
|
ClearConfigFileList();
|
|
ClearAvailableROMList();
|
|
}
|
|
|
|
|
|
void gui_purge_events(void)
|
|
{
|
|
int counter = 0;
|
|
|
|
SDL_Event event;
|
|
SDL_Delay(150);
|
|
// Strangely PS3 controller always send events, so we need a maximum number of event to purge.
|
|
while(SDL_PollEvent(&event) && counter < 50)
|
|
{
|
|
counter++;
|
|
SDL_Delay(10);
|
|
}
|
|
keybuf_init();
|
|
}
|
|
|
|
|
|
int gui_update (void)
|
|
{
|
|
char tmp[MAX_PATH];
|
|
|
|
fetch_savestatepath(savestate_fname, MAX_DPATH);
|
|
fetch_screenshotpath(screenshot_filename, MAX_DPATH);
|
|
|
|
if(strlen(currprefs.df[0]) > 0)
|
|
extractFileName(currprefs.df[0], tmp);
|
|
else
|
|
strncpy(tmp, last_loaded_config, MAX_PATH);
|
|
|
|
strncat(savestate_fname, tmp, MAX_DPATH);
|
|
strncat(screenshot_filename, tmp, MAX_DPATH);
|
|
removeFileExtension(savestate_fname);
|
|
removeFileExtension(screenshot_filename);
|
|
|
|
switch(currentStateNum)
|
|
{
|
|
case 1:
|
|
strcat(savestate_fname,"-1.uss");
|
|
strcat(screenshot_filename,"-1.png");
|
|
break;
|
|
case 2:
|
|
strcat(savestate_fname,"-2.uss");
|
|
strcat(screenshot_filename,"-2.png");
|
|
break;
|
|
case 3:
|
|
strcat(savestate_fname,"-3.uss");
|
|
strcat(screenshot_filename,"-3.png");
|
|
break;
|
|
default:
|
|
strcat(savestate_fname,".uss");
|
|
strcat(screenshot_filename,".png");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
static void goMenu(void)
|
|
{
|
|
if (quit_program != 0)
|
|
return;
|
|
emulating=1;
|
|
pause_sound();
|
|
|
|
if(lstAvailableROMs.size() == 0)
|
|
RescanROMs();
|
|
graphics_subshutdown();
|
|
prefs_to_gui();
|
|
run_gui();
|
|
gui_to_prefs();
|
|
setCpuSpeed();
|
|
update_display(&changed_prefs);
|
|
|
|
/* Clear menu garbage at the bottom of the screen */
|
|
black_screen_now();
|
|
notice_screen_contents_lost();
|
|
resume_sound();
|
|
|
|
inputdevice_copyconfig (&changed_prefs, &currprefs);
|
|
inputdevice_config_change_test ();
|
|
|
|
gui_update ();
|
|
|
|
gui_purge_events();
|
|
fpscounter_reset();
|
|
notice_screen_contents_lost();
|
|
}
|
|
|
|
|
|
static int customKey[256] =
|
|
{ 0, AK_UP, AK_DN, AK_LF, AK_RT, AK_NP0, AK_NP1, AK_NP2, /* 0 - 7 */
|
|
AK_NP3, AK_NP4, AK_NP5, AK_NP6, AK_NP7, AK_NP8, AK_NP9, AK_ENT, /* 8 - 15 */
|
|
AK_NPDIV, AK_NPMUL, AK_NPSUB, AK_NPADD, AK_NPDEL, AK_NPLPAREN, AK_NPRPAREN, AK_SPC, /* 16 - 23 */
|
|
AK_BS, AK_TAB, AK_RET, AK_ESC, AK_DEL, AK_LSH, AK_RSH, AK_CAPSLOCK, /* 24 - 31 */
|
|
AK_CTRL, AK_LALT, AK_RALT, AK_LAMI, AK_RAMI, AK_HELP, AK_LBRACKET, AK_RBRACKET, /* 32 - 39 */
|
|
AK_SEMICOLON, AK_COMMA, AK_PERIOD, AK_SLASH, AK_BACKSLASH, AK_QUOTE, AK_NUMBERSIGN, AK_LTGT, /* 40 - 47 */
|
|
AK_BACKQUOTE, AK_MINUS, AK_EQUAL, AK_A, AK_B, AK_C, AK_D, AK_E, /* 48 - 55 */
|
|
AK_F, AK_G, AK_H, AK_I, AK_J, AK_K, AK_L, AK_M, /* 56 - 63 */
|
|
AK_N, AK_O, AK_P, AK_Q, AK_R, AK_S, AK_T, AK_U, /* 64 - 71 */
|
|
AK_V, AK_W, AK_X, AK_Y, AK_Z, AK_1, AK_2, AK_3, /* 72 - 79 */
|
|
AK_4, AK_5, AK_6, AK_7, AK_8, AK_9, AK_0, AK_F1, /* 80 - 87 */
|
|
AK_F2, AK_F3, AK_F4, AK_F5, AK_F6, AK_F7, AK_F8, AK_F9, /* 88 - 95 */
|
|
AK_F10, 0 }; /* 96 - 97 */
|
|
|
|
static int getMapping(int customId)
|
|
{
|
|
if(customId > 96)
|
|
return 0;
|
|
else
|
|
return customKey[customId];
|
|
}
|
|
|
|
void moveVertical(int value)
|
|
{
|
|
changed_prefs.pandora_vertical_offset += value;
|
|
if(changed_prefs.pandora_vertical_offset < -16)
|
|
changed_prefs.pandora_vertical_offset = -16;
|
|
else if(changed_prefs.pandora_vertical_offset > 16)
|
|
changed_prefs.pandora_vertical_offset = 16;
|
|
}
|
|
|
|
void gui_handle_events (void)
|
|
{
|
|
int i;
|
|
int key = 0;
|
|
|
|
Uint8 *keystate = SDL_GetKeyState(NULL);
|
|
dpadUp = keystate[SDLK_UP];
|
|
dpadDown = keystate[SDLK_DOWN];
|
|
dpadLeft = keystate[SDLK_LEFT];
|
|
dpadRight = keystate[SDLK_RIGHT];
|
|
buttonA = keystate[SDLK_HOME];
|
|
buttonB = keystate[SDLK_END];
|
|
buttonX = keystate[SDLK_PAGEDOWN];
|
|
buttonY = keystate[SDLK_PAGEUP];
|
|
triggerL = keystate[SDLK_RSHIFT];
|
|
triggerR = keystate[SDLK_RCTRL];
|
|
|
|
if(keystate[SDLK_LCTRL])
|
|
goMenu();
|
|
|
|
//L + R
|
|
if(triggerL && triggerR)
|
|
{
|
|
//up
|
|
if(dpadUp)
|
|
{
|
|
moveVertical(1);
|
|
stylusAdjustY += 2;
|
|
}
|
|
//down
|
|
else if(dpadDown)
|
|
{
|
|
moveVertical(-1);
|
|
stylusAdjustY -= 2;
|
|
}
|
|
//1
|
|
else if(keystate[SDLK_1])
|
|
{
|
|
changed_prefs.gfx_size.height = amigaheight_values[0];
|
|
update_display(&changed_prefs);
|
|
}
|
|
//2
|
|
else if(keystate[SDLK_2])
|
|
{
|
|
changed_prefs.gfx_size.height = amigaheight_values[1];
|
|
update_display(&changed_prefs);
|
|
}
|
|
//3
|
|
else if(keystate[SDLK_3])
|
|
{
|
|
changed_prefs.gfx_size.height = amigaheight_values[2];
|
|
update_display(&changed_prefs);
|
|
}
|
|
//4
|
|
else if(keystate[SDLK_4])
|
|
{
|
|
changed_prefs.gfx_size.height = amigaheight_values[3];
|
|
update_display(&changed_prefs);
|
|
}
|
|
//5
|
|
else if(keystate[SDLK_5])
|
|
{
|
|
changed_prefs.gfx_size.height = amigaheight_values[4];
|
|
update_display(&changed_prefs);
|
|
}
|
|
//6
|
|
else if(keystate[SDLK_6])
|
|
{
|
|
changed_prefs.gfx_size.height = amigaheight_values[5];
|
|
update_display(&changed_prefs);
|
|
}
|
|
//9
|
|
else if(keystate[SDLK_9])
|
|
{
|
|
for(i=0; i<AMIGAHEIGHT_COUNT; ++i)
|
|
{
|
|
if(currprefs.gfx_size.height == amigaheight_values[i])
|
|
{
|
|
if(i > 0)
|
|
changed_prefs.gfx_size.height = amigaheight_values[i - 1];
|
|
else
|
|
changed_prefs.gfx_size.height = amigaheight_values[AMIGAHEIGHT_COUNT - 1];
|
|
break;
|
|
}
|
|
}
|
|
update_display(&changed_prefs);
|
|
}
|
|
//0
|
|
else if(keystate[SDLK_0])
|
|
{
|
|
for(i=0; i<AMIGAHEIGHT_COUNT; ++i)
|
|
{
|
|
if(currprefs.gfx_size.height == amigaheight_values[i])
|
|
{
|
|
if(i < AMIGAHEIGHT_COUNT - 1)
|
|
changed_prefs.gfx_size.height = amigaheight_values[i + 1];
|
|
else
|
|
changed_prefs.gfx_size.height = amigaheight_values[0];
|
|
break;
|
|
}
|
|
}
|
|
update_display(&changed_prefs);
|
|
}
|
|
else if(keystate[SDLK_w])
|
|
{
|
|
// Change width
|
|
for(i=0; i<AMIGAWIDTH_COUNT; ++i)
|
|
{
|
|
if(currprefs.gfx_size.width == amigawidth_values[i])
|
|
{
|
|
if(i < AMIGAWIDTH_COUNT - 1)
|
|
changed_prefs.gfx_size.width = amigawidth_values[i + 1];
|
|
else
|
|
changed_prefs.gfx_size.width = amigawidth_values[0];
|
|
break;
|
|
}
|
|
}
|
|
update_display(&changed_prefs);
|
|
}
|
|
}
|
|
|
|
else if(triggerL)
|
|
{
|
|
if(keystate[SDLK_a])
|
|
{
|
|
keystate[SDLK_a]=0;
|
|
currprefs.m68k_speed == 2 ? changed_prefs.m68k_speed = 0 : changed_prefs.m68k_speed++;
|
|
check_prefs_changed_cpu();
|
|
}
|
|
else if(keystate[SDLK_c])
|
|
{
|
|
keystate[SDLK_c]=0;
|
|
currprefs.pandora_customControls = !currprefs.pandora_customControls;
|
|
}
|
|
else if(keystate[SDLK_d])
|
|
{
|
|
keystate[SDLK_d]=0;
|
|
changed_prefs.leds_on_screen = !currprefs.leds_on_screen;
|
|
}
|
|
else if(keystate[SDLK_f])
|
|
{
|
|
keystate[SDLK_f]=0;
|
|
changed_prefs.gfx_framerate ? changed_prefs.gfx_framerate = 0 : changed_prefs.gfx_framerate = 1;
|
|
}
|
|
else if(keystate[SDLK_s])
|
|
{
|
|
keystate[SDLK_s]=0;
|
|
savestate_state = STATE_DOSAVE;
|
|
}
|
|
else if(keystate[SDLK_l])
|
|
{
|
|
FILE *f=fopen(savestate_fname, "rb");
|
|
keystate[SDLK_l]=0;
|
|
if(f)
|
|
{
|
|
fclose(f);
|
|
savestate_state = STATE_DORESTORE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(currprefs.pandora_customControls)
|
|
{
|
|
if(currprefs.pandora_custom_dpad == 2) // dPad is custom
|
|
{
|
|
//UP
|
|
if(dpadUp)
|
|
{
|
|
if(!justMovedUp)
|
|
{
|
|
if(currprefs.pandora_custom_up == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_up == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_up > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_up);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justMovedUp=1;
|
|
}
|
|
}
|
|
else if(justMovedUp)
|
|
{
|
|
if(currprefs.pandora_custom_up == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_up == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_up > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_up);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justMovedUp=0;
|
|
}
|
|
|
|
//DOWN
|
|
if(dpadDown)
|
|
{
|
|
if(!justMovedDown)
|
|
{
|
|
if(currprefs.pandora_custom_down == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_down == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_down > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_down);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justMovedDown=1;
|
|
}
|
|
}
|
|
else if(justMovedDown)
|
|
{
|
|
if(currprefs.pandora_custom_down == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_down == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_down > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_down);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justMovedDown=0;
|
|
}
|
|
|
|
//LEFT
|
|
if(dpadLeft)
|
|
{
|
|
if(!justMovedLeft)
|
|
{
|
|
if(currprefs.pandora_custom_left == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_left == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_left > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_left);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justMovedLeft=1;
|
|
}
|
|
}
|
|
else if(justMovedLeft)
|
|
{
|
|
if(currprefs.pandora_custom_left == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_left == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_left > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_left);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justMovedLeft=0;
|
|
}
|
|
|
|
//RIGHT
|
|
if(dpadRight)
|
|
{
|
|
if(!justMovedRight)
|
|
{
|
|
if(currprefs.pandora_custom_right == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_right == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_right > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_right);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justMovedRight=1;
|
|
}
|
|
}
|
|
else if(justMovedRight)
|
|
{
|
|
if(currprefs.pandora_custom_right == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_right == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_right > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_right);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justMovedRight=0;
|
|
}
|
|
}
|
|
|
|
//(A)
|
|
if(buttonA)
|
|
{
|
|
if(!justPressedA)
|
|
{
|
|
if(currprefs.pandora_custom_A == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_A == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_A > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_A);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justPressedA=1;
|
|
}
|
|
}
|
|
else if(justPressedA)
|
|
{
|
|
if(currprefs.pandora_custom_A == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_A == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_A > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_A);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justPressedA=0;
|
|
}
|
|
|
|
//(B)
|
|
if(buttonB)
|
|
{
|
|
if(!justPressedB)
|
|
{
|
|
if(currprefs.pandora_custom_B == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_B == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_B > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_B);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justPressedB=1;
|
|
}
|
|
}
|
|
else if(justPressedB)
|
|
{
|
|
if(currprefs.pandora_custom_B == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_B == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_B > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_B);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justPressedB=0;
|
|
}
|
|
|
|
//(X)
|
|
if(buttonX)
|
|
{
|
|
if(!justPressedX)
|
|
{
|
|
if(currprefs.pandora_custom_X == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_X == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_X > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_X);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justPressedX=1;
|
|
}
|
|
}
|
|
else if(justPressedX)
|
|
{
|
|
if(currprefs.pandora_custom_X == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_X == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_X > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_X);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justPressedX=0;
|
|
}
|
|
|
|
//(Y)
|
|
if(buttonY)
|
|
{
|
|
if(!justPressedY)
|
|
{
|
|
if(currprefs.pandora_custom_Y == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_Y == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_Y > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_Y);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justPressedY=1;
|
|
}
|
|
}
|
|
else if(justPressedY)
|
|
{
|
|
if(currprefs.pandora_custom_Y == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_Y == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_Y > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_Y);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justPressedY=0;
|
|
}
|
|
|
|
//(L)
|
|
if(triggerL)
|
|
{
|
|
if(!justPressedL)
|
|
{
|
|
if(currprefs.pandora_custom_L == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_L == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_L > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_L);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justPressedL=1;
|
|
}
|
|
}
|
|
else if(justPressedL)
|
|
{
|
|
if(currprefs.pandora_custom_L == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_L == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_L > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_L);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justPressedL=0;
|
|
}
|
|
|
|
//(R)
|
|
if(triggerR)
|
|
{
|
|
if(!justPressedR)
|
|
{
|
|
if(currprefs.pandora_custom_R == -1) buttonstate[0]=1;
|
|
else if(currprefs.pandora_custom_R == -2) buttonstate[2]=1;
|
|
else if(currprefs.pandora_custom_R > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_R);
|
|
uae4all_keystate[key] = 1;
|
|
record_key(key << 1);
|
|
}
|
|
justPressedR=1;
|
|
}
|
|
}
|
|
else if(justPressedR)
|
|
{
|
|
if(currprefs.pandora_custom_R == -1) buttonstate[0]=0;
|
|
else if(currprefs.pandora_custom_R == -2) buttonstate[2]=0;
|
|
else if(currprefs.pandora_custom_R > 0)
|
|
{
|
|
key = getMapping(currprefs.pandora_custom_R);
|
|
uae4all_keystate[key] = 0;
|
|
record_key((key << 1) | 1);
|
|
}
|
|
justPressedR=0;
|
|
}
|
|
}
|
|
|
|
else // Custom controls not active
|
|
{
|
|
if(currprefs.pandora_custom_dpad < 2 && triggerR)
|
|
{
|
|
//R+dpad = arrow keys in joystick and mouse mode
|
|
//dpad up
|
|
if(dpadUp)
|
|
{
|
|
if(!justMovedUp)
|
|
{
|
|
//arrow up
|
|
uae4all_keystate[AK_UP] = 1;
|
|
record_key(AK_UP << 1);
|
|
justMovedUp=1;
|
|
}
|
|
}
|
|
else if(justMovedUp)
|
|
{
|
|
//arrow up
|
|
uae4all_keystate[AK_UP] = 0;
|
|
record_key((AK_UP << 1) | 1);
|
|
justMovedUp=0;
|
|
}
|
|
//dpad down
|
|
if(dpadDown)
|
|
{
|
|
if(!justMovedDown)
|
|
{
|
|
//arrow down
|
|
uae4all_keystate[AK_DN] = 1;
|
|
record_key(AK_DN << 1);
|
|
justMovedDown=1;
|
|
}
|
|
}
|
|
else if(justMovedDown)
|
|
{
|
|
//arrow down
|
|
uae4all_keystate[AK_DN] = 0;
|
|
record_key((AK_DN << 1) | 1);
|
|
justMovedDown=0;
|
|
}
|
|
//dpad left
|
|
if(dpadLeft)
|
|
{
|
|
if(!justMovedLeft)
|
|
{
|
|
//arrow left
|
|
uae4all_keystate[AK_LF] = 1;
|
|
record_key(AK_LF << 1);
|
|
justMovedLeft=1;
|
|
}
|
|
}
|
|
else if(justMovedLeft)
|
|
{
|
|
//arrow left
|
|
uae4all_keystate[AK_LF] = 0;
|
|
record_key((AK_LF << 1) | 1);
|
|
justMovedLeft=0;
|
|
}
|
|
//dpad right
|
|
if (dpadRight)
|
|
{
|
|
if(!justMovedRight)
|
|
{
|
|
//arrow right
|
|
uae4all_keystate[AK_RT] = 1;
|
|
record_key(AK_RT << 1);
|
|
justMovedRight=1;
|
|
}
|
|
}
|
|
else if(justMovedRight)
|
|
{
|
|
//arrow right
|
|
uae4all_keystate[AK_RT] = 0;
|
|
record_key((AK_RT << 1) | 1);
|
|
justMovedRight=0;
|
|
}
|
|
}
|
|
|
|
switch(currprefs.pandora_custom_dpad)
|
|
{
|
|
case 0: // dPad is joystick
|
|
// R-trigger emulates some Amiga-Keys
|
|
if(triggerR)
|
|
{
|
|
//(A) button
|
|
if(buttonA)
|
|
{
|
|
if(!justPressedA)
|
|
{
|
|
//CTRL
|
|
uae4all_keystate[AK_CTRL] = 1;
|
|
record_key(AK_CTRL << 1);
|
|
justPressedA=1;
|
|
}
|
|
}
|
|
else if(justPressedA)
|
|
{
|
|
uae4all_keystate[AK_CTRL] = 0;
|
|
record_key((AK_CTRL << 1) | 1);
|
|
justPressedA=0;
|
|
}
|
|
//(B) button
|
|
if(buttonB)
|
|
{
|
|
if(!justPressedB)
|
|
{
|
|
//left ALT
|
|
uae4all_keystate[AK_LALT] = 1;
|
|
record_key(AK_LALT << 1);
|
|
justPressedB=1;
|
|
}
|
|
}
|
|
else if(justPressedB)
|
|
{
|
|
uae4all_keystate[AK_LALT] = 0;
|
|
record_key((AK_LALT << 1) | 1);
|
|
justPressedB=0;
|
|
}
|
|
//(X) button
|
|
if(buttonX)
|
|
{
|
|
if(!justPressedX)
|
|
{
|
|
//HELP
|
|
uae4all_keystate[AK_HELP] = 1;
|
|
record_key(AK_HELP << 1);
|
|
justPressedX=1;
|
|
}
|
|
}
|
|
else if(justPressedX)
|
|
{
|
|
//HELP
|
|
uae4all_keystate[AK_HELP] = 0;
|
|
record_key((AK_HELP << 1) | 1);
|
|
justPressedX=0;
|
|
}
|
|
}
|
|
// L-trigger emulates left and right mouse button
|
|
else if(triggerL)
|
|
{
|
|
//(A) button
|
|
if(buttonA)
|
|
{
|
|
if(!justPressedA)
|
|
{
|
|
//left mouse-button down
|
|
buttonstate[0] = 1;
|
|
justPressedA=1;
|
|
}
|
|
}
|
|
else if(justPressedA)
|
|
{
|
|
//left mouse-button up
|
|
buttonstate[0] = 0;
|
|
justPressedA=0;
|
|
}
|
|
//(B) button
|
|
if(buttonB)
|
|
{
|
|
if(!justPressedB)
|
|
{
|
|
//right mouse-button down
|
|
buttonstate[2] = 1;
|
|
justPressedB=1;
|
|
}
|
|
}
|
|
else if(justPressedB)
|
|
{
|
|
//right mouse-button up
|
|
buttonstate[2] = 0;
|
|
justPressedB=0;
|
|
}
|
|
}
|
|
|
|
else if(currprefs.pandora_joyConf < 2)
|
|
{
|
|
// Y-Button mapped to Space
|
|
if(buttonY)
|
|
{
|
|
if(!justPressedY)
|
|
{
|
|
//SPACE
|
|
uae4all_keystate[AK_SPC] = 1;
|
|
record_key(AK_SPC << 1);
|
|
justPressedY=1;
|
|
}
|
|
}
|
|
else if(justPressedY)
|
|
{
|
|
//SPACE
|
|
uae4all_keystate[AK_SPC] = 0;
|
|
record_key((AK_SPC << 1) | 1);
|
|
justPressedY=0;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case 1: // dPad is mouse
|
|
// A and B emulates mouse buttons
|
|
if(buttonA)
|
|
{
|
|
if(!justPressedA)
|
|
{
|
|
//left mouse-button down
|
|
buttonstate[0] = 1;
|
|
justPressedA=1;
|
|
}
|
|
}
|
|
else if(justPressedA)
|
|
{
|
|
//left mouse-button up
|
|
buttonstate[0] = 0;
|
|
justPressedA=0;
|
|
}
|
|
//(B) button
|
|
if(buttonB)
|
|
{
|
|
if(!justPressedB)
|
|
{
|
|
//right mouse-button down
|
|
buttonstate[2] = 1;
|
|
justPressedB=1;
|
|
}
|
|
}
|
|
else if(justPressedB)
|
|
{
|
|
//right mouse-button up
|
|
buttonstate[2] = 0;
|
|
justPressedB=0;
|
|
}
|
|
|
|
// Y emulates Space
|
|
if(buttonY)
|
|
{
|
|
if(!justPressedY)
|
|
{
|
|
//SPACE
|
|
uae4all_keystate[AK_SPC] = 1;
|
|
record_key(AK_SPC << 1);
|
|
justPressedY=1;
|
|
}
|
|
}
|
|
else if(justPressedY)
|
|
{
|
|
//SPACE
|
|
uae4all_keystate[AK_SPC] = 0;
|
|
record_key((AK_SPC << 1) | 1);
|
|
justPressedY=0;
|
|
}
|
|
|
|
break;
|
|
|
|
case 2: // dPad is custom (stylus) -> dPad decides which mouse button is clicked
|
|
//dpad up
|
|
if (dpadUp)
|
|
{
|
|
if(!justMovedUp)
|
|
{
|
|
//left and right mouse-buttons down
|
|
buttonstate[0] = 1;
|
|
buttonstate[2] = 1;
|
|
stylusClickOverride = 1;
|
|
justMovedUp=1;
|
|
}
|
|
}
|
|
else if(justMovedUp)
|
|
{
|
|
//left and right mouse-buttons up
|
|
buttonstate[0] = 0;
|
|
buttonstate[2] = 0;
|
|
stylusClickOverride = 0;
|
|
justMovedUp=0;
|
|
}
|
|
//dpad down
|
|
if (dpadDown)
|
|
{
|
|
if(!justMovedDown)
|
|
{
|
|
//no clicks with stylus now
|
|
stylusClickOverride=1;
|
|
justMovedDown=1;
|
|
}
|
|
}
|
|
else if(justMovedDown)
|
|
{
|
|
//clicks active again
|
|
stylusClickOverride=0;
|
|
justMovedDown=0;
|
|
}
|
|
//dpad left
|
|
if (dpadLeft)
|
|
{
|
|
if(!justMovedLeft)
|
|
{
|
|
//left mouse-button down
|
|
buttonstate[0] = 1;
|
|
stylusClickOverride = 1;
|
|
justMovedLeft=1;
|
|
}
|
|
}
|
|
else if(justMovedLeft)
|
|
{
|
|
//left mouse-button up
|
|
buttonstate[0] = 0;
|
|
stylusClickOverride = 0;
|
|
justMovedLeft=0;
|
|
}
|
|
//dpad right
|
|
if (dpadRight)
|
|
{
|
|
if(!justMovedRight)
|
|
{
|
|
//right mouse-button down
|
|
buttonstate[2] = 1;
|
|
stylusClickOverride = 1;
|
|
justMovedRight=1;
|
|
}
|
|
}
|
|
else if(justMovedRight)
|
|
{
|
|
//right mouse-button up
|
|
buttonstate[2] = 0;
|
|
stylusClickOverride = 0;
|
|
justMovedRight=0;
|
|
}
|
|
|
|
//L + up
|
|
if(triggerL && dpadUp)
|
|
stylusAdjustY-=2;
|
|
//L + down
|
|
if(triggerL && dpadDown)
|
|
stylusAdjustY+=2;
|
|
//L + left
|
|
if(triggerL && dpadLeft)
|
|
stylusAdjustX-=2;
|
|
//L + right
|
|
if(triggerL && dpadRight)
|
|
stylusAdjustX+=2;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void gui_hd_led (int led)
|
|
{
|
|
static int resetcounter;
|
|
|
|
if (led == 0) {
|
|
resetcounter--;
|
|
if (resetcounter > 0)
|
|
return;
|
|
}
|
|
gui_data.hd = led;
|
|
resetcounter = 2;
|
|
}
|
|
|
|
void gui_cd_led (int led)
|
|
{
|
|
}
|
|
|
|
void gui_led (int led, int on)
|
|
{
|
|
}
|
|
|
|
void gui_filename (int num, const char *name)
|
|
{
|
|
}
|
|
|
|
void gui_message (const char *format,...)
|
|
{
|
|
char msg[2048];
|
|
va_list parms;
|
|
|
|
va_start (parms, format);
|
|
vsprintf( msg, format, parms );
|
|
va_end (parms);
|
|
|
|
InGameMessage(msg);
|
|
}
|
|
|
|
void notify_user (int msg)
|
|
{
|
|
int i=0;
|
|
while(gui_msglist[i].num >= 0)
|
|
{
|
|
if(gui_msglist[i].num == msg)
|
|
{
|
|
gui_message(gui_msglist[i].msg);
|
|
break;
|
|
}
|
|
++i;
|
|
}
|
|
}
|
|
|
|
|
|
void gui_lock (void)
|
|
{
|
|
}
|
|
|
|
void gui_unlock (void)
|
|
{
|
|
}
|
|
|
|
|
|
void FilterFiles(std::vector<std::string> *files, const char *filter[])
|
|
{
|
|
for (int q=0; q<files->size(); q++)
|
|
{
|
|
std::string tmp = (*files)[q];
|
|
|
|
bool bRemove = true;
|
|
for(int f=0; filter[f] != NULL && strlen(filter[f]) > 0; ++f)
|
|
{
|
|
if(tmp.size() >= strlen(filter[f]))
|
|
{
|
|
if(!strcasecmp(tmp.substr(tmp.size() - strlen(filter[f])).c_str(), filter[f]))
|
|
{
|
|
bRemove = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bRemove)
|
|
{
|
|
files->erase(files->begin() + q);
|
|
--q;
|
|
}
|
|
}
|
|
}
|