void menu_update_system_info(void *data, bool *load_no_rom)
{
rgui_handle_t *rgui = (rgui_handle_t*)data;
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&rgui->info);
if (*g_settings.libretro)
{
libretro_get_system_info(g_settings.libretro, &rgui->info, load_no_rom);
#endif
// Keep track of info for the currently selected core.
if (rgui->core_info)
{
if (core_info_list_get_info(rgui->core_info, &rgui->core_info_current, g_settings.libretro))
{
const core_info_t *info = &rgui->core_info_current;
RARCH_LOG("[Core Info]:\n");
if (info->display_name)
RARCH_LOG(" Display Name: %s\n", info->display_name);
if (info->supported_extensions)
RARCH_LOG(" Supported Extensions: %s\n", info->supported_extensions);
if (info->authors)
RARCH_LOG(" Authors: %s\n", info->authors);
if (info->permissions)
RARCH_LOG(" Permissions: %s\n", info->permissions);
}
}
#ifdef HAVE_DYNAMIC
}
#endif
}
void menu_free(void *data)
{
menu_handle_t *menu = (menu_handle_t*)data;
if (!menu)
return;
#ifdef HAVE_SHADER_MANAGER
if (menu->shader)
free(menu->shader);
menu->shader = NULL;
#endif
if (driver.menu_ctx && driver.menu_ctx->free)
driver.menu_ctx->free(menu);
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&g_extern.menu.info);
#endif
file_list_free(menu->menu_stack);
file_list_free(menu->selection_buf);
rarch_main_command(RARCH_CMD_HISTORY_DEINIT);
if (g_extern.core_info)
core_info_list_free(g_extern.core_info);
if (g_extern.core_info_current)
free(g_extern.core_info_current);
free(data);
}
void menu_update_system_info(menu_handle_t *menu, bool *load_no_content)
{
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&menu->info);
if (*g_settings.libretro)
{
libretro_get_system_info(g_settings.libretro, &menu->info,
load_no_content);
#endif
/* Keep track of info for the currently selected core. */
if (menu->core_info)
{
if (core_info_list_get_info(menu->core_info,
menu->core_info_current, g_settings.libretro))
{
const core_info_t *info = (const core_info_t*)menu->core_info_current;
RARCH_LOG("[Core Info]:\n");
if (info->display_name)
RARCH_LOG(" Display Name: %s\n", info->display_name);
if (info->supported_extensions)
RARCH_LOG(" Supported Extensions: %s\n", info->supported_extensions);
if (info->authors)
RARCH_LOG(" Authors: %s\n", info->authors);
if (info->permissions)
RARCH_LOG(" Permissions: %s\n", info->permissions);
}
}
#ifdef HAVE_DYNAMIC
}
#endif
}
/**
* menu_free:
* @menu : Menu handle.
*
* Frees a menu handle
**/
void menu_free(menu_handle_t *menu)
{
global_t *global = global_get_ptr();
if (!menu)
return;
if (menu->playlist)
content_playlist_free(menu->playlist);
menu->playlist = NULL;
menu_shader_free(menu);
menu_input_free();
menu_navigation_free();
menu_driver_free(menu);
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&g_system_menu);
#endif
menu_display_free();
menu_entries_free();
event_command(EVENT_CMD_HISTORY_DEINIT);
if (global->core_info.list)
core_info_list_free(global->core_info.list);
if (global->core_info.current)
free(global->core_info.current);
global->core_info.current = NULL;
free(menu);
}
void load_menu_game_history(unsigned game_index)
{
const char *path = NULL;
const char *core_path = NULL;
const char *core_name = NULL;
rom_history_get_index(rgui->history,
game_index, &path, &core_path, &core_name);
strlcpy(g_settings.libretro, core_path, sizeof(g_settings.libretro));
if (path)
{
rgui->load_no_rom = false;
strlcpy(g_extern.fullpath, path, sizeof(g_extern.fullpath));
}
else
{
rgui->load_no_rom = true;
*g_extern.fullpath = '\0';
}
#if !defined( HAVE_DYNAMIC) && defined(RARCH_CONSOLE)
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
g_extern.lifecycle_mode_state |= (1ULL << MODE_EXITSPAWN);
g_extern.lifecycle_mode_state |= (1ULL << MODE_EXITSPAWN_START_GAME);
#elif defined(HAVE_DYNAMIC)
libretro_free_system_info(&rgui->info);
libretro_get_system_info(g_settings.libretro, &rgui->info, NULL);
g_extern.lifecycle_mode_state |= (1ULL << MODE_LOAD_GAME);
#endif
}
/**
* menu_free:
* @menu : Menu handle.
*
* Frees a menu handle
**/
void menu_free(menu_handle_t *menu)
{
global_t *global = global_get_ptr();
if (!menu)
return;
menu_free_list(menu);
#ifdef HAVE_SHADER_MANAGER
if (menu->shader)
free(menu->shader);
menu->shader = NULL;
#endif
menu_driver_free(menu);
#ifdef HAVE_LIBRETRODB
menu_database_free(menu);
#endif
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&global->menu.info);
#endif
if (menu->msg_queue)
msg_queue_free(menu->msg_queue);
menu->msg_queue = NULL;
menu_display_free(menu);
if (menu->frame_buf.data)
free(menu->frame_buf.data);
menu->frame_buf.data = NULL;
menu_list_free(menu->menu_list);
menu->menu_list = NULL;
event_command(EVENT_CMD_HISTORY_DEINIT);
if (global->core_info)
core_info_list_free(global->core_info);
if (global->core_info_current)
free(global->core_info_current);
free(menu);
}
void menu_free(void *data)
{
rgui_handle_t *rgui = (rgui_handle_t*)data;
if (!rgui)
return;
if (driver.menu_ctx && driver.menu_ctx->free)
driver.menu_ctx->free(rgui);
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&rgui->info);
#endif
file_list_free(rgui->menu_stack);
file_list_free(rgui->selection_buf);
rom_history_free(rgui->history);
core_info_list_free(rgui->core_info);
free(rgui);
}
/**
* menu_free:
* @menu : Menu handle.
*
* Frees a menu handle
**/
void menu_free(menu_handle_t *menu)
{
global_t *global = global_get_ptr();
menu_display_t *disp = menu_display_get_ptr();
if (!menu || !disp)
return;
if (menu->playlist)
content_playlist_free(menu->playlist);
menu->playlist = NULL;
menu_shader_free(menu);
menu_driver_free(menu);
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&global->menu.info);
#endif
menu_display_free(menu);
menu_free_list(&menu->entries);
event_command(EVENT_CMD_HISTORY_DEINIT);
if (global->core_info)
core_info_list_free(global->core_info);
if (global->core_info_current)
free(global->core_info_current);
global->core_info_current = NULL;
menu_driver_unset_alive();
free(menu);
}
/**
* event_command:
* @cmd : Event command index.
*
* Performs RetroArch event command with index @cmd.
*
* Returns: true (1) on success, otherwise false (0).
**/
bool event_command(enum event_command cmd)
{
unsigned i = 0;
bool boolean = false;
runloop_t *runloop = rarch_main_get_ptr();
driver_t *driver = driver_get_ptr();
global_t *global = global_get_ptr();
settings_t *settings = config_get_ptr();
rarch_system_info_t *system = rarch_system_info_get_ptr();
(void)i;
switch (cmd)
{
case EVENT_CMD_LOAD_CONTENT_PERSIST:
#ifdef HAVE_DYNAMIC
event_command(EVENT_CMD_LOAD_CORE);
#endif
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT);
break;
#ifdef HAVE_FFMPEG
case EVENT_CMD_LOAD_CONTENT_FFMPEG:
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT_FFMPEG);
break;
#endif
case EVENT_CMD_LOAD_CONTENT_IMAGEVIEWER:
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT_IMAGEVIEWER);
break;
case EVENT_CMD_LOAD_CONTENT:
#ifdef HAVE_DYNAMIC
event_command(EVENT_CMD_LOAD_CONTENT_PERSIST);
#else
rarch_environment_cb(RETRO_ENVIRONMENT_SET_LIBRETRO_PATH,
(void*)settings->libretro);
rarch_environment_cb(RETRO_ENVIRONMENT_EXEC,
(void*)global->fullpath);
event_command(EVENT_CMD_QUIT);
#endif
break;
case EVENT_CMD_LOAD_CORE_DEINIT:
#ifdef HAVE_DYNAMIC
libretro_free_system_info(&global->menu.info);
#endif
break;
case EVENT_CMD_LOAD_CORE_PERSIST:
event_command(EVENT_CMD_LOAD_CORE_DEINIT);
{
#ifdef HAVE_MENU
menu_handle_t *menu = menu_driver_get_ptr();
if (menu)
event_update_system_info(&global->menu.info,
&menu->load_no_content);
#endif
}
break;
case EVENT_CMD_LOAD_CORE:
event_command(EVENT_CMD_LOAD_CORE_PERSIST);
#ifndef HAVE_DYNAMIC
event_command(EVENT_CMD_QUIT);
#endif
break;
case EVENT_CMD_LOAD_STATE:
/* Immutable - disallow savestate load when
* we absolutely cannot change game state. */
if (global->bsv.movie)
return false;
#ifdef HAVE_NETPLAY
if (driver->netplay_data)
return false;
#endif
event_main_state(cmd);
break;
case EVENT_CMD_RESIZE_WINDOWED_SCALE:
if (global->pending.windowed_scale == 0)
return false;
settings->video.scale = global->pending.windowed_scale;
if (!settings->video.fullscreen)
event_command(EVENT_CMD_REINIT);
global->pending.windowed_scale = 0;
break;
case EVENT_CMD_MENU_TOGGLE:
if (menu_driver_alive())
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
else
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING);
break;
case EVENT_CMD_CONTROLLERS_INIT:
event_init_controllers();
break;
case EVENT_CMD_RESET:
RARCH_LOG(RETRO_LOG_RESETTING_CONTENT);
rarch_main_msg_queue_push("Reset.", 1, 120, true);
pretro_reset();
/* bSNES since v073r01 resets controllers to JOYPAD
* after a reset, so just enforce it here. */
event_command(EVENT_CMD_CONTROLLERS_INIT);
break;
case EVENT_CMD_SAVE_STATE:
if (settings->savestate_auto_index)
settings->state_slot++;
event_main_state(cmd);
break;
case EVENT_CMD_TAKE_SCREENSHOT:
if (!take_screenshot())
return false;
break;
case EVENT_CMD_PREPARE_DUMMY:
{
#ifdef HAVE_MENU
menu_handle_t *menu = menu_driver_get_ptr();
if (menu)
menu->load_no_content = false;
#endif
rarch_main_data_deinit();
*global->fullpath = '\0';
rarch_main_set_state(RARCH_ACTION_STATE_LOAD_CONTENT);
}
break;
case EVENT_CMD_UNLOAD_CORE:
event_command(EVENT_CMD_PREPARE_DUMMY);
event_command(EVENT_CMD_LOAD_CORE_DEINIT);
break;
case EVENT_CMD_QUIT:
rarch_main_set_state(RARCH_ACTION_STATE_QUIT);
break;
case EVENT_CMD_REINIT:
{
const struct retro_hw_render_callback *hw_render =
(const struct retro_hw_render_callback*)video_driver_callback();
driver->video_cache_context = hw_render->cache_context;
driver->video_cache_context_ack = false;
event_command(EVENT_CMD_RESET_CONTEXT);
driver->video_cache_context = false;
/* Poll input to avoid possibly stale data to corrupt things. */
input_driver_poll();
#ifdef HAVE_MENU
menu_display_fb_set_dirty();
if (menu_driver_alive())
event_command(EVENT_CMD_VIDEO_SET_BLOCKING_STATE);
#endif
}
break;
case EVENT_CMD_CHEATS_DEINIT:
if (!global)
break;
if (global->cheat)
cheat_manager_free(global->cheat);
global->cheat = NULL;
break;
case EVENT_CMD_CHEATS_INIT:
event_command(EVENT_CMD_CHEATS_DEINIT);
event_init_cheats();
break;
case EVENT_CMD_REMAPPING_DEINIT:
break;
case EVENT_CMD_REMAPPING_INIT:
event_command(EVENT_CMD_REMAPPING_DEINIT);
event_init_remapping();
break;
case EVENT_CMD_REWIND_DEINIT:
if (!global)
break;
#ifdef HAVE_NETPLAY
if (driver->netplay_data)
return false;
#endif
if (global->rewind.state)
state_manager_free(global->rewind.state);
global->rewind.state = NULL;
break;
case EVENT_CMD_REWIND_INIT:
init_rewind();
break;
case EVENT_CMD_REWIND_TOGGLE:
if (settings->rewind_enable)
event_command(EVENT_CMD_REWIND_INIT);
else
event_command(EVENT_CMD_REWIND_DEINIT);
break;
case EVENT_CMD_AUTOSAVE_DEINIT:
#ifdef HAVE_THREADS
event_deinit_autosave();
#endif
break;
case EVENT_CMD_AUTOSAVE_INIT:
event_command(EVENT_CMD_AUTOSAVE_DEINIT);
#ifdef HAVE_THREADS
event_init_autosave();
#endif
break;
case EVENT_CMD_AUTOSAVE_STATE:
event_save_auto_state();
break;
case EVENT_CMD_AUDIO_STOP:
if (!driver->audio_data)
return false;
if (!audio_driver_alive())
return false;
if (!audio_driver_stop())
return false;
break;
case EVENT_CMD_AUDIO_START:
if (!driver->audio_data || audio_driver_alive())
return false;
if (!settings->audio.mute_enable && !audio_driver_start())
{
RARCH_ERR("Failed to start audio driver. Will continue without audio.\n");
driver->audio_active = false;
}
break;
case EVENT_CMD_AUDIO_MUTE_TOGGLE:
{
const char *msg = !settings->audio.mute_enable ?
"Audio muted." : "Audio unmuted.";
if (!audio_driver_mute_toggle())
{
RARCH_ERR("Failed to unmute audio.\n");
return false;
}
rarch_main_msg_queue_push(msg, 1, 180, true);
RARCH_LOG("%s\n", msg);
}
break;
case EVENT_CMD_OVERLAY_DEINIT:
#ifdef HAVE_OVERLAY
if (driver->overlay)
input_overlay_free(driver->overlay);
driver->overlay = NULL;
memset(&driver->overlay_state, 0, sizeof(driver->overlay_state));
#endif
break;
case EVENT_CMD_OVERLAY_INIT:
event_command(EVENT_CMD_OVERLAY_DEINIT);
#ifdef HAVE_OVERLAY
if (driver->osk_enable)
{
if (!*settings->osk.overlay)
break;
}
else
{
if (!*settings->input.overlay)
break;
}
driver->overlay = input_overlay_new(driver->osk_enable ? settings->osk.overlay : settings->input.overlay,
driver->osk_enable ? settings->osk.enable : settings->input.overlay_enable,
settings->input.overlay_opacity, settings->input.overlay_scale);
if (!driver->overlay)
RARCH_ERR("Failed to load overlay.\n");
#endif
break;
case EVENT_CMD_OVERLAY_NEXT:
#ifdef HAVE_OVERLAY
input_overlay_next(driver->overlay, settings->input.overlay_opacity);
#endif
break;
case EVENT_CMD_DSP_FILTER_DEINIT:
if (!global)
break;
audio_driver_dsp_filter_free();
break;
case EVENT_CMD_DSP_FILTER_INIT:
event_command(EVENT_CMD_DSP_FILTER_DEINIT);
if (!*settings->audio.dsp_plugin)
break;
audio_driver_dsp_filter_init(settings->audio.dsp_plugin);
break;
case EVENT_CMD_GPU_RECORD_DEINIT:
if (!global)
break;
if (global->record.gpu_buffer)
free(global->record.gpu_buffer);
global->record.gpu_buffer = NULL;
break;
case EVENT_CMD_RECORD_DEINIT:
if (!recording_deinit())
return false;
break;
case EVENT_CMD_RECORD_INIT:
event_command(EVENT_CMD_HISTORY_DEINIT);
if (!recording_init())
return false;
break;
case EVENT_CMD_HISTORY_DEINIT:
if (g_defaults.history)
{
content_playlist_write_file(g_defaults.history);
content_playlist_free(g_defaults.history);
}
g_defaults.history = NULL;
break;
case EVENT_CMD_HISTORY_INIT:
event_command(EVENT_CMD_HISTORY_DEINIT);
if (!settings->history_list_enable)
return false;
RARCH_LOG("Loading history file: [%s].\n", settings->content_history_path);
g_defaults.history = content_playlist_init(
settings->content_history_path,
settings->content_history_size);
break;
case EVENT_CMD_CORE_INFO_DEINIT:
if (!global)
break;
if (global->core_info)
core_info_list_free(global->core_info);
global->core_info = NULL;
break;
case EVENT_CMD_DATA_RUNLOOP_FREE:
rarch_main_data_free();
break;
case EVENT_CMD_CORE_INFO_INIT:
event_command(EVENT_CMD_CORE_INFO_DEINIT);
if (*settings->libretro_directory)
global->core_info = core_info_list_new();
break;
case EVENT_CMD_CORE_DEINIT:
{
struct retro_hw_render_callback *cb = video_driver_callback();
event_deinit_core(true);
if (cb)
memset(cb, 0, sizeof(*cb));
break;
}
case EVENT_CMD_CORE_INIT:
if (!event_init_core())
return false;
break;
case EVENT_CMD_VIDEO_APPLY_STATE_CHANGES:
video_driver_apply_state_changes();
break;
case EVENT_CMD_VIDEO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case EVENT_CMD_VIDEO_SET_BLOCKING_STATE:
video_driver_set_nonblock_state(boolean);
break;
case EVENT_CMD_VIDEO_SET_ASPECT_RATIO:
video_driver_set_aspect_ratio(settings->video.aspect_ratio_idx);
break;
case EVENT_CMD_AUDIO_SET_NONBLOCKING_STATE:
boolean = true; /* fall-through */
case EVENT_CMD_AUDIO_SET_BLOCKING_STATE:
audio_driver_set_nonblock_state(boolean);
break;
case EVENT_CMD_OVERLAY_SET_SCALE_FACTOR:
#ifdef HAVE_OVERLAY
input_overlay_set_scale_factor(driver->overlay,
settings->input.overlay_scale);
#endif
break;
case EVENT_CMD_OVERLAY_SET_ALPHA_MOD:
#ifdef HAVE_OVERLAY
input_overlay_set_alpha_mod(driver->overlay,
settings->input.overlay_opacity);
#endif
break;
case EVENT_CMD_DRIVERS_DEINIT:
uninit_drivers(DRIVERS_CMD_ALL);
break;
case EVENT_CMD_DRIVERS_INIT:
init_drivers(DRIVERS_CMD_ALL);
break;
case EVENT_CMD_AUDIO_REINIT:
uninit_drivers(DRIVER_AUDIO);
init_drivers(DRIVER_AUDIO);
break;
case EVENT_CMD_RESET_CONTEXT:
event_command(EVENT_CMD_DRIVERS_DEINIT);
event_command(EVENT_CMD_DRIVERS_INIT);
break;
case EVENT_CMD_QUIT_RETROARCH:
rarch_main_set_state(RARCH_ACTION_STATE_FORCE_QUIT);
break;
case EVENT_CMD_RESUME:
rarch_main_set_state(RARCH_ACTION_STATE_MENU_RUNNING_FINISHED);
break;
case EVENT_CMD_RESTART_RETROARCH:
#if defined(GEKKO) && defined(HW_RVL)
fill_pathname_join(global->fullpath, g_defaults.core_dir,
SALAMANDER_FILE,
sizeof(global->fullpath));
#endif
if (driver->frontend_ctx && driver->frontend_ctx->set_fork)
driver->frontend_ctx->set_fork(true, false);
break;
case EVENT_CMD_MENU_SAVE_CONFIG:
if (!event_save_core_config())
return false;
break;
case EVENT_CMD_SHADERS_APPLY_CHANGES:
#ifdef HAVE_MENU
menu_shader_manager_apply_changes();
#endif
break;
case EVENT_CMD_PAUSE_CHECKS:
if (runloop->is_paused)
{
RARCH_LOG("Paused.\n");
event_command(EVENT_CMD_AUDIO_STOP);
if (settings->video.black_frame_insertion)
video_driver_cached_frame();
}
else
{
RARCH_LOG("Unpaused.\n");
event_command(EVENT_CMD_AUDIO_START);
}
break;
case EVENT_CMD_PAUSE_TOGGLE:
runloop->is_paused = !runloop->is_paused;
event_command(EVENT_CMD_PAUSE_CHECKS);
break;
case EVENT_CMD_UNPAUSE:
runloop->is_paused = false;
event_command(EVENT_CMD_PAUSE_CHECKS);
break;
case EVENT_CMD_PAUSE:
runloop->is_paused = true;
event_command(EVENT_CMD_PAUSE_CHECKS);
break;
case EVENT_CMD_MENU_PAUSE_LIBRETRO:
if (menu_driver_alive())
{
if (settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_STOP);
else
event_command(EVENT_CMD_AUDIO_START);
}
else
{
if (settings->menu.pause_libretro)
event_command(EVENT_CMD_AUDIO_START);
}
break;
case EVENT_CMD_SHADER_DIR_DEINIT:
if (!global)
break;
dir_list_free(global->shader_dir.list);
global->shader_dir.list = NULL;
global->shader_dir.ptr = 0;
break;
case EVENT_CMD_SHADER_DIR_INIT:
event_command(EVENT_CMD_SHADER_DIR_DEINIT);
if (!*settings->video.shader_dir)
return false;
global->shader_dir.list = dir_list_new_special(NULL, DIR_LIST_SHADERS);
if (!global->shader_dir.list || global->shader_dir.list->size == 0)
{
event_command(EVENT_CMD_SHADER_DIR_DEINIT);
return false;
}
global->shader_dir.ptr = 0;
dir_list_sort(global->shader_dir.list, false);
for (i = 0; i < global->shader_dir.list->size; i++)
RARCH_LOG("Found shader \"%s\"\n",
global->shader_dir.list->elems[i].data);
break;
case EVENT_CMD_SAVEFILES:
event_save_files();
break;
case EVENT_CMD_SAVEFILES_DEINIT:
if (!global)
break;
if (global->savefiles)
string_list_free(global->savefiles);
global->savefiles = NULL;
break;
case EVENT_CMD_SAVEFILES_INIT:
global->use_sram = global->use_sram && !global->sram_save_disable
#ifdef HAVE_NETPLAY
&& (!driver->netplay_data || !global->netplay_is_client)
#endif
;
if (!global->use_sram)
RARCH_LOG("SRAM will not be saved.\n");
if (global->use_sram)
event_command(EVENT_CMD_AUTOSAVE_INIT);
break;
case EVENT_CMD_MSG_QUEUE_DEINIT:
rarch_main_msg_queue_free();
break;
case EVENT_CMD_MSG_QUEUE_INIT:
event_command(EVENT_CMD_MSG_QUEUE_DEINIT);
rarch_main_msg_queue_init();
rarch_main_data_init_queues();
break;
case EVENT_CMD_BSV_MOVIE_DEINIT:
if (!global)
break;
if (global->bsv.movie)
bsv_movie_free(global->bsv.movie);
global->bsv.movie = NULL;
break;
case EVENT_CMD_BSV_MOVIE_INIT:
event_command(EVENT_CMD_BSV_MOVIE_DEINIT);
event_init_movie();
break;
case EVENT_CMD_NETPLAY_DEINIT:
#ifdef HAVE_NETPLAY
deinit_netplay();
#endif
break;
case EVENT_CMD_NETWORK_DEINIT:
#ifdef HAVE_NETWORKING
network_deinit();
#endif
break;
case EVENT_CMD_NETWORK_INIT:
#ifdef HAVE_NETWORKING
network_init();
#endif
break;
case EVENT_CMD_NETPLAY_INIT:
event_command(EVENT_CMD_NETPLAY_DEINIT);
#ifdef HAVE_NETPLAY
if (!init_netplay())
return false;
#endif
break;
case EVENT_CMD_NETPLAY_FLIP_PLAYERS:
#ifdef HAVE_NETPLAY
{
netplay_t *netplay = (netplay_t*)driver->netplay_data;
if (!netplay)
return false;
netplay_flip_users(netplay);
}
#endif
break;
case EVENT_CMD_FULLSCREEN_TOGGLE:
if (!video_driver_has_windowed())
return false;
/* If we go fullscreen we drop all drivers and
* reinitialize to be safe. */
settings->video.fullscreen = !settings->video.fullscreen;
event_command(EVENT_CMD_REINIT);
break;
case EVENT_CMD_COMMAND_DEINIT:
#ifdef HAVE_COMMAND
if (driver->command)
rarch_cmd_free(driver->command);
driver->command = NULL;
#endif
break;
case EVENT_CMD_COMMAND_INIT:
event_command(EVENT_CMD_COMMAND_DEINIT);
#ifdef HAVE_COMMAND
event_init_command();
#endif
break;
case EVENT_CMD_TEMPORARY_CONTENT_DEINIT:
if (!global)
break;
if (global->temporary_content)
event_free_temporary_content();
global->temporary_content = NULL;
break;
case EVENT_CMD_SUBSYSTEM_FULLPATHS_DEINIT:
if (!global)
break;
if (global->subsystem_fullpaths)
string_list_free(global->subsystem_fullpaths);
global->subsystem_fullpaths = NULL;
break;
case EVENT_CMD_LOG_FILE_DEINIT:
if (!global)
break;
if (global->log_file && global->log_file != stderr)
fclose(global->log_file);
global->log_file = NULL;
break;
case EVENT_CMD_DISK_EJECT_TOGGLE:
if (system && system->disk_control.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&system->disk_control;
if (control)
event_check_disk_eject(control);
}
else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true);
break;
case EVENT_CMD_DISK_NEXT:
if (system && system->disk_control.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&system->disk_control;
if (!control)
return false;
if (!control->get_eject_state())
return false;
event_check_disk_next(control);
}
else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true);
break;
case EVENT_CMD_DISK_PREV:
if (system && system->disk_control.get_num_images)
{
const struct retro_disk_control_callback *control =
(const struct retro_disk_control_callback*)
&system->disk_control;
if (!control)
return false;
if (!control->get_eject_state())
return false;
event_check_disk_prev(control);
}
else
rarch_main_msg_queue_push("Core does not support Disk Options.", 1, 120, true);
break;
case EVENT_CMD_RUMBLE_STOP:
for (i = 0; i < MAX_USERS; i++)
{
input_driver_set_rumble_state(i, RETRO_RUMBLE_STRONG, 0);
input_driver_set_rumble_state(i, RETRO_RUMBLE_WEAK, 0);
}
break;
case EVENT_CMD_GRAB_MOUSE_TOGGLE:
{
static bool grab_mouse_state = false;
grab_mouse_state = !grab_mouse_state;
if (!driver->input || !input_driver_grab_mouse(grab_mouse_state))
return false;
RARCH_LOG("Grab mouse state: %s.\n",
grab_mouse_state ? "yes" : "no");
video_driver_show_mouse(!grab_mouse_state);
}
break;
case EVENT_CMD_PERFCNT_REPORT_FRONTEND_LOG:
rarch_perf_log();
break;
case EVENT_CMD_VOLUME_UP:
event_set_volume(0.5f);
break;
case EVENT_CMD_VOLUME_DOWN:
event_set_volume(-0.5f);
break;
case EVENT_CMD_NONE:
default:
goto error;
}
return true;
error:
return false;
}
bool menu_driver_ctl(enum rarch_menu_ctl_state state, void *data)
{
static struct retro_system_info menu_driver_system;
static bool menu_driver_pending_quick_menu = false;
static bool menu_driver_pending_action = false;
static bool menu_driver_prevent_populate = false;
static bool menu_driver_load_no_content = false;
static bool menu_driver_alive = false;
static bool menu_driver_data_own = false;
static bool menu_driver_pending_quit = false;
static bool menu_driver_pending_shutdown = false;
static playlist_t *menu_driver_playlist = NULL;
static struct video_shader *menu_driver_shader = NULL;
static menu_handle_t *menu_driver_data = NULL;
static const menu_ctx_driver_t *menu_driver_ctx = NULL;
static void *menu_userdata = NULL;
settings_t *settings = config_get_ptr();
switch (state)
{
case RARCH_MENU_CTL_IS_PENDING_ACTION:
if (!menu_driver_pending_action)
return false;
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_ACTION, NULL);
break;
case RARCH_MENU_CTL_SET_PENDING_ACTION:
menu_driver_pending_action = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_ACTION:
menu_driver_pending_action = false;
break;
case RARCH_MENU_CTL_DRIVER_DATA_GET:
{
menu_handle_t **driver_data = (menu_handle_t**)data;
if (!driver_data)
return false;
*driver_data = menu_driver_data;
}
break;
case RARCH_MENU_CTL_IS_PENDING_QUICK_MENU:
return menu_driver_pending_quick_menu;
case RARCH_MENU_CTL_SET_PENDING_QUICK_MENU:
menu_driver_pending_quick_menu = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_QUICK_MENU:
menu_driver_pending_quick_menu = false;
break;
case RARCH_MENU_CTL_IS_PENDING_QUIT:
return menu_driver_pending_quit;
case RARCH_MENU_CTL_SET_PENDING_QUIT:
menu_driver_pending_quit = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_QUIT:
menu_driver_pending_quit = false;
break;
case RARCH_MENU_CTL_IS_PENDING_SHUTDOWN:
return menu_driver_pending_shutdown;
case RARCH_MENU_CTL_SET_PENDING_SHUTDOWN:
menu_driver_pending_shutdown = true;
break;
case RARCH_MENU_CTL_UNSET_PENDING_SHUTDOWN:
menu_driver_pending_shutdown = false;
break;
case RARCH_MENU_CTL_DESTROY:
menu_driver_pending_quick_menu = false;
menu_driver_pending_action = false;
menu_driver_pending_quit = false;
menu_driver_pending_shutdown = false;
menu_driver_prevent_populate = false;
menu_driver_load_no_content = false;
menu_driver_alive = false;
menu_driver_data_own = false;
menu_driver_ctx = NULL;
menu_userdata = NULL;
break;
case RARCH_MENU_CTL_PLAYLIST_FREE:
if (menu_driver_playlist)
playlist_free(menu_driver_playlist);
menu_driver_playlist = NULL;
break;
case RARCH_MENU_CTL_FIND_DRIVER:
{
int i;
driver_ctx_info_t drv;
settings_t *settings = config_get_ptr();
drv.label = "menu_driver";
drv.s = settings->menu.driver;
driver_ctl(RARCH_DRIVER_CTL_FIND_INDEX, &drv);
i = drv.len;
if (i >= 0)
menu_driver_ctx = (const menu_ctx_driver_t*)
menu_driver_find_handle(i);
else
{
unsigned d;
RARCH_WARN("Couldn't find any menu driver named \"%s\"\n",
settings->menu.driver);
RARCH_LOG_OUTPUT("Available menu drivers are:\n");
for (d = 0; menu_driver_find_handle(d); d++)
RARCH_LOG_OUTPUT("\t%s\n", menu_driver_find_ident(d));
RARCH_WARN("Going to default to first menu driver...\n");
menu_driver_ctx = (const menu_ctx_driver_t*)
menu_driver_find_handle(0);
if (!menu_driver_ctx)
{
retroarch_fail(1, "find_menu_driver()");
return false;
}
}
}
break;
case RARCH_MENU_CTL_PLAYLIST_INIT:
{
const char *path = (const char*)data;
if (string_is_empty(path))
return false;
menu_driver_playlist = playlist_init(path,
COLLECTION_SIZE);
}
break;
case RARCH_MENU_CTL_PLAYLIST_GET:
{
playlist_t **playlist = (playlist_t**)data;
if (!playlist)
return false;
*playlist = menu_driver_playlist;
}
break;
case RARCH_MENU_CTL_SYSTEM_INFO_GET:
{
struct retro_system_info **system =
(struct retro_system_info**)data;
if (!system)
return false;
*system = &menu_driver_system;
}
break;
case RARCH_MENU_CTL_SYSTEM_INFO_DEINIT:
libretro_free_system_info(&menu_driver_system);
memset(&menu_driver_system, 0, sizeof(struct retro_system_info));
break;
case RARCH_MENU_CTL_RENDER_MESSAGEBOX:
if (menu_driver_ctx->render_messagebox)
menu_driver_ctx->render_messagebox(menu_userdata,
menu_driver_data->menu_state.msg);
break;
case RARCH_MENU_CTL_BLIT_RENDER:
if (menu_driver_ctx->render)
menu_driver_ctx->render(menu_userdata);
break;
case RARCH_MENU_CTL_RENDER:
if (!menu_driver_data)
return false;
if (BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_FRAMEBUFFER)
!= BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_MESSAGEBOX))
BIT64_SET(menu_driver_data->state, MENU_STATE_RENDER_FRAMEBUFFER);
if (BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_FRAMEBUFFER))
menu_display_set_framebuffer_dirty_flag();
if (BIT64_GET(menu_driver_data->state, MENU_STATE_RENDER_MESSAGEBOX)
&& !string_is_empty(menu_driver_data->menu_state.msg))
{
menu_driver_ctl(RARCH_MENU_CTL_RENDER_MESSAGEBOX, NULL);
if (ui_companion_is_on_foreground())
{
const ui_companion_driver_t *ui = ui_companion_get_ptr();
if (ui->render_messagebox)
ui->render_messagebox(menu_driver_data->menu_state.msg);
}
}
if (BIT64_GET(menu_driver_data->state, MENU_STATE_BLIT))
{
menu_animation_ctl(MENU_ANIMATION_CTL_UPDATE_TIME, NULL);
menu_driver_ctl(RARCH_MENU_CTL_BLIT_RENDER, NULL);
}
if (menu_driver_ctl(RARCH_MENU_CTL_IS_ALIVE, NULL)
&& !runloop_ctl(RUNLOOP_CTL_IS_IDLE, NULL))
menu_display_libretro();
menu_driver_ctl(RARCH_MENU_CTL_SET_TEXTURE, NULL);
menu_driver_data->state = 0;
break;
case RARCH_MENU_CTL_SHADER_DEINIT:
#ifdef HAVE_SHADER_MANAGER
if (menu_driver_shader)
free(menu_driver_shader);
menu_driver_shader = NULL;
#endif
break;
case RARCH_MENU_CTL_SHADER_INIT:
#ifdef HAVE_SHADER_MANAGER
menu_driver_shader = (struct video_shader*)
calloc(1, sizeof(struct video_shader));
if (!menu_driver_shader)
return false;
#endif
break;
case RARCH_MENU_CTL_SHADER_GET:
{
struct video_shader **shader = (struct video_shader**)data;
if (!shader)
return false;
*shader = menu_driver_shader;
}
break;
case RARCH_MENU_CTL_FRAME:
if (!menu_driver_alive)
return false;
if (menu_driver_ctx->frame)
menu_driver_ctx->frame(menu_userdata);
break;
case RARCH_MENU_CTL_SET_PREVENT_POPULATE:
menu_driver_prevent_populate = true;
break;
case RARCH_MENU_CTL_UNSET_PREVENT_POPULATE:
menu_driver_prevent_populate = false;
break;
case RARCH_MENU_CTL_IS_PREVENT_POPULATE:
return menu_driver_prevent_populate;
case RARCH_MENU_CTL_SET_TOGGLE:
menu_driver_toggle(true);
break;
case RARCH_MENU_CTL_UNSET_TOGGLE:
menu_driver_toggle(false);
break;
case RARCH_MENU_CTL_SET_ALIVE:
menu_driver_alive = true;
break;
case RARCH_MENU_CTL_UNSET_ALIVE:
menu_driver_alive = false;
break;
case RARCH_MENU_CTL_IS_ALIVE:
return menu_driver_alive;
case RARCH_MENU_CTL_SET_OWN_DRIVER:
menu_driver_data_own = true;
break;
case RARCH_MENU_CTL_UNSET_OWN_DRIVER:
if (!content_is_inited())
return false;
menu_driver_data_own = false;
break;
case RARCH_MENU_CTL_SET_TEXTURE:
if (menu_driver_ctx->set_texture)
menu_driver_ctx->set_texture();
break;
case RARCH_MENU_CTL_IS_SET_TEXTURE:
if (!menu_driver_ctx)
return false;
return menu_driver_ctx->set_texture;
case RARCH_MENU_CTL_OWNS_DRIVER:
return menu_driver_data_own;
case RARCH_MENU_CTL_DEINIT:
menu_driver_ctl(RARCH_MENU_CTL_CONTEXT_DESTROY, NULL);
if (menu_driver_ctl(RARCH_MENU_CTL_OWNS_DRIVER, NULL))
return true;
if (menu_driver_data)
{
menu_driver_ctl(RARCH_MENU_CTL_PLAYLIST_FREE, NULL);
menu_shader_free(menu_driver_data);
menu_input_ctl(MENU_INPUT_CTL_DEINIT, NULL);
menu_navigation_ctl(MENU_NAVIGATION_CTL_DEINIT, NULL);
if (menu_driver_ctx && menu_driver_ctx->free)
menu_driver_ctx->free(menu_userdata);
if (menu_userdata)
free(menu_userdata);
menu_userdata = NULL;
menu_driver_ctl(RARCH_MENU_CTL_SYSTEM_INFO_DEINIT, NULL);
menu_display_deinit();
menu_entries_ctl(MENU_ENTRIES_CTL_DEINIT, NULL);
command_event(CMD_EVENT_HISTORY_DEINIT, NULL);
core_info_deinit_list();
core_info_free_current_core();
free(menu_driver_data);
}
menu_driver_data = NULL;
break;
case RARCH_MENU_CTL_INIT:
if (menu_driver_data)
return true;
menu_driver_data = (menu_handle_t*)
menu_driver_ctx->init(&menu_userdata);
if (!menu_driver_data || !menu_init(menu_driver_data))
{
retroarch_fail(1, "init_menu()");
return false;
}
strlcpy(settings->menu.driver, menu_driver_ctx->ident,
sizeof(settings->menu.driver));
if (menu_driver_ctx->lists_init)
{
if (!menu_driver_ctx->lists_init(menu_driver_data))
{
retroarch_fail(1, "init_menu()");
return false;
}
}
break;
case RARCH_MENU_CTL_LOAD_NO_CONTENT_GET:
{
bool **ptr = (bool**)data;
if (!ptr)
return false;
*ptr = (bool*)&menu_driver_load_no_content;
}
break;
case RARCH_MENU_CTL_HAS_LOAD_NO_CONTENT:
return menu_driver_load_no_content;
case RARCH_MENU_CTL_SET_LOAD_NO_CONTENT:
menu_driver_load_no_content = true;
break;
case RARCH_MENU_CTL_UNSET_LOAD_NO_CONTENT:
menu_driver_load_no_content = false;
break;
case RARCH_MENU_CTL_NAVIGATION_INCREMENT:
if (menu_driver_ctx->navigation_increment)
menu_driver_ctx->navigation_increment(menu_userdata);
break;
case RARCH_MENU_CTL_NAVIGATION_DECREMENT:
if (menu_driver_ctx->navigation_decrement)
menu_driver_ctx->navigation_decrement(menu_userdata);
break;
case RARCH_MENU_CTL_NAVIGATION_SET:
{
bool *scroll = (bool*)data;
if (!scroll)
return false;
if (menu_driver_ctx->navigation_set)
menu_driver_ctx->navigation_set(menu_userdata, *scroll);
}
break;
case RARCH_MENU_CTL_NAVIGATION_SET_LAST:
if (menu_driver_ctx->navigation_set_last)
menu_driver_ctx->navigation_set_last(menu_userdata);
break;
case RARCH_MENU_CTL_NAVIGATION_ASCEND_ALPHABET:
{
size_t *ptr_out = (size_t*)data;
if (!ptr_out)
return false;
if (menu_driver_ctx->navigation_ascend_alphabet)
menu_driver_ctx->navigation_ascend_alphabet(
menu_userdata, ptr_out);
}
case RARCH_MENU_CTL_NAVIGATION_DESCEND_ALPHABET:
{
size_t *ptr_out = (size_t*)data;
if (!ptr_out)
return false;
if (menu_driver_ctx->navigation_descend_alphabet)
menu_driver_ctx->navigation_descend_alphabet(
menu_userdata, ptr_out);
}
break;
case RARCH_MENU_CTL_NAVIGATION_CLEAR:
{
bool *pending_push = (bool*)data;
if (!pending_push)
return false;
if (menu_driver_ctx->navigation_clear)
menu_driver_ctx->navigation_clear(
menu_userdata, pending_push);
}
break;
case RARCH_MENU_CTL_POPULATE_ENTRIES:
{
menu_displaylist_info_t *info = (menu_displaylist_info_t*)data;
if (!info)
return false;
if (menu_driver_ctx->populate_entries)
menu_driver_ctx->populate_entries(
menu_userdata, info->path,
info->label, info->type);
}
break;
case RARCH_MENU_CTL_LIST_GET_ENTRY:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->list_get_entry)
{
list->entry = NULL;
return false;
}
list->entry = menu_driver_ctx->list_get_entry(menu_userdata,
list->type, list->idx);
}
break;
case RARCH_MENU_CTL_LIST_GET_SIZE:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->list_get_size)
{
list->size = 0;
return false;
}
list->size = menu_driver_ctx->list_get_size(menu_userdata, list->type);
}
break;
case RARCH_MENU_CTL_LIST_GET_SELECTION:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->list_get_selection)
{
list->selection = 0;
return false;
}
list->selection = menu_driver_ctx->list_get_selection(menu_userdata);
}
break;
case RARCH_MENU_CTL_LIST_FREE:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (menu_driver_ctx)
{
if (menu_driver_ctx->list_free)
menu_driver_ctx->list_free(list->list, list->idx, list->list_size);
}
if (list->list)
{
file_list_free_userdata (list->list, list->idx);
file_list_free_actiondata(list->list, list->idx);
}
}
break;
case RARCH_MENU_CTL_LIST_PUSH:
{
menu_ctx_displaylist_t *disp_list = (menu_ctx_displaylist_t*)data;
if (menu_driver_ctx->list_push)
if (menu_driver_ctx->list_push(menu_driver_data,
menu_userdata, disp_list->info, disp_list->type) == 0)
return true;
}
return false;
case RARCH_MENU_CTL_LIST_CLEAR:
{
file_list_t *list = (file_list_t*)data;
if (!list)
return false;
if (menu_driver_ctx->list_clear)
menu_driver_ctx->list_clear(list);
}
break;
case RARCH_MENU_CTL_TOGGLE:
{
bool *latch = (bool*)data;
if (!latch)
return false;
if (menu_driver_ctx && menu_driver_ctx->toggle)
menu_driver_ctx->toggle(menu_userdata, *latch);
}
break;
case RARCH_MENU_CTL_REFRESH:
{
#if 0
bool refresh = false;
menu_entries_ctl(MENU_ENTRIES_CTL_LIST_DEINIT, NULL);
menu_entries_ctl(MENU_ENTRIES_CTL_SETTINGS_DEINIT, NULL);
menu_entries_ctl(MENU_ENTRIES_CTL_INIT, NULL);
menu_entries_ctl(MENU_ENTRIES_CTL_SET_REFRESH, &refresh);
#endif
}
break;
case RARCH_MENU_CTL_CONTEXT_RESET:
if (!menu_driver_ctx || !menu_driver_ctx->context_reset)
return false;
menu_driver_ctx->context_reset(menu_userdata);
break;
case RARCH_MENU_CTL_CONTEXT_DESTROY:
if (!menu_driver_ctx || !menu_driver_ctx->context_destroy)
return false;
menu_driver_ctx->context_destroy(menu_userdata);
break;
case RARCH_MENU_CTL_SHADER_MANAGER_INIT:
menu_shader_manager_init(menu_driver_data);
break;
case RARCH_MENU_CTL_LIST_SET_SELECTION:
{
file_list_t *list = (file_list_t*)data;
if (!list)
return false;
if (!menu_driver_ctx || !menu_driver_ctx->list_set_selection)
return false;
menu_driver_ctx->list_set_selection(menu_userdata, list);
}
break;
case RARCH_MENU_CTL_LIST_CACHE:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!list || !menu_driver_ctx || !menu_driver_ctx->list_cache)
return false;
menu_driver_ctx->list_cache(menu_userdata,
list->type, list->action);
}
break;
case RARCH_MENU_CTL_LIST_INSERT:
{
menu_ctx_list_t *list = (menu_ctx_list_t*)data;
if (!list || !menu_driver_ctx || !menu_driver_ctx->list_insert)
return false;
menu_driver_ctx->list_insert(menu_userdata,
list->list, list->path, list->label, list->idx);
}
break;
case RARCH_MENU_CTL_LOAD_IMAGE:
{
menu_ctx_load_image_t *load_image_info =
(menu_ctx_load_image_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->load_image)
return false;
return menu_driver_ctx->load_image(menu_userdata,
load_image_info->data, load_image_info->type);
}
case RARCH_MENU_CTL_ITERATE:
{
bool retcode = false;
menu_ctx_iterate_t *iterate = (menu_ctx_iterate_t*)data;
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_QUICK_MENU, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_QUICK_MENU, NULL);
menu_entries_flush_stack(NULL, MENU_SETTINGS);
menu_display_set_msg_force(true);
generic_action_ok_displaylist_push("",
"", 0, 0, 0, ACTION_OK_DL_CONTENT_SETTINGS);
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_QUIT, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_QUIT, NULL);
return false;
}
return true;
}
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_QUIT, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_QUIT, NULL);
return false;
}
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_SHUTDOWN, NULL))
{
menu_driver_ctl(RARCH_MENU_CTL_UNSET_PENDING_SHUTDOWN, NULL);
if (!command_event(CMD_EVENT_QUIT, NULL))
return false;
return true;
}
if (!menu_driver_ctx || !menu_driver_ctx->iterate)
return false;
if (menu_driver_ctl(RARCH_MENU_CTL_IS_PENDING_ACTION, &retcode))
{
iterate->action = pending_iter.action;
pending_iter.action = MENU_ACTION_NOOP;
}
if (menu_driver_ctx->iterate(menu_driver_data,
menu_userdata, iterate->action) == -1)
return false;
}
break;
case RARCH_MENU_CTL_ENVIRONMENT:
{
menu_ctx_environment_t *menu_environ =
(menu_ctx_environment_t*)data;
if (menu_driver_ctx->environ_cb)
{
if (menu_driver_ctx->environ_cb(menu_environ->type,
menu_environ->data, menu_userdata) == 0)
return true;
}
}
return false;
case RARCH_MENU_CTL_POINTER_TAP:
{
menu_ctx_pointer_t *point = (menu_ctx_pointer_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->pointer_tap)
{
point->retcode = 0;
return false;
}
point->retcode = menu_driver_ctx->pointer_tap(menu_userdata,
point->x, point->y, point->ptr,
point->cbs, point->entry, point->action);
}
break;
case RARCH_MENU_CTL_BIND_INIT:
{
menu_ctx_bind_t *bind = (menu_ctx_bind_t*)data;
if (!menu_driver_ctx || !menu_driver_ctx->bind_init)
{
bind->retcode = 0;
return false;
}
bind->retcode = menu_driver_ctx->bind_init(
bind->cbs,
bind->path,
bind->label,
bind->type,
bind->idx,
bind->elem0,
bind->elem1,
bind->label_hash,
bind->menu_label_hash);
}
break;
case RARCH_MENU_CTL_UPDATE_THUMBNAIL_PATH:
{
size_t selection;
if (!menu_navigation_ctl(MENU_NAVIGATION_CTL_GET_SELECTION, &selection))
return false;
if (!menu_driver_ctx || !menu_driver_ctx->update_thumbnail_path)
return false;
menu_driver_ctx->update_thumbnail_path(menu_userdata, selection);
}
break;
case RARCH_MENU_CTL_UPDATE_THUMBNAIL_IMAGE:
{
if (!menu_driver_ctx || !menu_driver_ctx->update_thumbnail_image)
return false;
menu_driver_ctx->update_thumbnail_image(menu_userdata);
}
break;
default:
case RARCH_MENU_CTL_NONE:
break;
}
return true;
}
