From 1614519874dc697fef1daf69acd380641775f83d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Andr=C3=A9=20Santoni?= Date: Sun, 8 Apr 2018 09:55:16 +0700 Subject: [PATCH] Clone xmb to stripe menu --- .vscode/c_cpp_properties.json | 251 +- Makefile.common | 11 + configuration.c | 5 + file_path_special.c | 4 + griffin/griffin.c | 4 + menu/drivers/stripes.c | 5205 +++++++++++++++++ menu/menu_driver.c | 3 + menu/menu_driver.h | 1 + pkg/apple/RetroArch.xcodeproj/project.pbxproj | 4 +- qb/config.libs.sh | 2 + qb/config.params.sh | 1 + 11 files changed, 5365 insertions(+), 126 deletions(-) create mode 100755 menu/drivers/stripes.c diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json index 81c2529184..c6f4ffd0eb 100644 --- a/.vscode/c_cpp_properties.json +++ b/.vscode/c_cpp_properties.json @@ -1,125 +1,128 @@ -{ - "configurations": [ - { - "name": "Mac", - "includePath": [ - "/usr/include", - "/usr/local/include", - "${workspaceRoot}" - ], - "defines": [], - "intelliSenseMode": "clang-x64", - "browse": { - "path": [ - "/usr/include", - "/usr/local/include", - "${workspaceRoot}" - ], - "limitSymbolsToIncludedHeaders": true, - "databaseFilename": "" - }, - "macFrameworkPath": [ - "/System/Library/Frameworks", - "/Library/Frameworks" - ] - }, - { - "name": "Linux", - "includePath": [ - "/usr/include", - "/usr/local/include", - "${workspaceRoot}" - ], - "defines": [], - "intelliSenseMode": "clang-x64", - "browse": { - "path": [ - "/usr/include", - "/usr/local/include", - "${workspaceRoot}" - ], - "limitSymbolsToIncludedHeaders": true, - "databaseFilename": "" - } - }, - { - "name": "Win32", - "includePath": [ - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/um", - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/ucrt", - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/shared", - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/winrt", - "${workspaceRoot}" - ], - "defines": [ - "_DEBUG", - "UNICODE" - ], - "intelliSenseMode": "msvc-x64", - "browse": { - "path": [ - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/um", - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/ucrt", - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/shared", - "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/winrt", - "${workspaceRoot}" - ], - "limitSymbolsToIncludedHeaders": true, - "databaseFilename": "" - } - }, - { - "name": "msys2-mingw32", - "includePath": [ - "C:/msys64/mingw32/include", - "C:/msys64/mingw32/i686-w64-mingw32/include", - "${workspaceRoot}/libretro-common/include", - "${workspaceRoot}/include", - "${workspaceRoot}" - ], - "defines": [ - "_DEBUG", - "UNICODE" - ], - "intelliSenseMode": "msvc-x64", - "browse": { - "path": [ - "C:/msys64/mingw32/include", - "C:/msys64/mingw32/i686-w64-mingw32/include", - "${workspaceRoot}/libretro-common/include", - "${workspaceRoot}/include", - "${workspaceRoot}" - ], - "limitSymbolsToIncludedHeaders": true, - "databaseFilename": "" - } - }, - { - "name": "msys2-mingw64", - "includePath": [ - "C:/msys64/mingw64/include", - "C:/msys64/mingw64/x86_64-w64-mingw32/include", - "${workspaceRoot}/libretro-common/include", - "${workspaceRoot}/include", - "${workspaceRoot}" - ], - "defines": [ - "_DEBUG", - "UNICODE" - ], - "intelliSenseMode": "msvc-x64", - "browse": { - "path": [ - "C:/msys64/mingw64/include", - "C:/msys64/mingw64/x86_64-w64-mingw32/include", - "${workspaceRoot}/libretro-common/include", - "${workspaceRoot}/include", - "${workspaceRoot}" - ], - "limitSymbolsToIncludedHeaders": true, - "databaseFilename": "" - } - } - ], - "version": 3 +{ + "configurations": [ + { + "name": "Mac", + "includePath": [ + "/usr/include", + "/usr/local/include", + "${workspaceRoot}" + ], + "defines": [], + "intelliSenseMode": "clang-x64", + "browse": { + "path": [ + "/usr/include", + "/usr/local/include", + "${workspaceRoot}" + ], + "limitSymbolsToIncludedHeaders": true, + "databaseFilename": "" + }, + "macFrameworkPath": [ + "/System/Library/Frameworks", + "/Library/Frameworks" + ], + "compilerPath": "/usr/bin/clang", + "cStandard": "c11", + "cppStandard": "c++17" + }, + { + "name": "Linux", + "includePath": [ + "/usr/include", + "/usr/local/include", + "${workspaceRoot}" + ], + "defines": [], + "intelliSenseMode": "clang-x64", + "browse": { + "path": [ + "/usr/include", + "/usr/local/include", + "${workspaceRoot}" + ], + "limitSymbolsToIncludedHeaders": true, + "databaseFilename": "" + } + }, + { + "name": "Win32", + "includePath": [ + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/um", + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/ucrt", + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/shared", + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/winrt", + "${workspaceRoot}" + ], + "defines": [ + "_DEBUG", + "UNICODE" + ], + "intelliSenseMode": "msvc-x64", + "browse": { + "path": [ + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/um", + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/ucrt", + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/shared", + "C:/Program Files (x86)/Windows Kits/10/Include/10.0.15063.0/winrt", + "${workspaceRoot}" + ], + "limitSymbolsToIncludedHeaders": true, + "databaseFilename": "" + } + }, + { + "name": "msys2-mingw32", + "includePath": [ + "C:/msys64/mingw32/include", + "C:/msys64/mingw32/i686-w64-mingw32/include", + "${workspaceRoot}/libretro-common/include", + "${workspaceRoot}/include", + "${workspaceRoot}" + ], + "defines": [ + "_DEBUG", + "UNICODE" + ], + "intelliSenseMode": "msvc-x64", + "browse": { + "path": [ + "C:/msys64/mingw32/include", + "C:/msys64/mingw32/i686-w64-mingw32/include", + "${workspaceRoot}/libretro-common/include", + "${workspaceRoot}/include", + "${workspaceRoot}" + ], + "limitSymbolsToIncludedHeaders": true, + "databaseFilename": "" + } + }, + { + "name": "msys2-mingw64", + "includePath": [ + "C:/msys64/mingw64/include", + "C:/msys64/mingw64/x86_64-w64-mingw32/include", + "${workspaceRoot}/libretro-common/include", + "${workspaceRoot}/include", + "${workspaceRoot}" + ], + "defines": [ + "_DEBUG", + "UNICODE" + ], + "intelliSenseMode": "msvc-x64", + "browse": { + "path": [ + "C:/msys64/mingw64/include", + "C:/msys64/mingw64/x86_64-w64-mingw32/include", + "${workspaceRoot}/libretro-common/include", + "${workspaceRoot}/include", + "${workspaceRoot}" + ], + "limitSymbolsToIncludedHeaders": true, + "databaseFilename": "" + } + } + ], + "version": 3 } \ No newline at end of file diff --git a/Makefile.common b/Makefile.common index 972d61e34e..7163289e68 100644 --- a/Makefile.common +++ b/Makefile.common @@ -724,11 +724,16 @@ ifeq ($(HW_CONTEXT_MENU_DRIVERS), 1) ifeq ($(HAVE_XMB),) HAVE_XMB = 1 endif + + ifeq ($(HAVE_STRIPES),) + HAVE_STRIPES = 1 + endif else HAVE_ZARCH ?= 0 HAVE_MATERIALUI ?= 0 #HAVE_NUKLEAR ?= 0 HAVE_XMB ?= 0 + HAVE_STRIPES ?= 0 endif ifeq ($(HAVE_RGUI), 1) @@ -760,6 +765,12 @@ ifeq ($(HAVE_XMB), 1) HAVE_MENU_COMMON = 1 endif +ifeq ($(HAVE_STRIPES), 1) + OBJ += menu/drivers/stripes.o + DEFINES += -DHAVE_STRIPES + HAVE_MENU_COMMON = 1 +endif + ifeq ($(HAVE_LAKKA), 1) DEFINES += -DHAVE_LAKKA endif diff --git a/configuration.c b/configuration.c index 9f0eed8a04..f3a2f5b6f3 100644 --- a/configuration.c +++ b/configuration.c @@ -271,6 +271,7 @@ enum menu_driver_enum MENU_XUI, MENU_MATERIALUI, MENU_XMB, + MENU_STRIPES, MENU_NUKLEAR, MENU_NULL }; @@ -502,6 +503,8 @@ static enum location_driver_enum LOCATION_DEFAULT_DRIVER = LOCATION_NULL; static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_XUI; #elif defined(HAVE_MATERIALUI) && defined(RARCH_MOBILE) static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_MATERIALUI; +#elif defined(HAVE_STRIPES) && !defined(_XBOX) +static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_XMB; #elif defined(HAVE_XMB) && !defined(_XBOX) static enum menu_driver_enum MENU_DEFAULT_DRIVER = MENU_XMB; #elif defined(HAVE_RGUI) @@ -995,6 +998,8 @@ const char *config_get_default_menu(void) return "glui"; case MENU_XMB: return "xmb"; + case MENU_STRIPES: + return "stripes"; case MENU_NUKLEAR: return "nuklear"; case MENU_NULL: diff --git a/file_path_special.c b/file_path_special.c index e58d10032f..2f1a002567 100644 --- a/file_path_special.c +++ b/file_path_special.c @@ -130,6 +130,10 @@ bool fill_pathname_application_data(char *s, size_t len) const char* xmb_theme_ident(void); #endif +#ifdef HAVE_STRIPES +const char* stripes_theme_ident(void); +#endif + void fill_pathname_application_special(char *s, size_t len, enum application_special_type type) { diff --git a/griffin/griffin.c b/griffin/griffin.c index bb0d9121f6..e79c991044 100644 --- a/griffin/griffin.c +++ b/griffin/griffin.c @@ -1220,6 +1220,10 @@ MENU #include "../menu/drivers/xmb.c" #endif +#ifdef HAVE_STRIPES +#include "../menu/drivers/stripes.c" +#endif + #ifdef HAVE_MATERIALUI #include "../menu/drivers/materialui.c" #endif diff --git a/menu/drivers/stripes.c b/menu/drivers/stripes.c new file mode 100755 index 0000000000..520cf87812 --- /dev/null +++ b/menu/drivers/stripes.c @@ -0,0 +1,5205 @@ +/* RetroArch - A frontend for libretro. + * Copyright (C) 2011-2017 - Daniel De Matteis + * Copyright (C) 2014-2017 - Jean-André Santoni + * Copyright (C) 2016-2017 - Brad Parker + * Copyright (C) 2018 - Alfredo Monclús + * + * RetroArch is free software: you can redistribute it and/or modify it under the terms + * of the GNU General Public License as published by the Free Software Found- + * ation, either version 3 of the License, or (at your option) any later version. + * + * RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with RetroArch. + * If not, see . + */ + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_CONFIG_H +#include "../../config.h" +#endif + +#include "../../frontend/frontend_driver.h" + +#include "menu_generic.h" + +#include "../menu_driver.h" +#include "../menu_animation.h" + +#include "../../core_info.h" +#include "../../core.h" +#include "../menu_entries.h" +#include "../widgets/menu_entry.h" +#include "../widgets/menu_input_dialog.h" +#include "../widgets/menu_osk.h" +#include "../widgets/menu_filebrowser.h" + +#include "../menu_event.h" + +#include "../../verbosity.h" +#include "../../configuration.h" +#include "../../playlist.h" +#include "../../retroarch.h" + +#include "../../tasks/tasks_internal.h" + +#include "../../cheevos/badges.h" +#include "../../content.h" + +#define STRIPES_RIBBON_ROWS 64 +#define STRIPES_RIBBON_COLS 64 +#define STRIPES_RIBBON_VERTICES 2*STRIPES_RIBBON_COLS*STRIPES_RIBBON_ROWS-2*STRIPES_RIBBON_COLS + +#ifndef STRIPES_DELAY +#define STRIPES_DELAY 10 +#endif + +#define BATTERY_LEVEL_CHECK_INTERVAL (30 * 1000000) + +#if 0 +#define STRIPES_DEBUG +#endif + +/* NOTE: If you change this you HAVE to update + * stripes_alloc_node() and stripes_copy_node() */ +typedef struct +{ + float alpha; + float label_alpha; + float zoom; + float x; + float y; + uintptr_t icon; + uintptr_t content_icon; + char *fullpath; +} stripes_node_t; + +enum +{ + STRIPES_TEXTURE_MAIN_MENU = 0, + STRIPES_TEXTURE_SETTINGS, + STRIPES_TEXTURE_HISTORY, + STRIPES_TEXTURE_FAVORITES, + STRIPES_TEXTURE_MUSICS, +#ifdef HAVE_FFMPEG + STRIPES_TEXTURE_MOVIES, +#endif +#ifdef HAVE_NETWORKING + STRIPES_TEXTURE_NETPLAY, + STRIPES_TEXTURE_ROOM, +/* stub these out until we have the icons + STRIPES_TEXTURE_ROOM_LAN, + STRIPES_TEXTURE_ROOM_MITM,*/ +#endif +#ifdef HAVE_IMAGEVIEWER + STRIPES_TEXTURE_IMAGES, +#endif + STRIPES_TEXTURE_SETTING, + STRIPES_TEXTURE_SUBSETTING, + STRIPES_TEXTURE_ARROW, + STRIPES_TEXTURE_RUN, + STRIPES_TEXTURE_CLOSE, + STRIPES_TEXTURE_RESUME, + STRIPES_TEXTURE_SAVESTATE, + STRIPES_TEXTURE_LOADSTATE, + STRIPES_TEXTURE_UNDO, + STRIPES_TEXTURE_CORE_INFO, + STRIPES_TEXTURE_WIFI, + STRIPES_TEXTURE_CORE_OPTIONS, + STRIPES_TEXTURE_INPUT_REMAPPING_OPTIONS, + STRIPES_TEXTURE_CHEAT_OPTIONS, + STRIPES_TEXTURE_DISK_OPTIONS, + STRIPES_TEXTURE_SHADER_OPTIONS, + STRIPES_TEXTURE_ACHIEVEMENT_LIST, + STRIPES_TEXTURE_SCREENSHOT, + STRIPES_TEXTURE_RELOAD, + STRIPES_TEXTURE_RENAME, + STRIPES_TEXTURE_FILE, + STRIPES_TEXTURE_FOLDER, + STRIPES_TEXTURE_ZIP, + STRIPES_TEXTURE_FAVORITE, + STRIPES_TEXTURE_ADD_FAVORITE, + STRIPES_TEXTURE_MUSIC, + STRIPES_TEXTURE_IMAGE, + STRIPES_TEXTURE_MOVIE, + STRIPES_TEXTURE_CORE, + STRIPES_TEXTURE_RDB, + STRIPES_TEXTURE_CURSOR, + STRIPES_TEXTURE_SWITCH_ON, + STRIPES_TEXTURE_SWITCH_OFF, + STRIPES_TEXTURE_CLOCK, + STRIPES_TEXTURE_BATTERY_FULL, + STRIPES_TEXTURE_BATTERY_CHARGING, + STRIPES_TEXTURE_POINTER, + STRIPES_TEXTURE_ADD, + STRIPES_TEXTURE_KEY, + STRIPES_TEXTURE_KEY_HOVER, + STRIPES_TEXTURE_DIALOG_SLICE, + STRIPES_TEXTURE_LAST +}; + +enum +{ + STRIPES_SYSTEM_TAB_MAIN = 0, + STRIPES_SYSTEM_TAB_SETTINGS, + STRIPES_SYSTEM_TAB_HISTORY, + STRIPES_SYSTEM_TAB_FAVORITES, + STRIPES_SYSTEM_TAB_MUSIC, +#ifdef HAVE_FFMPEG + STRIPES_SYSTEM_TAB_VIDEO, +#endif +#ifdef HAVE_IMAGEVIEWER + STRIPES_SYSTEM_TAB_IMAGES, +#endif +#ifdef HAVE_NETWORKING + STRIPES_SYSTEM_TAB_NETPLAY, +#endif + STRIPES_SYSTEM_TAB_ADD, + + /* End of this enum - use the last one to determine num of possible tabs */ + STRIPES_SYSTEM_TAB_MAX_LENGTH +}; + +typedef struct stripes_handle +{ + bool mouse_show; + + uint8_t system_tab_end; + uint8_t tabs[STRIPES_SYSTEM_TAB_MAX_LENGTH]; + + int depth; + int old_depth; + int icon_size; + int cursor_size; + + size_t categories_selection_ptr; + size_t categories_selection_ptr_old; + size_t selection_ptr_old; + + unsigned categories_active_idx; + unsigned categories_active_idx_old; + uintptr_t thumbnail; + uintptr_t left_thumbnail; + uintptr_t savestate_thumbnail; + + float x; + float alpha; + float thumbnail_width; + float thumbnail_height; + float left_thumbnail_width; + float left_thumbnail_height; + float savestate_thumbnail_width; + float savestate_thumbnail_height; + float above_subitem_offset; + float above_item_offset; + float active_item_factor; + float under_item_offset; + float shadow_offset; + float font_size; + float font2_size; + + float margins_screen_left; + float margins_screen_top; + float margins_setting_left; + float margins_title_left; + float margins_title_top; + float margins_title_bottom; + float margins_label_left; + float margins_label_top; + float icon_spacing_horizontal; + float icon_spacing_vertical; + float items_active_alpha; + float items_active_zoom; + float items_passive_alpha; + float items_passive_zoom; + float margins_dialog; + float margins_slice; + float textures_arrow_alpha; + float categories_x_pos; + float categories_passive_alpha; + float categories_passive_zoom; + float categories_active_zoom; + float categories_active_alpha; + + uint64_t frame_count; + + char title_name[255]; + char *box_message; + char *thumbnail_system; + char *thumbnail_content; + char *savestate_thumbnail_file_path; + char *thumbnail_file_path; + char *left_thumbnail_file_path; + char *bg_file_path; + + file_list_t *selection_buf_old; + file_list_t *horizontal_list; + + struct + { + menu_texture_item bg; + menu_texture_item list[STRIPES_TEXTURE_LAST]; + } textures; + + stripes_node_t main_menu_node; +#ifdef HAVE_IMAGEVIEWER + stripes_node_t images_tab_node; +#endif + stripes_node_t music_tab_node; +#ifdef HAVE_FFMPEG + stripes_node_t video_tab_node; +#endif + stripes_node_t settings_tab_node; + stripes_node_t history_tab_node; + stripes_node_t favorites_tab_node; + stripes_node_t add_tab_node; + stripes_node_t netplay_tab_node; + + font_data_t *font; + font_data_t *font2; + video_font_raster_block_t raster_block; + video_font_raster_block_t raster_block2; +} stripes_handle_t; + +float stripes_scale_mod[8] = { + 1, 1, 1, 1, 1, 1, 1, 1 +}; + +static float stripes_coord_shadow[] = { + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, 0 +}; + +static float stripes_coord_black[] = { + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, + 0, 0, 0, 0 +}; + +static float stripes_coord_white[] = { + 1, 1, 1, + 1, 1, 1, + 1, 1, 1, + 1, 1, 1, + 1, 1, 1, 1 +}; + +static float stripes_item_color[] = { + 1, 1, 1, + 1, 1, 1, + 1, 1, 1, + 1, 1, 1, + 1, 1, 1, 1 +}; + + +float stripes_stripes_gradient_dark_purple[16] = { + 20/255.0, 13/255.0, 20/255.0, 1.0, + 20/255.0, 13/255.0, 20/255.0, 1.0, + 92/255.0, 44/255.0, 92/255.0, 1.0, + 148/255.0, 90/255.0, 148/255.0, 1.0, +}; + +float stripes_gradient_midnight_blue[16] = { + 44/255.0, 62/255.0, 80/255.0, 1.0, + 44/255.0, 62/255.0, 80/255.0, 1.0, + 44/255.0, 62/255.0, 80/255.0, 1.0, + 44/255.0, 62/255.0, 80/255.0, 1.0, +}; + +float stripes_gradient_golden[16] = { + 174/255.0, 123/255.0, 44/255.0, 1.0, + 205/255.0, 174/255.0, 84/255.0, 1.0, + 58/255.0, 43/255.0, 24/255.0, 1.0, + 58/255.0, 43/255.0, 24/255.0, 1.0, +}; + +float stripes_gradient_legacy_red[16] = { + 171/255.0, 70/255.0, 59/255.0, 1.0, + 171/255.0, 70/255.0, 59/255.0, 1.0, + 190/255.0, 80/255.0, 69/255.0, 1.0, + 190/255.0, 80/255.0, 69/255.0, 1.0, +}; + +float stripes_gradient_electric_blue[16] = { + 1/255.0, 2/255.0, 67/255.0, 1.0, + 1/255.0, 73/255.0, 183/255.0, 1.0, + 1/255.0, 93/255.0, 194/255.0, 1.0, + 3/255.0, 162/255.0, 254/255.0, 1.0, +}; + +float stripes_gradient_apple_green[16] = { + 102/255.0, 134/255.0, 58/255.0, 1.0, + 122/255.0, 131/255.0, 52/255.0, 1.0, + 82/255.0, 101/255.0, 35/255.0, 1.0, + 63/255.0, 95/255.0, 30/255.0, 1.0, +}; + +float stripes_gradient_undersea[16] = { + 23/255.0, 18/255.0, 41/255.0, 1.0, + 30/255.0, 72/255.0, 114/255.0, 1.0, + 52/255.0, 88/255.0, 110/255.0, 1.0, + 69/255.0, 125/255.0, 140/255.0, 1.0, + +}; + +float stripes_gradient_volcanic_red[16] = { + 1.0, 0.0, 0.1, 1.00, + 1.0, 0.1, 0.0, 1.00, + 0.1, 0.0, 0.1, 1.00, + 0.1, 0.0, 0.1, 1.00, +}; + +float stripes_gradient_dark[16] = { + 0.1, 0.1, 0.1, 1.00, + 0.1, 0.1, 0.1, 1.00, + 0.0, 0.0, 0.0, 1.00, + 0.0, 0.0, 0.0, 1.00, +}; + +float stripes_gradient_light[16] = { + 1.0, 1.0, 1.0, 1.00, + 1.0, 1.0, 1.0, 1.00, + 1.0, 1.0, 1.0, 1.00, + 1.0, 1.0, 1.0, 1.00, +}; + +float stripes_gradient_morning_blue[16] = { + 221/255.0, 241/255.0, 254/255.0, 1.00, + 135/255.0, 206/255.0, 250/255.0, 1.00, + 1.0, 1.0, 1.0, 1.00, + 170/255.0, 200/255.0, 252/255.0, 1.00, +}; + +static void stripes_calculate_visible_range(const stripes_handle_t *stripes, + unsigned height, size_t list_size, unsigned current, + unsigned *first, unsigned *last); + +const char* stripes_theme_ident(void) +{ + settings_t *settings = config_get_ptr(); + switch (settings->uints.menu_xmb_theme) + { + case XMB_ICON_THEME_FLATUI: + return "flatui"; + case XMB_ICON_THEME_RETROACTIVE: + return "retroactive"; + case XMB_ICON_THEME_RETROSYSTEM: + return "retrosystem"; + case XMB_ICON_THEME_PIXEL: + return "pixel"; + case XMB_ICON_THEME_NEOACTIVE: + return "neoactive"; + case XMB_ICON_THEME_SYSTEMATIC: + return "systematic"; + case XMB_ICON_THEME_DOTART: + return "dot-art"; + case XMB_ICON_THEME_CUSTOM: + return "custom"; + case XMB_ICON_THEME_MONOCHROME_INVERTED: + return "monochrome-inverted"; + case XMB_ICON_THEME_MONOCHROME: + default: + break; + } + + return "monochrome"; +} + +/* NOTE: This exists because calloc()ing stripes_node_t is expensive + * when you can have big lists like MAME and fba playlists */ +static stripes_node_t *stripes_alloc_node(void) +{ + stripes_node_t *node = (stripes_node_t*)malloc(sizeof(*node)); + + node->alpha = node->label_alpha = 0; + node->zoom = node->x = node->y = 0; + node->icon = node->content_icon = 0; + node->fullpath = NULL; + + return node; +} + +static void stripes_free_node(stripes_node_t *node) +{ + if (!node) + return; + + if (node->fullpath) + free(node->fullpath); + + node->fullpath = NULL; + + free(node); +} + +/** + * @brief frees all stripes_node_t in a file_list_t + * + * file_list_t asumes userdata holds a simple structure and + * free()'s it. Can't change this at the time because other + * code depends on this behavior. + * + * @param list + * @param actiondata whether to free actiondata too + */ +static void stripes_free_list_nodes(file_list_t *list, bool actiondata) +{ + unsigned i, size = file_list_get_size(list); + + for (i = 0; i < size; ++i) + { + stripes_free_node((stripes_node_t*)file_list_get_userdata_at_offset(list, i)); + + /* file_list_set_userdata() doesn't accept NULL */ + list->list[i].userdata = NULL; + + if (actiondata) + file_list_free_actiondata(list, i); + } +} + +static stripes_node_t *stripes_copy_node(const stripes_node_t *old_node) +{ + stripes_node_t *new_node = (stripes_node_t*)malloc(sizeof(*new_node)); + + *new_node = *old_node; + new_node->fullpath = old_node->fullpath ? strdup(old_node->fullpath) : NULL; + + return new_node; +} + +static const char *stripes_thumbnails_ident(char pos) +{ + char folder = 0; + settings_t *settings = config_get_ptr(); + + if (pos == 'R') + folder = settings->uints.menu_thumbnails; + if (pos == 'L') + folder = settings->uints.menu_left_thumbnails; + + switch (folder) + { + case 1: + return "Named_Snaps"; + case 2: + return "Named_Titles"; + case 3: + return "Named_Boxarts"; + case 0: + default: + break; + } + + return msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF); +} + +static float *stripes_gradient_ident(video_frame_info_t *video_info) +{ + switch (video_info->xmb_color_theme) + { + case XMB_THEME_DARK_PURPLE: + return &stripes_stripes_gradient_dark_purple[0]; + case XMB_THEME_MIDNIGHT_BLUE: + return &stripes_gradient_midnight_blue[0]; + case XMB_THEME_GOLDEN: + return &stripes_gradient_golden[0]; + case XMB_THEME_ELECTRIC_BLUE: + return &stripes_gradient_electric_blue[0]; + case XMB_THEME_APPLE_GREEN: + return &stripes_gradient_apple_green[0]; + case XMB_THEME_UNDERSEA: + return &stripes_gradient_undersea[0]; + case XMB_THEME_VOLCANIC_RED: + return &stripes_gradient_volcanic_red[0]; + case XMB_THEME_DARK: + return &stripes_gradient_dark[0]; + case XMB_THEME_LIGHT: + return &stripes_gradient_light[0]; + case XMB_THEME_MORNING_BLUE: + return &stripes_gradient_morning_blue[0]; + case XMB_THEME_LEGACY_RED: + default: + break; + } + + return &stripes_gradient_legacy_red[0]; +} + +static size_t stripes_list_get_selection(void *data) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (!stripes) + return 0; + + return stripes->categories_selection_ptr; +} + +static size_t stripes_list_get_size(void *data, enum menu_list_type type) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + + switch (type) + { + case MENU_LIST_PLAIN: + return menu_entries_get_stack_size(0); + case MENU_LIST_HORIZONTAL: + if (stripes && stripes->horizontal_list) + return file_list_get_size(stripes->horizontal_list); + break; + case MENU_LIST_TABS: + return stripes->system_tab_end; + } + + return 0; +} + +static void *stripes_list_get_entry(void *data, + enum menu_list_type type, unsigned i) +{ + size_t list_size = 0; + stripes_handle_t *stripes = (stripes_handle_t*)data; + + switch (type) + { + case MENU_LIST_PLAIN: + { + file_list_t *menu_stack = menu_entries_get_menu_stack_ptr(0); + list_size = menu_entries_get_stack_size(0); + if (i < list_size) + return (void*)&menu_stack->list[i]; + } + break; + case MENU_LIST_HORIZONTAL: + if (stripes && stripes->horizontal_list) + list_size = file_list_get_size(stripes->horizontal_list); + if (i < list_size) + return (void*)&stripes->horizontal_list->list[i]; + break; + default: + break; + } + + return NULL; +} + +static INLINE float stripes_item_y(const stripes_handle_t *stripes, int i, size_t current) +{ + float iy = stripes->icon_spacing_vertical; + + if (i < (int)current) + if (stripes->depth > 1) + iy *= (i - (int)current + stripes->above_subitem_offset); + else + iy *= (i - (int)current + stripes->above_item_offset); + else + iy *= (i - (int)current + stripes->under_item_offset); + + if (i == (int)current) + iy = stripes->icon_spacing_vertical * stripes->active_item_factor; + + return iy; +} + +static void stripes_draw_icon( + video_frame_info_t *video_info, + int icon_size, + math_matrix_4x4 *mymat, + uintptr_t texture, + float x, + float y, + unsigned width, + unsigned height, + float alpha, + float rotation, + float scale_factor, + float *color, + float shadow_offset) +{ + menu_display_ctx_draw_t draw; + struct video_coords coords; + + if ( + (x < (-icon_size / 2.0f)) || + (x > width) || + (y < (icon_size / 2.0f)) || + (y > height + icon_size) + ) + return; + + coords.vertices = 4; + coords.vertex = NULL; + coords.tex_coord = NULL; + coords.lut_tex_coord = NULL; + + draw.width = icon_size; + draw.height = icon_size; + draw.rotation = rotation; + draw.scale_factor = scale_factor; +#if defined(VITA) || defined(WIIU) + draw.width *= scale_factor; + draw.height *= scale_factor; +#endif + draw.coords = &coords; + draw.matrix_data = mymat; + draw.texture = texture; + draw.prim_type = MENU_DISPLAY_PRIM_TRIANGLESTRIP; + draw.pipeline.id = 0; + + if (video_info->xmb_shadows_enable) + { + menu_display_set_alpha(stripes_coord_shadow, color[3] * 0.35f); + + coords.color = stripes_coord_shadow; + draw.x = x + shadow_offset; + draw.y = height - y - shadow_offset; + +#if defined(VITA) || defined(WIIU) + if(scale_factor < 1) + { + draw.x = draw.x + (icon_size-draw.width)/2; + draw.y = draw.y + (icon_size-draw.width)/2; + } +#endif + menu_display_draw(&draw, video_info); + } + + coords.color = (const float*)color; + draw.x = x; + draw.y = height - y; + +#if defined(VITA) || defined(WIIU) + if(scale_factor < 1) + { + draw.x = draw.x + (icon_size-draw.width)/2; + draw.y = draw.y + (icon_size-draw.width)/2; + } +#endif + menu_display_draw(&draw, video_info); +} + +static void stripes_draw_thumbnail( + video_frame_info_t *video_info, + stripes_handle_t *stripes, float *color, + unsigned width, unsigned height, + float x, float y, + float w, float h, uintptr_t texture) +{ + menu_display_ctx_rotate_draw_t rotate_draw; + menu_display_ctx_draw_t draw; + struct video_coords coords; + math_matrix_4x4 mymat; + + rotate_draw.matrix = &mymat; + rotate_draw.rotation = 0; + rotate_draw.scale_x = 1; + rotate_draw.scale_y = 1; + rotate_draw.scale_z = 1; + rotate_draw.scale_enable = true; + + menu_display_rotate_z(&rotate_draw, video_info); + + coords.vertices = 4; + coords.vertex = NULL; + coords.tex_coord = NULL; + coords.lut_tex_coord = NULL; + + draw.width = w; + draw.height = h; + draw.coords = &coords; + draw.matrix_data = &mymat; + draw.texture = texture; + draw.prim_type = MENU_DISPLAY_PRIM_TRIANGLESTRIP; + draw.pipeline.id = 0; + + if (video_info->xmb_shadows_enable) + { + menu_display_set_alpha(stripes_coord_shadow, color[3] * 0.35f); + + coords.color = stripes_coord_shadow; + draw.x = x + stripes->shadow_offset; + draw.y = height - y - stripes->shadow_offset; + + menu_display_draw(&draw, video_info); + } + + coords.color = (const float*)color; + draw.x = x; + draw.y = height - y; + + menu_display_set_alpha(color, 1.0f); + + menu_display_draw(&draw, video_info); +} + +static void stripes_draw_text( + video_frame_info_t *video_info, + stripes_handle_t *stripes, + const char *str, float x, + float y, float scale_factor, float alpha, + enum text_alignment text_align, + unsigned width, unsigned height, font_data_t* font) +{ + uint32_t color; + uint8_t a8; + settings_t *settings; + + if (alpha > stripes->alpha) + alpha = stripes->alpha; + + a8 = 255 * alpha; + + /* Avoid drawing 100% transparent text */ + if (a8 == 0) + return; + + settings = config_get_ptr(); + color = FONT_COLOR_RGBA( + settings->uints.menu_font_color_red, + settings->uints.menu_font_color_green, + settings->uints.menu_font_color_blue, a8); + + menu_display_draw_text(font, str, x, y, + width, height, color, text_align, scale_factor, + video_info->xmb_shadows_enable, + stripes->shadow_offset); +} + +static void stripes_messagebox(void *data, const char *message) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (!stripes || string_is_empty(message)) + return; + + stripes->box_message = strdup(message); +} + +static void stripes_render_keyboard(stripes_handle_t *stripes, + video_frame_info_t *video_info, + const char *grid[], unsigned id) +{ + unsigned i; + int ptr_width, ptr_height; + unsigned width = video_info->width; + unsigned height = video_info->height; + float dark[16] = { + 0.00, 0.00, 0.00, 0.85, + 0.00, 0.00, 0.00, 0.85, + 0.00, 0.00, 0.00, 0.85, + 0.00, 0.00, 0.00, 0.85, + }; + + float white[16]= { + 1.00, 1.00, 1.00, 1.00, + 1.00, 1.00, 1.00, 1.00, + 1.00, 1.00, 1.00, 1.00, + 1.00, 1.00, 1.00, 1.00, + }; + + menu_display_draw_quad( + video_info, + 0, height/2.0, width, height/2.0, + width, height, + &dark[0]); + + ptr_width = width / 11; + ptr_height = height / 10; + + if (ptr_width >= ptr_height) + ptr_width = ptr_height; + + for (i = 0; i < 44; i++) + { + int line_y = (i / 11) * height / 10.0; + + if (i == id) + { + uintptr_t texture = stripes->textures.list[STRIPES_TEXTURE_KEY_HOVER]; + + menu_display_blend_begin(video_info); + + menu_display_draw_texture( + video_info, + width/2.0 - (11*ptr_width)/2.0 + (i % 11) * ptr_width, + height/2.0 + ptr_height*1.5 + line_y, + ptr_width, ptr_height, + width, height, + &white[0], + texture); + + menu_display_blend_end(video_info); + } + + menu_display_draw_text(stripes->font, grid[i], + width/2.0 - (11*ptr_width)/2.0 + (i % 11) * ptr_width + ptr_width/2.0, + height/2.0 + ptr_height + line_y + stripes->font->size / 3, + width, height, 0xffffffff, TEXT_ALIGN_CENTER, 1.0f, + false, 0); + } +} + +/* Returns the OSK key at a given position */ +static int stripes_osk_ptr_at_pos(void *data, int x, int y, unsigned width, unsigned height) +{ + unsigned i; + int ptr_width, ptr_height; + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (!stripes) + return -1; + + ptr_width = width / 11; + ptr_height = height / 10; + + if (ptr_width >= ptr_height) + ptr_width = ptr_height; + + for (i = 0; i < 44; i++) + { + int line_y = (i / 11)*height/10.0; + int ptr_x = width/2.0 - (11*ptr_width)/2.0 + (i % 11) * ptr_width; + int ptr_y = height/2.0 + ptr_height*1.5 + line_y - ptr_height; + + if (x > ptr_x && x < ptr_x + ptr_width + && y > ptr_y && y < ptr_y + ptr_height) + return i; + } + + return -1; +} + +static void stripes_render_messagebox_internal( + video_frame_info_t *video_info, + stripes_handle_t *stripes, const char *message, float* stripes_coord_white) +{ + unsigned i, y_position; + int x, y, longest = 0, longest_width = 0; + float line_height = 0; + unsigned width = video_info->width; + unsigned height = video_info->height; + struct string_list *list = !string_is_empty(message) + ? string_split(message, "\n") : NULL; + + if (!list || !stripes || !stripes->font) + { + if (list) + string_list_free(list); + return; + } + + if (list->elems == 0) + goto end; + + line_height = stripes->font->size * 1.2; + + y_position = height / 2; + if (menu_input_dialog_get_display_kb()) + y_position = height / 4; + + x = width / 2; + y = y_position - (list->size-1) * line_height / 2; + + /* find the longest line width */ + for (i = 0; i < list->size; i++) + { + const char *msg = list->elems[i].data; + int len = (int)utf8len(msg); + + if (len > longest) + { + longest = len; + longest_width = font_driver_get_message_width( + stripes->font, msg, strlen(msg), 1); + } + } + + menu_display_blend_begin(video_info); + + menu_display_draw_texture_slice( + video_info, + x - longest_width/2 - stripes->margins_dialog, + y + stripes->margins_slice - stripes->margins_dialog, + 256, 256, + longest_width + stripes->margins_dialog * 2, + line_height * list->size + stripes->margins_dialog * 2, + width, height, + &stripes_coord_white[0], + stripes->margins_slice, 1.0, + stripes->textures.list[STRIPES_TEXTURE_DIALOG_SLICE]); + + for (i = 0; i < list->size; i++) + { + const char *msg = list->elems[i].data; + + if (msg) + menu_display_draw_text(stripes->font, msg, + x - longest_width/2.0, + y + (i+0.75) * line_height, + width, height, 0x444444ff, TEXT_ALIGN_LEFT, 1.0f, false, 0); + } + + if (menu_input_dialog_get_display_kb()) + stripes_render_keyboard(stripes, + video_info, + menu_event_get_osk_grid(), + menu_event_get_osk_ptr()); + +end: + string_list_free(list); +} + +static void stripes_update_thumbnail_path(void *data, unsigned i, char pos) +{ + menu_entry_t entry; + unsigned entry_type = 0; + char new_path[PATH_MAX_LENGTH] = {0}; + settings_t *settings = config_get_ptr(); + stripes_handle_t *stripes = (stripes_handle_t*)data; + playlist_t *playlist = NULL; + const char *dir_thumbnails = settings->paths.directory_thumbnails; + + menu_entry_init(&entry); + + if (!stripes || string_is_empty(dir_thumbnails)) + goto end; + + menu_entry_get(&entry, 0, i, NULL, true); + + entry_type = menu_entry_get_type_new(&entry); + + if (entry_type == FILE_TYPE_IMAGEVIEWER || entry_type == FILE_TYPE_IMAGE) + { + file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0); + stripes_node_t *node = (stripes_node_t*) + file_list_get_userdata_at_offset(selection_buf, i); + + if (!string_is_empty(node->fullpath) && + (pos == 'R' || (pos == 'L' && string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))))) + { + if (!string_is_empty(entry.path)) + fill_pathname_join( + new_path, + node->fullpath, + entry.path, + sizeof(new_path)); + + goto end; + } + } + else if (filebrowser_get_type() != FILEBROWSER_NONE) + { + stripes->thumbnail = 0; + goto end; + } + + menu_driver_ctl(RARCH_MENU_CTL_PLAYLIST_GET, &playlist); + + if (playlist) + { + const char *core_name = NULL; + playlist_get_index(playlist, i, + NULL, NULL, NULL, &core_name, NULL, NULL); + + if (string_is_equal(core_name, "imageviewer")) + { + if (pos == 'R' || (pos == 'L' && string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF)))) + { + if (!string_is_empty(entry.label)) + strlcpy(new_path, entry.label, + sizeof(new_path)); + goto end; + } + else + { + stripes->left_thumbnail = 0; + goto end; + } + } + } + + /* Append thumbnail system directory */ + if (!string_is_empty(stripes->thumbnail_system)) + fill_pathname_join( + new_path, + dir_thumbnails, + stripes->thumbnail_system, + sizeof(new_path)); + + if (!string_is_empty(new_path)) + { + char *tmp_new2 = (char*) + malloc(PATH_MAX_LENGTH * sizeof(char)); + + tmp_new2[0] = '\0'; + + /* Append Named_Snaps/Named_Boxarts/Named_Titles */ + if (pos == 'R') + fill_pathname_join(tmp_new2, new_path, + stripes_thumbnails_ident('R'), PATH_MAX_LENGTH * sizeof(char)); + if (pos == 'L') + fill_pathname_join(tmp_new2, new_path, + stripes_thumbnails_ident('L'), PATH_MAX_LENGTH * sizeof(char)); + + strlcpy(new_path, tmp_new2, + PATH_MAX_LENGTH * sizeof(char)); + free(tmp_new2); + } + + /* Scrub characters that are not cross-platform and/or violate the + * No-Intro filename standard: + * http://datomatic.no-intro.org/stuff/The%20Official%20No-Intro%20Convention%20(20071030).zip + * Replace these characters in the entry name with underscores. + */ + if (!string_is_empty(stripes->thumbnail_content)) + { + char *scrub_char_pointer = NULL; + char *tmp_new = (char*) + malloc(PATH_MAX_LENGTH * sizeof(char)); + char *tmp = strdup(stripes->thumbnail_content); + + tmp_new[0] = '\0'; + + while((scrub_char_pointer = strpbrk(tmp, "&*/:`\"<>?\\|"))) + *scrub_char_pointer = '_'; + + /* Look for thumbnail file with this scrubbed filename */ + + fill_pathname_join(tmp_new, + new_path, + tmp, PATH_MAX_LENGTH * sizeof(char)); + + if (!string_is_empty(tmp_new)) + strlcpy(new_path, + tmp_new, sizeof(new_path)); + + free(tmp_new); + free(tmp); + } + + /* Append png extension */ + if (!string_is_empty(new_path)) + strlcat(new_path, + file_path_str(FILE_PATH_PNG_EXTENSION), + sizeof(new_path)); + +end: + if (stripes && !string_is_empty(new_path)) + { + if (pos == 'R') + stripes->thumbnail_file_path = strdup(new_path); + if (pos == 'L') + stripes->left_thumbnail_file_path = strdup(new_path); + } + + menu_entry_free(&entry); +} + +static void stripes_update_savestate_thumbnail_path(void *data, unsigned i) +{ + menu_entry_t entry; + settings_t *settings = config_get_ptr(); + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (!stripes) + return; + + menu_entry_init(&entry); + menu_entry_get(&entry, 0, i, NULL, true); + + if (!string_is_empty(stripes->savestate_thumbnail_file_path)) + free(stripes->savestate_thumbnail_file_path); + stripes->savestate_thumbnail_file_path = NULL; + + if (!string_is_empty(entry.label)) + { + if ( (settings->bools.savestate_thumbnail_enable) + && ((string_is_equal(entry.label, "state_slot")) + || (string_is_equal(entry.label, "loadstate")) + || (string_is_equal(entry.label, "savestate")))) + { + size_t path_size = 8024 * sizeof(char); + char *path = (char*)malloc(8204 * sizeof(char)); + global_t *global = global_get_ptr(); + + path[0] = '\0'; + + if (global) + { + int state_slot = settings->ints.state_slot; + + if (state_slot > 0) + snprintf(path, path_size, "%s%d", + global->name.savestate, state_slot); + else if (state_slot < 0) + fill_pathname_join_delim(path, + global->name.savestate, "auto", '.', path_size); + else + strlcpy(path, global->name.savestate, path_size); + } + + strlcat(path, file_path_str(FILE_PATH_PNG_EXTENSION), path_size); + + if (filestream_exists(path)) + { + if (!string_is_empty(stripes->savestate_thumbnail_file_path)) + free(stripes->savestate_thumbnail_file_path); + stripes->savestate_thumbnail_file_path = strdup(path); + } + + free(path); + } + } + + menu_entry_free(&entry); +} + +static void stripes_update_thumbnail_image(void *data) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + if (!stripes) + return; + + if (!(string_is_empty(stripes->thumbnail_file_path))) + { + if (filestream_exists(stripes->thumbnail_file_path)) + task_push_image_load(stripes->thumbnail_file_path, + menu_display_handle_thumbnail_upload, NULL); + else + stripes->thumbnail = 0; + + free(stripes->thumbnail_file_path); + stripes->thumbnail_file_path = NULL; + } + + if (!(string_is_empty(stripes->left_thumbnail_file_path))) + { + if (filestream_exists(stripes->left_thumbnail_file_path)) + task_push_image_load(stripes->left_thumbnail_file_path, + menu_display_handle_left_thumbnail_upload, NULL); + else + stripes->left_thumbnail = 0; + + free(stripes->left_thumbnail_file_path); + stripes->left_thumbnail_file_path = NULL; + } +} + +static void stripes_set_thumbnail_system(void *data, char*s, size_t len) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + if (!stripes) + return; + + if (!string_is_empty(stripes->thumbnail_system)) + free(stripes->thumbnail_system); + stripes->thumbnail_system = strdup(s); +} + +static void stripes_reset_thumbnail_content(void *data) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + if (!stripes) + return; + if (!string_is_empty(stripes->thumbnail_content)) + free(stripes->thumbnail_content); + stripes->thumbnail_content = NULL; +} + +static void stripes_set_thumbnail_content(void *data, char *s, size_t len) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + if (!stripes) + return; + if (!string_is_empty(stripes->thumbnail_content)) + free(stripes->thumbnail_content); + stripes->thumbnail_content = strdup(s); +} + +static void stripes_update_savestate_thumbnail_image(void *data) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + if (!stripes) + return; + + if (!string_is_empty(stripes->savestate_thumbnail_file_path) + && filestream_exists(stripes->savestate_thumbnail_file_path)) + task_push_image_load(stripes->savestate_thumbnail_file_path, + menu_display_handle_savestate_thumbnail_upload, NULL); + else + stripes->savestate_thumbnail = 0; +} + +static unsigned stripes_get_system_tab(stripes_handle_t *stripes, unsigned i) +{ + if (i <= stripes->system_tab_end) + { + return stripes->tabs[i]; + } + return UINT_MAX; +} + +static void stripes_selection_pointer_changed( + stripes_handle_t *stripes, bool allow_animations) +{ + unsigned i, end, height; + menu_animation_ctx_tag tag; + menu_entry_t entry; + size_t num = 0; + int threshold = 0; + menu_list_t *menu_list = NULL; + file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0); + size_t selection = menu_navigation_get_selection(); + const char *thumb_ident = stripes_thumbnails_ident('R'); + const char *lft_thumb_ident= stripes_thumbnails_ident('L'); + + menu_entries_ctl(MENU_ENTRIES_CTL_LIST_GET, &menu_list); + menu_entry_init(&entry); + + if (!stripes) + goto end; + + menu_entry_get(&entry, 0, selection, NULL, true); + + end = (unsigned)menu_entries_get_size(); + threshold = stripes->icon_size * 10; + + video_driver_get_size(NULL, &height); + + tag = (uintptr_t)selection_buf; + + menu_animation_ctl(MENU_ANIMATION_CTL_KILL_BY_TAG, &tag); + menu_entries_ctl(MENU_ENTRIES_CTL_SET_START, &num); + + for (i = 0; i < end; i++) + { + float iy, real_iy; + float ia = stripes->items_passive_alpha; + float iz = stripes->items_passive_zoom; + stripes_node_t *node = (stripes_node_t*) + file_list_get_userdata_at_offset(selection_buf, i); + + if (!node) + continue; + + iy = stripes_item_y(stripes, i, selection); + real_iy = iy + stripes->margins_screen_top; + + if (i == selection) + { + unsigned depth = (unsigned)stripes_list_get_size(stripes, MENU_LIST_PLAIN); + unsigned stripes_system_tab = stripes_get_system_tab(stripes, (unsigned)stripes->categories_selection_ptr); + unsigned entry_type = menu_entry_get_type_new(&entry); + + ia = stripes->items_active_alpha; + iz = stripes->items_active_zoom; + if (!string_is_equal(thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF)) || !string_is_equal(lft_thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + if ((stripes_system_tab > STRIPES_SYSTEM_TAB_SETTINGS && depth == 1) || + (stripes_system_tab < STRIPES_SYSTEM_TAB_SETTINGS && depth == 4)) + { + if (!string_is_empty(entry.path)) + stripes_set_thumbnail_content(stripes, entry.path, 0 /* will be ignored */); + if (!string_is_equal(thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + stripes_update_thumbnail_path(stripes, i, 'R'); + stripes_update_thumbnail_image(stripes); + } + if (!string_is_equal(lft_thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + stripes_update_thumbnail_path(stripes, i, 'L'); + stripes_update_thumbnail_image(stripes); + } + } + else if (((entry_type == FILE_TYPE_IMAGE || entry_type == FILE_TYPE_IMAGEVIEWER || + entry_type == FILE_TYPE_RDB || entry_type == FILE_TYPE_RDB_ENTRY) + && stripes_system_tab <= STRIPES_SYSTEM_TAB_SETTINGS)) + { + if (!string_is_empty(entry.path)) + stripes_set_thumbnail_content(stripes, entry.path, 0 /* will be ignored */); + if (!string_is_equal(thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + stripes_update_thumbnail_path(stripes, i, 'R'); + stripes_update_thumbnail_image(stripes); + } + else if (!string_is_equal(lft_thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + stripes_update_thumbnail_path(stripes, i, 'L'); + stripes_update_thumbnail_image(stripes); + } + } + else if (filebrowser_get_type() != FILEBROWSER_NONE) + { + stripes_reset_thumbnail_content(stripes); + if (!string_is_equal(thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + stripes_update_thumbnail_path(stripes, i, 'R'); + stripes_update_thumbnail_image(stripes); + } + else if (!string_is_equal(lft_thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + stripes_update_thumbnail_path(stripes, i, 'L'); + stripes_update_thumbnail_image(stripes); + } + } + } + stripes_update_savestate_thumbnail_path(stripes, i); + stripes_update_savestate_thumbnail_image(stripes); + } + + if ( (!allow_animations) + || (real_iy < -threshold + || real_iy > height+threshold)) + { + node->alpha = node->label_alpha = ia; + node->y = iy; + node->zoom = iz; + } + else + { + menu_animation_ctx_entry_t anim_entry; + + anim_entry.duration = STRIPES_DELAY; + anim_entry.target_value = ia; + anim_entry.subject = &node->alpha; + anim_entry.easing_enum = EASING_OUT_QUAD; + anim_entry.tag = tag; + anim_entry.cb = NULL; + + menu_animation_push(&anim_entry); + + anim_entry.subject = &node->label_alpha; + + menu_animation_push(&anim_entry); + + anim_entry.target_value = iz; + anim_entry.subject = &node->zoom; + + menu_animation_push(&anim_entry); + + anim_entry.target_value = iy; + anim_entry.subject = &node->y; + + menu_animation_push(&anim_entry); + } + } + +end: + menu_entry_free(&entry); +} + +static void stripes_list_open_old(stripes_handle_t *stripes, + file_list_t *list, int dir, size_t current) +{ + unsigned i, height = 0; + int threshold = stripes->icon_size * 10; + size_t end = 0; + + end = file_list_get_size(list); + + video_driver_get_size(NULL, &height); + + for (i = 0; i < end; i++) + { + float ia = 0; + float real_y; + stripes_node_t *node = (stripes_node_t*) + file_list_get_userdata_at_offset(list, i); + + if (!node) + continue; + + if (i == current) + ia = stripes->items_active_alpha; + if (dir == -1) + ia = 0; + + real_y = node->y + stripes->margins_screen_top; + + if (real_y < -threshold || real_y > height+threshold) + { + node->alpha = ia; + node->label_alpha = 0; + node->x = stripes->icon_size * dir * -2; + } + else + { + menu_animation_ctx_entry_t anim_entry; + + anim_entry.duration = STRIPES_DELAY; + anim_entry.target_value = ia; + anim_entry.subject = &node->alpha; + anim_entry.easing_enum = EASING_OUT_QUAD; + anim_entry.tag = (uintptr_t)list; + anim_entry.cb = NULL; + + menu_animation_push(&anim_entry); + + anim_entry.target_value = 0; + anim_entry.subject = &node->label_alpha; + + menu_animation_push(&anim_entry); + + anim_entry.target_value = stripes->icon_size * dir * -2; + anim_entry.subject = &node->x; + + menu_animation_push(&anim_entry); + } + } +} + +static void stripes_list_open_new(stripes_handle_t *stripes, + file_list_t *list, int dir, size_t current) +{ + unsigned i, height; + unsigned stripes_system_tab = 0; + size_t skip = 0; + int threshold = stripes->icon_size * 10; + size_t end = file_list_get_size(list); + + video_driver_get_size(NULL, &height); + + for (i = 0; i < end; i++) + { + float ia; + float real_y; + stripes_node_t *node = (stripes_node_t*) + file_list_get_userdata_at_offset(list, i); + + if (!node) + continue; + + if (dir == 1 || (dir == -1 && i != current)) + node->alpha = 0; + + if (dir == 1 || dir == -1) + node->label_alpha = 0; + + node->x = stripes->icon_size * dir * 2; + node->y = stripes_item_y(stripes, i, current); + node->zoom = stripes->categories_passive_zoom; + + real_y = node->y + stripes->margins_screen_top; + + if (i == current) + node->zoom = stripes->categories_active_zoom; + + ia = stripes->items_passive_alpha; + if (i == current) + ia = stripes->items_active_alpha; + + if (real_y < -threshold || real_y > height+threshold) + { + node->alpha = node->label_alpha = ia; + node->x = 0; + } + else + { + menu_animation_ctx_entry_t anim_entry; + + anim_entry.duration = STRIPES_DELAY; + anim_entry.target_value = ia; + anim_entry.subject = &node->alpha; + anim_entry.easing_enum = EASING_OUT_QUAD; + anim_entry.tag = (uintptr_t)list; + anim_entry.cb = NULL; + + menu_animation_push(&anim_entry); + + anim_entry.subject = &node->label_alpha; + + menu_animation_push(&anim_entry); + + anim_entry.target_value = 0; + anim_entry.subject = &node->x; + + menu_animation_push(&anim_entry); + } + } + + stripes->old_depth = stripes->depth; + menu_entries_ctl(MENU_ENTRIES_CTL_SET_START, &skip); + + stripes_system_tab = stripes_get_system_tab(stripes, + (unsigned)stripes->categories_selection_ptr); + + if (stripes_system_tab <= STRIPES_SYSTEM_TAB_SETTINGS) + { + if (stripes->depth < 4) + stripes_reset_thumbnail_content(stripes); + stripes_update_thumbnail_path(stripes, 0, 'R'); + stripes_update_thumbnail_image(stripes); + stripes_update_thumbnail_path(stripes, 0, 'L'); + stripes_update_thumbnail_image(stripes); + } +} + +static stripes_node_t *stripes_node_allocate_userdata( + stripes_handle_t *stripes, unsigned i) +{ + stripes_node_t *tmp = NULL; + stripes_node_t *node = stripes_alloc_node(); + + if (!node) + { + RARCH_ERR("XMB node could not be allocated.\n"); + return NULL; + } + + node->alpha = stripes->categories_passive_alpha; + node->zoom = stripes->categories_passive_zoom; + + if ((i + stripes->system_tab_end) == stripes->categories_active_idx) + { + node->alpha = stripes->categories_active_alpha; + node->zoom = stripes->categories_active_zoom; + } + + tmp = (stripes_node_t*)file_list_get_userdata_at_offset( + stripes->horizontal_list, i); + stripes_free_node(tmp); + + file_list_set_userdata(stripes->horizontal_list, i, node); + + return node; +} + +static stripes_node_t* stripes_get_userdata_from_horizontal_list( + stripes_handle_t *stripes, unsigned i) +{ + return (stripes_node_t*) + file_list_get_userdata_at_offset(stripes->horizontal_list, i); +} + +static void stripes_push_animations(stripes_node_t *node, + uintptr_t tag, float ia, float ix) +{ + menu_animation_ctx_entry_t anim_entry; + + anim_entry.duration = STRIPES_DELAY; + anim_entry.target_value = ia; + anim_entry.subject = &node->alpha; + anim_entry.easing_enum = EASING_OUT_QUAD; + anim_entry.tag = tag; + anim_entry.cb = NULL; + + menu_animation_push(&anim_entry); + + anim_entry.subject = &node->label_alpha; + + menu_animation_push(&anim_entry); + + anim_entry.target_value = ix; + anim_entry.subject = &node->x; + + menu_animation_push(&anim_entry); +} + +static void stripes_list_switch_old(stripes_handle_t *stripes, + file_list_t *list, int dir, size_t current) +{ + unsigned i, first, last, height; + size_t end = file_list_get_size(list); + float ix = -stripes->icon_spacing_horizontal * dir; + float ia = 0; + + first = 0; + last = end > 0 ? end - 1 : 0; + + video_driver_get_size(NULL, &height); + stripes_calculate_visible_range(stripes, height, end, + current, &first, &last); + + for (i = 0; i < end; i++) + { + stripes_node_t *node = (stripes_node_t*) + file_list_get_userdata_at_offset(list, i); + + if (!node) + continue; + + if (i >= first && i <= last) + stripes_push_animations(node, (uintptr_t)list, ia, ix); + else + { + node->alpha = node->label_alpha = ia; + node->x = ix; + } + } +} + +static void stripes_list_switch_new(stripes_handle_t *stripes, + file_list_t *list, int dir, size_t current) +{ + unsigned i, first, last, height; + size_t end = 0; + settings_t *settings = config_get_ptr(); + + if (settings->bools.menu_dynamic_wallpaper_enable) + { + size_t path_size = PATH_MAX_LENGTH * sizeof(char); + char *path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); + char *tmp = string_replace_substring(stripes->title_name, "/", " "); + + path[0] = '\0'; + + if (tmp) + { + fill_pathname_join_noext( + path, + settings->paths.directory_dynamic_wallpapers, + tmp, + path_size); + free(tmp); + } + + strlcat(path, + file_path_str(FILE_PATH_PNG_EXTENSION), + path_size); + + if (!filestream_exists(path)) + fill_pathname_application_special(path, path_size, + APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_BG); + + if(!string_is_equal(path, stripes->bg_file_path)) + { + if(filestream_exists(path)) + { + task_push_image_load(path, + menu_display_handle_wallpaper_upload, NULL); + if (!string_is_empty(stripes->bg_file_path)) + free(stripes->bg_file_path); + stripes->bg_file_path = strdup(path); + } + } + + free(path); + } + + end = file_list_get_size(list); + + first = 0; + last = end > 0 ? end - 1 : 0; + + video_driver_get_size(NULL, &height); + stripes_calculate_visible_range(stripes, height, end, current, &first, &last); + + for (i = 0; i < end; i++) + { + stripes_node_t *node = (stripes_node_t*) + file_list_get_userdata_at_offset(list, i); + float ia = stripes->items_passive_alpha; + + if (!node) + continue; + + node->x = stripes->icon_spacing_horizontal * dir; + node->alpha = 0; + node->label_alpha = 0; + + if (i == current) + ia = stripes->items_active_alpha; + + if (i >= first && i <= last) + stripes_push_animations(node, (uintptr_t)list, ia, 0); + else + { + node->x = 0; + node->alpha = node->label_alpha = ia; + } + } +} + +static void stripes_set_title(stripes_handle_t *stripes) +{ + if (stripes->categories_selection_ptr <= stripes->system_tab_end) + { + menu_entries_get_title(stripes->title_name, sizeof(stripes->title_name)); + } + else + { + const char *path = NULL; + menu_entries_get_at_offset( + stripes->horizontal_list, + stripes->categories_selection_ptr - (stripes->system_tab_end + 1), + &path, NULL, NULL, NULL, NULL); + + if (!path) + return; + + fill_pathname_base_noext( + stripes->title_name, path, sizeof(stripes->title_name)); + } +} + +static stripes_node_t* stripes_get_node(stripes_handle_t *stripes, unsigned i) +{ + switch (stripes_get_system_tab(stripes, i)) + { + case STRIPES_SYSTEM_TAB_SETTINGS: + return &stripes->settings_tab_node; +#ifdef HAVE_IMAGEVIEWER + case STRIPES_SYSTEM_TAB_IMAGES: + return &stripes->images_tab_node; +#endif + case STRIPES_SYSTEM_TAB_MUSIC: + return &stripes->music_tab_node; +#ifdef HAVE_FFMPEG + case STRIPES_SYSTEM_TAB_VIDEO: + return &stripes->video_tab_node; +#endif + case STRIPES_SYSTEM_TAB_HISTORY: + return &stripes->history_tab_node; + case STRIPES_SYSTEM_TAB_FAVORITES: + return &stripes->favorites_tab_node; +#ifdef HAVE_NETWORKING + case STRIPES_SYSTEM_TAB_NETPLAY: + return &stripes->netplay_tab_node; +#endif + case STRIPES_SYSTEM_TAB_ADD: + return &stripes->add_tab_node; + default: + if (i > stripes->system_tab_end) + return stripes_get_userdata_from_horizontal_list( + stripes, i - (stripes->system_tab_end + 1)); + } + + return &stripes->main_menu_node; +} + +static void stripes_list_switch_horizontal_list(stripes_handle_t *stripes) +{ + unsigned j; + size_t list_size = stripes_list_get_size(stripes, MENU_LIST_HORIZONTAL) + + stripes->system_tab_end; + + for (j = 0; j <= list_size; j++) + { + menu_animation_ctx_entry_t entry; + float ia = stripes->categories_passive_alpha; + float iz = stripes->categories_passive_zoom; + stripes_node_t *node = stripes_get_node(stripes, j); + + if (!node) + continue; + + if (j == stripes->categories_active_idx) + { + ia = stripes->categories_active_alpha; + iz = stripes->categories_active_zoom; + } + + entry.duration = STRIPES_DELAY; + entry.target_value = ia; + entry.subject = &node->alpha; + entry.easing_enum = EASING_OUT_QUAD; + /* TODO/FIXME - integer conversion resulted in change of sign */ + entry.tag = -1; + entry.cb = NULL; + + menu_animation_push(&entry); + + entry.target_value = iz; + entry.subject = &node->zoom; + + menu_animation_push(&entry); + } +} + +static void stripes_list_switch(stripes_handle_t *stripes) +{ + menu_animation_ctx_entry_t anim_entry; + int dir = -1; + file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0); + size_t selection = menu_navigation_get_selection(); + settings_t *settings = config_get_ptr(); + + if (stripes->categories_selection_ptr > stripes->categories_selection_ptr_old) + dir = 1; + + stripes->categories_active_idx += dir; + + stripes_list_switch_horizontal_list(stripes); + + anim_entry.duration = STRIPES_DELAY; + anim_entry.target_value = stripes->icon_spacing_horizontal + * -(float)stripes->categories_selection_ptr; + anim_entry.subject = &stripes->categories_x_pos; + anim_entry.easing_enum = EASING_OUT_QUAD; + /* TODO/FIXME - integer conversion resulted in change of sign */ + anim_entry.tag = -1; + anim_entry.cb = NULL; + + if (anim_entry.subject) + menu_animation_push(&anim_entry); + + dir = -1; + if (stripes->categories_selection_ptr > stripes->categories_selection_ptr_old) + dir = 1; + + stripes_list_switch_old(stripes, stripes->selection_buf_old, + dir, stripes->selection_ptr_old); + + /* Check if we are to have horizontal animations. */ + if (settings->bools.menu_horizontal_animation) + stripes_list_switch_new(stripes, selection_buf, dir, selection); + stripes->categories_active_idx_old = (unsigned)stripes->categories_selection_ptr; + + if (!string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + menu_entry_t entry; + + menu_entry_init(&entry); + menu_entry_get(&entry, 0, selection, NULL, true); + + if (!string_is_empty(entry.path)) + stripes_set_thumbnail_content(stripes, entry.path, 0 /* will be ignored */); + + menu_entry_free(&entry); + + stripes_update_thumbnail_path(stripes, 0, 'R'); + stripes_update_thumbnail_image(stripes); + } + if (!string_is_equal(stripes_thumbnails_ident('L'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + menu_entry_t entry; + + menu_entry_init(&entry); + menu_entry_get(&entry, 0, selection, NULL, true); + + if (!string_is_empty(entry.path)) + stripes_set_thumbnail_content(stripes, entry.path, 0 /* will be ignored */); + + menu_entry_free(&entry); + + stripes_update_thumbnail_path(stripes, 0, 'L'); + stripes_update_thumbnail_image(stripes); + } +} + +static void stripes_list_open_horizontal_list(stripes_handle_t *stripes) +{ + unsigned j; + size_t list_size = stripes_list_get_size(stripes, MENU_LIST_HORIZONTAL) + + stripes->system_tab_end; + + for (j = 0; j <= list_size; j++) + { + menu_animation_ctx_entry_t anim_entry; + float ia = 0; + stripes_node_t *node = stripes_get_node(stripes, j); + + if (!node) + continue; + + if (j == stripes->categories_active_idx) + ia = stripes->categories_active_alpha; + else if (stripes->depth <= 1) + ia = stripes->categories_passive_alpha; + + anim_entry.duration = STRIPES_DELAY; + anim_entry.target_value = ia; + anim_entry.subject = &node->alpha; + anim_entry.easing_enum = EASING_OUT_QUAD; + /* TODO/FIXME - integer conversion resulted in change of sign */ + anim_entry.tag = -1; + anim_entry.cb = NULL; + + if (anim_entry.subject) + menu_animation_push(&anim_entry); + } +} + +static void stripes_context_destroy_horizontal_list(stripes_handle_t *stripes) +{ + unsigned i; + size_t list_size = stripes_list_get_size(stripes, MENU_LIST_HORIZONTAL); + + for (i = 0; i < list_size; i++) + { + const char *path = NULL; + stripes_node_t *node = stripes_get_userdata_from_horizontal_list(stripes, i); + + if (!node) + continue; + + file_list_get_at_offset(stripes->horizontal_list, i, + &path, NULL, NULL, NULL); + + if (!path || !strstr(path, file_path_str(FILE_PATH_LPL_EXTENSION))) + continue; + + video_driver_texture_unload(&node->icon); + video_driver_texture_unload(&node->content_icon); + } +} + +static void stripes_init_horizontal_list(stripes_handle_t *stripes) +{ + menu_displaylist_info_t info; + settings_t *settings = config_get_ptr(); + + menu_displaylist_info_init(&info); + + info.list = stripes->horizontal_list; + info.path = strdup( + settings->paths.directory_playlist); + info.label = strdup( + msg_hash_to_str(MENU_ENUM_LABEL_CONTENT_COLLECTION_LIST)); + info.exts = strdup( + file_path_str(FILE_PATH_LPL_EXTENSION_NO_DOT)); + info.type_default = FILE_TYPE_PLAIN; + info.enum_idx = MENU_ENUM_LABEL_CONTENT_COLLECTION_LIST; + + if (!string_is_empty(info.path)) + { + if (menu_displaylist_ctl(DISPLAYLIST_DATABASE_PLAYLISTS_HORIZONTAL, &info)) + { + size_t i; + for (i = 0; i < stripes->horizontal_list->size; i++) + stripes_node_allocate_userdata(stripes, (unsigned)i); + menu_displaylist_process(&info); + } + } + + menu_displaylist_info_free(&info); +} + +static void stripes_toggle_horizontal_list(stripes_handle_t *stripes) +{ + unsigned i; + size_t list_size = stripes_list_get_size(stripes, MENU_LIST_HORIZONTAL) + + stripes->system_tab_end; + + for (i = 0; i <= list_size; i++) + { + stripes_node_t *node = stripes_get_node(stripes, i); + + if (!node) + continue; + + node->alpha = 0; + node->zoom = stripes->categories_passive_zoom; + + if (i == stripes->categories_active_idx) + { + node->alpha = stripes->categories_active_alpha; + node->zoom = stripes->categories_active_zoom; + } + else if (stripes->depth <= 1) + node->alpha = stripes->categories_passive_alpha; + } +} + +static void stripes_context_reset_horizontal_list( + stripes_handle_t *stripes) +{ + unsigned i; + int depth; /* keep this integer */ + size_t list_size = + stripes_list_get_size(stripes, MENU_LIST_HORIZONTAL); + + stripes->categories_x_pos = + stripes->icon_spacing_horizontal * + -(float)stripes->categories_selection_ptr; + + depth = (stripes->depth > 1) ? 2 : 1; + stripes->x = stripes->icon_size * -(depth*2-2); + + for (i = 0; i < list_size; i++) + { + const char *path = NULL; + stripes_node_t *node = + stripes_get_userdata_from_horizontal_list(stripes, i); + + if (!node) + { + node = stripes_node_allocate_userdata(stripes, i); + if (!node) + continue; + } + + + file_list_get_at_offset(stripes->horizontal_list, i, + &path, NULL, NULL, NULL); + + if (!path) + continue; + + if (!strstr(path, file_path_str(FILE_PATH_LPL_EXTENSION))) + continue; + + { + struct texture_image ti; + char sysname[256]; + char *iconpath = (char*) + malloc(PATH_MAX_LENGTH * sizeof(char)); + char *texturepath = (char*) + malloc(PATH_MAX_LENGTH * sizeof(char)); + char *content_texturepath = (char*) + malloc(PATH_MAX_LENGTH * sizeof(char)); + + iconpath[0] = sysname[0] = + texturepath[0] = content_texturepath[0] = '\0'; + + fill_pathname_base_noext(sysname, path, sizeof(sysname)); + + fill_pathname_application_special(iconpath, + PATH_MAX_LENGTH * sizeof(char), + APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_ICONS); + + fill_pathname_join_concat(texturepath, iconpath, sysname, + file_path_str(FILE_PATH_PNG_EXTENSION), + PATH_MAX_LENGTH * sizeof(char)); + + ti.width = 0; + ti.height = 0; + ti.pixels = NULL; + ti.supports_rgba = video_driver_supports_rgba(); + + if (image_texture_load(&ti, texturepath)) + { + if(ti.pixels) + { + video_driver_texture_unload(&node->icon); + video_driver_texture_load(&ti, + TEXTURE_FILTER_MIPMAP_LINEAR, &node->icon); + } + + image_texture_free(&ti); + } + + strlcat(iconpath, sysname, PATH_MAX_LENGTH * sizeof(char)); + fill_pathname_join_delim(content_texturepath, iconpath, + file_path_str(FILE_PATH_CONTENT_BASENAME), '-', + PATH_MAX_LENGTH * sizeof(char)); + + if (image_texture_load(&ti, content_texturepath)) + { + if(ti.pixels) + { + video_driver_texture_unload(&node->content_icon); + video_driver_texture_load(&ti, + TEXTURE_FILTER_MIPMAP_LINEAR, &node->content_icon); + } + + image_texture_free(&ti); + } + + free(iconpath); + free(texturepath); + free(content_texturepath); + } + } + + stripes_toggle_horizontal_list(stripes); +} + +static void stripes_refresh_horizontal_list(stripes_handle_t *stripes) +{ + stripes_context_destroy_horizontal_list(stripes); + if (stripes->horizontal_list) + { + stripes_free_list_nodes(stripes->horizontal_list, false); + file_list_free(stripes->horizontal_list); + } + stripes->horizontal_list = NULL; + + menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL); + + stripes->horizontal_list = (file_list_t*) + calloc(1, sizeof(file_list_t)); + + if (stripes->horizontal_list) + stripes_init_horizontal_list(stripes); + + stripes_context_reset_horizontal_list(stripes); +} + +static int stripes_environ(enum menu_environ_cb type, void *data, void *userdata) +{ + stripes_handle_t *stripes = (stripes_handle_t*)userdata; + + switch (type) + { + case MENU_ENVIRON_ENABLE_MOUSE_CURSOR: + if (!stripes) + return -1; + stripes->mouse_show = true; + break; + case MENU_ENVIRON_DISABLE_MOUSE_CURSOR: + if (!stripes) + return -1; + stripes->mouse_show = false; + break; + case MENU_ENVIRON_RESET_HORIZONTAL_LIST: + if (!stripes) + return -1; + + stripes_refresh_horizontal_list(stripes); + break; + default: + return -1; + } + + return 0; +} + +static void stripes_list_open(stripes_handle_t *stripes) +{ + menu_animation_ctx_entry_t entry; + + int dir = 0; + file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0); + size_t selection = menu_navigation_get_selection(); + + stripes->depth = (int)stripes_list_get_size(stripes, MENU_LIST_PLAIN); + + if (stripes->depth > stripes->old_depth) + dir = 1; + else if (stripes->depth < stripes->old_depth) + dir = -1; + + stripes_list_open_horizontal_list(stripes); + + stripes_list_open_old(stripes, stripes->selection_buf_old, + dir, stripes->selection_ptr_old); + stripes_list_open_new(stripes, selection_buf, + dir, selection); + + + entry.duration = STRIPES_DELAY; + entry.target_value = stripes->icon_size * -(stripes->depth*2-2); + entry.subject = &stripes->x; + entry.easing_enum = EASING_OUT_QUAD; + /* TODO/FIXME - integer conversion resulted in change of sign */ + entry.tag = -1; + entry.cb = NULL; + + switch (stripes->depth) + { + case 1: + menu_animation_push(&entry); + + entry.target_value = 0; + entry.subject = &stripes->textures_arrow_alpha; + + menu_animation_push(&entry); + break; + case 2: + menu_animation_push(&entry); + + entry.target_value = 1; + entry.subject = &stripes->textures_arrow_alpha; + + menu_animation_push(&entry); + break; + } + + stripes->old_depth = stripes->depth; +} + +static void stripes_populate_entries(void *data, + const char *path, + const char *label, unsigned k) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (!stripes) + return; + + if (menu_driver_ctl(RARCH_MENU_CTL_IS_PREVENT_POPULATE, NULL)) + { + stripes_selection_pointer_changed(stripes, false); + menu_driver_ctl(RARCH_MENU_CTL_UNSET_PREVENT_POPULATE, NULL); + if (!string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + stripes_update_thumbnail_image(stripes); + stripes_update_savestate_thumbnail_image(stripes); + if (!string_is_equal(stripes_thumbnails_ident('L'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + stripes_update_thumbnail_image(stripes); + return; + } + + stripes_set_title(stripes); + + if (stripes->categories_selection_ptr != stripes->categories_active_idx_old) + stripes_list_switch(stripes); + else + stripes_list_open(stripes); +} + +static uintptr_t stripes_icon_get_id(stripes_handle_t *stripes, + stripes_node_t *core_node, stripes_node_t *node, + enum msg_hash_enums enum_idx, unsigned type, bool active) +{ + switch (enum_idx) + { + case MENU_ENUM_LABEL_CORE_OPTIONS: + case MENU_ENUM_LABEL_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE: + return stripes->textures.list[STRIPES_TEXTURE_CORE_OPTIONS]; + case MENU_ENUM_LABEL_ADD_TO_FAVORITES: + case MENU_ENUM_LABEL_ADD_TO_FAVORITES_PLAYLIST: + return stripes->textures.list[STRIPES_TEXTURE_ADD_FAVORITE]; + case MENU_ENUM_LABEL_RESET_CORE_ASSOCIATION: + return stripes->textures.list[STRIPES_TEXTURE_RENAME]; + case MENU_ENUM_LABEL_CORE_INPUT_REMAPPING_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_INPUT_REMAPPING_OPTIONS]; + case MENU_ENUM_LABEL_CORE_CHEAT_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_CHEAT_OPTIONS]; + case MENU_ENUM_LABEL_DISK_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_DISK_OPTIONS]; + case MENU_ENUM_LABEL_SHADER_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_SHADER_OPTIONS]; + case MENU_ENUM_LABEL_ACHIEVEMENT_LIST: + return stripes->textures.list[STRIPES_TEXTURE_ACHIEVEMENT_LIST]; + case MENU_ENUM_LABEL_ACHIEVEMENT_LIST_HARDCORE: + return stripes->textures.list[STRIPES_TEXTURE_ACHIEVEMENT_LIST]; + case MENU_ENUM_LABEL_SAVE_STATE: + return stripes->textures.list[STRIPES_TEXTURE_SAVESTATE]; + case MENU_ENUM_LABEL_LOAD_STATE: + return stripes->textures.list[STRIPES_TEXTURE_LOADSTATE]; + case MENU_ENUM_LABEL_PARENT_DIRECTORY: + case MENU_ENUM_LABEL_UNDO_LOAD_STATE: + case MENU_ENUM_LABEL_UNDO_SAVE_STATE: + return stripes->textures.list[STRIPES_TEXTURE_UNDO]; + case MENU_ENUM_LABEL_TAKE_SCREENSHOT: + return stripes->textures.list[STRIPES_TEXTURE_SCREENSHOT]; + case MENU_ENUM_LABEL_DELETE_ENTRY: + return stripes->textures.list[STRIPES_TEXTURE_CLOSE]; + case MENU_ENUM_LABEL_RESTART_CONTENT: + return stripes->textures.list[STRIPES_TEXTURE_RELOAD]; + case MENU_ENUM_LABEL_RENAME_ENTRY: + return stripes->textures.list[STRIPES_TEXTURE_RENAME]; + case MENU_ENUM_LABEL_RESUME_CONTENT: + return stripes->textures.list[STRIPES_TEXTURE_RESUME]; + case MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_CORE: + case MENU_ENUM_LABEL_SAVE_CURRENT_CONFIG_OVERRIDE_GAME: + return stripes->textures.list[STRIPES_TEXTURE_SAVESTATE]; + case MENU_ENUM_LABEL_FAVORITES: + case MENU_ENUM_LABEL_DOWNLOADED_FILE_DETECT_CORE_LIST: + return stripes->textures.list[STRIPES_TEXTURE_FOLDER]; + case MENU_ENUM_LABEL_FILE_DETECT_CORE_LIST_PUSH_DIR: + return stripes->textures.list[STRIPES_TEXTURE_RDB]; + default: + break; + } + + switch(type) + { + case FILE_TYPE_DIRECTORY: + return stripes->textures.list[STRIPES_TEXTURE_FOLDER]; + case FILE_TYPE_PLAIN: + case FILE_TYPE_IN_CARCHIVE: + return stripes->textures.list[STRIPES_TEXTURE_FILE]; + case FILE_TYPE_RPL_ENTRY: + if (core_node) + return core_node->content_icon; + + switch (stripes_get_system_tab(stripes, + (unsigned)stripes->categories_selection_ptr)) + { + case STRIPES_SYSTEM_TAB_FAVORITES: + return stripes->textures.list[STRIPES_TEXTURE_FAVORITE]; + case STRIPES_SYSTEM_TAB_MUSIC: + return stripes->textures.list[STRIPES_TEXTURE_MUSIC]; +#ifdef HAVE_IMAGEVIEWER + case STRIPES_SYSTEM_TAB_IMAGES: + return stripes->textures.list[STRIPES_TEXTURE_IMAGE]; +#endif +#ifdef HAVE_FFMPEG + case STRIPES_SYSTEM_TAB_VIDEO: + return stripes->textures.list[STRIPES_TEXTURE_MOVIE]; +#endif + default: + break; + } + return stripes->textures.list[STRIPES_TEXTURE_FILE]; + case FILE_TYPE_CARCHIVE: + return stripes->textures.list[STRIPES_TEXTURE_ZIP]; + case FILE_TYPE_MUSIC: + return stripes->textures.list[STRIPES_TEXTURE_MUSIC]; + case FILE_TYPE_IMAGE: + case FILE_TYPE_IMAGEVIEWER: + return stripes->textures.list[STRIPES_TEXTURE_IMAGE]; + case FILE_TYPE_MOVIE: + return stripes->textures.list[STRIPES_TEXTURE_MOVIE]; + case FILE_TYPE_CORE: + case FILE_TYPE_DIRECT_LOAD: + return stripes->textures.list[STRIPES_TEXTURE_CORE]; + case FILE_TYPE_RDB: + return stripes->textures.list[STRIPES_TEXTURE_RDB]; + case FILE_TYPE_CURSOR: + return stripes->textures.list[STRIPES_TEXTURE_CURSOR]; + case FILE_TYPE_PLAYLIST_ENTRY: + case MENU_SETTING_ACTION_RUN: + return stripes->textures.list[STRIPES_TEXTURE_RUN]; + case MENU_SETTING_ACTION_CLOSE: + return stripes->textures.list[STRIPES_TEXTURE_CLOSE]; + case MENU_SETTING_ACTION_SAVESTATE: + return stripes->textures.list[STRIPES_TEXTURE_SAVESTATE]; + case MENU_SETTING_ACTION_LOADSTATE: + return stripes->textures.list[STRIPES_TEXTURE_LOADSTATE]; + case FILE_TYPE_RDB_ENTRY: + case MENU_SETTING_ACTION_CORE_INFORMATION: + return stripes->textures.list[STRIPES_TEXTURE_CORE_INFO]; + case MENU_SETTING_ACTION_CORE_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_CORE_OPTIONS]; + case MENU_SETTING_ACTION_CORE_INPUT_REMAPPING_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_INPUT_REMAPPING_OPTIONS]; + case MENU_SETTING_ACTION_CORE_CHEAT_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_CHEAT_OPTIONS]; + case MENU_SETTING_ACTION_CORE_DISK_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_DISK_OPTIONS]; + case MENU_SETTING_ACTION_CORE_SHADER_OPTIONS: + return stripes->textures.list[STRIPES_TEXTURE_SHADER_OPTIONS]; + case MENU_SETTING_ACTION_SCREENSHOT: + return stripes->textures.list[STRIPES_TEXTURE_SCREENSHOT]; + case MENU_SETTING_ACTION_DELETE_ENTRY: + return stripes->textures.list[STRIPES_TEXTURE_CLOSE]; + case MENU_SETTING_ACTION_RESET: + return stripes->textures.list[STRIPES_TEXTURE_RELOAD]; + case MENU_SETTING_ACTION: + if (stripes->depth == 3) + return stripes->textures.list[STRIPES_TEXTURE_SUBSETTING]; + return stripes->textures.list[STRIPES_TEXTURE_SETTING]; + case MENU_SETTING_GROUP: + return stripes->textures.list[STRIPES_TEXTURE_SETTING]; + case MENU_INFO_MESSAGE: + return stripes->textures.list[STRIPES_TEXTURE_CORE_INFO]; + case MENU_WIFI: + return stripes->textures.list[STRIPES_TEXTURE_WIFI]; +#ifdef HAVE_NETWORKING + case MENU_ROOM: + return stripes->textures.list[STRIPES_TEXTURE_ROOM]; +#if 0 + /* stub these out until we have the icons */ + case MENU_ROOM_LAN: + return stripes->textures.list[STRIPES_TEXTURE_ROOM_LAN]; + case MENU_ROOM_MITM: + return stripes->textures.list[STRIPES_TEXTURE_ROOM_MITM]; +#endif +#endif + } + +#ifdef HAVE_CHEEVOS + if ( + (type >= MENU_SETTINGS_CHEEVOS_START) && + (type < MENU_SETTINGS_NETPLAY_ROOMS_START) + ) + { + int new_id = type - MENU_SETTINGS_CHEEVOS_START; + if (get_badge_texture(new_id) != 0) + return get_badge_texture(new_id); + /* Should be replaced with placeholder badge icon. */ + return stripes->textures.list[STRIPES_TEXTURE_SUBSETTING]; + } +#endif + + return stripes->textures.list[STRIPES_TEXTURE_SUBSETTING]; +} + +static void stripes_calculate_visible_range(const stripes_handle_t *stripes, + unsigned height, size_t list_size, unsigned current, + unsigned *first, unsigned *last) +{ + unsigned j; + float base_y = stripes->margins_screen_top; + + *first = 0; + *last = list_size ? list_size - 1 : 0; + + if (current) + { + for (j = current; j-- > 0; ) + { + float bottom = stripes_item_y(stripes, j, current) + + base_y + stripes->icon_size; + + if (bottom < 0) + break; + + *first = j; + } + } + + for (j = current+1; j < list_size; j++) + { + float top = stripes_item_y(stripes, j, current) + base_y; + + if (top > height) + break; + + *last = j; + } +} + +static int stripes_draw_item( + video_frame_info_t *video_info, + menu_entry_t *entry, + math_matrix_4x4 *mymat, + stripes_handle_t *stripes, + stripes_node_t *core_node, + file_list_t *list, + float *color, + const char *thumb_ident, + const char *left_thumb_ident, + uint64_t frame_count, + size_t i, + size_t current, + unsigned width, + unsigned height + ) +{ + float icon_x, icon_y, label_offset; + menu_animation_ctx_ticker_t ticker; + char tmp[255]; + char *ticker_str = NULL; + unsigned entry_type = 0; + const float half_size = stripes->icon_size / 2.0f; + uintptr_t texture_switch = 0; + bool do_draw_text = false; + unsigned ticker_limit = 35 * stripes_scale_mod[0]; + stripes_node_t * node = (stripes_node_t*) + file_list_get_userdata_at_offset(list, i); + settings_t *settings = config_get_ptr(); + + if (!node) + goto iterate; + + tmp[0] = '\0'; + + icon_y = stripes->margins_screen_top + node->y + half_size; + + if (icon_y < half_size) + goto iterate; + + if (icon_y > height + stripes->icon_size) + goto end; + + icon_x = node->x + stripes->margins_screen_left + + stripes->icon_spacing_horizontal - half_size; + + if (icon_x < -half_size || icon_x > width) + goto iterate; + + entry_type = menu_entry_get_type_new(entry); + + if (entry_type == FILE_TYPE_CONTENTLIST_ENTRY) + { + char entry_path[PATH_MAX_LENGTH] = {0}; + strlcpy(entry_path, entry->path, sizeof(entry_path)); + + fill_short_pathname_representation(entry_path, entry_path, + sizeof(entry_path)); + + if (!string_is_empty(entry_path)) + { + if (!string_is_empty(entry->path)) + free(entry->path); + entry->path = strdup(entry_path); + } + } + + if (string_is_equal(entry->value, + msg_hash_to_str(MENU_ENUM_LABEL_DISABLED)) || + (string_is_equal(entry->value, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF)))) + { + if (stripes->textures.list[STRIPES_TEXTURE_SWITCH_OFF]) + texture_switch = stripes->textures.list[STRIPES_TEXTURE_SWITCH_OFF]; + else + do_draw_text = true; + } + else if (string_is_equal(entry->value, + msg_hash_to_str(MENU_ENUM_LABEL_ENABLED)) || + (string_is_equal(entry->value, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_ON)))) + { + if (stripes->textures.list[STRIPES_TEXTURE_SWITCH_ON]) + texture_switch = stripes->textures.list[STRIPES_TEXTURE_SWITCH_ON]; + else + do_draw_text = true; + } + else + { + if (!string_is_empty(entry->value)) + { + if ( + string_is_equal(entry->value, "...") || + string_is_equal(entry->value, "(COMP)") || + string_is_equal(entry->value, "(CORE)") || + string_is_equal(entry->value, "(MOVIE)") || + string_is_equal(entry->value, "(MUSIC)") || + string_is_equal(entry->value, "(DIR)") || + string_is_equal(entry->value, "(RDB)") || + string_is_equal(entry->value, "(CURSOR)")|| + string_is_equal(entry->value, "(CFILE)") || + string_is_equal(entry->value, "(FILE)") || + string_is_equal(entry->value, "(IMAGE)") + ) + { + } + else + do_draw_text = true; + } + else + do_draw_text = true; + + } + + if (string_is_empty(entry->value)) + { + if (stripes->savestate_thumbnail || + (!string_is_equal + (thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF)) + && stripes->thumbnail) || + (!string_is_equal + (left_thumb_ident, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF)) + && stripes->left_thumbnail + && settings->bools.menu_xmb_vertical_thumbnails) + ) + ticker_limit = 40 * stripes_scale_mod[1]; + else + ticker_limit = 70 * stripes_scale_mod[2]; + } + + if (!string_is_empty(entry->path)) + ticker_str = menu_entry_get_rich_label(entry); + + ticker.s = tmp; + ticker.len = ticker_limit; + ticker.idx = frame_count / 20; + ticker.str = ticker_str; + ticker.selected = (i == current); + + if (ticker.str) + menu_animation_ticker(&ticker); + + label_offset = stripes->margins_label_top; + if (i == current && width > 320 && height > 240 + && !string_is_empty(entry->sublabel)) + { + char entry_sublabel[255] = {0}; + + label_offset = - stripes->margins_label_top; + + word_wrap(entry_sublabel, entry->sublabel, 50 * stripes_scale_mod[3], true); + + stripes_draw_text(video_info, stripes, entry_sublabel, + node->x + stripes->margins_screen_left + + stripes->icon_spacing_horizontal + stripes->margins_label_left, + stripes->margins_screen_top + node->y + stripes->margins_label_top*3.5, + 1, node->label_alpha, TEXT_ALIGN_LEFT, + width, height, stripes->font2); + } + + stripes_draw_text(video_info, stripes, tmp, + node->x + stripes->margins_screen_left + + stripes->icon_spacing_horizontal + stripes->margins_label_left, + stripes->margins_screen_top + node->y + label_offset, + 1, node->label_alpha, TEXT_ALIGN_LEFT, + width, height, stripes->font); + + tmp[0] = '\0'; + + ticker.s = tmp; + ticker.len = 35 * stripes_scale_mod[7]; + ticker.idx = frame_count / 20; + ticker.selected = (i == current); + + if (!string_is_empty(entry->value)) + { + ticker.str = entry->value; + menu_animation_ticker(&ticker); + } + + if (do_draw_text) + stripes_draw_text(video_info, stripes, tmp, + node->x + + + stripes->margins_screen_left + + stripes->icon_spacing_horizontal + + stripes->margins_label_left + + stripes->margins_setting_left, + stripes->margins_screen_top + node->y + stripes->margins_label_top, + 1, + node->label_alpha, + TEXT_ALIGN_LEFT, + width, height, stripes->font); + + + menu_display_set_alpha(color, MIN(node->alpha, stripes->alpha)); + + if (color[3] != 0) + { + math_matrix_4x4 mymat_tmp; + menu_display_ctx_rotate_draw_t rotate_draw; + uintptr_t texture = stripes_icon_get_id(stripes, core_node, node, + entry->enum_idx, entry_type, (i == current)); + float x = icon_x; + float y = icon_y; + float rotation = 0; + float scale_factor = node->zoom; + + rotate_draw.matrix = &mymat_tmp; + rotate_draw.rotation = rotation; + rotate_draw.scale_x = scale_factor; + rotate_draw.scale_y = scale_factor; + rotate_draw.scale_z = 1; + rotate_draw.scale_enable = true; + + menu_display_rotate_z(&rotate_draw, video_info); + + stripes_draw_icon(video_info, + stripes->icon_size, + &mymat_tmp, + texture, + x, + y, + width, + height, + 1.0, + rotation, + scale_factor, + &color[0], + stripes->shadow_offset); + } + + menu_display_set_alpha(color, MIN(node->alpha, stripes->alpha)); + + if (texture_switch != 0 && color[3] != 0) + stripes_draw_icon(video_info, + stripes->icon_size, + mymat, + texture_switch, + node->x + stripes->margins_screen_left + + stripes->icon_spacing_horizontal + + stripes->icon_size / 2.0 + stripes->margins_setting_left, + stripes->margins_screen_top + node->y + stripes->icon_size / 2.0, + width, height, + node->alpha, + 0, + 1, + &color[0], + stripes->shadow_offset); + +iterate: + if (!string_is_empty(ticker_str)) + free(ticker_str); + return 0; + +end: + if (!string_is_empty(ticker_str)) + free(ticker_str); + return -1; +} + +static void stripes_draw_items( + video_frame_info_t *video_info, + stripes_handle_t *stripes, + file_list_t *list, + size_t current, size_t cat_selection_ptr, float *color, + unsigned width, unsigned height) +{ + size_t i; + unsigned first, last; + math_matrix_4x4 mymat; + menu_display_ctx_rotate_draw_t rotate_draw; + stripes_node_t *core_node = NULL; + size_t end = 0; + uint64_t frame_count = stripes ? stripes->frame_count : 0; + const char *thumb_ident = stripes_thumbnails_ident('R'); + const char *left_thumb_ident= stripes_thumbnails_ident('L'); + + if (!list || !list->size || !stripes) + return; + + if (cat_selection_ptr > stripes->system_tab_end) + core_node = stripes_get_userdata_from_horizontal_list( + stripes, (unsigned)(cat_selection_ptr - (stripes->system_tab_end + 1))); + + end = file_list_get_size(list); + + rotate_draw.matrix = &mymat; + rotate_draw.rotation = 0; + rotate_draw.scale_x = 1; + rotate_draw.scale_y = 1; + rotate_draw.scale_z = 1; + rotate_draw.scale_enable = true; + + menu_display_rotate_z(&rotate_draw, video_info); + + menu_entries_ctl(MENU_ENTRIES_CTL_START_GET, &i); + + if (list == stripes->selection_buf_old) + { + stripes_node_t *node = (stripes_node_t*) + file_list_get_userdata_at_offset(list, current); + + if (node && (uint8_t)(255 * node->alpha) == 0) + return; + + i = 0; + } + + first = i; + last = end - 1; + + stripes_calculate_visible_range(stripes, height, end, current, &first, &last); + + menu_display_blend_begin(video_info); + + for (i = first; i <= last; i++) + { + int ret; + menu_entry_t entry; + menu_entry_init(&entry); + menu_entry_get(&entry, 0, i, list, true); + ret = stripes_draw_item(video_info, + &entry, + &mymat, + stripes, core_node, + list, color, thumb_ident, left_thumb_ident, + frame_count, + i, current, + width, height); + menu_entry_free(&entry); + if (ret == -1) + break; + } + + menu_display_blend_end(video_info); +} + +static void stripes_render(void *data, bool is_idle) +{ + size_t i; + float delta_time; + menu_animation_ctx_delta_t delta; + settings_t *settings = config_get_ptr(); + stripes_handle_t *stripes = (stripes_handle_t*)data; + unsigned end = (unsigned)menu_entries_get_size(); + bool mouse_enable = settings->bools.menu_mouse_enable; + bool pointer_enable = settings->bools.menu_pointer_enable; + + if (!stripes) + return; + + menu_animation_ctl(MENU_ANIMATION_CTL_DELTA_TIME, &delta_time); + + delta.current = delta_time; + + if (menu_animation_get_ideal_delta_time(&delta)) + menu_animation_update(delta.ideal); + + if (pointer_enable || mouse_enable) + { + size_t selection = menu_navigation_get_selection(); + int16_t pointer_y = menu_input_pointer_state(MENU_POINTER_Y_AXIS); + int16_t mouse_y = menu_input_mouse_state(MENU_MOUSE_Y_AXIS) + + (stripes->cursor_size/2); + unsigned first = 0, last = end; + unsigned height; + + video_driver_get_size(NULL, &height); + + if (height) + stripes_calculate_visible_range(stripes, height, + end, selection, &first, &last); + + for (i = first; i <= last; i++) + { + float item_y1 = stripes->margins_screen_top + + stripes_item_y(stripes, (int)i, selection); + float item_y2 = item_y1 + stripes->icon_size; + + if (pointer_enable) + { + if (pointer_y > item_y1 && pointer_y < item_y2) + menu_input_ctl(MENU_INPUT_CTL_POINTER_PTR, &i); + } + + if (mouse_enable) + { + if (mouse_y > item_y1 && mouse_y < item_y2) + menu_input_ctl(MENU_INPUT_CTL_MOUSE_PTR, &i); + } + } + } + + menu_entries_ctl(MENU_ENTRIES_CTL_START_GET, &i); + + if (i >= end) + { + i = 0; + menu_entries_ctl(MENU_ENTRIES_CTL_SET_START, &i); + } + + menu_animation_ctl(MENU_ANIMATION_CTL_CLEAR_ACTIVE, NULL); +} + +static bool stripes_shader_pipeline_active(video_frame_info_t *video_info) +{ + if (string_is_not_equal(menu_driver_ident(), "stripes")) + return false; + if (video_info->menu_shader_pipeline == XMB_SHADER_PIPELINE_WALLPAPER) + return false; + return true; +} + +static void stripes_draw_bg( + stripes_handle_t *stripes, + video_frame_info_t *video_info, + unsigned width, + unsigned height, + float alpha, + uintptr_t texture_id, + float *stripes_coord_black, + float *stripes_coord_white) +{ + menu_display_ctx_draw_t draw; + + bool running = video_info->libretro_running; + + draw.x = 0; + draw.y = 0; + draw.texture = texture_id; + draw.width = width; + draw.height = height; + draw.color = &stripes_coord_black[0]; + draw.vertex = NULL; + draw.tex_coord = NULL; + draw.vertex_count = 4; + draw.prim_type = MENU_DISPLAY_PRIM_TRIANGLESTRIP; + draw.pipeline.id = 0; + draw.pipeline.active = stripes_shader_pipeline_active(video_info); + + menu_display_blend_begin(video_info); + menu_display_set_viewport(video_info->width, video_info->height); + +#ifdef HAVE_SHADERPIPELINE + if (video_info->menu_shader_pipeline > XMB_SHADER_PIPELINE_WALLPAPER + && + (video_info->xmb_color_theme != XMB_THEME_WALLPAPER)) + { + draw.color = stripes_gradient_ident(video_info); + + if (running) + menu_display_set_alpha(draw.color, stripes_coord_black[3]); + else + menu_display_set_alpha(draw.color, stripes_coord_white[3]); + + menu_display_draw_gradient(&draw, video_info); + + draw.pipeline.id = VIDEO_SHADER_MENU_2; + + switch (video_info->menu_shader_pipeline) + { + case XMB_SHADER_PIPELINE_RIBBON: + draw.pipeline.id = VIDEO_SHADER_MENU; + break; + case XMB_SHADER_PIPELINE_SIMPLE_SNOW: + draw.pipeline.id = VIDEO_SHADER_MENU_3; + break; + case XMB_SHADER_PIPELINE_SNOW: + draw.pipeline.id = VIDEO_SHADER_MENU_4; + break; + case XMB_SHADER_PIPELINE_BOKEH: + draw.pipeline.id = VIDEO_SHADER_MENU_5; + break; + case XMB_SHADER_PIPELINE_SNOWFLAKE: + draw.pipeline.id = VIDEO_SHADER_MENU_6; + break; + default: + break; + } + + menu_display_draw_pipeline(&draw, video_info); + } + else +#endif + { + uintptr_t texture = draw.texture; + + if (video_info->xmb_color_theme != XMB_THEME_WALLPAPER) + draw.color = stripes_gradient_ident(video_info); + + if (running) + menu_display_set_alpha(draw.color, stripes_coord_black[3]); + else + menu_display_set_alpha(draw.color, stripes_coord_white[3]); + + if (video_info->xmb_color_theme != XMB_THEME_WALLPAPER) + menu_display_draw_gradient(&draw, video_info); + + { + float override_opacity = video_info->menu_wallpaper_opacity; + bool add_opacity = false; + + draw.texture = texture; + menu_display_set_alpha(draw.color, stripes_coord_white[3]); + + if (draw.texture) + draw.color = &stripes_coord_white[0]; + + if (running || video_info->xmb_color_theme == XMB_THEME_WALLPAPER) + add_opacity = true; + + menu_display_draw_bg(&draw, video_info, add_opacity, override_opacity); + } + } + + menu_display_draw(&draw, video_info); + menu_display_blend_end(video_info); +} + +static void stripes_draw_dark_layer( + stripes_handle_t *stripes, + video_frame_info_t *video_info, + unsigned width, + unsigned height) +{ + menu_display_ctx_draw_t draw; + struct video_coords coords; + float black[16] = { + 0, 0, 0, 1, + 0, 0, 0, 1, + 0, 0, 0, 1, + 0, 0, 0, 1, + }; + + menu_display_set_alpha(black, MIN(stripes->alpha, 0.75)); + + coords.vertices = 4; + coords.vertex = NULL; + coords.tex_coord = NULL; + coords.lut_tex_coord = NULL; + coords.color = &black[0]; + + draw.x = 0; + draw.y = 0; + draw.width = width; + draw.height = height; + draw.coords = &coords; + draw.matrix_data = NULL; + draw.texture = menu_display_white_texture; + draw.prim_type = MENU_DISPLAY_PRIM_TRIANGLESTRIP; + draw.pipeline.id = 0; + + menu_display_blend_begin(video_info); + menu_display_draw(&draw, video_info); + menu_display_blend_end(video_info); +} + +static void stripes_frame(void *data, video_frame_info_t *video_info) +{ + math_matrix_4x4 mymat; + unsigned i; + menu_display_ctx_rotate_draw_t rotate_draw; + char msg[1024]; + char title_msg[255]; + char title_truncated[255]; + size_t selection = 0; + size_t percent_width = 0; + const int min_thumb_size = 50; + bool render_background = false; + file_list_t *selection_buf = NULL; + unsigned width = video_info->width; + unsigned height = video_info->height; + const float under_thumb_margin = 0.96; + float scale_factor = 0.0f; + float pseudo_font_length = 0.0f; + stripes_handle_t *stripes = (stripes_handle_t*)data; + settings_t *settings = config_get_ptr(); + + if (!stripes) + return; + + scale_factor = (settings->uints.menu_xmb_scale_factor * (float)width) / (1920.0 * 100); + pseudo_font_length = stripes->icon_spacing_horizontal * 4 - stripes->icon_size / 4; + + stripes->frame_count++; + + msg[0] = '\0'; + title_msg[0] = '\0'; + title_truncated[0] = '\0'; + + font_driver_bind_block(stripes->font, &stripes->raster_block); + font_driver_bind_block(stripes->font2, &stripes->raster_block2); + + stripes->raster_block.carr.coords.vertices = 0; + stripes->raster_block2.carr.coords.vertices = 0; + + menu_display_set_alpha(stripes_coord_black, MIN( + (float)video_info->xmb_alpha_factor/100, stripes->alpha)); + menu_display_set_alpha(stripes_coord_white, stripes->alpha); + + stripes_draw_bg( + stripes, + video_info, + width, + height, + stripes->alpha, + stripes->textures.bg, + stripes_coord_black, + stripes_coord_white); + + selection = menu_navigation_get_selection(); + + strlcpy(title_truncated, + stripes->title_name, sizeof(title_truncated)); + + if (selection > 1) + { + /* skip 25 utf8 multi-byte chars */ + char *end = title_truncated; + + for(i = 0; i < 25 && *end; i++) + { + end++; + while((*end & 0xC0) == 0x80) + end++; + } + + *end = '\0'; + } + + /* Title text */ + stripes_draw_text(video_info, stripes, + title_truncated, stripes->margins_title_left, + stripes->margins_title_top, + 1, 1, TEXT_ALIGN_LEFT, + width, height, stripes->font); + + if (settings->bools.menu_core_enable && + menu_entries_get_core_title(title_msg, sizeof(title_msg)) == 0) + stripes_draw_text(video_info, stripes, title_msg, stripes->margins_title_left, + height - stripes->margins_title_bottom, 1, 1, TEXT_ALIGN_LEFT, + width, height, stripes->font); + + rotate_draw.matrix = &mymat; + rotate_draw.rotation = 0; + rotate_draw.scale_x = 1; + rotate_draw.scale_y = 1; + rotate_draw.scale_z = 1; + rotate_draw.scale_enable = true; + + menu_display_rotate_z(&rotate_draw, video_info); + menu_display_blend_begin(video_info); + + /* Save State thumbnail, right side */ + if (stripes->savestate_thumbnail) + { + stripes_draw_thumbnail(video_info, + stripes, &stripes_coord_white[0], width, height, + stripes->margins_screen_left * stripes_scale_mod[5] + + stripes->icon_spacing_horizontal + pseudo_font_length, + stripes->margins_screen_top + stripes->icon_size + + stripes->savestate_thumbnail_height * stripes_scale_mod[4], + stripes->savestate_thumbnail_width * stripes_scale_mod[4], + stripes->savestate_thumbnail_height * stripes_scale_mod[4], + stripes->savestate_thumbnail); + } + + /* Right thumbnail big size */ + if (!settings->bools.menu_xmb_vertical_thumbnails || + (settings->bools.menu_xmb_vertical_thumbnails && !stripes->left_thumbnail)) + { + /* Do not draw the right thumbnail if there is no space available */ + + if (((stripes->margins_screen_top + + stripes->icon_size + min_thumb_size) <= height) && + ((stripes->margins_screen_left * stripes_scale_mod[5] + + stripes->icon_spacing_horizontal + + pseudo_font_length + min_thumb_size) <= width)) + { + if (stripes->thumbnail + && !string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + /* Limit thumbnail width */ + + float thumb_width = 0.0f; + float thumb_height = 0.0f; + float thumb_max_width = (float)width - (stripes->icon_size / 6) + - (stripes->margins_screen_left * stripes_scale_mod[5]) - + stripes->icon_spacing_horizontal - pseudo_font_length; + + #ifdef STRIPES_DEBUG + RARCH_LOG("[XMB thumbnail] width: %.2f, height: %.2f\n", + stripes->thumbnail_width, stripes->thumbnail_height); + RARCH_LOG("[XMB thumbnail] w: %.2f, h: %.2f\n", width, height); + #endif + + if (stripes->thumbnail_width * stripes_scale_mod[4] > thumb_max_width) + { + thumb_width = (stripes->thumbnail_width * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->thumbnail_width * stripes_scale_mod[4])); + thumb_height = (stripes->thumbnail_height * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->thumbnail_width * stripes_scale_mod[4])); + } + else + { + thumb_width = stripes->thumbnail_width * stripes_scale_mod[4]; + thumb_height = stripes->thumbnail_height * stripes_scale_mod[4]; + } + + /* Limit thumbnail height to screen height + margin. */ + + if (stripes->margins_screen_top + stripes->icon_size + thumb_height >= + ((float)height * under_thumb_margin)) + { + thumb_width = thumb_width * + ((((float)height * under_thumb_margin) - + stripes->margins_screen_top - stripes->icon_size) / + thumb_height); + thumb_height = thumb_height * + ((((float)height * under_thumb_margin) - + stripes->margins_screen_top - stripes->icon_size) / + thumb_height); + } + + stripes_draw_thumbnail(video_info, + stripes, &stripes_coord_white[0], width, height, + (float)width - (stripes->icon_size / 6) - thumb_max_width + + ((thumb_max_width - thumb_width) / 2), + stripes->margins_screen_top + stripes->icon_size + thumb_height, + thumb_width, thumb_height, + stripes->thumbnail); + } + } + } + + /* Left thumbnail in the left margin */ + /* Do not draw the left thumbnail if there is no space available */ + if (!settings->bools.menu_xmb_vertical_thumbnails && + (stripes->margins_screen_top + stripes->icon_size * + (!(stripes->depth == 1)? 2.1 : 1) + min_thumb_size) + <= (float)height) + { + /* Left Thumbnail in the left margin */ + + if (stripes->left_thumbnail + && !string_is_equal(stripes_thumbnails_ident('L'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + /* Limit left thumbnail width */ + + float left_thumb_width = 0.0f; + float left_thumb_height = 0.0f; + float thumb_max_width = stripes->icon_size * 3.4; + + #ifdef STRIPES_DEBUG + RARCH_LOG("[XMB left thumbnail] width: %.2f, height: %.2f\n", + stripes->left_thumbnail_width, stripes->left_thumbnail_height); + RARCH_LOG("[XMB left thumbnail] w: %.2f, h: %.2f\n", width, height); + #endif + + if (stripes->left_thumbnail_width * stripes_scale_mod[4] > thumb_max_width) + { + left_thumb_width = (stripes->left_thumbnail_width * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->left_thumbnail_width * stripes_scale_mod[4])); + left_thumb_height = (stripes->left_thumbnail_height * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->left_thumbnail_width * stripes_scale_mod[4])); + } + else + { + left_thumb_width = stripes->left_thumbnail_width * stripes_scale_mod[4]; + left_thumb_height = stripes->left_thumbnail_height * stripes_scale_mod[4]; + } + + /* Limit left thumbnail height to screen height + margin. */ + if (stripes->margins_screen_top + stripes->icon_size * + (!(stripes->depth == 1)? 2.1 : 1) + + left_thumb_height >= + ((float)height - (96.0 * scale_factor))) + { + left_thumb_width = left_thumb_width * + ((((float)height - (96.0 * scale_factor)) + - stripes->margins_screen_top - + (stripes->icon_size * (!(stripes->depth == 1)? 2.1 : 1))) / + left_thumb_height); + + left_thumb_height = left_thumb_height * + ((((float)height - (96.0 * scale_factor)) + - stripes->margins_screen_top - + (stripes->icon_size * (!(stripes->depth == 1)? 2.1 : 1))) / + left_thumb_height); + } + else + { + left_thumb_width = left_thumb_width; + left_thumb_height = left_thumb_height; + } + + stripes_draw_thumbnail(video_info, + stripes, &stripes_coord_white[0], width, height, + (stripes->icon_size / 6) + + ((thumb_max_width - left_thumb_width) / 2), + stripes->margins_screen_top + stripes->icon_size * + (!(stripes->depth == 1)? 2.1 : 1) + left_thumb_height, + left_thumb_width, left_thumb_height, + stripes->left_thumbnail); + } + } + + /* No Right Thumbnail, draw only the left one big size */ + if (settings->bools.menu_xmb_vertical_thumbnails && !stripes->thumbnail) + { + /* Do not draw the left thumbnail if there is no space available */ + + if (((stripes->margins_screen_top + + stripes->icon_size + min_thumb_size) <= height) && + ((stripes->margins_screen_left * stripes_scale_mod[5] + + stripes->icon_spacing_horizontal + + pseudo_font_length + min_thumb_size) <= width)) + { + if (stripes->left_thumbnail + && !string_is_equal(stripes_thumbnails_ident('L'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + /* Limit left thumbnail width */ + + float left_thumb_width = 0.0f; + float left_thumb_height = 0.0f; + float thumb_max_width = (float)width - (stripes->icon_size / 6) + - (stripes->margins_screen_left * stripes_scale_mod[5]) - + stripes->icon_spacing_horizontal - pseudo_font_length; + + #ifdef STRIPES_DEBUG + RARCH_LOG("[XMB thumbnail] width: %.2f, height: %.2f\n", + stripes->thumbnail_width, stripes->thumbnail_height); + RARCH_LOG("[XMB thumbnail] w: %.2f, h: %.2f\n", width, height); + #endif + + if (stripes->left_thumbnail_width * stripes_scale_mod[4] > thumb_max_width) + { + left_thumb_width = (stripes->left_thumbnail_width * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->left_thumbnail_width * stripes_scale_mod[4])); + left_thumb_height = (stripes->left_thumbnail_height * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->left_thumbnail_width * stripes_scale_mod[4])); + } + else + { + left_thumb_width = stripes->left_thumbnail_width * stripes_scale_mod[4]; + left_thumb_height = stripes->left_thumbnail_height * stripes_scale_mod[4]; + } + + /* Limit left thumbnail height to screen height + margin. */ + + if (stripes->margins_screen_top + stripes->icon_size + left_thumb_height >= + ((float)height * under_thumb_margin)) + { + left_thumb_width = left_thumb_width * + ((((float)height * under_thumb_margin) - + stripes->margins_screen_top - stripes->icon_size) / + left_thumb_height); + left_thumb_height = left_thumb_height * + ((((float)height * under_thumb_margin) - + stripes->margins_screen_top - stripes->icon_size) / + left_thumb_height); + } + + stripes_draw_thumbnail(video_info, + stripes, &stripes_coord_white[0], width, height, + (float)width - (stripes->icon_size / 6) - thumb_max_width + + ((thumb_max_width - left_thumb_width) / 2), + stripes->margins_screen_top + stripes->icon_size + left_thumb_height, + left_thumb_width, left_thumb_height, + stripes->left_thumbnail); + } + } + } + + /* Clock image */ + menu_display_set_alpha(stripes_coord_white, MIN(stripes->alpha, 1.00f)); + + if (video_info->battery_level_enable) + { + char msg[12]; + static retro_time_t last_time = 0; + bool charging = false; + retro_time_t current_time = cpu_features_get_time_usec(); + int percent = 0; + enum frontend_powerstate state = get_last_powerstate(&percent); + + if (state == FRONTEND_POWERSTATE_CHARGING) + charging = true; + + if (current_time - last_time >= BATTERY_LEVEL_CHECK_INTERVAL) + { + last_time = current_time; + task_push_get_powerstate(); + } + + *msg = '\0'; + + if (percent > 0) + { + size_t x_pos = stripes->icon_size / 6; + size_t x_pos_icon = stripes->margins_title_left; + + if (stripes_coord_white[3] != 0) + stripes_draw_icon(video_info, + stripes->icon_size, + &mymat, + stripes->textures.list[charging + ? STRIPES_TEXTURE_BATTERY_CHARGING : STRIPES_TEXTURE_BATTERY_FULL], + width - (stripes->icon_size / 2) - x_pos_icon, + stripes->icon_size, + width, + height, + 1, + 0, + 1, + &stripes_coord_white[0], + stripes->shadow_offset); + + snprintf(msg, sizeof(msg), "%d%%", percent); + + percent_width = (unsigned) + font_driver_get_message_width( + stripes->font, msg, (unsigned)strlen(msg), 1); + + stripes_draw_text(video_info, stripes, msg, + width - stripes->margins_title_left - x_pos, + stripes->margins_title_top, 1, 1, TEXT_ALIGN_RIGHT, + width, height, stripes->font); + } + } + + if (video_info->timedate_enable) + { + menu_display_ctx_datetime_t datetime; + char timedate[255]; + int x_pos = 0; + + if (stripes_coord_white[3] != 0) + { + int x_pos = 0; + + if (percent_width) + x_pos = percent_width + (stripes->icon_size / 2.5); + + stripes_draw_icon(video_info, + stripes->icon_size, + &mymat, + stripes->textures.list[STRIPES_TEXTURE_CLOCK], + width - stripes->icon_size - x_pos, + stripes->icon_size, + width, + height, + 1, + 0, + 1, + &stripes_coord_white[0], + stripes->shadow_offset); + } + + timedate[0] = '\0'; + + datetime.s = timedate; + datetime.len = sizeof(timedate); + datetime.time_mode = 4; + + menu_display_timedate(&datetime); + + if (percent_width) + x_pos = percent_width + (stripes->icon_size / 2.5); + + stripes_draw_text(video_info, stripes, timedate, + width - stripes->margins_title_left - stripes->icon_size / 4 - x_pos, + stripes->margins_title_top, 1, 1, TEXT_ALIGN_RIGHT, + width, height, stripes->font); + } + + /* Arrow image */ + menu_display_set_alpha(stripes_coord_white, + MIN(stripes->textures_arrow_alpha, stripes->alpha)); + + if (stripes_coord_white[3] != 0) + stripes_draw_icon(video_info, + stripes->icon_size, + &mymat, + stripes->textures.list[STRIPES_TEXTURE_ARROW], + stripes->x + stripes->margins_screen_left + + stripes->icon_spacing_horizontal - + stripes->icon_size / 2.0 + stripes->icon_size, + stripes->margins_screen_top + + stripes->icon_size / 2.0 + stripes->icon_spacing_vertical + * stripes->active_item_factor, + width, + height, + stripes->textures_arrow_alpha, + 0, + 1, + &stripes_coord_white[0], + stripes->shadow_offset); + + menu_display_blend_begin(video_info); + + /* Horizontal tab icons */ + for (i = 0; i <= stripes_list_get_size(stripes, MENU_LIST_HORIZONTAL) + + stripes->system_tab_end; i++) + { + stripes_node_t *node = stripes_get_node(stripes, i); + + if (!node) + continue; + + menu_display_set_alpha(stripes_item_color, MIN(node->alpha, stripes->alpha)); + + if (stripes_item_color[3] != 0) + { + menu_display_ctx_rotate_draw_t rotate_draw; + math_matrix_4x4 mymat; + uintptr_t texture = node->icon; + float x = stripes->x + stripes->categories_x_pos + + stripes->margins_screen_left + + stripes->icon_spacing_horizontal + * (i + 1) - stripes->icon_size / 2.0; + float y = stripes->margins_screen_top + + stripes->icon_size / 2.0; + float rotation = 0; + float scale_factor = node->zoom; + + rotate_draw.matrix = &mymat; + rotate_draw.rotation = rotation; + rotate_draw.scale_x = scale_factor; + rotate_draw.scale_y = scale_factor; + rotate_draw.scale_z = 1; + rotate_draw.scale_enable = true; + + menu_display_rotate_z(&rotate_draw, video_info); + + stripes_draw_icon(video_info, + stripes->icon_size, + &mymat, + texture, + x, + y, + width, + height, + 1.0, + rotation, + scale_factor, + &stripes_item_color[0], + stripes->shadow_offset); + } + } + + /* Right side 2 thumbnails on top of each other */ + /* here to be displayed above the horizontal icons */ + if (stripes->left_thumbnail && stripes->thumbnail && settings->bools.menu_xmb_vertical_thumbnails) + { + /* Do not draw the right thumbnail if there is no space available */ + if (((stripes->margins_screen_top + + stripes->icon_size + min_thumb_size) <= height) && + ((stripes->margins_screen_left * stripes_scale_mod[5] + + stripes->icon_spacing_horizontal + + pseudo_font_length + min_thumb_size) <= width)) + { + if (stripes->thumbnail && + !string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + /* Limit right thumbnail width */ + + float thumb_width = 0.0f; + float thumb_height = 0.0f; + float thumb_max_width = (float)width - (stripes->icon_size / 6) - + (stripes->margins_screen_left * stripes_scale_mod[5]) - + stripes->icon_spacing_horizontal - pseudo_font_length; + + #ifdef STRIPES_DEBUG + RARCH_LOG("[XMB thumbnail] width: %.2f, height: %.2f\n", + stripes->thumbnail_width, stripes->thumbnail_height); + RARCH_LOG("[XMB thumbnail] w: %.2f, h: %.2f\n", width, height); + #endif + + if (stripes->thumbnail_width * stripes_scale_mod[4] > thumb_max_width) + { + thumb_width = (stripes->thumbnail_width * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->thumbnail_width * stripes_scale_mod[4])); + thumb_height = (stripes->thumbnail_height * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->thumbnail_width * stripes_scale_mod[4])); + } + else + { + thumb_width = stripes->thumbnail_width * stripes_scale_mod[4]; + thumb_height = stripes->thumbnail_height * stripes_scale_mod[4]; + } + + /* Limit right thumbnail height to usable area. */ + + if (thumb_height >= + ((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) + { + thumb_width = thumb_width * + ((((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) / + thumb_height); + thumb_height = thumb_height * + ((((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) / + thumb_height); + } + + stripes_draw_thumbnail(video_info, + stripes, &stripes_coord_white[0], width, height, + (float)width - (stripes->icon_size / 6) - thumb_max_width + + ((thumb_max_width - thumb_width) / 2), + stripes->icon_size + ((((float)height / 2 - + (stripes->icon_size + (stripes->icon_size/12))) - thumb_height) / 2) + + thumb_height, + thumb_width, thumb_height, + stripes->thumbnail); + } + } + + /* Do not draw the left thumbnail if there is no space available */ + + if (((stripes->margins_screen_top + + stripes->icon_size + min_thumb_size) <= height) && + ((stripes->margins_screen_left * stripes_scale_mod[5] + + stripes->icon_spacing_horizontal + + pseudo_font_length + min_thumb_size) <= width)) + { + if (stripes->left_thumbnail && + !string_is_equal(stripes_thumbnails_ident('L'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + { + /* Limit left thumbnail width */ + + float left_thumb_width = 0.0f; + float left_thumb_height = 0.0f; + float thumb_max_width = (float)width - (stripes->icon_size / 6) - + (stripes->margins_screen_left * stripes_scale_mod[5]) - + stripes->icon_spacing_horizontal - pseudo_font_length; + + #ifdef STRIPES_DEBUG + RARCH_LOG("[XMB left thumbnail] width: %.2f, height: %.2f\n", + stripes->left_thumbnail_width, stripes->left_thumbnail_height); + RARCH_LOG("[XMB left thumbnail] w: %.2f, h: %.2f\n", width, height); + #endif + + if (stripes->left_thumbnail_width * stripes_scale_mod[4] > thumb_max_width) + { + left_thumb_width = (stripes->left_thumbnail_width * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->left_thumbnail_width * stripes_scale_mod[4])); + left_thumb_height = (stripes->left_thumbnail_height * stripes_scale_mod[4]) * + (thumb_max_width / (stripes->left_thumbnail_width * stripes_scale_mod[4])); + } + else + { + left_thumb_width = stripes->left_thumbnail_width * stripes_scale_mod[4]; + left_thumb_height = stripes->left_thumbnail_height * stripes_scale_mod[4]; + } + + /* Limit left thumbnail height to usable area. */ + + if (left_thumb_height >= + ((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) + { + left_thumb_width = left_thumb_width * + ((((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) / + left_thumb_height); + left_thumb_height = left_thumb_height * + ((((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) / + left_thumb_height); + } + + stripes_draw_thumbnail(video_info, + stripes, &stripes_coord_white[0], width, height, + (float)width - (stripes->icon_size / 6) - thumb_max_width + + ((thumb_max_width - left_thumb_width) / 2), + stripes->icon_size + + (((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) + + (((((float)height - ((stripes->icon_size / 6) * 2) - stripes->icon_size) / 2) - + left_thumb_height) / 2) + left_thumb_height, + left_thumb_width, left_thumb_height, + stripes->left_thumbnail); + } + } + } + + menu_display_blend_end(video_info); + + /* Vertical icons */ + if (stripes) + stripes_draw_items( + video_info, + stripes, + stripes->selection_buf_old, + stripes->selection_ptr_old, + (stripes_list_get_size(stripes, MENU_LIST_PLAIN) > 1) + ? stripes->categories_selection_ptr : + stripes->categories_selection_ptr_old, + &stripes_item_color[0], + width, + height); + + selection_buf = menu_entries_get_selection_buf_ptr(0); + + if (stripes) + stripes_draw_items( + video_info, + stripes, + selection_buf, + selection, + stripes->categories_selection_ptr, + &stripes_item_color[0], + width, + height); + + font_driver_flush(video_info->width, video_info->height, stripes->font, + video_info); + font_driver_bind_block(stripes->font, NULL); + + font_driver_flush(video_info->width, video_info->height, stripes->font2, + video_info); + font_driver_bind_block(stripes->font2, NULL); + + if (menu_input_dialog_get_display_kb()) + { + const char *str = menu_input_dialog_get_buffer(); + const char *label = menu_input_dialog_get_label_buffer(); + + snprintf(msg, sizeof(msg), "%s\n%s", label, str); + render_background = true; + } + + if (!string_is_empty(stripes->box_message)) + { + strlcpy(msg, stripes->box_message, + sizeof(msg)); + free(stripes->box_message); + stripes->box_message = NULL; + render_background = true; + } + + if (render_background) + { + stripes_draw_dark_layer(stripes, video_info, width, height); + stripes_render_messagebox_internal( + video_info, stripes, msg, &stripes_coord_white[0]); + } + + /* Cursor image */ + if (stripes->mouse_show) + { + menu_display_set_alpha(stripes_coord_white, MIN(stripes->alpha, 1.00f)); + menu_display_draw_cursor( + video_info, + &stripes_coord_white[0], + stripes->cursor_size, + stripes->textures.list[STRIPES_TEXTURE_POINTER], + menu_input_mouse_state(MENU_MOUSE_X_AXIS), + menu_input_mouse_state(MENU_MOUSE_Y_AXIS), + width, + height); + } + + menu_display_unset_viewport(video_info->width, video_info->height); +} + +static void stripes_layout_ps3(stripes_handle_t *stripes, int width) +{ + unsigned new_font_size, new_header_height; + settings_t *settings = config_get_ptr(); + + float scale_factor = + (settings->uints.menu_xmb_scale_factor * width) / (1920.0 * 100); + + stripes->above_subitem_offset = 1.5; + stripes->above_item_offset = -1.0; + stripes->active_item_factor = 3.0; + stripes->under_item_offset = 5.0; + + stripes->categories_active_zoom = 1.0; + stripes->categories_passive_zoom = 0.5; + stripes->items_active_zoom = 1.0; + stripes->items_passive_zoom = 0.5; + + stripes->categories_active_alpha = 1.0; + stripes->categories_passive_alpha = 0.85; + stripes->items_active_alpha = 1.0; + stripes->items_passive_alpha = 0.85; + + stripes->shadow_offset = 2.0; + + new_font_size = 32.0 * scale_factor; + stripes->font2_size = 24.0 * scale_factor; + new_header_height = 128.0 * scale_factor; + + + stripes->thumbnail_width = 1024.0 * scale_factor; + stripes->left_thumbnail_width = 1024.0 * scale_factor; + stripes->savestate_thumbnail_width= 460.0 * scale_factor; + stripes->cursor_size = 64.0 * scale_factor; + + stripes->icon_spacing_horizontal = 200.0 * scale_factor; + stripes->icon_spacing_vertical = 64.0 * scale_factor; + + stripes->margins_screen_top = (256+32) * scale_factor; + stripes->margins_screen_left = 336.0 * scale_factor; + + stripes->margins_title_left = 60 * scale_factor; + stripes->margins_title_top = 60 * scale_factor + new_font_size / 3; + stripes->margins_title_bottom = 60 * scale_factor - new_font_size / 3; + + stripes->margins_label_left = 85.0 * scale_factor; + stripes->margins_label_top = new_font_size / 3.0; + + stripes->margins_setting_left = 600.0 * scale_factor * stripes_scale_mod[6]; + stripes->margins_dialog = 48 * scale_factor; + + stripes->margins_slice = 16; + + stripes->icon_size = 128.0 * scale_factor; + stripes->font_size = new_font_size; + +#ifdef STRIPES_DEBUG + RARCH_LOG("[XMB] margin screen left: %.2f\n", stripes->margins_screen_left); + RARCH_LOG("[XMB] margin screen top: %.2f\n", stripes->margins_screen_top); + RARCH_LOG("[XMB] margin title left: %.2f\n", stripes->margins_title_left); + RARCH_LOG("[XMB] margin title top: %.2f\n", stripes->margins_title_top); + RARCH_LOG("[XMB] margin title bott: %.2f\n", stripes->margins_title_bottom); + RARCH_LOG("[XMB] margin label left: %.2f\n", stripes->margins_label_left); + RARCH_LOG("[XMB] margin label top: %.2f\n", stripes->margins_label_top); + RARCH_LOG("[XMB] margin sett left: %.2f\n", stripes->margins_setting_left); + RARCH_LOG("[XMB] icon spacing hor: %.2f\n", stripes->icon_spacing_horizontal); + RARCH_LOG("[XMB] icon spacing ver: %.2f\n", stripes->icon_spacing_vertical); + RARCH_LOG("[XMB] icon size: %.2f\n", stripes->icon_size); +#endif + + menu_display_set_header_height(new_header_height); +} + +static void stripes_layout_psp(stripes_handle_t *stripes, int width) +{ + unsigned new_font_size, new_header_height; + settings_t *settings = config_get_ptr(); + float scale_factor = + ((settings->uints.menu_xmb_scale_factor * width) / (1920.0 * 100)) * 1.5; +#ifdef _3DS + scale_factor = + settings->uints.menu_xmb_scale_factor / 400.0; +#endif + + stripes->above_subitem_offset = 1.5; + stripes->above_item_offset = -1.0; + stripes->active_item_factor = 2.0; + stripes->under_item_offset = 3.0; + + stripes->categories_active_zoom = 1.0; + stripes->categories_passive_zoom = 1.0; + stripes->items_active_zoom = 1.0; + stripes->items_passive_zoom = 1.0; + + stripes->categories_active_alpha = 1.0; + stripes->categories_passive_alpha = 0.85; + stripes->items_active_alpha = 1.0; + stripes->items_passive_alpha = 0.85; + + stripes->shadow_offset = 1.0; + + new_font_size = 32.0 * scale_factor; + stripes->font2_size = 24.0 * scale_factor; + new_header_height = 128.0 * scale_factor; + stripes->margins_screen_top = (256+32) * scale_factor; + + stripes->thumbnail_width = 460.0 * scale_factor; + stripes->left_thumbnail_width = 400.0 * scale_factor; + stripes->savestate_thumbnail_width= 460.0 * scale_factor; + stripes->cursor_size = 64.0; + + stripes->icon_spacing_horizontal = 250.0 * scale_factor; + stripes->icon_spacing_vertical = 108.0 * scale_factor; + + stripes->margins_screen_left = 136.0 * scale_factor; + stripes->margins_title_left = 60 * scale_factor; + stripes->margins_title_top = 60 * scale_factor + new_font_size / 3; + stripes->margins_title_bottom = 60 * scale_factor - new_font_size / 3; + stripes->margins_label_left = 85.0 * scale_factor; + stripes->margins_label_top = new_font_size / 3.0; + stripes->margins_setting_left = 600.0 * scale_factor; + stripes->margins_dialog = 48 * scale_factor; + stripes->margins_slice = 16; + stripes->icon_size = 128.0 * scale_factor; + stripes->font_size = new_font_size; + +#ifdef STRIPES_DEBUG + RARCH_LOG("[XMB] margin screen left: %.2f\n", stripes->margins_screen_left); + RARCH_LOG("[XMB] margin screen top: %.2f\n", stripes->margins_screen_top); + RARCH_LOG("[XMB] margin title left: %.2f\n", stripes->margins_title_left); + RARCH_LOG("[XMB] margin title top: %.2f\n", stripes->margins_title_top); + RARCH_LOG("[XMB] margin title bott: %.2f\n", stripes->margins_title_bottom); + RARCH_LOG("[XMB] margin label left: %.2f\n", stripes->margins_label_left); + RARCH_LOG("[XMB] margin label top: %.2f\n", stripes->margins_label_top); + RARCH_LOG("[XMB] margin sett left: %.2f\n", stripes->margins_setting_left); + RARCH_LOG("[XMB] icon spacing hor: %.2f\n", stripes->icon_spacing_horizontal); + RARCH_LOG("[XMB] icon spacing ver: %.2f\n", stripes->icon_spacing_vertical); + RARCH_LOG("[XMB] icon size: %.2f\n", stripes->icon_size); +#endif + + menu_display_set_header_height(new_header_height); +} + +static void stripes_layout(stripes_handle_t *stripes) +{ + unsigned width, height, i, current, end; + file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0); + size_t selection = menu_navigation_get_selection(); + + video_driver_get_size(&width, &height); + + /* Mimic the layout of the PSP instead of the PS3 on tiny screens */ + if (width > 320 && height > 240) + stripes_layout_ps3(stripes, width); + else + stripes_layout_psp(stripes, width); + + current = (unsigned)selection; + end = (unsigned)menu_entries_get_size(); + + for (i = 0; i < end; i++) + { + float ia = stripes->items_passive_alpha; + float iz = stripes->items_passive_zoom; + stripes_node_t *node = (stripes_node_t*)file_list_get_userdata_at_offset( + selection_buf, i); + + if (!node) + continue; + + if (i == current) + { + ia = stripes->items_active_alpha; + iz = stripes->items_active_alpha; + } + + node->alpha = ia; + node->label_alpha = ia; + node->zoom = iz; + node->y = stripes_item_y(stripes, i, current); + } + + if (stripes->depth <= 1) + return; + + current = (unsigned)stripes->selection_ptr_old; + end = (unsigned)file_list_get_size(stripes->selection_buf_old); + + for (i = 0; i < end; i++) + { + float ia = 0; + float iz = stripes->items_passive_zoom; + stripes_node_t *node = (stripes_node_t*)file_list_get_userdata_at_offset( + stripes->selection_buf_old, i); + + if (!node) + continue; + + if (i == current) + { + ia = stripes->items_active_alpha; + iz = stripes->items_active_alpha; + } + + node->alpha = ia; + node->label_alpha = 0; + node->zoom = iz; + node->y = stripes_item_y(stripes, i, current); + node->x = stripes->icon_size * 1 * -2; + } +} + +static void stripes_ribbon_set_vertex(float *ribbon_verts, + unsigned idx, unsigned row, unsigned col) +{ + ribbon_verts[idx++] = ((float)col) / (STRIPES_RIBBON_COLS-1) * 2.0f - 1.0f; + ribbon_verts[idx++] = ((float)row) / (STRIPES_RIBBON_ROWS-1) * 2.0f - 1.0f; +} + +static void stripes_init_ribbon(stripes_handle_t * stripes) +{ + video_coords_t coords; + unsigned r, c, col; + unsigned i = 0; + video_coord_array_t *ca = menu_display_get_coords_array(); + unsigned vertices_total = STRIPES_RIBBON_VERTICES; + float *dummy = (float*)calloc(4 * vertices_total, sizeof(float)); + float *ribbon_verts = (float*)calloc(2 * vertices_total, sizeof(float)); + + /* Set up vertices */ + for (r = 0; r < STRIPES_RIBBON_ROWS - 1; r++) + { + for (c = 0; c < STRIPES_RIBBON_COLS; c++) + { + col = r % 2 ? STRIPES_RIBBON_COLS - c - 1 : c; + stripes_ribbon_set_vertex(ribbon_verts, i, r, col); + stripes_ribbon_set_vertex(ribbon_verts, i + 2, r + 1, col); + i += 4; + } + } + + coords.color = dummy; + coords.vertex = ribbon_verts; + coords.tex_coord = dummy; + coords.lut_tex_coord = dummy; + coords.vertices = vertices_total; + + video_coord_array_append(ca, &coords, coords.vertices); + + free(dummy); + free(ribbon_verts); +} + + + +static void *stripes_init(void **userdata, bool video_is_threaded) +{ + unsigned width, height; + int i; + stripes_handle_t *stripes = NULL; + settings_t *settings = config_get_ptr(); + menu_handle_t *menu = (menu_handle_t*)calloc(1, sizeof(*menu)); + float scale_value = settings->uints.menu_xmb_scale_factor; + + /* scaling multiplier formulas made from these values: */ + /* stripes_scale 50 = {2.5, 2.5, 2, 1.7, 2.5, 4, 2.4, 2.5} */ + /* stripes_scale 75 = { 2, 1.6, 1.6, 1.4, 1.5, 2.3, 1.9, 1.3} */ + if (scale_value < 100) + { + /* text length & word wrap (base 35 apply to file browser, 1st column) */ + stripes_scale_mod[0] = -0.03 * scale_value + 4.083; + /* playlist text length when thumbnail is ON (small, base 40) */ + stripes_scale_mod[1] = -0.03 * scale_value + 3.95; + /* playlist text length when thumbnail is OFF (large, base 70) */ + stripes_scale_mod[2] = -0.02 * scale_value + 3.033; + /* sub-label length & word wrap */ + stripes_scale_mod[3] = -0.014 * scale_value + 2.416; + /* thumbnail size & vertical margin from top */ + stripes_scale_mod[4] = -0.03 * scale_value + 3.916; + /* thumbnail horizontal left margin (horizontal positioning) */ + stripes_scale_mod[5] = -0.06 * scale_value + 6.933; + /* margin before 2nd column start (shaders parameters, cheats...) */ + stripes_scale_mod[6] = -0.028 * scale_value + 3.866; + /* text length & word wrap (base 35 apply to 2nd column in cheats, shaders, etc) */ + stripes_scale_mod[7] = 134.179 * pow(scale_value, -1.0778); + + for (i = 0; i < 8; i++) + if (stripes_scale_mod[i] < 1) + stripes_scale_mod[i] = 1; + } + + if (!menu) + goto error; + + if (!menu_display_init_first_driver(video_is_threaded)) + goto error; + + video_driver_get_size(&width, &height); + + stripes = (stripes_handle_t*)calloc(1, sizeof(stripes_handle_t)); + + if (!stripes) + goto error; + + *userdata = stripes; + + stripes->selection_buf_old = (file_list_t*)calloc(1, sizeof(file_list_t)); + + if (!stripes->selection_buf_old) + goto error; + + stripes->categories_active_idx = 0; + stripes->categories_active_idx_old = 0; + stripes->x = 0; + stripes->categories_x_pos = 0; + stripes->textures_arrow_alpha = 0; + stripes->depth = 1; + stripes->old_depth = 1; + stripes->alpha = 0; + + stripes->system_tab_end = 0; + stripes->tabs[stripes->system_tab_end] = STRIPES_SYSTEM_TAB_MAIN; + if (settings->bools.menu_content_show_settings && !settings->bools.kiosk_mode_enable) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_SETTINGS; + if (settings->bools.menu_content_show_favorites) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_FAVORITES; + if (settings->bools.menu_content_show_history) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_HISTORY; +#ifdef HAVE_IMAGEVIEWER + if (settings->bools.menu_content_show_images) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_IMAGES; +#endif + if (settings->bools.menu_content_show_music) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_MUSIC; +#ifdef HAVE_FFMPEG + if (settings->bools.menu_content_show_video) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_VIDEO; +#endif +#ifdef HAVE_NETWORKING + if (settings->bools.menu_content_show_netplay) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_NETPLAY; +#endif +#ifdef HAVE_LIBRETRODB + if (settings->bools.menu_content_show_add && !settings->bools.kiosk_mode_enable) + stripes->tabs[++stripes->system_tab_end] = STRIPES_SYSTEM_TAB_ADD; +#endif + + menu_driver_ctl(RARCH_MENU_CTL_UNSET_PREVENT_POPULATE, NULL); + + /* TODO/FIXME - we don't use framebuffer at all + * for XMB, we should refactor this dependency + * away. */ + + menu_display_set_width(width); + menu_display_set_height(height); + + menu_display_allocate_white_texture(); + + stripes->horizontal_list = (file_list_t*)calloc(1, sizeof(file_list_t)); + + if (stripes->horizontal_list) + stripes_init_horizontal_list(stripes); + + stripes_init_ribbon(stripes); + + return menu; + +error: + if (menu) + free(menu); + + if (stripes) + { + if (stripes->selection_buf_old) + free(stripes->selection_buf_old); + stripes->selection_buf_old = NULL; + if (stripes->horizontal_list) + { + stripes_free_list_nodes(stripes->horizontal_list, false); + file_list_free(stripes->horizontal_list); + } + stripes->horizontal_list = NULL; + } + return NULL; +} + +static void stripes_free(void *data) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (stripes) + { + if (stripes->selection_buf_old) + { + stripes_free_list_nodes(stripes->selection_buf_old, false); + file_list_free(stripes->selection_buf_old); + } + + if (stripes->horizontal_list) + { + stripes_free_list_nodes(stripes->horizontal_list, false); + file_list_free(stripes->horizontal_list); + } + + stripes->selection_buf_old = NULL; + stripes->horizontal_list = NULL; + + video_coord_array_free(&stripes->raster_block.carr); + video_coord_array_free(&stripes->raster_block2.carr); + + if (!string_is_empty(stripes->box_message)) + free(stripes->box_message); + if (!string_is_empty(stripes->thumbnail_system)) + free(stripes->thumbnail_system); + if (!string_is_empty(stripes->thumbnail_content)) + free(stripes->thumbnail_content); + if (!string_is_empty(stripes->savestate_thumbnail_file_path)) + free(stripes->savestate_thumbnail_file_path); + if (!string_is_empty(stripes->thumbnail_file_path)) + free(stripes->thumbnail_file_path); + if (!string_is_empty(stripes->left_thumbnail_file_path)) + free(stripes->left_thumbnail_file_path); + if (!string_is_empty(stripes->bg_file_path)) + free(stripes->bg_file_path); + } + + font_driver_bind_block(NULL, NULL); +} + +static void stripes_context_bg_destroy(stripes_handle_t *stripes) +{ + if (!stripes) + return; + video_driver_texture_unload(&stripes->textures.bg); + video_driver_texture_unload(&menu_display_white_texture); +} + +static bool stripes_load_image(void *userdata, void *data, enum menu_image_type type) +{ + stripes_handle_t *stripes = (stripes_handle_t*)userdata; + + if (!stripes || !data) + return false; + + switch (type) + { + case MENU_IMAGE_NONE: + break; + case MENU_IMAGE_WALLPAPER: + stripes_context_bg_destroy(stripes); + video_driver_texture_unload(&stripes->textures.bg); + video_driver_texture_load(data, + TEXTURE_FILTER_MIPMAP_LINEAR, + &stripes->textures.bg); + menu_display_allocate_white_texture(); + break; + case MENU_IMAGE_THUMBNAIL: + { + struct texture_image *img = (struct texture_image*)data; + stripes->thumbnail_height = stripes->thumbnail_width + * (float)img->height / (float)img->width; + video_driver_texture_unload(&stripes->thumbnail); + video_driver_texture_load(data, + TEXTURE_FILTER_MIPMAP_LINEAR, &stripes->thumbnail); + } + break; + case MENU_IMAGE_LEFT_THUMBNAIL: + { + struct texture_image *img = (struct texture_image*)data; + stripes->left_thumbnail_height = stripes->left_thumbnail_width + * (float)img->height / (float)img->width; + video_driver_texture_unload(&stripes->left_thumbnail); + video_driver_texture_load(data, + TEXTURE_FILTER_MIPMAP_LINEAR, &stripes->left_thumbnail); + } + break; + case MENU_IMAGE_SAVESTATE_THUMBNAIL: + { + struct texture_image *img = (struct texture_image*)data; + stripes->savestate_thumbnail_height = stripes->savestate_thumbnail_width + * (float)img->height / (float)img->width; + video_driver_texture_unload(&stripes->savestate_thumbnail); + video_driver_texture_load(data, + TEXTURE_FILTER_MIPMAP_LINEAR, &stripes->savestate_thumbnail); + } + break; + } + + return true; +} + +static const char *stripes_texture_path(unsigned id) +{ + switch (id) + { + case STRIPES_TEXTURE_MAIN_MENU: +#if defined(HAVE_LAKKA) + return "lakka.png"; +#else + return "retroarch.png"; +#endif + case STRIPES_TEXTURE_SETTINGS: + return "settings.png"; + case STRIPES_TEXTURE_HISTORY: + return "history.png"; + case STRIPES_TEXTURE_FAVORITES: + return "favorites.png"; + case STRIPES_TEXTURE_ADD_FAVORITE: + return "add-favorite.png"; + case STRIPES_TEXTURE_MUSICS: + return "musics.png"; +#ifdef HAVE_FFMPEG + case STRIPES_TEXTURE_MOVIES: + return "movies.png"; +#endif +#ifdef HAVE_IMAGEVIEWER + case STRIPES_TEXTURE_IMAGES: + return "images.png"; +#endif + case STRIPES_TEXTURE_SETTING: + return "setting.png"; + case STRIPES_TEXTURE_SUBSETTING: + return "subsetting.png"; + case STRIPES_TEXTURE_ARROW: + return "arrow.png"; + case STRIPES_TEXTURE_RUN: + return "run.png"; + case STRIPES_TEXTURE_CLOSE: + return "close.png"; + case STRIPES_TEXTURE_RESUME: + return "resume.png"; + case STRIPES_TEXTURE_CLOCK: + return "clock.png"; + case STRIPES_TEXTURE_BATTERY_FULL: + return "battery-full.png"; + case STRIPES_TEXTURE_BATTERY_CHARGING: + return "battery-charging.png"; + case STRIPES_TEXTURE_POINTER: + return "pointer.png"; + case STRIPES_TEXTURE_SAVESTATE: + return "savestate.png"; + case STRIPES_TEXTURE_LOADSTATE: + return "loadstate.png"; + case STRIPES_TEXTURE_UNDO: + return "undo.png"; + case STRIPES_TEXTURE_CORE_INFO: + return "core-infos.png"; + case STRIPES_TEXTURE_WIFI: + return "wifi.png"; + case STRIPES_TEXTURE_CORE_OPTIONS: + return "core-options.png"; + case STRIPES_TEXTURE_INPUT_REMAPPING_OPTIONS: + return "core-input-remapping-options.png"; + case STRIPES_TEXTURE_CHEAT_OPTIONS: + return "core-cheat-options.png"; + case STRIPES_TEXTURE_DISK_OPTIONS: + return "core-disk-options.png"; + case STRIPES_TEXTURE_SHADER_OPTIONS: + return "core-shader-options.png"; + case STRIPES_TEXTURE_ACHIEVEMENT_LIST: + return "achievement-list.png"; + case STRIPES_TEXTURE_SCREENSHOT: + return "screenshot.png"; + case STRIPES_TEXTURE_RELOAD: + return "reload.png"; + case STRIPES_TEXTURE_RENAME: + return "rename.png"; + case STRIPES_TEXTURE_FILE: + return "file.png"; + case STRIPES_TEXTURE_FOLDER: + return "folder.png"; + case STRIPES_TEXTURE_ZIP: + return "zip.png"; + case STRIPES_TEXTURE_MUSIC: + return "music.png"; + case STRIPES_TEXTURE_FAVORITE: + return "favorites-content.png"; + case STRIPES_TEXTURE_IMAGE: + return "image.png"; + case STRIPES_TEXTURE_MOVIE: + return "movie.png"; + case STRIPES_TEXTURE_CORE: + return "core.png"; + case STRIPES_TEXTURE_RDB: + return "database.png"; + case STRIPES_TEXTURE_CURSOR: + return "cursor.png"; + case STRIPES_TEXTURE_SWITCH_ON: + return "on.png"; + case STRIPES_TEXTURE_SWITCH_OFF: + return "off.png"; + case STRIPES_TEXTURE_ADD: + return "add.png"; +#ifdef HAVE_NETWORKING + case STRIPES_TEXTURE_NETPLAY: + return "netplay.png"; + case STRIPES_TEXTURE_ROOM: + return "room.png"; + /* stub these out until we have the icons + case STRIPES_TEXTURE_ROOM_LAN: + return "room_lan.png"; + case STRIPES_TEXTURE_ROOM_MITM: + return "room_mitm.png"; + */ +#endif + case STRIPES_TEXTURE_KEY: + return "key.png"; + case STRIPES_TEXTURE_KEY_HOVER: + return "key-hover.png"; + case STRIPES_TEXTURE_DIALOG_SLICE: + return "dialog-slice.png"; + + } + + return NULL; +} + +static void stripes_context_reset_textures( + stripes_handle_t *stripes, const char *iconpath) +{ + unsigned i; + + for (i = 0; i < STRIPES_TEXTURE_LAST; i++) + menu_display_reset_textures_list(stripes_texture_path(i), iconpath, &stripes->textures.list[i], TEXTURE_FILTER_MIPMAP_LINEAR); + + menu_display_allocate_white_texture(); + + stripes->main_menu_node.icon = stripes->textures.list[STRIPES_TEXTURE_MAIN_MENU]; + stripes->main_menu_node.alpha = stripes->categories_active_alpha; + stripes->main_menu_node.zoom = stripes->categories_active_zoom; + + stripes->settings_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_SETTINGS]; + stripes->settings_tab_node.alpha = stripes->categories_active_alpha; + stripes->settings_tab_node.zoom = stripes->categories_active_zoom; + + stripes->history_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_HISTORY]; + stripes->history_tab_node.alpha = stripes->categories_active_alpha; + stripes->history_tab_node.zoom = stripes->categories_active_zoom; + + stripes->favorites_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_FAVORITES]; + stripes->favorites_tab_node.alpha = stripes->categories_active_alpha; + stripes->favorites_tab_node.zoom = stripes->categories_active_zoom; + + stripes->music_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_MUSICS]; + stripes->music_tab_node.alpha = stripes->categories_active_alpha; + stripes->music_tab_node.zoom = stripes->categories_active_zoom; + +#ifdef HAVE_FFMPEG + stripes->video_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_MOVIES]; + stripes->video_tab_node.alpha = stripes->categories_active_alpha; + stripes->video_tab_node.zoom = stripes->categories_active_zoom; +#endif + +#ifdef HAVE_IMAGEVIEWER + stripes->images_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_IMAGES]; + stripes->images_tab_node.alpha = stripes->categories_active_alpha; + stripes->images_tab_node.zoom = stripes->categories_active_zoom; +#endif + + stripes->add_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_ADD]; + stripes->add_tab_node.alpha = stripes->categories_active_alpha; + stripes->add_tab_node.zoom = stripes->categories_active_zoom; + +#ifdef HAVE_NETWORKING + stripes->netplay_tab_node.icon = stripes->textures.list[STRIPES_TEXTURE_NETPLAY]; + stripes->netplay_tab_node.alpha = stripes->categories_active_alpha; + stripes->netplay_tab_node.zoom = stripes->categories_active_zoom; +#endif +} + +static void stripes_context_reset_background(const char *iconpath) +{ + char *path = NULL; + settings_t *settings = config_get_ptr(); + const char *path_menu_wp = settings->paths.path_menu_wallpaper; + + if (!string_is_empty(path_menu_wp)) + path = strdup(path_menu_wp); + else if (!string_is_empty(iconpath)) + { + path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); + path[0] = '\0'; + + fill_pathname_join(path, iconpath, "bg.png", + PATH_MAX_LENGTH * sizeof(char)); + } + + if (filestream_exists(path)) + task_push_image_load(path, + menu_display_handle_wallpaper_upload, NULL); + + if (path) + free(path); +} + +static void stripes_context_reset(void *data, bool is_threaded) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (stripes) + { + char bg_file_path[PATH_MAX_LENGTH] = {0}; + char *iconpath = (char*)malloc(PATH_MAX_LENGTH * sizeof(char)); + iconpath[0] = '\0'; + + fill_pathname_application_special(bg_file_path, + sizeof(bg_file_path), APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_BG); + + if (!string_is_empty(bg_file_path)) + { + if (!string_is_empty(stripes->bg_file_path)) + free(stripes->bg_file_path); + stripes->bg_file_path = strdup(bg_file_path); + } + + fill_pathname_application_special(iconpath, + PATH_MAX_LENGTH * sizeof(char), + APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_ICONS); + + stripes_layout(stripes); + stripes->font = menu_display_font(APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_FONT, + stripes->font_size, + is_threaded); + stripes->font2 = menu_display_font(APPLICATION_SPECIAL_DIRECTORY_ASSETS_XMB_FONT, + stripes->font2_size, + is_threaded); + stripes_context_reset_textures(stripes, iconpath); + stripes_context_reset_background(iconpath); + stripes_context_reset_horizontal_list(stripes); + + if (!string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + stripes_update_thumbnail_image(stripes); + if (!string_is_equal(stripes_thumbnails_ident('R'), + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OFF))) + stripes_update_thumbnail_image(stripes); + stripes_update_savestate_thumbnail_image(stripes); + + free(iconpath); + } +} + +static void stripes_navigation_clear(void *data, bool pending_push) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + if (!pending_push) + stripes_selection_pointer_changed(stripes, true); +} + +static void stripes_navigation_pointer_changed(void *data) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + stripes_selection_pointer_changed(stripes, true); +} + +static void stripes_navigation_set(void *data, bool scroll) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + stripes_selection_pointer_changed(stripes, true); +} + +static void stripes_navigation_alphabet(void *data, size_t *unused) +{ + stripes_handle_t *stripes = (stripes_handle_t*)data; + stripes_selection_pointer_changed(stripes, true); +} + +static void stripes_list_insert(void *userdata, + file_list_t *list, + const char *path, + const char *fullpath, + const char *unused, + size_t list_size, + unsigned entry_type) +{ + int current = 0; + int i = (int)list_size; + stripes_node_t *node = NULL; + stripes_handle_t *stripes = (stripes_handle_t*)userdata; + size_t selection = menu_navigation_get_selection(); + + if (!stripes || !list) + return; + + node = (stripes_node_t*)file_list_get_userdata_at_offset(list, i); + + if (!node) + node = stripes_alloc_node(); + + if (!node) + { + RARCH_ERR("XMB node could not be allocated.\n"); + return; + } + + current = (int)selection; + + if (!string_is_empty(fullpath)) + { + if (node->fullpath) + free(node->fullpath); + + node->fullpath = strdup(fullpath); + } + + node->alpha = stripes->items_passive_alpha; + node->zoom = stripes->items_passive_zoom; + node->label_alpha = node->alpha; + node->y = stripes_item_y(stripes, i, current); + node->x = 0; + + if (i == current) + { + node->alpha = stripes->items_active_alpha; + node->label_alpha = stripes->items_active_alpha; + node->zoom = stripes->items_active_alpha; + } + + file_list_set_userdata(list, i, node); +} + +static void stripes_list_clear(file_list_t *list) +{ + menu_animation_ctx_tag tag = (uintptr_t)list; + + menu_animation_ctl(MENU_ANIMATION_CTL_KILL_BY_TAG, &tag); + + stripes_free_list_nodes(list, false); +} + +static void stripes_list_free(file_list_t *list, size_t a, size_t b) +{ + stripes_list_clear(list); +} + +static void stripes_list_deep_copy(const file_list_t *src, file_list_t *dst, + size_t first, size_t last) +{ + size_t i, j = 0; + menu_animation_ctx_tag tag = (uintptr_t)dst; + + menu_animation_ctl(MENU_ANIMATION_CTL_KILL_BY_TAG, &tag); + + /* use true here because file_list_copy() doesn't free actiondata */ + stripes_free_list_nodes(dst, true); + + file_list_clear(dst); + file_list_reserve(dst, (last + 1) - first); + + for (i = first; i <= last; ++i) + { + struct item_file *d = &dst->list[j]; + struct item_file *s = &src->list[i]; + + void *src_udata = s->userdata; + void *src_adata = s->actiondata; + + *d = *s; + d->alt = string_is_empty(d->alt) ? NULL : strdup(d->alt); + d->path = string_is_empty(d->path) ? NULL : strdup(d->path); + d->label = string_is_empty(d->label) ? NULL : strdup(d->label); + + if (src_udata) + file_list_set_userdata(dst, j, (void*)stripes_copy_node((const stripes_node_t*)src_udata)); + + if (src_adata) + { + void *data = malloc(sizeof(menu_file_list_cbs_t)); + memcpy(data, src_adata, sizeof(menu_file_list_cbs_t)); + file_list_set_actiondata(dst, j, data); + } + + ++j; + } + + dst->size = j; +} + +static void stripes_list_cache(void *data, enum menu_list_type type, unsigned action) +{ + size_t stack_size, list_size; + stripes_handle_t *stripes = (stripes_handle_t*)data; + file_list_t *menu_stack = menu_entries_get_menu_stack_ptr(0); + file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0); + size_t selection = menu_navigation_get_selection(); + settings_t *settings = config_get_ptr(); + + if (!stripes) + return; + + /* Check whether to enable the horizontal animation. */ + if (settings->bools.menu_horizontal_animation) + { + unsigned first = 0, last = 0; + unsigned height = 0; + video_driver_get_size(NULL, &height); + + /* FIXME: this shouldn't be happening at all */ + if (selection >= selection_buf->size) + selection = selection_buf->size ? selection_buf->size - 1 : 0; + + stripes->selection_ptr_old = selection; + + stripes_calculate_visible_range(stripes, height, selection_buf->size, + stripes->selection_ptr_old, &first, &last); + + stripes_list_deep_copy(selection_buf, stripes->selection_buf_old, first, last); + + stripes->selection_ptr_old -= first; + last -= first; + first = 0; + } + else + stripes->selection_ptr_old = 0; + + list_size = stripes_list_get_size(stripes, MENU_LIST_HORIZONTAL) + + stripes->system_tab_end; + + switch (type) + { + case MENU_LIST_PLAIN: + break; + case MENU_LIST_HORIZONTAL: + stripes->categories_selection_ptr_old = stripes->categories_selection_ptr; + + switch (action) + { + case MENU_ACTION_LEFT: + if (stripes->categories_selection_ptr == 0) + { + stripes->categories_selection_ptr = list_size; + stripes->categories_active_idx = (unsigned)(list_size - 1); + } + else + stripes->categories_selection_ptr--; + break; + default: + if (stripes->categories_selection_ptr == list_size) + { + stripes->categories_selection_ptr = 0; + stripes->categories_active_idx = 1; + } + else + stripes->categories_selection_ptr++; + break; + } + + stack_size = menu_stack->size; + + if (menu_stack->list[stack_size - 1].label) + free(menu_stack->list[stack_size - 1].label); + menu_stack->list[stack_size - 1].label = NULL; + + switch (stripes_get_system_tab(stripes, (unsigned)stripes->categories_selection_ptr)) + { + case STRIPES_SYSTEM_TAB_MAIN: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU)); + menu_stack->list[stack_size - 1].type = + MENU_SETTINGS; + break; + case STRIPES_SYSTEM_TAB_SETTINGS: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_SETTINGS_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_SETTINGS_TAB; + break; +#ifdef HAVE_IMAGEVIEWER + case STRIPES_SYSTEM_TAB_IMAGES: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_IMAGES_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_IMAGES_TAB; + break; +#endif + case STRIPES_SYSTEM_TAB_MUSIC: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_MUSIC_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_MUSIC_TAB; + break; +#ifdef HAVE_FFMPEG + case STRIPES_SYSTEM_TAB_VIDEO: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_VIDEO_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_VIDEO_TAB; + break; +#endif + case STRIPES_SYSTEM_TAB_HISTORY: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_HISTORY_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_HISTORY_TAB; + break; + case STRIPES_SYSTEM_TAB_FAVORITES: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_FAVORITES_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_FAVORITES_TAB; + break; +#ifdef HAVE_NETWORKING + case STRIPES_SYSTEM_TAB_NETPLAY: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_NETPLAY_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_NETPLAY_TAB; + break; +#endif + case STRIPES_SYSTEM_TAB_ADD: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_ADD_TAB)); + menu_stack->list[stack_size - 1].type = + MENU_ADD_TAB; + break; + default: + menu_stack->list[stack_size - 1].label = + strdup(msg_hash_to_str(MENU_ENUM_LABEL_HORIZONTAL_MENU)); + menu_stack->list[stack_size - 1].type = + MENU_SETTING_HORIZONTAL_MENU; + break; + } + break; + default: + break; + } +} + + +static void stripes_context_destroy(void *data) +{ + unsigned i; + stripes_handle_t *stripes = (stripes_handle_t*)data; + + if (!stripes) + return; + + for (i = 0; i < STRIPES_TEXTURE_LAST; i++) + video_driver_texture_unload(&stripes->textures.list[i]); + + video_driver_texture_unload(&stripes->thumbnail); + video_driver_texture_unload(&stripes->left_thumbnail); + video_driver_texture_unload(&stripes->savestate_thumbnail); + + stripes_context_destroy_horizontal_list(stripes); + stripes_context_bg_destroy(stripes); + + menu_display_font_free(stripes->font); + menu_display_font_free(stripes->font2); + + stripes->font = NULL; + stripes->font2 = NULL; +} + +static void stripes_toggle(void *userdata, bool menu_on) +{ + menu_animation_ctx_entry_t entry; + bool tmp = false; + stripes_handle_t *stripes = (stripes_handle_t*)userdata; + + if (!stripes) + return; + + stripes->depth = (int)stripes_list_get_size(stripes, MENU_LIST_PLAIN); + + if (!menu_on) + { + stripes->alpha = 0; + return; + } + + entry.duration = STRIPES_DELAY * 2; + entry.target_value = 1.0f; + entry.subject = &stripes->alpha; + entry.easing_enum = EASING_OUT_QUAD; + /* TODO/FIXME - integer conversion resulted in change of sign */ + entry.tag = -1; + entry.cb = NULL; + + menu_animation_push(&entry); + + tmp = !menu_entries_ctl(MENU_ENTRIES_CTL_NEEDS_REFRESH, NULL); + + if (tmp) + menu_driver_ctl(RARCH_MENU_CTL_SET_PREVENT_POPULATE, NULL); + else + menu_driver_ctl(RARCH_MENU_CTL_UNSET_PREVENT_POPULATE, NULL); + + stripes_toggle_horizontal_list(stripes); +} + +static int stripes_deferred_push_content_actions(menu_displaylist_info_t *info) +{ + if (!menu_displaylist_ctl( + DISPLAYLIST_HORIZONTAL_CONTENT_ACTIONS, info)) + return -1; + menu_displaylist_process(info); + menu_displaylist_info_free(info); + return 0; +} + +static int stripes_list_bind_init_compare_label(menu_file_list_cbs_t *cbs) +{ + if (cbs && cbs->enum_idx != MSG_UNKNOWN) + { + switch (cbs->enum_idx) + { + case MENU_ENUM_LABEL_CONTENT_ACTIONS: + cbs->action_deferred_push = stripes_deferred_push_content_actions; + break; + default: + return -1; + } + } + + return 0; +} + +static int stripes_list_bind_init(menu_file_list_cbs_t *cbs, + const char *path, const char *label, unsigned type, size_t idx) +{ + if (stripes_list_bind_init_compare_label(cbs) == 0) + return 0; + + return -1; +} + +static int stripes_list_push(void *data, void *userdata, + menu_displaylist_info_t *info, unsigned type) +{ + menu_displaylist_ctx_parse_entry_t entry; + int ret = -1; + int i = 0; + core_info_list_t *list = NULL; + menu_handle_t *menu = (menu_handle_t*)data; + + switch (type) + { + case DISPLAYLIST_LOAD_CONTENT_LIST: + { + settings_t *settings = config_get_ptr(); + + menu_entries_ctl(MENU_ENTRIES_CTL_CLEAR, info->list); + + menu_entries_append_enum(info->list, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_FAVORITES), + msg_hash_to_str(MENU_ENUM_LABEL_FAVORITES), + MENU_ENUM_LABEL_FAVORITES, + MENU_SETTING_ACTION, 0, 0); + + core_info_get_list(&list); + if (core_info_list_num_info_files(list)) + { + menu_entries_append_enum(info->list, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_DOWNLOADED_FILE_DETECT_CORE_LIST), + msg_hash_to_str(MENU_ENUM_LABEL_DOWNLOADED_FILE_DETECT_CORE_LIST), + MENU_ENUM_LABEL_DOWNLOADED_FILE_DETECT_CORE_LIST, + MENU_SETTING_ACTION, 0, 0); + } + +#ifdef HAVE_LIBRETRODB + menu_entries_append_enum(info->list, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_CONTENT_COLLECTION_LIST), + msg_hash_to_str(MENU_ENUM_LABEL_CONTENT_COLLECTION_LIST), + MENU_ENUM_LABEL_CONTENT_COLLECTION_LIST, + MENU_SETTING_ACTION, 0, 0); +#endif + + if (frontend_driver_parse_drive_list(info->list, true) != 0) + menu_entries_append_enum(info->list, "/", + msg_hash_to_str(MENU_ENUM_LABEL_FILE_DETECT_CORE_LIST_PUSH_DIR), + MENU_ENUM_LABEL_FILE_DETECT_CORE_LIST_PUSH_DIR, + MENU_SETTING_ACTION, 0, 0); + + if (!settings->bools.kiosk_mode_enable) + { + menu_entries_append_enum(info->list, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_MENU_FILE_BROWSER_SETTINGS), + msg_hash_to_str(MENU_ENUM_LABEL_MENU_FILE_BROWSER_SETTINGS), + MENU_ENUM_LABEL_MENU_FILE_BROWSER_SETTINGS, + MENU_SETTING_ACTION, 0, 0); + } + + info->need_push = true; + info->need_refresh = true; + ret = 0; + } + break; + case DISPLAYLIST_MAIN_MENU: + { + settings_t *settings = config_get_ptr(); + rarch_system_info_t *system = runloop_get_system_info(); + menu_entries_ctl(MENU_ENTRIES_CTL_CLEAR, info->list); + + entry.data = menu; + entry.info = info; + entry.parse_type = PARSE_ACTION; + entry.add_empty_entry = false; + + if (!string_is_empty(system->info.library_name) && + !string_is_equal(system->info.library_name, + msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_CORE))) + { + entry.enum_idx = MENU_ENUM_LABEL_CONTENT_SETTINGS; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + + if (system->load_no_content) + { + entry.enum_idx = MENU_ENUM_LABEL_START_CORE; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + +#ifndef HAVE_DYNAMIC + if (frontend_driver_has_fork()) +#endif + { + if (settings->bools.menu_show_load_core) + { + entry.enum_idx = MENU_ENUM_LABEL_CORE_LIST; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + } + + if (settings->bools.menu_show_load_content) + { + const struct retro_subsystem_info* subsystem = NULL; + + entry.enum_idx = MENU_ENUM_LABEL_LOAD_CONTENT_LIST; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + + subsystem = system->subsystem.data; + + if (subsystem) + { + for (i = 0; i < system->subsystem.size; i++, subsystem++) + { + char s[PATH_MAX_LENGTH]; + if (content_get_subsystem() == i) + { + if (content_get_subsystem_rom_id() < subsystem->num_roms) + { + snprintf(s, sizeof(s), + "Load %s %s", + subsystem->desc, + i == content_get_subsystem() + ? "\u2605" : " "); + menu_entries_append_enum(info->list, + s, + msg_hash_to_str(MENU_ENUM_LABEL_SUBSYSTEM_ADD), + MENU_ENUM_LABEL_SUBSYSTEM_ADD, + MENU_SETTINGS_SUBSYSTEM_ADD + i, 0, 0); + } + else + { + snprintf(s, sizeof(s), + "Start %s %s", + subsystem->desc, + i == content_get_subsystem() + ? "\u2605" : " "); + menu_entries_append_enum(info->list, + s, + msg_hash_to_str(MENU_ENUM_LABEL_SUBSYSTEM_LOAD), + MENU_ENUM_LABEL_SUBSYSTEM_LOAD, + MENU_SETTINGS_SUBSYSTEM_LOAD, 0, 0); + } + } + else + { + snprintf(s, sizeof(s), + "Load %s %s", + subsystem->desc, + i == content_get_subsystem() + ? "\u2605" : " "); + menu_entries_append_enum(info->list, + s, + msg_hash_to_str(MENU_ENUM_LABEL_SUBSYSTEM_ADD), + MENU_ENUM_LABEL_SUBSYSTEM_ADD, + MENU_SETTINGS_SUBSYSTEM_ADD + i, 0, 0); + } + } + } + } + + entry.enum_idx = MENU_ENUM_LABEL_ADD_CONTENT_LIST; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); +#if defined(HAVE_NETWORKING) + { + settings_t *settings = config_get_ptr(); + if (settings->bools.menu_show_online_updater && !settings->bools.kiosk_mode_enable) + { + entry.enum_idx = MENU_ENUM_LABEL_ONLINE_UPDATER; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + } +#endif + if (!settings->bools.menu_content_show_settings && !string_is_empty(settings->paths.menu_content_show_settings_password)) + { + entry.enum_idx = MENU_ENUM_LABEL_XMB_MAIN_MENU_ENABLE_SETTINGS; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + + if (settings->bools.kiosk_mode_enable && !string_is_empty(settings->paths.kiosk_mode_password)) + { + entry.enum_idx = MENU_ENUM_LABEL_MENU_DISABLE_KIOSK_MODE; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + + if (settings->bools.menu_show_information) + { + entry.enum_idx = MENU_ENUM_LABEL_INFORMATION_LIST; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + +#ifndef HAVE_DYNAMIC + entry.enum_idx = MENU_ENUM_LABEL_RESTART_RETROARCH; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); +#endif + + if (settings->bools.menu_show_configurations && !settings->bools.kiosk_mode_enable) + { + entry.enum_idx = MENU_ENUM_LABEL_CONFIGURATIONS_LIST; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + + if (settings->bools.menu_show_help) + { + entry.enum_idx = MENU_ENUM_LABEL_HELP_LIST; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + +#if !defined(IOS) + if (settings->bools.menu_show_quit_retroarch) + { + entry.enum_idx = MENU_ENUM_LABEL_QUIT_RETROARCH; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } +#endif + + if (settings->bools.menu_show_reboot) + { + entry.enum_idx = MENU_ENUM_LABEL_REBOOT; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + } + + entry.enum_idx = MENU_ENUM_LABEL_SHUTDOWN; + menu_displaylist_ctl(DISPLAYLIST_SETTING_ENUM, &entry); + info->need_push = true; + ret = 0; + } + break; + } + return ret; +} + +static bool stripes_menu_init_list(void *data) +{ + menu_displaylist_info_t info; + + file_list_t *menu_stack = menu_entries_get_menu_stack_ptr(0); + file_list_t *selection_buf = menu_entries_get_selection_buf_ptr(0); + + menu_displaylist_info_init(&info); + + info.label = strdup( + msg_hash_to_str(MENU_ENUM_LABEL_MAIN_MENU)); + info.exts = + strdup(file_path_str(FILE_PATH_LPL_EXTENSION_NO_DOT)); + info.type_default = FILE_TYPE_PLAIN; + info.enum_idx = MENU_ENUM_LABEL_MAIN_MENU; + + menu_entries_append_enum(menu_stack, info.path, + info.label, + MENU_ENUM_LABEL_MAIN_MENU, + info.type, info.flags, 0); + + info.list = selection_buf; + + if (!menu_displaylist_ctl(DISPLAYLIST_MAIN_MENU, &info)) + goto error; + + info.need_push = true; + + if (!menu_displaylist_process(&info)) + goto error; + + menu_displaylist_info_free(&info); + return true; + +error: + menu_displaylist_info_free(&info); + return false; +} + +static int stripes_pointer_tap(void *userdata, + unsigned x, unsigned y, unsigned ptr, + menu_file_list_cbs_t *cbs, + menu_entry_t *entry, unsigned action) +{ + unsigned header_height = menu_display_get_header_height(); + + if (y < header_height) + { + size_t selection = menu_navigation_get_selection(); + return (unsigned)menu_entry_action(entry, (unsigned)selection, MENU_ACTION_CANCEL); + } + else if (ptr <= (menu_entries_get_size() - 1)) + { + size_t selection = menu_navigation_get_selection(); + if (ptr == selection && cbs && cbs->action_select) + return (unsigned)menu_entry_action(entry, (unsigned)selection, MENU_ACTION_SELECT); + + menu_navigation_set_selection(ptr); + menu_driver_navigation_set(false); + } + + return 0; +} + +menu_ctx_driver_t menu_ctx_stripes = { + NULL, + stripes_messagebox, + generic_menu_iterate, + stripes_render, + stripes_frame, + stripes_init, + stripes_free, + stripes_context_reset, + stripes_context_destroy, + stripes_populate_entries, + stripes_toggle, + stripes_navigation_clear, + stripes_navigation_pointer_changed, + stripes_navigation_pointer_changed, + stripes_navigation_set, + stripes_navigation_pointer_changed, + stripes_navigation_alphabet, + stripes_navigation_alphabet, + stripes_menu_init_list, + stripes_list_insert, + NULL, + stripes_list_free, + stripes_list_clear, + stripes_list_cache, + stripes_list_push, + stripes_list_get_selection, + stripes_list_get_size, + stripes_list_get_entry, + NULL, + stripes_list_bind_init, + stripes_load_image, + "stripes", + stripes_environ, + stripes_pointer_tap, + stripes_update_thumbnail_path, + stripes_update_thumbnail_image, + stripes_set_thumbnail_system, + stripes_set_thumbnail_content, + stripes_osk_ptr_at_pos, + stripes_update_savestate_thumbnail_path, + stripes_update_savestate_thumbnail_image +}; diff --git a/menu/menu_driver.c b/menu/menu_driver.c index dde5ee212b..0912114c17 100644 --- a/menu/menu_driver.c +++ b/menu/menu_driver.c @@ -81,6 +81,9 @@ static const menu_ctx_driver_t *menu_ctx_drivers[] = { #if defined(HAVE_XMB) &menu_ctx_xmb, #endif +#if defined(HAVE_STRIPES) + &menu_ctx_stripes, +#endif #if defined(HAVE_RGUI) &menu_ctx_rgui, #endif diff --git a/menu/menu_driver.h b/menu/menu_driver.h index b61131a33d..d36214da0a 100644 --- a/menu/menu_driver.h +++ b/menu/menu_driver.h @@ -771,6 +771,7 @@ extern menu_ctx_driver_t menu_ctx_rgui; extern menu_ctx_driver_t menu_ctx_mui; extern menu_ctx_driver_t menu_ctx_nuklear; extern menu_ctx_driver_t menu_ctx_xmb; +extern menu_ctx_driver_t menu_ctx_stripes; extern menu_ctx_driver_t menu_ctx_zarch; extern menu_ctx_driver_t menu_ctx_null; diff --git a/pkg/apple/RetroArch.xcodeproj/project.pbxproj b/pkg/apple/RetroArch.xcodeproj/project.pbxproj index 3b4f0dd4be..6c0637f444 100644 --- a/pkg/apple/RetroArch.xcodeproj/project.pbxproj +++ b/pkg/apple/RetroArch.xcodeproj/project.pbxproj @@ -539,7 +539,7 @@ "-DHAVE_MATERIALUI", "-DHAVE_HID", "-DHAVE_XMB", - "-DHAVE_SEGA", + "-DHAVE_STRIPES", "-DHAVE_SHADERPIPELINE", "-DHAVE_MMAP", "-DHAVE_LIBRETRODB", @@ -600,7 +600,7 @@ "-DHAVE_MATERIALUI", "-DHAVE_HID", "-DHAVE_XMB", - "-DHAVE_SEGA", + "-DHAVE_STRIPES", "-DHAVE_SHADERPIPELINE", "-DHAVE_MMAP", "-DHAVE_LIBRETRODB", diff --git a/qb/config.libs.sh b/qb/config.libs.sh index e0c3382d5b..d5894d2fc6 100644 --- a/qb/config.libs.sh +++ b/qb/config.libs.sh @@ -477,6 +477,7 @@ if [ "$HAVE_MATERIALUI" != 'no' ] || [ "$HAVE_XMB" != 'no' ] || [ "$HAVE_ZARCH" if [ "$HAVE_RGUI" = 'no' ]; then HAVE_MATERIALUI=no HAVE_XMB=no + HAVE_STRIPES=no HAVE_ZARCH=no die : 'Notice: RGUI not available, MaterialUI, XMB and ZARCH will also be disabled.' elif [ "$HAVE_OPENGL" = 'no' ] && [ "$HAVE_OPENGLES" = 'no' ] && [ "$HAVE_VULKAN" = 'no' ]; then @@ -489,6 +490,7 @@ if [ "$HAVE_MATERIALUI" != 'no' ] || [ "$HAVE_XMB" != 'no' ] || [ "$HAVE_ZARCH" else HAVE_MATERIALUI=no HAVE_XMB=no + HAVE_STRIPES=no HAVE_ZARCH=no die : 'Notice: Hardware rendering context not available, XMB, MaterialUI and ZARCH will also be disabled.' fi diff --git a/qb/config.params.sh b/qb/config.params.sh index 94135f94f6..6c120234b5 100644 --- a/qb/config.params.sh +++ b/qb/config.params.sh @@ -9,6 +9,7 @@ HAVE_LIBRETRODB=yes # Libretrodb support HAVE_RGUI=yes # RGUI menu HAVE_MATERIALUI=auto # MaterialUI menu HAVE_XMB=auto # XMB menu +HAVE_STRIPES=auto # Stripes menu HAVE_ZARCH=no # Zarch menu HAVE_NUKLEAR=no # Nuklear menu HAVE_RUNAHEAD=yes # Runahead support