Example #1
0
static int action_ok_file_load_with_detect_core(const char *path,
      const char *label, unsigned type, size_t idx)
{
   int ret;
   const char *menu_path    = NULL;
   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_get_last_stack(menu->menu_list,
         &menu_path, NULL, NULL);

   ret = rarch_defer_core(global->core_info,
         menu_path, path, label, menu->deferred_path,
         sizeof(menu->deferred_path));

   if (ret == -1)
   {
      event_command(EVENT_CMD_LOAD_CORE);
      menu_entries_common_load_content(false);
      return -1;
   }

   if (ret == 0)
      menu_list_push_stack_refresh(
            menu->menu_list,
            settings->libretro_directory,
            "deferred_core_list",
            0, idx);

   return ret;
}
Example #2
0
static int action_ok_core_updater_list(const char *path,
      const char *label, unsigned type, size_t idx)
{
   char url_path[PATH_MAX_LENGTH];
   menu_handle_t *menu      = menu_driver_get_ptr();
   driver_t *driver         = driver_get_ptr();
   settings_t *settings     = config_get_ptr();
   if (!menu)
      return -1;

   driver->menu->nonblocking_refresh = true;

   (void)url_path;

   if (settings->network.buildbot_url[0] == '\0')
      return -1;

#ifdef HAVE_NETWORKING
   event_command(EVENT_CMD_NETWORK_INIT);

   fill_pathname_join(url_path, settings->network.buildbot_url,
         ".index", sizeof(url_path));

   rarch_main_data_msg_queue_push(DATA_TYPE_HTTP, url_path, "cb_core_updater_list", 0, 1,
         true);
#endif

   return menu_list_push_stack_refresh(
         menu->menu_list,
         path, "deferred_core_updater_list", type, idx);
}
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;
}
Example #4
0
static int menu_action_handle_setting(rarch_setting_t *setting,
      unsigned type, unsigned action, bool wraparound)
{
   menu_handle_t *menu = menu_driver_get_ptr();

   if (!setting)
      return -1;

   switch (setting->type)
   {
      case ST_PATH:
         if (action == MENU_ACTION_OK)
            menu_list_push_stack_refresh(
                  menu->menu_list,
                  setting->default_value.string,
                  setting->name,
                  type,
                  menu->navigation.selection_ptr);
         /* fall-through. */
      case ST_BOOL:
      case ST_INT:
      case ST_UINT:
      case ST_HEX:
      case ST_FLOAT:
      case ST_STRING:
      case ST_DIR:
      case ST_BIND:
      case ST_ACTION:
         return menu_setting_handler(setting, action);
      default:
         break;
   }

   return -1;
}
Example #5
0
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;
}
Example #6
0
static int action_ok_push_default(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu = menu_driver_get_ptr();
   if (!menu)
      return -1;
   return menu_list_push_stack_refresh(
         menu->menu_list,
         label, label, type, idx);
}
Example #7
0
static int action_ok_shader_parameters(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu = menu_driver_get_ptr();
   if (!menu)
      return -1;
   return menu_list_push_stack_refresh(
         menu->menu_list,
         "", label, MENU_SETTING_ACTION,
         idx);
}
Example #8
0
static int action_ok_disk_image_append_list(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu      = menu_driver_get_ptr();
   settings_t *settings     = config_get_ptr();

   if (!menu)
      return -1;
   return menu_list_push_stack_refresh(
         menu->menu_list,
         settings->menu_content_directory, label, type,
         idx);
}
Example #9
0
static int action_ok_cheat_file(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu      = menu_driver_get_ptr();
   settings_t *settings     = config_get_ptr();
   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         settings->cheat_database,
         label, type, idx);
}
Example #10
0
static int action_ok_configurations_list(const char *path,
      const char *label, unsigned type, size_t idx)
{
   settings_t *settings     = config_get_ptr();
   menu_handle_t *menu      = menu_driver_get_ptr();
   const char *dir          = settings->menu_config_directory;
   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         dir ? dir : label, label, type,
         idx);
}
Example #11
0
static int action_ok_shader_preset(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu   = menu_driver_get_ptr();
   settings_t *settings  = config_get_ptr();

   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         settings->video.shader_dir,
         label, type, idx);
}
Example #12
0
static int action_ok_audio_dsp_plugin(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu      = menu_driver_get_ptr();
   settings_t *settings     = config_get_ptr();
   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         settings->audio.filter_dir,
         "audio_dsp_plugin",
         0, idx);
}
Example #13
0
static int action_ok_record_configfile(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu      = menu_driver_get_ptr();
   global_t   *global       = global_get_ptr();

   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         global->record.config_dir,
         label, type, idx);
}
Example #14
0
static int action_ok_remap_file(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu      = menu_driver_get_ptr();
   settings_t *settings     = config_get_ptr();

   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         settings->input_remapping_directory,
         label, type, idx);
}
Example #15
0
static int action_ok_video_filter(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu      = menu_driver_get_ptr();
   settings_t *settings     = config_get_ptr();
   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         settings->video.filter_dir,
         "deferred_video_filter",
         0, idx);
}
Example #16
0
static int action_ok_push_generic_list(const char *path,
      const char *label, unsigned type, size_t idx)
{
   menu_handle_t *menu = menu_driver_get_ptr();
   if (!menu)
      return -1;

   if (path)
      strlcpy(menu->deferred_path, path,
            sizeof(menu->deferred_path));

   return menu_list_push_stack_refresh(
         menu->menu_list,
         "", label, type, idx);
}
Example #17
0
static int action_ok_shader_pass(const char *path,
      const char *label, unsigned type, size_t idx)
{
   hack_shader_pass      = type - MENU_SETTINGS_SHADER_PASS_0;
   menu_handle_t *menu   = menu_driver_get_ptr();
   settings_t *settings  = config_get_ptr();
   if (!menu)
      return -1;

   return menu_list_push_stack_refresh(
         menu->menu_list,
         settings->video.shader_dir,
         label,
         type,
         idx);
}
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;
}
Example #19
0
static int action_ok_rdb_entry(const char *path,
      const char *label, unsigned type, size_t idx)
{
   char tmp[PATH_MAX_LENGTH];
   menu_handle_t *menu = menu_driver_get_ptr();
   if (!menu)
      return -1;

   strlcpy(tmp, "deferred_rdb_entry_detail|", sizeof(tmp));
   strlcat(tmp, path, sizeof(tmp));

   return menu_list_push_stack_refresh(
         menu->menu_list,
         label,
         tmp,
         0, idx);
}
Example #20
0
static int action_ok_cursor_manager_list(const char *path,
      const char *label, unsigned type, size_t idx)
{
   char cursor_path[PATH_MAX_LENGTH];
   menu_handle_t *menu      = menu_driver_get_ptr();
   settings_t *settings     = config_get_ptr();

   if (!menu)
      return -1;

   fill_pathname_join(cursor_path, settings->cursor_directory,
         path, sizeof(cursor_path));

   return menu_list_push_stack_refresh(
         menu->menu_list,
         cursor_path,
         "deferred_cursor_manager_list",
         0, idx);
}
Example #21
0
static int action_ok_directory_push(const char *path,
      const char *label, unsigned type, size_t idx)
{
   const char *menu_path  = NULL;
   const char *menu_label = NULL;
   char cat_path[PATH_MAX_LENGTH];
   menu_handle_t *menu = menu_driver_get_ptr();
   if (!menu)
      return -1;

   if (!path)
      return -1;

   menu_list_get_last_stack(menu->menu_list,
         &menu_path, &menu_label, NULL);

   fill_pathname_join(cat_path, menu_path, path, sizeof(cat_path));

   return menu_list_push_stack_refresh(menu->menu_list,
         cat_path, menu_label, type, idx);
}
Example #22
0
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;
}
Example #23
0
static int action_ok_database_manager_list(const char *path,
      const char *label, unsigned type, size_t idx)
{
   char rdb_path[PATH_MAX_LENGTH];
   menu_handle_t *menu      = menu_driver_get_ptr();
   settings_t *settings     = config_get_ptr();

   if (!menu)
      return -1;
   if (!path)
      return -1;
   if (!label)
      return -1;

   fill_pathname_join(rdb_path, settings->content_database,
         path, sizeof(rdb_path));

   return menu_list_push_stack_refresh(
         menu->menu_list,
         rdb_path,
         "deferred_database_manager_list",
         0, idx);
}
Example #24
0
static int action_ok_rdb_entry_submenu(const char *path,
      const char *label, unsigned type, size_t idx)
{
   int ret;
   union string_list_elem_attr attr;
   char new_label[PATH_MAX_LENGTH];
   char *rdb = NULL;
   int len = 0;
   struct string_list *str_list  = NULL;
   struct string_list *str_list2 = NULL;
   menu_handle_t *menu = menu_driver_get_ptr();

   if (!menu)
      return -1;

   if (!label)
      return -1;

   str_list = string_split(label, "|");

   if (!str_list)
      return -1;

   str_list2 = string_list_new();
   if (!str_list2)
   {
      string_list_free(str_list);
      return -1;
   }

   /* element 0 : label
    * element 1 : value
    * element 2 : database path
    */

   attr.i = 0;

   len += strlen(str_list->elems[1].data) + 1;
   string_list_append(str_list2, str_list->elems[1].data, attr);

   len += strlen(str_list->elems[2].data) + 1;
   string_list_append(str_list2, str_list->elems[2].data, attr);

   rdb = (char*)calloc(len, sizeof(char));

   if (!rdb)
   {
      string_list_free(str_list);
      string_list_free(str_list2);
      return -1;
   }

   string_list_join_concat(rdb, len, str_list2, "|");

   strlcpy(new_label, "deferred_cursor_manager_list_", sizeof(new_label));
   strlcat(new_label, str_list->elems[0].data, sizeof(new_label));

   ret = menu_list_push_stack_refresh(
         menu->menu_list,
         rdb,
         new_label,
         0, idx);

   string_list_free(str_list);
   string_list_free(str_list2);

   return ret;
}