static bool zarch_menu_init_list(void *data)
{
menu_displaylist_info_t info = {0};
file_list_t *menu_stack = menu_entries_get_menu_stack_ptr(0);
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
strlcpy(info.label,
menu_hash_to_str(MENU_VALUE_HISTORY_TAB), sizeof(info.label));
menu_entries_push(menu_stack,
info.path, info.label, info.type, info.flags, 0);
event_cmd_ctl(EVENT_CMD_HISTORY_INIT, NULL);
info.list = selection_buf;
if (menu_displaylist_ctl(DISPLAYLIST_HISTORY, &info))
{
info.need_push = true;
return menu_displaylist_ctl(DISPLAYLIST_PROCESS, &info);
}
return false;
}
int deferred_push_content_list(void *data, void *userdata, const char *path,
const char *label, unsigned type)
{
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
return action_refresh_default((file_list_t*)data, selection_buf);
}
static int action_right_mainmenu(unsigned type, const char *label,
bool wraparound)
{
menu_ctx_list_t list_info;
size_t selection = 0;
menu_file_list_cbs_t *cbs = NULL;
unsigned push_list = 0;
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
file_list_t *menu_stack = menu_entries_get_menu_stack_ptr(0);
settings_t *settings = config_get_ptr();
unsigned action = MENU_ACTION_RIGHT;
menu_driver_ctl(RARCH_MENU_CTL_LIST_GET_SELECTION, &list_info);
list_info.type = MENU_LIST_PLAIN;
menu_driver_ctl(RARCH_MENU_CTL_LIST_GET_SIZE, &list_info);
if (list_info.size == 1)
{
menu_ctx_list_t list_horiz_info;
menu_ctx_list_t list_tabs_info;
list_horiz_info.type = MENU_LIST_HORIZONTAL;
list_tabs_info.type = MENU_LIST_TABS;
menu_driver_ctl(RARCH_MENU_CTL_LIST_GET_SIZE, &list_horiz_info);
menu_driver_ctl(RARCH_MENU_CTL_LIST_GET_SIZE, &list_tabs_info);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
if ((list_info.selection != (list_horiz_info.size + list_tabs_info.size))
|| settings->menu.navigation.wraparound.enable)
push_list = 1;
}
else
push_list = 2;
menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection);
cbs = menu_entries_get_actiondata_at_offset(selection_buf, selection);
switch (push_list)
{
case 1:
{
menu_ctx_list_t list_info;
list_info.type = MENU_LIST_HORIZONTAL;
list_info.action = action;
menu_driver_ctl(RARCH_MENU_CTL_LIST_CACHE, &list_info);
if (cbs && cbs->action_content_list_switch)
return cbs->action_content_list_switch(selection_buf, menu_stack,
"", "", 0);
}
break;
case 2:
action_right_scroll(0, "", false);
break;
case 0:
default:
break;
}
return 0;
}
static void rmenu_render(void)
{
bool msg_force;
size_t begin, end, i, j, selection;
struct font_params font_parms = {0};
char title[256] = {0};
char title_buf[256] = {0};
char title_msg[64] = {0};
menu_handle_t *menu = menu_driver_get_ptr();
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr();
uint64_t *frame_count = video_driver_get_frame_count();
size_t entries_end = menu_entries_get_end();
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return;
if (!menu)
return;
if (!render_normal)
{
render_normal = true;
return;
}
menu_display_ctl(MENU_DISPLAY_CTL_MSG_FORCE, &msg_force);
if (menu_entries_needs_refresh() && menu_driver_alive()
&& !msg_force)
return;
menu_display_fb_unset_dirty();
menu_animation_clear_active();
if (!selection_buf)
return;
begin = (selection >= (ENTRIES_HEIGHT / 2)) ?
(selection - (ENTRIES_HEIGHT / 2)) : 0;
end = ((selection + ENTRIES_HEIGHT) <= entries_end)
? selection + ENTRIES_HEIGHT : entries_end;
if (entries_end <= ENTRIES_HEIGHT)
begin = 0;
if (end - begin > ENTRIES_HEIGHT)
end = begin + ENTRIES_HEIGHT;
menu_entries_get_title(title, sizeof(title));
menu_animation_ticker_str(title_buf, RMENU_TERM_WIDTH,
*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;
video_driver_set_osd_msg(title_buf, &font_parms, NULL);
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;
menu_entries_get_core_title(title_msg, sizeof(title_msg));
video_driver_set_osd_msg(title_msg, &font_parms, NULL);
j = 0;
for (i = begin; i < end; i++, j++)
{
char entry_path[PATH_MAX_LENGTH] = {0};
char entry_value[PATH_MAX_LENGTH] = {0};
char message[PATH_MAX_LENGTH] = {0};
char entry_title_buf[PATH_MAX_LENGTH] = {0};
char type_str_buf[PATH_MAX_LENGTH] = {0};
unsigned entry_spacing = menu_entry_get_spacing(i);
bool entry_selected = menu_entry_is_currently_selected(i);
menu_entry_get_value(i, entry_value, sizeof(entry_value));
menu_entry_get_path(i, entry_path, sizeof(entry_path));
menu_animation_ticker_str(entry_title_buf, RMENU_TERM_WIDTH - (entry_spacing + 1 + 2),
*frame_count / 15, entry_path, entry_selected);
menu_animation_ticker_str(type_str_buf, entry_spacing,
*frame_count / 15, entry_value, entry_selected);
snprintf(message, sizeof(message), "%c %s",
entry_selected ? '>' : ' ', entry_title_buf);
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 int action_select_default(const char *path, const char *label, unsigned type,
size_t idx)
{
menu_entry_t entry;
int ret = 0;
enum menu_action action = MENU_ACTION_NOOP;
menu_file_list_cbs_t *cbs = NULL;
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
entry.path[0] = '\0';
entry.label[0] = '\0';
entry.sublabel[0] = '\0';
entry.value[0] = '\0';
entry.rich_label[0] = '\0';
entry.enum_idx = MSG_UNKNOWN;
entry.entry_idx = 0;
entry.idx = 0;
entry.type = 0;
entry.spacing = 0;
menu_entry_get(&entry, 0, idx, NULL, false);
cbs = menu_entries_get_actiondata_at_offset(selection_buf, idx);
if (!cbs)
return -1;
if (cbs->setting)
{
switch (setting_get_type(cbs->setting))
{
case ST_BOOL:
case ST_INT:
case ST_UINT:
case ST_FLOAT:
action = MENU_ACTION_RIGHT;
break;
case ST_PATH:
case ST_DIR:
case ST_ACTION:
case ST_STRING:
case ST_HEX:
case ST_BIND:
action = MENU_ACTION_OK;
break;
default:
break;
}
}
if (action == MENU_ACTION_NOOP)
{
if (cbs->action_ok)
action = MENU_ACTION_OK;
else
{
if (cbs->action_start)
action = MENU_ACTION_START;
if (cbs->action_right)
action = MENU_ACTION_RIGHT;
}
}
if (action != MENU_ACTION_NOOP)
ret = menu_entry_action(&entry, idx, action);
task_queue_ctl(TASK_QUEUE_CTL_CHECK, NULL);
return ret;
}
int menu_entry_action(menu_entry_t *entry, unsigned i, enum menu_action action)
{
int ret = 0;
file_list_t *selection_buf =
menu_entries_get_selection_buf_ptr(0);
menu_file_list_cbs_t *cbs =
menu_entries_get_actiondata_at_offset(selection_buf, i);
switch (action)
{
case MENU_ACTION_UP:
if (cbs && cbs->action_up)
ret = cbs->action_up(entry->type, entry->label);
break;
case MENU_ACTION_DOWN:
if (cbs && cbs->action_down)
ret = cbs->action_down(entry->type, entry->label);
break;
case MENU_ACTION_SCROLL_UP:
menu_navigation_ctl(MENU_NAVIGATION_CTL_DESCEND_ALPHABET, NULL);
break;
case MENU_ACTION_SCROLL_DOWN:
menu_navigation_ctl(MENU_NAVIGATION_CTL_ASCEND_ALPHABET, NULL);
break;
case MENU_ACTION_CANCEL:
if (cbs && cbs->action_cancel)
ret = cbs->action_cancel(entry->path,
entry->label, entry->type, i);
break;
case MENU_ACTION_OK:
if (cbs && cbs->action_ok)
ret = cbs->action_ok(entry->path,
entry->label, entry->type, i, entry->entry_idx);
break;
case MENU_ACTION_START:
if (cbs && cbs->action_start)
ret = cbs->action_start(entry->type, entry->label);
break;
case MENU_ACTION_LEFT:
if (cbs && cbs->action_left)
ret = cbs->action_left(entry->type, entry->label, false);
break;
case MENU_ACTION_RIGHT:
if (cbs && cbs->action_right)
ret = cbs->action_right(entry->type, entry->label, false);
break;
case MENU_ACTION_INFO:
if (cbs && cbs->action_info)
ret = cbs->action_info(entry->type, entry->label);
break;
case MENU_ACTION_SELECT:
if (cbs && cbs->action_select)
ret = cbs->action_select(entry->path,
entry->label, entry->type, i);
break;
case MENU_ACTION_SEARCH:
menu_input_ctl(MENU_INPUT_CTL_SEARCH_START, NULL);
break;
case MENU_ACTION_SCAN:
if (cbs && cbs->action_scan)
ret = cbs->action_scan(entry->path,
entry->label, entry->type, i);
break;
default:
break;
}
cbs = menu_entries_get_actiondata_at_offset(selection_buf, i);
if (menu_entries_ctl(MENU_ENTRIES_CTL_NEEDS_REFRESH, NULL))
{
if (cbs && cbs->action_refresh)
{
bool refresh = false;
file_list_t *menu_stack = menu_entries_get_menu_stack_ptr(0);
cbs->action_refresh(selection_buf, menu_stack);
menu_entries_ctl(MENU_ENTRIES_CTL_UNSET_REFRESH, &refresh);
}
}
return ret;
}
/**
* menu_iterate:
* @input : input sample for this frame
* @old_input : input sample of the previous frame
* @trigger_input : difference' input sample - difference
* between 'input' and 'old_input'
*
* Runs RetroArch menu for one frame.
*
* Returns: 0 on success, -1 if we need to quit out of the loop.
**/
int generic_menu_iterate(enum menu_action action)
{
size_t selection;
menu_entry_t entry;
enum action_iterate_type iterate_type;
const char *label = NULL;
int ret = 0;
uint32_t label_hash = 0;
uint32_t hash = 0;
menu_handle_t *menu = menu_driver_get_ptr();
file_list_t *menu_stack = menu_entries_get_menu_stack_ptr();
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr();
menu_entries_get_last_stack(NULL, &label, NULL, NULL);
if (!menu)
return 0;
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return 0;
menu->menu_state.msg[0] = '\0';
hash = menu_hash_calculate(label);
iterate_type = action_iterate_type(hash);
if (action != MENU_ACTION_NOOP || menu_entries_needs_refresh() || menu_display_ctl(MENU_DISPLAY_CTL_UPDATE_PENDING, NULL))
{
BIT64_SET(menu->state, MENU_STATE_RENDER_FRAMEBUFFER);
}
switch (iterate_type)
{
case ITERATE_TYPE_HELP:
ret = action_iterate_help(menu->menu_state.msg, sizeof(menu->menu_state.msg), label);
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (ret == 1 || action == MENU_ACTION_OK)
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
break;
case ITERATE_TYPE_BIND:
if (menu_input_key_bind_iterate(menu->menu_state.msg, sizeof(menu->menu_state.msg)))
{
menu_entries_pop_stack(&selection);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
else
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
break;
case ITERATE_TYPE_INFO:
{
menu_file_list_cbs_t *cbs = menu_entries_get_actiondata_at_offset(selection_buf, selection);
rarch_setting_t *setting = cbs->setting;
if (setting)
{
char needle[PATH_MAX_LENGTH];
strlcpy(needle, menu_setting_get_name(setting), sizeof(needle));
label_hash = menu_hash_calculate(needle);
}
ret = menu_hash_get_help(label_hash, menu->menu_state.msg, sizeof(menu->menu_state.msg));
}
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (action == MENU_ACTION_OK)
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
break;
case ITERATE_TYPE_DEFAULT:
/* FIXME: Crappy hack, needed for mouse controls to not be completely broken
* in case we press back.
*
* We need to fix this entire mess, mouse controls should not rely on a
* hack like this in order to work. */
selection = max(min(selection, (menu_entries_get_size() - 1)), 0);
menu_entry_get(&entry, selection, NULL, false);
ret = menu_entry_action(&entry, selection, (enum menu_action)action);
if (ret)
goto end;
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
/* Have to defer it so we let settings refresh. */
if (menu->push_help_screen)
{
menu_displaylist_info_t info = {0};
info.list = menu_stack;
strlcpy(info.label,
menu_hash_to_str(MENU_LABEL_HELP),
sizeof(info.label));
menu_displaylist_push_list(&info, DISPLAYLIST_HELP);
}
break;
}
BIT64_SET(menu->state, MENU_STATE_BLIT);
if (BIT64_GET(menu->state, MENU_STATE_POP_STACK))
{
size_t new_selection_ptr = selection;
menu_entries_pop_stack(&new_selection_ptr);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
if (BIT64_GET(menu->state, MENU_STATE_POST_ITERATE))
menu_input_post_iterate(&ret, action);
end:
if (ret)
return -1;
return 0;
}
/**
* menu_iterate:
* @input : input sample for this frame
* @old_input : input sample of the previous frame
* @trigger_input : difference' input sample - difference
* between 'input' and 'old_input'
*
* Runs RetroArch menu for one frame.
*
* Returns: 0 on success, -1 if we need to quit out of the loop.
**/
int generic_menu_iterate(void *data, void *userdata, enum menu_action action)
{
menu_entry_t entry;
enum action_iterate_type iterate_type;
size_t selection = 0;
unsigned file_type = 0;
int ret = 0;
uint32_t hash = 0;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
const char *label = NULL;
menu_handle_t *menu = (menu_handle_t*)data;
menu_entries_get_last_stack(NULL, &label, &file_type, &enum_idx, NULL);
if (!menu)
return 0;
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return 0;
menu->menu_state.msg[0] = '\0';
hash = msg_hash_calculate(label);
iterate_type = action_iterate_type(hash);
menu_driver_set_binding_state(iterate_type == ITERATE_TYPE_BIND);
if ( action != MENU_ACTION_NOOP
|| menu_entries_ctl(MENU_ENTRIES_CTL_NEEDS_REFRESH, NULL)
|| menu_display_get_update_pending())
{
BIT64_SET(menu->state, MENU_STATE_RENDER_FRAMEBUFFER);
}
switch (iterate_type)
{
case ITERATE_TYPE_HELP:
ret = menu_dialog_iterate(
menu->menu_state.msg, sizeof(menu->menu_state.msg), label);
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (ret == 1 || action == MENU_ACTION_OK)
{
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
menu_dialog_set_active(false);
}
if (action == MENU_ACTION_CANCEL)
{
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
menu_dialog_set_active(false);
}
break;
case ITERATE_TYPE_BIND:
{
menu_input_ctx_bind_t bind;
bind.s = menu->menu_state.msg;
bind.len = sizeof(menu->menu_state.msg);
if (menu_input_key_bind_iterate(&bind))
{
menu_entries_pop_stack(&selection, 0, 0);
menu_navigation_ctl(
MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
else
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
}
break;
case ITERATE_TYPE_INFO:
{
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
menu_file_list_cbs_t *cbs =
menu_entries_get_actiondata_at_offset(selection_buf, selection);
if (cbs->enum_idx != MSG_UNKNOWN)
{
ret = menu_hash_get_help_enum(cbs->enum_idx,
menu->menu_state.msg, sizeof(menu->menu_state.msg));
}
else
{
unsigned type = 0;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
menu_entries_get_at_offset(selection_buf, selection,
NULL, NULL, &type, NULL, NULL);
switch (type)
{
case FILE_TYPE_FONT:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_FONT;
break;
case FILE_TYPE_RDB:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_RDB;
break;
case FILE_TYPE_OVERLAY:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_OVERLAY;
break;
case FILE_TYPE_CHEAT:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_CHEAT;
break;
case FILE_TYPE_SHADER_PRESET:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_SHADER_PRESET;
break;
case FILE_TYPE_SHADER:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_SHADER;
break;
case FILE_TYPE_REMAP:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_REMAP;
break;
case FILE_TYPE_RECORD_CONFIG:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_RECORD_CONFIG;
break;
case FILE_TYPE_CURSOR:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_CURSOR;
break;
case FILE_TYPE_CONFIG:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_CONFIG;
break;
case FILE_TYPE_CARCHIVE:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_COMPRESSED_ARCHIVE;
break;
case FILE_TYPE_DIRECTORY:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_DIRECTORY;
break;
case FILE_TYPE_VIDEOFILTER: /* TODO/FIXME */
case FILE_TYPE_AUDIOFILTER: /* TODO/FIXME */
case FILE_TYPE_SHADER_SLANG: /* TODO/FIXME */
case FILE_TYPE_SHADER_GLSL: /* TODO/FIXME */
case FILE_TYPE_SHADER_HLSL: /* TODO/FIXME */
case FILE_TYPE_SHADER_CG: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_GLSLP: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_HLSLP: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_CGP: /* TODO/FIXME */
case FILE_TYPE_SHADER_PRESET_SLANGP: /* TODO/FIXME */
case FILE_TYPE_PLAIN:
enum_idx = MENU_ENUM_LABEL_FILE_BROWSER_PLAIN_FILE;
break;
default:
break;
}
if (enum_idx != MSG_UNKNOWN)
ret = menu_hash_get_help_enum(enum_idx,
menu->menu_state.msg, sizeof(menu->menu_state.msg));
}
}
BIT64_SET(menu->state, MENU_STATE_RENDER_MESSAGEBOX);
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
if (action == MENU_ACTION_OK || action == MENU_ACTION_CANCEL)
{
BIT64_SET(menu->state, MENU_STATE_POP_STACK);
}
menu_dialog_set_active(false);
break;
case ITERATE_TYPE_DEFAULT:
/* FIXME: Crappy hack, needed for mouse controls
* to not be completely broken in case we press back.
*
* We need to fix this entire mess, mouse controls
* should not rely on a hack like this in order to work. */
selection = MAX(MIN(selection, (menu_entries_get_size() - 1)), 0);
menu_entry_get(&entry, 0, selection, NULL, false);
ret = menu_entry_action(&entry, selection, (enum menu_action)action);
if (ret)
goto end;
BIT64_SET(menu->state, MENU_STATE_POST_ITERATE);
/* Have to defer it so we let settings refresh. */
menu_dialog_push();
break;
}
BIT64_SET(menu->state, MENU_STATE_BLIT);
if (BIT64_GET(menu->state, MENU_STATE_POP_STACK))
{
size_t new_selection_ptr = selection;
menu_entries_pop_stack(&new_selection_ptr, 0, 0);
menu_navigation_ctl(MENU_NAVIGATION_CTL_SET_SELECTION, &selection);
}
if (BIT64_GET(menu->state, MENU_STATE_POST_ITERATE))
menu_input_post_iterate(&ret, action);
end:
if (ret)
return -1;
return 0;
}
static int action_select_default(const char *path, const char *label, unsigned type,
size_t idx)
{
menu_entry_t entry;
int ret = 0;
enum menu_action action = MENU_ACTION_NOOP;
menu_file_list_cbs_t *cbs = NULL;
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0);
menu_entry_init(&entry);
menu_entry_get(&entry, 0, idx, NULL, false);
if (selection_buf)
cbs = (menu_file_list_cbs_t*)
file_list_get_actiondata_at_offset(selection_buf, idx);
if (!cbs)
{
menu_entry_free(&entry);
return -1;
}
if (cbs->setting)
{
switch (setting_get_type(cbs->setting))
{
case ST_BOOL:
case ST_INT:
case ST_UINT:
case ST_FLOAT:
action = MENU_ACTION_RIGHT;
break;
case ST_PATH:
case ST_DIR:
case ST_ACTION:
case ST_STRING:
case ST_HEX:
case ST_BIND:
action = MENU_ACTION_OK;
break;
default:
break;
}
}
if (action == MENU_ACTION_NOOP)
{
if (cbs->action_ok)
action = MENU_ACTION_OK;
else
{
if (cbs->action_start)
action = MENU_ACTION_START;
if (cbs->action_right)
action = MENU_ACTION_RIGHT;
}
}
if (action != MENU_ACTION_NOOP)
ret = menu_entry_action(&entry, (unsigned)idx, action);
menu_entry_free(&entry);
task_queue_check();
return ret;
}
void menu_entry_get(menu_entry_t *entry, size_t stack_idx,
size_t i, void *userdata, bool use_representation)
{
char newpath[255];
const char *path = NULL;
const char *entry_label = NULL;
menu_file_list_cbs_t *cbs = NULL;
file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(stack_idx);
file_list_t *list = (userdata) ? (file_list_t*)userdata : selection_buf;
newpath[0] = '\0';
if (!list)
return;
file_list_get_at_offset(list, i, &path, &entry_label, &entry->type,
&entry->entry_idx);
cbs = (menu_file_list_cbs_t*)file_list_get_actiondata_at_offset(list, i);
if (cbs)
{
const char *label = NULL;
enum msg_hash_enums enum_idx = MSG_UNKNOWN;
entry->enum_idx = cbs->enum_idx;
entry->checked = cbs->checked;
menu_entries_get_last_stack(NULL, &label, NULL, &enum_idx, NULL);
if (cbs->action_get_value && use_representation)
{
char tmp[255];
tmp[0] = '\0';
cbs->action_get_value(list,
&entry->spacing, entry->type,
(unsigned)i, label,
tmp,
sizeof(tmp),
entry_label, path,
newpath,
sizeof(newpath)
);
if (!string_is_empty(tmp))
entry->value = strdup(tmp);
}
if (cbs->action_label)
{
char tmp[255];
tmp[0] = '\0';
cbs->action_label(list,
entry->type, (unsigned)i,
label, path,
tmp,
sizeof(tmp));
if (!string_is_empty(tmp))
entry->rich_label = strdup(tmp);
}
if (cbs->action_sublabel)
{
char tmp[512];
tmp[0] = '\0';
cbs->action_sublabel(list,
entry->type, (unsigned)i,
label, path,
tmp,
sizeof(tmp));
if (!string_is_empty(tmp))
entry->sublabel = strdup(tmp);
}
}
entry->idx = (unsigned)i;
if (!string_is_empty(path) && !use_representation)
strlcpy(newpath, path, sizeof(newpath));
else if (cbs && cbs->setting && cbs->setting->enum_value_idx != MSG_UNKNOWN
&& !cbs->setting->dont_use_enum_idx_representation)
strlcpy(newpath,
msg_hash_to_str(cbs->setting->enum_value_idx),
sizeof(newpath));
if (!string_is_empty(newpath))
entry->path = strdup(newpath);
if (!string_is_empty(entry_label))
entry->label = strdup(entry_label);
}
