static int menu_archive_open(void)
{
char cat_path[PATH_MAX];
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_list_pop_stack(driver.menu->menu_list);
menu_list_get_last_stack(driver.menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(driver.menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr, &path, NULL, &type);
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_list_push_stack_refresh(
driver.menu->menu_list,
cat_path,
menu_label,
type,
driver.menu->selection_ptr);
return 0;
}
static int archive_open(void)
{
char cat_path[PATH_MAX_LENGTH];
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return -1;
menu_list_pop_stack(menu->menu_list);
menu_list_get_last_stack(menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(menu->menu_list->selection_buf,
menu->navigation.selection_ptr, &path, NULL, &type);
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
menu_list_push_stack_refresh(
menu->menu_list,
cat_path,
menu_label,
type,
menu->navigation.selection_ptr);
return 0;
}
/**
* menu_entries_list_elem_is_dir:
* @list : File list handle.
* @offset : Offset index of element.
*
* Is the current entry at offset @offset a directory?
*
* Returns: true (1) if entry is a directory, otherwise false (0).
**/
static INLINE bool menu_entries_list_elem_is_dir(file_list_t *list,
unsigned offset)
{
const char *path = NULL;
const char *label = NULL;
unsigned type = 0;
menu_list_get_at_offset(list, offset, &path, &label, &type);
return type != MENU_FILE_PLAIN;
}
static int archive_load(void)
{
int ret = 0;
menu_displaylist_info_t info = {0};
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
size_t entry_idx = 0;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
size_t selected = menu_navigation_get_current_selection();
menu_handle_t *menu = menu_driver_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
if (!menu || !menu_list)
return -1;
menu_list_pop_stack(menu_list);
menu_list_get_last_stack(menu_list, &menu_path, &menu_label, NULL, NULL);
if (menu_list_get_size(menu_list) == 0)
return 0;
menu_list_get_at_offset(menu_list->selection_buf,
selected, &path, NULL, NULL, &entry_idx);
ret = rarch_defer_core(global->core_info, menu_path, path, menu_label,
menu->deferred_path, sizeof(menu->deferred_path));
fill_pathname_join(detect_content_path, menu_path, path,
sizeof(detect_content_path));
switch (ret)
{
case -1:
event_command(EVENT_CMD_LOAD_CORE);
menu_common_load_content(false, CORE_TYPE_PLAIN);
break;
case 0:
info.list = menu_list->menu_stack;
info.type = 0;
info.directory_ptr = selected;
strlcpy(info.path, settings->libretro_directory, sizeof(info.path));
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_DEFERRED_CORE_LIST), sizeof(info.label));
ret = menu_displaylist_push_list(&info, DISPLAYLIST_GENERIC);
break;
}
return ret;
}
static int menu_info_screen_iterate(unsigned action)
{
char msg[PATH_MAX];
char needle[PATH_MAX];
unsigned info_type = 0;
rarch_setting_t *current_setting = NULL;
file_list_t *list = (file_list_t*)driver.menu->menu_list->selection_buf;
if (!driver.menu)
return 0;
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
current_setting = (rarch_setting_t*)setting_data_find_setting(
driver.menu->list_settings,
list->list[driver.menu->selection_ptr].label);
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
else if ((current_setting = (rarch_setting_t*)setting_data_find_setting(
driver.menu->list_mainmenu,
list->list[driver.menu->selection_ptr].label)))
{
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
}
else
{
const char *label = NULL;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr, NULL, &label,
&info_type);
if (label)
strlcpy(needle, label, sizeof(needle));
}
setting_data_get_description(needle, msg, sizeof(msg));
if (driver.video_data && driver.menu_ctx &&
driver.menu_ctx->render_messagebox)
{
if (*msg && msg[0] != '\0')
driver.menu_ctx->render_messagebox(msg);
}
if (action == MENU_ACTION_OK)
menu_list_pop_stack(driver.menu->menu_list);
return 0;
}
static int action_iterate_info(const char *label, unsigned action)
{
char msg[PATH_MAX_LENGTH];
char needle[PATH_MAX_LENGTH];
unsigned info_type = 0;
rarch_setting_t *current_setting = NULL;
file_list_t *list = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
if (!menu)
return 0;
list = (file_list_t*)menu->menu_list->selection_buf;
menu_driver_render();
current_setting = (rarch_setting_t*)setting_find_setting(
menu->list_settings,
list->list[menu->navigation.selection_ptr].label);
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
else if ((current_setting = (rarch_setting_t*)setting_find_setting(
menu->list_settings,
list->list[menu->navigation.selection_ptr].label)))
{
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
}
else
{
const char *lbl = NULL;
menu_list_get_at_offset(list,
menu->navigation.selection_ptr, NULL, &lbl,
&info_type);
if (lbl)
strlcpy(needle, lbl, sizeof(needle));
}
setting_get_description(needle, msg, sizeof(msg));
menu_driver_render_messagebox(msg);
if (action == MENU_ACTION_OK)
menu_list_pop(menu->menu_list->menu_stack, &menu->navigation.selection_ptr);
return 0;
}
static int archive_load(void)
{
int ret;
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_handle_t *menu = menu_driver_get_ptr();
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
if (!menu)
return -1;
menu_list_pop_stack(menu->menu_list);
menu_list_get_last_stack(menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(menu->menu_list->selection_buf,
menu->navigation.selection_ptr, &path, NULL, &type);
ret = rarch_defer_core(global->core_info, menu_path, path, menu_label,
menu->deferred_path, sizeof(menu->deferred_path));
switch (ret)
{
case -1:
event_command(EVENT_CMD_LOAD_CORE);
menu_entries_common_load_content(false);
break;
case 0:
menu_list_push_stack_refresh(
menu->menu_list,
settings->libretro_directory,
"deferred_core_list",
0,
menu->navigation.selection_ptr);
break;
}
return 0;
}
enum menu_entry_type menu_entry_get_type(uint32_t i)
{
rarch_setting_t *setting;
const char *path = NULL, *entry_label = NULL;
unsigned type = 0;
const char *dir = NULL;
const char *label = NULL;
menu_list_t *menu_list = menu_list_get_ptr();
unsigned menu_type = 0;
menu_list_get_last_stack(menu_list, &dir, &label, &menu_type);
menu_list_get_at_offset(menu_list->selection_buf, i, &path,
&entry_label, &type);
setting = menu_entry_get_setting(i);
// XXX Really a special kind of ST_ACTION, but this should be
// changed
if (setting_is_of_path_type(setting))
return MENU_ENTRY_PATH;
else if (setting && setting->type == ST_BOOL )
return MENU_ENTRY_BOOL;
else if (setting && setting->type == ST_BIND )
return MENU_ENTRY_BIND;
else if (setting_is_of_enum_type(setting))
return MENU_ENTRY_ENUM;
else if (setting && setting->type == ST_INT )
return MENU_ENTRY_INT;
else if (setting && setting->type == ST_UINT )
return MENU_ENTRY_UINT;
else if (setting && setting->type == ST_FLOAT )
return MENU_ENTRY_FLOAT;
else if (setting && setting->type == ST_PATH )
return MENU_ENTRY_PATH;
else if (setting && setting->type == ST_DIR )
return MENU_ENTRY_DIR;
else if (setting && setting->type == ST_STRING )
return MENU_ENTRY_STRING;
else if (setting && setting->type == ST_HEX )
return MENU_ENTRY_HEX;
else
return MENU_ENTRY_ACTION;
}
static rarch_setting_t *menu_entry_get_setting(uint32_t i)
{
const char *path = NULL;
const char *entry_label = NULL;
const char *dir = NULL;
const char *label = NULL;
menu_list_t *menu_list = menu_list_get_ptr();
unsigned type = 0;
unsigned menu_type = 0;
menu_list_get_last_stack(menu_list, &dir,
&label, &menu_type, NULL);
menu_list_get_at_offset(menu_list->selection_buf, i, &path,
&entry_label, &type, NULL);
return menu_setting_find(
menu_list->selection_buf->list[i].label);
}
static int menu_archive_load(void)
{
int ret;
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
menu_list_pop_stack(driver.menu->menu_list);
menu_list_get_last_stack(driver.menu->menu_list,
&menu_path, &menu_label, NULL);
if (menu_list_get_size(driver.menu->menu_list) == 0)
return 0;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr, &path, NULL, &type);
ret = rarch_defer_core(g_extern.core_info, menu_path, path,
driver.menu->deferred_path, sizeof(driver.menu->deferred_path));
switch (ret)
{
case -1:
rarch_main_command(RARCH_CMD_LOAD_CORE);
menu_common_load_content();
break;
case 0:
menu_list_push_stack_refresh(
driver.menu->menu_list,
g_settings.libretro_directory,
"deferred_core_list",
0,
driver.menu->selection_ptr);
break;
}
return 0;
}
static int archive_open(void)
{
char cat_path[PATH_MAX_LENGTH] = {0};
menu_displaylist_info_t info = {0};
const char *menu_path = NULL;
const char *menu_label = NULL;
const char* path = NULL;
unsigned int type = 0;
size_t entry_idx = 0;
menu_navigation_t *nav = menu_navigation_get_ptr();
menu_list_t *menu_list = menu_list_get_ptr();
if (!menu_list || !nav)
return -1;
menu_list_pop_stack(menu_list);
menu_list_get_last_stack(menu_list,
&menu_path, &menu_label, NULL, NULL);
if (menu_list_get_size(menu_list) == 0)
return 0;
menu_list_get_at_offset(menu_list->selection_buf,
nav->selection_ptr, &path, NULL, &type, &entry_idx);
fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));
fill_pathname_join(detect_content_path, menu_path, path,
sizeof(detect_content_path));
info.list = menu_list->menu_stack;
info.type = type;
info.directory_ptr = nav->selection_ptr;
strlcpy(info.path, cat_path, sizeof(info.path));
strlcpy(info.label, menu_label, sizeof(info.label));
return menu_displaylist_push_list(&info, DISPLAYLIST_GENERIC);
}
void menu_entry_get(menu_entry_t *entry, size_t i,
void *userdata, bool use_representation)
{
const char *label = NULL;
const char *path = NULL;
const char *entry_label = NULL;
menu_file_list_cbs_t *cbs = NULL;
file_list_t *list = NULL;
menu_list_t *menu_list = menu_list_get_ptr();
if (!menu_list)
return;
menu_list_get_last_stack(menu_list, NULL, &label, NULL, NULL);
list = userdata ? (file_list_t*)userdata : menu_list->selection_buf;
if (!list)
return;
menu_list_get_at_offset(list, i, &path, &entry_label, &entry->type,
&entry->entry_idx);
cbs = menu_list_get_actiondata_at_offset(list, i);
if (cbs && cbs->action_get_value && use_representation)
cbs->action_get_value(list,
&entry->spacing, entry->type, i, label,
entry->value, sizeof(entry->value),
entry_label, path,
entry->path, sizeof(entry->path));
entry->idx = i;
if (path && !use_representation)
strlcpy(entry->path, path, sizeof(entry->path));
if (entry_label)
strlcpy(entry->label, entry_label, sizeof(entry->label));
}
static int action_iterate_info(char *s, size_t len, const char *label)
{
int ret = 0;
char needle[PATH_MAX_LENGTH] = {0};
unsigned info_type = 0;
rarch_setting_t *current_setting = NULL;
file_list_t *list = NULL;
menu_list_t *menu_list = menu_list_get_ptr();
size_t selection = menu_navigation_get_current_selection();
if (!menu_list)
return 0;
list = (file_list_t*)menu_list->selection_buf;
menu_driver_render();
current_setting = menu_setting_find(list->list[selection].label);
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
else if ((current_setting = menu_setting_find(list->list[selection].label)))
{
if (current_setting)
strlcpy(needle, current_setting->name, sizeof(needle));
}
else
{
const char *lbl = NULL;
menu_list_get_at_offset(list, selection, NULL, &lbl, &info_type, NULL);
if (lbl)
strlcpy(needle, lbl, sizeof(needle));
}
setting_get_description(needle, s, len);
return ret;
}
static int menu_common_iterate(unsigned action)
{
int ret = 0;
unsigned type = 0;
unsigned type_offset = 0;
const char *label = NULL;
const char *label_offset = NULL;
const char *path_offset = NULL;
unsigned scroll_speed = 0;
menu_file_list_cbs_t *cbs = (menu_file_list_cbs_t*)
menu_list_get_actiondata_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr);
menu_list_get_last_stack(driver.menu->menu_list, NULL, &label, &type);
mouse_iterate(action);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->set_texture)
driver.menu_ctx->set_texture(driver.menu);
if (!strcmp(label, "help"))
return menu_start_screen_iterate(action);
else if (!strcmp(label, "message"))
return menu_message_toggle(action);
else if (!strcmp(label, "load_open_zip"))
{
switch (g_settings.archive.mode)
{
case 0:
return menu_load_or_open_zip_iterate(action);
case 1:
return menu_archive_load();
case 2:
return menu_archive_open();
default:
break;
}
}
else if (!strcmp(label, "info_screen"))
return menu_info_screen_iterate(action);
else if (
type == MENU_SETTINGS_CUSTOM_VIEWPORT ||
!strcmp(label, "custom_viewport_2")
)
return menu_viewport_iterate(action);
else if (type == MENU_SETTINGS_CUSTOM_BIND)
{
if (menu_input_bind_iterate(driver.menu))
menu_list_pop_stack(driver.menu->menu_list);
return 0;
}
else if (type == MENU_SETTINGS_CUSTOM_BIND_KEYBOARD)
{
if (menu_input_bind_iterate_keyboard(driver.menu))
menu_list_pop_stack(driver.menu->menu_list);
return 0;
}
menu_list_get_at_offset(driver.menu->menu_list->selection_buf,
driver.menu->selection_ptr, &path_offset, &label_offset, &type_offset);
if (driver.menu->need_refresh && action != MENU_ACTION_MESSAGE)
action = MENU_ACTION_REFRESH;
scroll_speed = (max(driver.menu->scroll_accel, 2) - 2) / 4 + 1;
switch (action)
{
case MENU_ACTION_UP:
if (driver.menu->selection_ptr >= scroll_speed)
menu_navigation_set(driver.menu,
driver.menu->selection_ptr - scroll_speed, true);
else
menu_navigation_set(driver.menu,
menu_list_get_size(driver.menu->menu_list) - 1, true);
break;
case MENU_ACTION_DOWN:
if (driver.menu->selection_ptr + scroll_speed < (menu_list_get_size(driver.menu->menu_list)))
menu_navigation_set(driver.menu,
driver.menu->selection_ptr + scroll_speed, true);
else
menu_navigation_clear(driver.menu, false);
break;
case MENU_ACTION_SCROLL_UP:
menu_navigation_descend_alphabet(driver.menu, &driver.menu->selection_ptr);
break;
case MENU_ACTION_SCROLL_DOWN:
menu_navigation_ascend_alphabet(driver.menu, &driver.menu->selection_ptr);
break;
case MENU_ACTION_CANCEL:
apply_deferred_settings();
menu_list_pop_stack(driver.menu->menu_list);
break;
case MENU_ACTION_OK:
if (cbs && cbs->action_ok)
return cbs->action_ok(path_offset, label_offset, type_offset, driver.menu->selection_ptr);
break;
case MENU_ACTION_START:
if (cbs && cbs->action_start)
return cbs->action_start(type_offset, label_offset, action);
break;
case MENU_ACTION_LEFT:
case MENU_ACTION_RIGHT:
if (cbs && cbs->action_toggle)
ret = cbs->action_toggle(type_offset, label_offset, action);
break;
case MENU_ACTION_SELECT:
menu_list_push_stack(driver.menu->menu_list, "", "info_screen",
0, driver.menu->selection_ptr);
break;
case MENU_ACTION_REFRESH:
menu_entries_deferred_push(driver.menu->menu_list->selection_buf,
driver.menu->menu_list->menu_stack);
driver.menu->need_refresh = false;
break;
case MENU_ACTION_MESSAGE:
driver.menu->msg_force = true;
break;
default:
break;
}
if (ret)
return ret;
ret = mouse_post_iterate(cbs, path_offset, label_offset, type_offset, action);
if (driver.menu_ctx && driver.menu_ctx->iterate)
driver.menu_ctx->iterate(driver.menu, action);
if (driver.video_data && driver.menu_ctx && driver.menu_ctx->render)
driver.menu_ctx->render();
/* Have to defer it so we let settings refresh. */
if (driver.menu->push_start_screen)
{
menu_list_push_stack(driver.menu->menu_list, "", "help", 0, 0);
driver.menu->push_start_screen = false;
}
return ret;
}
enum menu_entry_type menu_entry_get_type(uint32_t i)
{
rarch_setting_t *setting = NULL;
const char *path = NULL;
const char *entry_label = NULL;
const char *dir = NULL;
const char *label = NULL;
menu_list_t *menu_list = menu_list_get_ptr();
unsigned type = 0;
unsigned menu_type = 0;
menu_list_get_last_stack(menu_list, &dir,
&label, &menu_type, NULL);
menu_list_get_at_offset(menu_list->selection_buf, i, &path,
&entry_label, &type, NULL);
setting = menu_entry_get_setting(i);
// XXX Really a special kind of ST_ACTION, but this should be
// changed
if (menu_setting_is_of_path_type(setting))
return MENU_ENTRY_PATH;
if (menu_setting_is_of_enum_type(setting))
return MENU_ENTRY_ENUM;
if (setting)
{
switch (setting->type)
{
case ST_BOOL:
return MENU_ENTRY_BOOL;
case ST_BIND:
return MENU_ENTRY_BIND;
case ST_INT:
return MENU_ENTRY_INT;
case ST_UINT:
return MENU_ENTRY_UINT;
case ST_FLOAT:
return MENU_ENTRY_FLOAT;
case ST_PATH:
return MENU_ENTRY_PATH;
case ST_DIR:
return MENU_ENTRY_DIR;
case ST_STRING:
return MENU_ENTRY_STRING;
case ST_HEX:
return MENU_ENTRY_HEX;
case ST_NONE:
case ST_ACTION:
case ST_GROUP:
case ST_SUB_GROUP:
case ST_END_GROUP:
case ST_END_SUB_GROUP:
break;
}
}
return MENU_ENTRY_ACTION;
}
static void rmenu_render(void)
{
size_t begin, end;
struct font_params font_parms;
menu_handle_t *menu = (menu_handle_t*)driver.menu;
if (!menu)
return;
if (!render_normal)
{
render_normal = true;
return;
}
if (menu->need_refresh && g_extern.is_menu
&& !menu->msg_force)
return;
if (!driver.menu->menu_list->selection_buf)
return;
begin = (menu->selection_ptr >= (ENTRIES_HEIGHT / 2)) ?
(menu->selection_ptr - (ENTRIES_HEIGHT / 2)) : 0;
end = ((menu->selection_ptr + ENTRIES_HEIGHT) <=
menu_list_get_size(driver.menu->menu_list)) ?
menu->selection_ptr + ENTRIES_HEIGHT :
menu_list_get_size(driver.menu->menu_list);
if (menu_list_get_size(driver.menu->menu_list) <= ENTRIES_HEIGHT)
begin = 0;
if (end - begin > ENTRIES_HEIGHT)
end = begin + ENTRIES_HEIGHT;
rmenu_render_background();
char title[256];
const char *dir = NULL;
const char *label = NULL;
unsigned menu_type = 0;
menu_list_get_last_stack(driver.menu->menu_list, &dir, &label, &menu_type);
get_title(label, dir, menu_type, title, sizeof(title));
char title_buf[256];
menu_ticker_line(title_buf, RMENU_TERM_WIDTH,
g_extern.frame_count / 15, title, true);
font_parms.x = POSITION_EDGE_MIN + POSITION_OFFSET;
font_parms.y = POSITION_EDGE_MIN + POSITION_RENDER_OFFSET
- (POSITION_OFFSET*2);
font_parms.scale = FONT_SIZE_NORMAL;
font_parms.color = WHITE;
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
title_buf, &font_parms);
char title_msg[64];
const char *core_name = g_extern.menu.info.library_name;
if (!core_name)
core_name = g_extern.system.info.library_name;
if (!core_name)
core_name = "No Core";
const char *core_version = g_extern.menu.info.library_version;
if (!core_version)
core_version = g_extern.system.info.library_version;
if (!core_version)
core_version = "";
font_parms.x = POSITION_EDGE_MIN + POSITION_OFFSET;
font_parms.y = POSITION_EDGE_MAX - (POSITION_OFFSET*2);
font_parms.scale = FONT_SIZE_NORMAL;
font_parms.color = WHITE;
snprintf(title_msg, sizeof(title_msg), "%s - %s %s",
PACKAGE_VERSION, core_name, core_version);
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
title_msg, &font_parms);
size_t i, j;
j = 0;
for (i = begin; i < end; i++, j++)
{
char message[PATH_MAX], type_str[PATH_MAX],
entry_title_buf[PATH_MAX], type_str_buf[PATH_MAX],
path_buf[PATH_MAX];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
bool selected = false;
menu_list_get_at_offset(menu->menu_list->selection_buf, i,
&path, &entry_label, &type);
disp_set_label(menu->menu_list->selection_buf, &w, type, i, label,
type_str, sizeof(type_str),
entry_label, path,
path_buf, sizeof(path_buf));
selected = (i == driver.menu->selection_ptr);
menu_ticker_line(entry_title_buf, RMENU_TERM_WIDTH - (w + 1 + 2),
g_extern.frame_count / 15, path, selected);
menu_ticker_line(type_str_buf, w, g_extern.frame_count / 15,
type_str, selected);
snprintf(message, sizeof(message), "%c %s",
selected ? '>' : ' ', entry_title_buf);
//blit_line(menu, x, y, message, selected);
font_parms.x = POSITION_EDGE_MIN + POSITION_OFFSET;
font_parms.y = POSITION_EDGE_MIN + POSITION_RENDER_OFFSET
+ (POSITION_OFFSET * j);
font_parms.scale = FONT_SIZE_NORMAL;
font_parms.color = WHITE;
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
message, &font_parms);
font_parms.x = POSITION_EDGE_CENTER + POSITION_OFFSET;
if (driver.video_data && driver.video_poke
&& driver.video_poke->set_osd_msg)
driver.video_poke->set_osd_msg(driver.video_data,
type_str_buf, &font_parms);
}
}
static int action_iterate_main(const char *label, unsigned action)
{
int ret = 0;
unsigned type_offset = 0;
const char *label_offset = NULL;
const char *path_offset = NULL;
menu_file_list_cbs_t *cbs = NULL;
menu_handle_t *menu = menu_driver_get_ptr();
global_t *global = global_get_ptr();
if (!menu)
return 0;
cbs = (menu_file_list_cbs_t*)
menu_list_get_actiondata_at_offset(menu->menu_list->selection_buf,
menu->navigation.selection_ptr);
menu_list_get_at_offset(menu->menu_list->selection_buf,
menu->navigation.selection_ptr, &path_offset, &label_offset, &type_offset);
if (!strcmp(label, "help"))
return action_iterate_help(label, action);
else if (!strcmp(label, "info_screen"))
return action_iterate_info(label, action);
else if (!strcmp(label, "load_open_zip"))
return action_iterate_load_open_zip(label, action);
else if (!strcmp(label, "message"))
return action_iterate_message(label, action);
else if (
!strcmp(label, "custom_viewport_1") ||
!strcmp(label, "custom_viewport_2")
)
return action_iterate_menu_viewport(label, action);
else if (
!strcmp(label, "custom_bind") ||
!strcmp(label, "custom_bind_all") ||
!strcmp(label, "custom_bind_defaults")
)
{
if (global->menu.bind_mode_keyboard)
return action_iterate_custom_bind_keyboard(label, action);
else
return action_iterate_custom_bind(label, action);
}
if (menu->need_refresh && !menu->nonblocking_refresh && action != MENU_ACTION_MESSAGE)
action = MENU_ACTION_REFRESH;
switch (action)
{
case MENU_ACTION_UP:
case MENU_ACTION_DOWN:
if (cbs && cbs->action_up_or_down)
ret = cbs->action_up_or_down(type_offset, label_offset, action);
break;
case MENU_ACTION_SCROLL_UP:
menu_navigation_descend_alphabet(&menu->navigation, &menu->navigation.selection_ptr);
break;
case MENU_ACTION_SCROLL_DOWN:
menu_navigation_ascend_alphabet(&menu->navigation, &menu->navigation.selection_ptr);
break;
case MENU_ACTION_CANCEL:
if (cbs && cbs->action_cancel)
return cbs->action_cancel(path_offset, label_offset, type_offset, menu->navigation.selection_ptr);
break;
case MENU_ACTION_OK:
if (cbs && cbs->action_ok)
return cbs->action_ok(path_offset, label_offset, type_offset, menu->navigation.selection_ptr);
break;
case MENU_ACTION_START:
if (cbs && cbs->action_start)
return cbs->action_start(type_offset, label_offset, action);
break;
case MENU_ACTION_LEFT:
case MENU_ACTION_RIGHT:
if (cbs && cbs->action_toggle)
ret = cbs->action_toggle(type_offset, label_offset, action, false);
break;
case MENU_ACTION_SELECT:
if (cbs && cbs->action_select)
ret = cbs->action_select(type_offset, label_offset, action);
break;
case MENU_ACTION_REFRESH:
if (cbs && cbs->action_refresh)
ret = cbs->action_refresh(menu->menu_list->selection_buf,
menu->menu_list->menu_stack);
break;
case MENU_ACTION_MESSAGE:
menu->msg_force = true;
break;
case MENU_ACTION_SEARCH:
menu_input_search_start();
break;
case MENU_ACTION_TEST:
#if 0
menu->rdl = database_info_write_rdl_init("/home/twinaphex/roms");
if (!menu->rdl)
return -1;
#endif
break;
default:
break;
}
if (ret)
return ret;
ret = mouse_post_iterate(cbs, path_offset, label_offset, type_offset, action);
ret |= pointer_post_iterate(cbs, path_offset, label_offset, type_offset, action);
menu_driver_render();
/* Have to defer it so we let settings refresh. */
if (menu->push_start_screen)
{
menu_list_push_stack(menu->menu_list, "", "help", 0, 0);
menu->push_start_screen = false;
}
return ret;
}
static void glui_frame(void)
{
unsigned x, y;
size_t i;
char title[PATH_MAX], title_buf[PATH_MAX],
title_msg[PATH_MAX];
const char *dir = NULL;
const char *label = NULL;
unsigned menu_type = 0;
size_t end;
gl_t *gl = (gl_t*)driver_video_resolve(NULL);
glui_handle_t *glui = NULL;
if (!driver.menu || !gl)
return;
glui = (glui_handle_t*)driver.menu->userdata;
if (!glui)
return;
if (driver.menu->need_refresh
&& g_extern.is_menu
&& !driver.menu->msg_force)
return;
glui->line_height = g_settings.video.font_size * 4 / 3;
glui->glyph_width = glui->line_height / 2;
glui->margin = gl->win_width / 20 ;
glui->term_width = (gl->win_width - glui->margin * 2) / glui->glyph_width;
glui->term_height = (gl->win_height - glui->margin * 2) / glui->line_height - 2;
driver.menu->mouse.ptr = (driver.menu->mouse.y - glui->margin) /
glui->line_height - 2 + driver.menu->begin;
glViewport(0, 0, gl->win_width, gl->win_height);
if (driver.menu->mouse.wheeldown && driver.menu->begin
< menu_list_get_size(driver.menu->menu_list) - glui->term_height)
driver.menu->begin++;
if (driver.menu->mouse.wheelup && driver.menu->begin > 0)
driver.menu->begin--;
/* Do not scroll if all items are visible. */
if (menu_list_get_size(driver.menu->menu_list) <= glui->term_height)
driver.menu->begin = 0;
end = (driver.menu->begin + glui->term_height <=
menu_list_get_size(driver.menu->menu_list)) ?
driver.menu->begin + glui->term_height :
menu_list_get_size(driver.menu->menu_list);
glui_render_background(false);
menu_list_get_last_stack(driver.menu->menu_list, &dir, &label, &menu_type);
get_title(label, dir, menu_type, title, sizeof(title));
menu_ticker_line(title_buf, glui->term_width - 3,
g_extern.frame_count / glui->margin, title, true);
glui_blit_line(glui->margin * 2, glui->margin + glui->line_height,
title_buf, true);
const char *core_name = g_extern.menu.info.library_name;
if (!core_name)
core_name = g_extern.system.info.library_name;
if (!core_name)
core_name = "No Core";
const char *core_version = g_extern.menu.info.library_version;
if (!core_version)
core_version = g_extern.system.info.library_version;
if (!core_version)
core_version = "";
snprintf(title_msg, sizeof(title_msg), "%s - %s %s", PACKAGE_VERSION,
core_name, core_version);
glui_blit_line(
glui->margin * 2,
glui->margin + glui->term_height * glui->line_height
+ glui->line_height * 2, title_msg, true);
x = glui->margin;
y = glui->margin + glui->line_height * 2;
for (i = driver.menu->begin; i < end; i++, y += glui->line_height)
{
char message[PATH_MAX], type_str[PATH_MAX],
entry_title_buf[PATH_MAX], type_str_buf[PATH_MAX],
path_buf[PATH_MAX];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
bool selected = false;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf, i, &path,
&entry_label, &type);
rarch_setting_t *setting = (rarch_setting_t*)setting_data_find_setting(
driver.menu->list_settings,
driver.menu->menu_list->selection_buf->list[i].label);
(void)setting;
disp_set_label(driver.menu->menu_list->selection_buf, &w, type, i, label,
type_str, sizeof(type_str),
entry_label, path,
path_buf, sizeof(path_buf));
selected = (i == driver.menu->selection_ptr);
menu_ticker_line(entry_title_buf, glui->term_width - (w + 1 + 2),
g_extern.frame_count / glui->margin, path_buf, selected);
menu_ticker_line(type_str_buf, w,
g_extern.frame_count / glui->margin, type_str, selected);
strlcpy(message, entry_title_buf, sizeof(message));
glui_blit_line(x, y, message, selected);
glui_blit_line(gl->win_width - glui->glyph_width * w - glui->margin ,
y, type_str_buf, selected);
}
#ifdef GEKKO
const char *message_queue;
if (driver.menu->msg_force)
{
message_queue = msg_queue_pull(g_extern.msg_queue);
driver.menu->msg_force = false;
}
else
message_queue = driver.current_msg;
glui_render_messagebox(message_queue);
#endif
if (driver.menu->keyboard.display)
{
char msg[PATH_MAX];
const char *str = *driver.menu->keyboard.buffer;
if (!str)
str = "";
glui_render_background(true);
snprintf(msg, sizeof(msg), "%s\n%s", driver.menu->keyboard.label, str);
glui_render_messagebox(msg);
}
if (glui->box_message[0] != '\0')
{
glui_render_background(true);
glui_render_messagebox(glui->box_message);
glui->box_message[0] = '\0';
}
if (driver.menu->mouse.enable)
glui_draw_cursor(driver.menu->mouse.x, driver.menu->mouse.y);
gl_set_viewport(gl, gl->win_width, gl->win_height, false, false);
}
static void rmenu_xui_render(void)
{
size_t end, i;
char title[PATH_MAX_LENGTH];
const char *dir = NULL, *label = NULL;
unsigned menu_type = 0;
menu_handle_t *menu = menu_driver_resolve();
if (!menu)
return;
if (menu->need_refresh &&
g_runloop.is_menu && !menu->msg_force)
return;
g_runloop.frames.video.current.menu.animation.is_active = false;
g_runloop.frames.video.current.menu.label.is_updated = false;
g_runloop.frames.video.current.menu.framebuf.dirty = false;
rmenu_xui_render_background();
menu_list_get_last_stack(menu->menu_list, &dir, &label, &menu_type);
if (XuiHandleIsValid(m_menutitle))
{
get_title(label, dir, menu_type, title, sizeof(title));
mbstowcs(strw_buffer, title, sizeof(strw_buffer) / sizeof(wchar_t));
XuiTextElementSetText(m_menutitle, strw_buffer);
menu_animation_ticker_line(title, RXUI_TERM_WIDTH - 3, g_runloop.frames.video.count / 15, title, true);
}
if (XuiHandleIsValid(m_menutitle))
{
const char *core_version = NULL;
const char *core_name = g_extern.menu.info.library_name;
if (!core_name)
core_name = g_extern.system.info.library_name;
if (!core_name)
core_name = "No Core";
core_version = g_extern.menu.info.library_version;
if (!core_version)
core_version = g_extern.system.info.library_version;
if (!core_version)
core_version = "";
snprintf(title, sizeof(title), "%s - %s %s",
PACKAGE_VERSION, core_name, core_version);
mbstowcs(strw_buffer, title, sizeof(strw_buffer) / sizeof(wchar_t));
XuiTextElementSetText(m_menutitlebottom, strw_buffer);
}
end = menu_list_get_size(menu->menu_list);
for (i = 0; i < end; i++)
{
wchar_t msg_left[PATH_MAX_LENGTH], msg_right[PATH_MAX_LENGTH];
char type_str[PATH_MAX_LENGTH], path_buf[PATH_MAX_LENGTH];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
menu_file_list_cbs_t *cbs = NULL;
menu_list_get_at_offset(menu->menu_list->selection_buf, i, &path,
&entry_label, &type);
cbs = (menu_file_list_cbs_t*)
menu_list_get_actiondata_at_offset(menu->menu_list->selection_buf,
i);
if (cbs && cbs->action_get_representation)
cbs->action_get_representation(menu->menu_list->selection_buf,
&w, type, i, label,
type_str, sizeof(type_str),
entry_label, path,
path_buf, sizeof(path_buf));
mbstowcs(msg_left, path_buf, sizeof(msg_left) / sizeof(wchar_t));
mbstowcs(msg_right, type_str, sizeof(msg_right) / sizeof(wchar_t));
rmenu_xui_set_list_text(i, msg_left, msg_right);
}
XuiListSetCurSelVisible(m_menulist, menu->navigation.selection_ptr);
if (menu->keyboard.display)
{
char msg[1024];
const char *str = *menu->keyboard.buffer;
if (!str)
str = "";
snprintf(msg, sizeof(msg), "%s\n%s", menu->keyboard.label, str);
rmenu_xui_render_messagebox(msg);
}
}
int menu_entries_parse_list(
file_list_t *list, file_list_t *menu_list,
const char *dir, const char *label, unsigned type,
unsigned default_type_plain, const char *exts,
rarch_setting_t *setting)
{
size_t i, list_size;
bool path_is_compressed, push_dir;
int device = 0;
struct string_list *str_list = NULL;
settings_t *settings = config_get_ptr();
global_t *global = global_get_ptr();
(void)device;
if (!list || !menu_list)
return -1;
menu_list_clear(list);
if (!*dir)
{
menu_entries_parse_drive_list(list);
menu_driver_populate_entries(dir, label, type);
return 0;
}
#if defined(GEKKO) && defined(HW_RVL)
slock_lock(gx_device_mutex);
device = gx_get_device_from_path(dir);
if (device != -1 && !gx_devices[device].mounted &&
gx_devices[device].interface->isInserted())
fatMountSimple(gx_devices[device].name, gx_devices[device].interface);
slock_unlock(gx_device_mutex);
#endif
path_is_compressed = path_is_compressed_file(dir);
push_dir = (setting && setting->browser_selection_type == ST_DIR);
if (path_is_compressed)
str_list = compressed_file_list_new(dir,exts);
else
str_list = dir_list_new(dir,
settings->menu.navigation.browser.filter.supported_extensions_enable
? exts : NULL, true);
if (push_dir)
menu_list_push(list, "<Use this directory>", "",
MENU_FILE_USE_DIRECTORY, 0);
if (!str_list)
return -1;
dir_list_sort(str_list, true);
list_size = str_list->size;
for (i = 0; i < str_list->size; i++)
{
bool is_dir;
const char *path = NULL;
menu_file_type_t file_type = MENU_FILE_NONE;
switch (str_list->elems[i].attr.i)
{
case RARCH_DIRECTORY:
file_type = MENU_FILE_DIRECTORY;
break;
case RARCH_COMPRESSED_ARCHIVE:
file_type = MENU_FILE_CARCHIVE;
break;
case RARCH_COMPRESSED_FILE_IN_ARCHIVE:
file_type = MENU_FILE_IN_CARCHIVE;
break;
case RARCH_PLAIN_FILE:
default:
if (!strcmp(label, "detect_core_list"))
{
if (path_is_compressed_file(str_list->elems[i].data))
{
/* in case of deferred_core_list we have to interpret
* every archive as an archive to disallow instant loading
*/
file_type = MENU_FILE_CARCHIVE;
break;
}
}
file_type = (menu_file_type_t)default_type_plain;
break;
}
is_dir = (file_type == MENU_FILE_DIRECTORY);
if (push_dir && !is_dir)
continue;
/* Need to preserve slash first time. */
path = str_list->elems[i].data;
if (*dir && !path_is_compressed)
path = path_basename(path);
#ifdef HAVE_LIBRETRO_MANAGEMENT
#ifdef RARCH_CONSOLE
if (!strcmp(label, "core_list") && (is_dir ||
strcasecmp(path, SALAMANDER_FILE) == 0))
continue;
#endif
#endif
/* Push type further down in the chain.
* Needed for shader manager currently. */
if (!strcmp(label, "core_list"))
{
/* Compressed cores are unsupported */
if (file_type == MENU_FILE_CARCHIVE)
continue;
menu_list_push(list, path, "",
is_dir ? MENU_FILE_DIRECTORY : MENU_FILE_CORE, 0);
}
else
menu_list_push(list, path, "",
file_type, 0);
}
string_list_free(str_list);
if (!strcmp(label, "core_list"))
{
driver_t *driver = driver_get_ptr();
menu_list_get_last_stack(driver->menu->menu_list, &dir, NULL, NULL);
list_size = file_list_get_size(list);
for (i = 0; i < list_size; i++)
{
char core_path[PATH_MAX_LENGTH], display_name[PATH_MAX_LENGTH];
const char *path = NULL;
menu_list_get_at_offset(list, i, &path, NULL, &type);
if (type != MENU_FILE_CORE)
continue;
fill_pathname_join(core_path, dir, path, sizeof(core_path));
if (global->core_info &&
core_info_list_get_display_name(global->core_info,
core_path, display_name, sizeof(display_name)))
menu_list_set_alt_at_offset(list, i, display_name);
}
menu_list_sort_on_alt(list);
}
menu_list_populate_generic(list, dir, label, type);
return 0;
}
static void rmenu_render(void)
{
size_t begin, end, i, j;
struct font_params font_parms;
char title[256], title_buf[256];
char title_msg[64];
const char *dir = NULL;
const char *label = NULL;
const char *core_name = NULL;
const char *core_version = NULL;
unsigned menu_type = 0;
menu_handle_t *menu = menu_driver_get_ptr();
global_t *global = global_get_ptr();
runloop_t *runloop = rarch_main_get_ptr();
if (!menu)
return;
if (!render_normal)
{
render_normal = true;
return;
}
if (menu->need_refresh && runloop->is_menu
&& !menu->msg_force)
return;
runloop->frames.video.current.menu.animation.is_active = false;
runloop->frames.video.current.menu.label.is_updated = false;
runloop->frames.video.current.menu.framebuf.dirty = false;
if (!menu->menu_list->selection_buf)
return;
begin = (menu->navigation.selection_ptr >= (ENTRIES_HEIGHT / 2)) ?
(menu->navigation.selection_ptr - (ENTRIES_HEIGHT / 2)) : 0;
end = ((menu->navigation.selection_ptr + ENTRIES_HEIGHT) <=
menu_list_get_size(menu->menu_list)) ?
menu->navigation.selection_ptr + ENTRIES_HEIGHT :
menu_list_get_size(menu->menu_list);
if (menu_list_get_size(menu->menu_list) <= ENTRIES_HEIGHT)
begin = 0;
if (end - begin > ENTRIES_HEIGHT)
end = begin + ENTRIES_HEIGHT;
rmenu_render_background();
menu_list_get_last_stack(menu->menu_list, &dir, &label, &menu_type);
get_title(label, dir, menu_type, title, sizeof(title));
menu_animation_ticker_line(title_buf, RMENU_TERM_WIDTH,
runloop->frames.video.count / 15, title, true);
font_parms.x = POSITION_EDGE_MIN + POSITION_OFFSET;
font_parms.y = POSITION_EDGE_MIN + POSITION_RENDER_OFFSET
- (POSITION_OFFSET*2);
font_parms.scale = FONT_SIZE_NORMAL;
font_parms.color = WHITE;
video_driver_set_osd_msg(title_buf, &font_parms, NULL);
core_name = global->menu.info.library_name;
if (!core_name)
core_name = global->system.info.library_name;
if (!core_name)
core_name = "No Core";
core_version = global->menu.info.library_version;
if (!core_version)
core_version = global->system.info.library_version;
if (!core_version)
core_version = "";
font_parms.x = POSITION_EDGE_MIN + POSITION_OFFSET;
font_parms.y = POSITION_EDGE_MAX - (POSITION_OFFSET*2);
font_parms.scale = FONT_SIZE_NORMAL;
font_parms.color = WHITE;
snprintf(title_msg, sizeof(title_msg), "%s - %s %s",
PACKAGE_VERSION, core_name, core_version);
video_driver_set_osd_msg(title_msg, &font_parms, NULL);
j = 0;
for (i = begin; i < end; i++, j++)
{
char message[PATH_MAX_LENGTH], type_str[PATH_MAX_LENGTH],
entry_title_buf[PATH_MAX_LENGTH], type_str_buf[PATH_MAX_LENGTH],
path_buf[PATH_MAX_LENGTH];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
bool selected = false;
menu_file_list_cbs_t *cbs = NULL;
menu_list_get_at_offset(menu->menu_list->selection_buf, i,
&path, &entry_label, &type);
cbs = (menu_file_list_cbs_t*)
menu_list_get_actiondata_at_offset(menu->menu_list->selection_buf,
i);
if (cbs && cbs->action_get_representation)
cbs->action_get_representation(menu->menu_list->selection_buf,
&w, type, i, label,
type_str, sizeof(type_str),
entry_label, path,
path_buf, sizeof(path_buf));
selected = (i == menu->navigation.selection_ptr);
menu_animation_ticker_line(entry_title_buf, RMENU_TERM_WIDTH - (w + 1 + 2),
runloop->frames.video.count / 15, path, selected);
menu_animation_ticker_line(type_str_buf, w, runloop->frames.video.count / 15,
type_str, selected);
snprintf(message, sizeof(message), "%c %s",
selected ? '>' : ' ', entry_title_buf);
#if 0
blit_line(x, y, message, selected);
#endif
font_parms.x = POSITION_EDGE_MIN + POSITION_OFFSET;
font_parms.y = POSITION_EDGE_MIN + POSITION_RENDER_OFFSET
+ (POSITION_OFFSET * j);
font_parms.scale = FONT_SIZE_NORMAL;
font_parms.color = WHITE;
video_driver_set_osd_msg(message, &font_parms, NULL);
font_parms.x = POSITION_EDGE_CENTER + POSITION_OFFSET;
video_driver_set_osd_msg(type_str_buf, &font_parms, NULL);
}
}
static void rmenu_xui_render(void)
{
size_t begin, end;
char title[256];
const char *dir = NULL;
const char *label = NULL;
unsigned menu_type = 0;
if (!driver.menu || driver.menu->need_refresh &&
g_extern.is_menu && !driver.menu->msg_force)
return;
begin = driver.menu->selection_ptr;
end = menu_list_get_size(driver.menu->menu_list);
rmenu_xui_render_background();
menu_list_get_last_stack(driver.menu->menu_list, &dir,
&label, &menu_type);
get_title(label, dir, menu_type,
title, sizeof(title));
mbstowcs(strw_buffer, title, sizeof(strw_buffer) / sizeof(wchar_t));
XuiTextElementSetText(m_menutitle, strw_buffer);
char title_buf[256];
menu_ticker_line(title_buf, RXUI_TERM_WIDTH - 3,
g_extern.frame_count / 15, title, true);
blit_line(RXUI_TERM_START_X + 15, 15, title_buf, true);
char title_msg[64];
const char *core_name = g_extern.menu.info.library_name;
if (!core_name)
core_name = g_extern.system.info.library_name;
if (!core_name)
core_name = "No Core";
const char *core_version = g_extern.menu.info.library_version;
if (!core_version)
core_version = g_extern.system.info.library_version;
if (!core_version)
core_version = "";
snprintf(title_msg, sizeof(title_msg), "%s - %s %s",
PACKAGE_VERSION, core_name, core_version);
blit_line(RXUI_TERM_START_X + 15,
(RXUI_TERM_HEIGHT * FONT_HEIGHT_STRIDE) + RXUI_TERM_START_Y + 2,
title_msg, true);
unsigned x, y;
size_t i;
x = RXUI_TERM_START_X;
y = RXUI_TERM_START_Y;
for (i = begin; i < end; i++/*, y += FONT_HEIGHT_STRIDE */)
{
char message[PATH_MAX], type_str[PATH_MAX],
entry_title_buf[PATH_MAX], type_str_buf[PATH_MAX],
path_buf[PATH_MAX];
const char *path = NULL, *entry_label = NULL;
unsigned type = 0, w = 0;
bool selected = false;
menu_list_get_at_offset(driver.menu->menu_list->selection_buf, i, &path,
&entry_label, &type);
disp_set_label(driver.menu->menu_list->selection_buf,
&w, type, i, label,
type_str, sizeof(type_str),
entry_label, path,
path_buf, sizeof(path_buf));
selected = (i == driver.menu->selection_ptr);
#if 0
if ((type == MENU_FILE_PLAIN || type == MENU_FILE_DIRECTORY))
menu_ticker_line(entry_title_buf, RXUI_TERM_WIDTH - (w + 1 + 2), g_extern.frame_count / 15, path, selected);
else
menu_ticker_line(type_str_buf, w, g_extern.frame_count / 15, type_str, selected);
#endif
snprintf(message, sizeof(message), "%s : %s",
entry_title_buf,
type_str_buf);
wchar_t msg_w[256];
mbstowcs(msg_w, message, sizeof(msg_w) / sizeof(wchar_t));
XuiListSetText(m_menulist, i, msg_w);
blit_line(x, y, message, i);
}
if (driver.menu->keyboard.display)
{
char msg[1024];
const char *str = *driver.menu->keyboard.buffer;
if (!str)
str = "";
snprintf(msg, sizeof(msg), "%s\n%s", driver.menu->keyboard.label, str);
rmenu_xui_render_messagebox(msg);
}
}
