X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=gp2x%2Fmenu.c;h=a8d1f9e742ace69b32902ca31fce5167d3cd50cf;hb=c7a4ff64287b12487c7e9cc13ce3b7d2aa6e1f06;hp=6336126ed81d8f24f6c30cf2ee995ad6ea4d64fd;hpb=720ee7f6244cb51cc123a7fd16832161db9a3b4d;p=libpicofe.git

diff --git a/gp2x/menu.c b/gp2x/menu.c
index 6336126..a8d1f9e 100644
--- a/gp2x/menu.c
+++ b/gp2x/menu.c
@@ -1,4 +1,4 @@
-// (c) Copyright 2006 notaz, All rights reserved.
+// (c) Copyright 2006,2007 notaz, All rights reserved.
 // Free for non-commercial use.
 
 // For commercial use, separate licencing terms must be obtained.
@@ -14,21 +14,26 @@
 #include "emu.h"
 #include "menu.h"
 #include "usbjoy.h"
+#include "../common/arm_utils.h"
+#include "../common/menu.h"
+#include "../common/readpng.h"
 #include "version.h"
 
-#include "Pico/PicoInt.h"
+#include <Pico/PicoInt.h>
+#include <Pico/Patch.h>
+#include <zlib/zlib.h>
 
 #ifndef _DIRENT_HAVE_D_TYPE
 #error "need d_type for file browser
 #endif
 
-extern char *actionNames[];
 extern char romFileName[PATH_MAX];
 extern char *rom_data;
 extern int  mmuhack_status;
 extern int  state_slot;
+extern int  config_slot, config_slot_current;
 
-static char *gp2xKeyNames[] = {
+static const char *gp2xKeyNames[] = {
 	"UP",    "???",    "LEFT", "???",  "DOWN", "???", "RIGHT",    "???",
 	"START", "SELECT", "L",    "R",    "A",    "B",   "X",        "Y",
 	"???",   "???",    "???",  "???",  "???",  "???", "VOL DOWN", "VOL UP",
@@ -37,154 +42,8 @@ static char *gp2xKeyNames[] = {
 
 char menuErrorMsg[40] = {0, };
 
-
-static unsigned char fontdata8x8[] =
-{
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-	0x3C,0x42,0x99,0xBD,0xBD,0x99,0x42,0x3C,0x3C,0x42,0x81,0x81,0x81,0x81,0x42,0x3C,
-	0xFE,0x82,0x8A,0xD2,0xA2,0x82,0xFE,0x00,0xFE,0x82,0x82,0x82,0x82,0x82,0xFE,0x00,
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x64,0x74,0x7C,0x38,0x00,0x00,
-	0x80,0xC0,0xF0,0xFC,0xF0,0xC0,0x80,0x00,0x01,0x03,0x0F,0x3F,0x0F,0x03,0x01,0x00,
-	0x18,0x3C,0x7E,0x18,0x7E,0x3C,0x18,0x00,0xEE,0xEE,0xEE,0xCC,0x00,0xCC,0xCC,0x00,
-	0x00,0x00,0x30,0x68,0x78,0x30,0x00,0x00,0x00,0x38,0x64,0x74,0x7C,0x38,0x00,0x00,
-	0x3C,0x66,0x7A,0x7A,0x7E,0x7E,0x3C,0x00,0x0E,0x3E,0x3A,0x22,0x26,0x6E,0xE4,0x40,
-	0x18,0x3C,0x7E,0x3C,0x3C,0x3C,0x3C,0x00,0x3C,0x3C,0x3C,0x3C,0x7E,0x3C,0x18,0x00,
-	0x08,0x7C,0x7E,0x7E,0x7C,0x08,0x00,0x00,0x10,0x3E,0x7E,0x7E,0x3E,0x10,0x00,0x00,
-	0x58,0x2A,0xDC,0xC8,0xDC,0x2A,0x58,0x00,0x24,0x66,0xFF,0xFF,0x66,0x24,0x00,0x00,
-	0x00,0x10,0x10,0x38,0x38,0x7C,0xFE,0x00,0xFE,0x7C,0x38,0x38,0x10,0x10,0x00,0x00,
-	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x1C,0x1C,0x18,0x00,0x18,0x18,0x00,
-	0x6C,0x6C,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x28,0x7C,0x28,0x7C,0x28,0x00,0x00,
-	0x10,0x38,0x60,0x38,0x0C,0x78,0x10,0x00,0x40,0xA4,0x48,0x10,0x24,0x4A,0x04,0x00,
-	0x18,0x34,0x18,0x3A,0x6C,0x66,0x3A,0x00,0x18,0x18,0x20,0x00,0x00,0x00,0x00,0x00,
-	0x30,0x60,0x60,0x60,0x60,0x60,0x30,0x00,0x0C,0x06,0x06,0x06,0x06,0x06,0x0C,0x00,
-	0x10,0x54,0x38,0x7C,0x38,0x54,0x10,0x00,0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00,
-	0x00,0x00,0x00,0x00,0x18,0x18,0x30,0x00,0x00,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,
-	0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x04,0x08,0x10,0x20,0x40,0x00,0x00,
-	0x38,0x4C,0xC6,0xC6,0xC6,0x64,0x38,0x00,0x18,0x38,0x18,0x18,0x18,0x18,0x7E,0x00,
-	0x7C,0xC6,0x0E,0x3C,0x78,0xE0,0xFE,0x00,0x7E,0x0C,0x18,0x3C,0x06,0xC6,0x7C,0x00,
-	0x1C,0x3C,0x6C,0xCC,0xFE,0x0C,0x0C,0x00,0xFC,0xC0,0xFC,0x06,0x06,0xC6,0x7C,0x00,
-	0x3C,0x60,0xC0,0xFC,0xC6,0xC6,0x7C,0x00,0xFE,0xC6,0x0C,0x18,0x30,0x30,0x30,0x00,
-	0x78,0xC4,0xE4,0x78,0x86,0x86,0x7C,0x00,0x7C,0xC6,0xC6,0x7E,0x06,0x0C,0x78,0x00,
-	0x00,0x00,0x18,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x18,0x18,0x30,
-	0x1C,0x38,0x70,0xE0,0x70,0x38,0x1C,0x00,0x00,0x7C,0x00,0x00,0x7C,0x00,0x00,0x00,
-	0x70,0x38,0x1C,0x0E,0x1C,0x38,0x70,0x00,0x7C,0xC6,0xC6,0x1C,0x18,0x00,0x18,0x00,
-	0x3C,0x42,0x99,0xA1,0xA5,0x99,0x42,0x3C,0x38,0x6C,0xC6,0xC6,0xFE,0xC6,0xC6,0x00,
-	0xFC,0xC6,0xC6,0xFC,0xC6,0xC6,0xFC,0x00,0x3C,0x66,0xC0,0xC0,0xC0,0x66,0x3C,0x00,
-	0xF8,0xCC,0xC6,0xC6,0xC6,0xCC,0xF8,0x00,0xFE,0xC0,0xC0,0xFC,0xC0,0xC0,0xFE,0x00,
-	0xFE,0xC0,0xC0,0xFC,0xC0,0xC0,0xC0,0x00,0x3E,0x60,0xC0,0xCE,0xC6,0x66,0x3E,0x00,
-	0xC6,0xC6,0xC6,0xFE,0xC6,0xC6,0xC6,0x00,0x7E,0x18,0x18,0x18,0x18,0x18,0x7E,0x00,
-	0x06,0x06,0x06,0x06,0xC6,0xC6,0x7C,0x00,0xC6,0xCC,0xD8,0xF0,0xF8,0xDC,0xCE,0x00,
-	0x60,0x60,0x60,0x60,0x60,0x60,0x7E,0x00,0xC6,0xEE,0xFE,0xFE,0xD6,0xC6,0xC6,0x00,
-	0xC6,0xE6,0xF6,0xFE,0xDE,0xCE,0xC6,0x00,0x7C,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00,
-	0xFC,0xC6,0xC6,0xC6,0xFC,0xC0,0xC0,0x00,0x7C,0xC6,0xC6,0xC6,0xDE,0xCC,0x7A,0x00,
-	0xFC,0xC6,0xC6,0xCE,0xF8,0xDC,0xCE,0x00,0x78,0xCC,0xC0,0x7C,0x06,0xC6,0x7C,0x00,
-	0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0xC6,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00,
-	0xC6,0xC6,0xC6,0xEE,0x7C,0x38,0x10,0x00,0xC6,0xC6,0xD6,0xFE,0xFE,0xEE,0xC6,0x00,
-	0xC6,0xEE,0x3C,0x38,0x7C,0xEE,0xC6,0x00,0x66,0x66,0x66,0x3C,0x18,0x18,0x18,0x00,
-	0xFE,0x0E,0x1C,0x38,0x70,0xE0,0xFE,0x00,0x3C,0x30,0x30,0x30,0x30,0x30,0x3C,0x00,
-	0x60,0x60,0x30,0x18,0x0C,0x06,0x06,0x00,0x3C,0x0C,0x0C,0x0C,0x0C,0x0C,0x3C,0x00,
-	0x18,0x3C,0x66,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,
-	0x30,0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x3C,0x06,0x3E,0x66,0x66,0x3C,0x00,
-	0x60,0x7C,0x66,0x66,0x66,0x66,0x7C,0x00,0x00,0x3C,0x66,0x60,0x60,0x66,0x3C,0x00,
-	0x06,0x3E,0x66,0x66,0x66,0x66,0x3E,0x00,0x00,0x3C,0x66,0x66,0x7E,0x60,0x3C,0x00,
-	0x1C,0x30,0x78,0x30,0x30,0x30,0x30,0x00,0x00,0x3E,0x66,0x66,0x66,0x3E,0x06,0x3C,
-	0x60,0x7C,0x76,0x66,0x66,0x66,0x66,0x00,0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x00,
-	0x0C,0x00,0x1C,0x0C,0x0C,0x0C,0x0C,0x38,0x60,0x60,0x66,0x6C,0x78,0x6C,0x66,0x00,
-	0x38,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0xEC,0xFE,0xFE,0xFE,0xD6,0xC6,0x00,
-	0x00,0x7C,0x76,0x66,0x66,0x66,0x66,0x00,0x00,0x3C,0x66,0x66,0x66,0x66,0x3C,0x00,
-	0x00,0x7C,0x66,0x66,0x66,0x7C,0x60,0x60,0x00,0x3E,0x66,0x66,0x66,0x3E,0x06,0x06,
-	0x00,0x7E,0x70,0x60,0x60,0x60,0x60,0x00,0x00,0x3C,0x60,0x3C,0x06,0x66,0x3C,0x00,
-	0x30,0x78,0x30,0x30,0x30,0x30,0x1C,0x00,0x00,0x66,0x66,0x66,0x66,0x6E,0x3E,0x00,
-	0x00,0x66,0x66,0x66,0x66,0x3C,0x18,0x00,0x00,0xC6,0xD6,0xFE,0xFE,0x7C,0x6C,0x00,
-	0x00,0x66,0x3C,0x18,0x3C,0x66,0x66,0x00,0x00,0x66,0x66,0x66,0x66,0x3E,0x06,0x3C,
-	0x00,0x7E,0x0C,0x18,0x30,0x60,0x7E,0x00,0x0E,0x18,0x0C,0x38,0x0C,0x18,0x0E,0x00,
-	0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00,0x70,0x18,0x30,0x1C,0x30,0x18,0x70,0x00,
-	0x00,0x00,0x76,0xDC,0x00,0x00,0x00,0x00,0x10,0x28,0x10,0x54,0xAA,0x44,0x00,0x00,
-};
-
-static void gp2x_text(unsigned char *screen, int x, int y, char *text, int color)
-{
-	int i,l;
-
-	screen = screen + x + y*320;
-
-	for (i = 0; i < strlen(text); i++)
-	{
-		for (l=0;l<8;l++)
-		{
-			if(fontdata8x8[((text[i])*8)+l]&0x80) screen[l*320+0]=color;
-			if(fontdata8x8[((text[i])*8)+l]&0x40) screen[l*320+1]=color;
-			if(fontdata8x8[((text[i])*8)+l]&0x20) screen[l*320+2]=color;
-			if(fontdata8x8[((text[i])*8)+l]&0x10) screen[l*320+3]=color;
-			if(fontdata8x8[((text[i])*8)+l]&0x08) screen[l*320+4]=color;
-			if(fontdata8x8[((text[i])*8)+l]&0x04) screen[l*320+5]=color;
-			if(fontdata8x8[((text[i])*8)+l]&0x02) screen[l*320+6]=color;
-			if(fontdata8x8[((text[i])*8)+l]&0x01) screen[l*320+7]=color;
-		}
-		screen += 8;
-	}
-}
-
-// draws white text to current bbp15 screen
-void gp2x_text_out15(int x, int y, char *text)
-{
-	int i,l;
-	unsigned short *screen = gp2x_screen;
-
-	screen = screen + x + y*320;
-
-	for (i = 0; i < strlen(text); i++)
-	{
-		for (l=0;l<8;l++)
-		{
-			if(fontdata8x8[((text[i])*8)+l]&0x80) screen[l*320+0]=0xffff;
-			if(fontdata8x8[((text[i])*8)+l]&0x40) screen[l*320+1]=0xffff;
-			if(fontdata8x8[((text[i])*8)+l]&0x20) screen[l*320+2]=0xffff;
-			if(fontdata8x8[((text[i])*8)+l]&0x10) screen[l*320+3]=0xffff;
-			if(fontdata8x8[((text[i])*8)+l]&0x08) screen[l*320+4]=0xffff;
-			if(fontdata8x8[((text[i])*8)+l]&0x04) screen[l*320+5]=0xffff;
-			if(fontdata8x8[((text[i])*8)+l]&0x02) screen[l*320+6]=0xffff;
-			if(fontdata8x8[((text[i])*8)+l]&0x01) screen[l*320+7]=0xffff;
-		}
-		screen += 8;
-	}
-}
-
-
-void gp2x_text_out8(int x, int y, char *texto, ...)
-{
-	va_list args;
-	char    buffer[512];
-
-	va_start(args,texto);
-	vsprintf(buffer,texto,args);
-	va_end(args);
-
-	gp2x_text(gp2x_screen,x,y,buffer,1);
-}
-
-
-void gp2x_text_out8_2(int x, int y, char *texto, int color)
-{
-	gp2x_text(gp2x_screen, x, y, texto, color);
-}
-
-void gp2x_text_out8_lim(int x, int y, char *texto, int max)
-{
-	char    buffer[320/8+1];
-
-	strncpy(buffer, texto, 320/8);
-	if (max > 320/8) max = 320/8;
-	if (max < 0) max = 0;
-	buffer[max] = 0;
-
-	gp2x_text(gp2x_screen,x,y,buffer,1);
-}
-
+static void menu_darken_bg(void *dst, int pixels, int darker);
+static void menu_prepare_bg(int use_game_bg);
 
 static unsigned long inp_prev = 0;
 static int inp_prevjoy = 0;
@@ -192,14 +51,16 @@ static int inp_prevjoy = 0;
 static unsigned long wait_for_input(unsigned long interesting)
 {
 	unsigned long ret;
-	static int repeats = 0, wait = 300*1000;
+	static int repeats = 0, wait = 50*1000;
 	int release = 0, i;
 
-	if (repeats == 5 || repeats == 15 || repeats == 30) wait /= 2;
+	if (repeats == 2 || repeats == 4) wait /= 2;
+	if (repeats == 6) wait = 15 * 1000;
 
 	for (i = 0; i < 6 && inp_prev == gp2x_joystick_read(1); i++) {
-		if(i == 0) repeats++;
-		usleep(wait/6);
+		if (i == 0) repeats++;
+		if (wait >= 30*1000) usleep(wait); // usleep sleeps for ~30ms minimum
+		else spend_cycles(wait * currentConfig.CPUclock);
 	}
 
 	while ( !((ret = gp2x_joystick_read(1)) & interesting) ) {
@@ -209,7 +70,7 @@ static unsigned long wait_for_input(unsigned long interesting)
 
 	if (release || ret != inp_prev) {
 		repeats = 0;
-		wait = 300*1000;
+		wait = 50*1000;
 	}
 	inp_prev = ret;
 	inp_prevjoy = 0;
@@ -268,10 +129,66 @@ static unsigned long wait_for_input_usbjoy(unsigned long interesting, int *joy)
 	return ret;
 }
 
+static void menu_flip(void)
+{
+	gp2x_video_flush_cache();
+	gp2x_video_flip2();
+}
+
+
+// --------- loading ROM screen ----------
+
+static void load_progress_cb(int percent)
+{
+	int ln, len = percent * 320 / 100;
+	unsigned short *dst = (unsigned short *)gp2x_screen + 320*20;
+
+	if (len > 320) len = 320;
+	for (ln = 10; ln > 0; ln--, dst += 320)
+		memset(dst, 0xff, len*2);
+	menu_flip();
+}
+
+void menu_romload_prepare(const char *rom_name)
+{
+	const char *p = rom_name + strlen(rom_name);
+	while (p > rom_name && *p != '/') p--;
+
+	if (rom_data) gp2x_pd_clone_buffer2();
+	else memset(gp2x_screen, 0, 320*240*2);
+
+	smalltext_out16(1, 1, "Loading", 0xffff);
+	smalltext_out16_lim(1, 10, p, 0xffff, 53);
+	gp2x_memcpy_buffers(3, gp2x_screen, 0, 320*240*2);
+	menu_flip();
+	PicoCartLoadProgressCB = load_progress_cb;
+}
 
+void menu_romload_end(void)
+{
+	PicoCartLoadProgressCB = NULL;
+	smalltext_out16(1, 30, "Starting emulation...", 0xffff);
+	menu_flip();
+}
 
 // -------------- ROM selector --------------
 
+// rrrr rggg gggb bbbb
+static unsigned short file2color(const char *fname)
+{
+	const char *ext = fname + strlen(fname) - 3;
+	static const char *rom_exts[]   = { "zip", "bin", "smd", "gen", "iso" };
+	static const char *other_exts[] = { "gmv", "pat" };
+	int i;
+
+	if (ext < fname) ext = fname;
+	for (i = 0; i < sizeof(rom_exts)/sizeof(rom_exts[0]); i++)
+		if (strcasecmp(ext, rom_exts[i]) == 0) return 0xbdff;
+	for (i = 0; i < sizeof(other_exts)/sizeof(other_exts[0]); i++)
+		if (strcasecmp(ext, other_exts[i]) == 0) return 0xaff5;
+	return 0xffff;
+}
+
 static void draw_dirlist(char *curdir, struct dirent **namelist, int n, int sel)
 {
 	int start, i, pos;
@@ -279,23 +196,30 @@ static void draw_dirlist(char *curdir, struct dirent **namelist, int n, int sel)
 	start = 12 - sel;
 	n--; // exclude current dir (".")
 
-	memset(gp2x_screen, 0, 320*240);
+	gp2x_pd_clone_buffer2();
+
+	if (rom_data == NULL) {
+		menu_darken_bg(gp2x_screen, 320*240, 0);
+	}
+
+	menu_darken_bg((char *)gp2x_screen + 320*120*2, 320*8, 0);
 
 	if(start - 2 >= 0)
-		gp2x_text_out8_lim(14, (start - 2)*10, curdir, 38);
+		smalltext_out16_lim(14, (start - 2)*10, curdir, 0xffff, 53-2);
 	for (i = 0; i < n; i++) {
 		pos = start + i;
 		if (pos < 0)  continue;
 		if (pos > 23) break;
 		if (namelist[i+1]->d_type == DT_DIR) {
-			gp2x_text_out8_lim(14,   pos*10, "/", 1);
-			gp2x_text_out8_lim(14+8, pos*10, namelist[i+1]->d_name, 37);
+			smalltext_out16_lim(14,   pos*10, "/", 0xfff6, 1);
+			smalltext_out16_lim(14+6, pos*10, namelist[i+1]->d_name, 0xfff6, 53-3);
 		} else {
-			gp2x_text_out8_lim(14,   pos*10, namelist[i+1]->d_name, 38);
+			unsigned short color = file2color(namelist[i+1]->d_name);
+			smalltext_out16_lim(14,   pos*10, namelist[i+1]->d_name, color, 53-2);
 		}
 	}
-	gp2x_text_out8(5, 120, ">");
-	gp2x_video_flip();
+	text_out16(5, 120, ">");
+	menu_flip();
 }
 
 static int scandir_cmp(const void *p1, const void *p2)
@@ -307,6 +231,28 @@ static int scandir_cmp(const void *p1, const void *p2)
 	return alphasort(d1, d2);
 }
 
+static char *filter_exts[] = {
+	".mp3", ".MP3", ".srm", ".brm", "s.gz", ".mds",	"bcfg", ".txt", ".htm", "html",
+	".jpg", ".gpe", ".cue"
+};
+
+static int scandir_filter(const struct dirent *ent)
+{
+	const char *p;
+	int i;
+
+	if (ent == NULL || ent->d_name == NULL) return 0;
+	if (strlen(ent->d_name) < 5) return 1;
+
+	p = ent->d_name + strlen(ent->d_name) - 4;
+
+	for (i = 0; i < sizeof(filter_exts)/sizeof(filter_exts[0]); i++)
+	{
+		if (strcmp(p, filter_exts[i]) == 0) return 0;
+	}
+
+	return 1;
+}
 
 static char *romsel_loop(char *curr_path)
 {
@@ -326,10 +272,10 @@ static char *romsel_loop(char *curr_path)
 		fname = p+1;
 	}
 
-	n = scandir(curr_path, &namelist, 0, scandir_cmp);
+	n = scandir(curr_path, &namelist, scandir_filter, scandir_cmp);
 	if (n < 0) {
 		// try root
-		n = scandir(curr_path, &namelist, 0, scandir_cmp);
+		n = scandir("/", &namelist, scandir_filter, scandir_cmp);
 		if (n < 0) {
 			// oops, we failed
 			printf("dir: "); printf(curr_path); printf("\n");
@@ -352,11 +298,13 @@ static char *romsel_loop(char *curr_path)
 	for (;;)
 	{
 		draw_dirlist(curr_path, namelist, n, sel);
-		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_LEFT|GP2X_RIGHT|GP2X_B|GP2X_X);
+		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_LEFT|GP2X_RIGHT|GP2X_L|GP2X_R|GP2X_B|GP2X_X);
 		if(inp & GP2X_UP  )  { sel--;   if (sel < 0)   sel = n-2; }
 		if(inp & GP2X_DOWN)  { sel++;   if (sel > n-2) sel = 0; }
 		if(inp & GP2X_LEFT)  { sel-=10; if (sel < 0)   sel = 0; }
+		if(inp & GP2X_L)     { sel-=24; if (sel < 0)   sel = 0; }
 		if(inp & GP2X_RIGHT) { sel+=10; if (sel > n-2) sel = n-2; }
+		if(inp & GP2X_R)     { sel+=24; if (sel > n-2) sel = n-2; }
 		if(inp & GP2X_B)     { // enter dir/select
 			again:
 			if (namelist[sel+1]->d_type == DT_REG) {
@@ -413,6 +361,215 @@ static char *romsel_loop(char *curr_path)
 	return ret;
 }
 
+// ------------ debug menu ------------
+
+char *debugString(void);
+
+static void draw_debug(void)
+{
+	char *p, *str = debugString();
+	int len, line;
+
+	gp2x_pd_clone_buffer2();
+
+	p = str;
+	for (line = 0; line < 24; line++)
+	{
+		while (*p && *p != '\n') p++;
+		len = p - str;
+		if (len > 55) len = 55;
+		smalltext_out16_lim(1, line*10, str, 0xffff, len);
+		if (*p == 0) break;
+		p++; str = p;
+	}
+	menu_flip();
+}
+
+static void debug_menu_loop(void)
+{
+	draw_debug();
+	wait_for_input(GP2X_B|GP2X_X);
+}
+
+// ------------ patch/gg menu ------------
+
+static void draw_patchlist(int sel)
+{
+	int start, i, pos, active;
+
+	start = 12 - sel;
+
+	gp2x_pd_clone_buffer2();
+
+	for (i = 0; i < PicoPatchCount; i++) {
+		pos = start + i;
+		if (pos < 0)  continue;
+		if (pos > 23) break;
+		active = PicoPatches[i].active;
+		smalltext_out16_lim(14,     pos*10, active ? "ON " : "OFF", active ? 0xfff6 : 0xffff, 3);
+		smalltext_out16_lim(14+6*4, pos*10, PicoPatches[i].name, active ? 0xfff6 : 0xffff, 53-6);
+	}
+	pos = start + i;
+	if (pos < 24) smalltext_out16_lim(14, pos*10, "done", 0xffff, 4);
+
+	text_out16(5, 120, ">");
+	menu_flip();
+}
+
+
+static void patches_menu_loop(void)
+{
+	int menu_sel = 0;
+	unsigned long inp = 0;
+
+	for(;;)
+	{
+		draw_patchlist(menu_sel);
+		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_LEFT|GP2X_RIGHT|GP2X_L|GP2X_R|GP2X_B|GP2X_X);
+		if(inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = PicoPatchCount; }
+		if(inp & GP2X_DOWN) { menu_sel++; if (menu_sel > PicoPatchCount) menu_sel = 0; }
+		if(inp &(GP2X_LEFT|GP2X_L))  { menu_sel-=10; if (menu_sel < 0) menu_sel = 0; }
+		if(inp &(GP2X_RIGHT|GP2X_R)) { menu_sel+=10; if (menu_sel > PicoPatchCount) menu_sel = PicoPatchCount; }
+		if(inp & GP2X_B) { // action
+			if (menu_sel < PicoPatchCount)
+				PicoPatches[menu_sel].active = !PicoPatches[menu_sel].active;
+			else 	return;
+		}
+		if(inp & GP2X_X) return;
+	}
+
+}
+
+// ------------ savestate loader ------------
+
+static int state_slot_flags = 0;
+
+static void state_check_slots(void)
+{
+	int slot;
+
+	state_slot_flags = 0;
+
+	for (slot = 0; slot < 10; slot++)
+	{
+		if (emu_check_save_file(slot))
+		{
+			state_slot_flags |= 1 << slot;
+		}
+	}
+}
+
+static void draw_savestate_bg(int slot)
+{
+	struct PicoVideo tmp_pv;
+	unsigned short tmp_cram[0x40];
+	unsigned short tmp_vsram[0x40];
+	void *tmp_vram, *file;
+	char *fname;
+
+	fname = emu_GetSaveFName(1, 0, slot);
+	if (!fname) return;
+
+	tmp_vram = malloc(sizeof(Pico.vram));
+	if (tmp_vram == NULL) return;
+
+	memcpy(tmp_vram, Pico.vram, sizeof(Pico.vram));
+	memcpy(tmp_cram, Pico.cram, sizeof(Pico.cram));
+	memcpy(tmp_vsram, Pico.vsram, sizeof(Pico.vsram));
+	memcpy(&tmp_pv, &Pico.video, sizeof(Pico.video));
+
+	if (strcmp(fname + strlen(fname) - 3, ".gz") == 0) {
+		file = gzopen(fname, "rb");
+		emu_set_save_cbs(1);
+	} else {
+		file = fopen(fname, "rb");
+		emu_set_save_cbs(0);
+	}
+
+	if (file) {
+		if (PicoMCD & 1) {
+			PicoCdLoadStateGfx(file);
+		} else {
+			areaSeek(file, 0x10020, SEEK_SET);  // skip header and RAM in state file
+			areaRead(Pico.vram, 1, sizeof(Pico.vram), file);
+			areaSeek(file, 0x2000, SEEK_CUR);
+			areaRead(Pico.cram, 1, sizeof(Pico.cram), file);
+			areaRead(Pico.vsram, 1, sizeof(Pico.vsram), file);
+			areaSeek(file, 0x221a0, SEEK_SET);
+			areaRead(&Pico.video, 1, sizeof(Pico.video), file);
+		}
+		areaClose(file);
+	}
+
+	emu_forced_frame();
+	menu_prepare_bg(1);
+
+	memcpy(Pico.vram, tmp_vram, sizeof(Pico.vram));
+	memcpy(Pico.cram, tmp_cram, sizeof(Pico.cram));
+	memcpy(Pico.vsram, tmp_vsram, sizeof(Pico.vsram));
+	memcpy(&Pico.video, &tmp_pv,  sizeof(Pico.video));
+	free(tmp_vram);
+}
+
+static void draw_savestate_menu(int menu_sel, int is_loading)
+{
+	int tl_x = 25, tl_y = 60, y, i;
+
+	if (state_slot_flags & (1 << menu_sel))
+		draw_savestate_bg(menu_sel);
+	gp2x_pd_clone_buffer2();
+
+	text_out16(tl_x, 30, is_loading ? "Load state" : "Save state");
+
+	menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 108);
+
+	/* draw all 10 slots */
+	y = tl_y;
+	for (i = 0; i < 10; i++, y+=10)
+	{
+		text_out16(tl_x, y, "SLOT %i (%s)", i, (state_slot_flags & (1 << i)) ? "USED" : "free");
+	}
+	text_out16(tl_x, y, "back");
+
+	menu_flip();
+}
+
+static int savestate_menu_loop(int is_loading)
+{
+	static int menu_sel = 10;
+	int menu_sel_max = 10;
+	unsigned long inp = 0;
+
+	state_check_slots();
+
+	for(;;)
+	{
+		draw_savestate_menu(menu_sel, is_loading);
+		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_B|GP2X_X);
+		if(inp & GP2X_UP  ) {
+			do {
+				menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max;
+			} while (!(state_slot_flags & (1 << menu_sel)) && menu_sel != menu_sel_max && is_loading);
+		}
+		if(inp & GP2X_DOWN) {
+			do {
+				menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0;
+			} while (!(state_slot_flags & (1 << menu_sel)) && menu_sel != menu_sel_max && is_loading);
+		}
+		if(inp & GP2X_B) { // save/load
+			if (menu_sel < 10) {
+				state_slot = menu_sel;
+				if (emu_SaveLoadGame(is_loading, 0)) {
+					strcpy(menuErrorMsg, is_loading ? "Load failed" : "Save failed");
+					return 1;
+				}
+				return 0;
+			} else	return 1;
+		}
+		if(inp & GP2X_X) return 1;
+	}
+}
+
 // -------------- key config --------------
 
 static char *usb_joy_key_name(int joy, int num)
@@ -429,17 +586,17 @@ static char *usb_joy_key_name(int joy, int num)
 	return name;
 }
 
-static void draw_key_config(int curr_act, int is_p2)
+static char *action_binds(int player_idx, int action_mask)
 {
-	char strkeys[32*5];
+	static char strkeys[32*5];
 	int joy, i;
 
 	strkeys[0] = 0;
-	for (i = 0; i < 32; i++)
+	for (i = 0; i < 32; i++) // i is key index
 	{
-		if (currentConfig.KeyBinds[i] & (1 << curr_act))
+		if (currentConfig.KeyBinds[i] & action_mask)
 		{
-			if (curr_act < 16 && (currentConfig.KeyBinds[i] & (1 << 16)) != (is_p2 << 16)) continue;
+			if (player_idx >= 0 && ((currentConfig.KeyBinds[i] >> 16) & 3) != player_idx) continue;
 			if (strkeys[0]) { strcat(strkeys, " + "); strcat(strkeys, gp2xKeyNames[i]); break; }
 			else strcpy(strkeys, gp2xKeyNames[i]);
 		}
@@ -448,9 +605,9 @@ static void draw_key_config(int curr_act, int is_p2)
 	{
 		for (i = 0; i < 32; i++)
 		{
-			if (currentConfig.JoyBinds[joy][i] & (1 << curr_act))
+			if (currentConfig.JoyBinds[joy][i] & action_mask)
 			{
-				if (curr_act < 16 && (currentConfig.JoyBinds[joy][i] & (1 << 16)) != (is_p2 << 16)) continue;
+				if (player_idx >= 0 && ((currentConfig.JoyBinds[joy][i] >> 16) & 3) != player_idx) continue;
 				if (strkeys[0]) {
 					strcat(strkeys, ", "); strcat(strkeys, usb_joy_key_name(joy + 1, i));
 					break;
@@ -460,50 +617,121 @@ static void draw_key_config(int curr_act, int is_p2)
 		}
 	}
 
-	memset(gp2x_screen, 0, 320*240);
-	gp2x_text_out8(60, 40, "Action: %s", actionNames[curr_act]);
-	gp2x_text_out8(60, 60, "Keys: %s", strkeys);
+	return strkeys;
+}
+
+static void unbind_action(int action)
+{
+	int i, u;
 
-	gp2x_text_out8(30, 180, "Use SELECT to change action");
-	gp2x_text_out8(30, 190, "Press a key to bind/unbind");
-	gp2x_text_out8(30, 200, "Select \"Done\" action and");
-	gp2x_text_out8(30, 210, "  press any key to finish");
-	gp2x_video_flip();
+	for (i = 0; i < 32; i++)
+		currentConfig.KeyBinds[i] &= ~action;
+	for (u = 0; u < 4; u++)
+		for (i = 0; i < 32; i++)
+			currentConfig.JoyBinds[u][i] &= ~action;
 }
 
-static void key_config_loop(int is_p2)
+static int count_bound_keys(int action, int joy)
 {
-	int curr_act = 0, joy = 0, i;
+	int i, keys = 0;
+
+	if (joy)
+	{
+		for (i = 0; i < 32; i++)
+			if (currentConfig.JoyBinds[joy-1][i] & action) keys++;
+	}
+	else
+	{
+		for (i = 0; i < 32; i++)
+			if (currentConfig.KeyBinds[i] & action) keys++;
+	}
+	return keys;
+}
+
+typedef struct { char *name; int mask; } bind_action_t;
+
+static void draw_key_config(const bind_action_t *opts, int opt_cnt, int player_idx, int sel)
+{
+	int x, y, tl_y = 40, i;
+
+	gp2x_pd_clone_buffer2();
+	if (player_idx >= 0) {
+		text_out16(80, 20, "Player %i controls", player_idx + 1);
+		x = 100;
+	} else {
+		text_out16(80, 20, "Emulator controls");
+		x = 40;
+	}
+
+	menu_draw_selection(x - 16, tl_y + sel*10, (player_idx >= 0) ? 66 : 130);
+
+	y = tl_y;
+	for (i = 0; i < opt_cnt; i++, y+=10)
+		text_out16(x, y, "%s : %s", opts[i].name, action_binds(player_idx, opts[i].mask));
+
+	text_out16(x, y, "Done");
+
+	if (sel < opt_cnt) {
+		text_out16(30, 180, "Press a button to bind/unbind");
+		text_out16(30, 190, "Use SELECT to clear");
+		text_out16(30, 200, "To bind UP/DOWN, hold SELECT");
+		text_out16(30, 210, "Select \"Done\" to exit");
+	} else {
+		text_out16(30, 190, "Use Options -> Save cfg");
+		text_out16(30, 200, "to save controls");
+		text_out16(30, 210, "Press B or X to exit");
+	}
+	menu_flip();
+}
+
+static void key_config_loop(const bind_action_t *opts, int opt_cnt, int player_idx)
+{
+	int joy = 0, sel = 0, menu_sel_max = opt_cnt, prev_select = 0, i;
 	unsigned long inp = 0;
 
 	for (;;)
 	{
-		draw_key_config(curr_act, is_p2);
+		draw_key_config(opts, opt_cnt, player_idx, sel);
 		inp = wait_for_input_usbjoy(CONFIGURABLE_KEYS, &joy);
 		// printf("got %08lX from joy %i\n", inp, joy);
 		if (joy == 0) {
-			if (inp & GP2X_SELECT) {
-				curr_act++;
-				while (!actionNames[curr_act] && curr_act < 32) curr_act++;
-				if (curr_act > 31) curr_act = 0;
+			if (!(inp & GP2X_SELECT)) {
+				prev_select = 0;
+				if(inp & GP2X_UP  ) { sel--; if (sel < 0) sel = menu_sel_max; continue; }
+				if(inp & GP2X_DOWN) { sel++; if (sel > menu_sel_max) sel = 0; continue; }
 			}
+			if (sel >= opt_cnt) {
+				if (inp & (GP2X_B|GP2X_X)) break;
+				else continue;
+			}
+			// if we are here, we want to bind/unbind something
+			if ((inp & GP2X_SELECT) && !prev_select)
+				unbind_action(opts[sel].mask);
+			prev_select = inp & GP2X_SELECT;
 			inp &= CONFIGURABLE_KEYS;
 			inp &= ~GP2X_SELECT;
-		}
-		if (curr_act == 31 && inp) break;
-		if (joy == 0) {
 			for (i = 0; i < 32; i++)
 				if (inp & (1 << i)) {
-					currentConfig.KeyBinds[i] ^= (1 << curr_act);
-					if (is_p2) currentConfig.KeyBinds[i] |=  (1 << 16); // player 2 flag
-					else       currentConfig.KeyBinds[i] &= ~(1 << 16);
+					if (count_bound_keys(opts[sel].mask, 0) >= 2)
+					     currentConfig.KeyBinds[i] &= ~opts[sel].mask; // allow to unbind only
+					else currentConfig.KeyBinds[i] ^=  opts[sel].mask;
+					if (player_idx >= 0) {
+						currentConfig.KeyBinds[i] &= ~(3 << 16);
+						currentConfig.KeyBinds[i] |= player_idx << 16;
+					}
 				}
-		} else {
+		}
+		else if (sel < opt_cnt)
+		{
 			for (i = 0; i < 32; i++)
 				if (inp & (1 << i)) {
-					currentConfig.JoyBinds[joy-1][i] ^= (1 << curr_act);
-					if (is_p2) currentConfig.JoyBinds[joy-1][i] |=  (1 << 16);
-					else       currentConfig.JoyBinds[joy-1][i] &= ~(1 << 16);
+					if (count_bound_keys(opts[sel].mask, joy) >= 1) // disallow combos for usbjoy
+					     currentConfig.JoyBinds[joy-1][i] &= ~opts[sel].mask;
+					else currentConfig.JoyBinds[joy-1][i] ^=  opts[sel].mask;
+					if (player_idx >= 0) {
+						currentConfig.JoyBinds[joy-1][i] &= ~(3 << 16);
+						currentConfig.JoyBinds[joy-1][i] |= player_idx << 16;
+					}
 				}
 		}
 	}
@@ -515,187 +743,448 @@ static void draw_kc_sel(int menu_sel)
 	char joyname[36];
 
 	y = tl_y;
-	memset(gp2x_screen, 0, 320*240);
-	gp2x_text_out8(tl_x, y,       "Player 1");
-	gp2x_text_out8(tl_x, (y+=10), "Player 2");
-	gp2x_text_out8(tl_x, (y+=10), "Done");
+	gp2x_pd_clone_buffer2();
+	menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 138);
 
-	// draw cursor
-	gp2x_text_out8(tl_x - 16, tl_y + menu_sel*10, ">");
+	text_out16(tl_x, y,       "Player 1");
+	text_out16(tl_x, (y+=10), "Player 2");
+	text_out16(tl_x, (y+=10), "Emulator controls");
+	text_out16(tl_x, (y+=10), "Done");
 
 	tl_x = 25;
-	gp2x_text_out8(tl_x, (y=110), "USB joys detected:");
+	text_out16(tl_x, (y=110), "USB joys detected:");
 	if (num_of_joys > 0) {
 		for (i = 0; i < num_of_joys; i++) {
 			strncpy(joyname, joy_name(joys[i]), 33); joyname[33] = 0;
-			gp2x_text_out8(tl_x, (y+=10), "%i: %s", i+1, joyname);
+			text_out16(tl_x, (y+=10), "%i: %s", i+1, joyname);
 		}
 	} else {
-		gp2x_text_out8(tl_x, (y+=10), "none");
+		text_out16(tl_x, (y+=10), "none");
 	}
 
-
-	gp2x_video_flip();
+	menu_flip();
 }
 
+
+// PicoPad[] format: MXYZ SACB RLDU
+static bind_action_t ctrl_actions[] =
+{
+	{ "UP     ", 0x001 },
+	{ "DOWN   ", 0x002 },
+	{ "LEFT   ", 0x004 },
+	{ "RIGHT  ", 0x008 },
+	{ "A      ", 0x040 },
+	{ "B      ", 0x010 },
+	{ "C      ", 0x020 },
+	{ "START  ", 0x080 },
+	{ "MODE   ", 0x800 },
+	{ "X      ", 0x400 },
+	{ "Y      ", 0x200 },
+	{ "Z      ", 0x100 },
+};
+
+// player2_flag, ?, ?, ?, ?, ?, ?, menu
+// "NEXT SAVE SLOT", "PREV SAVE SLOT", "SWITCH RENDERER", "SAVE STATE",
+// "LOAD STATE", "VOLUME UP", "VOLUME DOWN", "DONE"
+static bind_action_t emuctrl_actions[] =
+{
+	{ "Load State     ", 1<<28 },
+	{ "Save State     ", 1<<27 },
+	{ "Prev Save Slot ", 1<<25 },
+	{ "Next Save Slot ", 1<<24 },
+	{ "Switch Renderer", 1<<26 },
+	{ "Volume Down    ", 1<<30 },
+	{ "Volume Up      ", 1<<29 },
+	{ "Enter Menu     ", 1<<23 },
+};
+
 static void kc_sel_loop(void)
 {
-	int menu_sel = 2, menu_sel_max = 2;
+	int menu_sel = 3, menu_sel_max = 3;
 	unsigned long inp = 0;
+	int is_6button = currentConfig.PicoOpt & 0x020;
 
-	for(;;)
+	while (1)
 	{
 		draw_kc_sel(menu_sel);
 		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_B|GP2X_X);
-		if(inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
-		if(inp & GP2X_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
-		if(inp & GP2X_B) {
+		if (inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+		if (inp & GP2X_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+		if (inp & GP2X_B) {
 			switch (menu_sel) {
-				case 0: key_config_loop(0); return;
-				case 1: key_config_loop(1); return;
+				case 0: key_config_loop(ctrl_actions, is_6button ? 12 : 8, 0); return;
+				case 1: key_config_loop(ctrl_actions, is_6button ? 12 : 8, 1); return;
+				case 2: key_config_loop(emuctrl_actions,
+						sizeof(emuctrl_actions)/sizeof(emuctrl_actions[0]), -1); return;
+				case 3: if (rom_data == NULL) emu_WriteConfig(0); return;
 				default: return;
 			}
 		}
-		if(inp & GP2X_X) return;
+		if (inp & GP2X_X) return;
+	}
+}
+
+
+// --------- sega/mega cd options ----------
+
+menu_entry cdopt_entries[] =
+{
+	{ NULL,                        MB_NONE,  MA_CDOPT_TESTBIOS_USA, NULL, 0, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_CDOPT_TESTBIOS_EUR, NULL, 0, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_CDOPT_TESTBIOS_JAP, NULL, 0, 0, 0, 1 },
+	{ "CD LEDs",                   MB_ONOFF, MA_CDOPT_LEDS,         &currentConfig.EmuOpt,  0x0400, 0, 0, 1 },
+	{ "CDDA audio (using mp3s)",   MB_ONOFF, MA_CDOPT_CDDA,         &currentConfig.PicoOpt, 0x0800, 0, 0, 1 },
+	{ "PCM audio",                 MB_ONOFF, MA_CDOPT_PCM,          &currentConfig.PicoOpt, 0x0400, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_CDOPT_READAHEAD,    NULL, 0, 0, 0, 1 },
+	{ "SaveRAM cart",              MB_ONOFF, MA_CDOPT_SAVERAM,      &currentConfig.PicoOpt, 0x8000, 0, 0, 1 },
+	{ "Scale/Rot. fx (slow)",      MB_ONOFF, MA_CDOPT_SCALEROT_CHIP,&currentConfig.PicoOpt, 0x1000, 0, 0, 1 },
+	{ "Better sync (slow)",        MB_ONOFF, MA_CDOPT_BETTER_SYNC,  &currentConfig.PicoOpt, 0x2000, 0, 0, 1 },
+	{ "done",                      MB_NONE,  MA_CDOPT_DONE,         NULL, 0, 0, 0, 1 },
+};
+
+#define CDOPT_ENTRY_COUNT (sizeof(cdopt_entries) / sizeof(cdopt_entries[0]))
+
+
+struct bios_names_t
+{
+	char us[32], eu[32], jp[32];
+};
+
+static void menu_cdopt_cust_draw(const menu_entry *entry, int x, int y, void *param)
+{
+	struct bios_names_t *bios_names = param;
+	char ra_buff[16];
+
+	switch (entry->id)
+	{
+		case MA_CDOPT_TESTBIOS_USA: text_out16(x, y, "USA BIOS:     %s", bios_names->us); break;
+		case MA_CDOPT_TESTBIOS_EUR: text_out16(x, y, "EUR BIOS:     %s", bios_names->eu); break;
+		case MA_CDOPT_TESTBIOS_JAP: text_out16(x, y, "JAP BIOS:     %s", bios_names->jp); break;
+		case MA_CDOPT_READAHEAD:
+			if (PicoCDBuffers > 1) sprintf(ra_buff, "%5iK", PicoCDBuffers * 2);
+			else strcpy(ra_buff, "     OFF");
+			text_out16(x, y, "ReadAhead buffer      %s", ra_buff);
+			break;
+		default:break;
 	}
 }
 
+static void draw_cd_menu_options(int menu_sel, struct bios_names_t *bios_names)
+{
+	int tl_x = 25, tl_y = 60;
+	menu_id selected_id;
+	char ra_buff[16];
+
+	if (PicoCDBuffers > 1) sprintf(ra_buff, "%5iK", PicoCDBuffers * 2);
+	else strcpy(ra_buff, "     OFF");
 
+	gp2x_pd_clone_buffer2();
+
+	menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 246);
+
+	me_draw(cdopt_entries, CDOPT_ENTRY_COUNT, tl_x, tl_y, menu_cdopt_cust_draw, bios_names);
+
+	selected_id = me_index2id(cdopt_entries, CDOPT_ENTRY_COUNT, menu_sel);
+	if ((selected_id == MA_CDOPT_TESTBIOS_USA && strcmp(bios_names->us, "NOT FOUND")) ||
+		(selected_id == MA_CDOPT_TESTBIOS_EUR && strcmp(bios_names->eu, "NOT FOUND")) ||
+		(selected_id == MA_CDOPT_TESTBIOS_JAP && strcmp(bios_names->jp, "NOT FOUND")))
+			text_out16(tl_x, 210, "Press start to test selected BIOS");
+
+	menu_flip();
+}
+
+static void cd_menu_loop_options(void)
+{
+	static int menu_sel = 0;
+	int menu_sel_max = 10;
+	unsigned long inp = 0;
+	struct bios_names_t bios_names;
+	menu_id selected_id;
+	char *bios, *p;
+
+	if (find_bios(4, &bios)) { // US
+		for (p = bios+strlen(bios)-1; p > bios && *p != '/'; p--); p++;
+		strncpy(bios_names.us, p, sizeof(bios_names.us)); bios_names.us[sizeof(bios_names.us)-1] = 0;
+	} else	strcpy(bios_names.us, "NOT FOUND");
+
+	if (find_bios(8, &bios)) { // EU
+		for (p = bios+strlen(bios)-1; p > bios && *p != '/'; p--); p++;
+		strncpy(bios_names.eu, p, sizeof(bios_names.eu)); bios_names.eu[sizeof(bios_names.eu)-1] = 0;
+	} else	strcpy(bios_names.eu, "NOT FOUND");
+
+	if (find_bios(1, &bios)) { // JP
+		for (p = bios+strlen(bios)-1; p > bios && *p != '/'; p--); p++;
+		strncpy(bios_names.jp, p, sizeof(bios_names.jp)); bios_names.jp[sizeof(bios_names.jp)-1] = 0;
+	} else	strcpy(bios_names.jp, "NOT FOUND");
+
+	for(;;)
+	{
+		draw_cd_menu_options(menu_sel, &bios_names);
+		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_LEFT|GP2X_RIGHT|GP2X_B|GP2X_X|GP2X_A|GP2X_START);
+		if (inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+		if (inp & GP2X_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+		selected_id = me_index2id(cdopt_entries, CDOPT_ENTRY_COUNT, menu_sel);
+		if (inp & (GP2X_LEFT|GP2X_RIGHT)) { // multi choise
+			if (!me_process(cdopt_entries, CDOPT_ENTRY_COUNT, selected_id, (inp&GP2X_RIGHT) ? 1 : 0) &&
+			    selected_id == MA_CDOPT_READAHEAD) {
+				if (inp & GP2X_LEFT) {
+					PicoCDBuffers >>= 1;
+					if (PicoCDBuffers < 64) PicoCDBuffers = 0;
+				} else {
+					if (PicoCDBuffers < 64) PicoCDBuffers = 64;
+					else PicoCDBuffers <<= 1;
+					if (PicoCDBuffers > 8*1024) PicoCDBuffers = 8*1024; // 16M
+				}
+			}
+		}
+		if (inp & GP2X_B) { // toggleable options
+			if (!me_process(cdopt_entries, CDOPT_ENTRY_COUNT, selected_id, 1) &&
+			    selected_id == MA_CDOPT_DONE) {
+				return;
+			}
+		}
+		if (inp & GP2X_START) { // BIOS testers
+			switch (selected_id) {
+				case MA_CDOPT_TESTBIOS_USA:
+					if (find_bios(4, &bios)) { // test US
+						strcpy(romFileName, bios);
+						engineState = PGS_ReloadRom;
+						return;
+					}
+					break;
+				case MA_CDOPT_TESTBIOS_EUR:
+					if (find_bios(8, &bios)) { // test EU
+						strcpy(romFileName, bios);
+						engineState = PGS_ReloadRom;
+						return;
+					}
+					break;
+				case MA_CDOPT_TESTBIOS_JAP:
+					if (find_bios(1, &bios)) { // test JP
+						strcpy(romFileName, bios);
+						engineState = PGS_ReloadRom;
+						return;
+					}
+					break;
+				default:
+					break;
+			}
+		}
+		if (inp & (GP2X_X|GP2X_A)) return;
+	}
+}
 
 
 // --------- advanced options ----------
 
-// order must match that of currentConfig_t
-struct {
-	int EmuOpt;
-	int PicoOpt;
-	int PsndRate;
-	int PicoRegion;
-	int Frameskip;
-	int CPUclock;
-} tmp_opts;
-int tmp_gamma;
+menu_entry opt2_entries[] =
+{
+	{ NULL,                        MB_NONE,  MA_OPT2_GAMMA,         NULL, 0, 0, 0, 1 },
+	{ "A_SN's gamma curve",        MB_ONOFF, MA_OPT2_A_SN_GAMMA,    &currentConfig.EmuOpt, 0x1000, 0, 0, 1 },
+	{ "Perfect vsync",             MB_ONOFF, MA_OPT2_VSYNC,         &currentConfig.EmuOpt, 0x2000, 0, 0, 1 },
+	{ "Emulate Z80",               MB_ONOFF, MA_OPT2_ENABLE_Z80,    &currentConfig.PicoOpt,0x0004, 0, 0, 1 },
+	{ "Emulate YM2612 (FM)",       MB_ONOFF, MA_OPT2_ENABLE_YM2612, &currentConfig.PicoOpt,0x0001, 0, 0, 1 },
+	{ "Emulate SN76496 (PSG)",     MB_ONOFF, MA_OPT2_ENABLE_SN76496,&currentConfig.PicoOpt,0x0002, 0, 0, 1 },
+	{ "gzip savestates",           MB_ONOFF, MA_OPT2_GZIP_STATES,   &currentConfig.EmuOpt, 0x0008, 0, 0, 1 },
+	{ "Don't save last used ROM",  MB_ONOFF, MA_OPT2_NO_LAST_ROM,   &currentConfig.EmuOpt, 0x0020, 0, 0, 1 },
+	{ "needs restart:",            MB_NONE,  MA_NONE,               NULL, 0, 0, 0, 1 },
+	{ "craigix's RAM timings",     MB_ONOFF, MA_OPT2_RAMTIMINGS,    &currentConfig.EmuOpt, 0x0100, 0, 0, 1 },
+	{ NULL,                        MB_ONOFF, MA_OPT2_SQUIDGEHACK,   &currentConfig.EmuOpt, 0x0010, 0, 0, 1 },
+	{ "done",                      MB_NONE,  MA_OPT2_DONE,          NULL, 0, 0, 0, 1 },
+};
+
+#define OPT2_ENTRY_COUNT (sizeof(opt2_entries) / sizeof(opt2_entries[0]))
+
+static void menu_opt2_cust_draw(const menu_entry *entry, int x, int y, void *param)
+{
+	if (entry->id == MA_OPT2_GAMMA)
+		text_out16(x, y, "Gamma correction           %i.%02i", currentConfig.gamma / 100, currentConfig.gamma%100);
+	else if (entry->id == MA_OPT2_SQUIDGEHACK)
+		text_out16(x, y, "squidgehack (now %s %s", mmuhack_status ? "active)  " : "inactive)",
+			(currentConfig.EmuOpt&0x0010)?"ON":"OFF");
+}
+
 
 static void draw_amenu_options(int menu_sel)
 {
-	int tl_x = 25, tl_y = 60, y;
-	char *mms = mmuhack_status ? "active)  " : "inactive)";
+	int tl_x = 25, tl_y = 50;
 
-	y = tl_y;
-	memset(gp2x_screen, 0, 320*240);
-	gp2x_text_out8(tl_x, y,       "Scale 32 column mode       %s", (tmp_opts.PicoOpt&0x100)?"ON":"OFF"); // 0
-	gp2x_text_out8(tl_x, (y+=10), "Gamma correction           %i.%02i", tmp_gamma / 100, tmp_gamma%100); // 1
-	gp2x_text_out8(tl_x, (y+=10), "Emulate Z80                %s", (tmp_opts.PicoOpt&0x004)?"ON":"OFF"); // 2
-	gp2x_text_out8(tl_x, (y+=10), "Emulate YM2612 (FM)        %s", (tmp_opts.PicoOpt&0x001)?"ON":"OFF"); // 3
-	gp2x_text_out8(tl_x, (y+=10), "Emulate SN76496 (PSG)      %s", (tmp_opts.PicoOpt&0x002)?"ON":"OFF"); // 4
-	gp2x_text_out8(tl_x, (y+=10), "gzip savestates            %s", (tmp_opts.EmuOpt &0x008)?"ON":"OFF"); // 5
-	gp2x_text_out8(tl_x, (y+=10), "Don't save config on exit  %s", (tmp_opts.EmuOpt &0x020)?"ON":"OFF"); // 6
-	gp2x_text_out8(tl_x, (y+=10), "needs restart:");
-	gp2x_text_out8(tl_x, (y+=10), "craigix's RAM timings      %s", (tmp_opts.EmuOpt &0x100)?"ON":"OFF"); // 8
-	gp2x_text_out8(tl_x, (y+=10), "squidgehack (now %s %s",   mms, (tmp_opts.EmuOpt &0x010)?"ON":"OFF"); // 9
-	gp2x_text_out8(tl_x, (y+=10), "Done");
+	gp2x_pd_clone_buffer2();
 
-	// draw cursor
-	gp2x_text_out8(tl_x - 16, tl_y + menu_sel*10, ">");
+	menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 252);
 
-	gp2x_video_flip();
+	me_draw(opt2_entries, OPT2_ENTRY_COUNT, tl_x, tl_y, menu_opt2_cust_draw, NULL);
+
+	menu_flip();
 }
 
 static void amenu_loop_options(void)
 {
-	int menu_sel = 0, menu_sel_max = 11;
+	static int menu_sel = 0;
+	int menu_sel_max;
 	unsigned long inp = 0;
+	menu_id selected_id;
+
+	menu_sel_max = me_count_enabled(opt2_entries, OPT2_ENTRY_COUNT) - 1;
 
 	for(;;)
 	{
 		draw_amenu_options(menu_sel);
 		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_LEFT|GP2X_RIGHT|GP2X_B|GP2X_X|GP2X_A);
-		if(inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
-		if(inp & GP2X_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
-		if((inp& GP2X_B)||(inp&GP2X_LEFT)||(inp&GP2X_RIGHT)) { // toggleable options
-			switch (menu_sel) {
-				case  0: tmp_opts.PicoOpt^=0x100; break;
-				case  2: tmp_opts.PicoOpt^=0x004; break;
-				case  3: tmp_opts.PicoOpt^=0x001; break;
-				case  4: tmp_opts.PicoOpt^=0x002; break;
-				case  5: tmp_opts.EmuOpt ^=0x008; break;
-				case  6: tmp_opts.EmuOpt ^=0x020; break;
-				case  8: tmp_opts.EmuOpt ^=0x100; break;
-				case  9: tmp_opts.EmuOpt ^=0x010; break;
-				case 10: return;
+		if (inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+		if (inp & GP2X_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+		selected_id = me_index2id(opt2_entries, OPT2_ENTRY_COUNT, menu_sel);
+		if (inp & (GP2X_LEFT|GP2X_RIGHT)) { // multi choise
+			if (!me_process(opt2_entries, OPT2_ENTRY_COUNT, selected_id, (inp&GP2X_RIGHT) ? 1 : 0) &&
+			    selected_id == MA_OPT2_GAMMA) {
+				while ((inp = gp2x_joystick_read(1)) & (GP2X_LEFT|GP2X_RIGHT)) {
+					currentConfig.gamma += (inp & GP2X_LEFT) ? -1 : 1;
+					if (currentConfig.gamma <   1) currentConfig.gamma =   1;
+					if (currentConfig.gamma > 300) currentConfig.gamma = 300;
+					draw_amenu_options(menu_sel);
+					usleep(18*1000);
+				}
 			}
 		}
-		if(inp & (GP2X_X|GP2X_A)) return;
-		if(inp & (GP2X_LEFT|GP2X_RIGHT)) { // multi choise
-			switch (menu_sel) {
-				case 1:
-					while ((inp = gp2x_joystick_read(1)) & (GP2X_LEFT|GP2X_RIGHT)) {
-						tmp_gamma += (inp & GP2X_LEFT) ? -1 : 1;
-						if (tmp_gamma <   1) tmp_gamma =   1;
-						if (tmp_gamma > 300) tmp_gamma = 300;
-						draw_amenu_options(menu_sel);
-						usleep(18*1000);
-					}
-					break;
+		if (inp & GP2X_B) { // toggleable options
+			if (!me_process(opt2_entries, OPT2_ENTRY_COUNT, selected_id, 1) &&
+			    selected_id == MA_OPT2_DONE) {
+				return;
 			}
 		}
+		if (inp & (GP2X_X|GP2X_A)) return;
 	}
 }
 
 // -------------- options --------------
 
-static char *region_name(unsigned int code)
+
+menu_entry opt_entries[] =
 {
-	char *names[] = { "Auto", "Japan NTSC", "Japan PAL", "USA", "Europe" };
-	int i = 0;
-	code <<= 1;
-	while((code >>=1)) i++;
-	if (i > 4) return "unknown";
-	return names[i];
-}
+	{ NULL,                        MB_NONE,  MA_OPT_RENDERER,      NULL, 0, 0, 0, 1 },
+	{ NULL,                        MB_RANGE, MA_OPT_SCALING,       &currentConfig.scaling, 0, 0, 3, 1 },
+	{ "Accurate timing (slower)",  MB_ONOFF, MA_OPT_ACC_TIMING,    &currentConfig.PicoOpt, 0x040, 0, 0, 1 },
+	{ "Accurate sprites (slower)", MB_ONOFF, MA_OPT_ACC_SPRITES,   &currentConfig.PicoOpt, 0x080, 0, 0, 1 },
+	{ "Show FPS",                  MB_ONOFF, MA_OPT_SHOW_FPS,      &currentConfig.EmuOpt,  0x002, 0, 0, 1 },
+	{ NULL,                        MB_RANGE, MA_OPT_FRAMESKIP,     &currentConfig.Frameskip, 0, -1, 16, 1 },
+	{ "Enable sound",              MB_ONOFF, MA_OPT_ENABLE_SOUND,  &currentConfig.EmuOpt,  0x004, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_OPT_SOUND_QUALITY, NULL, 0, 0, 0, 1 },
+	{ "Use ARM940 core for sound", MB_ONOFF, MA_OPT_ARM940_SOUND,  &currentConfig.PicoOpt, 0x200, 0, 0, 1 },
+	{ "6 button pad",              MB_ONOFF, MA_OPT_6BUTTON_PAD,   &currentConfig.PicoOpt, 0x020, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_OPT_REGION,        NULL, 0, 0, 0, 1 },
+	{ "Use SRAM/BRAM savestates",  MB_ONOFF, MA_OPT_SRAM_STATES,   &currentConfig.EmuOpt,  0x001, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_OPT_CONFIRM_STATES,NULL, 0, 0, 0, 1 },
+	{ "Save slot",                 MB_RANGE, MA_OPT_SAVE_SLOT,     &state_slot, 0, 0, 9, 1 },
+	{ NULL,                        MB_NONE,  MA_OPT_CPU_CLOCKS,    NULL, 0, 0, 0, 1 },
+	{ "[Sega/Mega CD options]",    MB_NONE,  MA_OPT_SCD_OPTS,      NULL, 0, 0, 0, 1 },
+	{ "[advanced options]",        MB_NONE,  MA_OPT_ADV_OPTS,      NULL, 0, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_OPT_SAVECFG,       NULL, 0, 0, 0, 1 },
+	{ "Save cfg for current game only",MB_NONE,MA_OPT_SAVECFG_GAME,NULL, 0, 0, 0, 1 },
+	{ NULL,                        MB_NONE,  MA_OPT_LOADCFG,       NULL, 0, 0, 0, 1 },
+};
 
-static void draw_menu_options(int menu_sel)
+#define OPT_ENTRY_COUNT (sizeof(opt_entries) / sizeof(opt_entries[0]))
+
+
+static const char *region_name(unsigned int code)
 {
-	int tl_x = 25, tl_y = 40, y;
-	char monostereo[8], strframeskip[8], *strrend;
-
-	strcpy(monostereo, (tmp_opts.PicoOpt&0x08)?"stereo":"mono");
-	if (tmp_opts.Frameskip < 0)
-		 strcpy(strframeskip, "Auto");
-	else sprintf(strframeskip, "%i", tmp_opts.Frameskip);
-	if (tmp_opts.PicoOpt&0x10) {
-		strrend = " 8bit fast";
-	} else if (tmp_opts.EmuOpt&0x80) {
-		strrend = "16bit accurate";
+	static const char *names[] = { "Auto", "      Japan NTSC", "      Japan PAL", "      USA", "      Europe" };
+	static const char *names_short[] = { "", " JP", " JP", " US", " EU" };
+	int u, i = 0;
+	if (code) {
+		code <<= 1;
+		while((code >>= 1)) i++;
+		if (i > 4) return "unknown";
+		return names[i];
 	} else {
-		strrend = " 8bit accurate";
+		static char name[24];
+		strcpy(name, "Auto:");
+		for (u = 0; u < 3; u++) {
+			i = 0; code = ((PicoAutoRgnOrder >> u*4) & 0xf) << 1;
+			while((code >>= 1)) i++;
+			strcat(name, names_short[i]);
+		}
+		return name;
 	}
+}
 
-	y = tl_y;
-	memset(gp2x_screen, 0, 320*240);
-	gp2x_text_out8(tl_x, y,       "Renderer:            %s", strrend); // 0
-	gp2x_text_out8(tl_x, (y+=10), "Accurate timing (slower)   %s", (tmp_opts.PicoOpt&0x040)?"ON":"OFF"); // 1
-	gp2x_text_out8(tl_x, (y+=10), "Accurate sprites (slower)  %s", (tmp_opts.PicoOpt&0x080)?"ON":"OFF"); // 2
-	gp2x_text_out8(tl_x, (y+=10), "Show FPS                   %s", (tmp_opts.EmuOpt &0x002)?"ON":"OFF"); // 3
-	gp2x_text_out8(tl_x, (y+=10), "Frameskip                  %s", strframeskip);
-	gp2x_text_out8(tl_x, (y+=10), "Enable sound               %s", (tmp_opts.EmuOpt &0x004)?"ON":"OFF"); // 5
-	gp2x_text_out8(tl_x, (y+=10), "Sound Quality:     %5iHz %s", tmp_opts.PsndRate, monostereo);
-	gp2x_text_out8(tl_x, (y+=10), "Use ARM940 core for sound  %s", (tmp_opts.PicoOpt&0x200)?"ON":"OFF"); // 7
-	gp2x_text_out8(tl_x, (y+=10), "6 button pad               %s", (tmp_opts.PicoOpt&0x020)?"ON":"OFF"); // 8
-	gp2x_text_out8(tl_x, (y+=10), "Genesis Region:            %s", region_name(tmp_opts.PicoRegion));
-	gp2x_text_out8(tl_x, (y+=10), "Use SRAM savestates        %s", (tmp_opts.EmuOpt &0x001)?"ON":"OFF"); // 10
-	gp2x_text_out8(tl_x, (y+=10), "Confirm save overwrites    %s", (tmp_opts.EmuOpt &0x200)?"ON":"OFF"); // 11
-	gp2x_text_out8(tl_x, (y+=10), "Save slot                  %i", state_slot); // 12
-	gp2x_text_out8(tl_x, (y+=10), "GP2X CPU clocks            %iMhz", tmp_opts.CPUclock);
-	gp2x_text_out8(tl_x, (y+=10), "[advanced options]");
-	gp2x_text_out8(tl_x, (y+=10), "Save cfg as default");
-	if (rom_data)
-		gp2x_text_out8(tl_x, (y+=10), "Save cfg for current game only");
 
-	// draw cursor
-	gp2x_text_out8(tl_x - 16, tl_y + menu_sel*10, ">");
+static void menu_opt_cust_draw(const menu_entry *entry, int x, int y, void *param)
+{
+	char *str, str24[24];
+
+	switch (entry->id)
+	{
+		case MA_OPT_RENDERER:
+			if (currentConfig.PicoOpt&0x10)
+				str = " 8bit fast";
+			else if (currentConfig.EmuOpt&0x80)
+				str = "16bit accurate";
+			else
+				str = " 8bit accurate";
+			text_out16(x, y, "Renderer:            %s", str);
+			break;
+		case MA_OPT_SCALING:
+			switch (currentConfig.scaling) {
+				default: str = "            OFF";   break;
+				case 1:  str = "hw horizontal";     break;
+				case 2:  str = "hw horiz. + vert."; break;
+				case 3:  str = "sw horizontal";     break;
+			}
+			text_out16(x, y, "Scaling:       %s", str);
+			break;
+		case MA_OPT_FRAMESKIP:
+			if (currentConfig.Frameskip < 0)
+			     strcpy(str24, "Auto");
+			else sprintf(str24, "%i", currentConfig.Frameskip);
+			text_out16(x, y, "Frameskip                  %s", str24);
+			break;
+		case MA_OPT_SOUND_QUALITY:
+			str = (currentConfig.PicoOpt&0x08)?"stereo":"mono";
+			text_out16(x, y, "Sound Quality:     %5iHz %s", currentConfig.PsndRate, str);
+			break;
+		case MA_OPT_REGION:
+			text_out16(x, y, "Region:              %s", region_name(currentConfig.PicoRegion));
+			break;
+		case MA_OPT_CONFIRM_STATES:
+			switch ((currentConfig.EmuOpt >> 9) & 5) {
+				default: str = "OFF";    break;
+				case 1:  str = "writes"; break;
+				case 4:  str = "loads";  break;
+				case 5:  str = "both";   break;
+			}
+			text_out16(x, y, "Confirm savestate          %s", str);
+			break;
+		case MA_OPT_CPU_CLOCKS:
+			text_out16(x, y, "GP2X CPU clocks            %iMhz", currentConfig.CPUclock);
+			break;
+		case MA_OPT_SAVECFG:
+			str24[0] = 0;
+			if (config_slot != 0) sprintf(str24, " (profile: %i)", config_slot);
+			text_out16(x, y, "Save cfg as default%s", str24);
+			break;
+		case MA_OPT_LOADCFG:
+			text_out16(x, y, "Load cfg from profile %i", config_slot);
+			break;
+		default:
+			printf("%s: unimplemented (%i)\n", __FUNCTION__, entry->id);
+			break;
+	}
+}
+
+
+
+static void draw_menu_options(int menu_sel)
+{
+	int tl_x = 25, tl_y = 24;
+
+	gp2x_pd_clone_buffer2();
+
+	menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 284);
+
+	me_draw(opt_entries, OPT_ENTRY_COUNT, tl_x, tl_y, menu_opt_cust_draw, NULL);
 
-	gp2x_video_flip();
+	menu_flip();
 }
 
 static int sndrate_prevnext(int rate, int dir)
@@ -711,112 +1200,167 @@ static int sndrate_prevnext(int rate, int dir)
 	return rates[i];
 }
 
+static void region_prevnext(int right)
+{
+	// jp_ntsc=1, jp_pal=2, usa=4, eu=8
+	static int rgn_orders[] = { 0x148, 0x184, 0x814, 0x418, 0x841, 0x481 };
+	int i;
+	if (right) {
+		if (!currentConfig.PicoRegion) {
+			for (i = 0; i < 6; i++)
+				if (rgn_orders[i] == PicoAutoRgnOrder) break;
+			if (i < 5) PicoAutoRgnOrder = rgn_orders[i+1];
+			else currentConfig.PicoRegion=1;
+		}
+		else currentConfig.PicoRegion<<=1;
+		if (currentConfig.PicoRegion > 8) currentConfig.PicoRegion = 8;
+	} else {
+		if (!currentConfig.PicoRegion) {
+			for (i = 0; i < 6; i++)
+				if (rgn_orders[i] == PicoAutoRgnOrder) break;
+			if (i > 0) PicoAutoRgnOrder = rgn_orders[i-1];
+		}
+		else currentConfig.PicoRegion>>=1;
+	}
+}
+
 static void menu_options_save(void)
 {
-	memcpy(&currentConfig.EmuOpt, &tmp_opts.EmuOpt, sizeof(tmp_opts));
-	currentConfig.gamma = tmp_gamma;
 	PicoOpt = currentConfig.PicoOpt;
 	PsndRate = currentConfig.PsndRate;
 	PicoRegionOverride = currentConfig.PicoRegion;
-	if (PicoOpt & 0x20) {
-		actionNames[ 8] = "Z"; actionNames[ 9] = "Y";
-		actionNames[10] = "X"; actionNames[11] = "MODE";
-	} else {
-		actionNames[8] = actionNames[9] = actionNames[10] = actionNames[11] = 0;
+	if (!(PicoOpt & 0x20)) {
+		// unbind XYZ MODE, just in case
+		unbind_action(0xf00);
 	}
+	scaling_update();
 }
 
-static void menu_loop_options(void)
+static int menu_loop_options(void)
 {
-	int menu_sel = 0, menu_sel_max = 15;
+	static int menu_sel = 0;
+	int menu_sel_max, ret;
 	unsigned long inp = 0;
+	menu_id selected_id;
 
-	if (rom_data) menu_sel_max++;
-	memcpy(&tmp_opts.EmuOpt, &currentConfig.EmuOpt, sizeof(tmp_opts));
-	tmp_gamma = currentConfig.gamma;
-	tmp_opts.PicoOpt = PicoOpt;
-	tmp_opts.PsndRate = PsndRate;
-	tmp_opts.PicoRegion = PicoRegionOverride;
+	currentConfig.PicoOpt = PicoOpt;
+	currentConfig.PsndRate = PsndRate;
+	currentConfig.PicoRegion = PicoRegionOverride;
 
-	for(;;)
+	me_enable(opt_entries, OPT_ENTRY_COUNT, MA_OPT_SAVECFG_GAME, rom_data != NULL);
+	me_enable(opt_entries, OPT_ENTRY_COUNT, MA_OPT_LOADCFG, config_slot != config_slot_current);
+	menu_sel_max = me_count_enabled(opt_entries, OPT_ENTRY_COUNT) - 1;
+	if (menu_sel > menu_sel_max) menu_sel = menu_sel_max;
+
+	while (1)
 	{
 		draw_menu_options(menu_sel);
 		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_LEFT|GP2X_RIGHT|GP2X_B|GP2X_X|GP2X_A);
-		if(inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
-		if(inp & GP2X_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
-		if((inp& GP2X_B)||(inp&GP2X_LEFT)||(inp&GP2X_RIGHT)) { // toggleable options
-			switch (menu_sel) {
-				case  1: tmp_opts.PicoOpt^=0x040; break;
-				case  2: tmp_opts.PicoOpt^=0x080; break;
-				case  3: tmp_opts.EmuOpt ^=0x002; break;
-				case  5: tmp_opts.EmuOpt ^=0x004; break;
-				case  7: tmp_opts.PicoOpt^=0x200; break;
-				case  8: tmp_opts.PicoOpt^=0x020; break;
-				case 10: tmp_opts.EmuOpt ^=0x001; break;
-				case 11: tmp_opts.EmuOpt ^=0x200; break;
-				case 14: amenu_loop_options();    break;
-				case 15: // done (save)
-					menu_options_save();
-					emu_WriteConfig(0);
-					return;
-				case 16: // done (save for current game)
-					menu_options_save();
-					emu_WriteConfig(1);
-					return;
+		if (inp & GP2X_UP  ) { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+		if (inp & GP2X_DOWN) { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+		selected_id = me_index2id(opt_entries, OPT_ENTRY_COUNT, menu_sel);
+		if (inp & (GP2X_LEFT|GP2X_RIGHT)) { // multi choise
+			if (!me_process(opt_entries, OPT_ENTRY_COUNT, selected_id, (inp&GP2X_RIGHT) ? 1 : 0)) {
+				switch (selected_id) {
+					case MA_OPT_RENDERER:
+						if (inp & GP2X_LEFT) {
+							if      (  currentConfig.PicoOpt&0x10) currentConfig.PicoOpt&= ~0x10;
+							else if (!(currentConfig.EmuOpt &0x80))currentConfig.EmuOpt |=  0x80;
+							else if (  currentConfig.EmuOpt &0x80) break;
+						} else {
+							if      (  currentConfig.PicoOpt&0x10) break;
+							else if (!(currentConfig.EmuOpt &0x80))currentConfig.PicoOpt|=  0x10;
+							else if (  currentConfig.EmuOpt &0x80) currentConfig.EmuOpt &= ~0x80;
+						}
+						break;
+					case MA_OPT_SOUND_QUALITY:
+						if ((inp & GP2X_RIGHT) && currentConfig.PsndRate == 44100 && !(currentConfig.PicoOpt&0x08)) {
+							currentConfig.PsndRate = 8000;  currentConfig.PicoOpt|= 0x08;
+						} else if ((inp & GP2X_LEFT) && currentConfig.PsndRate == 8000 && (currentConfig.PicoOpt&0x08)) {
+							currentConfig.PsndRate = 44100; currentConfig.PicoOpt&=~0x08;
+						} else currentConfig.PsndRate = sndrate_prevnext(currentConfig.PsndRate, inp & GP2X_RIGHT);
+						break;
+					case MA_OPT_REGION:
+						region_prevnext(inp & GP2X_RIGHT);
+						break;
+					case MA_OPT_CONFIRM_STATES: {
+							 int n = ((currentConfig.EmuOpt>>9)&1) | ((currentConfig.EmuOpt>>10)&2);
+							 n += (inp & GP2X_LEFT) ? -1 : 1;
+							 if (n < 0) n = 0; else if (n > 3) n = 3;
+							 n |= n << 1; n &= ~2;
+							 currentConfig.EmuOpt &= ~0xa00;
+							 currentConfig.EmuOpt |= n << 9;
+							 break;
+						 }
+					case MA_OPT_SAVE_SLOT:
+						 if (inp & GP2X_RIGHT) {
+							 state_slot++; if (state_slot > 9) state_slot = 0;
+						 } else {state_slot--; if (state_slot < 0) state_slot = 9;
+						 }
+						 break;
+					case MA_OPT_CPU_CLOCKS:
+						 while ((inp = gp2x_joystick_read(1)) & (GP2X_LEFT|GP2X_RIGHT)) {
+							 currentConfig.CPUclock += (inp & GP2X_LEFT) ? -1 : 1;
+							 if (currentConfig.CPUclock < 1) currentConfig.CPUclock = 1;
+							 draw_menu_options(menu_sel);
+							 usleep(50*1000);
+						 }
+						 break;
+					case MA_OPT_SAVECFG:
+					case MA_OPT_SAVECFG_GAME:
+					case MA_OPT_LOADCFG:
+						 config_slot += (inp&GP2X_RIGHT) ? 1 : -1;
+						 if (config_slot > 9) config_slot = 0;
+						 if (config_slot < 0) config_slot = 9;
+						 me_enable(opt_entries, OPT_ENTRY_COUNT, MA_OPT_LOADCFG, config_slot != config_slot_current);
+						 menu_sel_max = me_count_enabled(opt_entries, OPT_ENTRY_COUNT) - 1;
+						 if (menu_sel > menu_sel_max) menu_sel = menu_sel_max;
+						 break;
+					default:
+						//printf("%s: something unknown selected (%i)\n", __FUNCTION__, selected_id);
+						break;
+				}
 			}
 		}
-		if(inp & GP2X_X) return;  // done (no save)
-		if(inp & GP2X_A) {
-			menu_options_save();
-			return;  // done (save)
-		}
-		if(inp & (GP2X_LEFT|GP2X_RIGHT)) { // multi choise
-			switch (menu_sel) {
-				case  0:
-					if (inp & GP2X_LEFT) {
-						if      (  tmp_opts.PicoOpt&0x10) tmp_opts.PicoOpt&= ~0x10;
-						else if (!(tmp_opts.EmuOpt &0x80))tmp_opts.EmuOpt |=  0x80;
-						else if (  tmp_opts.EmuOpt &0x80) break;
-					} else {
-						if      (  tmp_opts.PicoOpt&0x10) break;
-						else if (!(tmp_opts.EmuOpt &0x80))tmp_opts.PicoOpt|=  0x10;
-						else if (  tmp_opts.EmuOpt &0x80) tmp_opts.EmuOpt &= ~0x80;
-					}
-					break;
-				case  4:
-					tmp_opts.Frameskip += (inp & GP2X_LEFT) ? -1 : 1;
-					if (tmp_opts.Frameskip < 0)  tmp_opts.Frameskip = -1;
-					if (tmp_opts.Frameskip > 32) tmp_opts.Frameskip = 32;
-					break;
-				case  6:
-					if ((inp & GP2X_RIGHT) && tmp_opts.PsndRate == 44100 && !(tmp_opts.PicoOpt&0x08)) {
-						tmp_opts.PsndRate = 8000;  tmp_opts.PicoOpt|= 0x08;
-					} else if ((inp & GP2X_LEFT) && tmp_opts.PsndRate == 8000 && (tmp_opts.PicoOpt&0x08)) {
-						tmp_opts.PsndRate = 44100; tmp_opts.PicoOpt&=~0x08;
-					} else tmp_opts.PsndRate = sndrate_prevnext(tmp_opts.PsndRate, inp & GP2X_RIGHT);
-					break;
-				case  9:
-					if (inp & GP2X_RIGHT) {
-						if (tmp_opts.PicoRegion) tmp_opts.PicoRegion<<=1; else tmp_opts.PicoRegion=1;
-						if (tmp_opts.PicoRegion > 8) tmp_opts.PicoRegion = 8;
-					} else  tmp_opts.PicoRegion>>=1;
-					break;
-				case 12:
-					if (inp & GP2X_RIGHT) {
-						state_slot++; if (state_slot > 9) state_slot = 0;
-					} else {state_slot--; if (state_slot < 0) state_slot = 9;
-					}
-					break;
-				case 13:
-					while ((inp = gp2x_joystick_read(1)) & (GP2X_LEFT|GP2X_RIGHT)) {
-						tmp_opts.CPUclock += (inp & GP2X_LEFT) ? -1 : 1;
-						if (tmp_opts.CPUclock < 1) tmp_opts.CPUclock = 1;
-						draw_menu_options(menu_sel);
-						usleep(50*1000);
-					}
-					break;
+		if (inp & GP2X_B) {
+			if (!me_process(opt_entries, OPT_ENTRY_COUNT, selected_id, 1))
+			{
+				switch (selected_id)
+				{
+					case MA_OPT_SCD_OPTS:
+						cd_menu_loop_options();
+						if (engineState == PGS_ReloadRom)
+							return 0; // test BIOS
+						break;
+					case MA_OPT_ADV_OPTS:
+						amenu_loop_options();
+						break;
+					case MA_OPT_SAVECFG: // done (update and write)
+						menu_options_save();
+						if (emu_WriteConfig(0)) strcpy(menuErrorMsg, "config saved");
+						else strcpy(menuErrorMsg, "failed to write config");
+						return 1;
+					case MA_OPT_SAVECFG_GAME: // done (update and write for current game)
+						menu_options_save();
+						if (emu_WriteConfig(1)) strcpy(menuErrorMsg, "config saved");
+						else strcpy(menuErrorMsg, "failed to write config");
+						return 1;
+					case MA_OPT_LOADCFG:
+						ret = emu_ReadConfig(1, 1);
+						if (!ret) ret = emu_ReadConfig(0, 1);
+						if (ret)  strcpy(menuErrorMsg, "config loaded");
+						else      strcpy(menuErrorMsg, "failed to load config");
+						return 1;
+					default:
+						//printf("%s: something unknown selected (%i)\n", __FUNCTION__, selected_id);
+						break;
+				}
 			}
 		}
+		if(inp & (GP2X_X|GP2X_A)) {
+			menu_options_save();
+			return 0;  // done (update, no write)
+		}
 	}
 }
 
@@ -824,87 +1368,96 @@ static void menu_loop_options(void)
 
 static void draw_menu_credits(void)
 {
-	int tl_x = 15, tl_y = 70, y;
-	memset(gp2x_screen, 0, 320*240);
+	int tl_x = 15, tl_y = 64, y;
+	gp2x_pd_clone_buffer2();
 
-	gp2x_text_out8(tl_x, 20, "PicoDrive v" VERSION " (c) notaz, 2006");
+	text_out16(tl_x, 20, "PicoDrive v" VERSION " (c) notaz, 2006,2007");
 	y = tl_y;
-	gp2x_text_out8(tl_x, y, "Credits:");
-	gp2x_text_out8(tl_x, (y+=10), "Dave: Cyclone 68000 core,");
-	gp2x_text_out8(tl_x, (y+=10), "      base code of PicoDrive");
-	gp2x_text_out8(tl_x, (y+=10), "Reesy & FluBBa: DrZ80 core");
-	gp2x_text_out8(tl_x, (y+=10), "MAME devs: YM2612 and SN76496 cores");
-	gp2x_text_out8(tl_x, (y+=10), "Charles MacDonald: Genesis hw docs");
-	gp2x_text_out8(tl_x, (y+=10), "Stephane Dallongeville:");
-	gp2x_text_out8(tl_x, (y+=10), "      opensource Gens");
-	gp2x_text_out8(tl_x, (y+=10), "Haze: Genesis hw info");
-	gp2x_text_out8(tl_x, (y+=10), "rlyeh and others: minimal SDK");
-	gp2x_text_out8(tl_x, (y+=10), "Squidge: squidgehack");
-	gp2x_text_out8(tl_x, (y+=10), "Dzz: ARM940 sample");
-	gp2x_text_out8(tl_x, (y+=10), "GnoStiC / Puck2099: USB joystick");
-	gp2x_text_out8(tl_x, (y+=10), "craigix: GP2X hardware");
-
-	gp2x_video_flip();
+	text_out16(tl_x, y, "Credits:");
+	text_out16(tl_x, (y+=10), "Dave: Cyclone 68000 core,");
+	text_out16(tl_x, (y+=10), "      base code of PicoDrive");
+	text_out16(tl_x, (y+=10), "Reesy & FluBBa: DrZ80 core");
+	text_out16(tl_x, (y+=10), "MAME devs: YM2612 and SN76496 cores");
+	text_out16(tl_x, (y+=10), "Charles MacDonald: Genesis hw docs");
+	text_out16(tl_x, (y+=10), "Stephane Dallongeville:");
+	text_out16(tl_x, (y+=10), "      opensource Gens");
+	text_out16(tl_x, (y+=10), "Haze: Genesis hw info");
+	text_out16(tl_x, (y+=10), "rlyeh and others: minimal SDK");
+	text_out16(tl_x, (y+=10), "Squidge: squidgehack");
+	text_out16(tl_x, (y+=10), "Dzz: ARM940 sample");
+	text_out16(tl_x, (y+=10), "GnoStiC / Puck2099: USB joystick");
+	text_out16(tl_x, (y+=10), "craigix: GP2X hardware");
+	text_out16(tl_x, (y+=10), "ketchupgun: skin design");
+
+	menu_flip();
 }
 
 
 // -------------- root menu --------------
 
+menu_entry main_entries[] =
+{
+	{ "Resume game",        MB_NONE, MA_MAIN_RESUME_GAME, NULL, 0, 0, 0, 0 },
+	{ "Save State",         MB_NONE, MA_MAIN_SAVE_STATE,  NULL, 0, 0, 0, 0 },
+	{ "Load State",         MB_NONE, MA_MAIN_LOAD_STATE,  NULL, 0, 0, 0, 0 },
+	{ "Reset game",         MB_NONE, MA_MAIN_RESET_GAME,  NULL, 0, 0, 0, 0 },
+	{ "Load new ROM/ISO",   MB_NONE, MA_MAIN_LOAD_ROM,    NULL, 0, 0, 0, 1 },
+	{ "Change options",     MB_NONE, MA_MAIN_OPTIONS,     NULL, 0, 0, 0, 1 },
+	{ "Configure controls", MB_NONE, MA_MAIN_CONTROLS,    NULL, 0, 0, 0, 1 },
+	{ "Credits",            MB_NONE, MA_MAIN_CREDITS,     NULL, 0, 0, 0, 1 },
+	{ "Patches / GameGenie",MB_NONE, MA_MAIN_PATCHES,     NULL, 0, 0, 0, 0 },
+	{ "Exit",               MB_NONE, MA_MAIN_EXIT,        NULL, 0, 0, 0, 1 }
+};
+
+#define MAIN_ENTRY_COUNT (sizeof(main_entries) / sizeof(main_entries[0]))
+
 static void draw_menu_root(int menu_sel)
 {
-	int tl_x = 70, tl_y = 70, y;
-	memset(gp2x_screen, 0, 320*240);
+	const int tl_x = 70, tl_y = 70;
 
-	gp2x_text_out8(tl_x, 20, "PicoDrive v" VERSION);
+	gp2x_pd_clone_buffer2();
 
-	y = tl_y;
-	if (rom_data) {
-		gp2x_text_out8(tl_x, y,       "Resume game");
-		gp2x_text_out8(tl_x, (y+=10), "Save State");
-		gp2x_text_out8(tl_x, (y+=10), "Load State");
-		gp2x_text_out8(tl_x, (y+=10), "Reset game");
-	} else {
-		y += 30;
-	}
-	gp2x_text_out8(tl_x, (y+=10), "Load new ROM");
-	gp2x_text_out8(tl_x, (y+=10), "Change options");
-	gp2x_text_out8(tl_x, (y+=10), "Configure controls");
-	gp2x_text_out8(tl_x, (y+=10), "Credits");
-	gp2x_text_out8(tl_x, (y+=10), "Exit");
+	text_out16(tl_x, 20, "PicoDrive v" VERSION);
+
+	menu_draw_selection(tl_x - 16, tl_y + menu_sel*10, 146);
+
+	me_draw(main_entries, MAIN_ENTRY_COUNT, tl_x, tl_y, NULL, NULL);
 
-	// draw cursor
-	gp2x_text_out8(tl_x - 16, tl_y + menu_sel*10, ">");
 	// error
-	if (menuErrorMsg[0]) gp2x_text_out8(5, 226, menuErrorMsg);
-	gp2x_video_flip();
+	if (menuErrorMsg[0]) {
+		memset((char *)gp2x_screen + 320*224*2, 0, 320*16*2);
+		text_out16(5, 226, menuErrorMsg);
+	}
+	menu_flip();
 }
 
 
 static void menu_loop_root(void)
 {
-	int menu_sel = 4, menu_sel_max = 8, menu_sel_min = 4;
+	static int menu_sel = 0;
+	int ret, menu_sel_max;
 	unsigned long inp = 0;
-	char curr_path[PATH_MAX], *selfname;
-	FILE *tstf;
 
-	if ( (tstf = fopen(currentConfig.lastRomFile, "rb")) )
-	{
-		fclose(tstf);
-		strcpy(curr_path, currentConfig.lastRomFile);
-	}
-	else
-	{
-		getcwd(curr_path, PATH_MAX);
-	}
+	me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_RESUME_GAME, rom_data != NULL);
+	me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_SAVE_STATE,  rom_data != NULL);
+	me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_LOAD_STATE,  rom_data != NULL);
+	me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_RESET_GAME,  rom_data != NULL);
+	me_enable(main_entries, MAIN_ENTRY_COUNT, MA_MAIN_PATCHES,     PicoPatches != NULL);
 
-	if (rom_data) menu_sel = menu_sel_min = 0;
+	menu_sel_max = me_count_enabled(main_entries, MAIN_ENTRY_COUNT) - 1;
+	if (menu_sel > menu_sel_max) menu_sel = menu_sel_max;
 
-	for(;;)
+	/* make sure action buttons are not pressed on entering menu */
+	draw_menu_root(menu_sel);
+	while (gp2x_joystick_read(1) & (GP2X_B|GP2X_X|GP2X_SELECT)) usleep(50*1000);
+
+	for (;;)
 	{
 		draw_menu_root(menu_sel);
-		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_B|GP2X_X|GP2X_SELECT);
-		if(inp & GP2X_UP  )  { menu_sel--; if (menu_sel < menu_sel_min) menu_sel = menu_sel_max; }
-		if(inp & GP2X_DOWN)  { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = menu_sel_min; }
+		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_B|GP2X_X|GP2X_SELECT|GP2X_L|GP2X_R);
+		if(inp & GP2X_UP  )  { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+		if(inp & GP2X_DOWN)  { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+		if((inp & (GP2X_L|GP2X_R)) == (GP2X_L|GP2X_R)) debug_menu_loop();
 		if(inp &(GP2X_SELECT|GP2X_X)){
 			if (rom_data) {
 				while (gp2x_joystick_read(1) & (GP2X_SELECT|GP2X_X)) usleep(50*1000); // wait until select is released
@@ -912,81 +1465,231 @@ static void menu_loop_root(void)
 				break;
 			}
 		}
-		if(inp & GP2X_B   )  {
-			switch (menu_sel) {
-				case 0: // resume game
-					if (rom_data) { engineState = PGS_Running; return; }
+		if(inp & GP2X_B)  {
+			switch (me_index2id(main_entries, MAIN_ENTRY_COUNT, menu_sel))
+			{
+				case MA_MAIN_RESUME_GAME:
+					if (rom_data) {
+						while (gp2x_joystick_read(1) & GP2X_B) usleep(50*1000);
+						engineState = PGS_Running;
+						return;
+					}
 					break;
-				case 1: // save state
+				case MA_MAIN_SAVE_STATE:
 					if (rom_data) {
-						if(emu_SaveLoadGame(0, 0)) {
-							strcpy(menuErrorMsg, "save failed");
+						if(savestate_menu_loop(0))
 							continue;
-						}
 						engineState = PGS_Running;
 						return;
 					}
 					break;
-				case 2: // load state
+				case MA_MAIN_LOAD_STATE:
 					if (rom_data) {
-						if(emu_SaveLoadGame(1, 0)) {
-							strcpy(menuErrorMsg, "load failed");
+						if(savestate_menu_loop(1))
 							continue;
-						}
 						engineState = PGS_Running;
 						return;
 					}
 					break;
-				case 3: // reset game
+				case MA_MAIN_RESET_GAME:
 					if (rom_data) {
 						emu_ResetGame();
 						engineState = PGS_Running;
 						return;
 					}
 					break;
-				case 4: // select rom
+				case MA_MAIN_LOAD_ROM:
+				{
+					char curr_path[PATH_MAX], *selfname;
+					FILE *tstf;
+					if ( (tstf = fopen(currentConfig.lastRomFile, "rb")) )
+					{
+						fclose(tstf);
+						strcpy(curr_path, currentConfig.lastRomFile);
+					}
+					else
+						getcwd(curr_path, PATH_MAX);
 					selfname = romsel_loop(curr_path);
 					if (selfname) {
 						printf("selected file: %s\n", selfname);
-						strncpy(currentConfig.lastRomFile, selfname, sizeof(currentConfig.lastRomFile)-1);
-						currentConfig.lastRomFile[sizeof(currentConfig.lastRomFile)-1] = 0;
 						engineState = PGS_ReloadRom;
+						return;
 					}
-					return;
-				case 5: // options
-					menu_loop_options();
 					break;
-				case 6: // controls
+				}
+				case MA_MAIN_OPTIONS:
+					ret = menu_loop_options();
+					if (ret == 1) continue; // status update
+					if (engineState == PGS_ReloadRom)
+						return; // BIOS test
+					break;
+				case MA_MAIN_CONTROLS:
 					kc_sel_loop();
 					break;
-				case 7: // credits
+				case MA_MAIN_CREDITS:
 					draw_menu_credits();
 					usleep(500*1000);
 					inp = wait_for_input(GP2X_B|GP2X_X);
 					break;
-				case 8: // exit
+				case MA_MAIN_EXIT:
 					engineState = PGS_Quit;
 					return;
+				case MA_MAIN_PATCHES:
+					if (rom_data && PicoPatches) {
+						patches_menu_loop();
+						PicoPatchApply();
+						strcpy(menuErrorMsg, "Patches applied");
+						continue;
+					}
+					break;
+				default:
+					printf("%s: something unknown selected\n", __FUNCTION__);
+					break;
 			}
 		}
 		menuErrorMsg[0] = 0; // clear error msg
 	}
 }
 
+static void menu_darken_bg(void *dst, int pixels, int darker)
+{
+	unsigned int *screen = dst;
+	pixels /= 2;
+	if (darker)
+	{
+		while (pixels--)
+		{
+			unsigned int p = *screen;
+			*screen++ = ((p&0xf79ef79e)>>1) - ((p&0xc618c618)>>3);
+		}
+	}
+	else
+	{
+		while (pixels--)
+		{
+			unsigned int p = *screen;
+			*screen++ = (p&0xf79ef79e)>>1;
+		}
+	}
+}
 
-void menu_loop(void)
+static void menu_prepare_bg(int use_game_bg)
+{
+	if (use_game_bg)
+	{
+		// darken the active framebuffer
+		memset(gp2x_screen, 0, 320*8*2);
+		menu_darken_bg((char *)gp2x_screen + 320*8*2, 320*224, 1);
+		memset((char *)gp2x_screen + 320*232*2, 0, 320*8*2);
+	}
+	else
+	{
+		// should really only happen once, on startup..
+		readpng(gp2x_screen, "skin/background.png", READPNG_BG);
+	}
+
+	// copy to buffer2
+	gp2x_memcpy_buffers((1<<2), gp2x_screen, 0, 320*240*2);
+}
+
+static void menu_gfx_prepare(void)
 {
-	int pal[2];
+	menu_prepare_bg(rom_data != NULL);
+
+	// switch to 16bpp
+	gp2x_video_changemode2(16);
+	gp2x_video_RGB_setscaling(0, 320, 240);
+	menu_flip();
+}
+
 
-	// switch to 8bpp
-	gp2x_video_changemode(8);
-	gp2x_video_RGB_setscaling(320, 240);
-	// set pal
-	pal[0] = 0;
-	pal[1] = 0x00ffffff;
-	gp2x_video_setpalette(pal, 2);
+void menu_loop(void)
+{
+	menu_gfx_prepare();
 
 	menu_loop_root();
 
 	menuErrorMsg[0] = 0;
 }
+
+
+// --------- CD tray close menu ----------
+
+static void draw_menu_tray(int menu_sel)
+{
+	int tl_x = 70, tl_y = 90, y;
+	memset(gp2x_screen, 0, 320*240*2);
+
+	text_out16(tl_x, 20, "The unit is about to");
+	text_out16(tl_x, 30, "close the CD tray.");
+
+	y = tl_y;
+	text_out16(tl_x, y,       "Load new CD image");
+	text_out16(tl_x, (y+=10), "Insert nothing");
+
+	// draw cursor
+	text_out16(tl_x - 16, tl_y + menu_sel*10, ">");
+	// error
+	if (menuErrorMsg[0]) text_out16(5, 226, menuErrorMsg);
+	menu_flip();
+}
+
+
+int menu_loop_tray(void)
+{
+	int menu_sel = 0, menu_sel_max = 1;
+	unsigned long inp = 0;
+	char curr_path[PATH_MAX], *selfname;
+	FILE *tstf;
+
+	gp2x_memset_all_buffers(0, 0, 320*240*2);
+	menu_gfx_prepare();
+
+	if ( (tstf = fopen(currentConfig.lastRomFile, "rb")) )
+	{
+		fclose(tstf);
+		strcpy(curr_path, currentConfig.lastRomFile);
+	}
+	else
+	{
+		getcwd(curr_path, PATH_MAX);
+	}
+
+	/* make sure action buttons are not pressed on entering menu */
+	draw_menu_tray(menu_sel);
+	while (gp2x_joystick_read(1) & GP2X_B) usleep(50*1000);
+
+	for (;;)
+	{
+		draw_menu_tray(menu_sel);
+		inp = wait_for_input(GP2X_UP|GP2X_DOWN|GP2X_B);
+		if(inp & GP2X_UP  )  { menu_sel--; if (menu_sel < 0) menu_sel = menu_sel_max; }
+		if(inp & GP2X_DOWN)  { menu_sel++; if (menu_sel > menu_sel_max) menu_sel = 0; }
+		if(inp & GP2X_B   )  {
+			switch (menu_sel) {
+				case 0: // select image
+					selfname = romsel_loop(curr_path);
+					if (selfname) {
+						int ret = -1, cd_type;
+						cd_type = emu_cd_check(NULL);
+						if (cd_type > 0)
+							ret = Insert_CD(romFileName, cd_type == 2);
+						if (ret != 0) {
+							sprintf(menuErrorMsg, "Load failed, invalid CD image?");
+							printf("%s\n", menuErrorMsg);
+							continue;
+						}
+						engineState = PGS_RestartRun;
+						return 1;
+					}
+					break;
+				case 1: // insert nothing
+					engineState = PGS_RestartRun;
+					return 0;
+			}
+		}
+		menuErrorMsg[0] = 0; // clear error msg
+	}
+}
+
+