forked from len0rd/rockbox
Update for Rockboy: - fix scaling for other color screens than H300 - full menu rewrite to display choices properly - some small tweaks to code - some formatting updates
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@10137 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Karl Kurbjun
parent
db8316fa52
commit
6952f03a7d
21 changed files with 442 additions and 751 deletions
|
|
@ -4,8 +4,6 @@
|
|||
/* Note: this file only exposes one function: do_user_menu(). */
|
||||
/*********************************************************************/
|
||||
|
||||
#include "stdlib.h"
|
||||
#include "string.h"
|
||||
#include "button.h"
|
||||
#include "rockmacros.h"
|
||||
#include "mem.h"
|
||||
|
|
@ -15,149 +13,68 @@
|
|||
#define MENU_BUTTON_DOWN BUTTON_SCROLL_FWD
|
||||
#define MENU_BUTTON_LEFT BUTTON_LEFT
|
||||
#define MENU_BUTTON_RIGHT BUTTON_RIGHT
|
||||
#define MENU_BUTTON_CANCEL BUTTON_MENU
|
||||
#elif (CONFIG_KEYPAD == GIGABEAT_PAD)
|
||||
#define MENU_BUTTON_UP BUTTON_UP
|
||||
#define MENU_BUTTON_DOWN BUTTON_DOWN
|
||||
#define MENU_BUTTON_LEFT BUTTON_LEFT
|
||||
#define MENU_BUTTON_RIGHT BUTTON_RIGHT
|
||||
#define MENU_BUTTON_CANCEL BUTTON_A
|
||||
#else
|
||||
#define MENU_BUTTON_UP BUTTON_UP
|
||||
#define MENU_BUTTON_DOWN BUTTON_DOWN
|
||||
#define MENU_BUTTON_LEFT BUTTON_LEFT
|
||||
#define MENU_BUTTON_RIGHT BUTTON_RIGHT
|
||||
#define MENU_BUTTON_CANCEL BUTTON_OFF
|
||||
#endif
|
||||
|
||||
void setvidmode(int);
|
||||
|
||||
/* load/save state function declarations */
|
||||
static void do_slot_menu(bool is_load);
|
||||
static void do_opt_menu(void);
|
||||
static void do_slot_menu(bool is_load);
|
||||
static void munge_name(char *buf, size_t bufsiz);
|
||||
|
||||
/* directory ROM save slots belong in */
|
||||
#define STATE_DIR "/.rockbox/rockboy"
|
||||
|
||||
#define MENU_CANCEL (-1)
|
||||
static int do_menu(char *title, char **items, size_t num_items, int sel_item);
|
||||
|
||||
/* main menu items */
|
||||
#define MAIN_MENU_TITLE "Rockboy"
|
||||
typedef enum {
|
||||
MM_ITEM_BACK,
|
||||
MM_ITEM_LOAD,
|
||||
MM_ITEM_SAVE,
|
||||
MM_ITEM_OPT,
|
||||
MM_ITEM_QUIT,
|
||||
MM_ITEM_LAST
|
||||
} MainMenuItem;
|
||||
|
||||
/* strings for the main menu */
|
||||
static const char *main_menu[] = {
|
||||
"Back to Game",
|
||||
"Load State...",
|
||||
"Save State...",
|
||||
"Options...",
|
||||
"Quit RockBoy"
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
SM_ITEM_SLOT1,
|
||||
SM_ITEM_SLOT2,
|
||||
SM_ITEM_SLOT3,
|
||||
SM_ITEM_SLOT4,
|
||||
SM_ITEM_SLOT5,
|
||||
SM_ITEM_FILE,
|
||||
SM_ITEM_BACK,
|
||||
SM_ITEM_LAST
|
||||
} SlotMenuItem;
|
||||
|
||||
/* this semi-evil, but we snprintf() into these strings later
|
||||
* Note: if you want more save slots, just add more lines
|
||||
* to this array */
|
||||
static const char *slot_menu[] = {
|
||||
"1. ",
|
||||
"2. ",
|
||||
"3. ",
|
||||
"4. ",
|
||||
"5. ",
|
||||
"Save to File... ",
|
||||
"Previous Menu... "
|
||||
};
|
||||
|
||||
#define OPT_MENU_TITLE "Options"
|
||||
typedef enum {
|
||||
OM_ITEM_FS,
|
||||
OM_ITEM_SOUND,
|
||||
OM_ITEM_STATS,
|
||||
OM_ITEM_FULLSCREEN,
|
||||
OM_ITEM_KEYS,
|
||||
OM_ITEM_BACK,
|
||||
OM_MENU_LAST
|
||||
} OptMenuItem;
|
||||
|
||||
static const char *opt_menu[] = {
|
||||
"Frameskip",
|
||||
"Sound ON/OFF",
|
||||
"Stats ON/OFF",
|
||||
"Fullscreen ON/OFF",
|
||||
"Set Keys (BUGGY)",
|
||||
"Previous Menu..."
|
||||
};
|
||||
|
||||
#define FS_MENU_TITLE "Frameskip"
|
||||
typedef enum {
|
||||
FS_ITEM_FS0,
|
||||
FS_ITEM_FS1,
|
||||
FS_ITEM_FS2,
|
||||
FS_ITEM_FS3,
|
||||
FS_ITEM_BACK,
|
||||
FS_MENU_LAST
|
||||
} FSMenuItem;
|
||||
|
||||
static const char *fs_menu[] = {
|
||||
"Frameskip 3 Max",
|
||||
"Frameskip 4 Max",
|
||||
"Frameskip 5 Max",
|
||||
"Frameskip 7 Max",
|
||||
"Previous Menu..."
|
||||
};
|
||||
|
||||
int getbutton(char *text)
|
||||
{
|
||||
rb->lcd_putsxy(0, 0, text);
|
||||
rb->lcd_update();
|
||||
rb->sleep(30);
|
||||
while (rb->button_get(false) != BUTTON_NONE)
|
||||
rb->yield();
|
||||
int button;
|
||||
while(true){
|
||||
button = rb->button_get(true);
|
||||
button=button&0x00000FFF;
|
||||
switch(button) {
|
||||
case MENU_BUTTON_LEFT:
|
||||
case MENU_BUTTON_RIGHT:
|
||||
case MENU_BUTTON_UP:
|
||||
case MENU_BUTTON_DOWN:
|
||||
break;
|
||||
default:
|
||||
return button;
|
||||
break;
|
||||
}
|
||||
}
|
||||
rb->lcd_putsxy(0, 0, text);
|
||||
rb->lcd_update();
|
||||
rb->sleep(30);
|
||||
|
||||
while (rb->button_get(false) != BUTTON_NONE)
|
||||
rb->yield();
|
||||
|
||||
int button;
|
||||
while(true)
|
||||
{
|
||||
button = rb->button_get(true);
|
||||
button=button&0x00000FFF;
|
||||
|
||||
switch(button)
|
||||
{
|
||||
case MENU_BUTTON_LEFT:
|
||||
case MENU_BUTTON_RIGHT:
|
||||
case MENU_BUTTON_UP:
|
||||
case MENU_BUTTON_DOWN:
|
||||
break;
|
||||
default:
|
||||
return button;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void setupkeys(void)
|
||||
{
|
||||
options.A=getbutton("Press A");
|
||||
options.A=getbutton("Press A");
|
||||
|
||||
options.B=getbutton("Press B");
|
||||
options.B=getbutton("Press B");
|
||||
|
||||
options.START=getbutton("Press Start");
|
||||
options.START=getbutton("Press Start");
|
||||
|
||||
options.SELECT=getbutton("Press Select");
|
||||
options.SELECT=getbutton("Press Select");
|
||||
|
||||
options.MENU=getbutton("Press Menu");
|
||||
options.MENU=getbutton("Press Menu");
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -165,67 +82,74 @@ void setupkeys(void)
|
|||
*
|
||||
* Returns USER_MENU_QUIT if the user selected "quit", otherwise
|
||||
* returns zero.
|
||||
*
|
||||
* Note: this is the only non-static function in this file at the
|
||||
* moment. In the future I may turn do_menu/etc into a proper API, in
|
||||
* which case they'll be exposed as well.
|
||||
*
|
||||
*/
|
||||
int do_user_menu(void) {
|
||||
int mi, ret, num_items;
|
||||
bool done = false;
|
||||
bool done=false;
|
||||
int m, ret=0;
|
||||
int result;
|
||||
|
||||
pcm_init();
|
||||
/* Clean out the button Queue */
|
||||
while (rb->button_get(false) != BUTTON_NONE)
|
||||
rb->yield();
|
||||
|
||||
/* set defaults */
|
||||
ret = 0; /* return value */
|
||||
mi = 0; /* initial menu selection */
|
||||
num_items = sizeof(main_menu) / sizeof(char*);
|
||||
|
||||
/* loop until we should exit menu */
|
||||
while (!done) {
|
||||
/* get item selection */
|
||||
mi = do_menu(MAIN_MENU_TITLE, (char**) main_menu, num_items, mi);
|
||||
|
||||
/* handle selected menu item */
|
||||
switch (mi) {
|
||||
case MM_ITEM_QUIT:
|
||||
ret = USER_MENU_QUIT;
|
||||
case MENU_CANCEL:
|
||||
case MM_ITEM_BACK:
|
||||
done = true;
|
||||
break;
|
||||
case MM_ITEM_LOAD:
|
||||
do_slot_menu(true);
|
||||
break;
|
||||
case MM_ITEM_SAVE:
|
||||
do_slot_menu(false);
|
||||
break;
|
||||
case MM_ITEM_OPT:
|
||||
do_opt_menu();
|
||||
break;
|
||||
static const struct menu_item items[] = {
|
||||
{"Load Game", NULL },
|
||||
{"Save Game", NULL },
|
||||
{"Options", NULL },
|
||||
{"Quit", NULL },
|
||||
};
|
||||
|
||||
pcm_init();
|
||||
|
||||
m = rb->menu_init(items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL);
|
||||
|
||||
while(!done)
|
||||
{
|
||||
result=rb->menu_show(m);
|
||||
|
||||
switch (result)
|
||||
{
|
||||
case 0: /* Load Game */
|
||||
do_slot_menu(true);
|
||||
break;
|
||||
case 1: /* Save Game */
|
||||
do_slot_menu(false);
|
||||
break;
|
||||
case 2: /* Options */
|
||||
do_opt_menu();
|
||||
break;
|
||||
case 3: /* Quit */
|
||||
ret = USER_MENU_QUIT;
|
||||
done=true;
|
||||
break;
|
||||
default:
|
||||
done=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
rb->lcd_clear_display();
|
||||
rb->lcd_update();
|
||||
/* return somethin' */
|
||||
return ret;
|
||||
|
||||
rb->menu_exit(m);
|
||||
|
||||
rb->lcd_setfont(0); /* Reset the font */
|
||||
rb->lcd_clear_display(); /* Clear display for screen size changes */
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* munge_name - munge a string into a filesystem-safe name
|
||||
*/
|
||||
static void munge_name(char *buf, const size_t bufsiz) {
|
||||
unsigned int i, max;
|
||||
unsigned int i, max;
|
||||
|
||||
/* check strlen */
|
||||
max = strlen(buf);
|
||||
max = (max < bufsiz) ? max : bufsiz;
|
||||
/* check strlen */
|
||||
max = strlen(buf);
|
||||
max = (max < bufsiz) ? max : bufsiz;
|
||||
|
||||
/* iterate over characters and munge them (if necessary) */
|
||||
for (i = 0; i < max; i++)
|
||||
if (!isalnum(buf[i]))
|
||||
buf[i] = '_';
|
||||
/* iterate over characters and munge them (if necessary) */
|
||||
for (i = 0; i < max; i++)
|
||||
if (!isalnum(buf[i]))
|
||||
buf[i] = '_';
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -235,15 +159,15 @@ static void munge_name(char *buf, const size_t bufsiz) {
|
|||
* checksum or something like that?
|
||||
*/
|
||||
static void build_slot_path(char *buf, size_t bufsiz, size_t slot_id) {
|
||||
char name_buf[40];
|
||||
char name_buf[40];
|
||||
|
||||
/* munge state file name */
|
||||
strncpy(name_buf, rom.name, sizeof(name_buf));
|
||||
name_buf[16] = '\0';
|
||||
munge_name(name_buf, strlen(name_buf));
|
||||
/* munge state file name */
|
||||
strncpy(name_buf, rom.name, 40);
|
||||
name_buf[16] = '\0';
|
||||
munge_name(name_buf, strlen(name_buf));
|
||||
|
||||
/* glom the whole mess together */
|
||||
snprintf(buf, bufsiz, "%s/%s-%d.rbs", STATE_DIR, name_buf, slot_id + 1);
|
||||
/* glom the whole mess together */
|
||||
snprintf(buf, bufsiz, "%s/%s-%d.rbs", STATE_DIR, name_buf, slot_id + 1);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -256,43 +180,46 @@ static void build_slot_path(char *buf, size_t bufsiz, size_t slot_id) {
|
|||
*
|
||||
*/
|
||||
static bool do_file(char *path, char *desc, bool is_load) {
|
||||
char buf[200], desc_buf[20];
|
||||
int fd, file_mode;
|
||||
char buf[200], desc_buf[20];
|
||||
int fd, file_mode;
|
||||
|
||||
/* set file mode */
|
||||
file_mode = is_load ? O_RDONLY : (O_WRONLY | O_CREAT);
|
||||
/* set file mode */
|
||||
file_mode = is_load ? O_RDONLY : (O_WRONLY | O_CREAT);
|
||||
|
||||
/* attempt to open file descriptor here */
|
||||
if ((fd = open(path, file_mode)) <= 0)
|
||||
return false;
|
||||
/* attempt to open file descriptor here */
|
||||
if ((fd = open(path, file_mode)) <= 0)
|
||||
return false;
|
||||
|
||||
/* load/save state */
|
||||
if (is_load) {
|
||||
/* load description */
|
||||
read(fd, desc_buf, 20);
|
||||
/* load/save state */
|
||||
if (is_load)
|
||||
{
|
||||
/* load description */
|
||||
read(fd, desc_buf, 20);
|
||||
|
||||
/* load state */
|
||||
loadstate(fd);
|
||||
|
||||
/* print out a status message so the user knows the state loaded */
|
||||
snprintf(buf, 200, "Loaded state from \"%s\"", path);
|
||||
rb->splash(HZ * 1, true, buf);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* build description buffer */
|
||||
memset(desc_buf, 0, 20);
|
||||
if (desc)
|
||||
strncpy(desc_buf, desc, 20);
|
||||
|
||||
/* load state */
|
||||
loadstate(fd);
|
||||
/* save state */
|
||||
write(fd, desc_buf, 20);
|
||||
savestate(fd);
|
||||
}
|
||||
|
||||
/* close file descriptor */
|
||||
close(fd);
|
||||
|
||||
/* print out a status message so the user knows the state loaded */
|
||||
snprintf(buf, sizeof(buf), "Loaded state from \"%s\"", path);
|
||||
rb->splash(HZ * 1, true, buf);
|
||||
} else {
|
||||
/* build description buffer */
|
||||
memset(desc_buf, 0, sizeof(desc_buf));
|
||||
if (desc)
|
||||
strncpy(desc_buf, desc, sizeof(desc_buf));
|
||||
|
||||
/* save state */
|
||||
write(fd, desc_buf, 20);
|
||||
savestate(fd);
|
||||
}
|
||||
|
||||
/* close file descriptor */
|
||||
close(fd);
|
||||
|
||||
/* return true (for success) */
|
||||
return true;
|
||||
/* return true (for success) */
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -301,339 +228,159 @@ static bool do_file(char *path, char *desc, bool is_load) {
|
|||
* Returns true on success and false on failure.
|
||||
*/
|
||||
static bool do_slot(size_t slot_id, bool is_load) {
|
||||
char path_buf[256], desc_buf[20];
|
||||
char path_buf[256], desc_buf[20];
|
||||
|
||||
/* build slot filename, clear desc buf */
|
||||
build_slot_path(path_buf, sizeof(path_buf), slot_id);
|
||||
memset(desc_buf, 0, sizeof(desc_buf));
|
||||
/* build slot filename, clear desc buf */
|
||||
build_slot_path(path_buf, 256, slot_id);
|
||||
memset(desc_buf, 0, 20);
|
||||
|
||||
/* if we're saving to a slot, then get a brief description */
|
||||
if (!is_load) {
|
||||
if (rb->kbd_input(desc_buf, sizeof(desc_buf)) || !strlen(desc_buf)) {
|
||||
memset(desc_buf, 0, sizeof(desc_buf));
|
||||
strncpy(desc_buf, "Untitled", sizeof(desc_buf));
|
||||
}
|
||||
}
|
||||
/* if we're saving to a slot, then get a brief description */
|
||||
if (!is_load)
|
||||
if (rb->kbd_input(desc_buf, 20) || !strlen(desc_buf))
|
||||
{
|
||||
memset(desc_buf, 0, 20);
|
||||
strncpy(desc_buf, "Untitled", 20);
|
||||
}
|
||||
|
||||
/* load/save file */
|
||||
return do_file(path_buf, desc_buf, is_load);
|
||||
/* load/save file */
|
||||
return do_file(path_buf, desc_buf, is_load);
|
||||
}
|
||||
|
||||
/*
|
||||
* get information on the given slot
|
||||
*/
|
||||
static void slot_info(char *info_buf, size_t info_bufsiz, size_t slot_id) {
|
||||
char buf[256];
|
||||
int fd;
|
||||
char buf[256];
|
||||
int fd;
|
||||
|
||||
/* get slot file path */
|
||||
build_slot_path(buf, sizeof(buf), slot_id);
|
||||
/* get slot file path */
|
||||
build_slot_path(buf, 256, slot_id);
|
||||
|
||||
/* attempt to open slot */
|
||||
if ((fd = open(buf, O_RDONLY)) >= 0) {
|
||||
/* this slot has a some data in it, read it */
|
||||
if (read(fd, buf, 20) > 0) {
|
||||
buf[20] = '\0';
|
||||
snprintf(info_buf, info_bufsiz, "%2d. %s", slot_id + 1, buf);
|
||||
} else {
|
||||
snprintf(info_buf, info_bufsiz, "%2d. ERROR", slot_id + 1);
|
||||
/* attempt to open slot */
|
||||
if ((fd = open(buf, O_RDONLY)) >= 0)
|
||||
{
|
||||
/* this slot has a some data in it, read it */
|
||||
if (read(fd, buf, 20) > 0)
|
||||
{
|
||||
buf[20] = '\0';
|
||||
snprintf(info_buf, info_bufsiz, "%d. %s", slot_id + 1, buf);
|
||||
}
|
||||
else
|
||||
snprintf(info_buf, info_bufsiz, "%d. ERROR", slot_id + 1);
|
||||
|
||||
close(fd);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* if we couldn't open the file, then the slot is empty */
|
||||
snprintf(info_buf, info_bufsiz, "%d. %s", slot_id + 1, "<Empty>");
|
||||
}
|
||||
close(fd);
|
||||
} else {
|
||||
/* if we couldn't open the file, then the slot is empty */
|
||||
snprintf(info_buf, info_bufsiz, "%2d.", slot_id + 1);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* do_slot_menu - prompt the user for a load/save memory slot
|
||||
*/
|
||||
static void do_slot_menu(bool is_load) {
|
||||
int i, mi, ret, num_items;
|
||||
bool done = false;
|
||||
char *title, buf[256];
|
||||
bool done=false;
|
||||
|
||||
/* set defaults */
|
||||
ret = 0; /* return value */
|
||||
mi = 0; /* initial menu selection */
|
||||
num_items = sizeof(slot_menu) / sizeof(char*);
|
||||
|
||||
/* create menu items (the last two are file and previous menu,
|
||||
* so don't populate those) */
|
||||
for (i = 0; i < num_items - 2; i++)
|
||||
slot_info((char*) slot_menu[i], 20, i);
|
||||
|
||||
/* set text of file item */
|
||||
snprintf((char*) slot_menu[SM_ITEM_FILE], 20, "%s File...", is_load ? "Load from" : "Save to");
|
||||
|
||||
/* set menu title */
|
||||
title = is_load ? "Load State" : "Save State";
|
||||
char buf[5][20];
|
||||
|
||||
/* loop until we should exit menu */
|
||||
while (!done) {
|
||||
/* get item selection */
|
||||
mi = do_menu(title, (char**) slot_menu, num_items, mi);
|
||||
int m;
|
||||
int result;
|
||||
int i;
|
||||
|
||||
struct menu_item items[] = {
|
||||
{ buf[0] , NULL },
|
||||
{ buf[1] , NULL },
|
||||
{ buf[2] , NULL },
|
||||
{ buf[3] , NULL },
|
||||
{ buf[4] , NULL },
|
||||
};
|
||||
|
||||
int num_items = sizeof(items) / sizeof(*items);
|
||||
|
||||
/* create menu items */
|
||||
for (i = 0; i < num_items; i++)
|
||||
slot_info(buf[i], 20, i);
|
||||
|
||||
m = rb->menu_init(items, num_items, NULL, NULL, NULL, NULL);
|
||||
|
||||
while(!done)
|
||||
{
|
||||
result=rb->menu_show(m);
|
||||
|
||||
/* handle selected menu item */
|
||||
done = true;
|
||||
if (mi != MENU_CANCEL && mi != SM_ITEM_BACK) {
|
||||
if (mi == SM_ITEM_FILE) {
|
||||
char rom_name_buf[40];
|
||||
|
||||
/* munge rom name to valid filename */
|
||||
strncpy(rom_name_buf, rom.name, 16);
|
||||
munge_name(rom_name_buf, sizeof(rom_name_buf));
|
||||
|
||||
/* create default filename */
|
||||
snprintf(buf, sizeof(buf), "/%s.rbs", rom_name_buf);
|
||||
|
||||
/* prompt for output filename, save to file */
|
||||
if (!rb->kbd_input(buf, sizeof(buf)))
|
||||
done = do_file(buf, NULL, is_load);
|
||||
} else {
|
||||
done = do_slot(mi, is_load);
|
||||
}
|
||||
|
||||
/* if we couldn't save the state file, then print out an
|
||||
* error message */
|
||||
if (!is_load && !done)
|
||||
rb->splash(HZ * 2, true, "Couldn't save state file.");
|
||||
if (result<num_items && result >= 0 )
|
||||
done = do_slot(result, is_load);
|
||||
else
|
||||
done = true;
|
||||
}
|
||||
}
|
||||
rb->menu_exit(m);
|
||||
}
|
||||
|
||||
static void do_fs_menu(void) {
|
||||
int mi, ret, num_items;
|
||||
bool done = false;
|
||||
static void do_opt_menu(void)
|
||||
{
|
||||
bool done=false;
|
||||
int m;
|
||||
int result;
|
||||
|
||||
/* set defaults */
|
||||
ret = 0; /* return value */
|
||||
mi = 0; /* initial menu selection */
|
||||
num_items = sizeof(fs_menu) / sizeof(char*);
|
||||
|
||||
/* loop until we should exit menu */
|
||||
while (!done) {
|
||||
/* get item selection */
|
||||
mi = do_menu(FS_MENU_TITLE, (char**) fs_menu, num_items, mi);
|
||||
static const struct opt_items onoff[2] = {
|
||||
{ "Off", NULL },
|
||||
{ "On" , NULL },
|
||||
};
|
||||
|
||||
static const struct opt_items fullscreen[]= {
|
||||
{ "Off", NULL },
|
||||
{ "Fullscreen", NULL },
|
||||
{ "Full - Maintain Ratio", NULL },
|
||||
};
|
||||
|
||||
static const struct opt_items frameskip[]= {
|
||||
{ "3 Max", NULL },
|
||||
{ "4 Max", NULL },
|
||||
{ "5 Max", NULL },
|
||||
{ "6 Max", NULL },
|
||||
};
|
||||
|
||||
static const struct menu_item items[] = {
|
||||
{"Max Frameskip", NULL },
|
||||
{"Sound" , NULL },
|
||||
{"Stats" , NULL },
|
||||
{"Fullscreen" , NULL },
|
||||
{"Set Keys (Buggy)", NULL },
|
||||
};
|
||||
|
||||
m = rb->menu_init(items, sizeof(items) / sizeof(*items), NULL, NULL, NULL, NULL);
|
||||
|
||||
while(!done)
|
||||
{
|
||||
|
||||
result=rb->menu_show(m);
|
||||
|
||||
/* handle selected menu item */
|
||||
switch (mi) {
|
||||
case MENU_CANCEL:
|
||||
case FS_ITEM_BACK:
|
||||
done = true;
|
||||
break;
|
||||
case FS_ITEM_FS0:
|
||||
options.maxskip=3;
|
||||
break;
|
||||
case FS_ITEM_FS1:
|
||||
options.maxskip=4;
|
||||
break;
|
||||
case FS_ITEM_FS2:
|
||||
options.maxskip=5;
|
||||
break;
|
||||
case FS_ITEM_FS3:
|
||||
options.maxskip=7;
|
||||
break;
|
||||
switch (result)
|
||||
{
|
||||
case 0: /* Frameskip */
|
||||
options.maxskip-=3;
|
||||
rb->set_option(items[0].desc, &options.maxskip, INT, frameskip, 4, NULL );
|
||||
options.maxskip+=3;
|
||||
break;
|
||||
case 1: /* Sound */
|
||||
if(options.sound>1) options.sound=1;
|
||||
rb->set_option(items[1].desc, &options.sound, INT, onoff, 2, NULL );
|
||||
break;
|
||||
case 2: /* Stats */
|
||||
rb->set_option(items[2].desc, &options.showstats, INT, onoff, 2, NULL );
|
||||
break;
|
||||
case 3: /* Fullscreen */
|
||||
rb->set_option(items[3].desc, &options.fullscreen, INT, fullscreen, 3, NULL );
|
||||
setvidmode(options.fullscreen);
|
||||
break;
|
||||
case 4: /* Keys */
|
||||
setupkeys();
|
||||
break;
|
||||
default:
|
||||
done=true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void do_opt_menu(void) {
|
||||
int mi, num_items;
|
||||
bool done = false;
|
||||
|
||||
/* set a couple of defaults */
|
||||
num_items = sizeof(opt_menu) / sizeof(char*);
|
||||
mi = 0;
|
||||
|
||||
while (!done) {
|
||||
mi = do_menu(OPT_MENU_TITLE, (char**) opt_menu, num_items, mi);
|
||||
switch (mi) {
|
||||
case OM_ITEM_FS:
|
||||
do_fs_menu();
|
||||
break;
|
||||
case OM_ITEM_SOUND:
|
||||
options.sound=!options.sound;
|
||||
break;
|
||||
case OM_ITEM_STATS:
|
||||
options.showstats=!options.showstats;
|
||||
break;
|
||||
case OM_ITEM_FULLSCREEN:
|
||||
options.fullscreen=!options.fullscreen;
|
||||
break;
|
||||
case OM_ITEM_KEYS:
|
||||
setupkeys();
|
||||
break;
|
||||
case MENU_CANCEL:
|
||||
case OM_ITEM_BACK:
|
||||
done = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*********************************************************************/
|
||||
/* MENU FUNCTIONS */
|
||||
/*********************************************************************/
|
||||
/* at some point i'll make this a generic menu interface, but for now,
|
||||
* these defines will suffice */
|
||||
#define MENU_X 10
|
||||
#define MENU_Y 8
|
||||
#define MENU_WIDTH (LCD_WIDTH - 2 * MENU_X)
|
||||
#define MENU_HEIGHT (LCD_HEIGHT - 2 * MENU_Y)
|
||||
#define MENU_RECT MENU_X, MENU_Y, MENU_WIDTH, MENU_HEIGHT
|
||||
#define SHADOW_RECT MENU_X + 1, MENU_Y + 1, MENU_WIDTH, MENU_HEIGHT
|
||||
#define MENU_ITEM_PAD 2
|
||||
|
||||
/*
|
||||
* select_item - select menu item (after deselecting current item)
|
||||
*/
|
||||
static void select_item(char *title, int curr_item, size_t item_i) {
|
||||
int x, y, w, h;
|
||||
|
||||
/* get size of title, use that as height ofr all lines */
|
||||
rb->lcd_getstringsize(title, &w, &h);
|
||||
h += MENU_ITEM_PAD * 2;
|
||||
|
||||
/* calc x and width */
|
||||
x = MENU_X + MENU_ITEM_PAD;
|
||||
w = MENU_WIDTH - 2 * MENU_ITEM_PAD;
|
||||
|
||||
rb->lcd_set_drawmode(DRMODE_COMPLEMENT);
|
||||
/* if there is a current item, then deselect it */
|
||||
if (curr_item >= 0) {
|
||||
/* deselect old item */
|
||||
y = MENU_Y + h + MENU_ITEM_PAD * 2; /* account for title */
|
||||
y += h * curr_item;
|
||||
rb->lcd_fillrect(x, y, w, h);
|
||||
}
|
||||
|
||||
/* select new item */
|
||||
curr_item = item_i;
|
||||
|
||||
/* select new item */
|
||||
y = MENU_Y + h + MENU_ITEM_PAD * 2; /* account for title */
|
||||
y += h * curr_item;
|
||||
rb->lcd_fillrect(x, y, w, h);
|
||||
rb->lcd_set_drawmode(DRMODE_SOLID);
|
||||
|
||||
/* update the menu window */
|
||||
rb->lcd_update_rect(MENU_RECT);
|
||||
}
|
||||
|
||||
/*
|
||||
* draw_menu - draw menu on screen
|
||||
*
|
||||
* Returns MENU_CANCEL if the user cancelled, or the item number of the
|
||||
* selected item.
|
||||
*
|
||||
*/
|
||||
static void draw_menu(char *title, char **items, size_t num_items) {
|
||||
size_t i;
|
||||
int x, y, w, h, by;
|
||||
|
||||
/* set to default? font */
|
||||
rb->lcd_setfont(0);
|
||||
|
||||
/* draw the outline */
|
||||
rb->lcd_fillrect(SHADOW_RECT);
|
||||
rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
|
||||
rb->lcd_fillrect(MENU_RECT);
|
||||
rb->lcd_set_drawmode(DRMODE_SOLID);
|
||||
rb->lcd_drawrect(MENU_RECT);
|
||||
|
||||
/* calculate x/y */
|
||||
x = MENU_X + MENU_ITEM_PAD;
|
||||
y = MENU_Y + MENU_ITEM_PAD * 2;
|
||||
rb->lcd_getstringsize(title, &w, &h);
|
||||
h += MENU_ITEM_PAD * 2;
|
||||
|
||||
/* draw menu stipple */
|
||||
for (i = MENU_Y; i < (size_t) y + h; i += 2)
|
||||
rb->lcd_drawline(MENU_X, i, MENU_X + MENU_WIDTH, i);
|
||||
|
||||
/* clear title rect */
|
||||
rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
|
||||
rb->lcd_fillrect((LCD_WIDTH - w) / 2 - 2, y - 2, w + 4, h);
|
||||
rb->lcd_set_drawmode(DRMODE_SOLID);
|
||||
|
||||
/* draw centered title on screen */
|
||||
rb->lcd_putsxy((LCD_WIDTH - w)/2, y, title);
|
||||
|
||||
/* calculate base Y for items */
|
||||
by = y + h + MENU_ITEM_PAD;
|
||||
|
||||
/* iterate over each item and draw it on the screen */
|
||||
for (i = 0; i < num_items; i++)
|
||||
rb->lcd_putsxy(x, by + h * i, items[i]);
|
||||
|
||||
/* update the screen */
|
||||
rb->lcd_update();
|
||||
}
|
||||
|
||||
/*
|
||||
* do_menu - draw menu on screen.
|
||||
*
|
||||
* Draw a menu titled @title on the screen, with @num_items elements
|
||||
* from @items, and select the @sel element. If in doubt, set @sel to
|
||||
* -1 :).
|
||||
*
|
||||
*/
|
||||
static int do_menu(char *title, char **items, size_t num_items, int sel) {
|
||||
int btn, sel_item, ret, curr_item;
|
||||
bool done = false;
|
||||
ret = MENU_CANCEL;
|
||||
|
||||
/* draw menu on screen and select the first item */
|
||||
draw_menu(title, items, num_items);
|
||||
curr_item = -1;
|
||||
select_item(title, curr_item, sel);
|
||||
curr_item = sel;
|
||||
|
||||
/* make sure button state is empty */
|
||||
while (rb->button_get(false) != BUTTON_NONE)
|
||||
rb->yield();
|
||||
|
||||
/* loop until the menu is finished */
|
||||
while (!done) {
|
||||
/* grab a button */
|
||||
btn = rb->button_get(true);
|
||||
|
||||
/* handle the button */
|
||||
switch (btn) {
|
||||
case MENU_BUTTON_DOWN:
|
||||
/* select next item in list */
|
||||
sel_item = curr_item + 1;
|
||||
if (sel_item >= (int) num_items)
|
||||
sel_item = 0;
|
||||
select_item(title, curr_item, sel_item);
|
||||
curr_item = sel_item;
|
||||
break;
|
||||
case MENU_BUTTON_UP:
|
||||
/* select prev item in list */
|
||||
sel_item = curr_item - 1;
|
||||
if (sel_item < 0)
|
||||
sel_item = num_items - 1;
|
||||
select_item(title, curr_item, sel_item);
|
||||
curr_item = sel_item;
|
||||
break;
|
||||
case MENU_BUTTON_RIGHT:
|
||||
/* select current item */
|
||||
ret = curr_item;
|
||||
done = true;
|
||||
break;
|
||||
case MENU_BUTTON_LEFT:
|
||||
case MENU_BUTTON_CANCEL:
|
||||
/* cancel out of menu */
|
||||
ret = MENU_CANCEL;
|
||||
done = true;
|
||||
break;
|
||||
}
|
||||
|
||||
/* give the OS some love */
|
||||
rb->yield();
|
||||
}
|
||||
|
||||
/* return selected item */
|
||||
return ret;
|
||||
rb->menu_exit(m);
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue