/* VitaShell Copyright (C) 2015-2018, TheFloW This program 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 Foundation, either version 3 of the License, or (at your option) any later version. This program 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 this program. If not, see . */ #include "main.h" #include "config.h" #include "init.h" #include "theme.h" #include "language.h" #include "settings.h" #include "message_dialog.h" #include "ime_dialog.h" #include "utils.h" #include "network_update.h" static void restartShell(); static void rebootDevice(); static void shutdownDevice(); static void suspendDevice(); static void showBatteryInfo(); static int changed = 0; static int theme = 0; int qr_used = 0; // QR functionality always available - no usage restrictions static volatile int auto_close_timer = 0; static void checkUpdates() { // Close menu immediately closeSettingsMenu(); // Start network update thread (it handles all UI internally) // This reuses the existing auto-update logic which works reliably SceUID thid = sceKernelCreateThread("network_update", (SceKernelThreadEntry)network_update_thread, 0x10000100, 0x10000, 0, 0, NULL); if (thid >= 0) sceKernelStartThread(thid, 0, NULL); // Let the thread handle everything - no custom dialogs to avoid conflicts } static char spoofed_version[6]; static SettingsMenuEntry *settings_menu_entries = NULL; static int n_settings_entries = 0; static char *usbdevice_options[4]; static char *select_button_options[3]; static char *focus_color_options_texts[8]; static char *font_size_options[3]; static char **theme_options = NULL; static int theme_count = 0; static char *theme_name = NULL; static int language_changed = 0; // Flag to track language changes static char *language_options[19]; // Complete language options array static char *repeat_options[4]; // audio repeat options static ConfigEntry settings_entries[] = { { "LANGUAGE", CONFIG_TYPE_DECIMAL, (int *)&language }, { "USBDEVICE", CONFIG_TYPE_DECIMAL, (int *)&vitashell_config.usbdevice }, { "SELECT_BUTTON", CONFIG_TYPE_DECIMAL, (int *)&vitashell_config.select_button }, { "DISABLE_AUTOUPDATE", CONFIG_TYPE_BOOLEAN, (int *)&vitashell_config.disable_autoupdate }, { "DISABLE_WARNING", CONFIG_TYPE_BOOLEAN, (int *)&vitashell_config.disable_warning }, { "DISABLE_LOW_BATTERY_WARNING", CONFIG_TYPE_BOOLEAN, (int *)&vitashell_config.disable_low_battery_warning }, { "AUDIO_REPEAT", CONFIG_TYPE_DECIMAL, (int *)&vitashell_config.audio_repeat }, { "FOCUS_COLOR", CONFIG_TYPE_DECIMAL, (int *)&vitashell_config.focus_color }, { "FONT_SIZE", CONFIG_TYPE_DECIMAL, (int *)&vitashell_config.font_size }, { "ENABLE_TOUCH", CONFIG_TYPE_BOOLEAN, (int *)&vitashell_config.enable_touch }, }; static ConfigEntry theme_entries[] = { { "THEME_NAME", CONFIG_TYPE_STRING, (void *)&theme_name }, }; SettingsMenuOption main_settings[] = { // { VITASHELL_SETTINGS_LANGUAGE, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, // language_options, sizeof(language_options) / sizeof(char *), &language }, { VITASHELL_SETTINGS_THEME, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, NULL, 0, NULL }, { VITASHELL_SETTINGS_FONT_SIZE, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, font_size_options, 3, &vitashell_config.font_size }, { VITASHELL_SETTINGS_USBDEVICE, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, usbdevice_options, sizeof(usbdevice_options) / sizeof(char **), &vitashell_config.usbdevice }, { VITASHELL_SETTINGS_SELECT_BUTTON, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, select_button_options, sizeof(select_button_options) / sizeof(char **), &vitashell_config.select_button }, { VITASHELL_SETTINGS_FOCUS_COLOR, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, focus_color_options_texts, 8, &vitashell_config.focus_color }, // 8 colors { VITASHELL_SETTINGS_ENABLE_TOUCH, SETTINGS_OPTION_TYPE_BOOLEAN, NULL, NULL, 0, NULL, 0, &vitashell_config.enable_touch }, { VITASHELL_SETTINGS_NO_AUTO_UPDATE, SETTINGS_OPTION_TYPE_BOOLEAN, NULL, NULL, 0, NULL, 0, &vitashell_config.disable_autoupdate }, { VITASHELL_SETTINGS_WARNING_MESSAGE, SETTINGS_OPTION_TYPE_BOOLEAN, NULL, NULL, 0, NULL, 0, &vitashell_config.disable_warning }, { VITASHELL_SETTINGS_LOW_BATTERY_WARNING, SETTINGS_OPTION_TYPE_BOOLEAN, NULL, NULL, 0, NULL, 0, &vitashell_config.disable_low_battery_warning }, { VITASHELL_SETTINGS_AUDIO_REPEAT, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, repeat_options, 4, &vitashell_config.audio_repeat }, { VITASHELL_SETTINGS_BATTERY_INFO, SETTINGS_OPTION_TYPE_CALLBACK, (void *)showBatteryInfo, NULL, 0, NULL, 0, NULL }, { VITASHELL_SETTINGS_CHECK_UPDATES, SETTINGS_OPTION_TYPE_CALLBACK, (void *)checkUpdates, NULL, 0, NULL, 0, NULL }, { VITASHELL_SETTINGS_RESTART_SHELL, SETTINGS_OPTION_TYPE_CALLBACK, (void *)restartShell, NULL, 0, NULL, 0, NULL }, }; SettingsMenuOption power_settings[] = { { VITASHELL_SETTINGS_REBOOT, SETTINGS_OPTION_TYPE_CALLBACK, (void *)rebootDevice, NULL, 0, NULL, 0, NULL }, { VITASHELL_SETTINGS_POWEROFF, SETTINGS_OPTION_TYPE_CALLBACK, (void *)shutdownDevice, NULL, 0, NULL, 0, NULL }, { VITASHELL_SETTINGS_STANDBY, SETTINGS_OPTION_TYPE_CALLBACK, (void *)suspendDevice, NULL, 0, NULL, 0, NULL }, }; SettingsMenuOption language_settings[] = { { VITASHELL_SETTINGS_LANGUAGE, SETTINGS_OPTION_TYPE_OPTIONS, NULL, NULL, 0, language_options, 12, &language }, // Only 12 languages actually set }; SettingsMenuEntry vitashell_settings_menu_entries[] = { { VITASHELL_SETTINGS_MAIN, main_settings, sizeof(main_settings) / sizeof(SettingsMenuOption) }, { VITASHELL_SETTINGS_LANGUAGE, language_settings, sizeof(language_settings) / sizeof(SettingsMenuOption) }, { VITASHELL_SETTINGS_POWER, power_settings, sizeof(power_settings) / sizeof(SettingsMenuOption) }, }; static SettingsMenu settings_menu; // Scrolling support for settings menu #define MAX_VISIBLE_OPTIONS 14 // Maximum options visible on screen static int settings_scroll_pos = 0; // Current scroll position void loadSettingsConfig() { // Load settings config file memset(&vitashell_config, 0, sizeof(VitaShellConfig)); // Disable automatic updates by default (disable_autoupdate = 1) vitashell_config.disable_autoupdate = 1; // Set default font size to Normal (1) vitashell_config.font_size = 1; // Enable touch by default (enable_touch = 1) vitashell_config.enable_touch = 1; readConfig("ux0:VitaShell/settings.txt", settings_entries, sizeof(settings_entries) / sizeof(ConfigEntry)); // Set current font size based on config if (vitashell_config.font_size == 0) current_font_size = 0.75f; // Small else if (vitashell_config.font_size == 1) current_font_size = 1.0f; // Normal else if (vitashell_config.font_size == 2) current_font_size = 1.25f; // Large else current_font_size = 1.0f; // Default to normal } void saveSettingsConfig() { // Save settings config file writeConfig("ux0:VitaShell/settings.txt", settings_entries, sizeof(settings_entries) / sizeof(ConfigEntry)); if (sceKernelGetModel() == SCE_KERNEL_MODEL_VITATV) { vitashell_config.select_button = SELECT_BUTTON_MODE_FTP; } } static void restartShell() { closeSettingsMenu(); sceAppMgrLoadExec("app0:eboot.bin", NULL, NULL); } static void showBatteryInfo() { int percent = -1; int exists = 0; int charging = 0; percent = scePowerGetBatteryLifePercent(); exists = 1; // Assume battery exists charging = scePowerIsBatteryCharging(); char message[256]; snprintf(message, sizeof(message), "Battery Information:\nExists: %s\nLevel: %d%%\nCharging: %s", exists ? "Yes" : "No", percent, charging ? "Yes" : "No"); initMessageDialog(SCE_MSG_DIALOG_BUTTON_TYPE_OK, message); setDialogStep(DIALOG_STEP_INFO); // Set step to handle dialog properly } static void rebootDevice() { closeSettingsMenu(); scePowerRequestColdReset(); } static void shutdownDevice() { closeSettingsMenu(); scePowerRequestStandby(); } static void suspendDevice() { closeSettingsMenu(); scePowerRequestSuspend(); } static uint64_t last_battery_check = 0; static int battery_warning_shown = 0; void checkLowBatteryWarning() { // Check every 30 seconds uint64_t now = sceKernelGetSystemTimeWide(); if (now - last_battery_check < 30LL * 1000 * 1000) { return; } last_battery_check = now; // Skip if warning disabled if (vitashell_config.disable_low_battery_warning) { return; } int percent = scePowerGetBatteryLifePercent(); int charging = scePowerIsBatteryCharging(); if (!charging && percent >= 0 && percent <= 20 && !battery_warning_shown) { battery_warning_shown = 1; initMessageDialog(SCE_MSG_DIALOG_BUTTON_TYPE_OK, "Low Battery Warning:\nBattery level is below 20%.\nPlease connect charger."); } else if (charging || percent > 20) { battery_warning_shown = 0; } } void initSettingsMenu() { int i; memset(&settings_menu, 0, sizeof(SettingsMenu)); settings_menu.status = SETTINGS_MENU_CLOSED; n_settings_entries = sizeof(vitashell_settings_menu_entries) / sizeof(SettingsMenuEntry); settings_menu_entries = vitashell_settings_menu_entries; for (i = 0; i < n_settings_entries; i++) settings_menu.n_options += settings_menu_entries[i].n_options; // Additional safety: verify language container integrity for critical strings if (!language_container[VITASHELL_SETTINGS_MAIN] || !language_container[VITASHELL_SETTINGS_USBDEVICE] || !language_container[VITASHELL_SETTINGS_SELECT_BUTTON] || !language_container[VITASHELL_SETTINGS_FOCUS_COLOR] || !language_container[ON] || !language_container[OFF]) { // If critical language strings are missing, force reload of English language loadLanguage(1); // Force load English language (index 1) } // Verify essential language strings for settings menu are available int essential_strings_missing = 0; if (!language_container[VITASHELL_SETTINGS_USB_MEMORY_CARD] || !language_container[VITASHELL_SETTINGS_USB_GAME_CARD] || !language_container[VITASHELL_SETTINGS_USB_SD2VITA] || !language_container[VITASHELL_SETTINGS_USB_PSVSD] || !language_container[VITASHELL_SETTINGS_SELECT_BUTTON_USB] || !language_container[VITASHELL_SETTINGS_SELECT_BUTTON_FTP] || !language_container[VITASHELL_SETTINGS_SELECT_BUTTON_QR] || !language_container[VITASHELL_SETTINGS_FOCUS_COLOR_DEFAULT] || !language_container[VITASHELL_SETTINGS_FOCUS_COLOR_LIGHT_GREY] || !language_container[VITASHELL_SETTINGS_FOCUS_COLOR_BLUE] || !language_container[VITASHELL_SETTINGS_FOCUS_COLOR_RED] || !language_container[VITASHELL_SETTINGS_FOCUS_COLOR_PINK] || !language_container[VITASHELL_SETTINGS_FOCUS_COLOR_YELLOW]) { essential_strings_missing = 1; } if (essential_strings_missing) { // Force reload English language again to ensure all strings are available loadLanguage(1); } // Initialize options with safety checks for language container usbdevice_options[0] = language_container[VITASHELL_SETTINGS_USB_MEMORY_CARD] ? language_container[VITASHELL_SETTINGS_USB_MEMORY_CARD] : "Memory Card"; usbdevice_options[1] = language_container[VITASHELL_SETTINGS_USB_GAME_CARD] ? language_container[VITASHELL_SETTINGS_USB_GAME_CARD] : "Game Card"; usbdevice_options[2] = language_container[VITASHELL_SETTINGS_USB_SD2VITA] ? language_container[VITASHELL_SETTINGS_USB_SD2VITA] : "SD2Vita"; usbdevice_options[3] = language_container[VITASHELL_SETTINGS_USB_PSVSD] ? language_container[VITASHELL_SETTINGS_USB_PSVSD] : "PSVSD"; select_button_options[0] = language_container[VITASHELL_SETTINGS_SELECT_BUTTON_USB] ? language_container[VITASHELL_SETTINGS_SELECT_BUTTON_USB] : "USB"; select_button_options[1] = language_container[VITASHELL_SETTINGS_SELECT_BUTTON_FTP] ? language_container[VITASHELL_SETTINGS_SELECT_BUTTON_FTP] : "FTP"; select_button_options[2] = language_container[VITASHELL_SETTINGS_SELECT_BUTTON_QR] ? language_container[VITASHELL_SETTINGS_SELECT_BUTTON_QR] : "QR"; focus_color_options_texts[0] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_DEFAULT] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_DEFAULT] : "Default"; focus_color_options_texts[1] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_LIGHT_GREY] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_LIGHT_GREY] : "Light Grey"; focus_color_options_texts[2] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_BLUE] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_BLUE] : "Blue"; focus_color_options_texts[3] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_RED] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_RED] : "Red"; focus_color_options_texts[4] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_PINK] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_PINK] : "Pink"; focus_color_options_texts[5] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_YELLOW] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_YELLOW] : "Yellow"; focus_color_options_texts[6] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_WHITE] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_WHITE] : "White"; focus_color_options_texts[7] = language_container[VITASHELL_SETTINGS_FOCUS_COLOR_RAINBOW] ? language_container[VITASHELL_SETTINGS_FOCUS_COLOR_RAINBOW] : "Rainbow"; font_size_options[0] = language_container[VITASHELL_SETTINGS_FONT_SIZE_SMALL] ? language_container[VITASHELL_SETTINGS_FONT_SIZE_SMALL] : "Small"; font_size_options[1] = language_container[VITASHELL_SETTINGS_FONT_SIZE_NORMAL] ? language_container[VITASHELL_SETTINGS_FONT_SIZE_NORMAL] : "Normal"; font_size_options[2] = language_container[VITASHELL_SETTINGS_FONT_SIZE_LARGE] ? language_container[VITASHELL_SETTINGS_FONT_SIZE_LARGE] : "Large"; // Language options - must match lang[] array in language.c order! language_options[0] = "Japanese"; // matches lang[0] language_options[1] = "English/US"; // matches lang[1] language_options[2] = "French"; // matches lang[2] language_options[3] = "Spanish"; // matches lang[3] language_options[4] = "German"; // matches lang[4] language_options[5] = "Italian"; // matches lang[5] language_options[6] = "Dutch"; // matches lang[6] language_options[7] = "Portuguese"; // matches lang[7] language_options[8] = "Russian"; // matches lang[8] language_options[9] = "Korean"; // matches lang[9] language_options[10] = "Chinese (Trad)";// matches lang[10] language_options[11] = "Chinese (Simp)";// matches lang[11] // Set only first 12 options, rest unused for now // Audio repeat options repeat_options[0] = "None"; repeat_options[1] = "Repeat One"; repeat_options[2] = "Repeat All"; repeat_options[3] = language_container[VITASHELL_SETTINGS_AUDIO_REPEAT_SHUFFLE] ? language_container[VITASHELL_SETTINGS_AUDIO_REPEAT_SHUFFLE] : "Shuffle"; theme_options = malloc(MAX_THEMES * sizeof(char *)); for (i = 0; i < MAX_THEMES; i++) theme_options[i] = malloc(MAX_THEME_LENGTH); } void openSettingsMenu() { settings_menu.status = SETTINGS_MENU_OPENING; settings_menu.entry_sel = 0; settings_menu.option_sel = 0; settings_scroll_pos = 0; // Reset scroll position // Get current theme - safer memory management if (theme_name) { free(theme_name); theme_name = NULL; } // Safely read theme config with error handling if (readConfig("ux0:VitaShell/theme/theme.txt", theme_entries, sizeof(theme_entries) / sizeof(ConfigEntry)) < 0 || !theme_name) { // If theme config fails to load or theme_name is NULL, initialize with safe defaults if (theme_name) { free(theme_name); } theme_name = strdup("default"); } // Get theme index in main tab int theme_index = -1; int i; for (i = 0; i < (sizeof(main_settings) / sizeof(SettingsMenuOption)); i++) { if (main_settings[i].name == VITASHELL_SETTINGS_THEME) { theme_index = i; break; } } // Find all themes - with better error handling if (theme_index >= 0) { SceUID dfd = sceIoDopen("ux0:VitaShell/theme"); if (dfd >= 0) { theme_count = 0; theme = 0; int res = 0; do { SceIoDirent dir; memset(&dir, 0, sizeof(SceIoDirent)); res = sceIoDread(dfd, &dir); if (res > 0) { if (SCE_S_ISDIR(dir.d_stat.st_mode) && dir.d_name[0] != '.') { // Safety check for theme_name and array bounds if (theme_name && strcasecmp(dir.d_name, theme_name) == 0 && theme_count < MAX_THEMES) theme = theme_count; // Ensure we don't exceed array bounds if (theme_count < MAX_THEMES && theme_options[theme_count]) { snprintf(theme_options[theme_count], MAX_THEME_LENGTH, "%s", dir.d_name); theme_count++; } } } } while (res > 0 && theme_count < MAX_THEMES); sceIoDclose(dfd); // Ensure we have at least one theme option if (theme_count == 0) { if (theme_options[0]) { snprintf(theme_options[0], MAX_THEME_LENGTH, "default"); theme_count = 1; theme = 0; } } main_settings[theme_index].options = theme_options; main_settings[theme_index].n_options = theme_count; main_settings[theme_index].value = &theme; } else { // If theme directory doesn't exist or can't be opened, use safe defaults if (theme_options[0]) { snprintf(theme_options[0], MAX_THEME_LENGTH, "default"); theme_count = 1; theme = 0; main_settings[theme_index].options = theme_options; main_settings[theme_index].n_options = theme_count; main_settings[theme_index].value = &theme; } } } changed = 0; } void closeSettingsMenu() { settings_menu.status = SETTINGS_MENU_CLOSING; // Save settings if (changed) { saveSettingsConfig(); // Save theme config file - with safety checks if (theme < theme_count && theme >= 0 && theme_options[theme]) { theme_entries[0].value = &theme_options[theme]; writeConfig("ux0:VitaShell/theme/theme.txt", theme_entries, sizeof(theme_entries) / sizeof(ConfigEntry)); } theme_entries[0].value = (void *)&theme_name; } // If language changed, ask for restart if (language_changed) { // Reset flag language_changed = 0; // Show language restart message (translated) with fallback char *restart_msg = language_container[LANGUAGE_CHANGED_RESTART_MSG] ? language_container[LANGUAGE_CHANGED_RESTART_MSG] : "Language changed. Restart VitaShell to apply?"; initMessageDialog(SCE_MSG_DIALOG_BUTTON_TYPE_YESNO, restart_msg); setDialogStep(DIALOG_STEP_SETTINGS_AGREEMENT); } } int getSettingsMenuStatus() { return settings_menu.status; } void drawSettingsMenu() { if (settings_menu.status == SETTINGS_MENU_CLOSED) return; // Closing settings menu if (settings_menu.status == SETTINGS_MENU_CLOSING) { if (settings_menu.cur_pos > 0.0f) { settings_menu.cur_pos -= easeOut(0.0f, settings_menu.cur_pos, 0.25f, 0.01f); } else { settings_menu.status = SETTINGS_MENU_CLOSED; } } // Opening settings menu if (settings_menu.status == SETTINGS_MENU_OPENING) { if (settings_menu.cur_pos < SCREEN_HEIGHT) { settings_menu.cur_pos += easeOut(settings_menu.cur_pos, SCREEN_HEIGHT, 0.25f, 0.01f); } else { settings_menu.status = SETTINGS_MENU_OPENED; } } // Safety check for texture if (!settings_image) return; // Draw settings menu vita2d_draw_texture(settings_image, 0.0f, SCREEN_HEIGHT - settings_menu.cur_pos); float y = SCREEN_HEIGHT - settings_menu.cur_pos + START_Y; // Calculate total menu height for scrolling float total_menu_height = 0; for (int i = 0; i < n_settings_entries; i++) { total_menu_height += FONT_Y_SPACE * 1.2f; // Title + bar space SettingsMenuOption *options = settings_menu_entries[i].options; int j; for (j = 0; j < settings_menu_entries[i].n_options; j++) { total_menu_height += FONT_Y_SPACE; // Each option } total_menu_height += FONT_Y_SPACE; // Space after section } // Enable scrolling if menu is too tall int needs_scrolling = (total_menu_height > (SCREEN_HEIGHT - START_Y - 50.0f)); if (needs_scrolling) { // Calculate scrollable area float scrollable_height = total_menu_height - (SCREEN_HEIGHT - START_Y - 50.0f); int max_scroll = (int)ceil(scrollable_height / FONT_Y_SPACE); // Clamp scroll position if (settings_scroll_pos > max_scroll) { settings_scroll_pos = max_scroll; } if (settings_scroll_pos < 0) { settings_scroll_pos = 0; } // Adjust Y position based on scroll y -= settings_scroll_pos * FONT_Y_SPACE; } int i; for (i = 0; i < n_settings_entries; i++) { // Title - safety check for language container char *title_text = language_container[settings_menu_entries[i].name] ? language_container[settings_menu_entries[i].name] : "Settings"; float x = pgf_text_width(title_text); pgf_draw_text(ALIGN_CENTER(SCREEN_WIDTH, x), y, SETTINGS_MENU_TITLE_COLOR, title_text); // Add colored decorative bar under each section title (positioned lower) float bar_width = pgf_text_width(title_text) + 20.0f; // Slightly wider than text float bar_x = ALIGN_CENTER(SCREEN_WIDTH, bar_width); // Different colors for each section uint32_t bar_color; if (settings_menu_entries[i].name == VITASHELL_SETTINGS_MAIN) { bar_color = RGBA8(0xFF, 0xA5, 0x00, 0xFF); // Orange for Main Settings } else if (settings_menu_entries[i].name == VITASHELL_SETTINGS_LANGUAGE) { bar_color = RGBA8(0x4E, 0xC4, 0xE8, 0xFF); // Light blue for Language Settings } else if (settings_menu_entries[i].name == VITASHELL_SETTINGS_POWER) { bar_color = RGBA8(0xFF, 0x6B, 0x6B, 0xFF); // Light red for Power Settings } else { bar_color = SETTINGS_MENU_TITLE_COLOR; // Default color } // Draw decorative bar positioned lower under the title vita2d_draw_rectangle(bar_x, y + FONT_Y_SPACE * 1.1f, bar_width, 2.0f, bar_color); y += FONT_Y_SPACE * 1.2f; // Optimized space for the bar SettingsMenuOption *options = settings_menu_entries[i].options; int j; int visible_count = 0; for (j = 0; j < settings_menu_entries[i].n_options; j++) { // QR option always available - no longer skip after first use // Count visible options for proper selection index visible_count++; int current_visible_index = visible_count - 1; int is_selected = (settings_menu.entry_sel == i && settings_menu.option_sel == current_visible_index); // Focus for selected visible option if (is_selected) vita2d_draw_rectangle(SHELL_MARGIN_X, y + 3.0f, MARK_WIDTH, FONT_Y_SPACE, SETTINGS_MENU_FOCUS_COLOR); if (options[j].type == SETTINGS_OPTION_TYPE_CALLBACK) { char *option_name = language_container[options[j].name] ? language_container[options[j].name] : "Option"; float x = pgf_text_width(option_name); pgf_draw_text(ALIGN_CENTER(SCREEN_WIDTH, x), y, SETTINGS_MENU_ITEM_COLOR, option_name); } else { char *option_name = language_container[options[j].name] ? language_container[options[j].name] : "Option"; float x = pgf_text_width(option_name); pgf_draw_text(ALIGN_RIGHT(SCREEN_HALF_WIDTH - 10.0f, x), y, SETTINGS_MENU_ITEM_COLOR, option_name); // Option switch (options[j].type) { case SETTINGS_OPTION_TYPE_BOOLEAN: { char *bool_text = (options[j].value && *(options[j].value)) ? (language_container[ON] ? language_container[ON] : "On") : (language_container[OFF] ? language_container[OFF] : "Off"); pgf_draw_text(SCREEN_HALF_WIDTH + 10.0f, y, SETTINGS_MENU_OPTION_COLOR, bool_text); break; } case SETTINGS_OPTION_TYPE_STRING: pgf_draw_text(SCREEN_HALF_WIDTH + 10.0f, y, SETTINGS_MENU_OPTION_COLOR, options[j].string); break; case SETTINGS_OPTION_TYPE_OPTIONS: { int value = 0; if (options[j].value) value = *(options[j].value); char *option_text = (options[j].options && options[j].options[value]) ? options[j].options[value] : ""; pgf_draw_text(SCREEN_HALF_WIDTH + 10.0f, y, SETTINGS_MENU_OPTION_COLOR, option_text); break; } } } y += FONT_Y_SPACE; } y += FONT_Y_SPACE; } } static int agreement = SETTINGS_AGREEMENT_NONE; void settingsAgree() { agreement = SETTINGS_AGREEMENT_AGREE; // Actually restart VitaShell when user agrees to language change sceAppMgrLoadExec("app0:eboot.bin", NULL, NULL); } void settingsDisagree() { agreement = SETTINGS_AGREEMENT_DISAGREE; } void settingsMenuCtrl() { // Safety checks for menu bounds if (settings_menu.entry_sel < 0 || settings_menu.entry_sel >= n_settings_entries) { settings_menu.entry_sel = 0; } if (settings_menu.option_sel < 0) { settings_menu.option_sel = 0; } // Calculate visible options count for current entry (QR always available) int visible_option_count = settings_menu_entries[settings_menu.entry_sel].n_options; // Find the actual option index from visible selection int actual_option_index = settings_menu.option_sel; if (actual_option_index == -1) { // Safety: reset selection if something went wrong settings_menu.option_sel = 0; actual_option_index = 0; } // Additional safety check for option bounds if (actual_option_index >= visible_option_count) { settings_menu.option_sel = visible_option_count - 1; actual_option_index = settings_menu.option_sel; } SettingsMenuOption *option = &settings_menu_entries[settings_menu.entry_sel].options[actual_option_index]; // Agreement if (agreement != SETTINGS_AGREEMENT_NONE) { agreement = SETTINGS_AGREEMENT_NONE; } // Change options - all visible options are interactable if (pressed_pad[PAD_ENTER] || pressed_pad[PAD_LEFT] || pressed_pad[PAD_RIGHT]) { changed = 1; switch (option->type) { case SETTINGS_OPTION_TYPE_BOOLEAN: if (option->value) *(option->value) = !*(option->value); break; case SETTINGS_OPTION_TYPE_STRING: initImeDialog(language_container[option->name], option->string, option->size_string, SCE_IME_TYPE_EXTENDED_NUMBER, 0, 0); setDialogStep(DIALOG_STEP_SETTINGS_STRING); break; case SETTINGS_OPTION_TYPE_CALLBACK: if (option->callback) option->callback(&option); break; case SETTINGS_OPTION_TYPE_OPTIONS: { if (option->value) { int old_value = *(option->value); if (option->name == VITASHELL_SETTINGS_SELECT_BUTTON) { // Normal cycling for SELECT_BUTTON: QR always available if (pressed_pad[PAD_LEFT]) { if (*(option->value) > 0) (*(option->value))--; else *(option->value) = 2; // 3 options: 0=USB, 1=FTP, 2=QR } else if (pressed_pad[PAD_ENTER] || pressed_pad[PAD_RIGHT]) { if (*(option->value) < 2) (*(option->value))++; else *(option->value) = 0; } } else { // Normal cycling for other options if (pressed_pad[PAD_LEFT]) { if (*(option->value) > 0) (*(option->value))--; else *(option->value) = option->n_options - 1; } else if (pressed_pad[PAD_ENTER] || pressed_pad[PAD_RIGHT]) { if (*(option->value) < option->n_options - 1) (*(option->value))++; else *(option->value) = 0; } } // Track if language changed if (option->name == VITASHELL_SETTINGS_LANGUAGE && old_value != *(option->value)) { language_changed = 1; } // Update font size immediately for UI feedback if (option->name == VITASHELL_SETTINGS_FONT_SIZE) { extern float current_font_size; if (vitashell_config.font_size == 0) current_font_size = 0.75f; else if (vitashell_config.font_size == 1) current_font_size = 1.0f; else if (vitashell_config.font_size == 2) current_font_size = 1.25f; else current_font_size = 1.0f; } } break; } } } // Enhanced navigation with automatic scrolling if (hold_pad[PAD_UP] || hold2_pad[PAD_LEFT_ANALOG_UP]) { if (settings_menu.option_sel > 0) { settings_menu.option_sel--; // Auto-scroll up if selection goes above visible area if (settings_menu.option_sel < 2) { settings_scroll_pos = MAX(0, settings_scroll_pos - 1); } } else if (settings_menu.entry_sel > 0) { settings_menu.entry_sel--; // Set to last option of previous entry - with bounds check int prev_entry_options = settings_menu_entries[settings_menu.entry_sel].n_options; settings_menu.option_sel = (prev_entry_options > 0) ? (prev_entry_options - 1) : 0; // Auto-scroll to show the new section settings_scroll_pos = MAX(0, settings_scroll_pos - 2); } } else if (hold_pad[PAD_DOWN] || hold2_pad[PAD_LEFT_ANALOG_DOWN]) { if (settings_menu.option_sel < visible_option_count - 1) { settings_menu.option_sel++; // Auto-scroll down if selection goes below visible area if (settings_menu.option_sel > MAX_VISIBLE_OPTIONS - 3) { settings_scroll_pos++; } } else if (settings_menu.entry_sel < n_settings_entries - 1) { settings_menu.entry_sel++; settings_menu.option_sel = 0; // Auto-scroll to show the new section settings_scroll_pos++; } } // Optional manual scrolling with L1/R1 buttons (still available) if (pressed_pad[PAD_LTRIGGER]) { // Manual scroll up settings_scroll_pos = MAX(0, settings_scroll_pos - 3); } else if (pressed_pad[PAD_RTRIGGER]) { // Manual scroll down settings_scroll_pos += 3; } // Close if (pressed_pad[PAD_START] || pressed_pad[PAD_CANCEL]) { closeSettingsMenu(); } }