mirror of
https://github.com/Oibaf66/frodo-wii.git
synced 2024-11-10 21:55:11 +01:00
1068 lines
24 KiB
C++
1068 lines
24 KiB
C++
/*********************************************************************
|
|
*
|
|
* Copyright (C) 2004,2008, Simon Kagstrom
|
|
*
|
|
* Filename: menu.c
|
|
* Author: Simon Kagstrom <simon.kagstrom@gmail.com>
|
|
* Description: Code for menus (originally for Mophun)
|
|
*
|
|
* $Id$
|
|
*
|
|
********************************************************************/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#if defined(GEKKO)
|
|
#include <wiiuse/wpad.h>
|
|
#endif
|
|
|
|
#include "sysdeps.h"
|
|
#include "Display.h"
|
|
#include "menu.h"
|
|
#include "menutexts.h"
|
|
|
|
typedef struct
|
|
{
|
|
int n_entries;
|
|
int index;
|
|
int sel;
|
|
} submenu_t;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
char title[256];
|
|
const char **pp_msgs;
|
|
TTF_Font *p_font;
|
|
int x1,y1;
|
|
int x2,y2;
|
|
int text_w;
|
|
int text_h;
|
|
|
|
int n_submenus;
|
|
submenu_t *p_submenus;
|
|
|
|
int cur_sel; /* Main selection */
|
|
int start_entry_visible;
|
|
int n_entries;
|
|
} menu_t;
|
|
|
|
#define IS_SUBMENU(p_msg) ( (p_msg)[0] == '^' )
|
|
#define IS_TEXT(p_msg) ( (p_msg)[0] == '#' || (p_msg)[0] == ' ' )
|
|
#define IS_MARKER(p_msg) ( (p_msg)[0] == '@' )
|
|
|
|
static TTF_Font *menu_font;
|
|
static TTF_Font *menu_font64;
|
|
#if defined(GEKKO)
|
|
#define FONT_PATH "/apps/frodo/FreeMono.ttf"
|
|
#define FONT64_PATH "/apps/frodo/C64.ttf"
|
|
#else
|
|
#define FONT_PATH "FreeMono.ttf"
|
|
#define FONT64_PATH "C64.ttf"
|
|
#endif
|
|
|
|
int fh, fw;
|
|
|
|
int msgInfo(char *text, int duration, SDL_Rect *irc)
|
|
{
|
|
int len = strlen(text);
|
|
int X, Y, wX, wY;
|
|
SDL_Rect src;
|
|
SDL_Rect rc;
|
|
SDL_Rect brc;
|
|
|
|
X = (FULL_DISPLAY_X /2) - (len / 2 + 1)*12;
|
|
Y = (FULL_DISPLAY_Y /2) - 24;
|
|
|
|
brc.x = FULL_DISPLAY_X/2-2*12;
|
|
brc.y=Y+42;
|
|
brc.w=48;
|
|
brc.h=20;
|
|
|
|
rc.x = X;
|
|
rc.y=Y;
|
|
rc.w=12*(len + 2);
|
|
rc.h=duration > 0 ? 48 : 80;
|
|
|
|
src.x=rc.x+4;
|
|
src.y=rc.y+4;
|
|
src.w=rc.w;
|
|
src.h=rc.h;
|
|
|
|
|
|
if (irc)
|
|
{
|
|
irc->x=rc.x;
|
|
irc->y=rc.y;
|
|
irc->w=src.w;
|
|
irc->h=src.h;
|
|
}
|
|
SDL_FillRect(real_screen, &src, SDL_MapRGB(real_screen->format, 0, 96, 0));
|
|
SDL_FillRect(real_screen, &rc, SDL_MapRGB(real_screen->format, 128, 128, 128));
|
|
menu_print_font(real_screen, 0,0,0, X+12, Y+12, text);
|
|
SDL_UpdateRect(real_screen, src.x, src.y, src.w, src.h);
|
|
SDL_UpdateRect(real_screen, rc.x, rc.y, rc.w,rc.h);
|
|
if (duration > 0)
|
|
SDL_Delay(duration);
|
|
else if (duration < 0)
|
|
{
|
|
SDL_FillRect(real_screen, &brc, SDL_MapRGB(real_screen->format, 0x00, 0x80, 0x00));
|
|
menu_print_font(real_screen, 0,0,0, FULL_DISPLAY_X/2-12, Y+42, "OK");
|
|
SDL_UpdateRect(real_screen, brc.x, brc.y, brc.w, brc.h);
|
|
menu_wait_key_press();
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
bool msgKill(SDL_Rect *rc)
|
|
{
|
|
SDL_UpdateRect(real_screen, rc->x, rc->y, rc->w,rc->h);
|
|
}
|
|
|
|
bool msgYesNo(char *text, bool default_opt, int x, int y)
|
|
{
|
|
int len = strlen(text);
|
|
int X, Y, wX, wY;
|
|
SDL_Rect src;
|
|
SDL_Rect rc;
|
|
SDL_Rect brc;
|
|
uint32_t key;
|
|
bool old;
|
|
|
|
old = default_opt;
|
|
|
|
if (x < 0)
|
|
X = (FULL_DISPLAY_X /2) - (len / 2 + 1)*12;
|
|
else
|
|
X = x;
|
|
|
|
if (y < 0)
|
|
Y = (FULL_DISPLAY_Y /2) - 48;
|
|
else
|
|
Y = y;
|
|
|
|
rc.x=X;
|
|
rc.y=Y;
|
|
rc.w=12*(len + 2);
|
|
rc.h=80;
|
|
|
|
src.x=rc.x+4;
|
|
src.y=rc.y+4;
|
|
src.w=rc.w;
|
|
src.h=rc.h;
|
|
|
|
while (1)
|
|
{
|
|
SDL_FillRect(real_screen, &src, SDL_MapRGB(real_screen->format, 0, 96, 0));
|
|
SDL_FillRect(real_screen, &rc, SDL_MapRGB(real_screen->format, 128, 128, 128));
|
|
menu_print_font(real_screen, 0,0,0, X+12, Y+12, text);
|
|
|
|
if (default_opt)
|
|
{
|
|
brc.x=rc.x + rc.w/2-5*12;
|
|
brc.y=rc.y+42;
|
|
brc.w=12*3;
|
|
brc.h=20;
|
|
SDL_FillRect(real_screen, &brc, SDL_MapRGB(real_screen->format, 0x00, 0x80, 0x00));
|
|
}
|
|
else
|
|
{
|
|
brc.x=rc.x + rc.w/2+5*12-2*12-6;
|
|
brc.y=rc.y+42;
|
|
brc.w=12*3;
|
|
brc.h=20;
|
|
SDL_FillRect(real_screen, &brc, SDL_MapRGB(real_screen->format, 0x80, 0x00, 0x00));
|
|
}
|
|
menu_print_font(real_screen, 0,0,0, rc.x + rc.w/2-5*12, Y+42, "YES");
|
|
menu_print_font(real_screen, 0,0,0, rc.x + rc.w/2-5*12+8*12, Y+42, "NO");
|
|
|
|
SDL_UpdateRect(real_screen, src.x, src.y, src.w, src.h);
|
|
SDL_UpdateRect(real_screen, rc.x, rc.y, rc.w,rc.h);
|
|
SDL_UpdateRect(real_screen, brc.x, brc.y, brc.w,brc.h);
|
|
|
|
key = menu_wait_key_press();
|
|
if (key & KEY_SELECT)
|
|
{
|
|
return default_opt;
|
|
}
|
|
else if (key & KEY_ESCAPE)
|
|
{
|
|
return false;
|
|
}
|
|
else if (key & KEY_LEFT)
|
|
{
|
|
default_opt = !default_opt;
|
|
}
|
|
else if (key & KEY_RIGHT)
|
|
{
|
|
default_opt = !default_opt;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static int cmpstringp(const void *p1, const void *p2)
|
|
{
|
|
const char *p1_s = *(const char**)p1;
|
|
const char *p2_s = *(const char**)p2;
|
|
|
|
/* Put directories first */
|
|
if (*p1_s == '[' && *p2_s != '[')
|
|
return -1;
|
|
if (*p1_s != '[' && *p2_s == '[')
|
|
return 1;
|
|
return strcmp(* (char * const *) p1, * (char * const *) p2);
|
|
}
|
|
|
|
/* Return true if name ends with ext (for filenames) */
|
|
static bool ext_matches(const char *name, const char *ext)
|
|
{
|
|
int len = strlen(name);
|
|
int ext_len = strlen(ext);
|
|
|
|
if (len <= ext_len)
|
|
return false;
|
|
return (strcmp(name + len - ext_len, ext) == 0);
|
|
|
|
}
|
|
|
|
static bool ext_matches_list(const char *name, const char **exts)
|
|
{
|
|
for (const char **p = exts; *p; p++)
|
|
{
|
|
if (ext_matches(name, *p))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static const char **get_file_list(const char *base_dir)
|
|
{
|
|
DIR *d = opendir(base_dir);
|
|
const char **file_list;
|
|
int cur = 0;
|
|
struct dirent *de;
|
|
int cnt = 16;
|
|
|
|
if (!d)
|
|
return NULL;
|
|
|
|
file_list = (const char**)malloc(cnt * sizeof(char*));
|
|
file_list[cur++] = strdup("None");
|
|
file_list[cur] = NULL;
|
|
|
|
for (de = readdir(d);
|
|
de;
|
|
de = readdir(d))
|
|
{
|
|
const char *exts[] = {".d64", ".D64", ".prg", ".PRG",
|
|
".p00", ".P00", ".s00", ".S00",
|
|
".t64", ".T64", ".sav", ".SAV", NULL};
|
|
if (de->d_type == DT_REG && ext_matches_list(de->d_name, exts))
|
|
{
|
|
char *p;
|
|
|
|
p = strdup(de->d_name);
|
|
file_list[cur++] = p;
|
|
file_list[cur] = NULL;
|
|
}
|
|
else if (de->d_type == DT_DIR)
|
|
{
|
|
char *p;
|
|
size_t len = strlen(de->d_name) + 4;
|
|
|
|
p = (char*)malloc( len );
|
|
snprintf(p, len, "[%s]", de->d_name);
|
|
file_list[cur++] = p;
|
|
file_list[cur] = NULL;
|
|
}
|
|
|
|
if (cur > cnt - 2)
|
|
{
|
|
cnt = cnt + 32;
|
|
file_list = (const char**)realloc(file_list, cnt * sizeof(char*));
|
|
if (!file_list)
|
|
return NULL;
|
|
}
|
|
}
|
|
closedir(d);
|
|
qsort(&file_list[1], cur-1, sizeof(const char *), cmpstringp);
|
|
|
|
return file_list;
|
|
}
|
|
|
|
|
|
static submenu_t *find_submenu(menu_t *p_menu, int index)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i<p_menu->n_submenus; i++)
|
|
{
|
|
if (p_menu->p_submenus[i].index == index)
|
|
return &p_menu->p_submenus[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void menu_print_font(SDL_Surface *screen, int r, int g, int b,
|
|
int x, int y, const char *msg)
|
|
{
|
|
#define _MAX_STRING 64
|
|
SDL_Surface *font_surf;
|
|
SDL_Rect dst = {x, y, 0, 0};
|
|
SDL_Color color = {r, g, b};
|
|
char buf[255];
|
|
unsigned int i;
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
strncpy(buf, msg, 254);
|
|
if (buf[0] != '|' && buf[0] != '^' && buf[0] != '.'
|
|
&& buf[0] != '-' && buf[0] != ' ' && !strstr(buf, " \""))
|
|
{
|
|
if (strlen(buf)>_MAX_STRING)
|
|
{
|
|
buf[_MAX_STRING-3] = '.';
|
|
buf[_MAX_STRING-2] = '.';
|
|
buf[_MAX_STRING-1] = '.';
|
|
buf[_MAX_STRING] = '\0';
|
|
}
|
|
}
|
|
/* Fixup multi-menu option look */
|
|
for (i = 0; i < strlen(buf) ; i++)
|
|
{
|
|
if (buf[i] == '^' || buf[i] == '|')
|
|
buf[i] = ' ';
|
|
}
|
|
|
|
font_surf = TTF_RenderText_Blended(menu_font, buf,
|
|
color);
|
|
if (!font_surf)
|
|
{
|
|
fprintf(stderr, "%s\n", TTF_GetError());
|
|
exit(1);
|
|
}
|
|
|
|
SDL_BlitSurface(font_surf, NULL, screen, &dst);
|
|
SDL_FreeSurface(font_surf);
|
|
}
|
|
|
|
void menu_print_font64(SDL_Surface *screen, int r, int g, int b, int x, int y, const char *msg)
|
|
{
|
|
#undef _MAX_STRING
|
|
#define _MAX_STRING 64
|
|
SDL_Surface *font_surf;
|
|
SDL_Rect dst = {x, y, 0, 0};
|
|
SDL_Color color = {r, g, b};
|
|
char buf[255];
|
|
unsigned int i;
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
strncpy(buf, msg, 254);
|
|
if (buf[0] != '|' && buf[0] != '^' && buf[0] != '.'
|
|
&& buf[0] != '#' && buf[0] != ' ' )
|
|
{
|
|
if (strlen(buf)>_MAX_STRING)
|
|
{
|
|
buf[_MAX_STRING-3] = '.';
|
|
buf[_MAX_STRING-2] = '.';
|
|
buf[_MAX_STRING-1] = '.';
|
|
buf[_MAX_STRING] = '\0';
|
|
}
|
|
}
|
|
|
|
/* Fixup multi-menu option look */
|
|
for (i = 0; i < strlen(buf) ; i++)
|
|
{
|
|
if (buf[i] == '^' || buf[i] == '|')
|
|
buf[i] = ' ';
|
|
}
|
|
|
|
font_surf = TTF_RenderText_Blended(menu_font64, buf, color);
|
|
if (!font_surf)
|
|
{
|
|
fprintf(stderr, "%s\n", TTF_GetError());
|
|
exit(1);
|
|
}
|
|
|
|
SDL_BlitSurface(font_surf, NULL, screen, &dst);
|
|
SDL_FreeSurface(font_surf);
|
|
}
|
|
|
|
|
|
static void menu_draw(SDL_Surface *screen, menu_t *p_menu, int sel)
|
|
{
|
|
int font_height = TTF_FontHeight(p_menu->p_font);
|
|
int line_height = (font_height + font_height / 4);
|
|
int x_start = p_menu->x1;
|
|
int y_start = p_menu->y1 + line_height;
|
|
SDL_Rect r;
|
|
int entries_visible = (p_menu->y2 - p_menu->y1) / line_height - 1;
|
|
|
|
int i, y;
|
|
char pTemp[256];
|
|
|
|
if ( p_menu->n_entries * line_height > p_menu->y2 )
|
|
y_start = p_menu->y1 + line_height;
|
|
|
|
if (p_menu->cur_sel - p_menu->start_entry_visible > entries_visible)
|
|
{
|
|
while (p_menu->cur_sel - p_menu->start_entry_visible > entries_visible)
|
|
{
|
|
p_menu->start_entry_visible ++;
|
|
if (p_menu->start_entry_visible > p_menu->n_entries)
|
|
{
|
|
p_menu->start_entry_visible = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if ( p_menu->cur_sel < p_menu->start_entry_visible )
|
|
p_menu->start_entry_visible = p_menu->cur_sel;
|
|
|
|
if (strlen(p_menu->title))
|
|
{
|
|
r.x = p_menu->x1;
|
|
r.y = p_menu->y1;
|
|
r.w = p_menu->x2 - p_menu->x1;
|
|
r.h = line_height-1;
|
|
if (sel < 0)
|
|
SDL_FillRect(screen, &r, SDL_MapRGB(screen->format, 0x40, 0x00, 0x00));
|
|
else
|
|
SDL_FillRect(screen, &r, SDL_MapRGB(screen->format, 0x00, 0x00, 0xff));
|
|
menu_print_font(screen, 0,0,0, p_menu->x1, p_menu->y1, p_menu->title);
|
|
}
|
|
|
|
for (i = p_menu->start_entry_visible; i <= p_menu->start_entry_visible + entries_visible; i++)
|
|
{
|
|
const char *msg = p_menu->pp_msgs[i];
|
|
|
|
if (i >= p_menu->n_entries)
|
|
break;
|
|
if (IS_MARKER(msg))
|
|
p_menu->cur_sel = atoi(&msg[1]);
|
|
else
|
|
{
|
|
y = (i - p_menu->start_entry_visible) * line_height;
|
|
|
|
if (sel < 0)
|
|
menu_print_font(screen, 0x40,0x40,0x40,
|
|
x_start, y_start + y, msg);
|
|
else if (p_menu->cur_sel == i) /* Selected - color */
|
|
menu_print_font(screen, 0,255,0,
|
|
x_start, y_start + y, msg);
|
|
else if (IS_SUBMENU(msg))
|
|
{
|
|
if (p_menu->cur_sel == i-1)
|
|
menu_print_font(screen, 0x80,0x80,0x80,
|
|
x_start, y_start + y, msg);
|
|
else
|
|
menu_print_font(screen, 0x40,0x40,0x40,
|
|
x_start, y_start + y, msg);
|
|
}
|
|
else if (msg[0] == '#')
|
|
{
|
|
switch (msg[1])
|
|
{
|
|
case '1':
|
|
menu_print_font(screen, 0,0,255,
|
|
x_start, y_start + y, msg+2);
|
|
break;
|
|
case '2':
|
|
menu_print_font(screen, 0x80,0x80,0x80,
|
|
x_start, y_start + y, msg+2);
|
|
break;
|
|
default:
|
|
menu_print_font(screen, 0x40,0x40,0x40,
|
|
x_start, y_start + y, msg);
|
|
break;
|
|
}
|
|
}
|
|
else /* Otherwise white */
|
|
menu_print_font(screen, 0x40,0x40,0x40,
|
|
x_start, y_start + y, msg);
|
|
if (IS_SUBMENU(msg))
|
|
{
|
|
submenu_t *p_submenu = find_submenu(p_menu, i);
|
|
int n_pipe = 0;
|
|
int n;
|
|
|
|
for (n=0; msg[n] != '\0'; n++)
|
|
{
|
|
/* Underline the selected entry */
|
|
if (msg[n] == '|')
|
|
{
|
|
int16_t n_chars;
|
|
|
|
for (n_chars = 1; msg[n+n_chars] && msg[n+n_chars] != '|'; n_chars++);
|
|
|
|
n_pipe++;
|
|
if (p_submenu->sel == n_pipe-1)
|
|
{
|
|
int w;
|
|
int h;
|
|
|
|
if (TTF_SizeText(p_menu->p_font, "X", &w, &h) < 0)
|
|
{
|
|
fw = w;
|
|
fh = h;
|
|
fprintf(stderr, "%s\n", TTF_GetError());
|
|
exit(1);
|
|
}
|
|
|
|
r = (SDL_Rect){ x_start + (n+1) * w-1, y_start + (i+ 1 - p_menu->start_entry_visible) * ((h + h/4)) -3, (n_chars - 1) * w, 2};
|
|
if (p_menu->cur_sel == i-1)
|
|
SDL_FillRect(screen, &r,
|
|
SDL_MapRGB(screen->format, 0x80,0x80,0x80));
|
|
else
|
|
SDL_FillRect(screen, &r,
|
|
SDL_MapRGB(screen->format, 0x40,0x40,0x40));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int get_next_seq_y(menu_t *p_menu, int v, int dy)
|
|
{
|
|
if (v + dy < 0)
|
|
return p_menu->n_entries - 1;
|
|
if (v + dy > p_menu->n_entries - 1)
|
|
return 0;
|
|
return v + dy;
|
|
}
|
|
|
|
static void select_next(menu_t *p_menu, int dx, int dy)
|
|
{
|
|
int next;
|
|
char buffer[256];
|
|
|
|
p_menu->cur_sel = get_next_seq_y(p_menu, p_menu->cur_sel, dy);
|
|
next = get_next_seq_y(p_menu, p_menu->cur_sel, dy + 1);
|
|
if (p_menu->pp_msgs[p_menu->cur_sel][0] == ' ' ||
|
|
p_menu->pp_msgs[p_menu->cur_sel][0] == '#' ||
|
|
IS_SUBMENU(p_menu->pp_msgs[p_menu->cur_sel]) )
|
|
select_next(p_menu, dx, dy);
|
|
|
|
/* If the next is a submenu */
|
|
if (dx != 0 && IS_SUBMENU(p_menu->pp_msgs[next]))
|
|
{
|
|
submenu_t *p_submenu = find_submenu(p_menu, next);
|
|
|
|
p_submenu->sel = (p_submenu->sel + dx) < 0 ? p_submenu->n_entries - 1 :
|
|
(p_submenu->sel + dx) % p_submenu->n_entries;
|
|
}
|
|
else if (dx == -1 && !strcmp(p_menu->pp_msgs[0], "[..]"))
|
|
p_menu->cur_sel = 0;
|
|
}
|
|
|
|
static void select_one(menu_t *p_menu, int sel)
|
|
{
|
|
if (sel >= p_menu->n_entries)
|
|
sel = 0;
|
|
p_menu->cur_sel = sel;
|
|
if (p_menu->pp_msgs[p_menu->cur_sel][0] == ' ' ||
|
|
p_menu->pp_msgs[p_menu->cur_sel][0] == '#' ||
|
|
IS_SUBMENU(p_menu->pp_msgs[p_menu->cur_sel]))
|
|
select_next(p_menu, 0, 1);
|
|
}
|
|
|
|
static int is_submenu_title(menu_t *p_menu, int n)
|
|
{
|
|
if (n+1 >= p_menu->n_entries)
|
|
return 0;
|
|
else
|
|
return IS_SUBMENU(p_menu->pp_msgs[n+1]);
|
|
}
|
|
|
|
|
|
static void menu_init(menu_t *p_menu, const char *title, TTF_Font *p_font, const char **pp_msgs,
|
|
int16_t x1, int16_t y1, int16_t x2, int16_t y2)
|
|
{
|
|
int submenu;
|
|
int i;
|
|
int j;
|
|
|
|
memset(p_menu, 0, sizeof(menu_t));
|
|
|
|
p_menu->pp_msgs = pp_msgs;
|
|
p_menu->p_font = p_font;
|
|
p_menu->x1 = x1;
|
|
p_menu->y1 = y1;
|
|
p_menu->x2 = x2;
|
|
p_menu->y2 = y2;
|
|
|
|
p_menu->text_w = 0;
|
|
p_menu->n_submenus = 0;
|
|
strcpy(p_menu->title, title);
|
|
|
|
for (p_menu->n_entries = 0; p_menu->pp_msgs[p_menu->n_entries]; p_menu->n_entries++)
|
|
{
|
|
int text_w_font;
|
|
|
|
/* Is this a submenu? */
|
|
if (IS_SUBMENU(p_menu->pp_msgs[p_menu->n_entries]))
|
|
{
|
|
p_menu->n_submenus++;
|
|
continue; /* Length of submenus is unimportant */
|
|
}
|
|
|
|
if (TTF_SizeText(p_font, p_menu->pp_msgs[p_menu->n_entries], &text_w_font, NULL) != 0)
|
|
{
|
|
fprintf(stderr, "%s\n", TTF_GetError());
|
|
exit(1);
|
|
}
|
|
if (text_w_font > p_menu->text_w)
|
|
p_menu->text_w = text_w_font;
|
|
}
|
|
if (p_menu->text_w > p_menu->x2 - p_menu->x1)
|
|
p_menu->text_w = p_menu->x2 - p_menu->x1;
|
|
|
|
if ( !(p_menu->p_submenus = (submenu_t *)malloc(sizeof(submenu_t) * p_menu->n_submenus)) )
|
|
{
|
|
perror("malloc failed!\n");
|
|
exit(1);
|
|
}
|
|
|
|
j=0;
|
|
submenu = 0;
|
|
for (; j < p_menu->n_entries; j++)
|
|
{
|
|
if (IS_SUBMENU(p_menu->pp_msgs[j]))
|
|
{
|
|
int n;
|
|
|
|
p_menu->p_submenus[submenu].index = j;
|
|
p_menu->p_submenus[submenu].sel = 0;
|
|
p_menu->p_submenus[submenu].n_entries = 0;
|
|
for (n=0; p_menu->pp_msgs[j][n] != '\0'; n++)
|
|
{
|
|
if (p_menu->pp_msgs[j][n] == '|')
|
|
p_menu->p_submenus[submenu].n_entries++;
|
|
}
|
|
submenu++;
|
|
}
|
|
}
|
|
p_menu->text_h = p_menu->n_entries * (TTF_FontHeight(p_font) + TTF_FontHeight(p_font) / 4);
|
|
}
|
|
|
|
static void menu_fini(menu_t *p_menu)
|
|
{
|
|
free(p_menu->p_submenus);
|
|
}
|
|
|
|
uint32_t menu_wait_key_press(void)
|
|
{
|
|
SDL_Event ev;
|
|
uint32_t keys = 0;
|
|
|
|
while (1)
|
|
{
|
|
#if defined(GEKKO)
|
|
Uint32 remote_keys, classic_keys;
|
|
WPADData *wpad, *wpad_other;
|
|
|
|
WPAD_ScanPads();
|
|
wpad = WPAD_Data(WPAD_CHAN_0);
|
|
wpad_other = WPAD_Data(WPAD_CHAN_1);
|
|
|
|
if (!wpad && !wpad_other)
|
|
return 0;
|
|
|
|
remote_keys = wpad->btns_d | wpad_other->btns_d;
|
|
classic_keys = 0;
|
|
|
|
/* Check classic controllers as well */
|
|
if (wpad->exp.type == WPAD_EXP_CLASSIC ||
|
|
wpad_other->exp.type == WPAD_EXP_CLASSIC)
|
|
{
|
|
static bool classic_keys_changed;
|
|
static Uint32 classic_last;
|
|
|
|
classic_keys = wpad->exp.classic.btns | wpad_other->exp.classic.btns;
|
|
|
|
classic_keys_changed = classic_keys != classic_last;
|
|
classic_last = classic_keys;
|
|
|
|
/* No repeat, thank you */
|
|
if (!classic_keys_changed)
|
|
classic_keys = 0;
|
|
}
|
|
|
|
if (remote_keys & WPAD_BUTTON_B)
|
|
keys |= KEY_HELP;
|
|
if ( (remote_keys & WPAD_BUTTON_DOWN) || (classic_keys & CLASSIC_CTRL_BUTTON_RIGHT) )
|
|
keys |= KEY_RIGHT;
|
|
if ( (remote_keys & WPAD_BUTTON_UP) || (classic_keys & CLASSIC_CTRL_BUTTON_LEFT) )
|
|
keys |= KEY_LEFT;
|
|
if ( (remote_keys & WPAD_BUTTON_LEFT) || (classic_keys & CLASSIC_CTRL_BUTTON_DOWN) )
|
|
keys |= KEY_DOWN;
|
|
if ( (remote_keys & WPAD_BUTTON_RIGHT) || (classic_keys & CLASSIC_CTRL_BUTTON_UP) )
|
|
keys |= KEY_UP;
|
|
if ( (remote_keys & WPAD_BUTTON_PLUS) || (classic_keys & CLASSIC_CTRL_BUTTON_PLUS) )
|
|
keys |= KEY_PAGEUP;
|
|
if ( (remote_keys & WPAD_BUTTON_MINUS) || (classic_keys & CLASSIC_CTRL_BUTTON_MINUS) )
|
|
keys |= KEY_PAGEDOWN;
|
|
if ( (remote_keys & (WPAD_BUTTON_A | WPAD_BUTTON_2) ) || (classic_keys & (CLASSIC_CTRL_BUTTON_A | CLASSIC_CTRL_BUTTON_X)) )
|
|
keys |= KEY_SELECT;
|
|
if ( (remote_keys & (WPAD_BUTTON_1 | WPAD_BUTTON_HOME) ) || (classic_keys & (CLASSIC_CTRL_BUTTON_B | CLASSIC_CTRL_BUTTON_Y)) )
|
|
keys |= KEY_ESCAPE;
|
|
|
|
#endif
|
|
if (SDL_PollEvent(&ev))
|
|
{
|
|
switch(ev.type)
|
|
{
|
|
case SDL_KEYDOWN:
|
|
switch (ev.key.keysym.sym)
|
|
{
|
|
case SDLK_UP:
|
|
keys |= KEY_UP;
|
|
break;
|
|
case SDLK_DOWN:
|
|
keys |= KEY_DOWN;
|
|
break;
|
|
case SDLK_LEFT:
|
|
keys |= KEY_LEFT;
|
|
break;
|
|
case SDLK_RIGHT:
|
|
keys |= KEY_RIGHT;
|
|
break;
|
|
case SDLK_PAGEDOWN:
|
|
keys |= KEY_PAGEDOWN;
|
|
break;
|
|
case SDLK_PAGEUP:
|
|
keys |= KEY_PAGEUP;
|
|
break;
|
|
case SDLK_RETURN:
|
|
case SDLK_SPACE:
|
|
keys |= KEY_SELECT;
|
|
break;
|
|
case SDLK_HOME:
|
|
case SDLK_ESCAPE:
|
|
keys |= KEY_ESCAPE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
case SDL_QUIT:
|
|
exit(0);
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
}
|
|
break;
|
|
}
|
|
if (keys != 0)
|
|
return keys;
|
|
SDL_Delay(100);
|
|
}
|
|
return keys;
|
|
}
|
|
|
|
|
|
extern void PicDisplay(char *name, int off_x, int off_y, int wait);
|
|
extern const char **get_t64_list(char *t64);
|
|
extern const char **get_prg_list(char *t64);
|
|
|
|
extern char curdir[256];
|
|
|
|
static int menu_select_internal(SDL_Surface *screen,
|
|
menu_t *p_menu, int *p_submenus, int sel,
|
|
void (*select_next_cb)(menu_t *p, void *data) = NULL,
|
|
void *select_next_cb_data = NULL)
|
|
{
|
|
int ret = -1;
|
|
|
|
for (int i = 0; i < p_menu->n_submenus; i++)
|
|
p_menu->p_submenus[i].sel = p_submenus[i];
|
|
|
|
while(1)
|
|
{
|
|
SDL_Rect r = {p_menu->x1, p_menu->y1,
|
|
p_menu->x2 - p_menu->x1, p_menu->y2 - p_menu->y1};
|
|
uint32_t keys;
|
|
int sel_last = p_menu->cur_sel;
|
|
|
|
SDL_FillRect(screen, &r, SDL_MapRGB(screen->format, 0x00, 0x80, 0x80));
|
|
|
|
menu_draw(screen, p_menu, 0);
|
|
SDL_Flip(screen);
|
|
|
|
keys = menu_wait_key_press();
|
|
|
|
if (keys & KEY_UP)
|
|
select_next(p_menu, 0, -1);
|
|
else if (keys & KEY_DOWN)
|
|
select_next(p_menu, 0, 1);
|
|
else if (keys & KEY_PAGEUP)
|
|
select_next(p_menu, 0, -6);
|
|
else if (keys & KEY_PAGEDOWN)
|
|
select_next(p_menu, 0, 6);
|
|
else if (keys & KEY_LEFT)
|
|
select_next(p_menu, -1, 0);
|
|
else if (keys & KEY_RIGHT)
|
|
select_next(p_menu, 1, 0);
|
|
else if (keys & KEY_ESCAPE)
|
|
break;
|
|
else if (keys & KEY_SELECT)
|
|
{
|
|
ret = p_menu->cur_sel;
|
|
int i;
|
|
|
|
for (i=0; i<p_menu->n_submenus; i++)
|
|
p_submenus[i] = p_menu->p_submenus[i].sel;
|
|
break;
|
|
}
|
|
/* Invoke the callback when an entry is selected */
|
|
if (sel_last != p_menu->cur_sel &&
|
|
select_next_cb != NULL)
|
|
select_next_cb(p_menu, select_next_cb_data);
|
|
}
|
|
|
|
SDL_FillRect(screen, 0, SDL_MapRGB(screen->format, 0, 0, 0));
|
|
return ret;
|
|
}
|
|
|
|
int menu_select_sized(const char *title, const char **msgs, int *submenus, int sel,
|
|
int x, int y, int x2, int y2,
|
|
void (*select_next_cb)(menu_t *p, void *data) = NULL,
|
|
void *select_next_cb_data = NULL)
|
|
|
|
{
|
|
menu_t menu;
|
|
int out;
|
|
bool info;
|
|
|
|
if (!strcmp(title, "Folder") || !strcmp(title, "Single File") ||
|
|
!strcmp(title, "C-64 Disc") || !strcmp(title, "C-64 Tape") || sel < 0)
|
|
info = false;
|
|
else
|
|
info = true;
|
|
|
|
menu_init(&menu, title, menu_font, msgs,
|
|
x, y, x2, y2);
|
|
|
|
if (sel >= 0)
|
|
select_one(&menu, sel);
|
|
out = menu_select_internal(real_screen, &menu, submenus, sel,
|
|
select_next_cb, select_next_cb_data);
|
|
|
|
menu_fini(&menu);
|
|
|
|
return out;
|
|
}
|
|
|
|
static int menu_select(const char *title, const char **msgs, int *submenus, int sel)
|
|
{
|
|
return menu_select_sized(title, msgs, submenus, sel,
|
|
0, 0, FULL_DISPLAY_X, FULL_DISPLAY_Y);
|
|
}
|
|
|
|
int menu_select(const char **msgs, int *submenus)
|
|
{
|
|
return menu_select("", msgs, submenus, 0);
|
|
}
|
|
|
|
extern "C" const char **DirD64(const char *FileName);
|
|
|
|
static void d64_list_cb(menu_t *p, void *data)
|
|
{
|
|
const char *dp = (const char*)data;
|
|
const char *exts[] = {".d64", ".D64", NULL};
|
|
const char *name = p->pp_msgs[p->cur_sel];
|
|
SDL_Rect r = {FULL_DISPLAY_X / 2, 0,
|
|
FULL_DISPLAY_X / 2, FULL_DISPLAY_Y};
|
|
|
|
SDL_FillRect(real_screen, &r, SDL_MapRGB(real_screen->format, 0x00, 0x90, 0x90));
|
|
if (ext_matches_list(name, exts))
|
|
{
|
|
char buf[255];
|
|
const char **dir;
|
|
menu_t menu;
|
|
|
|
snprintf(buf, 255, "%s/%s", dp, name);
|
|
dir = DirD64(buf);
|
|
if (!dir)
|
|
return;
|
|
|
|
menu_init(&menu, "D64 contents", menu_font, dir,
|
|
FULL_DISPLAY_X / 2, 0,
|
|
FULL_DISPLAY_X, FULL_DISPLAY_Y);
|
|
menu_draw(real_screen, &menu, 0);
|
|
menu_fini(&menu);
|
|
|
|
/* Cleanup dir list */
|
|
for ( int i = 0; dir[i]; i++ )
|
|
free((void*)dir[i]);
|
|
free(dir);
|
|
}
|
|
}
|
|
|
|
static const char *get_d64_file(const char *name)
|
|
{
|
|
const char **dir;
|
|
char *out = NULL;
|
|
|
|
dir = DirD64(name);
|
|
if (!dir)
|
|
return NULL;
|
|
|
|
int which = menu_select("Select D64 file", dir, NULL, 0);
|
|
|
|
if (which >= 0)
|
|
{
|
|
char *p = (char*)dir[which];
|
|
|
|
for (int i = 0; i < strlen(p); i++)
|
|
{
|
|
if (*p == '\"')
|
|
break;
|
|
p++;
|
|
}
|
|
p++;
|
|
for (int i = 0; i < strlen(p); i++)
|
|
{
|
|
if (p[i] == '\"')
|
|
{
|
|
p[i] = '\0';
|
|
break;
|
|
}
|
|
}
|
|
/* Copy and uppercase */
|
|
out = strdup(p);
|
|
for (int i = 0; i < strlen(out); i++)
|
|
out[i] = toupper(out[i]);
|
|
}
|
|
|
|
/* Cleanup dir list */
|
|
for ( int i = 0; dir[i]; i++ )
|
|
free((void*)dir[i]);
|
|
free(dir);
|
|
|
|
return out;
|
|
}
|
|
|
|
static const char *menu_select_file_internal(const char *dir_path,
|
|
int x, int y, int x2, int y2)
|
|
{
|
|
const char **file_list = get_file_list(dir_path);
|
|
char *sel;
|
|
char *out;
|
|
int opt;
|
|
|
|
if (file_list == NULL)
|
|
return NULL;
|
|
|
|
opt = menu_select_sized("Select file", file_list, NULL, 0,
|
|
x, y, x2, y2,
|
|
d64_list_cb, (void*)dir_path);
|
|
|
|
if (opt < 0)
|
|
return NULL;
|
|
sel = strdup(file_list[opt]);
|
|
|
|
/* Cleanup everything - file_list is NULL-terminated */
|
|
for ( int i = 0; file_list[i]; i++ )
|
|
free((void*)file_list[i]);
|
|
free(file_list);
|
|
|
|
if (!sel)
|
|
return NULL;
|
|
/* If this is a folder, enter it recursively */
|
|
if (sel[0] == '[')
|
|
{
|
|
char buf[255];
|
|
int len = strlen(sel);
|
|
int s;
|
|
const char *p;
|
|
|
|
/* Remove trailing ] */
|
|
sel[len-1] = '\0';
|
|
s = snprintf(buf, 128, "%s/%s", dir_path, sel + 1);
|
|
|
|
/* We don't need this anymore */
|
|
free((void*)sel);
|
|
/* Too deep recursion! */
|
|
if (s >= sizeof(buf))
|
|
return NULL;
|
|
return menu_select_file(buf);
|
|
}
|
|
|
|
out = (char*)malloc(strlen(dir_path) + strlen(sel) + 4);
|
|
snprintf(out, strlen(dir_path) + strlen(sel) + 4,
|
|
"%s/%s", dir_path, sel);
|
|
|
|
free(sel);
|
|
return out;
|
|
}
|
|
|
|
const char *menu_select_file_start(const char *dir_path, const char **d64_name)
|
|
{
|
|
const char *file = menu_select_file_internal(dir_path,
|
|
0, 0, FULL_DISPLAY_X/2, FULL_DISPLAY_Y);
|
|
const char *exts[] = {".d64", ".D64", NULL};
|
|
|
|
if (!file)
|
|
return NULL;
|
|
if (ext_matches_list(file, exts))
|
|
*d64_name = get_d64_file(file);
|
|
|
|
return file;
|
|
}
|
|
|
|
const char *menu_select_file(const char *dir_path)
|
|
{
|
|
return menu_select_file_internal(dir_path,
|
|
0, 0, FULL_DISPLAY_X/2, FULL_DISPLAY_Y);
|
|
}
|
|
|
|
static TTF_Font *read_font(const char *path)
|
|
{
|
|
TTF_Font *out;
|
|
SDL_RWops *rw;
|
|
Uint8 *data = (Uint8*)malloc(1 * 1024*1024);
|
|
FILE *fp = fopen(path, "r");
|
|
|
|
if (!data) {
|
|
fprintf(stderr, "Malloc failed\n");
|
|
exit(1);
|
|
}
|
|
if (!fp) {
|
|
fprintf(stderr, "Could not open font\n");
|
|
exit(1);
|
|
}
|
|
fread(data, 1, 1 * 1024 * 1024, fp);
|
|
rw = SDL_RWFromMem(data, 1 * 1024 * 1024);
|
|
if (!rw)
|
|
{
|
|
fprintf(stderr, "Could not create RW: %s\n", SDL_GetError());
|
|
exit(1);
|
|
}
|
|
out = TTF_OpenFontRW(rw, 1, 20);
|
|
if (!out)
|
|
{
|
|
fprintf(stderr, "Unable to open font %s\n", path);
|
|
exit(1);
|
|
}
|
|
fclose(fp);
|
|
|
|
return out;
|
|
}
|
|
|
|
void menu_init()
|
|
{
|
|
Uint8 *data64 = (Uint8*)malloc(1 * 1024*1024);
|
|
|
|
menu_font = read_font(FONT_PATH);
|
|
menu_font64 = read_font(FONT64_PATH);
|
|
}
|