OmniNX/Horizon-OC
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8652d1fc22015ba3de5cd82e1ff57f3ffb4ffa8a
Horizon-OC/Source/sys-clk/overlay/lib/libultrahand/libtesla/include/tesla.hpp
souldbminersmwc a7d7945a4b sysmodule: remove manager
2025-12-03 19:15:10 -05:00

13882 lines
643 KiB
C++
Raw Blame History

/********************************************************************************
* Custom Fork Information
*
* File: tesla.hpp
* Author: ppkantorski
* Description:
* This file serves as the core logic for the Ultrahand Overlay project's custom fork
* of libtesla, an overlay executor. Within this file, you will find a collection of
* functions, menu structures, and interaction logic designed to facilitate the
* smooth execution and flexible customization of overlays within the project.
*
* For the latest updates and contributions, visit the project's GitHub repository.
* (GitHub Repository: https://github.com/ppkantorski/Ultrahand-Overlay)
*
* Note: Please be aware that this notice cannot be altered or removed. It is a part
* of the project's documentation and must remain intact.
*
* Copyright (c) 2024 ppkantorski
********************************************************************************/
/**
* Copyright (C) 2020 werwolv
*
* This file is part of libtesla.
*
* libtesla 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 2 of the License, or
* (at your option) any later version.
*
* libtesla 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 libtesla. If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include <ultra.hpp>
#include <switch.h>
#include <arm_neon.h>
#include <strings.h>
#include <math.h>
#if !IS_LAUNCHER_DIRECTIVE
#include <filesystem> // unused, but preserved for projects that might need it
#endif
#include <algorithm>
#include <cstring>
#include <cwctype>
#include <string>
#include <functional>
#include <type_traits>
#include <mutex>
#include <shared_mutex>
#include <memory>
//#include <chrono> // despite being commented out, it must still be being imported via other libs
#include <list>
#include <stack>
#include <map>
//#include <barrier>
// Define this makro before including tesla.hpp in your main file. If you intend
// to use the tesla.hpp header in more than one source file, only define it once!
// #define TESLA_INIT_IMPL
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-function"
#ifdef TESLA_INIT_IMPL
#define STB_TRUETYPE_IMPLEMENTATION
#endif
#include "stb_truetype.h"
#pragma GCC diagnostic pop
#define ELEMENT_BOUNDS(elem) elem->getX(), elem->getY(), elem->getWidth(), elem->getHeight()
#define ASSERT_EXIT(x) if (R_FAILED(x)) std::exit(1)
#define ASSERT_FATAL(x) if (Result res = x; R_FAILED(res)) fatalThrow(res)
#define PACKED __attribute__((packed))
#define ALWAYS_INLINE inline __attribute__((always_inline))
/// Evaluates an expression that returns a result, and returns the result if it would fail.
#define TSL_R_TRY(resultExpr) \
({ \
const auto result = resultExpr; \
if (R_FAILED(result)) { \
return result; \
} \
})
using namespace std::literals::string_literals;
using namespace std::literals::chrono_literals; // potentially unused, restored for softare compatibility
#if IS_STATUS_MONITOR_DIRECTIVE
//struct GlyphInfo {
// u8* pointer;
// int width;
// int height;
//};
struct KeyPairHash {
std::size_t operator()(const std::pair<int, float>& key) const {
// Combine hashes of both components
union returnValue {
char c[8];
std::size_t s;
} value;
memcpy(&value.c[0], &key.first, 4);
memcpy(&value.c[4], &key.second, 4);
return value.s;
}
};
// Custom equality comparison for int-float pairs
struct KeyPairEqual {
bool operator()(const std::pair<int, float>& lhs, const std::pair<int, float>& rhs) const {
//static constexpr float epsilon = 0.00001f;
return lhs.first == rhs.first &&
std::abs(lhs.second - rhs.second) < 0.00001f;
}
};
//std::unordered_map<std::pair<s32, float>, GlyphInfo, KeyPairHash, KeyPairEqual> cache;
u8 TeslaFPS = 60;
//u8 alphabackground = 0xD;
volatile bool triggerExitNow = false;
volatile bool isRendering = false;
volatile bool delayUpdate = false;
volatile bool pendingExit = false;
volatile bool wasRendering = false;
LEvent renderingStopEvent;
bool FullMode = true;
bool deactivateOriginalFooter = false;
//bool fontCache = true;
bool disableJumpTo = false;
// Check for mini/micro mode flags
//bool isMiniOrMicroMode = false;
inline std::string lastMode;
inline std::set<std::string> overlayModes = {"full", "mini", "micro", "fps_graph", "fps_counter", "game_resolutions"};
bool isValidOverlayMode() {
return overlayModes.count(lastMode) > 0;
}
#endif
#if USING_FPS_INDICATOR_DIRECTIVE
float fps = 0.0;
int frameCount = 0;
double elapsedTime;
#endif
// Custom variables
//static bool jumpToListItem = false;
inline std::atomic<bool> jumpToTop{false};
inline std::atomic<bool> jumpToBottom{false};
inline std::atomic<bool> skipUp{false};
inline std::atomic<bool> skipDown{false};
inline u32 offsetWidthVar = 112;
inline std::string g_overlayFilename;;
inline std::string lastOverlayFilename;
inline std::string lastOverlayMode;
inline std::mutex jumpItemMutex;
inline std::string jumpItemName;
inline std::string jumpItemValue;
inline std::atomic<bool> jumpItemExactMatch{true};
inline std::atomic<bool> s_onLeftPage{false};
inline std::atomic<bool> s_onRightPage{false};
inline std::atomic<bool> screenshotsAreDisabled{false};
inline std::atomic<bool> screenshotsAreForceDisabled{false};
//#if IS_LAUNCHER_DIRECTIVE
inline bool hideHidden = false;
//#endif
//inline std::atomic<bool> isLaunchingNextOverlay{false};
inline std::atomic<bool> mainComboHasTriggered{false};
inline std::atomic<bool> launchComboHasTriggered{false};
// Sound triggering variables
inline std::atomic<bool> triggerNavigationSound{false};
inline std::atomic<bool> triggerEnterSound{false};
inline std::atomic<bool> triggerExitSound{false};
inline std::atomic<bool> triggerWallSound{false};
inline std::atomic<bool> triggerOnSound{false};
inline std::atomic<bool> triggerOffSound{false};
inline std::atomic<bool> triggerSettingsSound{false};
inline std::atomic<bool> triggerMoveSound{false};
inline std::atomic<bool> disableSound{false};
//inline std::atomic<bool> clearSoundCacheNow{false};
inline std::atomic<bool> reloadSoundCacheNow{false};
// Haptic triggering variables
inline std::atomic<bool> triggerRumbleClick{false};
inline std::atomic<bool> triggerRumbleDoubleClick{false};
static inline void triggerNavigationFeedback() {
triggerRumbleClick.store(true, std::memory_order_release);
triggerNavigationSound.store(true, std::memory_order_release);
}
static inline void triggerEnterFeedback() {
triggerRumbleClick.store(true, std::memory_order_release);
triggerEnterSound.store(true, std::memory_order_release);
}
static inline void triggerExitFeedback() {
triggerRumbleDoubleClick.store(true, std::memory_order_release);
triggerExitSound.store(true, std::memory_order_release);
}
namespace tsl {
// Booleans
inline std::atomic<bool> clearGlyphCacheNow(false);
// Constants
namespace cfg {
constexpr u32 ScreenWidth = 1920; ///< Width of the Screen
constexpr u32 ScreenHeight = 1080; ///< Height of the Screen
constexpr u32 LayerMaxWidth = 1280;
constexpr u32 LayerMaxHeight = 720;
extern u16 LayerWidth; ///< Width of the Tesla layer
extern u16 LayerHeight; ///< Height of the Tesla layer
extern u16 LayerPosX; ///< X position of the Tesla layer
extern u16 LayerPosY; ///< Y position of the Tesla layer
extern u16 FramebufferWidth; ///< Width of the framebuffer
extern u16 FramebufferHeight; ///< Height of the framebuffer
extern u64 launchCombo; ///< Overlay activation key combo
extern u64 launchCombo2; ///< Overlay activation key combo
}
/**
* @brief RGBA4444 Color structure
*/
struct Color {
union {
struct {
u16 r: 4, g: 4, b: 4, a: 4;
} PACKED;
u16 rgba;
};
constexpr inline Color(u16 raw): rgba(raw) {}
constexpr inline Color(u8 r, u8 g, u8 b, u8 a): r(r), g(g), b(b), a(a) {}
};
//#if USING_WIDGET_DIRECTIVE
// Ultra-fast version - zero variables, optimized calculations
inline constexpr Color GradientColor(float temperature) {
if (temperature <= 35.0f) return Color(7, 7, 15, 0xFF);
if (temperature >= 65.0f) return Color(15, 0, 0, 0xFF);
if (temperature < 45.0f) {
// Single calculation, avoid repetition
const float factor = (temperature - 35.0f) * 0.1f;
return Color(7 - 7 * factor, 7 + 8 * factor, 15 - 15 * factor, 0xFF);
}
if (temperature < 55.0f) {
return Color(15 * (temperature - 45.0f) * 0.1f, 15, 0, 0xFF);
}
return Color(15, 15 - 15 * (temperature - 55.0f) * 0.1f, 0, 0xFF);
}
//#endif
// Ultra-fast version - single variable, minimal branching
inline Color RGB888(const std::string& hexColor, size_t alpha = 15, const std::string& defaultHexColor = ult::whiteColor) {
const char* h = hexColor.size() == 6 ? hexColor.data() :
hexColor.size() == 7 && hexColor[0] == '#' ? hexColor.data() + 1 :
defaultHexColor.data();
return Color(
(ult::hexMap[h[0]] << 4 | ult::hexMap[h[1]]) >> 4,
(ult::hexMap[h[2]] << 4 | ult::hexMap[h[3]]) >> 4,
(ult::hexMap[h[4]] << 4 | ult::hexMap[h[5]]) >> 4,
alpha
);
}
namespace style {
constexpr u32 ListItemDefaultHeight = 70; ///< Standard list item height
constexpr u32 MiniListItemDefaultHeight = 40; ///< Mini list item height
constexpr u32 TrackBarDefaultHeight = 83; ///< Standard track bar height
constexpr u8 ListItemHighlightSaturation = 7; ///< Maximum saturation of Listitem highlights
constexpr u8 ListItemHighlightLength = 22; ///< Maximum length of Listitem highlights
namespace color {
constexpr Color ColorFrameBackground = { 0x0, 0x0, 0x0, 0xD }; ///< Overlay frame background color
constexpr Color ColorTransparent = { 0x0, 0x0, 0x0, 0x0 }; ///< Transparent color
constexpr Color ColorHighlight = { 0x0, 0xF, 0xD, 0xF }; ///< Greenish highlight color
constexpr Color ColorFrame = { 0x7, 0x7, 0x7, 0x7 }; ///< Outer boarder color // CUSTOM MODIFICATION
constexpr Color ColorHandle = { 0x5, 0x5, 0x5, 0xF }; ///< Track bar handle color
constexpr Color ColorText = { 0xF, 0xF, 0xF, 0xF }; ///< Standard text color
constexpr Color ColorDescription = { 0xA, 0xA, 0xA, 0xF }; ///< Description text color
constexpr Color ColorHeaderBar = { 0xC, 0xC, 0xC, 0xF }; ///< Category header rectangle color
constexpr Color ColorClickAnimation = { 0x0, 0x2, 0x2, 0xF }; ///< Element click animation color
}
}
static bool overrideBackButton = false; // for properly overriding the automatic "go back" functionality of KEY_B button presses
// Theme color variable definitions
//static bool disableColorfulLogo = false;
static Color logoColor1 = RGB888(ult::whiteColor);
static Color logoColor2 = RGB888("F7253E");
static size_t defaultBackgroundAlpha = 13;
static Color defaultBackgroundColor = RGB888(ult::blackColor, defaultBackgroundAlpha);
static Color defaultTextColor = RGB888(ult::whiteColor);
static Color notificationTextColor = RGB888(ult::whiteColor);
static Color headerTextColor = RGB888(ult::whiteColor);
static Color headerSeparatorColor = RGB888(ult::whiteColor);
static Color starColor = RGB888(ult::whiteColor);
static Color selectionStarColor = RGB888(ult::whiteColor);
static Color buttonColor = RGB888(ult::whiteColor);
static Color bottomTextColor = RGB888(ult::whiteColor);
static Color bottomSeparatorColor = RGB888(ult::whiteColor);
static Color topSeparatorColor = RGB888("404040");
static Color defaultOverlayColor = RGB888(ult::whiteColor);
static Color defaultPackageColor = RGB888(ult::whiteColor);//RGB888("#00FF00");
static Color defaultScriptColor = RGB888("FF33FF");
static Color clockColor = RGB888(ult::whiteColor);
static Color temperatureColor = RGB888(ult::whiteColor);
static Color batteryColor = RGB888("ffff45");
static Color batteryChargingColor = RGB888("00FF00");
static Color batteryLowColor = RGB888("FF0000");
static size_t widgetBackdropAlpha = 15;
static Color widgetBackdropColor = RGB888(ult::blackColor, widgetBackdropAlpha);
static Color overlayTextColor = RGB888(ult::whiteColor);
static Color ultOverlayTextColor = RGB888("9ed0ff");
static Color packageTextColor = RGB888(ult::whiteColor);
static Color ultPackageTextColor = RGB888("9ed0ff");
static Color bannerVersionTextColor = RGB888(ult::greyColor);
static Color overlayVersionTextColor = RGB888(ult::greyColor);
static Color ultOverlayVersionTextColor = RGB888("00FFDD");
static Color packageVersionTextColor = RGB888(ult::greyColor);
static Color ultPackageVersionTextColor = RGB888("00FFDD");
static Color onTextColor = RGB888("00FFDD");
static Color offTextColor = RGB888(ult::greyColor);
#if IS_LAUNCHER_DIRECTIVE
static Color dynamicLogoRGB1 = RGB888("00E669");
static Color dynamicLogoRGB2 = RGB888("8080EA");
#endif
//static bool disableSelectionBG = false;
//static bool disableSelectionValueColor = false;
static bool invertBGClickColor = false;
static size_t selectionBGAlpha = 11;
static Color selectionBGColor = RGB888(ult::blackColor, selectionBGAlpha);
static Color highlightColor1 = RGB888("2288CC");
static Color highlightColor2 = RGB888("88FFFF");
static Color highlightColor3 = RGB888("FFFF45");
static Color highlightColor4 = RGB888("F7253E");
static Color highlightColor = tsl::style::color::ColorHighlight;
static size_t clickAlpha = 7;
static Color clickColor = RGB888("3E25F7", clickAlpha);
static size_t progressAlpha = 7;
static Color progressColor = RGB888("253EF7", progressAlpha);
static Color trackBarColor = RGB888("555555");
static size_t separatorAlpha = 15;
static Color separatorColor = RGB888("404040", separatorAlpha);
static Color edgeSeparatorColor = RGB888("303030");
static Color textSeparatorColor = RGB888("404040");
static Color selectedTextColor = RGB888("9ed0ff");
static Color selectedValueTextColor = RGB888("FF7777");
static Color inprogressTextColor = RGB888(ult::whiteColor);
static Color invalidTextColor = RGB888("FF0000");
static Color clickTextColor = RGB888(ult::whiteColor);
static size_t tableBGAlpha = 14;
static Color tableBGColor = RGB888("2C2C2C", tableBGAlpha); //RGB888("303030", tableBGAlpha);
static Color sectionTextColor = RGB888(ult::whiteColor);
//static Color infoTextColor = RGB888("00FFDD");
static Color infoTextColor =RGB888("9ed0ff");
static Color warningTextColor = RGB888("FF7777");
static Color healthyRamTextColor = RGB888("00FF00");
static Color neutralRamTextColor = RGB888("FFAA00");
static Color badRamTextColor = RGB888("FF0000");
static Color trackBarSliderColor = RGB888("606060");
static Color trackBarSliderBorderColor = RGB888("505050");
static Color trackBarSliderMalleableColor = RGB888("A0A0A0");
static Color trackBarFullColor = RGB888("00FFDD");
static Color trackBarEmptyColor = RGB888("404040");
static void initializeThemeVars() {
auto themeData = ult::getParsedDataFromIniFile(ult::THEME_CONFIG_INI_PATH);
if (themeData.count(ult::THEME_STR) == 0) return;
auto& themeSection = themeData[ult::THEME_STR];
auto getValue = [&](const char* key) -> const std::string& {
auto it = themeSection.find(key);
return it != themeSection.end() ? it->second : ult::defaultThemeSettingsMap[key];
};
auto getColor = [&](const char* key, size_t alpha = 15) {
return RGB888(getValue(key), alpha);
};
auto getAlpha = [&](const char* key) {
const auto& alphaStr = getValue(key);
return ult::stoi(alphaStr);
};
#if IS_LAUNCHER_DIRECTIVE
logoColor1 = getColor("logo_color_1");
logoColor2 = getColor("logo_color_2");
dynamicLogoRGB1 = getColor("dynamic_logo_color_1");
dynamicLogoRGB2 = getColor("dynamic_logo_color_2");
#endif
defaultBackgroundAlpha = getAlpha("bg_alpha");
defaultBackgroundColor = getColor("bg_color", defaultBackgroundAlpha);
defaultTextColor = getColor("text_color");
notificationTextColor = getColor("notification_text_color");
headerTextColor = getColor("header_text_color");
headerSeparatorColor = getColor("header_separator_color");
starColor = getColor("star_color");
selectionStarColor = getColor("selection_star_color");
buttonColor = getColor("bottom_button_color");
bottomTextColor = getColor("bottom_text_color");
bottomSeparatorColor = getColor("bottom_separator_color");
topSeparatorColor = getColor("top_separator_color");
defaultOverlayColor = getColor("default_overlay_color");
defaultPackageColor = getColor("default_package_color");
defaultScriptColor = getColor("default_script_color");
clockColor = getColor("clock_color");
temperatureColor = getColor("temperature_color");
batteryColor = getColor("battery_color");
batteryChargingColor = getColor("battery_charging_color");
batteryLowColor = getColor("battery_low_color");
widgetBackdropAlpha = getAlpha("widget_backdrop_alpha");
widgetBackdropColor = getColor("widget_backdrop_color", widgetBackdropAlpha);
overlayTextColor = getColor("overlay_text_color");
ultOverlayTextColor = getColor("ult_overlay_text_color");
packageTextColor = getColor("package_text_color");
ultPackageTextColor = getColor("ult_package_text_color");
bannerVersionTextColor = getColor("banner_version_text_color");
overlayVersionTextColor = getColor("overlay_version_text_color");
ultOverlayVersionTextColor = getColor("ult_overlay_version_text_color");
packageVersionTextColor = getColor("package_version_text_color");
ultPackageVersionTextColor = getColor("ult_package_version_text_color");
onTextColor = getColor("on_text_color");
offTextColor = getColor("off_text_color");
invertBGClickColor = (getValue("invert_bg_click_color") == ult::TRUE_STR);
selectionBGAlpha = getAlpha("selection_bg_alpha");
selectionBGColor = getColor("selection_bg_color", selectionBGAlpha);
highlightColor1 = getColor("highlight_color_1");
highlightColor2 = getColor("highlight_color_2");
highlightColor3 = getColor("highlight_color_3");
highlightColor4 = getColor("highlight_color_4");
clickAlpha = getAlpha("click_alpha");
clickColor = getColor("click_color", clickAlpha);
progressAlpha = getAlpha("progress_alpha");
progressColor = getColor("progress_color", progressAlpha);
trackBarColor = getColor("trackbar_color");
separatorAlpha = getAlpha("separator_alpha");
separatorColor = getColor("separator_color", separatorAlpha);
textSeparatorColor = getColor("text_separator_color");
selectedTextColor = getColor("selection_text_color");
selectedValueTextColor = getColor("selection_value_text_color");
inprogressTextColor = getColor("inprogress_text_color");
invalidTextColor = getColor("invalid_text_color");
clickTextColor = getColor("click_text_color");
tableBGAlpha = getAlpha("table_bg_alpha");
tableBGColor = getColor("table_bg_color", tableBGAlpha);
sectionTextColor = getColor("table_section_text_color");
infoTextColor = getColor("table_info_text_color");
warningTextColor = getColor("warning_text_color");
healthyRamTextColor = getColor("healthy_ram_text_color");
neutralRamTextColor = getColor("neutral_ram_text_color");
badRamTextColor = getColor("bad_ram_text_color");
trackBarSliderColor = getColor("trackbar_slider_color");
trackBarSliderBorderColor = getColor("trackbar_slider_border_color");
trackBarSliderMalleableColor = getColor("trackbar_slider_malleable_color");
trackBarFullColor = getColor("trackbar_full_color");
trackBarEmptyColor = getColor("trackbar_empty_color");
}
#if !IS_LAUNCHER_DIRECTIVE
static void initializeUltrahandSettings() { // only needed for regular overlays
// Load INI data once instead of 4 separate file reads
auto ultrahandSection = ult::getKeyValuePairsFromSection(ult::ULTRAHAND_CONFIG_INI_PATH, ult::ULTRAHAND_PROJECT_NAME);
// Helper lambda to safely get string values
auto getStringValue = [&](const std::string& key, const std::string& defaultValue = "") -> std::string {
if (ultrahandSection.count(key) > 0) {
return ultrahandSection.at(key);
}
return defaultValue;
};
// Helper lambda to safely get boolean values
auto getBoolValue = [&](const std::string& key, bool defaultValue = false) -> bool {
if (ultrahandSection.count(key) > 0) {
return (ultrahandSection.at(key) == ult::TRUE_STR);
}
return defaultValue;
};
// Get default language with fallback
std::string defaultLang = getStringValue(ult::DEFAULT_LANG_STR, "en");
if (defaultLang.empty()) {
defaultLang = "en";
}
#ifdef UI_OVERRIDE_PATH
std::string UI_PATH = UI_OVERRIDE_PATH;
ult::preprocessPath(UI_PATH);
const std::string NEW_THEME_CONFIG_INI_PATH = UI_PATH+"theme.ini";
const std::string NEW_WALLPAPER_PATH = UI_PATH+"wallpaper.rgba";
const std::string TRANSLATION_JSON_PATH = UI_PATH+"lang/"+defaultLang+".json";
if (ult::isFileOrDirectory(NEW_THEME_CONFIG_INI_PATH))
ult::THEME_CONFIG_INI_PATH = NEW_THEME_CONFIG_INI_PATH; // Override theme path (optional)
if (ult::isFileOrDirectory(NEW_WALLPAPER_PATH))
ult::WALLPAPER_PATH = NEW_WALLPAPER_PATH; // Override wallpaper path (optional)
if (ult::isFileOrDirectory(TRANSLATION_JSON_PATH))
ult::loadTranslationsFromJSON(TRANSLATION_JSON_PATH); // load translations (optional)
#endif
// Set Ultrahand Globals using loaded section (defaults match initialization function)
ult::useLaunchCombos = getBoolValue("launch_combos", true); // TRUE_STR default
ult::useNotifications = getBoolValue("notifications", true); // TRUE_STR default
if (ult::useNotifications && !ult::isFile(ult::NOTIFICATIONS_FLAG_FILEPATH)) {
FILE* file = std::fopen((ult::NOTIFICATIONS_FLAG_FILEPATH).c_str(), "w");
if (file) {
std::fclose(file);
}
} else {
ult::deleteFileOrDirectory(ult::NOTIFICATIONS_FLAG_FILEPATH);
}
ult::useSoundEffects = getBoolValue("sound_effects", false);
ult::useHapticFeedback = getBoolValue("haptic_feedback", false);
ult::useSwipeToOpen = getBoolValue("swipe_to_open", true); // TRUE_STR default
ult::useOpaqueScreenshots = getBoolValue("opaque_screenshots", true); // TRUE_STR default
ultrahandSection.clear();
const std::string langFile = ult::LANG_PATH+defaultLang+".json";
if (ult::isFileOrDirectory(langFile))
ult::parseLanguage(langFile);
}
#endif
// Declarations
/**
* @brief Direction in which focus moved before landing on
* the currently focused element
*/
enum class FocusDirection {
None, ///< Focus was placed on the element programatically without user input
Up, ///< Focus moved upwards
Down, ///< Focus moved downwards
Left, ///< Focus moved from left to rigth
Right ///< Focus moved from right to left
};
/**
* @brief Current input controll mode
*
*/
enum class InputMode {
Controller, ///< Input from controller
Touch, ///< Touch input
TouchScroll ///< Moving/scrolling touch input
};
class Overlay;
namespace elm { class Element; }
namespace impl {
/**
* @brief Overlay launch parameters
*/
enum class LaunchFlags : u8 {
None = 0, ///< Do nothing special at launch
CloseOnExit = BIT(0) ///< Close the overlay the last Gui gets poped from the stack
};
static constexpr LaunchFlags operator|(LaunchFlags lhs, LaunchFlags rhs) {
return static_cast<LaunchFlags>(u8(lhs) | u8(rhs));
}
}
static void goBack(u32 count = 1);
static void pop(u32 count = 1);
static void setNextOverlay(const std::string& ovlPath, std::string args = "");
template<typename TOverlay, impl::LaunchFlags launchFlags = impl::LaunchFlags::CloseOnExit>
int loop(int argc, char** argv);
// Helpers
namespace hlp {
/**
* @brief Wrapper for service initialization
*
* @param f wrapped function
*/
template<typename F>
static inline void doWithSmSession(F f) {
smInitialize();
f();
smExit();
}
/**
* @brief Wrapper for sd card access using stdio
* @note Consider using raw fs calls instead as they are faster and need less space
*
* @param f wrapped function
*/
template<typename F>
static inline void doWithSDCardHandle(F f) {
fsdevMountSdmc();
f();
fsdevUnmountDevice("sdmc");
}
/**
* @brief Guard that will execute a passed function at the end of the current scope
*
* @param f wrapped function
*/
template<typename F>
class ScopeGuard {
ScopeGuard(const ScopeGuard&) = delete;
ScopeGuard& operator=(const ScopeGuard&) = delete;
private:
F f;
bool canceled = false;
public:
ALWAYS_INLINE ScopeGuard(F f) : f(std::move(f)) { }
ALWAYS_INLINE ~ScopeGuard() { if (!canceled) { f(); } }
void dismiss() { canceled = true; }
};
/**
* @brief libnx hid:sys shim that gives or takes away frocus to or from the process with the given aruid
*
* @param enable Give focus or take focus
* @param aruid Aruid of the process to focus/unfocus
* @return Result Result
*/
static Result hidsysEnableAppletToGetInput(bool enable, u64 aruid) {
const struct {
u8 permitInput;
u64 appletResourceUserId;
} in = { enable != 0, aruid };
return serviceDispatchIn(hidsysGetServiceSession(), 503, in);
}
static Result viAddToLayerStack(ViLayer *layer, ViLayerStack stack) {
const struct {
u32 stack;
u64 layerId;
} in = { stack, layer->layer_id };
return serviceDispatchIn(viGetSession_IManagerDisplayService(), 6000, in);
}
/**
* @brief Remove layer from layer stack
*/
static Result viRemoveFromLayerStack(ViLayer *layer, ViLayerStack stack) {
const struct {
u32 stack;
u64 layerId;
} in = { stack, layer->layer_id };
// Service command 6001 is commonly used for remove operations
// If this doesn't work, try 6002, 6010, or other nearby values
return serviceDispatchIn(viGetSession_IManagerDisplayService(), 6001, in);
}
/**
* @brief Toggles focus between the Tesla overlay and the rest of the system
*
* @param enabled Focus Tesla?
*/
static void requestForeground(bool enabled, bool updateGlobalFlag = true) {
if (updateGlobalFlag)
ult::currentForeground.store(enabled, std::memory_order_release);
u64 applicationAruid = 0, appletAruid = 0;
for (u64 programId = 0x0100000000001000UL; programId < 0x0100000000001020UL; programId++) {
pmdmntGetProcessId(&appletAruid, programId);
if (appletAruid != 0)
hidsysEnableAppletToGetInput(!enabled, appletAruid);
}
pmdmntGetApplicationProcessId(&applicationAruid);
hidsysEnableAppletToGetInput(!enabled, applicationAruid);
hidsysEnableAppletToGetInput(true, 0);
}
namespace ini {
/**
* @brief Ini file type
*/
using IniData = std::map<std::string, std::map<std::string, std::string>>;
/**
* @brief Parses a ini string
*
* @param str String to parse
* @return Parsed data
* // Modified to be "const std" instead of just "std"
*/
static IniData parseIni(const std::string &str) {
//IniData iniData;
//
//auto lines = split(str, '\n');
//
//std::string lastHeader = "";
//for (auto& line : lines) {
// line.erase(std::remove_if(line.begin(), line.end(), ::isspace), line.end());
//
// if (line[0] == '[' && line[line.size() - 1] == ']') {
// lastHeader = line.substr(1, line.size() - 2);
// iniData.emplace(lastHeader, std::map<std::string, std::string>{});
// }
// else if (auto keyValuePair = split(line, '='); keyValuePair.size() == 2) {
// iniData[lastHeader].emplace(keyValuePair[0], keyValuePair[1]);
// }
//}
return ult::parseIni(str);
}
/**
* @brief Unparses ini data into a string
*
* @param iniData Ini data
* @return Ini string
*/
static std::string unparseIni(const IniData &iniData) {
std::string result;
bool addSectionGap = false;
for (const auto &section : iniData) {
if (addSectionGap) {
result += '\n';
}
result += '[' + section.first + "]\n";
for (const auto &keyValue : section.second) {
result += keyValue.first + '=' + keyValue.second + '\n';
}
addSectionGap = true;
}
return result;
}
/**
* @brief Read Tesla settings file
*
* @return Settings data
*/
static IniData readOverlaySettings(auto& CONFIG_FILE) {
/* Open Sd card filesystem. */
FsFileSystem fsSdmc;
if (R_FAILED(fsOpenSdCardFileSystem(&fsSdmc)))
return {};
hlp::ScopeGuard fsGuard([&] { fsFsClose(&fsSdmc); });
/* Open config file. */
FsFile fileConfig;
if (R_FAILED(fsFsOpenFile(&fsSdmc, CONFIG_FILE, FsOpenMode_Read, &fileConfig)))
return {};
hlp::ScopeGuard fileGuard([&] { fsFileClose(&fileConfig); });
/* Get config file size. */
s64 configFileSize;
if (R_FAILED(fsFileGetSize(&fileConfig, &configFileSize)))
return {};
/* Read and parse config file. */
std::string configFileData(configFileSize, '\0');
u64 readSize;
Result rc = fsFileRead(&fileConfig, 0, configFileData.data(), configFileSize, FsReadOption_None, &readSize);
if (R_FAILED(rc) || readSize != static_cast<u64>(configFileSize))
return {};
return ult::parseIni(configFileData);
}
/**
* @brief Replace Tesla settings file with new data
*
* @param iniData new data
*/
static void writeOverlaySettings(IniData const &iniData, auto& CONFIG_FILE) {
/* Open Sd card filesystem. */
FsFileSystem fsSdmc;
if (R_FAILED(fsOpenSdCardFileSystem(&fsSdmc)))
return;
hlp::ScopeGuard fsGuard([&] { fsFsClose(&fsSdmc); });
/* Open config file. */
FsFile fileConfig;
if (R_FAILED(fsFsOpenFile(&fsSdmc, CONFIG_FILE, FsOpenMode_Write, &fileConfig)))
return;
hlp::ScopeGuard fileGuard([&] { fsFileClose(&fileConfig); });
const std::string iniString = unparseIni(iniData);
fsFileWrite(&fileConfig, 0, iniString.c_str(), iniString.length(), FsWriteOption_Flush);
}
/**
* @brief Merge and save changes into Tesla settings file
*
* @param changes setting values to add or update
*/
static void updateOverlaySettings(IniData const &changes, auto& CONFIG_FILE) {
hlp::ini::IniData iniData = hlp::ini::readOverlaySettings(CONFIG_FILE);
for (auto &section : changes) {
for (auto &keyValue : section.second) {
iniData[section.first][keyValue.first] = keyValue.second;
}
}
writeOverlaySettings(iniData, CONFIG_FILE);
}
}
/**
* @brief Decodes a key string into it's key code
*
* @param value Key string
* @return Key code
*/
static u64 stringToKeyCode(const std::string& value) {
for (const auto& keyInfo : ult::KEYS_INFO) {
if (strcasecmp(value.c_str(), keyInfo.name) == 0)
return keyInfo.key;
}
return 0;
}
/**
* @brief Decodes a combo string into key codes
*
* @param value Combo string
* @return Key codes
*/
static u64 comboStringToKeys(const std::string &value) {
u64 keyCombo = 0x00;
for (std::string key : ult::split(ult::removeWhiteSpaces(value), '+')) { // CUSTOM MODIFICATION (bug fix)
keyCombo |= hlp::stringToKeyCode(key);
}
return keyCombo;
}
/**
* @brief Encodes key codes into a combo string
*
* @param keys Key codes
* @return Combo string
*/
static std::string keysToComboString(u64 keys) {
if (keys == 0) return ""; // Early return for empty input
std::string result;
bool first = true;
for (const auto &keyInfo : ult::KEYS_INFO) {
if (keys & keyInfo.key) {
if (!first) {
result += "+";
}
result += keyInfo.name;
first = false;
}
}
return result;
}
inline static std::mutex comboMutex;
// Function to load key combo mappings from both overlays.ini and packages.ini
static void loadEntryKeyCombos() {
std::lock_guard<std::mutex> lock(comboMutex);
ult::g_entryCombos.clear();
// Load overlay combos from overlays.ini
auto overlayData = ult::getParsedDataFromIniFile(ult::OVERLAYS_INI_FILEPATH);
std::string fullPath;
u64 keys;
std::vector<std::string> modeList, comboList;
for (auto& [fileName, settings] : overlayData) {
fullPath = ult::OVERLAY_PATH + fileName;
// 1) main key_combo
if (auto it = settings.find(ult::KEY_COMBO_STR); it != settings.end() && !it->second.empty()) {
keys = hlp::comboStringToKeys(it->second);
if (keys) ult::g_entryCombos[keys] = { fullPath, "" };
}
// 2) per-mode combos
auto modesIt = settings.find("mode_args");
auto argsIt = settings.find("mode_combos");
if (modesIt != settings.end()) {
modeList = ult::splitIniList(modesIt->second);
comboList = (argsIt != settings.end())
? ult::splitIniList(argsIt->second)
: std::vector<std::string>();
if (comboList.size() < modeList.size())
comboList.resize(modeList.size());
for (size_t i = 0; i < modeList.size(); ++i) {
const std::string& comboStr = comboList[i];
if (comboStr.empty()) continue;
keys = hlp::comboStringToKeys(comboStr);
if (!keys) continue;
// launchArg is the *mode* (i.e. modeList[i])
ult::g_entryCombos[keys] = { fullPath, modeList[i] };
}
}
}
// Load package combos from packages.ini
auto packageData = ult::getParsedDataFromIniFile(ult::PACKAGES_INI_FILEPATH);
for (auto& [packageName, settings] : packageData) {
// Only handle main key_combo for packages (no modes for packages)
if (auto it = settings.find(ult::KEY_COMBO_STR); it != settings.end() && !it->second.empty()) {
keys = hlp::comboStringToKeys(it->second);
//std::string tmpPackageName = packageName;
//ult::removeQuotes(packageName);
if (keys) ult::g_entryCombos[keys] = { ult::OVERLAY_PATH + "ovlmenu.ovl", "--package " + packageName};
}
}
}
// Function to check if a key combination matches any overlay key combo
static OverlayCombo getEntryForKeyCombo(u64 keys) {
std::lock_guard<std::mutex> lock(comboMutex);
if (auto it = ult::g_entryCombos.find(keys); it != ult::g_entryCombos.end())
return it->second;
return { "", "" };
}
}
// Renderer
namespace gfx {
extern "C" u64 __nx_vi_layer_id;
struct ScissoringConfig {
u32 x, y, w, h, x_max, y_max;
};
// Forward declarations
class Renderer;
#ifdef UI_OVERRIDE_PATH
inline static std::shared_mutex s_translationCacheMutex;
#endif
class FontManager {
public:
struct Glyph {
stbtt_fontinfo *currFont;
float currFontSize;
int bounds[4];
int xAdvance;
u8 *glyphBmp;
int width, height;
// Add destructor to ensure cleanup
~Glyph() {
if (glyphBmp) {
stbtt_FreeBitmap(glyphBmp, nullptr);
glyphBmp = nullptr;
}
}
// Prevent copying to avoid double-free
Glyph(const Glyph&) = delete;
Glyph& operator=(const Glyph&) = delete;
// Allow moving
Glyph(Glyph&& other) noexcept
: currFont(other.currFont), currFontSize(other.currFontSize)
, xAdvance(other.xAdvance), glyphBmp(other.glyphBmp)
, width(other.width), height(other.height) {
memcpy(bounds, other.bounds, sizeof(bounds));
other.glyphBmp = nullptr; // Prevent double-free
}
Glyph& operator=(Glyph&& other) noexcept {
if (this != &other) {
if (glyphBmp) {
stbtt_FreeBitmap(glyphBmp, nullptr);
}
currFont = other.currFont;
currFontSize = other.currFontSize;
xAdvance = other.xAdvance;
glyphBmp = other.glyphBmp;
width = other.width;
height = other.height;
memcpy(bounds, other.bounds, sizeof(bounds));
other.glyphBmp = nullptr;
}
return *this;
}
Glyph() : currFont(nullptr), currFontSize(0.0f), xAdvance(0),
glyphBmp(nullptr), width(0), height(0) {
std::memset(bounds, 0, sizeof(bounds));
}
};
struct FontMetrics {
int ascent, descent, lineGap;
int lineHeight; // ascent - descent + lineGap
stbtt_fontinfo* font;
float fontSize;
FontMetrics() : ascent(0), descent(0), lineGap(0), lineHeight(0), font(nullptr), fontSize(0.0f) {}
FontMetrics(stbtt_fontinfo* f, float size) : font(f), fontSize(size) {
if (font) {
stbtt_GetFontVMetrics(font, &ascent, &descent, &lineGap);
const float scale = stbtt_ScaleForPixelHeight(font, fontSize);
ascent = static_cast<int>(ascent * scale);
descent = static_cast<int>(descent * scale);
lineGap = static_cast<int>(lineGap * scale);
lineHeight = ascent - descent + lineGap;
} else {
ascent = descent = lineGap = lineHeight = 0;
}
}
};
enum class CacheType {
Regular,
Notification,
Persistent
};
private:
inline static std::shared_mutex s_cacheMutex;
inline static std::mutex s_initMutex;
// Existing caches
inline static std::unordered_map<u64, std::shared_ptr<Glyph>> s_sharedGlyphCache;
//inline static std::unordered_map<u64, std::shared_ptr<Glyph>> s_persistentGlyphCache;
// NEW: Notification-specific cache
inline static std::unordered_map<u64, std::shared_ptr<Glyph>> s_notificationGlyphCache;
// Font metrics cache
inline static std::unordered_map<u64, FontMetrics> s_fontMetricsCache;
// Add cache size limits
static constexpr size_t MAX_CACHE_SIZE = 600;
static constexpr size_t CLEANUP_THRESHOLD = 500;
static constexpr size_t MAX_NOTIFICATION_CACHE_SIZE = 200; // Separate limit for notifications
// font handles & state
inline static stbtt_fontinfo* s_stdFont = nullptr;
inline static stbtt_fontinfo* s_localFont = nullptr;
inline static stbtt_fontinfo* s_extFont = nullptr;
inline static bool s_hasLocalFont = false;
inline static bool s_initialized = false;
// Fix cache key generation to prevent collisions
static u64 generateCacheKey(u32 character, bool monospace, u32 fontSize) {
// Use more bits for fontSize and separate monospace bit
u64 key = static_cast<u64>(character);
key = (key << 32) | static_cast<u64>(fontSize);
if (monospace) {
key |= (1ULL << 63); // Use the highest bit for monospace
}
return key;
}
// Generate cache key for font metrics
static u64 generateFontMetricsCacheKey(stbtt_fontinfo* font, u32 fontSize) {
// Use pointer address as font identifier and fontSize
const u64 fontKey = reinterpret_cast<uintptr_t>(font);
return (fontKey << 32) | static_cast<u64>(fontSize);
}
// Cleanup old entries when cache gets too large
static void cleanupOldEntries() {
if (s_sharedGlyphCache.size() <= CLEANUP_THRESHOLD) return;
// Simple cleanup: remove oldest entries
// In a real implementation, you might want LRU or other strategies
const size_t toRemove = s_sharedGlyphCache.size() - CLEANUP_THRESHOLD;
auto it = s_sharedGlyphCache.begin();
for (size_t i = 0; i < toRemove && it != s_sharedGlyphCache.end(); ++i) {
it = s_sharedGlyphCache.erase(it);
}
}
// NEW: Cleanup notification cache when it gets too large
static void cleanupNotificationCache() {
if (s_notificationGlyphCache.size() <= MAX_NOTIFICATION_CACHE_SIZE) return;
const size_t toRemove = s_notificationGlyphCache.size() - (MAX_NOTIFICATION_CACHE_SIZE / 2);
auto it = s_notificationGlyphCache.begin();
for (size_t i = 0; i < toRemove && it != s_notificationGlyphCache.end(); ++i) {
it = s_notificationGlyphCache.erase(it);
}
}
// NEW: Internal unified glyph creation method
static std::shared_ptr<Glyph> getOrCreateGlyphInternal(u32 character, bool monospace, u32 fontSize, CacheType cacheType) {
const u64 key = generateCacheKey(character, monospace, fontSize);
// Select target cache based on type
std::unordered_map<u64, std::shared_ptr<Glyph>>* targetCache;
switch (cacheType) {
case CacheType::Notification:
targetCache = &s_notificationGlyphCache;
break;
//case CacheType::Persistent:
// targetCache = &s_persistentGlyphCache;
// break;
default:
targetCache = &s_sharedGlyphCache;
break;
}
// First, try to find in target cache with shared lock
{
std::shared_lock<std::shared_mutex> readLock(s_cacheMutex);
if (!s_initialized) return nullptr;
// Check target cache first
auto it = targetCache->find(key);
if (it != targetCache->end()) {
return it->second;
}
// For notification cache, also check persistent cache (but not regular cache)
// For regular cache, also check persistent cache (existing behavior)
//if (cacheType != CacheType::Persistent) {
// auto persistentIt = s_persistentGlyphCache.find(key);
// if (persistentIt != s_persistentGlyphCache.end()) {
// return persistentIt->second;
// }
//}
}
// Glyph not found, need to create it with exclusive lock
std::unique_lock<std::shared_mutex> writeLock(s_cacheMutex);
if (!s_initialized) return nullptr;
// Double-check pattern for target cache
auto it = targetCache->find(key);
if (it != targetCache->end()) {
return it->second;
}
// Double-check persistent cache
//if (cacheType != CacheType::Persistent) {
// auto persistentIt = s_persistentGlyphCache.find(key);
// if (persistentIt != s_persistentGlyphCache.end()) {
// return persistentIt->second;
// }
//}
// Check cache size and cleanup if needed
if (cacheType == CacheType::Regular && s_sharedGlyphCache.size() >= MAX_CACHE_SIZE) {
cleanupOldEntries();
} else if (cacheType == CacheType::Notification && s_notificationGlyphCache.size() >= MAX_NOTIFICATION_CACHE_SIZE) {
cleanupNotificationCache();
}
// Create new glyph
auto glyph = std::make_shared<Glyph>();
glyph->currFont = selectFontForCharacterUnsafe(character);
if (!glyph->currFont) {
return nullptr;
}
glyph->currFontSize = stbtt_ScaleForPixelHeight(glyph->currFont, fontSize);
stbtt_GetCodepointBitmapBoxSubpixel(glyph->currFont, character,
glyph->currFontSize, glyph->currFontSize, 0, 0,
&glyph->bounds[0], &glyph->bounds[1], &glyph->bounds[2], &glyph->bounds[3]);
s32 yAdvance = 0;
stbtt_GetCodepointHMetrics(glyph->currFont, monospace ? 'W' : character,
&glyph->xAdvance, &yAdvance);
glyph->glyphBmp = stbtt_GetCodepointBitmap(glyph->currFont,
glyph->currFontSize, glyph->currFontSize, character,
&glyph->width, &glyph->height, nullptr, nullptr);
// Store in target cache
(*targetCache)[key] = glyph;
return glyph;
}
public:
// NEW: Preload and persist specific characters
//static void preloadPersistentGlyphs(const std::string& characters, u32 fontSize, bool monospace = false) {
// std::unique_lock<std::shared_mutex> writeLock(s_cacheMutex);
//
// if (!s_initialized) return;
//
// // Convert UTF-8 string to UTF-32 codepoints
// #pragma GCC diagnostic push
// #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
//
// std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> converter;
// const std::u32string codepoints = converter.from_bytes(characters);
//
// #pragma GCC diagnostic pop
//
// s32 yAdvance;
// for (char32_t character : codepoints) {
// const u64 key = generateCacheKey(character, monospace, fontSize);
//
// if (s_persistentGlyphCache.find(key) != s_persistentGlyphCache.end()) {
// continue;
// }
//
// auto glyph = std::make_shared<Glyph>();
// glyph->currFont = selectFontForCharacterUnsafe(character);
// if (!glyph->currFont) continue;
//
// glyph->currFontSize = stbtt_ScaleForPixelHeight(glyph->currFont, fontSize);
//
// stbtt_GetCodepointBitmapBoxSubpixel(glyph->currFont, character,
// glyph->currFontSize, glyph->currFontSize, 0, 0,
// &glyph->bounds[0], &glyph->bounds[1], &glyph->bounds[2], &glyph->bounds[3]);
//
// yAdvance = 0;
// stbtt_GetCodepointHMetrics(glyph->currFont, monospace ? 'W' : character,
// &glyph->xAdvance, &yAdvance);
//
// glyph->glyphBmp = stbtt_GetCodepointBitmap(glyph->currFont,
// glyph->currFontSize, glyph->currFontSize, character,
// &glyph->width, &glyph->height, nullptr, nullptr);
//
// s_persistentGlyphCache[key] = glyph;
// }
//}
static void initializeFonts(stbtt_fontinfo* stdFont, stbtt_fontinfo* localFont,
stbtt_fontinfo* extFont, bool hasLocalFont) {
std::lock_guard<std::mutex> initLock(s_initMutex);
std::unique_lock<std::shared_mutex> cacheLock(s_cacheMutex);
s_stdFont = stdFont;
s_localFont = localFont;
s_extFont = extFont;
s_hasLocalFont = hasLocalFont;
s_initialized = true;
}
static stbtt_fontinfo* selectFontForCharacter(u32 character) {
std::shared_lock<std::shared_mutex> lock(s_cacheMutex);
if (!s_initialized) return nullptr;
if (stbtt_FindGlyphIndex(s_extFont, character)) {
return s_extFont;
} else if (s_hasLocalFont && stbtt_FindGlyphIndex(s_localFont, character) != 0) {
return s_localFont;
}
return s_stdFont;
}
// Get font metrics with caching
static FontMetrics getFontMetrics(stbtt_fontinfo* font, u32 fontSize) {
if (!font) return FontMetrics();
const u64 key = generateFontMetricsCacheKey(font, fontSize);
// First, try to find existing metrics with shared lock
{
std::shared_lock<std::shared_mutex> readLock(s_cacheMutex);
auto it = s_fontMetricsCache.find(key);
if (it != s_fontMetricsCache.end()) {
return it->second;
}
}
// Metrics not found, need to create them with exclusive lock
std::unique_lock<std::shared_mutex> writeLock(s_cacheMutex);
// Double-check pattern
auto it = s_fontMetricsCache.find(key);
if (it != s_fontMetricsCache.end()) {
return it->second;
}
// Create new font metrics
FontMetrics metrics(font, static_cast<float>(fontSize));
s_fontMetricsCache[key] = metrics;
return metrics;
}
// Convenience method to get font metrics for a character (selects appropriate font)
static FontMetrics getFontMetricsForCharacter(u32 character, u32 fontSize) {
stbtt_fontinfo* font = selectFontForCharacter(character);
return getFontMetrics(font, fontSize);
}
// UPDATED: Regular glyph method - now uses internal method
static std::shared_ptr<Glyph> getOrCreateGlyph(u32 character, bool monospace, u32 fontSize) {
return getOrCreateGlyphInternal(character, monospace, fontSize, CacheType::Regular);
}
// NEW: Notification-specific glyph method
static std::shared_ptr<Glyph> getOrCreateNotificationGlyph(u32 character, bool monospace, u32 fontSize) {
return getOrCreateGlyphInternal(character, monospace, fontSize, CacheType::Notification);
}
// NEW: Clear only the notification cache
static void clearNotificationCache() {
std::unique_lock<std::shared_mutex> cacheLock(s_cacheMutex);
s_notificationGlyphCache.clear();
s_notificationGlyphCache.rehash(0);
}
static void clearCache() {
// Note: This is now safe because any code holding a shared_ptr
// will keep the Glyph alive even after the cache is cleared
std::unique_lock<std::shared_mutex> cacheLock(s_cacheMutex);
s_sharedGlyphCache.clear();
s_sharedGlyphCache.rehash(0);
s_fontMetricsCache.clear(); // Also clear font metrics cache
s_fontMetricsCache.rehash(0);
}
static void clearAllCaches() {
std::unique_lock<std::shared_mutex> cacheLock(s_cacheMutex);
s_sharedGlyphCache.clear();
s_sharedGlyphCache.rehash(0);
//s_persistentGlyphCache.clear();
//s_persistentGlyphCache.rehash(0);
s_notificationGlyphCache.clear();
s_notificationGlyphCache.rehash(0);
s_fontMetricsCache.clear();
s_fontMetricsCache.rehash(0);
}
static void cleanup() {
std::lock_guard<std::mutex> initLock(s_initMutex);
std::unique_lock<std::shared_mutex> cacheLock(s_cacheMutex);
s_sharedGlyphCache.clear();
s_sharedGlyphCache.rehash(0);
//s_persistentGlyphCache.clear();
//s_persistentGlyphCache.rehash(0);
s_notificationGlyphCache.clear();
s_notificationGlyphCache.rehash(0);
s_fontMetricsCache.clear();
s_initialized = false;
s_stdFont = nullptr;
s_localFont = nullptr;
s_extFont = nullptr;
s_hasLocalFont = false;
}
static size_t getCacheSize() {
std::shared_lock<std::shared_mutex> lock(s_cacheMutex);
return s_sharedGlyphCache.size();
}
static size_t getFontMetricsCacheSize() {
std::shared_lock<std::shared_mutex> lock(s_cacheMutex);
return s_fontMetricsCache.size();
}
static bool isInitialized() {
std::shared_lock<std::shared_mutex> lock(s_cacheMutex);
return s_initialized;
}
//static size_t getPersistentCacheSize() {
// std::shared_lock<std::shared_mutex> lock(s_cacheMutex);
// return s_persistentGlyphCache.size();
//}
// NEW: Get notification cache size
static size_t getNotificationCacheSize() {
std::shared_lock<std::shared_mutex> lock(s_cacheMutex);
return s_notificationGlyphCache.size();
}
// Add memory usage monitoring
static size_t getMemoryUsage() {
std::shared_lock<std::shared_mutex> lock(s_cacheMutex);
size_t totalMemory = 0;
// Regular cache
for (const auto& pair : s_sharedGlyphCache) {
const auto& glyph = pair.second;
if (glyph && glyph->glyphBmp) {
totalMemory += glyph->width * glyph->height;
}
}
// Persistent cache
//for (const auto& pair : s_persistentGlyphCache) {
// const auto& glyph = pair.second;
// if (glyph && glyph->glyphBmp) {
// totalMemory += glyph->width * glyph->height;
// }
//}
// Notification cache
for (const auto& pair : s_notificationGlyphCache) {
const auto& glyph = pair.second;
if (glyph && glyph->glyphBmp) {
totalMemory += glyph->width * glyph->height;
}
}
return totalMemory;
}
private:
static stbtt_fontinfo* selectFontForCharacterUnsafe(u32 character) {
if (!s_initialized) return nullptr;
if (stbtt_FindGlyphIndex(s_extFont, character)) {
return s_extFont;
} else if (s_hasLocalFont && stbtt_FindGlyphIndex(s_localFont, character) != 0) {
return s_localFont;
}
return s_stdFont;
}
};
// Static member definitions
//std::shared_mutex FontManager::s_cacheMutex;
//std::mutex FontManager::s_initMutex;
//std::unordered_map<u64, std::unique_ptr<FontManager::Glyph>> FontManager::s_sharedGlyphCache;
//stbtt_fontinfo* FontManager::s_stdFont = nullptr;
//stbtt_fontinfo* FontManager::s_localFont = nullptr;
//stbtt_fontinfo* FontManager::s_extFont = nullptr;
//bool FontManager::s_hasLocalFont = false;
//bool FontManager::s_initialized = false;
// Updated thread-safe calculateStringWidth function
static float calculateStringWidth(const std::string& originalString, const float fontSize, const bool monospace = false) {
if (originalString.empty() || !FontManager::isInitialized()) {
return 0.0f;
}
// Thread-safe translation cache access
std::string text;
#ifdef UI_OVERRIDE_PATH
{
std::shared_lock<std::shared_mutex> readLock(s_translationCacheMutex);
auto translatedIt = ult::translationCache.find(originalString);
if (translatedIt != ult::translationCache.end()) {
text = translatedIt->second;
} else {
// Don't insert anything, just fallback to original string
text = originalString;
}
}
#else
text = originalString;
#endif
// CRITICAL: Use the same data types as drawString
s32 maxWidth = 0;
s32 currentLineWidth = 0;
ssize_t codepointWidth;
u32 currCharacter = 0;
// Convert fontSize to u32 to match drawString behavior
const u32 fontSizeInt = static_cast<u32>(fontSize);
auto itStrEnd = text.cend();
auto itStr = text.cbegin();
// Fast ASCII check
bool isAsciiOnly = true;
for (unsigned char c : text) {
if (c > 127) {
isAsciiOnly = false;
break;
}
}
while (itStr != itStrEnd) {
// Decode UTF-8 codepoint
if (isAsciiOnly) {
currCharacter = static_cast<u32>(*itStr);
codepointWidth = 1;
} else {
codepointWidth = decode_utf8(&currCharacter, reinterpret_cast<const u8*>(&(*itStr)));
if (codepointWidth <= 0) break;
}
itStr += codepointWidth;
// Handle newlines
if (currCharacter == '\n') {
maxWidth = std::max(currentLineWidth, maxWidth);
currentLineWidth = 0;
continue;
}
// Use u32 fontSize to match drawString - now thread-safe
std::shared_ptr<FontManager::Glyph> glyph = FontManager::getOrCreateGlyph(currCharacter, monospace, fontSizeInt);
if (!glyph) continue;
// CRITICAL: Use the same calculation as drawString
currentLineWidth += static_cast<s32>(glyph->xAdvance * glyph->currFontSize);
}
// Final width calculation
maxWidth = std::max(currentLineWidth, maxWidth);
return static_cast<float>(maxWidth);
}
static std::pair<int, int> getUnderscanPixels();
/**
* @brief Manages the Tesla layer and draws raw data to the screen
*/
class Renderer final {
public:
using Glyph = FontManager::Glyph;
Renderer& operator=(Renderer&) = delete;
friend class tsl::Overlay;
/**
* @brief Gets the renderer instance
*
* @return Renderer
*/
inline static Renderer& get() {
static Renderer renderer;
return renderer;
}
stbtt_fontinfo m_stdFont, m_localFont, m_extFont;
bool m_hasLocalFont = false;
/**
* @brief Handles opacity of drawn colors for fadeout. Pass all colors through this function in order to apply opacity properly
*
* @param c Original color
* @return Color with applied opacity
*/
static inline Color a(const Color& c) {
const u8 opacity_limit = static_cast<u8>(0xF * Renderer::s_opacity);
return (c.rgba & 0x0FFF) | (static_cast<u16>(
ult::disableTransparency
? (ult::useOpaqueScreenshots
? 0xF // fully opaque when both flags on
: (c.a > 0xE ? c.a : 0xE)) // clamp to 14, keep lower values
: (c.a < opacity_limit ? c.a : opacity_limit) // normal fade logic
) << 12);
}
static inline Color aWithOpacity(const Color& c) {
const u8 opacity_limit = static_cast<u8>(0xF * Renderer::s_opacity);
return (c.rgba & 0x0FFF) | (static_cast<u16>(
ult::disableTransparency
? 0xF // fully opaque when both flags on
: (c.a < opacity_limit ? c.a : opacity_limit) // normal fade logic
) << 12);
}
static inline Color a2(const Color& c) {
const u8 opacity_limit = static_cast<u8>(0xF);
return (c.rgba & 0x0FFF) | (static_cast<u16>(
ult::disableTransparency
? (ult::useOpaqueScreenshots
? 0xF // fully opaque when both flags on
: (c.a > 0xE ? c.a : 0xE)) // clamp to 14, keep lower values
: (c.a < opacity_limit ? c.a : opacity_limit) // normal fade logic
) << 12);
}
/**
* @brief Enables scissoring, discarding of any draw outside the given boundaries
*
* @param x x pos
* @param y y pos
* @param w Width
* @param h Height
*/
inline void enableScissoring(const u32 x, const u32 y, const u32 w, const u32 h) {
this->m_scissoringStack.emplace(x, y, w, h, x+w, y+h);
}
/**
* @brief Disables scissoring
*/
inline void disableScissoring() {
this->m_scissoringStack.pop();
}
// Drawing functions
/**
* @brief Draw a single pixel onto the screen
*
* @param x X pos
* @param y Y pos
* @param color Color
*/
inline void setPixel(const u32 x, const u32 y, const Color& color) {
const u32 offset = this->getPixelOffset(x, y);
if (offset != UINT32_MAX) [[likely]] {
Color* framebuffer = static_cast<Color*>(this->getCurrentFramebuffer());
framebuffer[offset] = color;
}
}
inline void setPixelAtOffset(const u32 offset, const Color& color) {
Color* framebuffer = static_cast<Color*>(this->getCurrentFramebuffer());
framebuffer[offset] = color;
}
/**
* @brief Blends two colors
*
* @param src Source color
* @param dst Destination color
* @param alpha Opacity
* @return Blended color
*/
static constexpr u8 inv_alpha_table[16] = {15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0};
inline u8 __attribute__((always_inline)) blendColor(const u8 src, const u8 dst, const u8 alpha) {
return ((src * inv_alpha_table[alpha]) + (dst * alpha)) >> 4;
}
/**
* @brief Draws a single source blended pixel onto the screen
*
* @param x X pos
* @param y Y pos
* @param color Color
*/
inline void setPixelBlendSrc(const u32 x, const u32 y, const Color& color) {
const u32 offset = this->getPixelOffset(x, y);
if (offset == UINT32_MAX) [[unlikely]]
return;
Color* framebuffer = static_cast<Color*>(this->getCurrentFramebuffer());
const Color src = framebuffer[offset];
// Direct write instead of calling setPixel
framebuffer[offset] = Color(
blendColor(src.r, color.r, color.a),
blendColor(src.g, color.g, color.a),
blendColor(src.b, color.b, color.a),
src.a
);
}
// Compromise version - keep framebuffer lookup but inline the rest
inline void setPixelBlendDst(const u32 x, const u32 y, const Color& color) {
const u32 offset = this->getPixelOffset(x, y);
if (offset == UINT32_MAX) [[unlikely]]
return;
Color* framebuffer = static_cast<Color*>(this->getCurrentFramebuffer());
const Color src = framebuffer[offset];
// Direct write instead of calling setPixel
framebuffer[offset] = Color(
blendColor(src.r, color.r, color.a),
blendColor(src.g, color.g, color.a),
blendColor(src.b, color.b, color.a),
(color.a + (src.a * (0xF - color.a) >> 4))
);
}
// Batch version for setPixelBlendDst
inline void setPixelBlendDstBatch(const u32 baseX, const u32 baseY,
const u8 red[16], const u8 green[16],
const u8 blue[16], const u8 alpha[16],
const s32 count) {
// All variables moved outside the loop
const u16* framebuffer = static_cast<const u16*>(this->getCurrentFramebuffer());
u32 offset;
u8 currentAlpha;
u8 invAlpha;
Color src = {0}, end = {0};
u32 currentX;
for (s32 i = 0; i < count; ++i) {
// Early exit for transparent pixels
currentAlpha = alpha[i];
if (currentAlpha == 0)
continue;
currentX = baseX + i;
offset = this->getPixelOffset(currentX, baseY);
if (offset == UINT32_MAX) [[unlikely]]
continue;
// Direct framebuffer access and color construction
src = framebuffer[offset];
invAlpha = 0xF - currentAlpha;
// Direct member assignment instead of constructor
end.r = blendColor(src.r, red[i], currentAlpha);
end.g = blendColor(src.g, green[i], currentAlpha);
end.b = blendColor(src.b, blue[i], currentAlpha);
end.a = (currentAlpha + (src.a * invAlpha >> 4));
this->setPixelAtOffset(offset, end);
}
}
/**
* @brief Draws a rectangle of given sizes
*
* @param x X pos
* @param y Y pos
* @param w Width
* @param h Height
* @param color Color
*/
inline void drawRect(const s32 x, const s32 y, const s32 w, const s32 h, const Color& color) {
// Early exit for invalid dimensions
//if (w <= 0 || h <= 0) return;
// Calculate clipped bounds
const s32 x_start = x < 0 ? 0 : x;
const s32 y_start = y < 0 ? 0 : y;
const s32 x_end = (x + w > cfg::FramebufferWidth) ? cfg::FramebufferWidth : x + w;
const s32 y_end = (y + h > cfg::FramebufferHeight) ? cfg::FramebufferHeight : y + h;
// Early exit if completely outside bounds
if (x_start >= x_end || y_start >= y_end) [[unlikely]] return;
// Draw row by row for better cache locality
for (s32 yi = y_start; yi < y_end; ++yi) {
for (s32 xi = x_start; xi < x_end; ++xi) {
this->setPixelBlendDst(xi, yi, color);
}
}
}
/**
* @brief Worker function for multithreaded rectangle drawing
* @param x_start Start X coordinate
* @param x_end End X coordinate
* @param y_start Start Y coordinate for this thread
* @param y_end End Y coordinate for this thread
* @param color Color to draw
*/
inline void processRectChunk(const s32 x_start, const s32 x_end, const s32 y_start, const s32 y_end, const Color& color) {
for (s32 yi = y_start; yi < y_end; ++yi) {
for (s32 xi = x_start; xi < x_end; ++xi) {
this->setPixelBlendDst(xi, yi, color);
}
}
}
/**
* @brief Draws a rectangle of given sizes (Multi-threaded)
*
* @param x X pos
* @param y Y pos
* @param w Width
* @param h Height
* @param color Color
*/
inline void drawRectMultiThreaded(const s32 x, const s32 y, const s32 w, const s32 h, const Color& color) {
// Early exit for invalid dimensions
if (w <= 0 || h <= 0) return;
// Calculate clipped bounds
const s32 x_start = x < 0 ? 0 : x;
const s32 y_start = y < 0 ? 0 : y;
const s32 x_end = (x + w > cfg::FramebufferWidth) ? cfg::FramebufferWidth : x + w;
const s32 y_end = (y + h > cfg::FramebufferHeight) ? cfg::FramebufferHeight : y + h;
// Early exit if completely outside bounds
if (x_start >= x_end || y_start >= y_end) return;
// Calculate visible dimensions
const s32 visibleHeight = y_end - y_start;
// Calculate chunk size - divide rows among threads
const s32 chunkSize = std::max(1, visibleHeight / static_cast<s32>(ult::numThreads));
// Launch threads using ult::renderThreads array
for (unsigned i = 0; i < static_cast<unsigned>(ult::numThreads); ++i) {
const s32 startRow = y_start + (i * chunkSize);
const s32 endRow = (i == static_cast<unsigned>(ult::numThreads) - 1) ?
y_end :
std::min(startRow + chunkSize, y_end);
// Skip threads that have no work
if (startRow >= endRow) {
ult::renderThreads[i] = std::thread([](){}); // Empty thread (still needed for joining)
continue;
}
// Use member function instead of lambda - much faster
ult::renderThreads[i] = std::thread(&Renderer::processRectChunk, this,
x_start, x_end, startRow, endRow, color);
}
// Join all ult::renderThreads
for (auto& t : ult::renderThreads) {
t.join();
}
}
/**
* @brief Draws a rectangle of given sizes with empty filling
*
* @param x X pos
* @param y Y pos
* @param w Width
* @param h Height
* @param color Color
*/
inline void drawEmptyRect(s32 x, s32 y, s32 w, s32 h, Color color) {
// Only precompute values that are actually reused
const s32 x_end = x + w - 1;
const s32 y_end = y + h - 1;
// Early exit for completely out-of-bounds rectangles
if (x_end < 0 || y_end < 0 || x >= cfg::FramebufferWidth || y >= cfg::FramebufferHeight) [[unlikely]] {
return;
}
// Early exit for degenerate rectangles
//if (w <= 0 || h <= 0) {
// return;
//}
// These are reused for both horizontal lines
const s32 line_x_start = x < 0 ? 0 : x;
const s32 line_x_end = x_end >= cfg::FramebufferWidth ? cfg::FramebufferWidth - 1 : x_end;
// Draw top horizontal line
if (y >= 0 && y < cfg::FramebufferHeight) {
for (s32 xi = line_x_start; xi <= line_x_end; ++xi) {
this->setPixelBlendDst(xi, y, color);
}
}
// Draw bottom horizontal line (only if different from top)
if (h > 1 && y_end >= 0 && y_end < cfg::FramebufferHeight) {
for (s32 xi = line_x_start; xi <= line_x_end; ++xi) {
this->setPixelBlendDst(xi, y_end, color);
}
}
// Draw vertical lines only if there's space between horizontal lines
if (h > 2) {
// These are reused for both vertical lines
const s32 line_y_start = (y + 1) < 0 ? 0 : (y + 1);
const s32 line_y_end = (y_end - 1) >= cfg::FramebufferHeight ? cfg::FramebufferHeight - 1 : (y_end - 1);
// Only proceed if there are actually vertical pixels to draw
if (line_y_start <= line_y_end) {
// Left vertical line
if (x >= 0 && x < cfg::FramebufferWidth) {
for (s32 yi = line_y_start; yi <= line_y_end; ++yi) {
this->setPixelBlendDst(x, yi, color);
}
}
// Right vertical line (only if different from left)
if (w > 1 && x_end >= 0 && x_end < cfg::FramebufferWidth) {
for (s32 yi = line_y_start; yi <= line_y_end; ++yi) {
this->setPixelBlendDst(x_end, yi, color);
}
}
}
}
}
/**
* @brief Draws a line
*
* @param x0 Start X pos
* @param y0 Start Y pos
* @param x1 End X pos
* @param y1 End Y pos
* @param color Color
*/
inline void drawLine(s32 x0, s32 y0, s32 x1, s32 y1, Color color) {
// Early exit for single point
if (x0 == x1 && y0 == y1) {
if (x0 >= 0 && y0 >= 0 && x0 < cfg::FramebufferWidth && y0 < cfg::FramebufferHeight) {
this->setPixelBlendDst(x0, y0, color);
}
return;
}
// Calculate deltas
const s32 dx = x1 - x0;
const s32 dy = y1 - y0;
// Calculate absolute deltas and steps
const s32 abs_dx = dx < 0 ? -dx : dx;
const s32 abs_dy = dy < 0 ? -dy : dy;
const s32 step_x = dx < 0 ? -1 : 1;
const s32 step_y = dy < 0 ? -1 : 1;
// Bresenham's algorithm
s32 x = x0, y = y0;
s32 error = abs_dx - abs_dy;
s32 error2;
while (true) {
// Bounds check and draw pixel
if (x >= 0 && y >= 0 && x < cfg::FramebufferWidth && y < cfg::FramebufferHeight) {
this->setPixelBlendDst(x, y, color);
}
// Check if we've reached the end point
if (x == x1 && y == y1) break;
// Calculate error and step
error2 = error << 1; // error * 2
if (error2 > -abs_dy) {
error -= abs_dy;
x += step_x;
}
if (error2 < abs_dx) {
error += abs_dx;
y += step_y;
}
}
}
/**
* @brief Draws a dashed line
*
* @param x0 Start X pos
* @param y0 Start Y pos
* @param x1 End X pos
* @param y1 End Y pos
* @param line_width How long one line can be
* @param color Color
*/
inline void drawDashedLine(s32 x0, s32 y0, s32 x1, s32 y1, s32 line_width, Color color) {
// Source of formula: https://www.cc.gatech.edu/grads/m/Aaron.E.McClennen/Bresenham/code.html
const s32 x_min = std::min(x0, x1);
const s32 x_max = std::max(x0, x1);
const s32 y_min = std::min(y0, y1);
const s32 y_max = std::max(y0, y1);
if (x_min < 0 || y_min < 0 || x_min >= cfg::FramebufferWidth || y_min >= cfg::FramebufferHeight)
return;
const s32 dx = x_max - x_min;
const s32 dy = y_max - y_min;
s32 d = 2 * dy - dx;
const s32 incrE = 2*dy;
const s32 incrNE = 2*(dy - dx);
this->setPixelBlendDst(x_min, y_min, color);
s32 x = x_min;
s32 y = y_min;
s32 rendered = 0;
while(x < x1) {
if (d <= 0) {
d += incrE;
x++;
}
else {
d += incrNE;
x++;
y++;
}
rendered++;
if (x < 0 || y < 0 || x >= cfg::FramebufferWidth || y >= cfg::FramebufferHeight)
continue;
if (x <= x_max && y <= y_max) {
if (rendered > 0 && rendered < line_width) {
this->setPixelBlendDst(x, y, color);
}
else if (rendered > 0 && rendered >= line_width) {
rendered *= -1;
}
}
}
}
inline void drawCircle(const s32 centerX, const s32 centerY, const u16 radius, const bool filled, const Color& color) {
s32 x = radius;
s32 y = 0;
s32 radiusError = 0;
s32 xChange = 1 - (radius << 1);
s32 yChange = 0;
while (x >= y) {
if (filled) {
for (s32 i = centerX - x; i <= centerX + x; i++) {
this->setPixelBlendDst(i, centerY + y, color);
this->setPixelBlendDst(i, centerY - y, color);
}
for (s32 i = centerX - y; i <= centerX + y; i++) {
this->setPixelBlendDst(i, centerY + x, color);
this->setPixelBlendDst(i, centerY - x, color);
}
} else {
this->setPixelBlendDst(centerX + x, centerY + y, color);
this->setPixelBlendDst(centerX + y, centerY + x, color);
this->setPixelBlendDst(centerX - y, centerY + x, color);
this->setPixelBlendDst(centerX - x, centerY + y, color);
this->setPixelBlendDst(centerX - x, centerY - y, color);
this->setPixelBlendDst(centerX - y, centerY - x, color);
this->setPixelBlendDst(centerX + y, centerY - x, color);
this->setPixelBlendDst(centerX + x, centerY - y, color);
}
y++;
radiusError += yChange;
yChange += 2;
if (((radiusError << 1) + xChange) > 0) {
x--;
radiusError += xChange;
xChange += 2;
}
}
}
inline void drawBorderedRoundedRect(const s32 x, const s32 y, const s32 width, const s32 height, const s32 thickness, const s32 radius, const Color& highlightColor) {
const s32 startX = x + 4;
const s32 startY = y;
const s32 adjustedWidth = width - 12;
const s32 adjustedHeight = height + 1;
// Pre-calculate corner positions
const s32 leftCornerX = startX;
const s32 rightCornerX = x + width - 9;
const s32 topCornerY = startY;
const s32 bottomCornerY = startY + height;
// Draw borders (unchanged for exact visual match)
this->drawRect(startX, startY - thickness, adjustedWidth, thickness, highlightColor); // Top border
this->drawRect(startX, startY + adjustedHeight, adjustedWidth, thickness, highlightColor); // Bottom border
this->drawRect(startX - thickness, startY, thickness, adjustedHeight, highlightColor); // Left border
this->drawRect(startX + adjustedWidth, startY, thickness, adjustedHeight, highlightColor); // Right border
// Optimized filled quarter circle drawing - all 4 corners in one pass
s32 cx = radius;
s32 cy = 0;
s32 radiusError = 0;
s32 xChange = 1 - (radius << 1);
s32 yChange = 0;
while (cx >= cy) {
// Draw horizontal spans for all 4 corners simultaneously
// Upper-left corner (quadrant 2) - two horizontal lines
for (s32 i = leftCornerX - cx; i <= leftCornerX; i++) {
this->setPixelBlendDst(i, topCornerY - cy, highlightColor);
}
for (s32 i = leftCornerX - cy; i <= leftCornerX; i++) {
this->setPixelBlendDst(i, topCornerY - cx, highlightColor);
}
// Lower-left corner (quadrant 3) - two horizontal lines
for (s32 i = leftCornerX - cx; i <= leftCornerX; i++) {
this->setPixelBlendDst(i, bottomCornerY + cy, highlightColor);
}
for (s32 i = leftCornerX - cy; i <= leftCornerX; i++) {
this->setPixelBlendDst(i, bottomCornerY + cx, highlightColor);
}
// Upper-right corner (quadrant 1) - two horizontal lines
for (s32 i = rightCornerX; i <= rightCornerX + cx; i++) {
this->setPixelBlendDst(i, topCornerY - cy, highlightColor);
}
for (s32 i = rightCornerX; i <= rightCornerX + cy; i++) {
this->setPixelBlendDst(i, topCornerY - cx, highlightColor);
}
// Lower-right corner (quadrant 4) - two horizontal lines
for (s32 i = rightCornerX; i <= rightCornerX + cx; i++) {
this->setPixelBlendDst(i, bottomCornerY + cy, highlightColor);
}
for (s32 i = rightCornerX; i <= rightCornerX + cy; i++) {
this->setPixelBlendDst(i, bottomCornerY + cx, highlightColor);
}
// Bresenham circle algorithm step
cy++;
radiusError += yChange;
yChange += 2;
if (((radiusError << 1) + xChange) > 0) {
cx--;
radiusError += xChange;
xChange += 2;
}
}
}
// Pre-compute all horizontal spans for the entire shape
struct HorizontalSpan {
s32 start_x, end_x;
};
// Define processChunk as a static member function
// Optimized processRoundedRectChunk - assumes bounds checking done by caller
static void processRoundedRectChunk(Renderer* self, const s32 x, const s32 y, const s32 w, const s32 h,
const s32 radius, const Color& color, const s32 startRow, const s32 endRow) {
// Original rectangle bounds
const s32 orig_x = x, orig_y = y;
const s32 orig_x_end = x + w, orig_y_end = y + h;
// Calculate clipping bounds
const s32 clip_x = std::max(0, x);
const s32 clip_x_end = std::min(static_cast<s32>(cfg::FramebufferWidth), x + w);
// Use ORIGINAL coordinates to determine corner regions
const s32 orig_x_left = orig_x + radius, orig_x_right = orig_x_end - radius;
const s32 orig_y_top = orig_y + radius, orig_y_bottom = orig_y_end - radius;
const s32 r2 = radius * radius;
const u8 red = color.r, green = color.g, blue = color.b, alpha = color.a;
alignas(64) u8 redArray[512], greenArray[512], blueArray[512], alphaArray[512];
for (s32 i = 0; i < 512; i += 8) {
redArray[i] = redArray[i+1] = redArray[i+2] = redArray[i+3] =
redArray[i+4] = redArray[i+5] = redArray[i+6] = redArray[i+7] = red;
greenArray[i] = greenArray[i+1] = greenArray[i+2] = greenArray[i+3] =
greenArray[i+4] = greenArray[i+5] = greenArray[i+6] = greenArray[i+7] = green;
blueArray[i] = blueArray[i+1] = blueArray[i+2] = blueArray[i+3] =
blueArray[i+4] = blueArray[i+5] = blueArray[i+6] = blueArray[i+7] = blue;
alphaArray[i] = alphaArray[i+1] = alphaArray[i+2] = alphaArray[i+3] =
alphaArray[i+4] = alphaArray[i+5] = alphaArray[i+6] = alphaArray[i+7] = alpha;
}
s32 orig_span_start, orig_span_end;
s32 dx;
for (s32 y_current = startRow; y_current < endRow; ++y_current) {
// Skip if outside original rectangle bounds
if (y_current < orig_y || y_current >= orig_y_end) continue;
if (y_current >= orig_y_top && y_current < orig_y_bottom) {
// Middle section - full width
orig_span_start = orig_x;
orig_span_end = orig_x_end;
} else {
// Corner section
const s32 dy_abs = (y_current < orig_y_top) ? (orig_y_top - y_current) : (y_current - orig_y_bottom);
const s32 dy2 = dy_abs * dy_abs;
if (dy2 > r2) continue;
// Compute dx using integer square root approximation
dx = 0;
const s32 t = r2 - dy2;
while (dx * dx <= t) {
dx++;
}
dx--; // Get the largest dx where dx^2 + dy2 <= r2
// Calculate the span for this row in the original rectangle
orig_span_start = std::max(orig_x_left - dx, orig_x);
orig_span_end = std::min(orig_x_right + dx, orig_x_end);
}
// Clip the original span to visible bounds
const s32 span_start = std::max(orig_span_start, clip_x);
const s32 span_end = std::min(orig_span_end, clip_x_end);
if (span_start >= span_end) continue;
// Batch rendering
for (s32 x_pos = span_start; x_pos < span_end; x_pos += 512) {
self->setPixelBlendDstBatch(x_pos, y_current, redArray, greenArray, blueArray, alphaArray, std::min(512, span_end - x_pos));
}
}
}
/**
* @brief Draws a rounded rectangle of given sizes and corner radius (Multi-threaded)
*
* @param x X pos
* @param y Y pos
* @param w Width
* @param h Height
* @param radius Corner radius
* @param color Color
*/
inline void drawRoundedRectMultiThreaded(const s32 x, const s32 y, const s32 w, const s32 h, const s32 radius, const Color& color) {
if (w <= 0 || h <= 0) return;
// Get framebuffer bounds for early exit check
const s32 fb_width = static_cast<s32>(cfg::FramebufferWidth);
const s32 fb_height = static_cast<s32>(cfg::FramebufferHeight);
// Calculate clipped bounds for early exit check
const s32 clampedX = std::max(0, x);
const s32 clampedY = std::max(0, y);
const s32 clampedXEnd = std::min(fb_width, x + w);
const s32 clampedYEnd = std::min(fb_height, y + h);
// Early exit if nothing to draw after clamping
if (clampedX >= clampedXEnd || clampedY >= clampedYEnd) return;
// Calculate visible dimensions
const s32 visibleHeight = clampedYEnd - clampedY;
// Dynamic chunk size based on visible rectangle height
const s32 chunkSize = std::max(1, visibleHeight / (static_cast<s32>(ult::numThreads) * 2));
std::atomic<s32> currentRow(clampedY);
auto threadTask = [&]() {
s32 startRow, endRow;
while ((startRow = currentRow.fetch_add(chunkSize)) < clampedYEnd) {
endRow = std::min(startRow + chunkSize, clampedYEnd);
processRoundedRectChunk(this, x, y, w, h, radius, color, startRow, endRow);
}
};
// Launch threads using ult::renderThreads array
for (unsigned i = 0; i < static_cast<unsigned>(ult::numThreads); ++i) {
ult::renderThreads[i] = std::thread(threadTask);
}
// Join all ult::renderThreads
for (auto& t : ult::renderThreads) {
t.join();
}
}
/**
* @brief Draws a rounded rectangle of given sizes and corner radius (Single-threaded)
*
* @param x X pos
* @param y Y pos
* @param w Width
* @param h Height
* @param radius Corner radius
* @param color Color
*/
inline void drawRoundedRectSingleThreaded(const s32 x, const s32 y, const s32 w, const s32 h, const s32 radius, const Color& color) {
if (w <= 0 || h <= 0) return;
// Get framebuffer bounds for early exit check
const s32 fb_width = static_cast<s32>(cfg::FramebufferWidth);
const s32 fb_height = static_cast<s32>(cfg::FramebufferHeight);
// Calculate clipped bounds for early exit check
const s32 clampedX = std::max(0, x);
const s32 clampedY = std::max(0, y);
const s32 clampedXEnd = std::min(fb_width, x + w);
const s32 clampedYEnd = std::min(fb_height, y + h);
// Early exit if nothing to draw after clamping
if (clampedX >= clampedXEnd || clampedY >= clampedYEnd) return;
processRoundedRectChunk(this, x, y, w, h, radius, color, clampedY, clampedYEnd);
}
std::function<void(s32, s32, s32, s32, s32, Color)> drawRoundedRect;
inline void updateDrawFunction() {
if (ult::expandedMemory) {
drawRoundedRect = [this](s32 x, s32 y, s32 w, s32 h, s32 radius, Color color) {
drawRoundedRectMultiThreaded(x, y, w, h, radius, color);
};
} else {
drawRoundedRect = [this](s32 x, s32 y, s32 w, s32 h, s32 radius, Color color) {
drawRoundedRectSingleThreaded(x, y, w, h, radius, color);
};
}
}
inline void drawUniformRoundedRect(const s32 x, const s32 y, const s32 w, const s32 h, const Color& color) {
// Early exit for degenerate cases
//if (w <= 0 || h <= 0) return;
// Calculate radius and bounds
const s32 radius = h >> 1; // h / 2
//if (radius <= 0) return;
// Get framebuffer bounds
const s32 fb_width = cfg::FramebufferWidth;
const s32 fb_height = cfg::FramebufferHeight;
// Calculate clipped drawing bounds
const s32 clip_left = std::max(0, x);
const s32 clip_top = std::max(0, y);
const s32 clip_right = std::min(fb_width, x + w);
const s32 clip_bottom = std::min(fb_height, y + h);
// Early exit if completely clipped
if (clip_left >= clip_right || clip_top >= clip_bottom) return;
// Shape parameters
const s32 center_y = y + radius;
const s32 rect_left = x + radius;
const s32 rect_right = x + w - radius;
const s32 radius_sq = radius * radius;
// Choose drawing method based on alpha
const bool fullOpacity = (color.a == 0xF);
// Pre-compute variables
s32 y_curr, x_curr;
s32 dy, dy_sq, x_offset_sq;
s32 x_offset, row_start, row_end;
//u32 pixel_offset;
// Main drawing loop
for (y_curr = clip_top; y_curr < clip_bottom; ++y_curr) {
dy = y_curr - center_y;
dy_sq = dy * dy;
// Skip rows outside the shape
if (dy_sq > radius_sq) continue;
// Calculate horizontal extent for this row
x_offset_sq = radius_sq - dy_sq;
// Fast integer square root with better rounding
if (radius <= 32) {
// Direct calculation for small values
x_offset = 0;
while (x_offset * x_offset <= x_offset_sq) {
x_offset++;
}
// More intelligent step-back: only if we're significantly over
// This reduces the "flat edge" appearance
if (x_offset > 0) {
s32 current_sq = x_offset * x_offset;
s32 prev_sq = (x_offset - 1) * (x_offset - 1);
// Only step back if we're closer to the previous value
if (current_sq - x_offset_sq > x_offset_sq - prev_sq) {
x_offset--;
}
}
} else {
// Newton's method for larger values (converges in ~4 iterations)
x_offset = radius; // Initial guess
for (int i = 0; i < 4; ++i) {
x_offset = (x_offset + x_offset_sq / x_offset) >> 1;
}
// Ensure we're close to the actual value
while ((x_offset + 1) * (x_offset + 1) <= x_offset_sq) x_offset++;
while (x_offset * x_offset > x_offset_sq) x_offset--;
}
// Calculate row bounds
row_start = rect_left - x_offset;
row_end = rect_right + x_offset;
// Clip to visible area
row_start = std::max(row_start, clip_left);
row_end = std::min(row_end, clip_right);
if (row_start >= row_end) continue;
// Draw the row
if (fullOpacity) {
for (x_curr = row_start; x_curr < row_end; ++x_curr) {
const u32 offset = this->getPixelOffset((u32)x_curr, (u32)y_curr);
if (offset == UINT32_MAX) continue;
this->setPixelAtOffset(offset, color);
}
} else {
for (x_curr = row_start; x_curr < row_end; ++x_curr) {
const u32 offset = this->getPixelOffset((u32)x_curr, (u32)y_curr);
if (offset == UINT32_MAX) continue;
// you can keep using the existing blended helper which already checks UINT32_MAX
this->setPixelBlendDst((u32)x_curr, (u32)y_curr, color);
}
}
}
}
// Struct for batch pixel processing with better alignment
struct alignas(64) PixelBatch {
s32 baseX, baseY;
u8 red[32], green[32], blue[32], alpha[32]; // Doubled for 32-pixel batches
s32 count;
};
// Batch pixel setter - process multiple pixels at once if available
inline void setPixelBatchBlendSrc(const s32 baseX, const s32 baseY, const PixelBatch& batch) {
// If your graphics system supports batch operations, use them here
// Otherwise fall back to individual calls
for (s32 i = 0; i < batch.count; ++i) {
setPixelBlendSrc(baseX + i, baseY, {
batch.red[i], batch.green[i], batch.blue[i], batch.alpha[i]
});
}
}
// Fixed compilation errors - simplified SIMD version
static constexpr uint8x16_t lut = {0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255};
const uint8x16_t mask_low = vdupq_n_u8(0x0F);
// Pre-computed lookup table for 4-bit to 8-bit conversion
static constexpr u8 expand4to8[16] = {
0, 17, 34, 51, 68, 85, 102, 119, 136, 153, 170, 187, 204, 221, 238, 255
};
inline void processBMPChunk(const s32 x, const s32 y, const s32 screenW, const u8 *preprocessedData,
const s32 startRow, const s32 endRow, const u8 globalAlphaLimit) {
const s32 bytesPerRow = screenW * 2;
const s32 endX16 = screenW & ~15;
// Create SIMD vector for alpha limit
const uint8x16_t alpha_limit_vec = vdupq_n_u8(globalAlphaLimit);
// Pre-declare all variables outside loops
const u8 *rowPtr;
s32 baseY;
s32 x1;
const u8* ptr;
uint8x16x2_t packed;
uint8x16_t high1, low1, high2, low2;
uint8x16_t red, green, blue, alpha;
alignas(16) u8 red_vals[16], green_vals[16], blue_vals[16], alpha_vals[16];
s32 baseX;
s32 pixelX;
u32 offset;
Color color = {0}, src = {0}, end = {0};
const u16* framebuffer;
u8 p1, p2;
for (s32 y1 = startRow; y1 < endRow; ++y1) {
rowPtr = preprocessedData + (y1 * bytesPerRow);
baseY = y + y1;
x1 = 0;
// SIMD processing for 16 pixels at once
for (; x1 < endX16; x1 += 16) {
ptr = rowPtr + (x1 << 1);
packed = vld2q_u8(ptr);
// Expand 4-bit to 8-bit values
high1 = vshrq_n_u8(packed.val[0], 4);
low1 = vandq_u8(packed.val[0], mask_low);
high2 = vshrq_n_u8(packed.val[1], 4);
low2 = vandq_u8(packed.val[1], mask_low);
red = vqtbl1q_u8(lut, high1);
green = vqtbl1q_u8(lut, low1);
blue = vqtbl1q_u8(lut, high2);
alpha = vqtbl1q_u8(lut, low2);
// Apply alpha limit using SIMD min operation
alpha = vminq_u8(alpha, alpha_limit_vec);
// Store to arrays and process individually
vst1q_u8(red_vals, red);
vst1q_u8(green_vals, green);
vst1q_u8(blue_vals, blue);
vst1q_u8(alpha_vals, alpha);
baseX = x + x1;
// Process 16 pixels with minimal function call overhead
for (int i = 0; i < 16; ++i) {
// Skip transparent pixels
if (alpha_vals[i] == 0) continue;
pixelX = baseX + i;
offset = this->getPixelOffset(pixelX, baseY);
if (offset != UINT32_MAX) {
color = {red_vals[i], green_vals[i], blue_vals[i], alpha_vals[i]};
framebuffer = static_cast<const u16*>(this->getCurrentFramebuffer());
src = Color(framebuffer[offset]);
end = {
blendColor(src.r, color.r, color.a),
blendColor(src.g, color.g, color.a),
blendColor(src.b, color.b, color.a),
src.a
};
this->setPixelAtOffset(offset, end);
}
}
}
// Handle remaining pixels (less than 16) with pre-computed alpha limit
for (; x1 < screenW; ++x1) {
p1 = rowPtr[x1 << 1];
p2 = rowPtr[(x1 << 1) + 1];
u8 alpha = expand4to8[p2 & 0x0F];
alpha = (alpha < globalAlphaLimit) ? alpha : globalAlphaLimit;
setPixelBlendSrc(x + x1, baseY, {
expand4to8[p1 >> 4], expand4to8[p1 & 0x0F],
expand4to8[p2 >> 4], alpha
});
}
}
ult::inPlotBarrier.arrive_and_wait();
}
/**
* @brief Draws a scaled RGBA8888 bitmap from memory
*
* @param x X start position
* @param y Y start position
* @param w Bitmap width (original width of the bitmap)
* @param h Bitmap height (original height of the bitmap)
* @param bmp Pointer to bitmap data
* @param screenW Target screen width
* @param screenH Target screen height
*/
//inline void drawBitmapRGBA4444(const s32 x, const s32 y, const s32 screenW, const s32 screenH, const u8 *preprocessedData) {
// s32 startRow;
//
// // Divide rows among ult::renderThreads
// //s32 chunkSize = (screenH + ult::numThreads - 1) / ult::numThreads;
// for (unsigned i = 0; i < ult::numThreads; ++i) {
// startRow = i * ult::bmpChunkSize;
// //s32 endRow = std::min(startRow + ult::bmpChunkSize, screenH);
//
// // Bind the member function and create the thread
// ult::renderThreads[i] = std::thread(std::bind(&tsl::gfx::Renderer::processBMPChunk, this, x, y, screenW, preprocessedData, startRow, std::min(startRow + ult::bmpChunkSize, screenH)));
// }
//
// // Join all ult::renderThreads
// for (auto& t : ult::renderThreads) {
// t.join();
// }
//}
inline void drawBitmapRGBA4444(const s32 x, const s32 y, const s32 screenW, const s32 screenH,
const u8 *preprocessedData, float opacity = 1.0f) {
// Pre-compute alpha limit once
const u8 globalAlphaLimit = static_cast<u8>(0xF * opacity);
s32 startRow;
for (unsigned i = 0; i < ult::numThreads; ++i) {
startRow = i * ult::bmpChunkSize;
// Pass the alpha limit to each thread
ult::renderThreads[i] = std::thread(std::bind(&tsl::gfx::Renderer::processBMPChunk,
this, x, y, screenW, preprocessedData, startRow,
std::min(startRow + ult::bmpChunkSize, screenH), globalAlphaLimit));
}
// Join all threads
for (auto& t : ult::renderThreads) {
t.join();
}
}
//inline void drawWallpaper() {
// if (!ult::expandedMemory || ult::refreshWallpaper.load(std::memory_order_acquire)) {
// return;
// }
//
// ult::inPlot.store(true, std::memory_order_release);
//
// if (!ult::wallpaperData.empty() &&
// !ult::refreshWallpaper.load(std::memory_order_acquire) &&
// ult::correctFrameSize) {
// drawBitmapRGBA4444(0, 0, cfg::FramebufferWidth, cfg::FramebufferHeight, ult::wallpaperData.data());
// }
//
// ult::inPlot.store(false, std::memory_order_release);
//}
inline void drawWallpaper() {
if (!ult::expandedMemory || ult::refreshWallpaper.load(std::memory_order_acquire)) {
return;
}
ult::inPlot.store(true, std::memory_order_release);
if (!ult::wallpaperData.empty() &&
!ult::refreshWallpaper.load(std::memory_order_acquire) &&
ult::correctFrameSize) {
// Use the renderer's opacity directly
drawBitmapRGBA4444(0, 0, cfg::FramebufferWidth, cfg::FramebufferHeight,
ult::wallpaperData.data(), Renderer::s_opacity);
}
ult::inPlot.store(false, std::memory_order_release);
}
/**
* @brief Draws a RGBA8888 bitmap from memory
*
* @param x X start position
* @param y Y start position
* @param w Bitmap width
* @param h Bitmap height
* @param bmp Pointer to bitmap data
*/
inline void drawBitmap(s32 x, s32 y, s32 w, s32 h, const u8 *bmp) {
if (w <= 0 || h <= 0) [[unlikely]] return;
const u8* __restrict__ src = bmp;
s32 px;
// Completely unroll small bitmaps for maximum speed
if (w <= 8 && h <= 8) [[likely]] {
// Specialized path for small bitmaps (icons, etc.)
for (s32 py = 0; py < h; ++py) {
const s32 rowY = y + py;
px = x;
// Unroll inner loop completely for small widths
switch(w) {
case 8: goto pixel8;
case 7: goto pixel7;
case 6: goto pixel6;
case 5: goto pixel5;
case 4: goto pixel4;
case 3: goto pixel3;
case 2: goto pixel2;
case 1: goto pixel1;
default: break;
}
pixel8: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, a(c)); src += 4;
}
pixel7: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, a(c)); src += 4;
}
pixel6: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, a(c)); src += 4;
}
pixel5: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, a(c)); src += 4;
}
pixel4: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, a(c)); src += 4;
}
pixel3: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, a(c)); src += 4;
}
pixel2: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, a(c)); src += 4;
}
pixel1: {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px, rowY, a(c)); src += 4;
}
}
return;
}
// Fallback to vectorized version for larger bitmaps
const s32 vectorWidth = w & ~7; // Process 8 pixels at a time
const s32 remainder = w & 7;
for (s32 py = 0; py < h; ++py) {
const s32 rowY = y + py;
px = x;
// Process 8 pixels at once (cache-friendly)
for (s32 i = 0; i < vectorWidth; i += 8) {
// Prefetch next cache line
__builtin_prefetch(src + 64, 0, 3);
// Process 8 pixels with minimal overhead
for (int j = 0; j < 8; ++j) {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, (c));
src += 4;
}
}
// Handle remainder
for (s32 i = 0; i < remainder; ++i) {
const Color c = {static_cast<u8>(src[0] >> 4), static_cast<u8>(src[1] >> 4),
static_cast<u8>(src[2] >> 4), static_cast<u8>(src[3] >> 4)};
setPixelBlendSrc(px++, rowY, (c));
src += 4;
}
}
}
/**
* @brief Fills the entire layer with a given color
*
* @param color Color
*/
inline void fillScreen(const Color& color) {
std::fill_n(static_cast<Color*>(this->getCurrentFramebuffer()), this->getFramebufferSize() / sizeof(Color), color);
}
/**
* @brief Clears the layer (With transparency)
*
*/
inline void clearScreen() {
this->fillScreen(Color(0x0, 0x0, 0x0, 0x0)); // Fully transparent
}
const stbtt_fontinfo& getStandardFont() const {
return m_stdFont;
}
// Optimized unified drawString method with thread safety
inline std::pair<s32, s32> drawString(const std::string& originalString, bool monospace,
const s32 x, const s32 y, const u32 fontSize,
const Color& defaultColor, const ssize_t maxWidth = 0,
bool draw = true,
const Color* highlightColor = nullptr,
const std::vector<std::string>* specialSymbols = nullptr,
const u32 highlightStartChar = 0,
const u32 highlightEndChar = 0,
const bool useNotificationCache = false) { // NEW parameter
// Thread-safe translation cache access
std::string text;
#if defined(UI_OVERRIDE_PATH)// && (!defined(IS_STATUS_MONITOR) || (IS_STATUS_MONITOR == 0))
{
std::shared_lock<std::shared_mutex> readLock(s_translationCacheMutex);
auto translatedIt = ult::translationCache.find(originalString);
if (translatedIt != ult::translationCache.end()) {
text = translatedIt->second;
} else {
// Don't insert anything, just fallback to original string
text = originalString;
}
}
#else
text = originalString;
#endif
if (text.empty() || fontSize == 0) return {0, 0};
const float maxWidthLimit = maxWidth > 0 ? x + maxWidth : std::numeric_limits<float>::max();
// Check if highlighting is enabled (both highlight color and delimiters must be provided)
const bool highlightingEnabled = highlightColor && highlightStartChar != 0 && highlightEndChar != 0;
// Get font metrics for consistent line height using a standard character
// This ensures consistent line spacing regardless of which specific characters are used
const auto fontMetrics = FontManager::getFontMetricsForCharacter('A', fontSize);
const s32 lineHeight = static_cast<s32>(fontMetrics.lineHeight);
// Fast ASCII check with early exit
bool isAsciiOnly = true;
const char* textPtr = text.data();
const char* textEnd = textPtr + text.size();
for (const char* p = textPtr; p < textEnd; ++p) {
if (static_cast<unsigned char>(*p) > 127) {
isAsciiOnly = false;
break;
}
}
s32 maxX = x, currX = x, currY = y; // Changed to s32 for consistency
s32 maxY = y + lineHeight; // Initialize with at least one line height
bool inHighlight = false;
const Color* currentColor = &defaultColor;
// Pre-declare variables used in loops to avoid repeated allocations
u32 currCharacter;
ssize_t codepointWidth;
std::shared_ptr<FontManager::Glyph> glyph;
bool symbolProcessed;
size_t remainingLength;
u32 symChar;
ssize_t symWidth;
size_t i;
// Main processing loop with pointer arithmetic for ASCII optimization
if (isAsciiOnly && !specialSymbols) {
// Fast ASCII-only path
for (const char* p = textPtr; p < textEnd && currX < maxWidthLimit; ++p) {
currCharacter = static_cast<u32>(*p);
// Handle highlighting with configurable delimiters
if (highlightingEnabled) {
if (currCharacter == highlightStartChar) {
inHighlight = true;
} else if (currCharacter == highlightEndChar) {
inHighlight = false;
}
currentColor = (currCharacter == highlightStartChar || currCharacter == highlightEndChar) ?
&defaultColor : (inHighlight ? highlightColor : &defaultColor);
}
// Handle newline
if (currCharacter == '\n') {
maxX = std::max(currX, maxX);
currX = x;
currY += lineHeight; // Use consistent line height
maxY = std::max(maxY, currY + lineHeight); // Update maxY for new line
continue;
}
// Get glyph (now thread-safe)
// Get glyph - UPDATED to use notification cache when requested
if (useNotificationCache) {
glyph = FontManager::getOrCreateNotificationGlyph(currCharacter, monospace, fontSize);
} else {
glyph = FontManager::getOrCreateGlyph(currCharacter, monospace, fontSize);
}
if (!glyph) continue;
// Track maximum Y position reached using consistent line height
maxY = std::max(maxY, currY + lineHeight);
// Render if needed
if (draw && glyph->glyphBmp && currCharacter > 32) { // Space is 32
renderGlyph(glyph, currX, currY, *currentColor);
}
currX += static_cast<s32>(glyph->xAdvance * glyph->currFontSize);
}
} else {
// UTF-8 path with special symbols support
auto itStr = text.cbegin();
const auto itStrEnd = text.cend();
while (itStr != itStrEnd && currX < maxWidthLimit) {
// Check for special symbols first
symbolProcessed = false;
if (specialSymbols) {
remainingLength = itStrEnd - itStr;
for (const auto& symbol : *specialSymbols) {
if (remainingLength >= symbol.length() &&
std::equal(symbol.begin(), symbol.end(), itStr)) {
// Process special symbol
for (i = 0; i < symbol.length(); ) {
symWidth = decode_utf8(&symChar,
reinterpret_cast<const u8*>(&symbol[i]));
if (symWidth <= 0) break;
if (symChar == '\n') {
maxX = std::max(currX, maxX);
currX = x;
currY += lineHeight; // Use consistent line height
maxY = std::max(maxY, currY + lineHeight); // Update maxY for new line
} else {
glyph = FontManager::getOrCreateGlyph(symChar, monospace, fontSize);
if (glyph) {
// Track maximum Y position reached using consistent line height
maxY = std::max(maxY, currY + lineHeight);
if (draw && glyph->glyphBmp && symChar > 32) {
renderGlyph(glyph, currX, currY, *highlightColor);
}
currX += static_cast<s32>(glyph->xAdvance * glyph->currFontSize);
}
}
i += symWidth;
}
itStr += symbol.length();
symbolProcessed = true;
break;
}
}
}
if (symbolProcessed) continue;
// Decode character
if (isAsciiOnly) {
currCharacter = static_cast<u32>(*itStr);
codepointWidth = 1;
} else {
codepointWidth = decode_utf8(&currCharacter, reinterpret_cast<const u8*>(&(*itStr)));
if (codepointWidth <= 0) break;
}
itStr += codepointWidth;
// Handle highlighting with configurable delimiters
if (highlightingEnabled) {
if (currCharacter == highlightStartChar) {
inHighlight = true;
} else if (currCharacter == highlightEndChar) {
inHighlight = false;
}
currentColor = (currCharacter == highlightStartChar || currCharacter == highlightEndChar) ?
&defaultColor : (inHighlight ? highlightColor : &defaultColor);
}
// Handle newline
if (currCharacter == '\n') {
maxX = std::max(currX, maxX);
currX = x;
currY += lineHeight; // Use consistent line height
maxY = std::max(maxY, currY + lineHeight); // Update maxY for new line
continue;
}
// Get glyph (now thread-safe)
glyph = FontManager::getOrCreateGlyph(currCharacter, monospace, fontSize);
if (!glyph) continue;
// Track maximum Y position reached using consistent line height
maxY = std::max(maxY, currY + lineHeight);
// Render if needed
if (draw && glyph->glyphBmp && currCharacter > 32) {
renderGlyph(glyph, currX, currY, *currentColor);
}
currX += static_cast<s32>(glyph->xAdvance * glyph->currFontSize);
}
}
maxX = std::max(currX, maxX);
// Return consistent height based on proper font metrics
return {maxX - x, maxY - y};
}
inline std::pair<s32, s32> drawNotificationString(const std::string& text, bool monospace,
const s32 x, const s32 y, const u32 fontSize,
const Color& defaultColor, const ssize_t maxWidth = 0,
bool draw = true,
const Color* highlightColor = nullptr,
const std::vector<std::string>* specialSymbols = nullptr,
const u32 highlightStartChar = 0,
const u32 highlightEndChar = 0) {
return drawString(text, monospace, x, y, fontSize, defaultColor, maxWidth, draw,
highlightColor, specialSymbols, highlightStartChar, highlightEndChar, true);
}
// Convenience wrappers for backward compatibility
inline std::pair<s32, s32> drawStringWithHighlight(const std::string& text, bool monospace,
s32 x, s32 y, const u32 fontSize,
const Color& defaultColor,
const Color& specialColor,
const ssize_t maxWidth = 0,
const u32 startChar = '(',
const u32 endChar = ')') {
return drawString(text, monospace, x, y, fontSize, defaultColor, maxWidth, true, &specialColor, nullptr, startChar, endChar);
}
inline std::pair<s32, s32> drawStringWithColoredSections(const std::string& text, bool monospace,
const std::vector<std::string>& specialSymbols,
s32 x, const s32 y, const u32 fontSize,
const Color& defaultColor,
const Color& specialColor) {
return drawString(text, monospace, x, y, fontSize, defaultColor, 0, true, &specialColor, &specialSymbols);
}
// Calculate string dimensions without drawing
inline std::pair<s32, s32> getTextDimensions(const std::string& text, bool monospace,
const u32 fontSize, const ssize_t maxWidth = 0) {
return drawString(text, monospace, 0, 0, fontSize, Color{0,0,0,0}, maxWidth, false);
}
inline std::pair<s32, s32> getNotificationTextDimensions(const std::string& text, bool monospace,
const u32 fontSize, const ssize_t maxWidth = 0) {
return drawString(text, monospace, 0, 0, fontSize, Color{0,0,0,0}, maxWidth, false,
nullptr, nullptr, 0, 0, true);
}
// Thread-safe limitStringLength using the unified cache
inline std::string limitStringLength(const std::string& originalString, const bool monospace,
const u32 fontSize, const s32 maxLength) { // Changed fontSize to u32
// Thread-safe translation cache access
std::string text;
#ifdef UI_OVERRIDE_PATH
{
std::shared_lock<std::shared_mutex> readLock(s_translationCacheMutex);
auto translatedIt = ult::translationCache.find(originalString);
if (translatedIt != ult::translationCache.end()) {
text = translatedIt->second;
} else {
// Don't insert anything, just fallback to original string
text = originalString;
}
}
#else
text = originalString;
#endif
if (text.size() < 2) return text;
// Get ellipsis width using shared cache (now thread-safe)
static constexpr u32 ellipsisChar = 0x2026;
std::shared_ptr<FontManager::Glyph> ellipsisGlyph = FontManager::getOrCreateGlyph(ellipsisChar, monospace, fontSize);
if (!ellipsisGlyph) return text;
// Fixed: Use consistent s32 calculation like other functions
const s32 ellipsisWidth = static_cast<s32>(ellipsisGlyph->xAdvance * ellipsisGlyph->currFontSize);
const s32 maxWidthWithoutEllipsis = maxLength - ellipsisWidth;
if (maxWidthWithoutEllipsis <= 0) {
return "…"; // If there's no room for text, just return ellipsis
}
// Calculate width incrementally
s32 currX = 0;
auto itStr = text.cbegin();
const auto itStrEnd = text.cend();
auto lastValidPos = itStr;
// Fast ASCII check
bool isAsciiOnly = true;
for (unsigned char c : text) {
if (c > 127) {
isAsciiOnly = false;
break;
}
}
// Move variable declarations outside the loop
u32 currCharacter;
ssize_t codepointWidth;
s32 charWidth;
size_t bytePos;
while (itStr != itStrEnd) {
// Decode UTF-8 codepoint
if (isAsciiOnly) {
currCharacter = static_cast<u32>(*itStr);
codepointWidth = 1;
} else {
codepointWidth = decode_utf8(&currCharacter, reinterpret_cast<const u8*>(&(*itStr)));
if (codepointWidth <= 0) break;
}
// FontManager::getOrCreateGlyph is now thread-safe
std::shared_ptr<FontManager::Glyph> glyph = FontManager::getOrCreateGlyph(currCharacter, monospace, fontSize);
if (!glyph) {
itStr += codepointWidth;
continue;
}
// Fixed: Use consistent s32 calculation
charWidth = static_cast<s32>(glyph->xAdvance * glyph->currFontSize);
if (currX + charWidth > maxWidthWithoutEllipsis) {
// Calculate the byte position for substring
bytePos = std::distance(text.cbegin(), lastValidPos);
return text.substr(0, bytePos) + "…";
}
currX += charWidth;
itStr += codepointWidth;
lastValidPos = itStr;
}
return text;
}
inline void setLayerPos(u32 x, u32 y) {
//const float ratio = 1.5;
//u32 maxX = cfg::ScreenWidth - (int)(ratio * cfg::FramebufferWidth);
//u32 maxY = cfg::ScreenHeight - (int)(ratio * cfg::FramebufferHeight);
if (x > cfg::ScreenWidth - (int)(1.5 * cfg::FramebufferWidth) || y > cfg::ScreenHeight - (int)(1.5 * cfg::FramebufferHeight)) {
return;
}
setLayerPosImpl(x, y);
}
void updateLayerSize() {
const auto [horizontalUnderscanPixels, verticalUnderscanPixels] = getUnderscanPixels();
// Recalculate layer dimensions with new underscan values
cfg::LayerWidth = cfg::ScreenWidth * (float(cfg::FramebufferWidth) / float(cfg::LayerMaxWidth));
cfg::LayerHeight = cfg::ScreenHeight * (float(cfg::FramebufferHeight) / float(cfg::LayerMaxHeight));
// Apply underscan adjustments
if (ult::DefaultFramebufferWidth == 1280 && ult::DefaultFramebufferHeight == 28) {
cfg::LayerHeight += cfg::ScreenHeight/720. * verticalUnderscanPixels;
} else if (ult::correctFrameSize) {
cfg::LayerWidth += horizontalUnderscanPixels;
}
// Update position if using right alignment
if (ult::useRightAlignment && ult::correctFrameSize) {
ult::layerEdge = (1280 - 448);
}
// Update the existing layer with new dimensions
viSetLayerSize(&this->m_layer, cfg::LayerWidth, cfg::LayerHeight);
// Update position if using right alignment
if (ult::useRightAlignment && ult::correctFrameSize) {
viSetLayerPosition(&this->m_layer, 1280-32 - horizontalUnderscanPixels, 0);
viSetLayerSize(&this->m_layer, cfg::LayerWidth, cfg::LayerHeight);
viSetLayerPosition(&this->m_layer, 1280-32 - horizontalUnderscanPixels, 0);
}
// ADD THIS: Update position for micro mode bottom positioning
else if (ult::DefaultFramebufferWidth == 1280 && ult::DefaultFramebufferHeight == 28 && cfg::LayerPosY > 500) {
// Only adjust if already positioned at bottom (LayerPosY > 500 indicates bottom positioning)
const u32 targetY = !verticalUnderscanPixels ? 1038 : 1038- (cfg::ScreenHeight/720. * verticalUnderscanPixels) +0.5;
viSetLayerPosition(&this->m_layer, 0, targetY);
viSetLayerSize(&this->m_layer, cfg::LayerWidth, cfg::LayerHeight);
viSetLayerPosition(&this->m_layer, 0, targetY);
}
}
static Renderer& getRenderer() {
return get();
}
inline void setLayerPosImpl(u32 x, u32 y) {
// Get the underscan pixel values for both horizontal and vertical borders
//const auto [horizontalUnderscanPixels, verticalUnderscanPixels] = getUnderscanPixels();
// Simply set the position to what was requested - no automatic right alignment
cfg::LayerPosX = x;
cfg::LayerPosY = y;
ASSERT_FATAL(viSetLayerPosition(&this->m_layer, cfg::LayerPosX, cfg::LayerPosY));
}
#if USING_WIDGET_DIRECTIVE
// Method to draw clock, temperatures, and battery percentage
inline void drawWidget() {
static time_t lastTimeUpdate = 0;
static char timeStr[20];
static char PCB_temperatureStr[10];
static char SOC_temperatureStr[10];
static char chargeString[6];
static time_t lastSensorUpdate = 0;
const bool showAnyWidget = !(ult::hideBattery && ult::hidePCBTemp && ult::hideSOCTemp && ult::hideClock);
// Draw separator and backdrop if showing any widget
if (showAnyWidget) {
drawRect(239, 15 + 2 - 2, 1, 64 + 2, topSeparatorColor);
if (!ult::hideWidgetBackdrop) {
drawUniformRoundedRect(
247, 15 + 2 - 2,
(ult::extendedWidgetBackdrop
? tsl::cfg::FramebufferWidth - 255
: tsl::cfg::FramebufferWidth - 215),
64 + 2, widgetBackdropColor
);
}
}
// Calculate base Y offset
size_t y_offset = ((ult::hideBattery && ult::hidePCBTemp && ult::hideSOCTemp) || ult::hideClock)
? (55 + 2 - 1)
: (44 + 2 - 1);
// Constants for centering calculations
const int backdropCenterX = 247 + ((tsl::cfg::FramebufferWidth - 255) >> 1);
time_t currentTime = time(nullptr);
// Draw clock
if (!ult::hideClock) {
if (currentTime != lastTimeUpdate || ult::languageWasChanged.load(std::memory_order_acquire)) {
strftime(timeStr, sizeof(timeStr), ult::datetimeFormat.c_str(), localtime(&currentTime));
ult::localizeTimeStr(timeStr);
lastTimeUpdate = currentTime;
}
const int timeWidth = getTextDimensions(timeStr, false, 20).first;
if (ult::centerWidgetAlignment) {
// Centered alignment
drawString(timeStr, false, backdropCenterX - (timeWidth >> 1), y_offset, 20, clockColor);
} else {
// Right alignment
drawString(timeStr, false, tsl::cfg::FramebufferWidth - timeWidth - 25, y_offset, 20, clockColor);
}
y_offset += 22;
}
// Update sensor data every second
if ((currentTime - lastSensorUpdate) >= 1) {
if (!ult::hideSOCTemp) {
float socTemp = 0.0f;
ult::ReadSocTemperature(&socTemp);
ult::SOC_temperature.store(socTemp, std::memory_order_release);
snprintf(
SOC_temperatureStr, sizeof(SOC_temperatureStr),
"%d°C",
static_cast<int>(round(ult::SOC_temperature.load(std::memory_order_acquire)))
);
}
if (!ult::hidePCBTemp) {
float pcbTemp = 0.0f;
ult::ReadPcbTemperature(&pcbTemp);
ult::PCB_temperature.store(pcbTemp, std::memory_order_release);
snprintf(
PCB_temperatureStr, sizeof(PCB_temperatureStr),
"%d°C",
static_cast<int>(round(ult::PCB_temperature.load(std::memory_order_acquire)))
);
}
if (!ult::hideBattery) {
uint32_t bc = 0;
bool charging = false;
ult::powerGetDetails(&bc, &charging);
bc = std::min(bc, 100U);
ult::batteryCharge.store(bc, std::memory_order_release);
ult::isCharging.store(charging, std::memory_order_release);
snprintf(chargeString, sizeof(chargeString), "%u%%", bc);
}
lastSensorUpdate = currentTime;
}
if (ult::centerWidgetAlignment) {
// CENTERED ALIGNMENT
int totalWidth = 0;
int socWidth = 0, pcbWidth = 0, chargeWidth = 0;
bool hasMultiple = false;
const float socTemp = ult::SOC_temperature.load(std::memory_order_acquire);
const float pcbTemp = ult::PCB_temperature.load(std::memory_order_acquire);
const uint32_t batteryCharge = ult::batteryCharge.load(std::memory_order_acquire);
const bool charging = ult::isCharging.load(std::memory_order_acquire);
if (!ult::hideSOCTemp && socTemp > 0.0f) {
socWidth = getTextDimensions(SOC_temperatureStr, false, 20).first;
totalWidth += socWidth;
hasMultiple = true;
}
if (!ult::hidePCBTemp && pcbTemp > 0.0f) {
pcbWidth = getTextDimensions(PCB_temperatureStr, false, 20).first;
if (hasMultiple) totalWidth += 5;
totalWidth += pcbWidth;
hasMultiple = true;
}
if (!ult::hideBattery && batteryCharge > 0) {
chargeWidth = getTextDimensions(chargeString, false, 20).first;
if (hasMultiple) totalWidth += 5;
totalWidth += chargeWidth;
}
int currentX = backdropCenterX - (totalWidth >> 1);
if (socWidth > 0) {
drawString(
SOC_temperatureStr, false, currentX, y_offset, 20,
ult::dynamicWidgetColors
? tsl::GradientColor(socTemp)
: temperatureColor
);
currentX += socWidth + 5;
}
if (pcbWidth > 0) {
drawString(
PCB_temperatureStr, false, currentX, y_offset, 20,
ult::dynamicWidgetColors
? tsl::GradientColor(pcbTemp)
: temperatureColor
);
currentX += pcbWidth + 5;
}
if (chargeWidth > 0) {
const Color batteryColorToUse = charging
? batteryChargingColor
: (batteryCharge < 20 ? batteryLowColor : batteryColor);
drawString(chargeString, false, currentX, y_offset, 20, batteryColorToUse);
}
} else {
// RIGHT ALIGNMENT
int chargeWidth = 0, pcbWidth = 0, socWidth = 0;
const float pcbTemp = ult::PCB_temperature.load(std::memory_order_acquire);
const float socTemp = ult::SOC_temperature.load(std::memory_order_acquire);
const uint32_t batteryCharge = ult::batteryCharge.load(std::memory_order_acquire);
const bool charging = ult::isCharging.load(std::memory_order_acquire);
if (!ult::hideBattery && batteryCharge > 0) {
const Color batteryColorToUse = charging
? batteryChargingColor
: (batteryCharge < 20 ? batteryLowColor : batteryColor);
chargeWidth = getTextDimensions(chargeString, false, 20).first;
drawString(
chargeString, false,
tsl::cfg::FramebufferWidth - chargeWidth - 25,
y_offset, 20, batteryColorToUse
);
}
int offset = 0;
if (!ult::hidePCBTemp && pcbTemp > 0.0f) {
if (!ult::hideBattery) offset -= 5;
pcbWidth = getTextDimensions(PCB_temperatureStr, false, 20).first;
drawString(
PCB_temperatureStr, false,
tsl::cfg::FramebufferWidth + offset - pcbWidth - chargeWidth - 25,
y_offset, 20,
ult::dynamicWidgetColors
? tsl::GradientColor(pcbTemp)
: defaultTextColor
);
}
if (!ult::hideSOCTemp && socTemp > 0.0f) {
if (!ult::hidePCBTemp || !ult::hideBattery) offset -= 5;
socWidth = getTextDimensions(SOC_temperatureStr, false, 20).first;
drawString(
SOC_temperatureStr, false,
tsl::cfg::FramebufferWidth + offset - socWidth - pcbWidth - chargeWidth - 25,
y_offset, 20,
ult::dynamicWidgetColors
? tsl::GradientColor(socTemp)
: defaultTextColor
);
}
}
}
#endif
// Single unified glyph cache for all text operations
//inline static std::unordered_map<u64, Glyph> s_unifiedGlyphCache;
// Helper to select appropriate font for a character
inline std::shared_ptr<FontManager::Glyph> getOrCreateGlyph(u32 character, bool monospace, u32 fontSize) {
return FontManager::getOrCreateGlyph(character, monospace, fontSize);
}
inline stbtt_fontinfo* selectFontForCharacter(u32 character) {
return FontManager::selectFontForCharacter(character);
}
// Optimized glyph rendering
inline void renderGlyph(std::shared_ptr<FontManager::Glyph> glyph, float x, float y, const Color& color) {
if (!glyph->glyphBmp || color.a == 0) return;
const s32 xPos = static_cast<s32>(x + glyph->bounds[0]);
const s32 yPos = static_cast<s32>(y + glyph->bounds[1]);
// Quick bounds check
if (xPos >= cfg::FramebufferWidth || yPos >= cfg::FramebufferHeight ||
xPos + glyph->width <= 0 || yPos + glyph->height <= 0) return;
// Calculate clipping
const s32 startX = std::max(0, -xPos);
const s32 startY = std::max(0, -yPos);
const s32 endX = std::min(glyph->width, static_cast<s32>(cfg::FramebufferWidth) - xPos);
const s32 endY = std::min(glyph->height, static_cast<s32>(cfg::FramebufferHeight) - yPos);
// Move variable declarations outside loops
const s32 simdEnd = std::min(endX, (startX + 7) & ~7);
s32 bmpX;
uint8_t alpha;
s32 pixelX;
//Color tmpColor = {0};
// Render with optimized inner loop
const uint8_t* bmpPtr = glyph->glyphBmp + startY * glyph->width;
for (s32 bmpY = startY; bmpY < endY; ++bmpY) {
const s32 pixelY = yPos + bmpY;
bmpX = startX;
// Process 8 pixels at once
for (; bmpX < simdEnd; ++bmpX) {
alpha = bmpPtr[bmpX] >> 4;
if (alpha) {
pixelX = xPos + bmpX;
if (alpha == 0xF) {
this->setPixel(pixelX, pixelY, color);
} else {
this->setPixelBlendDst(pixelX, pixelY, Color(color.r, color.g, color.b, alpha));
}
}
}
// Process remaining pixels
for (; bmpX < endX; ++bmpX) {
alpha = bmpPtr[bmpX] >> 4;
if (alpha) {
pixelX = xPos + bmpX;
if (alpha == 0xF) {
this->setPixel(pixelX, pixelY, color);
} else {
this->setPixelBlendDst(pixelX, pixelY, Color(color.r, color.g, color.b, alpha));
}
}
}
bmpPtr += glyph->width;
}
}
/**
* @brief Adds the layer from screenshot and recording stacks
*/
inline void addScreenshotStacks(bool forceDisable = true) {
tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Screenshot);
tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Recording);
screenshotsAreDisabled.store(false, std::memory_order_release);
if (forceDisable)
screenshotsAreForceDisabled.store(false, std::memory_order_release);
}
/**
* @brief Removes the layer from screenshot and recording stacks
*/
inline void removeScreenshotStacks(bool forceDisable = true) {
tsl::hlp::viRemoveFromLayerStack(&this->m_layer, ViLayerStack_Screenshot);
tsl::hlp::viRemoveFromLayerStack(&this->m_layer, ViLayerStack_Recording);
screenshotsAreDisabled.store(true, std::memory_order_release);
if (forceDisable)
screenshotsAreForceDisabled.store(true, std::memory_order_release);
}
private:
Renderer() {
updateDrawFunction();
}
/**
* @brief Sets the opacity of the layer
*
* @param opacity Opacity
*/
inline static void setOpacity(float opacity) {
opacity = std::clamp(opacity, 0.0F, 1.0F);
Renderer::s_opacity = opacity;
}
bool m_initialized = false;
ViDisplay m_display;
ViLayer m_layer;
Event m_vsyncEvent;
NWindow m_window;
Framebuffer m_framebuffer;
void *m_currentFramebuffer = nullptr;
std::stack<ScissoringConfig> m_scissoringStack;
static inline float s_opacity = 1.0F;
/**
* @brief Get the current framebuffer address
*
* @return Framebuffer address
*/
inline void* getCurrentFramebuffer() {
return this->m_currentFramebuffer;
}
/**
* @brief Get the next framebuffer address
*
* @return Next framebuffer address
*/
inline void* getNextFramebuffer() {
return static_cast<u8*>(this->m_framebuffer.buf) + this->getNextFramebufferSlot() * this->getFramebufferSize();
}
/**
* @brief Get the framebuffer size
*
* @return Framebuffer size
*/
inline size_t getFramebufferSize() {
return this->m_framebuffer.fb_size;
}
/**
* @brief Get the number of framebuffers in use
*
* @return Number of framebuffers
*/
inline size_t getFramebufferCount() {
return this->m_framebuffer.num_fbs;
}
/**
* @brief Get the currently used framebuffer's slot
*
* @return Slot
*/
inline u8 getCurrentFramebufferSlot() {
return this->m_window.cur_slot;
}
/**
* @brief Get the next framebuffer's slot
*
* @return Next slot
*/
inline u8 getNextFramebufferSlot() {
return (this->getCurrentFramebufferSlot() + 1) % this->getFramebufferCount();
}
/**
* @brief Waits for the vsync event
*
*/
inline void waitForVSync() {
eventWait(&this->m_vsyncEvent, UINT64_MAX);
}
/**
* @brief Decodes a x and y coordinate into a offset into the swizzled framebuffer
*
* @param x X pos
* @param y Y Pos
* @return Offset
*/
inline u32 __attribute__((always_inline)) getPixelOffset(const u32 x, const u32 y) {
// Check for scissoring boundaries
if (!this->m_scissoringStack.empty()) {
const auto& currScissorConfig = this->m_scissoringStack.top();
if (x < currScissorConfig.x || y < currScissorConfig.y ||
x >= currScissorConfig.x_max ||
y >= currScissorConfig.y_max) {
return UINT32_MAX;
}
}
return ((((y & 127) >> 4) + ((x >> 5) << 3) + ((y >> 7) * offsetWidthVar)) << 9) +
((y & 8) << 5) + ((x & 16) << 3) + ((y & 6) << 4) +
((x & 8) << 1) + ((y & 1) << 3) + (x & 7);
}
/**
* @brief Initializes the renderer and layers
*
*/
void init() {
// Get the underscan pixel values for both horizontal and vertical borders
const auto [horizontalUnderscanPixels, verticalUnderscanPixels] = getUnderscanPixels();
//int horizontalUnderscanPixels = 0;
ult::useRightAlignment = (ult::parseValueFromIniSection(ult::ULTRAHAND_CONFIG_INI_PATH, ult::ULTRAHAND_PROJECT_NAME, "right_alignment") == ult::TRUE_STR);
//cfg::LayerPosX = 1280-32;
cfg::LayerPosX = 0;
cfg::LayerPosY = 0;
cfg::FramebufferWidth = ult::DefaultFramebufferWidth;
cfg::FramebufferHeight = ult::DefaultFramebufferHeight;
offsetWidthVar = (((cfg::FramebufferWidth / 2) >> 4) << 3);
ult::correctFrameSize = (cfg::FramebufferWidth == 448 && cfg::FramebufferHeight == 720); // for detecting the correct Overlay display size
if (ult::useRightAlignment && ult::correctFrameSize) {
cfg::LayerPosX = 1280-32 - horizontalUnderscanPixels;
ult::layerEdge = (1280-448);
}
cfg::LayerWidth = cfg::ScreenWidth * (float(cfg::FramebufferWidth) / float(cfg::LayerMaxWidth));
cfg::LayerHeight = cfg::ScreenHeight * (float(cfg::FramebufferHeight) / float(cfg::LayerMaxHeight));
// Apply underscanning offset
if (ult::DefaultFramebufferWidth == 1280 && ult::DefaultFramebufferHeight == 28) // for status monitor micro mode
cfg::LayerHeight += cfg::ScreenHeight/720. *verticalUnderscanPixels;
else if (ult::correctFrameSize)
cfg::LayerWidth += horizontalUnderscanPixels;
// NEW: Scale down to 1/4 size (0.5x in each dimension)
//static constexpr float scaleFactor = 0.5f;
//cfg::LayerWidth *= scaleFactor;
//cfg::LayerHeight *= scaleFactor;
if (this->m_initialized)
return;
//s32 layerZ = 0;
tsl::hlp::doWithSmSession([this, horizontalUnderscanPixels]{
ASSERT_FATAL(viInitialize(ViServiceType_Manager));
ASSERT_FATAL(viOpenDefaultDisplay(&this->m_display));
ASSERT_FATAL(viGetDisplayVsyncEvent(&this->m_display, &this->m_vsyncEvent));
ASSERT_FATAL(viCreateManagedLayer(&this->m_display, static_cast<ViLayerFlags>(0), 0, &__nx_vi_layer_id));
ASSERT_FATAL(viCreateLayer(&this->m_display, &this->m_layer));
ASSERT_FATAL(viSetLayerScalingMode(&this->m_layer, ViScalingMode_FitToLayer));
//if (s32 layerZ = 0; R_SUCCEEDED(viGetZOrderCountMax(&this->m_display, &layerZ)) && layerZ > 0)
// ASSERT_FATAL(viSetLayerZ(&this->m_layer, layerZ));
if (horizontalUnderscanPixels == 0) {
s32 layerZ = 0;
if (R_SUCCEEDED(viGetZOrderCountMax(&this->m_display, &layerZ)) && layerZ > 0) {
ASSERT_FATAL(viSetLayerZ(&this->m_layer, layerZ));
}
else {
ASSERT_FATAL(viSetLayerZ(&this->m_layer, 255)); // max value 255 as fallback
}
} else {
ASSERT_FATAL(viSetLayerZ(&this->m_layer, 34)); // 34 is the edge for underscanning
}
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Default));
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Screenshot));
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Recording));
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Arbitrary));
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_LastFrame));
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Null));
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_ApplicationForDebug));
ASSERT_FATAL(tsl::hlp::viAddToLayerStack(&this->m_layer, ViLayerStack_Lcd));
ASSERT_FATAL(viSetLayerSize(&this->m_layer, cfg::LayerWidth, cfg::LayerHeight));
ASSERT_FATAL(viSetLayerPosition(&this->m_layer, cfg::LayerPosX, cfg::LayerPosY));
ASSERT_FATAL(nwindowCreateFromLayer(&this->m_window, &this->m_layer));
ASSERT_FATAL(framebufferCreate(&this->m_framebuffer, &this->m_window, cfg::FramebufferWidth, cfg::FramebufferHeight, PIXEL_FORMAT_RGBA_4444, 2));
ASSERT_FATAL(setInitialize());
ASSERT_FATAL(this->initFonts());
setExit();
});
this->m_initialized = true;
}
/**
* @brief Exits the renderer and layer
*
*/
void exit() {
if (!this->m_initialized)
return;
// Cleanup shared font manager
FontManager::cleanup();
framebufferClose(&this->m_framebuffer);
nwindowClose(&this->m_window);
viDestroyManagedLayer(&this->m_layer);
viCloseDisplay(&this->m_display);
eventClose(&this->m_vsyncEvent);
viExit();
}
/**
* @brief Initializes Nintendo's shared fonts. Default and Extended
*
* @return Result
*/
Result initFonts() {
PlFontData stdFontData, localFontData, extFontData;
// Nintendo's default font
TSL_R_TRY(plGetSharedFontByType(&stdFontData, PlSharedFontType_Standard));
u8 *fontBuffer = reinterpret_cast<u8*>(stdFontData.address);
stbtt_InitFont(&this->m_stdFont, fontBuffer, stbtt_GetFontOffsetForIndex(fontBuffer, 0));
u64 languageCode;
if (R_SUCCEEDED(setGetSystemLanguage(&languageCode))) {
// Check if need localization font
SetLanguage setLanguage;
TSL_R_TRY(setMakeLanguage(languageCode, &setLanguage));
this->m_hasLocalFont = true;
switch (setLanguage) {
case SetLanguage_ZHCN:
case SetLanguage_ZHHANS:
TSL_R_TRY(plGetSharedFontByType(&localFontData, PlSharedFontType_ChineseSimplified));
break;
case SetLanguage_KO:
TSL_R_TRY(plGetSharedFontByType(&localFontData, PlSharedFontType_KO));
break;
case SetLanguage_ZHTW:
case SetLanguage_ZHHANT:
TSL_R_TRY(plGetSharedFontByType(&localFontData, PlSharedFontType_ChineseTraditional));
break;
default:
this->m_hasLocalFont = false;
break;
}
if (this->m_hasLocalFont) {
fontBuffer = reinterpret_cast<u8*>(localFontData.address);
stbtt_InitFont(&this->m_localFont, fontBuffer, stbtt_GetFontOffsetForIndex(fontBuffer, 0));
}
}
// Nintendo's extended font containing a bunch of icons
TSL_R_TRY(plGetSharedFontByType(&extFontData, PlSharedFontType_NintendoExt));
fontBuffer = reinterpret_cast<u8*>(extFontData.address);
stbtt_InitFont(&this->m_extFont, fontBuffer, stbtt_GetFontOffsetForIndex(fontBuffer, 0));
// Initialize the shared font manager
FontManager::initializeFonts(&this->m_stdFont, &this->m_localFont,
&this->m_extFont, this->m_hasLocalFont);
return 0;
}
/**
* @brief Start a new frame
* @warning Don't call this more than once before calling \ref endFrame
*/
inline void startFrame() {
this->m_currentFramebuffer = framebufferBegin(&this->m_framebuffer, nullptr);
}
/**
* @brief End the current frame
* @warning Don't call this before calling \ref startFrame once
*/
inline void endFrame() {
#if IS_STATUS_MONITOR_DIRECTIVE
if (isRendering) {
static u32 lastFPS = 0;
static u64 cachedIntervalNs = 1000000000ULL / 60; // Default to 60 FPS
u32 fps = TeslaFPS;
if (__builtin_expect(fps != lastFPS, 0)) {
cachedIntervalNs = (fps > 0) ? (1000000000ULL / fps) : cachedIntervalNs;
lastFPS = fps;
}
// Frame pacing before VSync
leventWait(&renderingStopEvent, cachedIntervalNs);
}
#endif
// Then hardware sync
this->waitForVSync();
framebufferEnd(&this->m_framebuffer);
this->m_currentFramebuffer = nullptr;
if (tsl::clearGlyphCacheNow.exchange(false)) {
tsl::gfx::FontManager::clearCache();
}
}
};
static std::pair<int, int> getUnderscanPixels() {
if (!ult::consoleIsDocked()) {
return {0, 0};
}
// Retrieve the TV settings
SetSysTvSettings tvSettings;
Result res = setsysGetTvSettings(&tvSettings);
if (R_FAILED(res)) {
// Handle error: return default underscan or log error
return {0, 0};
}
// The underscan value might not be a percentage, we need to interpret it correctly
const u32 underscanValue = tvSettings.underscan;
// Convert the underscan value to a fraction. Assuming 0 means no underscan and larger values represent
// greater underscan. Adjust this formula based on actual observed behavior or documentation.
const float underscanPercentage = 1.0f - (underscanValue / 100.0f);
// Original dimensions of the full 720p image (1280x720)
const float originalWidth = 1280;
const float originalHeight = 720;
// Adjust the width and height based on the underscan percentage
const float adjustedWidth = (originalWidth * underscanPercentage);
const float adjustedHeight = (originalHeight * underscanPercentage);
// Calculate the underscan in pixels (left/right and top/bottom)
const int horizontalUnderscanPixels = (originalWidth - adjustedWidth);
const int verticalUnderscanPixels = (originalHeight - adjustedHeight);
return {horizontalUnderscanPixels, verticalUnderscanPixels};
}
}
// Elements
namespace elm {
enum class TouchEvent {
Touch,
Hold,
Scroll,
Release,
None
};
/**
* @brief The top level Element of the libtesla UI library
* @note When creating your own elements, extend from this or one of it's sub classes
*/
class Element {
public:
Element() {}
virtual ~Element() {
m_clickListener = {}; // frees captures immediately
}
bool m_isTable = false; // Default to false for non-table elements
bool m_isItem = true;
u64 t_ns; // Changed from chrono::duration to nanoseconds
u8 saturation;
float progress;
s32 x, y;
s32 amplitude;
u64 m_animationStartTime; // Changed from chrono::time_point to nanoseconds
virtual bool isTable() const {
return m_isTable;
}
virtual bool isItem() const {
return m_isItem;
}
/**
* @brief Handles focus requesting
* @note This function should return the element to focus.
* When this element should be focused, return `this`.
* When one of it's child should be focused, return `this->child->requestFocus(oldFocus, direction)`
* When this element is not focusable, return `nullptr`
*
* @param oldFocus Previously focused element
* @param direction Direction in which focus moved. \ref FocusDirection::None is passed for the initial load
* @return Element to focus
*/
virtual inline Element* requestFocus(Element *oldFocus, FocusDirection direction) {
return nullptr;
}
/**
* @brief Function called when a joycon button got pressed
*
* @param keys Keys pressed in the last frame
* @return true when button press has been consumed
* @return false when button press should be passed on to the parent
*/
virtual inline bool onClick(u64 keys) {
return m_clickListener(keys);
}
/**
* @brief Called once per frame with the latest HID inputs
*
* @param keysDown Buttons pressed in the last frame
* @param keysHeld Buttons held down longer than one frame
* @param touchInput Last touch position
* @param leftJoyStick Left joystick position
* @param rightJoyStick Right joystick position
* @return Weather or not the input has been consumed
*/
virtual inline bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState joyStickPosLeft, HidAnalogStickState joyStickPosRight) {
return false;
}
/**
* @brief Function called when the element got touched
* @todo Not yet implemented
*
* @param x X pos
* @param y Y pos
* @return true when touch input has been consumed
* @return false when touch input should be passed on to the parent
*/
virtual inline bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) {
return false;
}
/**
* @brief Called once per frame to draw the element
* @warning Do not call this yourself. Use \ref Element::frame(gfx::Renderer *renderer)
*
* @param renderer Renderer
*/
virtual void draw(gfx::Renderer *renderer) = 0;
/**
* @brief Called when the underlying Gui gets created and after calling \ref Gui::invalidate() to calculate positions and boundaries of the element
* @warning Do not call this yourself. Use \ref Element::invalidate()
*
* @param parentX Parent X pos
* @param parentY Parent Y pos
* @param parentWidth Parent Width
* @param parentHeight Parent Height
*/
virtual inline void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) = 0;
/**
* @brief Draws highlighting and the element itself
* @note When drawing children of a element in \ref Element::draw(gfx::Renderer *renderer), use `this->child->frame(renderer)` instead of calling draw directly
*
* @param renderer
*/
void inline frame(gfx::Renderer *renderer) {
if (this->m_focused) {
renderer->enableScissoring(0, ult::activeHeaderHeight, tsl::cfg::FramebufferWidth, tsl::cfg::FramebufferHeight-73-ult::activeHeaderHeight);
this->drawFocusBackground(renderer);
this->drawHighlight(renderer);
renderer->disableScissoring();
}
this->draw(renderer);
}
/**
* @brief Forces a layout recreation of a element
*
*/
void inline invalidate() {
const auto& parent = this->getParent();
if (parent == nullptr)
this->layout(0, 0, cfg::FramebufferWidth, cfg::FramebufferHeight);
else
this->layout(ELEMENT_BOUNDS(parent));
}
/**
* @brief Shake the highlight in the given direction to signal that the focus cannot move there
*
* @param direction Direction to shake highlight in
*/
void inline shakeHighlight(FocusDirection direction) {
this->m_highlightShaking = true;
this->m_highlightShakingDirection = direction;
this->m_highlightShakingStartTime = armTicksToNs(armGetSystemTick()); // Changed
if (direction != FocusDirection::None && m_isItem) {
triggerRumbleClick.store(true, std::memory_order_release);
triggerWallSound.store(true, std::memory_order_release);
}
}
/**
* @brief Triggers the blue click animation to signal a element has been clicked on
*
*/
void inline triggerClickAnimation() {
this->m_clickAnimationProgress = tsl::style::ListItemHighlightLength;
this->m_animationStartTime = armTicksToNs(armGetSystemTick()); // Changed
}
/**
* @brief Resets the click animation progress, canceling the animation
*/
void inline resetClickAnimation() {
this->m_clickAnimationProgress = 0;
}
/**
* @brief Draws the blue highlight animation when clicking on a button
* @note Override this if you have a element that e.g requires a non-rectangular animation or a different color
*
* @param renderer Renderer
*/
virtual void drawClickAnimation(gfx::Renderer *renderer) {
if (!m_isItem)
return;
if (ult::useSelectionBG) {
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(this->getX() + x + 4, this->getY() + y, this->getWidth() - 8, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION
else
renderer->drawRect(this->getX() + x + 4, this->getY() + y, this->getWidth() - 8, this->getHeight(), aWithOpacity(selectionBGColor));
}
saturation = tsl::style::ListItemHighlightSaturation * (float(this->m_clickAnimationProgress) / float(tsl::style::ListItemHighlightLength));
Color animColor = {0xF,0xF,0xF,0xF};
if (invertBGClickColor) {
const u8 inverted = 15-saturation;
animColor = {inverted, inverted, inverted, selectionBGColor.a};
} else {
animColor = {saturation, saturation, saturation, selectionBGColor.a};
}
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(ELEMENT_BOUNDS(this), aWithOpacity(animColor));
else
renderer->drawRect(ELEMENT_BOUNDS(this), aWithOpacity(animColor));
// Cache time calculation - only compute once
static u64 lastTimeUpdate = 0;
static double cachedProgress = 0.0;
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
// Only recalculate progress if enough time has passed (reduce computation frequency)
if (currentTime_ns - lastTimeUpdate > 16666666) { // ~60 FPS update rate
//double time_seconds = currentTime_ns / 1000000000.0;
cachedProgress = (std::cos(2.0 * ult::_M_PI * std::fmod(currentTime_ns / 1000000000.0 - 0.25, 1.0)) + 1.0) / 2.0;
lastTimeUpdate = currentTime_ns;
}
progress = cachedProgress;
Color clickColor1 = highlightColor1;
Color clickColor2 = clickColor;
if (progress >= 0.5) {
clickColor1 = clickColor;
clickColor2 = highlightColor2;
}
// Combine color interpolation into single calculation
highlightColor = {
static_cast<u8>((clickColor1.r - clickColor2.r) * progress + clickColor2.r),
static_cast<u8>((clickColor1.g - clickColor2.g) * progress + clickColor2.g),
static_cast<u8>((clickColor1.b - clickColor2.b) * progress + clickColor2.b),
0xF
};
x = 0;
y = 0;
if (this->m_highlightShaking) {
t_ns = currentTime_ns - this->m_highlightShakingStartTime;
if (t_ns >= 100000000) // 100ms in nanoseconds
this->m_highlightShaking = false;
else {
// Use faster random generation if available, or cache amplitude
static int cachedAmplitude = std::rand() % 5 + 5;
if (t_ns % 10000000 == 0) // Update amplitude less frequently
cachedAmplitude = std::rand() % 5 + 5;
amplitude = cachedAmplitude;
const int shakeOffset = shakeAnimation(t_ns, amplitude);
switch (this->m_highlightShakingDirection) {
case FocusDirection::Up: y = -shakeOffset; break;
case FocusDirection::Down: y = shakeOffset; break;
case FocusDirection::Left: x = -shakeOffset; break;
case FocusDirection::Right: x = shakeOffset; break;
default: break;
}
x = std::clamp(x, -amplitude, amplitude);
y = std::clamp(y, -amplitude, amplitude);
}
}
renderer->drawBorderedRoundedRect(this->getX() + x, this->getY() + y, this->getWidth() +4, this->getHeight(), 5, 5, a(highlightColor));
}
/**
* @brief Draws the back background when a element is highlighted
* @note Override this if you have a element that e.g requires a non-rectangular focus
*
* @param renderer Renderer
*/
virtual void drawFocusBackground(gfx::Renderer *renderer) {
if (this->m_clickAnimationProgress > 0) {
this->drawClickAnimation(renderer);
// Single time calculation and direct millisecond conversion
//const double elapsed_ms = (armTicksToNs(armGetSystemTick()) - this->m_animationStartTime) * 0.000001; // Direct conversion
// Direct calculation without intermediate multiplication
this->m_clickAnimationProgress = tsl::style::ListItemHighlightLength * (1.0f - ((armTicksToNs(armGetSystemTick()) - this->m_animationStartTime) * 0.000001) * 0.002f); // 0.002f = 1/500
// Clamp to 0 in one operation
if (this->m_clickAnimationProgress < 0) {
this->m_clickAnimationProgress = 0;
}
}
}
/**
* @brief Draws the blue boarder when a element is highlighted
* @note Override this if you have a element that e.g requires a non-rectangular focus
*
* @param renderer Renderer
*/
virtual void drawHighlight(gfx::Renderer *renderer) { // CUSTOM MODIFICATION start
if (!m_isItem)
return;
// Use cached time calculation from drawClickAnimation if possible
static u64 lastHighlightUpdate = 0;
static double cachedHighlightProgress = 0.0;
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
// Update progress at 60 FPS rate with high-precision calculation
if (currentTime_ns - lastHighlightUpdate > 16666666) {
// High precision time calculation - matches original timing exactly
//double time_seconds = currentTime_ns * 0.000000001; // Direct conversion like original
// Match original calculation exactly but with higher precision
cachedHighlightProgress = (std::cos(2.0 * ult::_M_PI * std::fmod(currentTime_ns * 0.000000001 - 0.25, 1.0)) + 1.0) * 0.5;
lastHighlightUpdate = currentTime_ns;
}
progress = cachedHighlightProgress;
// Cache the interpreter state check result to avoid atomic load overhead
static bool lastInterpreterState = false;
static u64 lastInterpreterCheck = 0;
if (currentTime_ns - lastInterpreterCheck > 50000000) { // Check every 50ms
lastInterpreterState = ult::runningInterpreter.load(std::memory_order_acquire);
lastInterpreterCheck = currentTime_ns;
}
if (lastInterpreterState) {
// High precision floating point color interpolation for interpreter colors
highlightColor = {
static_cast<u8>(highlightColor4.r + (highlightColor3.r - highlightColor4.r) * progress + 0.5),
static_cast<u8>(highlightColor4.g + (highlightColor3.g - highlightColor4.g) * progress + 0.5),
static_cast<u8>(highlightColor4.b + (highlightColor3.b - highlightColor4.b) * progress + 0.5),
0xF
};
} else {
// High precision floating point color interpolation for normal colors
highlightColor = {
static_cast<u8>(highlightColor2.r + (highlightColor1.r - highlightColor2.r) * progress + 0.5),
static_cast<u8>(highlightColor2.g + (highlightColor1.g - highlightColor2.g) * progress + 0.5),
static_cast<u8>(highlightColor2.b + (highlightColor1.b - highlightColor2.b) * progress + 0.5),
0xF
};
}
x = 0;
y = 0;
if (this->m_highlightShaking) {
t_ns = currentTime_ns - this->m_highlightShakingStartTime;
if (t_ns >= 100000000) // 100ms in nanoseconds
this->m_highlightShaking = false;
else {
// Use cached amplitude like in drawClickAnimation
static int cachedAmplitude = std::rand() % 5 + 5;
if (t_ns % 10000000 == 0)
cachedAmplitude = std::rand() % 5 + 5;
amplitude = cachedAmplitude;
const int shakeOffset = shakeAnimation(t_ns, amplitude);
switch (this->m_highlightShakingDirection) {
case FocusDirection::Up: y = -shakeOffset; break;
case FocusDirection::Down: y = shakeOffset; break;
case FocusDirection::Left: x = -shakeOffset; break;
case FocusDirection::Right: x = shakeOffset; break;
default: break;
}
x = std::clamp(x, -amplitude, amplitude);
y = std::clamp(y, -amplitude, amplitude);
}
}
if (this->m_clickAnimationProgress == 0) {
if (ult::useSelectionBG) {
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(this->getX() + x + 4, this->getY() + y, this->getWidth() - 12 +4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION
else
renderer->drawRect(this->getX() + x + 4, this->getY() + y, this->getWidth() - 12 +4, this->getHeight(), aWithOpacity(selectionBGColor));
}
#if IS_LAUNCHER_DIRECTIVE
// Determine the active percentage to use
const float activePercentage = ult::displayPercentage.load(std::memory_order_acquire);
if (activePercentage > 0){
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(this->getX() + x + 4, this->getY() + y, (this->getWidth()- 12 +4)*(activePercentage * 0.01f), this->getHeight(), aWithOpacity(progressColor)); // Direct percentage conversion
else
renderer->drawRect(this->getX() + x + 4, this->getY() + y, (this->getWidth()- 12 +4)*(activePercentage * 0.01f), this->getHeight(), aWithOpacity(progressColor)); // Direct percentage conversion
}
#endif
renderer->drawBorderedRoundedRect(this->getX() + x, this->getY() + y, this->getWidth() +4, this->getHeight(), 5, 5, a(highlightColor));
}
ult::onTrackBar.store(false, std::memory_order_release);
}
/**
* @brief Sets the boundaries of this view
*
* @param x Start X pos
* @param y Start Y pos
* @param width Width
* @param height Height
*/
inline void setBoundaries(s32 x, s32 y, s32 width, s32 height) {
this->m_x = x;
this->m_y = y;
this->m_width = width;
this->m_height = height;
}
/**
* @brief Adds a click listener to the element
*
* @param clickListener Click listener called with keys that were pressed last frame. Callback should return true if keys got consumed
*/
virtual inline void setClickListener(std::function<bool(u64 keys)> clickListener) {
this->m_clickListener = clickListener;
}
/**
* @brief Gets the element's X position
*
* @return X position
*/
inline s32 getX() { return this->m_x; }
/**
* @brief Gets the element's Y position
*
* @return Y position
*/
inline s32 getY() { return this->m_y; }
/**
* @brief Gets the element's Width
*
* @return Width
*/
inline s32 getWidth() { return this->m_width; }
/**
* @brief Gets the element's Height
*
* @return Height
*/
inline s32 getHeight() { return this->m_height; }
inline s32 getTopBound() { return this->getY(); }
inline s32 getLeftBound() { return this->getX(); }
inline s32 getRightBound() { return this->getX() + this->getWidth(); }
inline s32 getBottomBound() { return this->getY() + this->getHeight(); }
/**
* @brief Check if the coordinates are in the elements bounds
*
* @return true if coordinates are in bounds, false otherwise
*/
bool inBounds(s32 touchX, s32 touchY) {
//static u32 ult::layerEdge = cfg::LayerPosX == 0 ? 0 : (1280-448);
return touchX >= this->getLeftBound() + int(ult::layerEdge) && touchX <= this->getRightBound() + int(ult::layerEdge) && touchY >= this->getTopBound() && touchY <= this->getBottomBound();
}
/**
* @brief Sets the element's parent
* @note This is required to handle focus and button downpassing properly
*
* @param parent Parent
*/
inline void setParent(Element *parent) { this->m_parent = parent; }
/**
* @brief Get the element's parent
*
* @return Parent
*/
inline Element* getParent() { return this->m_parent; }
virtual inline std::vector<Element*> getChildren() const {
return {}; // Return empty vector for simplicity
}
/**
* @brief Marks this element as focused or unfocused to draw the highlight
*
* @param focused Focused
*/
virtual inline void setFocused(bool focused) {
this->m_focused = focused;
this->m_clickAnimationProgress = 0;
}
virtual bool matchesJumpCriteria(const std::string& jumpText, const std::string& jumpValue, bool contains) const {
return false; // Default implementation for non-ListItem elements
}
static InputMode getInputMode() { return Element::s_inputMode; }
static void setInputMode(InputMode mode) { Element::s_inputMode = mode; }
protected:
constexpr static inline auto a = &gfx::Renderer::a;
constexpr static inline auto aWithOpacity = &gfx::Renderer::aWithOpacity;
bool m_focused = false;
u8 m_clickAnimationProgress = 0;
// Highlight shake animation
bool m_highlightShaking = false;
u64 m_highlightShakingStartTime; // Changed from chrono::time_point to nanoseconds
FocusDirection m_highlightShakingDirection;
static inline InputMode s_inputMode;
/**
* @brief Shake animation calculation based on a damped sine wave
*
* @param t_ns Passed time in nanoseconds
* @param a Amplitude
* @return Damped sine wave output
*/
inline int shakeAnimation(u64 t_ns, float a) {
//float w = 0.2F;
//float tau = 0.05F;
// Convert nanoseconds to microseconds for the calculation
const int t_us = t_ns / 1000;
return roundf(a * exp(-(0.05F * t_us) * sin(0.2F * t_us)));
}
private:
friend class Gui;
s32 m_x = 0, m_y = 0, m_width = 0, m_height = 0;
Element *m_parent = nullptr;
std::vector<Element*> m_children;
std::function<bool(u64 keys)> m_clickListener = [](u64) { return false; };
};
/**
* @brief A Element that exposes the renderer directly to draw custom views easily
*/
class CustomDrawer : public Element {
public:
/**
* @brief Constructor
* @note This element should only be used to draw static things the user cannot interact with e.g info text, images, etc.
*
* @param renderFunc Callback that will be called once every frame to draw this view
*/
CustomDrawer(std::function<void(gfx::Renderer* r, s32 x, s32 y, s32 w, s32 h)> renderFunc) : Element(), m_renderFunc(renderFunc) {
m_isItem = false;
m_isTable = true;
}
virtual ~CustomDrawer() {}
virtual void draw(gfx::Renderer* renderer) override {
//renderer->enableScissoring(ELEMENT_BOUNDS(this));
this->m_renderFunc(renderer, ELEMENT_BOUNDS(this));
//renderer->disableScissoring();
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
}
private:
std::function<void(gfx::Renderer*, s32 x, s32 y, s32 w, s32 h)> m_renderFunc;
};
//#endif
/**
* @brief A Element that exposes the renderer directly to draw custom views easily
*/
class TableDrawer : public Element {
public:
TableDrawer(std::function<void(gfx::Renderer* r, s32 x, s32 y, s32 w, s32 h)> renderFunc, bool _hideTableBackground, size_t _endGap, bool _isScrollable = false)
: Element(), m_renderFunc(renderFunc), hideTableBackground(_hideTableBackground), endGap(_endGap), isScrollable(_isScrollable) {
m_isTable = isScrollable; // Mark this element as a table
m_isItem = false;
}
virtual ~TableDrawer() {}
virtual void draw(gfx::Renderer* renderer) override {
renderer->enableScissoring(0, 88, tsl::cfg::FramebufferWidth, tsl::cfg::FramebufferHeight - 73 - 97 +2+5);
if (!hideTableBackground)
renderer->drawRoundedRect(this->getX() + 4+2, this->getY()-4-1, this->getWidth() +2 + 1, this->getHeight() + 20 - endGap+2, 10.0, aWithOpacity(tableBGColor));
m_renderFunc(renderer, this->getX() + 4, this->getY(), this->getWidth() + 4, this->getHeight());
renderer->disableScissoring();
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {}
virtual bool onClick(u64 keys) {
return false;
}
virtual Element* requestFocus(Element *oldFocus, FocusDirection direction) override {
return nullptr;
}
private:
std::function<void(gfx::Renderer*, s32 x, s32 y, s32 w, s32 h)> m_renderFunc;
bool hideTableBackground = false;
size_t endGap = 3;
bool isScrollable = false;
};
#if IS_LAUNCHER_DIRECTIVE
// Simple utility function to draw the dynamic "Ultra" part of the logo
static s32 drawDynamicUltraText(gfx::Renderer* renderer, s32 startX, s32 y, u32 fontSize,
const tsl::Color& staticColor, bool useNotificationMethod = false) {
static constexpr double cycleDuration = 1.6;
s32 currentX = startX;
if (ult::useDynamicLogo) {
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
const double currentTimeCount = static_cast<double>(currentTime_ns) / 1000000000.0;
const double timeBase = std::fmod(currentTimeCount, cycleDuration);
const double waveScale = 2.0 * ult::_M_PI / cycleDuration;
static constexpr double phaseShift = ult::_M_PI / 2.0;
float countOffset = 0;
for (const char letter : ult::SPLIT_PROJECT_NAME_1) {
const double wavePhase = waveScale * (timeBase + static_cast<double>(countOffset));
const double rawProgress = std::cos(wavePhase - phaseShift);
const double normalizedProgress = (rawProgress + 1.0) * 0.5;
const double smoothedProgress = normalizedProgress * normalizedProgress * (3.0 - 2.0 * normalizedProgress);
const double ultraSmoothProgress = smoothedProgress * smoothedProgress * (3.0 - 2.0 * smoothedProgress);
const double blend = std::max(0.0, std::min(1.0, ultraSmoothProgress));
const tsl::Color highlightColor = {
static_cast<u8>(dynamicLogoRGB1.r + (dynamicLogoRGB2.r - dynamicLogoRGB1.r) * blend + 0.5),
static_cast<u8>(dynamicLogoRGB1.g + (dynamicLogoRGB2.g - dynamicLogoRGB1.g) * blend + 0.5),
static_cast<u8>(dynamicLogoRGB1.b + (dynamicLogoRGB2.b - dynamicLogoRGB1.b) * blend + 0.5),
15
};
const std::string letterStr(1, letter);
if (useNotificationMethod) {
//const auto [letterWidth, letterHeight] = renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, highlightColor);
currentX += renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, highlightColor).first;
} else {
currentX += renderer->drawString(letterStr, false, currentX, y, fontSize, highlightColor).first;
}
countOffset -= static_cast<float>(cycleDuration / 8.0);
}
} else {
// Static rendering
for (const char letter : ult::SPLIT_PROJECT_NAME_1) {
const std::string letterStr(1, letter);
if (useNotificationMethod) {
//const auto [letterWidth, letterHeight] = renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, staticColor);
currentX += renderer->drawNotificationString(letterStr, false, currentX, y, fontSize, staticColor).first;
} else {
currentX += renderer->drawString(letterStr, false, currentX, y, fontSize, staticColor).first;
}
}
}
return currentX;
}
// Utility function to calculate width of the Ultra text (for notification centering)
static s32 calculateUltraTextWidth(gfx::Renderer* renderer, u32 fontSize, bool useNotificationMethod = false) {
s32 totalWidth = 0;
if (ult::useDynamicLogo) {
// Calculate width by measuring each character for dynamic rendering
for (const char letter : ult::SPLIT_PROJECT_NAME_1) {
const std::string letterStr(1, letter);
if (useNotificationMethod) {
//const auto [lw, lh] = renderer->getNotificationTextDimensions(letterStr, false, fontSize);
totalWidth += renderer->getNotificationTextDimensions(letterStr, false, fontSize).first;
} else {
//const auto [lw, lh] = renderer->getTextDimensions(letterStr, false, fontSize);
totalWidth += renderer->getTextDimensions(letterStr, false, fontSize).first;
}
}
} else {
// Static rendering - measure the whole string at once
if (useNotificationMethod) {
//const auto [uw, uh] = renderer->getNotificationTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize);
totalWidth = renderer->getNotificationTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize).first;
} else {
//const auto [uw, uh] = renderer->getTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize);
totalWidth = renderer->getTextDimensions(ult::SPLIT_PROJECT_NAME_1, false, fontSize).first;
}
}
return totalWidth;
}
#endif
struct TopCache {
std::string title;
std::string subtitle;
tsl::Color titleColor{0xF, 0xF, 0xF, 0xF}; // white by default
bool widgetDrawn = false;
bool useDynamicLogo = false;
bool disabled = false;
};
struct BottomCache {
std::string bottomText;
float backWidth = 0.0f;
float selectWidth = 0.0f;
float nextPageWidth = 0.0f;
bool disabled = false;
};
// Global or namespace-level variable
inline TopCache g_cachedTop;
inline BottomCache g_cachedBottom;
inline std::atomic<bool> g_disableMenuCacheOnReturn = false;
/**
* @brief The base frame which can contain another view
*
*/
class OverlayFrame : public Element {
public:
/**
* @brief Constructor
*
* @param title Name of the Overlay drawn bolt at the top
* @param subtitle Subtitle drawn bellow the title e.g version number
*/
std::string m_title;
std::string m_subtitle;
bool m_noClickableItems;
#if IS_LAUNCHER_DIRECTIVE
std::string m_menuMode; // CUSTOM MODIFICATION
std::string m_colorSelection; // CUSTOM MODIFICATION
std::string m_pageLeftName; // CUSTOM MODIFICATION
std::string m_pageRightName; // CUSTOM MODIFICATION
tsl::Color titleColor = {0xF,0xF,0xF,0xF};
float letterWidth;
#endif
#if USING_WIDGET_DIRECTIVE
bool m_showWidget = false;
#endif
float x, y;
int offset, y_offset;
int fontSize;
#if IS_LAUNCHER_DIRECTIVE
OverlayFrame(const std::string& title, const std::string& subtitle, const bool& _noClickableItems=false, const std::string& menuMode = "", const std::string& colorSelection = "", const std::string& pageLeftName = "", const std::string& pageRightName = "")
: Element(), m_title(title), m_subtitle(subtitle), m_noClickableItems(_noClickableItems), m_menuMode(menuMode), m_colorSelection(colorSelection), m_pageLeftName(pageLeftName), m_pageRightName(pageRightName) {
#else
OverlayFrame(const std::string& title, const std::string& subtitle, const bool& _noClickableItems=false)
: Element(), m_title(title), m_subtitle(subtitle), m_noClickableItems(_noClickableItems) {
#endif
ult::activeHeaderHeight = 97;
ult::loadWallpaperFileWhenSafe();
m_isItem = false;
disableSound.store(false, std::memory_order_release);
}
~OverlayFrame() {
delete m_contentElement;
// Check if returning from a list that disabled caching
if (g_disableMenuCacheOnReturn.exchange(false, std::memory_order_acq_rel)) {
g_cachedTop.disabled = true;
g_cachedBottom.disabled = true;
}
}
#if USING_FPS_INDICATOR_DIRECTIVE
// Function to calculate FPS
inline float updateFPS(double currentTimeCount) {
static double lastUpdateTime = currentTimeCount;
static int frameCount = 0;
static float fps = 0.0f;
++frameCount;
const double elapsedTime = currentTimeCount - lastUpdateTime;
if (elapsedTime >= 1.0) { // Update FPS every second
fps = frameCount / static_cast<float>(elapsedTime);
lastUpdateTime = currentTimeCount;
frameCount = 0;
}
return fps;
}
#endif
// CUSTOM SECTION START
void draw(gfx::Renderer *renderer) override {
if (!ult::themeIsInitialized.exchange(true, std::memory_order_acq_rel)) {
tsl::initializeThemeVars();
}
renderer->fillScreen(a(defaultBackgroundColor));
renderer->drawWallpaper();
y = 50;
offset = 0;
#if IS_LAUNCHER_DIRECTIVE
// Current interpreter state (atomic<bool>)
const bool interpreterIsRunningNow = ult::runningInterpreter.load(std::memory_order_acquire) && (ult::downloadPercentage.load(std::memory_order_acquire) != -1 || ult::unzipPercentage.load(std::memory_order_acquire) != -1 || ult::copyPercentage.load(std::memory_order_acquire) != -1);
if (m_noClickableItems != ult::noClickableItems.load(std::memory_order_acquire)) {
ult::noClickableItems.store(m_noClickableItems, std::memory_order_release);
}
const bool isUltrahandMenu = (m_title == ult::CAPITAL_ULTRAHAND_PROJECT_NAME &&
m_subtitle.find("Ultrahand Package") == std::string::npos &&
m_subtitle.find("Ultrahand Script") == std::string::npos);
// Determine if we should use cached data (first frame of new overlay)
const bool useCachedTop = !g_cachedTop.disabled &&
!g_cachedTop.title.empty() &&
(g_cachedTop.title != m_title || g_cachedTop.subtitle != m_subtitle);
// Use cached or current data for rendering
const std::string& renderTitle = useCachedTop ? g_cachedTop.title : m_title;
const std::string& renderSubtitle = useCachedTop ? g_cachedTop.subtitle : m_subtitle;
const tsl::Color& renderTitleColor = useCachedTop ? g_cachedTop.titleColor : titleColor;
const bool renderUseDynamicLogo = useCachedTop ? g_cachedTop.useDynamicLogo : ult::useDynamicLogo;
const bool renderIsUltrahandMenu = (renderTitle == ult::CAPITAL_ULTRAHAND_PROJECT_NAME &&
renderSubtitle.find("Ultrahand Package") == std::string::npos &&
renderSubtitle.find("Ultrahand Script") == std::string::npos);
if (renderIsUltrahandMenu) {
#if USING_WIDGET_DIRECTIVE
if (useCachedTop) {
if (g_cachedTop.widgetDrawn) {
renderer->drawWidget();
}
} else {
renderer->drawWidget();
}
#endif
if (ult::touchingMenu.load(std::memory_order_acquire) && ult::inMainMenu.load(std::memory_order_acquire)) {
renderer->drawRoundedRect(0.0f + 7, 12.0f, 245.0f - 13, 73.0f, 10.0f, a(clickColor));
}
x = 20;
fontSize = 42;
offset = 6;
if (renderUseDynamicLogo) {
x = drawDynamicUltraText(renderer, x, y + offset, fontSize, logoColor1, false);
} else {
for (const char letter : ult::SPLIT_PROJECT_NAME_1) {
const std::string letterStr(1, letter);
x += renderer->drawString(letterStr, false, x, y + offset, fontSize, logoColor1).first;
}
}
renderer->drawString(ult::SPLIT_PROJECT_NAME_2, false, x, y + offset, fontSize, (logoColor2));
} else {
if (useCachedTop) {
if (g_cachedTop.widgetDrawn) {
renderer->drawWidget();
}
} else {
if (m_showWidget) {
renderer->drawWidget();
}
}
x = 20;
y = 52 - 2;
fontSize = 32;
if (renderSubtitle.find("Ultrahand Script") != std::string::npos) {
renderer->drawString(renderTitle, false, x, y, fontSize, (defaultScriptColor));
} else {
tsl::Color drawColor = defaultPackageColor; // Default to green
if (!useCachedTop) {
// Calculate color only if not using cache
if (!m_colorSelection.empty()) {
const char firstChar = m_colorSelection[0];
const size_t len = m_colorSelection.length();
// Fast path: check first char + length for unique combinations
switch (firstChar) {
case 'g': // green
if (len == 5 && m_colorSelection.compare("green") == 0) {
drawColor = {0x0, 0xF, 0x0, 0xF};
}
break;
case 'r': // red
if (len == 3 && m_colorSelection.compare("red") == 0) {
drawColor = RGB888("#F7253E");
}
break;
case 'b': // blue
if (len == 4 && m_colorSelection.compare("blue") == 0) {
drawColor = {0x7, 0x7, 0xF, 0xF};
}
break;
case 'y': // yellow
if (len == 6 && m_colorSelection.compare("yellow") == 0) {
drawColor = {0xF, 0xF, 0x0, 0xF};
}
break;
case 'o': // orange
if (len == 6 && m_colorSelection.compare("orange") == 0) {
drawColor = {0xFF, 0xA5, 0x00, 0xFF};
}
break;
case 'p': // pink or purple
if (len == 4 && m_colorSelection.compare("pink") == 0) {
drawColor = {0xFF, 0x69, 0xB4, 0xFF};
} else if (len == 6 && m_colorSelection.compare("purple") == 0) {
drawColor = {0x80, 0x00, 0x80, 0xFF};
}
break;
case 'w': // white
if (len == 5 && m_colorSelection.compare("white") == 0) {
drawColor = {0xF, 0xF, 0xF, 0xF};
}
break;
case '#': // hex color
if (len == 7 && ult::isValidHexColor(m_colorSelection.substr(1))) {
drawColor = RGB888(m_colorSelection.substr(1));
}
break;
}
}
titleColor = drawColor;
} else {
drawColor = renderTitleColor;
}
renderer->drawString(renderTitle, false, x, y, fontSize, (drawColor));
y += 2;
}
}
static const std::vector<std::string> specialChars2 = {""};
if (renderTitle == ult::CAPITAL_ULTRAHAND_PROJECT_NAME) {
renderer->drawStringWithColoredSections(ult::versionLabel, false, specialChars2, 20, y+25, 15, (bannerVersionTextColor), textSeparatorColor);
} else {
std::string subtitle = renderSubtitle;
const size_t pos = subtitle.find("?Ultrahand Script");
if (pos != std::string::npos) {
subtitle.erase(pos, 17); // "?Ultrahand Script".length() = 17
}
renderer->drawStringWithColoredSections(subtitle, false, specialChars2, 20, y+23, 15, (bannerVersionTextColor), textSeparatorColor);
}
// Update top cache after rendering for next frame
g_cachedTop.title = m_title;
g_cachedTop.subtitle = m_subtitle;
g_cachedTop.titleColor = titleColor;
g_cachedTop.useDynamicLogo = ult::useDynamicLogo;
// Store whether widget was ACTUALLY drawn this frame
if (isUltrahandMenu) {
g_cachedTop.widgetDrawn = true; // Ultrahand menu always shows widget
} else {
g_cachedTop.widgetDrawn = m_showWidget; // Other menus use m_showWidget
}
g_cachedTop.disabled = false;
#else
// NON-LAUNCHER PATH WITH CACHE SUPPORT
if (m_noClickableItems != ult::noClickableItems.load(std::memory_order_acquire)) {
ult::noClickableItems.store(m_noClickableItems, std::memory_order_release);
}
// Determine if we should use cached data (first frame of new overlay)
const bool useCachedTop = !g_cachedTop.disabled &&
!g_cachedTop.title.empty() &&
(g_cachedTop.title != m_title || g_cachedTop.subtitle != m_subtitle);
// Use cached or current data for rendering
const std::string& renderTitle = useCachedTop ? g_cachedTop.title : m_title;
const std::string& renderSubtitle = useCachedTop ? g_cachedTop.subtitle : m_subtitle;
#if USING_WIDGET_DIRECTIVE
if (useCachedTop) {
if (g_cachedTop.widgetDrawn) {
renderer->drawWidget();
}
} else {
if (m_showWidget)
renderer->drawWidget();
}
#endif
renderer->drawString(renderTitle, false, 20, 52-2, 32, (defaultOverlayColor));
renderer->drawString(renderSubtitle, false, 20, y+2+23+2, 15, (bannerVersionTextColor));
// Update top cache after rendering for next frame
g_cachedTop.title = m_title;
g_cachedTop.subtitle = m_subtitle;
g_cachedTop.titleColor = {0xF, 0xF, 0xF, 0xF};
#if USING_WIDGET_DIRECTIVE
g_cachedTop.widgetDrawn = m_showWidget;
#else
g_cachedTop.widgetDrawn = false;
#endif
g_cachedTop.useDynamicLogo = false;
g_cachedTop.disabled = false;
#endif
renderer->drawRect(15, tsl::cfg::FramebufferHeight - 73, tsl::cfg::FramebufferWidth - 30, 1, a(bottomSeparatorColor));
// Compute gap width once from GAP_1 and derive halfGap
const float gapWidth = renderer->getTextDimensions(ult::GAP_1, false, 23).first;
// Calculate text widths for buttons depending on launch mode and interpreter state
#if IS_LAUNCHER_DIRECTIVE
const float backTextWidth = renderer->getTextDimensions(
"\uE0E1" + ult::GAP_2 + (!interpreterIsRunningNow ? ult::BACK : ult::HIDE), false, 23).first;
const float selectTextWidth = renderer->getTextDimensions(
"\uE0E0" + ult::GAP_2 + (!interpreterIsRunningNow ? ult::OK : ult::CANCEL), false, 23).first;
#else
const float backTextWidth = renderer->getTextDimensions(
"\uE0E1" + ult::GAP_2 + ult::BACK, false, 23).first;
const float selectTextWidth = renderer->getTextDimensions(
"\uE0E0" + ult::GAP_2 + ult::OK, false, 23).first;
#endif
const float _halfGap = gapWidth / 2.0f;
if (_halfGap != ult::halfGap.load(std::memory_order_acquire))
ult::halfGap.store(_halfGap, std::memory_order_release);
// Total button widths include half-gap padding on both sides
const float _backWidth = backTextWidth + gapWidth;
if (_backWidth != ult::backWidth.load(std::memory_order_acquire))
ult::backWidth.store(_backWidth, std::memory_order_release);
const float _selectWidth = selectTextWidth + gapWidth;
if (_selectWidth != ult::selectWidth.load(std::memory_order_acquire))
ult::selectWidth.store(_selectWidth, std::memory_order_release);
// Set initial button position
static constexpr float buttonStartX = 30;
const float buttonY = static_cast<float>(cfg::FramebufferHeight - 73 + 1);
// Draw back button if touched
if (ult::touchingBack) {
renderer->drawRoundedRect(buttonStartX+2 - _halfGap, buttonY, _backWidth-1, 73.0f, 10.0f, a(clickColor));
}
// Draw select button (to the right of back) if touched
if (ult::touchingSelect.load(std::memory_order_acquire) && !m_noClickableItems) {
renderer->drawRoundedRect(buttonStartX+2 - _halfGap + _backWidth+1, buttonY,
_selectWidth-2, 73.0f, 10.0f, a(clickColor));
}
#if IS_LAUNCHER_DIRECTIVE
// Handle optional next page button when in launcher mode and appropriate conditions are met
if (!interpreterIsRunningNow && (ult::inMainMenu.load(std::memory_order_acquire) ||
!m_pageLeftName.empty() || !m_pageRightName.empty())) {
// Construct next-page label inline without creating temporary strings
const float _nextPageWidth = renderer->getTextDimensions(
!m_pageLeftName.empty() ? ("\uE0ED" + ult::GAP_2 + m_pageLeftName) :
!m_pageRightName.empty() ? ("\uE0EE" + ult::GAP_2 + m_pageRightName) :
(ult::inMainMenu.load(std::memory_order_acquire) ?
(((m_menuMode.compare("packages") == 0) ?
(ult::usePageSwap ? "\uE0EE" : "\uE0ED") :
(ult::usePageSwap ? "\uE0ED" : "\uE0EE")) +
ult::GAP_2 + (ult::inOverlaysPage.load(std::memory_order_acquire) ?
ult::PACKAGES : ult::OVERLAYS_ABBR)) :
""),
false, 23).first + gapWidth;
if (_nextPageWidth != ult::nextPageWidth.load(std::memory_order_acquire))
ult::nextPageWidth.store(_nextPageWidth, std::memory_order_release);
// Draw next-page button if touched
if (ult::touchingNextPage.load(std::memory_order_acquire)) {
float nextX = buttonStartX+2 - _halfGap + _backWidth +1;
if (!m_noClickableItems)
nextX += _selectWidth;
renderer->drawRoundedRect(nextX, buttonY,
_nextPageWidth-2,
73.0f, 10.0f, a(clickColor));
}
}
#endif
#if IS_LAUNCHER_DIRECTIVE
std::string currentBottomLine =
"\uE0E1" + ult::GAP_2 +
(interpreterIsRunningNow ? ult::HIDE : ult::BACK) + ult::GAP_1 +
(!m_noClickableItems && !interpreterIsRunningNow
? "\uE0E0" + ult::GAP_2 + ult::OK + ult::GAP_1
: "") +
(interpreterIsRunningNow
? "\uE0E5" + ult::GAP_2 + ult::CANCEL + ult::GAP_1
: "") +
(!interpreterIsRunningNow
? (!ult::usePageSwap
? ((m_menuMode.compare("packages") == 0)
? "\uE0ED" + ult::GAP_2 + ult::OVERLAYS_ABBR
: (m_menuMode.compare("overlays") == 0)
? "\uE0EE" + ult::GAP_2 + ult::PACKAGES
: "")
: ((m_menuMode.compare("packages") == 0)
? "\uE0EE" + ult::GAP_2 + ult::OVERLAYS_ABBR
: (m_menuMode.compare("overlays") == 0)
? "\uE0ED" + ult::GAP_2 + ult::PACKAGES
: ""))
: "") +
(!interpreterIsRunningNow && !m_pageLeftName.empty()
? "\uE0ED" + ult::GAP_2 + m_pageLeftName
: !interpreterIsRunningNow && !m_pageRightName.empty()
? "\uE0EE" + ult::GAP_2 + m_pageRightName
: "");
#else
std::string currentBottomLine =
"\uE0E1" + ult::GAP_2 + ult::BACK + ult::GAP_1 +
(!m_noClickableItems
? "\uE0E0" + ult::GAP_2 + ult::OK + ult::GAP_1
: "");
#endif
// Determine if we should use cached bottom text (first frame of new overlay)
const bool useCachedBottom = !g_cachedBottom.disabled &&
!g_cachedBottom.bottomText.empty() &&
g_cachedBottom.bottomText != currentBottomLine;
const std::string& menuBottomLine = useCachedBottom ? g_cachedBottom.bottomText : currentBottomLine;
// Render the text - it starts halfGap inside the first button, so edgePadding + halfGap
static const std::vector<std::string> specialChars = {"\uE0E1","\uE0E0","\uE0ED","\uE0EE","\uE0E5"};
renderer->drawStringWithColoredSections(menuBottomLine, false, specialChars,
buttonStartX, 693, 23,
(bottomTextColor), (buttonColor));
// Update bottom cache after rendering for next frame
g_cachedBottom.bottomText = currentBottomLine;
g_cachedBottom.backWidth = _backWidth;
g_cachedBottom.selectWidth = _selectWidth;
#if IS_LAUNCHER_DIRECTIVE
g_cachedBottom.nextPageWidth = ult::nextPageWidth.load(std::memory_order_acquire);
#else
g_cachedBottom.nextPageWidth = 0.0f;
#endif
g_cachedBottom.disabled = false;
#if USING_FPS_INDICATOR_DIRECTIVE
// Update and display FPS
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
const double currentTime_seconds = currentTime_ns / 1000000000.0;
const float currentFps = updateFPS(currentTime_seconds);
static char fpsBuffer[32];
static float lastFps = -1.0f;
// Only update string if FPS changed significantly
if (std::abs(currentFps - lastFps) > 0.1f) {
snprintf(fpsBuffer, sizeof(fpsBuffer), "FPS: %.2f", currentFps);
lastFps = currentFps;
}
static constexpr auto whiteColor = tsl::Color(0xF,0xF,0xF,0xF);
renderer->drawString(fpsBuffer, false, 20, tsl::cfg::FramebufferHeight - 60, 20, whiteColor);
#endif
if (m_contentElement != nullptr)
m_contentElement->frame(renderer);
if (!ult::useRightAlignment)
renderer->drawRect(447, 0, 448, 720, a(edgeSeparatorColor));
else
renderer->drawRect(0, 0, 1, 720, a(edgeSeparatorColor));
}
// CUSTOM SECTION END
inline void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
setBoundaries(parentX, parentY, parentWidth, parentHeight);
if (m_contentElement != nullptr) {
m_contentElement->setBoundaries(parentX + 35, parentY + 97, parentWidth - 85, parentHeight - 73 - 105);
m_contentElement->invalidate();
}
}
inline Element* requestFocus(Element *oldFocus, FocusDirection direction) override {
return m_contentElement ? m_contentElement->requestFocus(oldFocus, direction) : nullptr;
}
inline bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) {
// Discard touches outside bounds
if (!m_contentElement || !m_contentElement->inBounds(currX, currY))
return false;
return m_contentElement->onTouch(event, currX, currY, prevX, prevY, initialX, initialY);
}
/**
* @brief Sets the content of the frame
*
* @param content Element
*/
inline void setContent(Element *content) {
delete m_contentElement;
m_contentElement = content;
if (content != nullptr) {
m_contentElement->setParent(this);
invalidate();
}
}
/**
* @brief Changes the title of the menu
*
* @param title Title to change to
*/
inline void setTitle(const std::string &title) {
m_title = title;
}
/**
* @brief Changes the subtitle of the menu
*
* @param title Subtitle to change to
*/
inline void setSubtitle(const std::string &subtitle) {
m_subtitle = subtitle;
}
protected:
Element *m_contentElement = nullptr;
};
#if IS_STATUS_MONITOR_DIRECTIVE
/**
* @brief The base frame which can contain another view
*
*/
class HeaderOverlayFrame : public Element {
public:
/**
* @brief Constructor
*
* @param title Name of the Overlay drawn bolt at the top
* @param subtitle Subtitle drawn bellow the title e.g version number
*/
std::string m_title;
std::string m_subtitle;
bool m_noClickableItems;
float x, y;
int offset, y_offset;
int fontSize;
HeaderOverlayFrame(const std::string& title, const std::string& subtitle, const bool& _noClickableItems=false)
: Element(), m_title(title), m_subtitle(subtitle), m_noClickableItems(_noClickableItems) {
ult::activeHeaderHeight = 97;
if (FullMode)
ult::loadWallpaperFileWhenSafe();
else
svcSleepThread(250'000); // sleep thread for initial values to auto-load
m_isItem = false;
}
virtual ~HeaderOverlayFrame() {
if (this->m_contentElement != nullptr)
delete this->m_contentElement;
// Check if returning from a list that disabled caching
if (g_disableMenuCacheOnReturn.exchange(false, std::memory_order_acq_rel)) {
g_cachedTop.disabled = true;
g_cachedBottom.disabled = true;
}
}
virtual void draw(gfx::Renderer *renderer) override {
if (!ult::themeIsInitialized.load(std::memory_order_acquire) && FullMode) {
ult::themeIsInitialized.store(true, std::memory_order_release);
tsl::initializeThemeVars();
}
if (m_noClickableItems != ult::noClickableItems.load(std::memory_order_acquire)) {
ult::noClickableItems.store(m_noClickableItems, std::memory_order_release);
}
if (FullMode == true) {
renderer->fillScreen(a(defaultBackgroundColor));
if (lastMode.empty() || (lastMode.compare("returning") == 0))
renderer->drawWallpaper();
} else {
renderer->fillScreen({ 0x0, 0x0, 0x0, 0x0});
}
y = 50;
offset = 0;
// Determine if we should use cached data (first frame of new overlay)
const bool useCachedTop = !g_cachedTop.disabled &&
!g_cachedTop.title.empty() &&
(g_cachedTop.title != m_title || g_cachedTop.subtitle != m_subtitle);
// Use cached or current data for rendering
const std::string& renderTitle = useCachedTop ? g_cachedTop.title : m_title;
const std::string& renderSubtitle = useCachedTop ? g_cachedTop.subtitle : m_subtitle;
renderer->drawString(renderTitle, false, 20, 50, 32, (defaultOverlayColor));
renderer->drawString(renderSubtitle, false, 20, y+2+23+2, 15, (bannerVersionTextColor));
if (FullMode == true)
renderer->drawRect(15, tsl::cfg::FramebufferHeight - 73, tsl::cfg::FramebufferWidth - 30, 1, a(bottomSeparatorColor));
// Set initial button position
static constexpr float buttonStartX = 30;
if (FullMode && !deactivateOriginalFooter) {
// Get the exact gap width from ult::GAP_1
const auto gapWidth = renderer->getTextDimensions(ult::GAP_1, false, 23).first;
const float _halfGap = gapWidth / 2.0f;
if (_halfGap != ult::halfGap.load(std::memory_order_acquire))
ult::halfGap.store(_halfGap, std::memory_order_release);
// Calculate text dimensions for buttons without gaps
const auto backTextWidth = renderer->getTextDimensions("\uE0E1" + ult::GAP_2 + ult::BACK, false, 23).first;
const auto selectTextWidth = renderer->getTextDimensions("\uE0E0" + ult::GAP_2 + ult::OK, false, 23).first;
// Update widths to include the half-gap padding on each side
const float _backWidth = backTextWidth + gapWidth;
if (_backWidth != ult::backWidth.load(std::memory_order_acquire))
ult::backWidth.store(_backWidth, std::memory_order_release);
const float _selectWidth = selectTextWidth + gapWidth;
if (_selectWidth != ult::selectWidth.load(std::memory_order_acquire))
ult::selectWidth.store(_selectWidth, std::memory_order_release);
const float buttonY = static_cast<float>(cfg::FramebufferHeight - 73 + 1);
// Draw back button rectangle
if (ult::touchingBack.load(std::memory_order_acquire)) {
renderer->drawRoundedRect(buttonStartX+2 - _halfGap, buttonY, _backWidth-1, 73.0f, 10.0f, a(clickColor));
}
// Draw select button rectangle (starts right after back button)
if (ult::touchingSelect.load(std::memory_order_acquire) && !m_noClickableItems) {
renderer->drawRoundedRect(buttonStartX+2 - _halfGap + _backWidth+1, buttonY,
_selectWidth-2, 73.0f, 10.0f, a(clickColor));
}
}
// Build current bottom line
const std::string currentBottomLine =
"\uE0E1" + ult::GAP_2 + ult::BACK + ult::GAP_1 +
(!m_noClickableItems
? "\uE0E0" + ult::GAP_2 + ult::OK + ult::GAP_1
: "");
// Determine if we should use cached bottom text (first frame of new overlay)
const bool useCachedBottom = !g_cachedBottom.disabled &&
!g_cachedBottom.bottomText.empty() &&
g_cachedBottom.bottomText != currentBottomLine;
const std::string& menuBottomLine = useCachedBottom ? g_cachedBottom.bottomText : currentBottomLine;
// Render the text with special character handling
if (!deactivateOriginalFooter) {
static const std::vector<std::string> specialChars = {"\uE0E1","\uE0E0","\uE0ED","\uE0EE","\uE0E5"};
renderer->drawStringWithColoredSections(menuBottomLine, false, specialChars, buttonStartX, 693, 23, (bottomTextColor), (buttonColor));
}
if (this->m_contentElement != nullptr)
this->m_contentElement->frame(renderer);
if (FullMode) {
if (!ult::useRightAlignment)
renderer->drawRect(447, 0, 448, 720, a(edgeSeparatorColor));
else
renderer->drawRect(0, 0, 1, 720, a(edgeSeparatorColor));
}
// Update top cache after rendering for next frame
g_cachedTop.title = m_title;
g_cachedTop.subtitle = m_subtitle;
g_cachedTop.titleColor = {0xF, 0xF, 0xF, 0xF}; // HeaderOverlayFrame uses default white
g_cachedTop.widgetDrawn = false; // HeaderOverlayFrame doesn't use widgets
g_cachedTop.useDynamicLogo = false; // HeaderOverlayFrame doesn't use dynamic logo
g_cachedTop.disabled = false;
// Update bottom cache after rendering for next frame
g_cachedBottom.bottomText = currentBottomLine;
g_cachedBottom.backWidth = ult::backWidth.load(std::memory_order_acquire);
g_cachedBottom.selectWidth = ult::selectWidth.load(std::memory_order_acquire);
g_cachedBottom.nextPageWidth = 0.0f; // HeaderOverlayFrame doesn't use next page
g_cachedBottom.disabled = false;
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
this->setBoundaries(parentX, parentY, parentWidth, parentHeight);
if (this->m_contentElement != nullptr) {
//this->m_contentElement->setBoundaries(parentX + 35, parentY + 140, parentWidth - 85, parentHeight - 73 - 105); // CUSTOM MODIFICATION
this->m_contentElement->setBoundaries(parentX + 35, parentY + ult::activeHeaderHeight, parentWidth - 85, parentHeight - 73 - 105);
this->m_contentElement->invalidate();
}
}
virtual inline Element* requestFocus(Element *oldFocus, FocusDirection direction) override {
if (this->m_contentElement != nullptr)
return this->m_contentElement->requestFocus(oldFocus, direction);
else
return nullptr;
}
virtual inline bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) {
// Discard touches outside bounds
if (!this->m_contentElement->inBounds(currX, currY))
return false;
if (this->m_contentElement != nullptr)
return this->m_contentElement->onTouch(event, currX, currY, prevX, prevY, initialX, initialY);
else return false;
}
/**
* @brief Sets the content of the frame
*
* @param content Element
*/
inline void setContent(Element *content) {
if (this->m_contentElement != nullptr)
delete this->m_contentElement;
this->m_contentElement = content;
if (content != nullptr) {
this->m_contentElement->setParent(this);
this->invalidate();
}
}
/**
* @brief Changes the title of the menu
*
* @param title Title to change to
*/
inline void setTitle(const std::string &title) {
this->m_title = title;
}
/**
* @brief Changes the subtitle of the menu
*
* @param title Subtitle to change to
*/
inline void setSubtitle(const std::string &subtitle) {
this->m_subtitle = subtitle;
}
protected:
Element *m_contentElement = nullptr;
//std::string m_title, m_subtitle;
};
#else
/**
* @brief The base frame which can contain another view with a customizable header
*
*/
class HeaderOverlayFrame : public Element {
public:
#if USING_WIDGET_DIRECTIVE
bool m_showWidget = false;
#endif
HeaderOverlayFrame(u16 headerHeight = 175) : Element(), m_headerHeight(headerHeight) {
ult::activeHeaderHeight = headerHeight;
// Load the bitmap file into memory
ult::loadWallpaperFileWhenSafe();
m_isItem = false;
}
virtual ~HeaderOverlayFrame() {
if (this->m_contentElement != nullptr)
delete this->m_contentElement;
if (this->m_header != nullptr)
delete this->m_header;
}
virtual void draw(gfx::Renderer *renderer) override {
if (!ult::themeIsInitialized.exchange(true, std::memory_order_acq_rel)) {
tsl::initializeThemeVars();
}
renderer->fillScreen(a(defaultBackgroundColor));
renderer->drawWallpaper();
//renderer->drawRect(tsl::cfg::FramebufferWidth - 1, 0, 1, tsl::cfg::FramebufferHeight, a(0xF222));
renderer->drawRect(15, tsl::cfg::FramebufferHeight - 73, tsl::cfg::FramebufferWidth - 30, 1, a(bottomSeparatorColor));
#if USING_WIDGET_DIRECTIVE
if (m_showWidget)
renderer->drawWidget();
#endif
// Get the exact gap width from ult::GAP_1
const float gapWidth = renderer->getTextDimensions(ult::GAP_1, false, 23).first;
const float _halfGap = gapWidth / 2.0f;
if (_halfGap != ult::halfGap.load(std::memory_order_acquire))
ult::halfGap.store(_halfGap, std::memory_order_release);
// Calculate text dimensions for buttons without gaps
const float backTextWidth = renderer->getTextDimensions("\uE0E1" + ult::GAP_2 + ult::BACK, false, 23).first;
const float selectTextWidth = renderer->getTextDimensions("\uE0E0" + ult::GAP_2 + ult::OK, false, 23).first;
// Store final widths with gap padding included
const float _backWidth = backTextWidth + gapWidth;
if (_backWidth != ult::backWidth.load(std::memory_order_acquire))
ult::backWidth.store(_backWidth, std::memory_order_release);
const float _selectWidth = selectTextWidth + gapWidth;
if (_selectWidth != ult::selectWidth.load(std::memory_order_acquire))
ult::selectWidth.store(_selectWidth, std::memory_order_release);
// Set initial button position
static constexpr float buttonStartX = 30;
const float buttonY = static_cast<float>(cfg::FramebufferHeight - 73 + 1);
// Draw back button rectangle
if (ult::touchingBack.load(std::memory_order_acquire)) {
renderer->drawRoundedRect(buttonStartX+2 - _halfGap, buttonY, _backWidth-1, 73.0f, 10.0f, a(clickColor));
}
// Draw select button rectangle
if (ult::touchingSelect.load(std::memory_order_acquire)) {
renderer->drawRoundedRect(buttonStartX+2 - _halfGap + _backWidth+1, buttonY,
_selectWidth-2, 73.0f, 10.0f, a(clickColor));
}
// Draw bottom text
const std::string menuBottomLine = "\uE0E1" + ult::GAP_2 + ult::BACK + ult::GAP_1 +
"\uE0E0" + ult::GAP_2 + ult::OK + ult::GAP_1;
renderer->drawStringWithColoredSections(menuBottomLine, false,
{"\uE0E1", "\uE0E0", "\uE0ED", "\uE0EE"},
buttonStartX, 693, 23,
bottomTextColor, buttonColor);
if (this->m_header != nullptr)
this->m_header->frame(renderer);
if (this->m_contentElement != nullptr)
this->m_contentElement->frame(renderer);
if (!ult::useRightAlignment)
renderer->drawRect(447, 0, 448, 720, a(edgeSeparatorColor));
else
renderer->drawRect(0, 0, 1, 720, a(edgeSeparatorColor));
}
virtual inline void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
this->setBoundaries(parentX, parentY, parentWidth, parentHeight);
if (this->m_contentElement != nullptr) {
this->m_contentElement->setBoundaries(parentX + 35, parentY + this->m_headerHeight, parentWidth - 85, parentHeight - 73 - this->m_headerHeight -8);
this->m_contentElement->invalidate();
}
if (this->m_header != nullptr) {
this->m_header->setBoundaries(parentX, parentY, parentWidth, this->m_headerHeight);
this->m_header->invalidate();
}
}
virtual inline bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) {
// Discard touches outside bounds
if (!this->m_contentElement->inBounds(currX, currY))
return false;
if (this->m_contentElement != nullptr)
return this->m_contentElement->onTouch(event, currX, currY, prevX, prevY, initialX, initialY);
else return false;
}
virtual inline Element* requestFocus(Element *oldFocus, FocusDirection direction) override {
if (this->m_contentElement != nullptr)
return this->m_contentElement->requestFocus(oldFocus, direction);
else
return nullptr;
}
/**
* @brief Sets the content of the frame
*
* @param content Element
*/
inline void setContent(Element *content) {
if (this->m_contentElement != nullptr)
delete this->m_contentElement;
this->m_contentElement = content;
if (content != nullptr) {
this->m_contentElement->setParent(this);
this->invalidate();
}
}
/**
* @brief Sets the header of the frame
*
* @param header Header custom drawer
*/
inline void setHeader(CustomDrawer *header) {
if (this->m_header != nullptr)
delete this->m_header;
this->m_header = header;
if (header != nullptr) {
this->m_header->setParent(this);
this->invalidate();
}
}
protected:
Element *m_contentElement = nullptr;
CustomDrawer *m_header = nullptr;
u16 m_headerHeight;
};
#endif
/**
* @brief Single color rectangle element mainly used for debugging to visualize boundaries
*
*/
class DebugRectangle : public Element {
public:
/**
* @brief Constructor
*
* @param color Color of the rectangle
*/
DebugRectangle(Color color) : Element(), m_color(color) {
m_isItem = false;
}
virtual ~DebugRectangle() {}
virtual void draw(gfx::Renderer *renderer) override {
renderer->drawRect(ELEMENT_BOUNDS(this), a(this->m_color));
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {}
private:
Color m_color;
};
class ListItem; // forward declaration
static std::mutex s_lastFrameItemsMutex;
static std::vector<Element*> s_lastFrameItems;
static std::atomic<bool> s_isForwardCache(false); // NEW VARIABLE FOR FORWARD CACHING
static std::atomic<bool> s_hasValidFrame(false);
static std::atomic<s32> s_cachedTopBound{0};
static std::atomic<s32> s_cachedBottomBound{0};
static std::atomic<s32> s_cachedHeight{0};
static std::atomic<s32> s_cachedListHeight{0};
static std::atomic<s32> s_cachedActualContentBottom{0};
static std::atomic<bool> s_shouldDrawScrollbar(false);
static std::atomic<u32> s_cachedScrollbarHeight{0};
static std::atomic<u32> s_cachedScrollbarOffset{0};
static std::atomic<u32> s_cachedScrollbarX{0};
static std::atomic<u32> s_cachedScrollbarY{0};
static std::atomic<float> s_currentScrollVelocity{0};
static std::atomic<bool> s_directionalKeyReleased{false};
static std::atomic<bool> s_cacheForwardFrameOnce(true);
static std::atomic<bool> lastInternalTouchRelease(true);
static std::atomic<bool> s_hasClearedCache(false);
//static std::atomic<bool> s_skipCaching(false);
static std::mutex s_safeToSwapMutex;
//static std::mutex s_safeTransitionMutex;
static std::atomic<bool> s_safeToSwap{false};
static std::atomic<bool> fullDeconstruction{false};
static std::atomic<bool> skipDeconstruction{false};
static std::atomic<bool> skipOnce{false};
static std::atomic<bool> isTableScrolling{false};
class List : public Element {
public:
List() : Element() {
if (fullDeconstruction.load(std::memory_order_acquire)) {
return;
}
s_safeToSwap.store(false, std::memory_order_release);
//s_directionalKeyReleased.store(false, std::memory_order_release);
//std::lock_guard<std::mutex> lock(s_safeTransitionMutex);
//s_safeToSwap.store(false, std::memory_order_release);
// Initialize instance state
m_hasForwardCached = false;
m_pendingJump = false;
m_cachingDisabled = false;
m_clearList = false;
m_focusedIndex = 0;
m_offset = 0;
m_nextOffset = 0;
m_listHeight = 0;
actualItemCount = 0;
m_isItem = false;
{
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
s_hasClearedCache.store(false, std::memory_order_release);
if (skipDeconstruction.load(std::memory_order_acquire)) {
purgePendingItems();
} else {
s_cacheForwardFrameOnce.store(true, std::memory_order_release);
skipOnce.store(false, std::memory_order_release);
}
}
}
virtual ~List() {
if (fullDeconstruction.load(std::memory_order_acquire)) {
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex); // Add this
purgePendingItems();
if (s_isForwardCache.load(std::memory_order_acquire)) {
clearStaticCacheUnsafe(true);
s_isForwardCache.store(false, std::memory_order_release);
} else {
clearStaticCacheUnsafe();
}
clearItems();
return;
}
s_safeToSwap.store(false, std::memory_order_release);
//s_directionalKeyReleased.store(false, std::memory_order_release);
//std::lock_guard<std::mutex> lock(s_safeTransitionMutex);
//s_safeToSwap.store(false, std::memory_order_release);
// NOW take mutex for shared static variable operations
{
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
if (!skipDeconstruction.load(std::memory_order_acquire)) {
purgePendingItems();
if (!s_isForwardCache.load(std::memory_order_acquire)) {
clearStaticCacheUnsafe();
clearItems();
}
s_isForwardCache.store(false, std::memory_order_release);
s_cacheForwardFrameOnce.store(true, std::memory_order_release);
}
if (m_cachingDisabled || (skipOnce.load(std::memory_order_acquire) && skipDeconstruction.load(std::memory_order_acquire))) {
purgePendingItems();
clearItems();
} else if (skipDeconstruction.load(std::memory_order_acquire)) {
skipOnce.store(true, std::memory_order_release);
}
}
}
virtual void draw(gfx::Renderer* renderer) override {
if (fullDeconstruction.load(std::memory_order_acquire)) {
return;
}
s_safeToSwap.store(false, std::memory_order_release);
std::lock_guard<std::mutex> lock(s_safeToSwapMutex);
//s_safeToSwap.store(false, std::memory_order_release);
// Early exit optimizations
if (m_clearList) {
if (!s_isForwardCache.load(std::memory_order_acquire)) {
clearStaticCacheUnsafe();
} else {
clearStaticCacheUnsafe(true);
}
clearItems();
s_isForwardCache.store(false, std::memory_order_release);
s_cacheForwardFrameOnce.store(true, std::memory_order_release);
return;
}
{
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
// Process pending operations in batch
if (!m_itemsToAdd.empty()) addPendingItems();
if (!m_itemsToRemove.empty()) removePendingItems();
}
// Only lock when checking s_lastFrameItems.empty()
bool shouldResetCache = false;
{
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
if (!s_hasValidFrame.load(std::memory_order_acquire) && s_lastFrameItems.empty() &&
!s_cacheForwardFrameOnce.load(std::memory_order_acquire)) {
shouldResetCache = true;
}
}
if (shouldResetCache) {
s_cacheForwardFrameOnce.store(true, std::memory_order_release);
}
// This part is for fixing returning to Ultrahand without rendering that first frame skip
static bool checkOnce = true;
if (checkOnce && m_pendingJump && !s_hasValidFrame.load(std::memory_order_acquire) &&
!s_isForwardCache.load(std::memory_order_acquire)) {
checkOnce = false;
return;
} else {
static bool checkOnce2 = true;
if (checkOnce2) {
checkOnce = true;
checkOnce2 = false;
}
}
// Check if we should render cached frame
if ((m_pendingJump || !m_hasForwardCached) &&
(s_hasValidFrame.load(std::memory_order_acquire) || s_isForwardCache.load(std::memory_order_acquire))) {
{
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
// Render using cached frame state if available
renderCachedFrame(renderer); // This method handles its own locking
// Clear cache after rendering
if (s_isForwardCache.load(std::memory_order_acquire))
clearStaticCacheUnsafe(true); // This method handles its own locking
else
clearStaticCacheUnsafe(); // This method handles its own locking
}
return;
}
// Cache bounds for hot loop
const s32 topBound = getTopBound();
const s32 bottomBound = getBottomBound();
const s32 height = getHeight();
renderer->enableScissoring(getLeftBound(), topBound-8, getWidth() + 8, height + 14);
{
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
// Optimized visibility culling
for (Element* entry : m_items) {
if (entry->getBottomBound() > topBound && entry->getTopBound() < bottomBound) {
entry->frame(renderer);
}
}
}
renderer->disableScissoring();
// Draw scrollbar only when needed
if (m_listHeight > height) {
drawScrollbar(renderer, height);
updateScrollAnimation();
}
// Handle caching operations - lock only for the critical section
{
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
if (!s_isForwardCache.load(std::memory_order_acquire) && s_hasValidFrame.load(std::memory_order_acquire)) {
// Clear cache after rendering (this is called within the lock)
clearStaticCacheUnsafe(); // New unsafe version for use within lock
s_hasValidFrame.store(false, std::memory_order_release);
s_cacheForwardFrameOnce.store(true, std::memory_order_release);
}
if (!m_cachingDisabled) {
if (s_cacheForwardFrameOnce.load(std::memory_order_acquire) &&
!s_hasValidFrame.load(std::memory_order_acquire)) {
// Cache current frame (this is called within the lock)
cacheCurrentFrameUnsafe(true); // New unsafe version for use within lock
s_cacheForwardFrameOnce.store(false, std::memory_order_release);
s_isForwardCache.store(true, std::memory_order_release);
s_hasValidFrame.store(true, std::memory_order_release);
m_hasForwardCached = true;
}
cacheCurrentScrollbar();
}
//if (m_cachingDisabled ||(s_hasValidFrame.load(std::memory_order_acquire) && s_isForwardCache.load(std::memory_order_acquire)))
// s_safeToSwap.store(true, std::memory_order_release);
}
s_safeToSwap.store(true, std::memory_order_release);
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
s32 y = getY() - m_offset;
// Position all items first (don't calculate m_listHeight here)
for (Element* entry : m_items) {
entry->setBoundaries(getX(), y, getWidth(), entry->getHeight());
entry->invalidate();
y += entry->getHeight();
}
// Calculate total height AFTER all invalidations are done
m_listHeight = BOTTOM_PADDING;
for (Element* entry : m_items) {
m_listHeight += entry->getHeight();
}
}
// Fixed onTouch method - prevents controller state corruption
virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
// Quick bounds check
if (!inBounds(currX, currY)) return false;
// Forward to children first
for (Element* item : m_items) {
if (item->onTouch(event, currX, currY, prevX, prevY, initialX, initialY)) {
return true;
}
}
// Handle scrolling
if (event != TouchEvent::Release && Element::getInputMode() == InputMode::TouchScroll) {
if (prevX && prevY) {
m_nextOffset += (prevY - currY);
m_nextOffset = std::clamp(m_nextOffset, 0.0f, static_cast<float>(m_listHeight - getHeight()));
// Track that we're touch scrolling
m_touchScrollActive = true;
}
return true;
}
return false;
}
inline void addItem(Element* element, u16 height = 0, ssize_t index = -1) {
if (!element) return;
// First item optimization
if (actualItemCount == 0 && element->m_isItem) {
auto* customDrawer = new tsl::elm::CustomDrawer([](gfx::Renderer*, s32, s32, s32, s32) {});
customDrawer->setBoundaries(getX(), getY(), getWidth(), 29+4);
customDrawer->setParent(this);
customDrawer->invalidate();
m_itemsToAdd.emplace_back(-1, customDrawer);
}
if (height) {
element->setBoundaries(getX(), getY(), getWidth(), height);
}
element->setParent(this);
element->invalidate();
m_itemsToAdd.emplace_back(index, element);
++actualItemCount;
}
virtual void removeItem(Element *element) {
if (element) m_itemsToRemove.push_back(element);
}
virtual void removeIndex(size_t index) {
if (index < m_items.size()) removeItem(m_items[index]);
}
inline void clear() {
m_clearList = true;
}
virtual Element* requestFocus(Element* oldFocus, FocusDirection direction) override {
if (m_clearList || !m_itemsToAdd.empty()) return nullptr;
static bool delayedHandle = false;
// NEW: Handle pending jump to specific item
if (m_pendingJump && !delayedHandle) {
delayedHandle = true;
return handleJumpToItem(oldFocus);
} else if (m_pendingJump) {
m_pendingJump = false;
delayedHandle = false;
return handleJumpToItem(oldFocus); // needs to be handled 2x for proper rendering
}
if (jumpToBottom.exchange(false, std::memory_order_acq_rel))
return handleJumpToBottom(oldFocus);
if (jumpToTop.exchange(false, std::memory_order_acq_rel))
return handleJumpToTop(oldFocus);
if (skipDown.exchange(false, std::memory_order_acq_rel))
return handleSkipDown(oldFocus);
if (skipUp.exchange(false, std::memory_order_acq_rel))
return handleSkipUp(oldFocus);
if (direction == FocusDirection::None) {
return handleInitialFocus(oldFocus);
}
else if (direction == FocusDirection::Down) {
return handleDownFocus(oldFocus);
}
else if (direction == FocusDirection::Up) {
return handleUpFocus(oldFocus);
}
return oldFocus;
}
inline void jumpToItem(const std::string& text = "", const std::string& value = "", bool exactMatch=true) {
if (!text.empty() || !value.empty()) {
m_pendingJump = true;
m_jumpToText = text;
m_jumpToValue = value;
m_jumpToExactMatch = exactMatch;
}
}
virtual Element* getItemAtIndex(u32 index) {
return (m_items.size() <= index) ? nullptr : m_items[index];
}
virtual s32 getIndexInList(Element *element) {
auto it = std::find(m_items.begin(), m_items.end(), element);
return (it == m_items.end()) ? -1 : static_cast<s32>(it - m_items.begin());
}
virtual s32 getLastIndex() {
return static_cast<s32>(m_items.size()) - 1;
}
virtual void setFocusedIndex(u32 index) {
if (m_items.size() > index) {
m_focusedIndex = index;
updateScrollOffset();
}
}
inline void onDirectionalKeyReleased() {
m_hasWrappedInCurrentSequence = false;
m_lastNavigationResult = NavigationResult::None;
m_isHolding = false;
m_stoppedAtBoundary = false;
m_lastNavigationTime = 0;
m_lastScrollTime = 0;
}
inline void disableCaching() {
m_cachingDisabled = true;
//clearFrameCache();
g_disableMenuCacheOnReturn.store(true, std::memory_order_release);
}
protected:
std::vector<Element*> m_items;
u16 m_focusedIndex = 0;
float m_offset = 0, m_nextOffset = 0;
s32 m_listHeight = 0;
bool m_clearList = false;
std::vector<Element*> m_itemsToRemove;
std::vector<std::pair<ssize_t, Element*>> m_itemsToAdd;
std::vector<float> prefixSums;
// Instance identification
//const size_t m_instanceId;
// Enhanced navigation state tracking
bool m_justWrapped = false;
bool m_isHolding = false;
bool m_stoppedAtBoundary = false;
u64 m_lastNavigationTime = 0;
static constexpr u64 HOLD_THRESHOLD_NS = 100000000ULL; // 100ms
size_t actualItemCount = 0;
// Jump to navigation variables
std::string m_jumpToText;
std::string m_jumpToValue;
bool m_jumpToExactMatch = false;
bool m_pendingJump = false;
bool m_hasForwardCached = false;
bool m_cachingDisabled = false; // New flag to disable caching
//bool m_hasRenderedCache = false;
// Stack variables for hot path - reused to avoid allocations
u32 scrollbarHeight;
u32 scrollbarOffset;
u32 prevOffset;
static constexpr float SCROLLBAR_X_OFFSET = 21.0f;
static constexpr float SCROLLBAR_Y_OFFSET = 3.0f;
static constexpr float SCROLLBAR_HEIGHT_TRIM = 6.0f;
//static constexpr float smoothingFactor = 0.15f;
//static constexpr float dampingFactor = 0.3f;
static constexpr float TABLE_SCROLL_STEP_SIZE = 10;
static constexpr float TABLE_SCROLL_STEP_SIZE_CLICK = 22;
static constexpr float BOTTOM_PADDING = 7.0f;
static constexpr float VIEW_CENTER_OFFSET = 7.0f;
u64 m_lastScrollTime = 0;
float m_scrollVelocity = 0.0f;
bool m_touchScrollActive = false;
enum class NavigationResult {
None,
Success,
HitBoundary,
Wrapped
};
bool m_hasWrappedInCurrentSequence = false;
NavigationResult m_lastNavigationResult = NavigationResult::None;
private:
// Thread-safe versions (handle their own locking)
static void clearStaticCache(bool preservePointers = false) {
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
clearStaticCacheUnsafe(preservePointers);
}
void cacheCurrentFrame(bool preservePointers = false) {
std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
cacheCurrentFrameUnsafe(preservePointers);
}
static void clearStaticCacheUnsafe(bool preservePointers = false) {
//std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
if (!preservePointers) {
// Normal case: delete elements and clear
for (Element* el : s_lastFrameItems) {
delete el;
}
}
s_lastFrameItems.clear();
//s_lastFrameItems.shrink_to_fit();
// CRITICAL: Always reset these, even for forward cache!
s_hasValidFrame.store(false, std::memory_order_release); // This MUST be false after clearing
s_isForwardCache.store(false, std::memory_order_release);
s_cachedTopBound.store(0, std::memory_order_release);
s_cachedBottomBound.store(0, std::memory_order_release);
s_cachedHeight.store(0, std::memory_order_release);
s_cachedListHeight.store(0, std::memory_order_release);
s_cachedActualContentBottom.store(0, std::memory_order_release);
s_shouldDrawScrollbar.store(false, std::memory_order_release);
s_cachedScrollbarHeight.store(0, std::memory_order_release);
s_cachedScrollbarOffset.store(0, std::memory_order_release);
s_cachedScrollbarX.store(0, std::memory_order_release);
s_cachedScrollbarY.store(0, std::memory_order_release);
}
void cacheCurrentFrameUnsafe(bool preservePointers = false) {
//std::lock_guard<std::mutex> lock(s_lastFrameItemsMutex);
if (!preservePointers) {
for (Element* el : s_lastFrameItems) delete el;
}
s_lastFrameItems = m_items;
// Store new cache values using atomic stores
s_cachedTopBound.store(getTopBound(), std::memory_order_release);
s_cachedBottomBound.store(getBottomBound(), std::memory_order_release);
s_cachedHeight.store(getHeight(), std::memory_order_release);
s_cachedListHeight.store(m_listHeight, std::memory_order_release);
if (preservePointers)
s_isForwardCache.store(true, std::memory_order_release);
s_hasValidFrame.store(true, std::memory_order_release);
}
void cacheCurrentScrollbar() {
const s32 cachedHeight = s_cachedHeight.load(std::memory_order_acquire);
const s32 cachedListHeight = s_cachedListHeight.load(std::memory_order_acquire);
s_shouldDrawScrollbar.store((cachedListHeight > cachedHeight), std::memory_order_release);
if (s_shouldDrawScrollbar.load(std::memory_order_acquire)) {
const float viewHeight = static_cast<float>(cachedHeight);
const float totalHeight = static_cast<float>(cachedListHeight);
const u32 maxScroll = std::max(static_cast<u32>(totalHeight - viewHeight), 1u);
u32 scrollbarHeight = std::min(
static_cast<u32>((viewHeight * viewHeight) / totalHeight),
static_cast<u32>(viewHeight)
);
u32 scrollbarOffset = std::min(
static_cast<u32>((m_offset / maxScroll) * (viewHeight - scrollbarHeight)),
static_cast<u32>(viewHeight - scrollbarHeight) // corrected potential bug
);
scrollbarHeight -= SCROLLBAR_HEIGHT_TRIM;
s_cachedScrollbarHeight.store(scrollbarHeight, std::memory_order_release);
s_cachedScrollbarOffset.store(scrollbarOffset, std::memory_order_release);
s_cachedScrollbarX.store(getRightBound() + SCROLLBAR_X_OFFSET, std::memory_order_release);
s_cachedScrollbarY.store(getY() + scrollbarOffset + SCROLLBAR_Y_OFFSET, std::memory_order_release);
}
}
void renderCachedFrame(gfx::Renderer* renderer) {
const s32 cachedTopBound = s_cachedTopBound.load(std::memory_order_acquire);
const s32 cachedBottomBound = s_cachedBottomBound.load(std::memory_order_acquire);
const s32 cachedHeight = s_cachedHeight.load(std::memory_order_acquire);
renderer->enableScissoring(getLeftBound(), cachedTopBound - 8, getWidth() + 8, cachedHeight + 14);
for (Element* entry : s_lastFrameItems) {
if (entry &&
entry->getBottomBound() > cachedTopBound &&
entry->getTopBound() < cachedBottomBound) {
entry->frame(renderer);
}
}
renderer->disableScissoring();
if (s_shouldDrawScrollbar.load(std::memory_order_acquire)) {
const u32 scrollbarX = s_cachedScrollbarX.load(std::memory_order_acquire);
const u32 scrollbarY = s_cachedScrollbarY.load(std::memory_order_acquire);
const u32 scrollbarHeight = s_cachedScrollbarHeight.load(std::memory_order_acquire);
renderer->drawRect(scrollbarX, scrollbarY, 5, scrollbarHeight, a(trackBarColor));
renderer->drawCircle(scrollbarX + 2, scrollbarY, 2, true, a(trackBarColor));
renderer->drawCircle(scrollbarX + 2, scrollbarY + scrollbarHeight, 2, true, a(trackBarColor));
}
}
void clearItems() {
for (Element* item : m_items) delete item;
m_items = {};
//m_items.clear();
//m_items.shrink_to_fit();
m_offset = 0;
m_focusedIndex = 0;
invalidate();
m_clearList = false;
actualItemCount = 0;
}
void addPendingItems() {
for (auto [index, element] : m_itemsToAdd) {
element->invalidate();
if (index >= 0 && static_cast<size_t>(index) < m_items.size()) {
m_items.insert(m_items.begin() + index, element);
} else {
m_items.push_back(element);
}
}
m_itemsToAdd = {};
//m_itemsToAdd.clear();
//m_itemsToAdd.shrink_to_fit();
invalidate();
updateScrollOffset();
}
void removePendingItems() {
//size_t index;
for (Element* element : m_itemsToRemove) {
auto it = std::find(m_items.begin(), m_items.end(), element);
if (it != m_items.end()) {
const size_t index = static_cast<size_t>(it - m_items.begin());
m_items.erase(it);
if (m_focusedIndex >= index && m_focusedIndex > 0) {
--m_focusedIndex;
}
delete element;
}
}
m_itemsToRemove = {};
//m_itemsToRemove.clear();
//m_itemsToRemove.shrink_to_fit();
invalidate();
updateScrollOffset();
}
void purgePendingItems() {
for (auto& [_, element] : m_itemsToAdd) {
if (element) { element->invalidate(); delete element; }
}
m_itemsToAdd = {};
//m_itemsToAdd.clear();
//m_itemsToAdd.shrink_to_fit();
//size_t index;
for (Element* element : m_itemsToRemove) {
auto it = std::find(m_items.begin(), m_items.end(), element);
if (it != m_items.end()) {
//index = static_cast<std::size_t>(it - m_items.begin());
const u16 index16 = static_cast<u16>(static_cast<std::size_t>(it - m_items.begin()));
element->invalidate();
delete element;
m_items.erase(it);
constexpr u16 noFocus = static_cast<u16>(0xFFFF);
if (m_focusedIndex == index16)
m_focusedIndex = noFocus;
else if (m_focusedIndex != noFocus && m_focusedIndex > index16)
--m_focusedIndex;
}
}
m_itemsToRemove = {};
//m_itemsToRemove.clear();
//m_itemsToRemove.shrink_to_fit();
invalidate();
updateScrollOffset();
}
void drawScrollbar(gfx::Renderer* renderer, s32 height) {
const float viewHeight = static_cast<float>(height);
const float totalHeight = static_cast<float>(m_listHeight);
const u32 maxScrollableHeight = std::max(static_cast<u32>(totalHeight - viewHeight), 1u);
scrollbarHeight = std::min(static_cast<u32>((viewHeight * viewHeight) / totalHeight),
static_cast<u32>(viewHeight));
scrollbarOffset = std::min(static_cast<u32>((m_offset / maxScrollableHeight) * (viewHeight - scrollbarHeight)),
static_cast<u32>(viewHeight - scrollbarHeight));
const u32 scrollbarX = getRightBound() + SCROLLBAR_X_OFFSET;
const u32 scrollbarY = getY() + scrollbarOffset+SCROLLBAR_Y_OFFSET;
scrollbarHeight -= SCROLLBAR_HEIGHT_TRIM; // shorten very slightly
renderer->drawRect(scrollbarX, scrollbarY, 5, scrollbarHeight, a(trackBarColor));
renderer->drawCircle(scrollbarX + 2, scrollbarY, 2, true, a(trackBarColor));
renderer->drawCircle(scrollbarX + 2, scrollbarY + scrollbarHeight, 2, true, a(trackBarColor));
}
inline void updateScrollAnimation() {
if (Element::getInputMode() == InputMode::Controller) {
// Clear touch flag when in controller mode
m_touchScrollActive = false;
// Calculate distance to target
const float diff = m_nextOffset - m_offset;
const float distance = std::abs(diff);
// ENHANCED BOUNDARY SNAPPING: More aggressive snapping for boundaries
if (distance < 1.0f) { // Increased threshold from 0.5f
m_offset = m_nextOffset;
m_scrollVelocity = 0.0f;
s_currentScrollVelocity.store(m_scrollVelocity, std::memory_order_release);
if (prevOffset != m_offset) {
invalidate();
prevOffset = m_offset;
}
return;
}
// SPECIAL CASE: If target is exactly 0 or max, be more aggressive
const float maxOffset = static_cast<float>(m_listHeight - getHeight());
if (m_nextOffset == 0.0f || m_nextOffset == maxOffset) {
if (distance < 3.0f) { // Larger snap zone for boundaries
m_offset = m_nextOffset;
m_scrollVelocity = 0.0f;
s_currentScrollVelocity.store(m_scrollVelocity, std::memory_order_release);
if (prevOffset != m_offset) {
invalidate();
prevOffset = m_offset;
}
return;
}
}
// Emergency correction if item is going out of bounds
if (m_focusedIndex < m_items.size()) {
float itemTop = 0.0f;
for (size_t i = 0; i < m_focusedIndex; ++i) {
itemTop += m_items[i]->getHeight();
}
const float itemBottom = itemTop + m_items[m_focusedIndex]->getHeight();
//float viewTop = m_offset;
const float viewBottom = m_offset + getHeight();
if (itemTop < m_offset || itemBottom > viewBottom) {
const float emergencySpeed = (itemBottom < m_offset || itemTop > viewBottom) ? 0.9f : 0.6f;
m_offset += diff * emergencySpeed;
m_scrollVelocity = diff * 0.3f;
s_currentScrollVelocity.store(m_scrollVelocity, std::memory_order_release);
if (prevOffset != m_offset) {
invalidate();
prevOffset = m_offset;
}
return;
}
}
// Rest of your existing smooth scrolling logic...
const bool isLargeJump = distance > getHeight() * 1.5f;
const bool isFromRest = std::abs(m_scrollVelocity) < 2.0f;
if (isLargeJump && isFromRest) {
static constexpr float gentleAcceleration = 0.08f;
static constexpr float gentleDamping = 0.85f;
const float targetVelocity = diff * gentleAcceleration;
m_scrollVelocity += (targetVelocity - m_scrollVelocity) * gentleDamping;
} else {
const float urgency = std::min(distance / getHeight(), 1.0f);
const float accelerationFactor = 0.18f + (0.24f * urgency);
const float dampingFactor = 0.48f - (0.18f * urgency);
const float targetVelocity = diff * accelerationFactor;
m_scrollVelocity += (targetVelocity - m_scrollVelocity) * dampingFactor;
}
// Apply velocity
m_offset += m_scrollVelocity;
// ENHANCED overshoot prevention with better boundary handling
if ((m_scrollVelocity > 0 && m_offset > m_nextOffset) ||
(m_scrollVelocity < 0 && m_offset < m_nextOffset)) {
m_offset = m_nextOffset;
m_scrollVelocity = 0.0f;
}
// ADDITIONAL: Force exact boundary values
if (m_nextOffset == 0.0f && m_offset < 1.0f) {
m_offset = 0.0f;
m_scrollVelocity = 0.0f;
} else if (m_nextOffset == maxOffset && m_offset > maxOffset - 1.0f) {
m_offset = maxOffset;
m_scrollVelocity = 0.0f;
}
s_currentScrollVelocity.store(m_scrollVelocity, std::memory_order_release);
} else if (Element::getInputMode() == InputMode::TouchScroll) {
// Your existing touch scroll logic...
m_offset = m_nextOffset;
m_scrollVelocity = 0.0f;
if (m_touchScrollActive) {
const float viewCenter = m_offset + (getHeight() / 2.0f);
float accumHeight = 0.0f;
//float itemHeight, itemCenter;
for (size_t i = 0; i < m_items.size(); ++i) {
const float itemHeight = m_items[i]->getHeight();
const float itemCenter = accumHeight + (itemHeight / 2.0f);
if (itemCenter >= viewCenter) {
m_focusedIndex = i;
break;
}
accumHeight += itemHeight;
}
}
}
if (prevOffset != m_offset) {
invalidate();
prevOffset = m_offset;
}
}
Element* handleInitialFocus(Element* oldFocus) {
const size_t itemCount = m_items.size();
if (itemCount == 0) return nullptr;
size_t startIndex = 0;
// Calculate starting index based on current scroll position
if (!oldFocus && m_offset > 0) {
float elementHeight = 0.0f;
const size_t maxIndex = itemCount - 1;
while (elementHeight < m_offset && startIndex < maxIndex) {
elementHeight += m_items[startIndex]->getHeight();
++startIndex;
}
}
//resetNavigationState();
// Save current offset to prevent scroll jumping
const float savedOffset = m_offset;
const float savedNextOffset = m_nextOffset;
// Single loop with wraparound logic - visits each item exactly once
for (size_t count = 0; count < itemCount; ++count) {
const size_t i = (startIndex + count) % itemCount;
if (!m_items[i]->isTable()) {
Element* const newFocus = m_items[i]->requestFocus(oldFocus, FocusDirection::None);
if (newFocus && newFocus != oldFocus) {
m_focusedIndex = i;
m_offset = savedOffset;
m_nextOffset = savedNextOffset;
return newFocus;
}
}
}
return nullptr;
}
inline Element* handleDownFocus(Element* oldFocus) {
static bool triggerShakeOnce = true;
const bool atBottom = isAtBottom();
updateHoldState();
// Check if the next item is non-focusable BEFORE we do anything else
if (m_focusedIndex + 1 < int(m_items.size())) {
Element* nextItem = m_items[m_focusedIndex + 1];
if (!nextItem->m_isItem) {
isTableScrolling.store(true, std::memory_order_release);
}
}
// If holding and at boundary, try to scroll first
if (m_isHolding && m_stoppedAtBoundary && !atBottom) {
scrollDown();
m_stoppedAtBoundary = false;
return oldFocus;
}
Element* result = navigateDown(oldFocus);
if (result != oldFocus) {
m_lastNavigationResult = NavigationResult::Success;
m_stoppedAtBoundary = false;
triggerShakeOnce = true; // This resets it for THIS function
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
return result;
}
// Check if we can still scroll down
if (!atBottom) {
scrollDown();
triggerShakeOnce = true; // ADDED: Reset when scrolling away from boundary
return oldFocus;
}
// At absolute bottom - check for wrapping (single tap)
if (!m_isHolding && !m_hasWrappedInCurrentSequence && atBottom) {
s_directionalKeyReleased.store(false, std::memory_order_release);
m_hasWrappedInCurrentSequence = true;
m_lastNavigationResult = NavigationResult::Wrapped;
//if (result->m_isItem) {
triggerShakeOnce = true; // Reset when wrapping
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
//}
return handleJumpToTop(oldFocus);
}
// Set boundary flag (for holding)
if (m_isHolding && atBottom) {
m_stoppedAtBoundary = true;
if (triggerShakeOnce) {
if (result->m_isItem) {
triggerRumbleClick.store(true, std::memory_order_release);
triggerWallSound.store(true, std::memory_order_release);
for (ssize_t i = static_cast<ssize_t>(m_focusedIndex); i >= 0; --i) {
if (m_items[i]->m_isItem) {
m_items[i]->shakeHighlight(FocusDirection::Down);
break;
}
}
} else {
triggerRumbleClick.store(true, std::memory_order_release);
triggerWallSound.store(true, std::memory_order_release);
}
triggerShakeOnce = false;
}
} else if (!m_isHolding) {
triggerShakeOnce = true;
}
m_lastNavigationResult = NavigationResult::HitBoundary;
return oldFocus;
}
inline Element* handleUpFocus(Element* oldFocus) {
static bool triggerShakeOnce = true;
const bool atTop = isAtTop();
updateHoldState();
// Check if the previous item is non-focusable BEFORE we do anything else
if (m_focusedIndex > 0) {
Element* prevItem = m_items[m_focusedIndex - 1];
if (prevItem->isTable()) {
isTableScrolling.store(true, std::memory_order_release);
}
}
// If holding and at boundary, try to scroll first
if (m_isHolding && m_stoppedAtBoundary && !atTop) {
scrollUp();
m_stoppedAtBoundary = false;
return oldFocus;
}
Element* result = navigateUp(oldFocus);
if (result != oldFocus) {
m_lastNavigationResult = NavigationResult::Success;
m_stoppedAtBoundary = false;
triggerShakeOnce = true; // This resets it for THIS function
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
return result;
}
// Check if we can still scroll up
if (!atTop) {
scrollUp();
triggerShakeOnce = true; // ADDED: Reset when scrolling away from boundary
return oldFocus;
}
// At absolute top - check for wrapping (single tap)
if (!m_isHolding && !m_hasWrappedInCurrentSequence && atTop) {
s_directionalKeyReleased.store(false, std::memory_order_release);
m_hasWrappedInCurrentSequence = true;
m_lastNavigationResult = NavigationResult::Wrapped;
//if (result->m_isItem) {
triggerShakeOnce = true; // Reset when wrapping
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
//}
return handleJumpToBottom(oldFocus);
}
// Set boundary flag (for holding)
if (m_isHolding && atTop) {
m_stoppedAtBoundary = true;
if (triggerShakeOnce) {
if (result->m_isItem) {
triggerRumbleClick.store(true, std::memory_order_release);
triggerWallSound.store(true, std::memory_order_release);
for (size_t i = m_focusedIndex; i < m_items.size(); ++i) {
if (m_items[i]->m_isItem) {
m_items[i]->shakeHighlight(FocusDirection::Up);
break;
}
}
} else {
triggerRumbleClick.store(true, std::memory_order_release);
triggerWallSound.store(true, std::memory_order_release);
}
triggerShakeOnce = false;
}
} else if (!m_isHolding) {
triggerShakeOnce = true;
}
m_lastNavigationResult = NavigationResult::HitBoundary;
return oldFocus;
}
inline bool isAtTop() {
if (m_items.empty()) return true;
// Check if we're at scroll position 0
if (m_offset != 0.0f) return false;
// Even at offset 0, check if the first item is actually visible
// This handles cases where the first item might be partially above viewport
if (!m_items.empty()) {
Element* firstItem = m_items[0];
return firstItem->getTopBound() >= getTopBound();
}
return true;
}
inline bool isAtBottom() {
if (m_items.empty()) return true;
// First check: are we at the maximum scroll offset?
//float maxOffset = static_cast<float>(m_listHeight - getHeight());
const bool atMaxOffset = (m_offset >= static_cast<float>(m_listHeight - getHeight()));
// If list is shorter than viewport, we're always at bottom
if (m_listHeight <= getHeight()) return true;
// If we're not at max offset, we're definitely not at bottom
if (!atMaxOffset) return false;
// At max offset - now check if the last item is actually fully visible
// This prevents wrap-around when there's still content below viewport
if (!m_items.empty()) {
Element* lastItem = m_items.back();
//s32 lastItemBottom = lastItem->getBottomBound();
//s32 viewportBottom = getBottomBound();
// We're truly at bottom only if:
// 1. We're at max scroll offset AND
// 2. The last item's bottom is at or above the viewport bottom
return lastItem->getBottomBound() <= getBottomBound();
}
return atMaxOffset;
}
// Helper to check if there are any focusable items
inline bool hasAnyFocusableItems() {
for (size_t i = 0; i < m_items.size(); ++i) {
//Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
//
//if (test) return true;
if (m_items[i]->m_isItem) return true;
}
return false;
}
inline void updateHoldState() {
const u64 currentTime = armTicksToNs(armGetSystemTick());
if ((m_lastNavigationTime != 0 && (currentTime - m_lastNavigationTime) < HOLD_THRESHOLD_NS)) {
m_isHolding = true;
} else {
m_isHolding = false;
m_stoppedAtBoundary = false;
m_hasWrappedInCurrentSequence = false;
}
m_lastNavigationTime = currentTime;
}
inline void resetNavigationState() {
m_hasWrappedInCurrentSequence = false;
m_lastNavigationResult = NavigationResult::None;
m_isHolding = false;
m_stoppedAtBoundary = false;
m_lastNavigationTime = 0;
}
inline Element* handleJumpToItem(Element* oldFocus) {
resetNavigationState();
invalidate();
const bool needsScroll = m_listHeight > getHeight();
const float viewHeight = static_cast<float>(getHeight());
const float maxOffset = needsScroll ? m_listHeight - viewHeight : 0.0f;
float h = 0.0f;
//float itemHeight, itemCenterPos, viewportCenter, idealOffset;
for (size_t i = 0; i < m_items.size(); ++i) {
m_focusedIndex = i;
Element* newFocus = m_items[i]->requestFocus(oldFocus, FocusDirection::Down);
if (newFocus && newFocus != oldFocus && m_items[i]->matchesJumpCriteria(m_jumpToText, m_jumpToValue, m_jumpToExactMatch)) {
// CHANGED: Calculate center of the item and center it in viewport
const float itemHeight = m_items[i]->getHeight();
// For middle items, use centering logic
const float itemCenterPos = h + (itemHeight / 2.0f); // FIXED: Use center, not bottom
const float viewportCenter = viewHeight / 2.0f + VIEW_CENTER_OFFSET + 0.5f; // Same offset as updateScrollOffset
//float idealOffset = itemCenterPos - viewportCenter;
// Clamp to valid bounds (same as updateScrollOffset)
const float idealOffset = std::max(0.0f, std::min(itemCenterPos - viewportCenter, maxOffset));
// Set both current and target offset
m_offset = m_nextOffset = idealOffset;
return newFocus;
}
h += m_items[i]->getHeight();
}
// No match found
return handleInitialFocus(oldFocus);
}
// Core navigation logic
// Optimized version with variable definitions pulled outside the loop
inline Element* navigateDown(Element* oldFocus) {
size_t searchIndex = m_focusedIndex + 1;
// If currently on a table that needs more scrolling
if (m_focusedIndex < m_items.size() && m_items[m_focusedIndex]->isTable()) {
Element* currentTable = m_items[m_focusedIndex];
if (currentTable->getBottomBound() > getBottomBound()) {
isTableScrolling.store(true, std::memory_order_release);
scrollDown();
return oldFocus;
}
}
// Cache invariant values (legitimate optimization)
const s32 viewBottom = getBottomBound();
const float containerHeight = getHeight();
const float offsetPlusHeight = m_offset + containerHeight;
while (searchIndex < m_items.size()) {
Element* item = m_items[searchIndex];
m_focusedIndex = searchIndex;
if (item->isTable()) {
// Table needs scrolling
const s32 tableBottom = item->getBottomBound();
if (tableBottom > viewBottom) {
isTableScrolling.store(true, std::memory_order_release);
scrollDown();
return oldFocus;
}
searchIndex++;
continue;
}
// Try to focus this item
Element* newFocus = item->requestFocus(oldFocus, FocusDirection::Down);
if (newFocus && newFocus != oldFocus) {
// ONLY reset when we successfully focus something
isTableScrolling.store(false, std::memory_order_release);
updateScrollOffset();
return newFocus;
} else {
// Non-focusable item (gap/header)
const float itemBottom = calculateItemPosition(searchIndex) + item->getHeight();
if (itemBottom > offsetPlusHeight) {
isTableScrolling.store(true, std::memory_order_release); // Treat gaps/headers like tables
scrollDown();
return oldFocus;
}
searchIndex++;
}
}
return oldFocus;
}
inline Element* navigateUp(Element* oldFocus) {
if (m_focusedIndex == 0) return oldFocus;
ssize_t searchIndex = static_cast<ssize_t>(m_focusedIndex) - 1;
// If currently on a table that needs more scrolling
if (m_focusedIndex < m_items.size() && m_items[m_focusedIndex]->isTable()) {
Element* currentTable = m_items[m_focusedIndex];
if (currentTable->getTopBound() < getTopBound()) {
isTableScrolling.store(true, std::memory_order_release);
scrollUp();
return oldFocus;
}
}
// Cache invariant values (legitimate optimization)
const s32 viewTop = getTopBound();
const float offset = m_offset; // Cache in case m_offset is volatile or has accessor overhead
while (searchIndex >= 0) {
Element* item = m_items[searchIndex];
m_focusedIndex = static_cast<size_t>(searchIndex);
if (item->isTable()) {
// Table needs scrolling
const s32 tableTop = item->getTopBound();
if (tableTop < viewTop) {
isTableScrolling.store(true, std::memory_order_release);
scrollUp();
return oldFocus;
}
searchIndex--;
continue;
}
// Try to focus this item
Element* newFocus = item->requestFocus(oldFocus, FocusDirection::Up);
if (newFocus && newFocus != oldFocus) {
// ONLY reset when we successfully focus something
isTableScrolling.store(false, std::memory_order_release);
updateScrollOffset();
return newFocus;
} else {
// Non-focusable item (gap/header)
const float itemTop = calculateItemPosition(static_cast<size_t>(searchIndex));
if (itemTop < offset) {
isTableScrolling.store(true, std::memory_order_release); // Treat gaps/headers like tables
scrollUp();
return oldFocus;
}
searchIndex--;
}
}
return oldFocus;
}
// Helper method to calculate an item's position in the list
inline float calculateItemPosition(size_t index) {
float position = 0.0f;
for (size_t i = 0; i < index && i < m_items.size(); ++i) {
position += m_items[i]->getHeight();
}
return position;
}
// Enhanced scroll methods that ensure we always reach boundaries
//inline bool canScrollDown() {
// if (m_listHeight <= getHeight()) return false;
// float maxOffset = static_cast<float>(m_listHeight - getHeight());
// return (m_nextOffset < maxOffset - 0.1f) && (m_offset < maxOffset - 0.1f);
//}
//
//inline bool canScrollUp() {
// return (m_nextOffset > 0.1f) || (m_offset > 0.1f);
//}
//u64 m_lastScrollNavigationTime = 0;
//bool m_isHoldingOnTable = false;
// Enhanced scroll methods that snap to exact boundaries
inline void scrollDown() {
const u64 currentTime = armTicksToNs(armGetSystemTick());
// Calculate frame time
float frameTimeMs = 0.0f;
if (m_lastScrollTime != 0) {
frameTimeMs = static_cast<float>(currentTime - m_lastScrollTime) / 1000000.0f;
}
m_lastScrollTime = currentTime;
// Use original frame-based amounts
float scrollAmount = m_isHolding ? TABLE_SCROLL_STEP_SIZE : TABLE_SCROLL_STEP_SIZE_CLICK;
// If frame took longer than ~33ms (slower than 30fps), scale up the scroll amount
if (frameTimeMs > 33.0f) {
const float scaleFactor = frameTimeMs / 16.67f; // 16.67ms = 60fps baseline
scrollAmount *= std::min(scaleFactor, 3.0f); // Cap at 3x for very slow frames
}
m_nextOffset = std::min(m_nextOffset + scrollAmount,
static_cast<float>(m_listHeight - getHeight()));
}
inline void scrollUp() {
const u64 currentTime = armTicksToNs(armGetSystemTick());
// Calculate frame time
float frameTimeMs = 0.0f;
if (m_lastScrollTime != 0) {
frameTimeMs = static_cast<float>(currentTime - m_lastScrollTime) / 1000000.0f;
}
m_lastScrollTime = currentTime;
// Use original frame-based amounts
float scrollAmount = m_isHolding ? TABLE_SCROLL_STEP_SIZE : TABLE_SCROLL_STEP_SIZE_CLICK;
// If frame took longer than ~33ms (slower than 30fps), scale up the scroll amount
if (frameTimeMs > 33.0f) {
const float scaleFactor = frameTimeMs / 16.67f; // 16.67ms = 60fps baseline
scrollAmount *= std::min(scaleFactor, 3.0f); // Cap at 3x for very slow frames
}
m_nextOffset = std::max(m_nextOffset - scrollAmount, 0.0f);
}
// Jump to Bottom (original behavior + fixed trigger condition)
Element* handleJumpToBottom(Element* oldFocus) {
if (m_items.empty()) return oldFocus;
invalidate();
resetNavigationState();
jumpToBottom.store(false, std::memory_order_release);
const float targetOffset = (m_listHeight > getHeight()) ?
static_cast<float>(m_listHeight - getHeight()) : 0.0f;
static constexpr float tolerance = 5.0f;
// Find last focusable item (search backward)
size_t lastFocusableIndex = m_items.size();
for (ssize_t i = static_cast<ssize_t>(m_items.size()) - 1; i >= 0; --i) {
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test) {
lastFocusableIndex = static_cast<size_t>(i);
break;
}
}
if (lastFocusableIndex == m_items.size())
return oldFocus; // no focusable items
bool alreadyAtBottom = (m_focusedIndex == lastFocusableIndex) &&
(std::abs(m_nextOffset - targetOffset) <= tolerance);
if (alreadyAtBottom)
return oldFocus;
const float oldOffset = m_nextOffset;
m_focusedIndex = lastFocusableIndex;
m_nextOffset = targetOffset;
Element* newFocus = m_items[lastFocusableIndex]->requestFocus(oldFocus, FocusDirection::None);
// Trigger feedback if offset or focus changed
if ((newFocus && newFocus != oldFocus) ||
(std::abs(m_nextOffset - oldOffset) > tolerance)) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
}
return newFocus ? newFocus : oldFocus;
}
// Jump to Top (original behavior + fixed trigger condition)
Element* handleJumpToTop(Element* oldFocus) {
if (m_items.empty()) return oldFocus;
invalidate();
resetNavigationState();
jumpToTop.store(false, std::memory_order_release);
static constexpr float targetOffset = 0.0f;
static constexpr float tolerance = 5.0f;
// Find first focusable item (search forward)
size_t firstFocusableIndex = m_items.size();
for (size_t i = 0; i < m_items.size(); ++i) {
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test) {
firstFocusableIndex = i;
break;
}
}
if (firstFocusableIndex == m_items.size())
return oldFocus; // no focusable items
bool alreadyAtTop = (m_focusedIndex == firstFocusableIndex) &&
(std::abs(m_nextOffset - targetOffset) <= tolerance);
if (alreadyAtTop)
return oldFocus;
const float oldOffset = m_nextOffset;
m_focusedIndex = firstFocusableIndex;
m_nextOffset = targetOffset;
Element* newFocus = m_items[firstFocusableIndex]->requestFocus(oldFocus, FocusDirection::None);
// Trigger feedback if offset or focus changed
if ((newFocus && newFocus != oldFocus) ||
(std::abs(m_nextOffset - oldOffset) > tolerance)) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
}
return newFocus ? newFocus : oldFocus;
}
Element* handleSkipDown(Element* oldFocus) {
if (m_items.empty()) return oldFocus;
invalidate();
resetNavigationState();
const float targetOffset = (m_listHeight > getHeight()) ?
static_cast<float>(m_listHeight - getHeight()) : 0.0f;
static constexpr float tolerance = 0.0f;
// Find last focusable item
size_t lastFocusableIndex = m_items.size();
for (ssize_t i = static_cast<ssize_t>(m_items.size()) - 1; i >= 0; --i) {
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test) {
lastFocusableIndex = static_cast<size_t>(i);
break;
}
}
const bool alreadyAtBottom = (lastFocusableIndex < m_items.size()) &&
(m_focusedIndex == lastFocusableIndex) &&
(std::abs(m_nextOffset - targetOffset) <= tolerance);
if (alreadyAtBottom) return oldFocus;
const float viewHeight = static_cast<float>(getHeight());
const float maxOffset = (m_listHeight > viewHeight) ? static_cast<float>(m_listHeight - viewHeight) : 0.0f;
const float targetViewportTop = std::min(m_offset + viewHeight, maxOffset);
const float actualTravelDistance = targetViewportTop - m_offset;
const bool traveledFullViewport = (actualTravelDistance >= viewHeight - tolerance);
const float targetViewportCenter = targetViewportTop + (viewHeight / 2.0f + VIEW_CENTER_OFFSET);
float itemTop = 0.0f;
size_t targetIndex = 0;
bool foundFocusable = false;
float bestDistance = std::numeric_limits<float>::max();
for (size_t i = 0; i < m_items.size(); ++i) {
const float itemHeight = m_items[i]->getHeight();
const float itemCenter = itemTop + (itemHeight / 2.0f);
const float distanceFromCenter = std::abs(itemCenter - targetViewportCenter);
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test && test->m_isItem && distanceFromCenter < bestDistance) {
targetIndex = i;
bestDistance = distanceFromCenter;
foundFocusable = true;
}
itemTop += itemHeight;
}
const float oldOffset = m_nextOffset;
if (foundFocusable) {
bool nearBottom = true;
if (targetIndex > m_focusedIndex && traveledFullViewport) {
m_focusedIndex = targetIndex;
nearBottom = false;
}
isTableScrolling.store(false, std::memory_order_release);
updateScrollOffset();
Element* newFocus = m_items[targetIndex]->requestFocus(oldFocus, FocusDirection::None);
if (newFocus && newFocus != oldFocus && !nearBottom && traveledFullViewport) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
return newFocus;
} else {
return handleJumpToBottom(oldFocus);
}
} else {
// Scroll viewport even if no focusable items
isTableScrolling.store(true, std::memory_order_release);
m_nextOffset = targetViewportTop;
if (std::abs(m_nextOffset - oldOffset) > 0.0f) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
}
// Focus last visible focusable item
float searchItemTop = 0.0f;
size_t lastVisibleFocusable = m_focusedIndex;
for (size_t i = 0; i < m_items.size(); ++i) {
const float itemHeight = m_items[i]->getHeight();
const float itemBottom = searchItemTop + itemHeight;
if (searchItemTop >= targetViewportTop + viewHeight) break;
if (itemBottom > targetViewportTop) {
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test && test->m_isItem) lastVisibleFocusable = i;
}
searchItemTop += itemHeight;
}
if (lastVisibleFocusable != m_focusedIndex) {
m_focusedIndex = lastVisibleFocusable;
Element* newFocus = m_items[m_focusedIndex]->requestFocus(oldFocus, FocusDirection::None);
if (newFocus && newFocus != oldFocus) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
return newFocus;
}
}
}
return oldFocus;
}
Element* handleSkipUp(Element* oldFocus) {
if (m_items.empty()) return oldFocus;
invalidate();
resetNavigationState();
static constexpr float targetOffset = 0.0f;
static constexpr float tolerance = 0.0f;
// Find first focusable item
size_t firstFocusableIndex = m_items.size();
for (size_t i = 0; i < m_items.size(); ++i) {
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test) {
firstFocusableIndex = i;
break;
}
}
const bool alreadyAtTop = (firstFocusableIndex < m_items.size()) &&
(m_focusedIndex == firstFocusableIndex) &&
(std::abs(m_nextOffset - targetOffset) <= tolerance);
if (alreadyAtTop) return oldFocus;
const float viewHeight = static_cast<float>(getHeight());
const float targetViewportTop = std::max(0.0f, m_offset - viewHeight);
const float actualTravelDistance = m_offset - targetViewportTop;
const bool traveledFullViewport = (actualTravelDistance >= viewHeight - tolerance);
const float targetViewportCenter = targetViewportTop + (viewHeight / 2.0f + VIEW_CENTER_OFFSET);
float itemTop = 0.0f;
size_t targetIndex = 0;
bool foundFocusable = false;
float bestDistance = std::numeric_limits<float>::max();
for (size_t i = 0; i < m_items.size(); ++i) {
const float itemHeight = m_items[i]->getHeight();
const float itemCenter = itemTop + (itemHeight / 2.0f);
const float distanceFromCenter = std::abs(itemCenter - targetViewportCenter);
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test && test->m_isItem && distanceFromCenter < bestDistance) {
targetIndex = i;
bestDistance = distanceFromCenter;
foundFocusable = true;
}
itemTop += itemHeight;
}
const float oldOffset = m_nextOffset;
if (foundFocusable) {
bool nearTop = true;
if (targetIndex < m_focusedIndex && traveledFullViewport) {
m_focusedIndex = targetIndex;
nearTop = false;
}
isTableScrolling.store(false, std::memory_order_release);
updateScrollOffset();
Element* newFocus = m_items[targetIndex]->requestFocus(oldFocus, FocusDirection::None);
if (newFocus && newFocus != oldFocus && !nearTop && traveledFullViewport) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
return newFocus;
} else {
return handleJumpToTop(oldFocus);
}
} else {
// Scroll viewport even if no focusable items
isTableScrolling.store(true, std::memory_order_release);
m_nextOffset = targetViewportTop;
if (std::abs(m_nextOffset - oldOffset) > 0.0f) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
}
// Focus first visible focusable item
float searchItemTop = 0.0f;
size_t firstVisibleFocusable = m_focusedIndex;
for (size_t i = 0; i < m_items.size(); ++i) {
const float itemHeight = m_items[i]->getHeight();
const float itemBottom = searchItemTop + itemHeight;
if (itemBottom > targetViewportTop && searchItemTop < targetViewportTop + viewHeight) {
Element* test = m_items[i]->requestFocus(nullptr, FocusDirection::None);
if (test && test->m_isItem) {
firstVisibleFocusable = i;
break;
}
}
searchItemTop += itemHeight;
}
if (firstVisibleFocusable != m_focusedIndex) {
m_focusedIndex = firstVisibleFocusable;
Element* newFocus = m_items[m_focusedIndex]->requestFocus(oldFocus, FocusDirection::None);
if (newFocus && newFocus != oldFocus) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
return newFocus;
}
}
}
return oldFocus;
}
inline void initializePrefixSums() {
prefixSums.clear();
prefixSums.resize(m_items.size() + 1, 0.0f);
for (size_t i = 1; i < prefixSums.size(); ++i) {
prefixSums[i] = prefixSums[i - 1] + m_items[i - 1]->getHeight();
}
}
// Keep your EXACT original updateScrollOffset() method unchanged:
virtual void updateScrollOffset() {
if (Element::getInputMode() != InputMode::Controller) return;
if (m_listHeight <= getHeight()) {
m_nextOffset = m_offset = 0;
return;
}
// Calculate position of focused item
float itemPos = 0.0f;
for (size_t i = 0; i < m_focusedIndex && i < m_items.size(); ++i) {
itemPos += m_items[i]->getHeight();
}
// Get the focused item's height
const float itemHeight = (m_focusedIndex < m_items.size()) ? m_items[m_focusedIndex]->getHeight() : 0.0f;
// Calculate viewport height
const float viewHeight = static_cast<float>(getHeight());
// FIXED: Special handling for the first focusable item
//if (m_focusedIndex == 0 || itemPos <= viewHeight * 0.3f) {
// // For items at the very top or very close to top, snap to absolute zero
// m_nextOffset = 0.0f;
// return;
//}
// FIXED: Special handling for items near the bottom
const float maxOffset = static_cast<float>(m_listHeight - getHeight());
//const float itemBottom = itemPos + itemHeight;
//if (itemBottom >= m_listHeight - (viewHeight * 0.3f)) {
// // For items near the bottom, snap to max offset
// m_nextOffset = maxOffset;
// return;
//}
// For middle items, use centering logic
const float itemCenterPos = itemPos + (itemHeight / 2.0f);
const float viewportCenter = viewHeight / 2.0f + VIEW_CENTER_OFFSET + 0.5f; // add slight offset
//float idealOffset = itemCenterPos - viewportCenter;
// Clamp to valid scroll bounds
const float idealOffset = std::max(0.0f, std::min(itemCenterPos - viewportCenter, maxOffset));
// Set target for smooth animation
m_nextOffset = idealOffset;
//m_nextOffset = std::max(0.0f, std::min(itemPos + itemHeight * 0.5f - (viewHeight * 0.5f + 7.0f), maxOffset));
}
};
/**
* @brief A item that goes into a list
*
*/
class ListItem : public Element {
public:
u32 width, height;
u64 m_touchStartTime_ns;
bool isLocked = false;
#if IS_LAUNCHER_DIRECTIVE
ListItem(const std::string& text, const std::string& value = "", bool isMini = false, bool useScriptKey = true)
: Element(), m_text(text), m_value(value), m_listItemHeight(isMini ? tsl::style::MiniListItemDefaultHeight : tsl::style::ListItemDefaultHeight) {
m_isItem = true;
m_flags.m_useScriptKey = useScriptKey;
m_flags.m_useClickAnimation = true;
m_text_clean = m_text;
ult::removeTag(m_text_clean);
applyInitialTranslations();
if (!value.empty()) applyInitialTranslations(true);
}
#else
ListItem(const std::string& text, const std::string& value = "", bool isMini = false)
: Element(), m_text(text), m_value(value), m_listItemHeight(isMini ? tsl::style::MiniListItemDefaultHeight : tsl::style::ListItemDefaultHeight) {
m_isItem = true;
m_flags.m_useClickAnimation = true;
m_text_clean = m_text;
ult::removeTag(m_text_clean);
applyInitialTranslations();
if (!value.empty()) applyInitialTranslations(true);
}
#endif
virtual ~ListItem() = default;
virtual void draw(gfx::Renderer *renderer) override {
const bool useClickTextColor = m_flags.m_touched && Element::getInputMode() == InputMode::Touch && ult::touchInBounds;
if (useClickTextColor) [[unlikely]] {
auto drawFunc = ult::expandedMemory ? &gfx::Renderer::drawRectMultiThreaded : &gfx::Renderer::drawRect;
(renderer->*drawFunc)(this->getX() + 4, this->getY(), this->getWidth() - 8, this->getHeight(), aWithOpacity(clickColor));
}
const s16 yOffset = ((tsl::style::ListItemDefaultHeight - m_listItemHeight) >> 1) + 1;
if (!m_maxWidth) [[unlikely]] {
calculateWidths(renderer);
}
// Optimized separator drawing
const float topBound = this->getTopBound();
const float bottomBound = this->getBottomBound();
static float lastBottomBound = 0.0f;
if (lastBottomBound != topBound) [[unlikely]] {
renderer->drawRect(this->getX() + 4, topBound, this->getWidth() + 10, 1, a(separatorColor));
}
renderer->drawRect(this->getX() + 4, bottomBound, this->getWidth() + 10, 1, a(separatorColor));
lastBottomBound = bottomBound;
#if IS_LAUNCHER_DIRECTIVE
static const std::vector<std::string> specialChars = {ult::STAR_SYMBOL};
#else
static const std::vector<std::string> specialChars = {ult::DIVIDER_SYMBOL};
#endif
// Fast path for non-truncated text
if (!m_flags.m_truncated) [[likely]] {
const Color textColor = m_focused
? (!ult::useSelectionText
? (m_flags.m_hasCustomTextColor ? m_customTextColor : defaultTextColor)
: (useClickTextColor
? clickTextColor
: selectedTextColor))
: (m_flags.m_hasCustomTextColor
? m_customTextColor
: (useClickTextColor
? clickTextColor
: defaultTextColor));
#if IS_LAUNCHER_DIRECTIVE
renderer->drawStringWithColoredSections(m_text_clean, false, specialChars, this->getX() + 19, this->getY() + 45 - yOffset, 23,
textColor, (m_focused ? starColor : selectionStarColor));
#else
renderer->drawStringWithColoredSections(m_text_clean, false, specialChars, this->getX() + 19, this->getY() + 45 - yOffset, 23,
textColor, textSeparatorColor);
#endif
} else {
drawTruncatedText(renderer, yOffset, useClickTextColor, specialChars);
}
if (!m_value.empty()) [[likely]] {
drawValue(renderer, yOffset, useClickTextColor);
}
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
this->setBoundaries(this->getX() + 3, this->getY(), this->getWidth() + 9, m_listItemHeight);
}
virtual bool onClick(u64 keys) override {
if (keys & KEY_A) [[likely]] {
triggerRumbleClick.store(true, std::memory_order_release);
if (isLocked)
triggerWallSound.store(true, std::memory_order_release);
else if (m_value.find(ult::CAPITAL_ON_STR) != std::string::npos)
triggerOffSound.store(true, std::memory_order_release);
else if (m_value.find(ult::CAPITAL_OFF_STR) != std::string::npos)
triggerOnSound.store(true, std::memory_order_release);
else
triggerEnterSound.store(true, std::memory_order_release);
if (m_flags.m_useClickAnimation)
triggerClickAnimation();
} else if (keys & (KEY_UP | KEY_DOWN | KEY_LEFT | KEY_RIGHT)) [[unlikely]] {
m_clickAnimationProgress = 0;
}
//if (keys & KEY_B) {
// triggerRumbleDoubleClick.store(true, std::memory_order_release);
// triggerExitSound.store(true, std::memory_order_release);
//
//}
return Element::onClick(keys);
}
virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
if (event == TouchEvent::Touch) [[likely]] {
if ((m_flags.m_touched = inBounds(currX, currY))) [[likely]] {
m_touchStartTime_ns = armTicksToNs(armGetSystemTick());
}
return false;
}
if (event == TouchEvent::Release && m_flags.m_touched) [[likely]] {
m_flags.m_touched = false;
if (Element::getInputMode() == InputMode::Touch) [[likely]] {
#if IS_LAUNCHER_DIRECTIVE
const s64 keyToUse = determineKeyOnTouchRelease(m_flags.m_useScriptKey);
#else
const s64 keyToUse = determineKeyOnTouchRelease(false);
#endif
const bool handled = onClick(keyToUse);
m_clickAnimationProgress = 0;
return handled;
}
}
return false;
}
virtual void setFocused(bool state) override {
if (state != m_focused) [[likely]] {
m_flags.m_scroll = false;
m_scrollOffset = 0;
timeIn_ns = armTicksToNs(armGetSystemTick());
Element::setFocused(state);
}
}
virtual inline Element* requestFocus(Element *oldFocus, FocusDirection direction) override {
return this;
}
inline void setText(const std::string& text) {
if (m_text != text) [[likely]] {
m_text = text;
m_text_clean = m_text;
ult::removeTag(m_text_clean);
resetTextProperties();
applyInitialTranslations();
}
}
inline void setValue(const std::string& value, bool faint = false) {
if (m_value != value || m_flags.m_faint != faint) [[likely]] {
m_value = value;
m_flags.m_faint = faint;
m_maxWidth = 0;
if (!value.empty()) applyInitialTranslations(true);
}
}
inline void setTextColor(Color color) {
m_customTextColor = color;
m_flags.m_hasCustomTextColor = true;
}
inline void setValueColor(Color color) {
m_customValueColor = color;
m_flags.m_hasCustomValueColor = true;
}
inline void clearTextColor() {
m_flags.m_hasCustomTextColor = false;
}
inline void clearValueColor() {
m_flags.m_hasCustomValueColor = false;
}
inline void disableClickAnimation() {
m_flags.m_useClickAnimation = false;
}
inline void enableClickAnimation() {
m_flags.m_useClickAnimation = true;
}
inline const std::string& getText() const noexcept {
return m_text;
}
inline const std::string& getValue() const noexcept {
return m_value;
}
virtual bool matchesJumpCriteria(const std::string& jumpText, const std::string& jumpValue, bool exactMatch=true) const {
if (jumpText.empty() && jumpValue.empty()) return false;
bool textMatches, valueMatches;
if (exactMatch) {
textMatches = (m_text == jumpText);
valueMatches = (m_value == jumpValue);
} else { // contains check
textMatches = (m_text.find(jumpText) != std::string::npos);
valueMatches = (m_value.find(jumpValue) != std::string::npos);
}
if (jumpText.empty() && !jumpValue.empty())
return valueMatches;
else if (!jumpText.empty() && jumpValue.empty())
return textMatches;
return (textMatches && valueMatches);
}
protected:
u64 timeIn_ns;
std::string m_text;
std::string m_text_clean;
std::string m_value;
std::string m_scrollText;
std::string m_ellipsisText;
u16 m_listItemHeight; // Changed from u32 to u16
// Bitfield for boolean flags - saves ~7 bytes per instance
struct {
bool m_scroll : 1;
bool m_truncated : 1;
bool m_faint : 1;
bool m_touched : 1;
bool m_hasCustomTextColor : 1;
bool m_hasCustomValueColor : 1;
bool m_useClickAnimation : 1;
#if IS_LAUNCHER_DIRECTIVE
bool m_useScriptKey : 1;
#endif
} m_flags = {};
Color m_customTextColor = {0};
Color m_customValueColor = {0};
float m_scrollOffset = 0.0f;
u16 m_maxWidth = 0; // Changed from u32 to u16
u16 m_textWidth = 0; // Changed from u32 to u16
private:
// Consolidated scroll constants struct
struct ScrollConstants {
double totalCycleDuration;
double delayDuration;
double scrollDuration;
double accelTime;
double constantVelocityTime;
double maxVelocity;
double accelDistance;
double constantVelocityDistance;
double minScrollDistance;
double invAccelTime;
double invDecelTime;
double invBillion;
bool initialized = false;
};
void applyInitialTranslations(bool isValue = false) {
std::string& target = isValue ? m_value : m_text_clean;
ult::applyLangReplacements(target, isValue);
ult::convertComboToUnicode(target);
#ifdef UI_OVERRIDE_PATH
{
const std::string originalKey = target;
std::shared_lock<std::shared_mutex> readLock(tsl::gfx::s_translationCacheMutex);
auto translatedIt = ult::translationCache.find(originalKey);
if (translatedIt != ult::translationCache.end()) {
target = translatedIt->second;
} else {
readLock.unlock();
std::unique_lock<std::shared_mutex> writeLock(tsl::gfx::s_translationCacheMutex);
translatedIt = ult::translationCache.find(originalKey);
if (translatedIt != ult::translationCache.end()) {
target = translatedIt->second;
} else {
ult::translationCache[originalKey] = originalKey;
}
}
}
#endif
}
void calculateWidths(gfx::Renderer* renderer) {
if (m_value.empty()) {
m_maxWidth = getWidth() - 62;
} else {
m_maxWidth = getWidth() - renderer->getTextDimensions(m_value, false, 20).first - 66;
}
const u16 width = renderer->getTextDimensions(m_text_clean, false, 23).first;
m_flags.m_truncated = width > m_maxWidth + 20;
if (m_flags.m_truncated) [[unlikely]] {
m_scrollText.clear();
m_scrollText.reserve(m_text_clean.size() * 2 + 8);
m_scrollText.append(m_text_clean).append(" ");
m_textWidth = renderer->getTextDimensions(m_scrollText, false, 23).first;
m_scrollText.append(m_text_clean);
m_ellipsisText = renderer->limitStringLength(m_text_clean, false, 23, m_maxWidth);
} else {
m_textWidth = width;
}
}
void drawTruncatedText(gfx::Renderer* renderer, s32 yOffset, bool useClickTextColor, const std::vector<std::string>& specialSymbols = {}) {
if (m_focused) {
renderer->enableScissoring(getX() + 6, 97, m_maxWidth + (m_value.empty() ? 49 : 27), tsl::cfg::FramebufferHeight - 170);
#if IS_LAUNCHER_DIRECTIVE
renderer->drawStringWithColoredSections(m_scrollText, false, specialSymbols, getX() + 19 - static_cast<s32>(m_scrollOffset), getY() + 45 - yOffset, 23,
!ult::useSelectionText ? defaultTextColor: (useClickTextColor ? clickTextColor : selectedTextColor), (starColor));
#else
renderer->drawStringWithColoredSections(m_scrollText, false, specialSymbols, getX() + 19 - static_cast<s32>(m_scrollOffset), getY() + 45 - yOffset, 23,
!ult::useSelectionText ? defaultTextColor: (useClickTextColor ? clickTextColor : selectedTextColor), (textSeparatorColor));
#endif
renderer->disableScissoring();
handleScrolling();
} else {
#if IS_LAUNCHER_DIRECTIVE
renderer->drawStringWithColoredSections(m_ellipsisText, false, specialSymbols, getX() + 19, getY() + 45 - yOffset, 23,
m_flags.m_hasCustomTextColor ? m_customTextColor : (useClickTextColor ? clickTextColor : defaultTextColor), (starColor));
#else
renderer->drawStringWithColoredSections(m_ellipsisText, false, specialSymbols, getX() + 19, getY() + 45 - yOffset, 23,
m_flags.m_hasCustomTextColor ? m_customTextColor : (useClickTextColor ? clickTextColor : defaultTextColor), (textSeparatorColor));
#endif
}
}
void handleScrolling() {
static ScrollConstants sc;
static u64 lastUpdateTime = 0;
static float cachedScrollOffset = 0.0f;
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
const u64 elapsed_ns = currentTime_ns - timeIn_ns;
if (!sc.initialized || sc.minScrollDistance != static_cast<double>(m_textWidth)) {
sc.delayDuration = 2.0;
static constexpr double pauseDuration = 1.0;
sc.maxVelocity = 166.0;
sc.accelTime = 0.5;
static constexpr double decelTime = 0.5;
sc.minScrollDistance = static_cast<double>(m_textWidth);
sc.accelDistance = 0.5 * sc.maxVelocity * sc.accelTime;
const double decelDistance = 0.5 * sc.maxVelocity * decelTime;
sc.constantVelocityDistance = std::max(0.0, sc.minScrollDistance - sc.accelDistance - decelDistance);
sc.constantVelocityTime = sc.constantVelocityDistance / sc.maxVelocity;
sc.scrollDuration = sc.accelTime + sc.constantVelocityTime + decelTime;
sc.totalCycleDuration = sc.delayDuration + sc.scrollDuration + pauseDuration;
sc.invAccelTime = 1.0 / sc.accelTime;
sc.invDecelTime = 1.0 / decelTime;
sc.invBillion = 1.0 / 1000000000.0;
sc.initialized = true;
}
const double elapsed_seconds = static_cast<double>(elapsed_ns) * sc.invBillion;
if (currentTime_ns - lastUpdateTime >= 8333333ULL) {
const double cyclePosition = std::fmod(elapsed_seconds, sc.totalCycleDuration);
if (cyclePosition < sc.delayDuration) [[likely]] {
cachedScrollOffset = 0.0f;
} else if (cyclePosition < sc.delayDuration + sc.scrollDuration) [[likely]] {
const double scrollTime = cyclePosition - sc.delayDuration;
double distance;
if (scrollTime <= sc.accelTime) {
const double t = scrollTime * sc.invAccelTime;
const double smoothT = t * t;
distance = smoothT * sc.accelDistance;
} else if (scrollTime <= sc.accelTime + sc.constantVelocityTime) {
const double constantTime = scrollTime - sc.accelTime;
distance = sc.accelDistance + (constantTime * sc.maxVelocity);
} else {
const double decelStartTime = sc.accelTime + sc.constantVelocityTime;
const double t = (scrollTime - decelStartTime) * sc.invDecelTime;
const double oneMinusT = 1.0 - t;
const double smoothT = 1.0 - oneMinusT * oneMinusT;
distance = sc.accelDistance + sc.constantVelocityDistance + (smoothT * (sc.minScrollDistance - sc.accelDistance - sc.constantVelocityDistance));
}
cachedScrollOffset = static_cast<float>(distance < sc.minScrollDistance ? distance : sc.minScrollDistance);
} else [[unlikely]] {
cachedScrollOffset = static_cast<float>(m_textWidth);
}
lastUpdateTime = currentTime_ns;
}
m_scrollOffset = cachedScrollOffset;
if (elapsed_seconds >= sc.totalCycleDuration) [[unlikely]] {
timeIn_ns = currentTime_ns;
}
}
void drawValue(gfx::Renderer* renderer, s32 yOffset, bool useClickTextColor) {
const s32 xPosition = getX() + m_maxWidth + 47;
const s32 yPosition = getY() + 45 - yOffset-1;
static constexpr s32 fontSize = 20;
static bool lastRunningInterpreter = false;
const auto textColor = determineValueTextColor(useClickTextColor, lastRunningInterpreter);
if (m_value != ult::INPROGRESS_SYMBOL) [[likely]] {
static const std::vector<std::string> specialChars = {ult::DIVIDER_SYMBOL};
renderer->drawStringWithColoredSections(m_value, false, specialChars, xPosition, yPosition, fontSize, textColor, textSeparatorColor);
} else {
drawThrobber(renderer, xPosition, yPosition, fontSize, textColor);
}
lastRunningInterpreter = ult::runningInterpreter.load(std::memory_order_acquire);
}
Color determineValueTextColor(bool useClickTextColor, bool lastRunningInterpreter) const {
if (m_focused && ult::useSelectionValue) {
if (m_value == ult::DROPDOWN_SYMBOL || m_value == ult::OPTION_SYMBOL) {
return useClickTextColor ? (clickTextColor) :
(m_flags.m_faint ? offTextColor : (useClickTextColor ? clickTextColor : (ult::useSelectionText ? selectedTextColor : defaultTextColor)));
}
const bool isRunning = ult::runningInterpreter.load(std::memory_order_acquire) || lastRunningInterpreter;
if (isRunning && (m_value.find(ult::DOWNLOAD_SYMBOL) != std::string::npos ||
m_value.find(ult::UNZIP_SYMBOL) != std::string::npos ||
m_value.find(ult::COPY_SYMBOL) != std::string::npos)) {
return m_flags.m_faint ? offTextColor : (inprogressTextColor);
}
if (m_value == ult::INPROGRESS_SYMBOL) {
return m_flags.m_faint ? offTextColor : (inprogressTextColor);
}
if (m_value == ult::CROSSMARK_SYMBOL) {
return m_flags.m_faint ? offTextColor : (invalidTextColor);
}
return useClickTextColor ? clickTextColor : selectedValueTextColor;
}
if (m_flags.m_hasCustomValueColor) {
return m_customValueColor;
}
if (m_value == ult::DROPDOWN_SYMBOL || m_value == ult::OPTION_SYMBOL) {
return (m_focused ? (useClickTextColor ? clickTextColor : (m_flags.m_faint ? offTextColor : (ult::useSelectionText ? selectedTextColor : defaultTextColor))) :
(useClickTextColor ? clickTextColor : (m_flags.m_faint ? offTextColor : defaultTextColor)));
}
const bool isRunning = ult::runningInterpreter.load(std::memory_order_acquire) || lastRunningInterpreter;
if (isRunning && (m_value.find(ult::DOWNLOAD_SYMBOL) != std::string::npos ||
m_value.find(ult::UNZIP_SYMBOL) != std::string::npos ||
m_value.find(ult::COPY_SYMBOL) != std::string::npos)) {
return m_flags.m_faint ? offTextColor : (inprogressTextColor);
}
if (m_value == ult::INPROGRESS_SYMBOL) {
return m_flags.m_faint ? offTextColor : (inprogressTextColor);
}
if (m_value == ult::CROSSMARK_SYMBOL) {
return m_flags.m_faint ? offTextColor : (invalidTextColor);
}
return (m_flags.m_faint ? offTextColor : (onTextColor));
}
void drawThrobber(gfx::Renderer* renderer, s32 xPosition, s32 yPosition, s32 fontSize, Color textColor) {
static size_t throbberCounter = 0;
const auto& throbberSymbol = ult::THROBBER_SYMBOLS[(throbberCounter / 10) % ult::THROBBER_SYMBOLS.size()];
throbberCounter = (throbberCounter + 1) % (10 * ult::THROBBER_SYMBOLS.size());
renderer->drawString(throbberSymbol, false, xPosition, yPosition, fontSize, textColor);
}
s64 determineKeyOnTouchRelease(bool useScriptKey) const {
const u64 touchDuration_ns = armTicksToNs(armGetSystemTick()) - m_touchStartTime_ns;
const float touchDurationInSeconds = static_cast<float>(touchDuration_ns) * 1e-9f;
#if IS_LAUNCHER_DIRECTIVE
if (touchDurationInSeconds >= 0.7f) [[unlikely]] {
ult::longTouchAndRelease.store(true, std::memory_order_release);
return useScriptKey ? SCRIPT_KEY : STAR_KEY;
}
#endif
if (touchDurationInSeconds >= 0.3f) [[unlikely]] {
ult::shortTouchAndRelease.store(true, std::memory_order_release);
return useScriptKey ? SCRIPT_KEY : SETTINGS_KEY;
}
return KEY_A;
}
void resetTextProperties() {
m_scrollText.clear();
m_ellipsisText.clear();
m_maxWidth = 0;
}
};
class MiniListItem : public ListItem {
public:
#if IS_LAUNCHER_DIRECTIVE
// Constructor for MiniListItem, with no `isMini` boolean.
MiniListItem(const std::string& text, const std::string& value = "", bool useScriptKey = false)
: ListItem(text, value, true, useScriptKey) { // Call the parent constructor with `isMini = true`
#else
MiniListItem(const std::string& text, const std::string& value = "")
: ListItem(text, value, true) { // Call the parent constructor with `isMini = true`
#endif
// Additional MiniListItem-specific initialization can go here, if necessary.
}
// Destructor if needed (inherits default behavior from ListItem)
virtual ~MiniListItem() {}
};
/**
* @brief A item that goes into a list (this version uses value and faint color sourcing)
*
*/
class ListItemV2 : public Element {
public:
u32 width, height;
u64 m_touchStartTime_ns; // Track the time when touch starts
/**
* @brief Constructor
*
* @param text Initial description text
*/
ListItemV2(const std::string& text, const std::string& value = "", Color valueColor = onTextColor, Color faintColor = offTextColor)
: Element(), m_text(text), m_value(value), m_valueColor{valueColor}, m_faintColor{faintColor} {
}
virtual ~ListItemV2() {}
virtual void draw(gfx::Renderer *renderer) override {
static float lastBottomBound;
bool useClickTextColor = false;
if (this->m_touched && Element::getInputMode() == InputMode::Touch) {
if (ult::touchInBounds) {
//renderer->drawRect(ELEMENT_BOUNDS(this), a(clickColor));
renderer->drawRect( this->getX()+4, this->getY(), this->getWidth()-8, this->getHeight(), a(clickColor));
useClickTextColor = true;
}
//renderer->drawRect(ELEMENT_BOUNDS(this), tsl::style::color::ColorClickAnimation);
}
// Calculate vertical offset to center the text
const s32 yOffset = (tsl::style::ListItemDefaultHeight - this->m_listItemHeight) / 2;
if (this->m_maxWidth == 0) {
if (this->m_value.length() > 0) {
//std::tie(width, height) = renderer->drawString(this->m_value, false, 0, 0, 20, a(tsl::style::color::ColorTransparent));
//auto valueWidth = renderer->getTextDimensions(this->m_value, false, 20).first;
width = renderer->getTextDimensions(this->m_value, false, 20).first;
this->m_maxWidth = this->getWidth() - width - 70 +4;
} else {
this->m_maxWidth = this->getWidth() - 40 -10 -12;
}
//std::tie(width, height) = renderer->drawString(this->m_text, false, 0, 0, 23, a(tsl::style::color::ColorTransparent));
//auto textWidth = renderer->getTextDimensions(this->m_text, false, 23).first;
width = renderer->getTextDimensions(this->m_text, false, 23).first;
this->m_trunctuated = width > this->m_maxWidth+20;
if (this->m_trunctuated) {
this->m_scrollText = this->m_text + " ";
//std::tie(width, height) = renderer->drawString(this->m_scrollText, false, 0, 0, 23, a(tsl::style::color::ColorTransparent));
//auto scrollWidth = renderer->getTextDimensions(this->m_scrollText, false, 23).first;
width = renderer->getTextDimensions(this->m_scrollText, false, 23).first;
this->m_scrollText += this->m_text;
this->m_textWidth = width;
this->m_ellipsisText = renderer->limitStringLength(this->m_text, false, 23, this->m_maxWidth);
} else {
this->m_textWidth = width;
}
}
if (lastBottomBound != this->getTopBound())
renderer->drawRect(this->getX()+4, this->getTopBound(), this->getWidth()+6 +4, 1, a(separatorColor));
renderer->drawRect(this->getX()+4, this->getBottomBound(), this->getWidth()+6 +4, 1, a(separatorColor));
lastBottomBound = this->getBottomBound();
if (this->m_trunctuated) {
if (this->m_focused) {
if (this->m_value.length() > 0)
renderer->enableScissoring(this->getX()+6, 97, this->m_maxWidth + 30 -3, tsl::cfg::FramebufferHeight-73-97);
else
renderer->enableScissoring(this->getX()+6, 97, this->m_maxWidth + 40 +9, tsl::cfg::FramebufferHeight-73-97);
renderer->drawString(this->m_scrollText, false, this->getX() + 20-1 - this->m_scrollOffset, this->getY() + 45 - yOffset, 23, a(selectedTextColor));
renderer->disableScissoring();
// Handle scrolling with frame rate compensation
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
const u64 elapsed_ns = currentTime_ns - this->timeIn_ns;
// Frame rate compensation - cache calculations to reduce stutter
static u64 lastUpdateTime = 0;
static float cachedScrollOffset = 0.0f;
// Pre-compute constants as statics to avoid recalculation
static bool constantsInitialized = false;
static double totalCycleDuration;
static double delayDuration;
static double scrollDuration;
static double accelTime;
static double constantVelocityTime;
static double maxVelocity;
static double accelDistance;
static double constantVelocityDistance;
static double minScrollDistance;
static double invAccelTime; // 1/accelTime for multiplication instead of division
static double invDecelTime; // 1/decelTime for multiplication instead of division
static double invBillion; // 1/1000000000.0 for ns to seconds conversion
if (!constantsInitialized || minScrollDistance != static_cast<double>(this->m_textWidth)) {
// Constants for velocity-based scrolling
delayDuration = 2.0;
static constexpr double pauseDuration = 1.0;
maxVelocity = 166.0;
accelTime = 0.5;
static constexpr double decelTime = 0.5;
// Pre-calculate derived constants
minScrollDistance = static_cast<double>(this->m_textWidth);
accelDistance = 0.5 * maxVelocity * accelTime;
const double decelDistance = 0.5 * maxVelocity * decelTime;
constantVelocityDistance = std::max(0.0, minScrollDistance - accelDistance - decelDistance);
constantVelocityTime = constantVelocityDistance / maxVelocity;
scrollDuration = accelTime + constantVelocityTime + decelTime;
totalCycleDuration = delayDuration + scrollDuration + pauseDuration;
// Pre-calculate reciprocals for faster division
invAccelTime = 1.0 / accelTime;
invDecelTime = 1.0 / decelTime;
invBillion = 1.0 / 1000000000.0;
constantsInitialized = true;
}
// Fast ns to seconds conversion
const double elapsed_seconds = static_cast<double>(elapsed_ns) * invBillion;
// Update at consistent intervals regardless of frame rate
if (currentTime_ns - lastUpdateTime >= 8333333ULL) { // ~120 FPS update rate
// Use std::fmod for modulo - it's optimized and faster than loops
const double cyclePosition = std::fmod(elapsed_seconds, totalCycleDuration);
if (cyclePosition < delayDuration) {
// Delay phase - no scrolling
cachedScrollOffset = 0.0f;
} else if (cyclePosition < delayDuration + scrollDuration) {
// Scrolling phase - velocity-based movement
const double scrollTime = cyclePosition - delayDuration;
double distance;
if (scrollTime <= accelTime) {
// Acceleration phase - quadratic ease-in
const double t = scrollTime * invAccelTime; // Multiply instead of divide
const double smoothT = t * t;
distance = smoothT * accelDistance;
} else if (scrollTime <= accelTime + constantVelocityTime) {
// Constant velocity phase
const double constantTime = scrollTime - accelTime;
distance = accelDistance + (constantTime * maxVelocity);
} else {
// Deceleration phase - quadratic ease-out
const double decelStartTime = accelTime + constantVelocityTime;
const double t = (scrollTime - decelStartTime) * invDecelTime; // Multiply instead of divide
const double oneMinusT = 1.0 - t;
const double smoothT = 1.0 - oneMinusT * oneMinusT; // Avoid repeated calculation
distance = accelDistance + constantVelocityDistance + (smoothT * (minScrollDistance - accelDistance - constantVelocityDistance));
}
// Use branchless min with conditional move behavior
cachedScrollOffset = static_cast<float>(distance < minScrollDistance ? distance : minScrollDistance);
} else {
// Pause phase - stay at end
cachedScrollOffset = static_cast<float>(this->m_textWidth);
}
lastUpdateTime = currentTime_ns;
}
// Use cached value for consistent display
this->m_scrollOffset = cachedScrollOffset;
// Reset timer when cycle completes
if (elapsed_seconds >= totalCycleDuration) {
this->timeIn_ns = currentTime_ns;
}
} else {
renderer->drawString(this->m_ellipsisText, false, this->getX() + 20-1, this->getY() + 45 - yOffset, 23, a(!useClickTextColor ? defaultTextColor : clickTextColor));
}
} else {
// Render the text with special character handling
#if IS_LAUNCHER_DIRECTIVE
static const std::vector<std::string> specialChars = {ult::STAR_SYMBOL};
#else
static const std::vector<std::string> specialChars = {};
#endif
renderer->drawStringWithColoredSections(this->m_text, false, specialChars, this->getX() + 20-1, this->getY() + 45 - yOffset, 23,
(this->m_focused ? (!useClickTextColor ? selectedTextColor : clickTextColor) : (!useClickTextColor ? defaultTextColor : clickTextColor)),
(this->m_focused ? starColor : selectionStarColor)
);
}
// CUSTOM SECTION START (modification for submenu footer color)
const s32 xPosition = this->getX() + this->m_maxWidth + 44 + 3;
const s32 yPosition = this->getY() + 45 - yOffset;
static constexpr s32 fontSize = 20;
//static bool lastRunningInterpreter = ult::runningInterpreter.load(std::memory_order_acquire);
// Determine text color
const auto textColor = this->m_faint ? a(m_faintColor) : a(m_valueColor);
if (this->m_value != ult::INPROGRESS_SYMBOL) {
// Draw the string with the determined text color
renderer->drawString(this->m_value, false, xPosition, yPosition, fontSize, textColor);
} else {
static size_t throbberCounter = 0;
// Reset counter to prevent overflow (every full cycle)
if (throbberCounter >= 10 * ult::THROBBER_SYMBOLS.size()) {
throbberCounter = 0;
}
// Get current throbber symbol (changes every 10 frames)
const size_t symbolIndex = (throbberCounter / 10) % ult::THROBBER_SYMBOLS.size();
const std::string& currentSymbol = ult::THROBBER_SYMBOLS[symbolIndex];
// Instance-specific counter for independent throbber animation
++throbberCounter;
renderer->drawString(currentSymbol, false, xPosition, yPosition, fontSize, textColor);
}
//lastRunningInterpreter = ult::runningInterpreter.load(std::memory_order_acquire);
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
this->setBoundaries(this->getX()+2+1, this->getY(), this->getWidth()+8+1, m_listItemHeight);
}
virtual bool onClick(u64 keys) override {
if (keys & KEY_A) {
this->triggerClickAnimation();
}
else if (keys & (KEY_UP | KEY_DOWN | KEY_LEFT | KEY_RIGHT))
this->m_clickAnimationProgress = 0;
return Element::onClick(keys);
}
virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
if (event == TouchEvent::Touch)
this->m_touched = this->inBounds(currX, currY);
if (event == TouchEvent::Release && this->m_touched) {
this->m_touched = false;
if (Element::getInputMode() == InputMode::Touch) {
const bool handled = this->onClick(KEY_A);
this->m_clickAnimationProgress = 0;
return handled;
}
}
return false;
}
virtual void setFocused(bool state) override {
this->m_scroll = false;
this->m_scrollOffset = 0;
this->timeIn_ns = armTicksToNs(armGetSystemTick());
Element::setFocused(state);
}
virtual Element* requestFocus(Element *oldFocus, FocusDirection direction) override {
return this;
}
/**
* @brief Sets the left hand description text of the list item
*
* @param text Text
*/
inline void setText(const std::string& text) {
this->m_text = text;
this->m_scrollText = "";
this->m_ellipsisText = "";
this->m_maxWidth = 0;
}
/**
* @brief Sets the right hand value text of the list item
*
* @param value Text
* @param faint Should the text be drawn in a glowing green or a faint gray
*/
inline void setValue(const std::string& value, bool faint = false) {
this->m_value = value;
this->m_faint = faint;
this->m_maxWidth = 0;
}
/**
* @brief Sets the value color
*
* @param value_color color of the value
*/
inline void setValueColor(Color value_color) {
this->m_valueColor = value_color;
}
/**
* @brief Sets the faint color
*
* @param faint_color color of the faint
*/
inline void setFaintColor(Color faint_color) {
this->m_faintColor = faint_color;
}
/**
* @brief Gets the left hand description text of the list item
*
* @return Text
*/
inline const std::string& getText() const {
return this->m_text;
}
/**
* @brief Gets the right hand value text of the list item
*
* @return Value
*/
inline const std::string& getValue() {
return this->m_value;
}
protected:
u64 timeIn_ns;
std::string m_text;
std::string m_value;
std::string m_scrollText;
std::string m_ellipsisText;
u32 m_listItemHeight = tsl::style::ListItemDefaultHeight;
#if IS_LAUNCHER_DIRECTIVE
bool m_useScriptKey = false;
#endif
Color m_valueColor;
Color m_faintColor;
bool m_scroll = false;
bool m_trunctuated = false;
bool m_faint = false;
bool m_touched = false;
u16 m_maxScroll = 0;
u16 m_scrollOffset = 0;
u32 m_maxWidth = 0;
u32 m_textWidth = 0;
u16 m_scrollAnimationCounter = 0;
};
/**
* @brief A toggleable list item that changes the state from On to Off when the A button gets pressed
*
*/
class ToggleListItem : public ListItem {
public:
/**
* @brief Constructor
*
* @param text Initial description text
* @param initialState Is the toggle set to On or Off initially
* @param onValue Value drawn if the toggle is on
* @param offValue Value drawn if the toggle is off
*/
ToggleListItem(const std::string& text, bool initialState, const std::string& onValue = ult::ON, const std::string& offValue = ult::OFF, bool isMini = false, bool delayedHandle=false)
: ListItem(text, "", isMini), m_state(initialState), m_onValue(onValue), m_offValue(offValue), m_delayedHandle(delayedHandle) {
this->setState(this->m_state);
}
virtual ~ToggleListItem() {}
virtual bool onClick(u64 keys) override {
#if IS_LAUNCHER_DIRECTIVE
if (ult::runningInterpreter.load(std::memory_order_acquire))
return false;
#endif
// Handle KEY_A for toggling
if (keys & KEY_A) {
triggerRumbleClick.store(true, std::memory_order_release);
if (!this->m_state)
triggerOnSound.store(true, std::memory_order_release);
else
triggerOffSound.store(true, std::memory_order_release);
this->m_state = !this->m_state;
if (!m_delayedHandle)
this->setState(this->m_state);
this->m_stateChangedListener(this->m_state);
return true;
}
//if (keys & KEY_B) {
// triggerRumbleDoubleClick.store(true, std::memory_order_release);
// triggerExitSound.store(true, std::memory_order_release);
//
//}
#if IS_LAUNCHER_DIRECTIVE
// Handle SCRIPT_KEY for executing script logic
else if (keys & SCRIPT_KEY) {
// Trigger the script key listener
if (this->m_scriptKeyListener) {
this->m_scriptKeyListener(this->m_state); // Pass the current state to the script key listener
}
return ListItem::onClick(keys);
}
#endif
return false;
}
/**
* @brief Gets the current state of the toggle
*
* @return State
*/
virtual inline bool getState() {
return this->m_state;
}
/**
* @brief Sets the current state of the toggle. Updates the Value
*
* @param state State
*/
virtual inline void setState(bool state) {
#if IS_LAUNCHER_DIRECTIVE
if (ult::runningInterpreter.load(std::memory_order_acquire))
return;
#endif
this->m_state = state;
this->setValue(state ? this->m_onValue : this->m_offValue, !state);
}
/**
* @brief Adds a listener that gets called whenever the state of the toggle changes
*
* @param stateChangedListener Listener with the current state passed in as parameter
*/
void setStateChangedListener(std::function<void(bool)> stateChangedListener) {
this->m_stateChangedListener = stateChangedListener;
}
#if IS_LAUNCHER_DIRECTIVE
// Attach the script key listener for SCRIPT_KEY handling
void setScriptKeyListener(std::function<void(bool)> scriptKeyListener) {
this->m_scriptKeyListener = scriptKeyListener;
}
#endif
protected:
bool m_state = true;
std::string m_onValue, m_offValue;
bool m_delayedHandle = false;
std::function<void(bool)> m_stateChangedListener = [](bool){};
#if IS_LAUNCHER_DIRECTIVE
std::function<void(bool)> m_scriptKeyListener = nullptr; // Script key listener (with state)
#endif
};
class MiniToggleListItem : public ToggleListItem {
public:
// Constructor for MiniToggleListItem, with no `isMini` boolean.
MiniToggleListItem(const std::string& text, bool initialState, const std::string& onValue = ult::ON, const std::string& offValue = ult::OFF)
: ToggleListItem(text, initialState, onValue, offValue, true) {
}
// Destructor if needed (inherits default behavior from ListItem)
virtual ~MiniToggleListItem() {}
};
class DummyListItem : public ListItem {
public:
DummyListItem()
: ListItem("") { // Use an empty string for the base class constructor
// Set the properties to indicate it's a dummy item
this->m_text = "";
this->m_value = "";
this->m_maxWidth = 0;
this->width = 0;
this->height = 0;
m_isItem = false;
}
virtual ~DummyListItem() {}
// Override the draw method to do nothing
virtual void draw(gfx::Renderer* renderer) override {
// Intentionally left blank
}
// Override the layout method to set the dimensions to zero
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
//this->setBoundaries(parentX, parentY, 0, 0); // Zero size
this->setBoundaries(this->getX(), this->getY(), 0, 0);
}
// Override the requestFocus method to allow this item to be focusable
virtual inline Element* requestFocus(Element* oldFocus, FocusDirection direction) override {
return this; // Allow this item to be focusable
}
//// Optionally override onClick and onTouch to handle interactions
//virtual bool onClick(u64 keys) override {
// return true; // Consume the click event
//}
//
//virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
// return true; // Consume the touch event
//}
};
class CategoryHeader : public Element {
public:
CategoryHeader(const std::string &title, bool hasSeparator = true)
: m_text(title), m_hasSeparator(hasSeparator), timeIn_ns(0),
m_scroll(false), m_truncated(false), m_scrollOffset(0.0f),
m_maxWidth(0), m_textWidth(0) {
ult::applyLangReplacements(m_text);
ult::convertComboToUnicode(m_text);
m_isItem = false;
}
virtual ~CategoryHeader() {}
virtual void draw(gfx::Renderer *renderer) override {
static const std::vector<std::string> specialChars = {""};
// Calculate widths if not done yet
if (!m_maxWidth) {
calculateWidths(renderer);
}
// Draw separator if needed
if (this->m_hasSeparator) {
renderer->drawRect(this->getX()+1+1, this->getBottomBound() - 29-4, 4, 22, (headerSeparatorColor));
}
// Determine text position
const int textX = m_hasSeparator ? (this->getX() + 15+1) : this->getX();
const int textY = this->getBottomBound() - 12-4;
// Handle scrolling text if truncated
if (m_truncated) {
if (!m_scroll) {
m_scroll = true;
timeIn_ns = armTicksToNs(armGetSystemTick());
}
// Calculate scissoring bounds that respect parent clipping
const int scissorX = textX;
const int scissorY = textY - 16;
const int scissorWidth = m_maxWidth;
const int scissorHeight = 24;
// Get parent bounds (you'll need to implement this based on your parent system)
// This assumes your parent has some way to get its visible bounds
if (Element* parent = this->getParent()) {
const int parentTop = parent->getY()-8; // or whatever method gets the top bound
const int parentBottom = parent->getBottomBound(); // or equivalent
const int parentLeft = parent->getX();
const int parentRight = parent->getX() + parent->getWidth();
// Clip scissor rectangle to parent bounds
const int clipLeft = std::max(scissorX, parentLeft);
const int clipRight = std::min(scissorX + scissorWidth, parentRight);
const int clipTop = std::max(scissorY, parentTop);
const int clipBottom = std::min(scissorY + scissorHeight, parentBottom);
// Only enable scissoring if there's a visible area
if (clipLeft < clipRight && clipTop < clipBottom) {
renderer->enableScissoring(clipLeft, clipTop,
clipRight - clipLeft,
clipBottom - clipTop);
renderer->drawStringWithColoredSections(m_scrollText, false, specialChars,
textX - static_cast<s32>(m_scrollOffset), textY, 16,
(headerTextColor), textSeparatorColor);
renderer->disableScissoring();
} else {
// Draw normal or ellipsis text
//const std::string& displayText = m_truncated ? m_ellipsisText : m_text;
renderer->drawStringWithColoredSections(m_text, false, specialChars,
textX, textY, 16, (headerTextColor), textSeparatorColor);
}
// If completely clipped, don't draw anything
} else {
// Draw normal or ellipsis text
//const std::string& displayText = m_truncated ? m_ellipsisText : m_text;
renderer->drawStringWithColoredSections(m_text, false, specialChars,
textX, textY, 16, (headerTextColor), textSeparatorColor);
}
handleScrolling();
} else {
// Draw normal or ellipsis text
//const std::string& displayText = m_truncated ? m_ellipsisText : m_text;
renderer->drawStringWithColoredSections(m_text, false, specialChars,
textX, textY, 16, (headerTextColor), textSeparatorColor);
}
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
// Check if the CategoryHeader is part of a list and if it's the first entry in it, half it's height
if (List *list = static_cast<List*>(this->getParent()); list != nullptr) {
if (list->getIndexInList(this) == 0) {
this->setBoundaries(this->getX(), this->getY(), this->getWidth(), 29+4);
return;
}
}
this->setBoundaries(this->getX(), this->getY(), this->getWidth(), tsl::style::ListItemDefaultHeight *0.90);
}
virtual bool onClick(u64 keys) {
return false;
}
virtual Element* requestFocus(Element *oldFocus, FocusDirection direction) override {
return nullptr;
}
virtual void setFocused(bool state) override {}
inline void setText(const std::string &text) {
if (this->m_text != text) {
this->m_text = text;
ult::applyLangReplacements(m_text);
ult::convertComboToUnicode(m_text);
//resetTextProperties();
}
}
inline const std::string& getText() const {
return this->m_text;
}
private:
std::string m_text;
bool m_hasSeparator;
// Scrolling properties (matching ListItem)
u64 timeIn_ns;
std::string m_scrollText;
//std::string m_ellipsisText;
bool m_scroll;
bool m_truncated;
float m_scrollOffset;
u32 m_maxWidth;
u32 m_textWidth;
// Frame rate compensation - cache calculations to reduce stutter
u64 lastUpdateTime = 0;
float cachedScrollOffset = 0.0f;
// Pre-compute constants as statics to avoid recalculation
bool constantsInitialized = false;
double totalCycleDuration;
double delayDuration;
double scrollDuration;
double accelTime;
double constantVelocityTime;
double maxVelocity;
double accelDistance;
double constantVelocityDistance;
double minScrollDistance;
double invAccelTime;
double invDecelTime;
double invBillion;
void calculateWidths(gfx::Renderer* renderer) {
// Available width (accounting for separator and margins)
m_maxWidth = getWidth() - (m_hasSeparator ? 20-3 : 4);
// Get actual text width
const u32 width = renderer->getTextDimensions(m_text, false, 16).first;
m_truncated = width > m_maxWidth;
if (m_truncated) {
// Build scroll text: "text text"
m_scrollText.clear();
m_scrollText.reserve(m_text.size() * 2 + 8);
m_scrollText.append(m_text).append(" ");
m_textWidth = renderer->getTextDimensions(m_scrollText, false, 16).first;
m_scrollText.append(m_text);
// Create ellipsis text
//m_ellipsisText = renderer->limitStringLength(m_text, false, 16, m_maxWidth);
} else {
m_textWidth = width;
}
}
void handleScrolling() {
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
const u64 elapsed_ns = currentTime_ns - timeIn_ns;
if (!constantsInitialized || minScrollDistance != static_cast<double>(m_textWidth)) {
// Constants for velocity-based scrolling (3 second pauses as requested)
delayDuration = 3.0; // 3 second pause at start
static constexpr double pauseDuration = 2.0; // 3 second pause at end
maxVelocity = 100.0; // Adjust for desired scroll speed
accelTime = 0.5;
static constexpr double decelTime = 0.5;
// Pre-calculate derived constants
minScrollDistance = static_cast<double>(m_textWidth);
accelDistance = 0.5 * maxVelocity * accelTime;
const double decelDistance = 0.5 * maxVelocity * decelTime;
constantVelocityDistance = std::max(0.0, minScrollDistance - accelDistance - decelDistance);
constantVelocityTime = constantVelocityDistance / maxVelocity;
scrollDuration = accelTime + constantVelocityTime + decelTime;
totalCycleDuration = delayDuration + scrollDuration + pauseDuration;
// Pre-calculate reciprocals for faster division
invAccelTime = 1.0 / accelTime;
invDecelTime = 1.0 / decelTime;
invBillion = 1.0 / 1000000000.0;
constantsInitialized = true;
}
// Fast ns to seconds conversion
const double elapsed_seconds = static_cast<double>(elapsed_ns) * invBillion;
// Update at consistent intervals regardless of frame rate
if (currentTime_ns - lastUpdateTime >= 8333333ULL) { // ~120 FPS update rate
// Use std::fmod for modulo - it's optimized and faster than loops
const double cyclePosition = std::fmod(elapsed_seconds, totalCycleDuration);
if (cyclePosition < delayDuration) {
// Delay phase - no scrolling (3 second pause)
cachedScrollOffset = 0.0f;
} else if (cyclePosition < delayDuration + scrollDuration) {
// Scrolling phase - velocity-based movement
const double scrollTime = cyclePosition - delayDuration;
double distance;
if (scrollTime <= accelTime) {
// Acceleration phase - quadratic ease-in
const double t = scrollTime * invAccelTime;
const double smoothT = t * t;
distance = smoothT * accelDistance;
} else if (scrollTime <= accelTime + constantVelocityTime) {
// Constant velocity phase
const double constantTime = scrollTime - accelTime;
distance = accelDistance + (constantTime * maxVelocity);
} else {
// Deceleration phase - quadratic ease-out
const double decelStartTime = accelTime + constantVelocityTime;
const double t = (scrollTime - decelStartTime) * invDecelTime;
const double oneMinusT = 1.0 - t;
const double smoothT = 1.0 - oneMinusT * oneMinusT;
distance = accelDistance + constantVelocityDistance + (smoothT * (minScrollDistance - accelDistance - constantVelocityDistance));
}
// Use branchless min
cachedScrollOffset = static_cast<float>(distance < minScrollDistance ? distance : minScrollDistance);
} else {
// Pause phase - stay at end (3 second pause)
cachedScrollOffset = static_cast<float>(m_textWidth);
}
lastUpdateTime = currentTime_ns;
}
// Use cached value for consistent display
m_scrollOffset = cachedScrollOffset;
// Reset timer when cycle completes
if (elapsed_seconds >= totalCycleDuration) {
timeIn_ns = currentTime_ns;
}
}
//void resetTextProperties() {
// m_scrollText.clear();
// m_ellipsisText.clear();
// m_maxWidth = 0;
//}
};
/**
* @brief A customizable analog trackbar going from 0% to 100% (like the brightness slider)
*
*/
class TrackBar : public Element {
public:
/**
* @brief Constructor
*
* @param icon Icon shown next to the track bar
* @param usingStepTrackbar Whether this is a step trackbar
* @param usingNamedStepTrackbar Whether this is a named step trackbar
* @param useV2Style Whether to use V2 visual style (label + value instead of icon)
* @param label Label text for V2 style
* @param units Units text for V2 style
*/
TrackBar(const char icon[3], bool usingStepTrackbar=false, bool usingNamedStepTrackbar = false,
bool useV2Style = false, const std::string& label = "", const std::string& units = "")
: m_icon(icon), m_usingStepTrackbar(usingStepTrackbar), m_usingNamedStepTrackbar(usingNamedStepTrackbar),
m_useV2Style(useV2Style), m_label(label), m_units(units) {
m_isItem = true;
}
virtual ~TrackBar() {}
virtual Element* requestFocus(Element *oldFocus, FocusDirection direction) {
return this;
}
virtual bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override {
if (keysHeld & KEY_LEFT && keysHeld & KEY_RIGHT)
return true;
if (keysHeld & KEY_LEFT) {
if (this->m_value > 0) {
this->m_value--;
this->m_valueChangedListener(this->m_value);
return true;
}
}
if (keysHeld & KEY_RIGHT) {
if (this->m_value < 100) {
this->m_value++;
this->m_valueChangedListener(this->m_value);
return true;
}
}
return false;
}
virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
const u16 trackBarWidth = this->getWidth() - 95;
const u16 handlePos = (trackBarWidth * (this->m_value - 0)) / (100 - 0);
const s32 circleCenterX = this->getX() + 59 + handlePos;
const s32 circleCenterY = this->getY() + 40 + 16 - 1;
static constexpr s32 circleRadius = 16;
static bool triggerOnce = true;
const bool touchInCircle = (std::abs(initialX - circleCenterX) <= circleRadius) && (std::abs(initialY - circleCenterY) <= circleRadius);
if (event == TouchEvent::Release) {
triggerOnce = true;
triggerRumbleDoubleClick.store(true, std::memory_order_release);
triggerOffSound.store(true, std::memory_order_release);
touchInSliderBounds = false;
return false;
}
if (touchInCircle || touchInSliderBounds) {
if (triggerOnce){
triggerOnce = false;
triggerRumbleClick.store(true, std::memory_order_release);
triggerOnSound.store(true, std::memory_order_release);
}
touchInSliderBounds = true;
//if (currX > this->getLeftBound() + 50 && currX < this->getRightBound() && currY > this->getTopBound() && currY < this->getBottomBound()) {
s16 newValue = (static_cast<float>(currX - (this->getX() + 60)) / static_cast<float>(this->getWidth() - 95)) * 100;
if (newValue < 0) {
newValue = 0;
} else if (newValue > 100) {
newValue = 100;
}
if (newValue != this->m_value) {
this->m_value = newValue;
this->m_valueChangedListener(this->getProgress());
}
return true;
//}
}
return false;
}
// Define drawBar function outside the draw method
void drawBar(gfx::Renderer *renderer, s32 x, s32 y, u16 width, Color& color, bool isRounded = true) {
if (isRounded) {
renderer->drawUniformRoundedRect(x, y, width, 7, a(color));
} else {
renderer->drawRect(x, y, width, 7, a(color));
}
}
virtual void draw(gfx::Renderer *renderer) override {
//static float lastBottomBound;
if (touchInSliderBounds) {
m_drawFrameless = true;
drawHighlight(renderer);
} else {
m_drawFrameless = false;
}
s32 xPos = this->getX() + 59;
s32 yPos = this->getY() + 40 + 16 - 1;
s32 width = this->getWidth() - 95;
u16 handlePos = width * (this->m_value) / (100);
if (!m_usingNamedStepTrackbar) {
yPos -= 11;
}
s32 iconOffset = 0;
if (!m_useV2Style && m_icon[0] != '\0') {
s32 iconWidth = 23;//tsl::gfx::calculateStringWidth(m_icon, 23);
iconOffset = 14 + iconWidth;
xPos += iconOffset;
width -= iconOffset;
handlePos = (width) * (this->m_value) / (100);
}
// Draw step tick marks if this is a step trackbar
if (m_usingStepTrackbar || m_usingNamedStepTrackbar) {
const u8 numSteps = m_numSteps;
const u16 baseX = xPos;
const u16 baseY = this->getY() + 44;
const u8 halfNumSteps = (numSteps - 1) / 2;
const u16 lastStepX = baseX + width - 1;
const float stepSpacing = static_cast<float>(width) / (numSteps - 1);
const auto stepColor = a(trackBarEmptyColor);
u16 stepX;
for (u8 i = 0; i < numSteps; i++) {
if (i == numSteps - 1) {
stepX = lastStepX;
} else {
stepX = baseX + static_cast<u16>(std::round(i * stepSpacing));
if (i > halfNumSteps) {
stepX -= 1;
}
}
renderer->drawRect(stepX, baseY, 1, 8, stepColor);
}
}
// Draw track bar background
drawBar(renderer, xPos, yPos-3, width, trackBarEmptyColor, !m_usingNamedStepTrackbar);
if (!this->m_focused) {
drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar);
renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(m_drawFrameless ? highlightColor : trackBarSliderBorderColor));
renderer->drawCircle(xPos + handlePos, yPos, 13, true, a((m_unlockedTrackbar || touchInSliderBounds) ? trackBarSliderMalleableColor : trackBarSliderColor));
} else {
touchInSliderBounds = false;
if (m_unlockedTrackbar != ult::unlockedSlide.load(std::memory_order_acquire))
ult::unlockedSlide.store(m_unlockedTrackbar, std::memory_order_release);
drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar);
renderer->drawCircle(xPos + x + handlePos, yPos +y, 16, true, a(highlightColor));
renderer->drawCircle(xPos + x + handlePos, yPos +y, 12, true, a((ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) ? trackBarSliderMalleableColor : trackBarSliderColor));
}
// Draw icon (original style) or label + value (V2 style)
if (m_useV2Style) {
// V2 Style: Draw label and value
std::string labelPart = this->m_label;
ult::removeTag(labelPart);
std::string valuePart;
if (!m_usingNamedStepTrackbar) {
valuePart = (m_units.compare("%") == 0 || m_units.compare("°C") == 0 || m_units.compare("°F") == 0)
? ult::to_string(m_value) + m_units
: ult::to_string(m_value) + (m_units.empty() ? "" : " ") + m_units;
} else {
valuePart = this->m_selection;
}
const auto valueWidth = renderer->getTextDimensions(valuePart, false, 16).first;
renderer->drawString(labelPart, false, this->getX() + 59, this->getY() + 14 + 16, 16,
((!this->m_focused || !ult::useSelectionText) ? (defaultTextColor) : (selectedTextColor)));
renderer->drawString(valuePart, false, this->getWidth() -17 - valueWidth, this->getY() + 14 + 16, 16, (this->m_focused && ult::useSelectionValue) ? selectedValueTextColor : onTextColor);
} else {
// Original Style: Draw icon
if (m_icon[0] != '\0')
renderer->drawString(this->m_icon, false, this->getX()+42, this->getY() + 50+2, 23, a(tsl::style::color::ColorText));
}
if (m_lastBottomBound != this->getTopBound())
renderer->drawRect(this->getX() + 4+20-1, this->getTopBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor));
renderer->drawRect(this->getX() + 4+20-1, this->getBottomBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor));
m_lastBottomBound = this->getBottomBound();
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
this->setBoundaries(this->getX() - 16 , this->getY(), this->getWidth()+20+4, tsl::style::TrackBarDefaultHeight );
}
virtual void drawFocusBackground(gfx::Renderer *renderer) {
// No background drawn here in HOS
}
virtual void drawHighlight(gfx::Renderer *renderer) override {
// Get current time using ARM system tick for animation timing
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
// High precision time calculation - matches standard cosine wave timing
const double time_seconds = static_cast<double>(currentTime_ns) / 1000000000.0;
// Standard cosine wave calculation with high precision
progress = (std::cos(2.0 * ult::_M_PI * std::fmod(time_seconds, 1.0) - ult::_M_PI / 2) + 1.0) / 2.0;
// High precision floating point color interpolation
highlightColor = {
static_cast<u8>(highlightColor2.r + (highlightColor1.r - highlightColor2.r) * progress + 0.5),
static_cast<u8>(highlightColor2.g + (highlightColor1.g - highlightColor2.g) * progress + 0.5),
static_cast<u8>(highlightColor2.b + (highlightColor1.b - highlightColor2.b) * progress + 0.5),
0xF
};
// Initialize position offsets
x = 0;
y = 0;
if (this->m_highlightShaking) {
//const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
t_ns = currentTime_ns - this->m_highlightShakingStartTime; // Changed
if (t_ns >= 100000000) // 100ms in nanoseconds
this->m_highlightShaking = false;
else {
amplitude = std::rand() % 5 + 5;
switch (this->m_highlightShakingDirection) {
case FocusDirection::Up:
y -= shakeAnimation(t_ns, amplitude); // Changed parameter
break;
case FocusDirection::Down:
y += shakeAnimation(t_ns, amplitude); // Changed parameter
break;
case FocusDirection::Left:
x -= shakeAnimation(t_ns, amplitude); // Changed parameter
break;
case FocusDirection::Right:
x += shakeAnimation(t_ns, amplitude); // Changed parameter
break;
default:
break;
}
x = std::clamp(x, -amplitude, amplitude);
y = std::clamp(y, -amplitude, amplitude);
}
}
if (!m_drawFrameless) {
if (ult::useSelectionBG) {
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION
else
renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor)); // CUSTOM MODIFICATION
//renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), a(selectionBGColor)); // CUSTOM MODIFICATION
}
renderer->drawBorderedRoundedRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11, this->getHeight(), 5, 5, a(highlightColor));
} else {
if (ult::useSelectionBG) {
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor)); // CUSTOM MODIFICATION
else
renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor)); // CUSTOM MODIFICATION
}
}
ult::onTrackBar.exchange(true, std::memory_order_acq_rel);
}
/**
* @brief Gets the current value of the trackbar
*
* @return State
*/
virtual inline u8 getProgress() {
return this->m_value;
}
/**
* @brief Sets the current state of the toggle. Updates the Value
*
* @param state State
*/
virtual void setProgress(u8 value) {
this->m_value = value;
}
/**
* @brief Adds a listener that gets called whenever the state of the toggle changes
*
* @param stateChangedListener Listener with the current state passed in as parameter
*/
void setValueChangedListener(std::function<void(u8)> valueChangedListener) {
this->m_valueChangedListener = valueChangedListener;
}
protected:
const char *m_icon = nullptr;
s16 m_value = 0;
bool m_interactionLocked = false;
std::function<void(u8)> m_valueChangedListener = [](u8){};
bool m_usingStepTrackbar = false;
bool m_usingNamedStepTrackbar = false;
bool m_unlockedTrackbar = true;
bool touchInSliderBounds = false;
u8 m_numSteps = 101;
// V2 Style properties
bool m_useV2Style = false;
std::string m_label;
std::string m_units;
std::string m_selection; // Used for named step trackbars
bool m_drawFrameless = false;
float m_lastBottomBound;
};
/**
* @brief A customizable analog trackbar going from 0% to 100% but using discrete steps (Like the volume slider)
*
*/
class StepTrackBar : public TrackBar {
public:
/**
* @brief Constructor
*
* @param icon Icon shown next to the track bar
* @param numSteps Number of steps the track bar has
* @param usingNamedStepTrackbar Whether this is a named step trackbar
* @param useV2Style Whether to use V2 visual style (label + value instead of icon)
* @param label Label text for V2 style
* @param units Units text for V2 style
*/
StepTrackBar(const char icon[3], size_t numSteps, bool usingNamedStepTrackbar = false,
bool useV2Style = false, const std::string& label = "", const std::string& units = "")
: TrackBar(icon, true, usingNamedStepTrackbar, useV2Style, label, units), m_numSteps(numSteps) { }
virtual ~StepTrackBar() {}
virtual bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override {
static u32 tick = 0;
if (keysHeld & KEY_LEFT && keysHeld & KEY_RIGHT) {
tick = 0;
return true;
}
if (keysHeld & (KEY_LEFT | KEY_RIGHT)) {
if ((tick == 0 || tick > 20) && (tick % 3) == 0) {
if (keysHeld & KEY_LEFT && this->m_value > 0) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
this->m_value = std::max(this->m_value - (100 / (this->m_numSteps - 1)), 0);
} else if (keysHeld & KEY_RIGHT && this->m_value < 100) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
this->m_value = std::min(this->m_value + (100 / (this->m_numSteps - 1)), 100);
} else {
return false;
}
this->m_valueChangedListener(this->getProgress());
}
tick++;
return true;
} else {
tick = 0;
}
return false;
}
virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
const u16 trackBarWidth = this->getWidth() - 95;
const u16 handlePos = (trackBarWidth * this->m_value) / 100;
const s32 circleCenterX = this->getX() + 59 + handlePos;
const s32 circleCenterY = this->getY() + 40 + 16 - 1;
static constexpr s32 circleRadius = 16;
static bool triggerOnce = true;
const bool touchInCircle = (std::abs(initialX - circleCenterX) <= circleRadius) && (std::abs(initialY - circleCenterY) <= circleRadius);
if (event == TouchEvent::Release) {
triggerOnce = true;
triggerRumbleDoubleClick.store(true, std::memory_order_release);
triggerOffSound.store(true, std::memory_order_release);
touchInSliderBounds = false;
return false;
}
if (touchInCircle || touchInSliderBounds) {
if (triggerOnce){
triggerOnce = false;
triggerRumbleClick.store(true, std::memory_order_release);
triggerOnSound.store(true, std::memory_order_release);
}
touchInSliderBounds = true;
//if (currY > this->getTopBound() && currY < this->getBottomBound()) {
s16 newValue = (static_cast<float>(currX - (this->getX() + 60)) / static_cast<float>(this->getWidth() - 95)) * 100;
if (newValue < 0) {
newValue = 0;
} else if (newValue > 100) {
newValue = 100;
} else {
newValue = std::round(newValue / (100.0F / (this->m_numSteps - 1))) * (100.0F / (this->m_numSteps - 1));
}
if (newValue != this->m_value) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
this->m_value = newValue;
this->m_valueChangedListener(this->getProgress());
}
return true;
//}
}
return false;
}
/**
* @brief Gets the current value of the trackbar
*
* @return State
*/
virtual inline u8 getProgress() override {
return this->m_value / (100 / (this->m_numSteps - 1));
}
/**
* @brief Sets the current state of the toggle. Updates the Value
*
* @param state State
*/
virtual void setProgress(u8 value) override {
value = std::min(value, u8(this->m_numSteps - 1));
this->m_value = value * (100 / (this->m_numSteps - 1));
}
protected:
u8 m_numSteps = 1;
};
/**
* @brief A customizable trackbar with multiple discrete steps with specific names. Name gets displayed above the bar
*
*/
class NamedStepTrackBar : public StepTrackBar {
public:
/**
* @brief Constructor
*
* @param icon Icon shown next to the track bar
* @param stepDescriptions Step names displayed above the track bar
* @param useV2Style Whether to use V2 visual style (label + value instead of icon)
* @param label Label text for V2 style
*/
NamedStepTrackBar(const char icon[3], std::initializer_list<std::string> stepDescriptions,
bool useV2Style = false, const std::string& label = "")
: StepTrackBar(icon, stepDescriptions.size(), true, useV2Style, label, ""),
m_stepDescriptions(stepDescriptions.begin(), stepDescriptions.end()) {
this->m_usingNamedStepTrackbar = true;
// Initialize selection with first step
if (!m_stepDescriptions.empty()) {
this->m_selection = m_stepDescriptions[0];
}
m_numSteps = m_stepDescriptions.size();
}
virtual ~NamedStepTrackBar() {}
virtual bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override {
// Store previous value to update selection
const u8 prevProgress = this->getProgress();
// Call parent input handling
const bool result = StepTrackBar::handleInput(keysDown, keysHeld, touchPos, leftJoyStick, rightJoyStick);
// Update selection if progress changed
if (result && this->getProgress() != prevProgress) {
const u8 currentIndex = this->getProgress();
if (currentIndex < m_stepDescriptions.size()) {
this->m_selection = m_stepDescriptions[currentIndex];
}
}
return result;
}
virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
// Store previous value to update selection
const u8 prevProgress = this->getProgress();
// Call parent touch handling
const bool result = StepTrackBar::onTouch(event, currX, currY, prevX, prevY, initialX, initialY);
// Update selection if progress changed
if (result && this->getProgress() != prevProgress) {
const u8 currentIndex = this->getProgress();
if (currentIndex < m_stepDescriptions.size()) {
this->m_selection = m_stepDescriptions[currentIndex];
}
}
return result;
}
virtual void setProgress(u8 value) override {
StepTrackBar::setProgress(value);
// Update selection when progress is set programmatically
const u8 currentIndex = this->getProgress();
if (currentIndex < m_stepDescriptions.size()) {
this->m_selection = m_stepDescriptions[currentIndex];
}
}
virtual void draw(gfx::Renderer *renderer) override {
if (touchInSliderBounds) {
m_drawFrameless = true;
drawHighlight(renderer);
} else {
m_drawFrameless = false;
}
s32 xPos = this->getX() + 59;
s32 yPos = this->getY() + 40 + 16 - 1;
s32 width = this->getWidth() - 95;
u16 handlePos = width * (this->m_value) / (100);
if (!m_usingNamedStepTrackbar) {
yPos -= 11;
}
s32 iconOffset = 0;
if (!m_useV2Style && m_icon[0] != '\0') {
s32 iconWidth = 23;
iconOffset = 14 + iconWidth;
xPos += iconOffset;
width -= iconOffset;
handlePos = (width) * (this->m_value) / (100);
}
// Draw step tick marks if this is a step trackbar
{
const u8 numSteps = m_numSteps;
const u16 baseX = xPos;
const u16 baseY = this->getY() + 44;
const u8 halfNumSteps = (numSteps - 1) / 2;
const u16 lastStepX = baseX + width - 1;
const float stepSpacing = static_cast<float>(width) / (numSteps - 1);
const auto stepColor = a(trackBarEmptyColor);
u16 stepX;
for (u8 i = 0; i < numSteps; i++) {
if (i == numSteps - 1) {
stepX = lastStepX;
} else {
stepX = baseX + static_cast<u16>(std::round(i * stepSpacing));
if (i > halfNumSteps) {
stepX -= 1;
}
}
renderer->drawRect(stepX, baseY, 1, 8, stepColor);
}
}
// Draw track bar background
drawBar(renderer, xPos, yPos-3, width, trackBarEmptyColor, !m_usingNamedStepTrackbar);
if (!this->m_focused) {
drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar);
renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(m_drawFrameless ? highlightColor : trackBarSliderBorderColor));
renderer->drawCircle(xPos + handlePos, yPos, 13, true, a((m_unlockedTrackbar || touchInSliderBounds) ? trackBarSliderMalleableColor : trackBarSliderColor));
} else {
touchInSliderBounds = false;
if (m_unlockedTrackbar != ult::unlockedSlide.load(std::memory_order_acquire))
ult::unlockedSlide.store(m_unlockedTrackbar, std::memory_order_release);
drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar);
renderer->drawCircle(xPos + x + handlePos, yPos +y, 16, true, a(highlightColor));
renderer->drawCircle(xPos + x + handlePos, yPos +y, 12, true, a((ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) ? trackBarSliderMalleableColor : trackBarSliderColor));
}
// Draw icon (original style) or label + value (V2 style)
if (m_useV2Style) {
// V2 Style: Draw label and value
std::string labelPart = this->m_label;
ult::removeTag(labelPart);
std::string valuePart;
if (!m_usingNamedStepTrackbar) {
valuePart = (m_units.compare("%") == 0 || m_units.compare("°C") == 0 || m_units.compare("°F") == 0)
? ult::to_string(m_value) + m_units
: ult::to_string(m_value) + (m_units.empty() ? "" : " ") + m_units;
} else {
valuePart = this->m_selection;
}
const auto valueWidth = renderer->getTextDimensions(valuePart, false, 16).first;
renderer->drawString(labelPart, false, this->getX() + 59, this->getY() + 14 + 16, 16,
((!this->m_focused || !ult::useSelectionText) ? (defaultTextColor) : (selectedTextColor)));
renderer->drawString(valuePart, false, this->getWidth() -17 - valueWidth, this->getY() + 14 + 16, 16, (this->m_focused && ult::useSelectionValue) ? selectedValueTextColor : onTextColor);
} else {
// Original Style: Draw icon
if (m_icon[0] != '\0')
renderer->drawString(this->m_icon, false, this->getX()+42, this->getY() + 50+2, 23, a(tsl::style::color::ColorText));
}
if (m_lastBottomBound != this->getTopBound())
renderer->drawRect(this->getX() + 4+20-1, this->getTopBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor));
renderer->drawRect(this->getX() + 4+20-1, this->getBottomBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor));
m_lastBottomBound = this->getBottomBound();
}
protected:
std::vector<std::string> m_stepDescriptions;
};
/**
* @brief A customizable analog trackbar going from minValue to maxValue
*
*/
class TrackBarV2 : public Element {
public:
u64 lastUpdate_ns;
Color highlightColor = {0xf, 0xf, 0xf, 0xf};
float progress;
float counter = 0.0;
s32 x, y;
s32 amplitude;
u32 descWidth, descHeight;
void setScriptKeyListener(std::function<void()> listener) {
m_scriptKeyListener = std::move(listener);
}
TrackBarV2(std::string label, std::string packagePath = "", s16 minValue = 0, s16 maxValue = 100, std::string units = "",
std::function<bool(std::vector<std::vector<std::string>>&&, const std::string&, const std::string&)> executeCommands = nullptr,
std::function<std::vector<std::vector<std::string>>(const std::vector<std::vector<std::string>>&, const std::string&, size_t, const std::string&)> sourceReplacementFunc = nullptr,
std::vector<std::vector<std::string>> cmd = {}, const std::string& selCmd = "", bool usingStepTrackbar = false, bool usingNamedStepTrackbar = false, s16 numSteps = -1, bool unlockedTrackbar = false, bool executeOnEveryTick = false)
: m_label(label), m_packagePath(packagePath), m_minValue(minValue), m_maxValue(maxValue), m_units(units),
interpretAndExecuteCommands(executeCommands), getSourceReplacement(sourceReplacementFunc), commands(std::move(cmd)), selectedCommand(selCmd),
m_usingStepTrackbar(usingStepTrackbar), m_usingNamedStepTrackbar(usingNamedStepTrackbar), m_numSteps(numSteps), m_unlockedTrackbar(unlockedTrackbar), m_executeOnEveryTick(executeOnEveryTick) {
m_isItem = true;
if (maxValue < minValue) {
std::swap(minValue, maxValue);
m_minValue = minValue;
m_maxValue = maxValue;
}
if ((!usingStepTrackbar && !usingNamedStepTrackbar) || numSteps == -1) {
m_numSteps = (maxValue - minValue) + 1;
}
if (m_numSteps < 2) {
m_numSteps = 2;
}
bool loadedValue = false;
if (!m_packagePath.empty()) {
auto configIniData = ult::getParsedDataFromIniFile(m_packagePath + "config.ini");
auto sectionIt = configIniData.find(m_label);
if (sectionIt != configIniData.end()) {
auto indexIt = sectionIt->second.find("index");
if (indexIt != sectionIt->second.end() && !indexIt->second.empty()) {
m_index = static_cast<s16>(ult::stoi(indexIt->second));
}
if (!m_usingNamedStepTrackbar) {
auto valueIt = sectionIt->second.find("value");
if (valueIt != sectionIt->second.end() && !valueIt->second.empty()) {
m_value = static_cast<s16>(ult::stoi(valueIt->second));
loadedValue = true;
}
}
}
}
if (m_index >= m_numSteps) m_index = m_numSteps - 1;
if (m_index < 0) m_index = 0;
if (!loadedValue) {
if (m_numSteps > 1) {
m_value = minValue + m_index * (static_cast<float>(maxValue - minValue) / (m_numSteps - 1));
} else {
m_value = minValue;
}
}
if (m_value > maxValue) m_value = maxValue;
if (m_value < minValue) m_value = minValue;
lastUpdate_ns = armTicksToNs(armGetSystemTick());
}
virtual ~TrackBarV2() {}
virtual Element* requestFocus(Element *oldFocus, FocusDirection direction) {
return this;
}
inline void updateAndExecute(bool updateIni = true) {
if (m_packagePath.empty()) {
return;
}
const std::string indexStr = ult::to_string(m_index);
const std::string valueStr = m_usingNamedStepTrackbar ? m_selection : ult::to_string(m_value);
if (updateIni) {
const std::string configPath = m_packagePath + "config.ini";
ult::setIniFileValue(configPath, m_label, "index", indexStr);
ult::setIniFileValue(configPath, m_label, "value", valueStr);
}
bool success = false;
static const std::string valuePlaceholder = "{value}";
static const std::string indexPlaceholder = "{index}";
static const size_t valuePlaceholderLen = valuePlaceholder.length();
static const size_t indexPlaceholderLen = indexPlaceholder.length();
const size_t valueStrLen = valueStr.length();
const size_t indexStrLen = indexStr.length();
size_t tryCount = 0;
while (!success) {
if (interpretAndExecuteCommands) {
if (tryCount > 3)
break;
auto modifiedCmds = getSourceReplacement(commands, valueStr, m_index, m_packagePath);
for (auto& cmd : modifiedCmds) {
for (auto& arg : cmd) {
for (size_t pos = 0; (pos = arg.find(valuePlaceholder, pos)) != std::string::npos; pos += valueStrLen) {
arg.replace(pos, valuePlaceholderLen, valueStr);
}
if (m_usingNamedStepTrackbar) {
for (size_t pos = 0; (pos = arg.find(indexPlaceholder, pos)) != std::string::npos; pos += indexStrLen) {
arg.replace(pos, indexPlaceholderLen, indexStr);
}
}
}
}
success = interpretAndExecuteCommands(std::move(modifiedCmds), m_packagePath, selectedCommand);
ult::resetPercentages();
if (success)
break;
tryCount++;
}
}
}
virtual inline bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override {
const u64 keysReleased = m_prevKeysHeld & ~keysHeld;
m_prevKeysHeld = keysHeld;
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
const u64 elapsed_ns = currentTime_ns - lastUpdate_ns;
m_keyRHeld = (keysHeld & KEY_R) != 0;
if ((keysHeld & KEY_R)) {
if (keysDown & KEY_UP && !(keysHeld & ~KEY_UP & ~KEY_R & ALL_KEYS_MASK))
this->shakeHighlight(FocusDirection::Up);
else if (keysDown & KEY_DOWN && !(keysHeld & ~KEY_DOWN & ~KEY_R & ALL_KEYS_MASK))
this->shakeHighlight(FocusDirection::Down);
else if (keysDown & KEY_LEFT && !(keysHeld & ~KEY_LEFT & ~KEY_R & ALL_KEYS_MASK)){
this->shakeHighlight(FocusDirection::Left);
}
else if (keysDown & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ~KEY_R & ALL_KEYS_MASK)) {
this->shakeHighlight(FocusDirection::Right);
}
return true;
}
if ((keysDown & KEY_A) && !(keysHeld & ~KEY_A & ALL_KEYS_MASK)) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerEnterSound.store(true, std::memory_order_release);
triggerEnterFeedback();
if (!m_unlockedTrackbar) {
ult::atomicToggle(ult::allowSlide);
m_holding = false;
}
if (m_unlockedTrackbar || (!m_unlockedTrackbar && !ult::allowSlide.load(std::memory_order_acquire))) {
updateAndExecute();
triggerClick = true;
}
return true;
}
//if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) {
// triggerRumbleDoubleClick.store(true, std::memory_order_release);
// triggerExitSound.store(true, std::memory_order_release);
//}
if ((keysDown & SCRIPT_KEY) && !(keysHeld & ~SCRIPT_KEY & ALL_KEYS_MASK)) {
if (m_scriptKeyListener) {
m_scriptKeyListener();
}
return true;
}
if (ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) {
// Handle key release
if (((keysReleased & KEY_LEFT) || (keysReleased & KEY_RIGHT))) {
// If we were holding and repeating, just stop
if (m_wasLastHeld) {
m_wasLastHeld = false;
//triggerNavigationSound.store(true, std::memory_order_release);
//triggerRumbleClick.store(true, std::memory_order_release);
m_holding = false;
updateAndExecute();
lastUpdate_ns = armTicksToNs(armGetSystemTick());
return true;
}
// If it was a quick tap (no repeat happened), handle the single tick
else if (m_holding) {
m_holding = false;
//triggerNavigationSound.store(true, std::memory_order_release);
//triggerRumbleClick.store(true, std::memory_order_release);
updateAndExecute();
lastUpdate_ns = armTicksToNs(armGetSystemTick());
return true;
}
}
// Ignore simultaneous left+right
if (keysDown & KEY_LEFT && keysDown & KEY_RIGHT)
return true;
if (keysHeld & KEY_LEFT && keysHeld & KEY_RIGHT)
return true;
// Handle initial key press
if (keysDown & KEY_LEFT || keysDown & KEY_RIGHT) {
triggerRumbleClick.store(true, std::memory_order_release);
// Start tracking the hold
m_holding = true;
m_wasLastHeld = false;
m_holdStartTime_ns = armTicksToNs(armGetSystemTick());
lastUpdate_ns = currentTime_ns;
// Perform the initial single tick
if (keysDown & KEY_LEFT && this->m_value > m_minValue) {
this->m_index--;
this->m_value--;
this->m_valueChangedListener(this->m_value);
updateAndExecute(false);
} else if (keysDown & KEY_RIGHT && this->m_value < m_maxValue) {
this->m_index++;
this->m_value++;
this->m_valueChangedListener(this->m_value);
updateAndExecute(false);
}
return true;
}
// Handle continued holding (after initial press)
if (m_holding && ((keysHeld & KEY_LEFT) || (keysHeld & KEY_RIGHT))) {
const u64 holdDuration_ns = currentTime_ns - m_holdStartTime_ns;
// Initial delay before repeating starts (e.g., 300ms)
static constexpr u64 initialDelay_ns = 300000000ULL;
// Calculate interval with acceleration
static constexpr u64 initialInterval_ns = 67000000ULL; // ~67ms
static constexpr u64 shortInterval_ns = 10000000ULL; // ~10ms
static constexpr u64 transitionPoint_ns = 1000000000ULL; // 2 seconds
// Trigger navigation sound every 100ms while holding
static u64 lastNavigationSound_ns = 0;
if (currentTime_ns - lastNavigationSound_ns >= 150'000'000ULL) { // 100ms
if (this->m_value > m_minValue && this->m_value < m_maxValue) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
}
lastNavigationSound_ns = currentTime_ns;
}
// If we haven't passed the initial delay, don't repeat yet
if (holdDuration_ns < initialDelay_ns) {
return true;
}
const u64 holdDurationAfterDelay_ns = holdDuration_ns - initialDelay_ns;
const float t = std::min(1.0f, static_cast<float>(holdDurationAfterDelay_ns) / static_cast<float>(transitionPoint_ns));
const u64 currentInterval_ns = static_cast<u64>((initialInterval_ns - shortInterval_ns) * (1.0f - t) + shortInterval_ns);
if (elapsed_ns >= currentInterval_ns) {
if (keysHeld & KEY_LEFT && this->m_value > m_minValue) {
this->m_index--;
this->m_value--;
this->m_valueChangedListener(this->m_value);
if (m_executeOnEveryTick) {
updateAndExecute(false);
}
lastUpdate_ns = currentTime_ns;
m_wasLastHeld = true;
return true;
}
if (keysHeld & KEY_RIGHT && this->m_value < m_maxValue) {
this->m_index++;
this->m_value++;
this->m_valueChangedListener(this->m_value);
if (m_executeOnEveryTick) {
updateAndExecute(false);
}
lastUpdate_ns = currentTime_ns;
m_wasLastHeld = true;
return true;
}
}
} else {
m_holding = false;
}
}
return false;
}
virtual bool onTouch(TouchEvent event, s32 currX, s32 currY, s32 prevX, s32 prevY, s32 initialX, s32 initialY) override {
const u16 trackBarWidth = this->getWidth() - 95;
const u16 handlePos = (trackBarWidth * (this->m_value - m_minValue)) / (m_maxValue - m_minValue);
const s32 circleCenterX = this->getX() + 59 + handlePos;
const s32 circleCenterY = this->getY() + 40 + 16 - 1;
static constexpr s32 circleRadius = 16;
static bool triggerOnce = true;
const bool touchInCircle = (std::abs(initialX - circleCenterX) <= circleRadius) && (std::abs(initialY - circleCenterY) <= circleRadius);
if (!m_unlockedTrackbar && !ult::allowSlide.load(std::memory_order_acquire)) {
return false;
}
if ((touchInCircle || touchInSliderBounds)) {
touchInSliderBounds = true;
if (triggerOnce) {
triggerOnce = false;
triggerRumbleClick.store(true, std::memory_order_release);
triggerOnSound.store(true, std::memory_order_release);
}
const s16 newIndex = std::max(static_cast<s16>(0), std::min(static_cast<s16>((currX - (this->getX() + 59)) / static_cast<float>(this->getWidth() - 95) * (m_numSteps - 1)), static_cast<s16>(m_numSteps - 1)));
const s16 newValue = m_minValue + newIndex * (static_cast<float>(m_maxValue - m_minValue) / (m_numSteps - 1));
if (newValue != this->m_value || newIndex != this->m_index) {
this->m_value = newValue;
this->m_index = newIndex;
this->m_valueChangedListener(this->getProgress());
if (m_executeOnEveryTick) {
updateAndExecute(false);
}
if (m_usingStepTrackbar || m_usingNamedStepTrackbar) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
}
} else {
if (event == TouchEvent::Release) {
triggerOnce = true;
updateAndExecute();
if (event == TouchEvent::Release)
touchInSliderBounds = false;
triggerRumbleDoubleClick.store(true, std::memory_order_release);
triggerOffSound.store(true, std::memory_order_release);
}
}
return true;
}
return false;
}
void drawBar(gfx::Renderer *renderer, s32 x, s32 y, u16 width, Color& color, bool isRounded = true) {
if (isRounded) {
renderer->drawUniformRoundedRect(x, y, width, 7, a(color));
} else {
renderer->drawRect(x, y, width, 7, a(color));
}
}
virtual void draw(gfx::Renderer *renderer) override {
const u16 handlePos = (this->getWidth() - 95) * (this->m_value - m_minValue) / (m_maxValue - m_minValue);
const s32 xPos = this->getX() + 59;
const s32 yPos = this->getY() + 40 + 16 - 1;
const s32 width = this->getWidth() - 95;
const bool shouldAppearLocked = m_unlockedTrackbar && m_keyRHeld;
const bool visuallyUnlocked = (m_unlockedTrackbar && !m_keyRHeld) || touchInSliderBounds;
if (visuallyUnlocked && touchInSliderBounds) {
m_drawFrameless = true;
drawHighlight(renderer);
} else {
m_drawFrameless = false;
}
drawBar(renderer, xPos, yPos-3, width, trackBarEmptyColor, !m_usingNamedStepTrackbar);
if (!this->m_focused) {
drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar);
renderer->drawCircle(xPos + handlePos, yPos, 16, true, a(!m_drawFrameless ? trackBarSliderBorderColor : highlightColor));
renderer->drawCircle(xPos + handlePos, yPos, 13, true, a(visuallyUnlocked ? trackBarSliderMalleableColor : trackBarSliderColor));
} else {
touchInSliderBounds = false;
if (m_unlockedTrackbar != ult::unlockedSlide.load(std::memory_order_acquire))
ult::unlockedSlide.store(m_unlockedTrackbar, std::memory_order_release);
drawBar(renderer, xPos, yPos-3, handlePos, trackBarFullColor, !m_usingNamedStepTrackbar);
renderer->drawCircle(xPos + x + handlePos, yPos +y, 16, true, a(highlightColor));
const bool focusedVisuallyUnlocked = (ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) && !shouldAppearLocked;
renderer->drawCircle(xPos + x + handlePos, yPos +y, 12, true, a(focusedVisuallyUnlocked ? trackBarSliderMalleableColor : trackBarSliderColor));
}
std::string labelPart = this->m_label;
ult::removeTag(labelPart);
if (!m_usingNamedStepTrackbar) {
m_valuePart = (this->m_units.compare("%") == 0 || this->m_units.compare("°C") == 0 || this->m_units.compare("°F") == 0)
? ult::to_string(this->m_value) + this->m_units
: ult::to_string(this->m_value) + (this->m_units.empty() ? "" : " ") + this->m_units;
} else
m_valuePart = this->m_selection;
const auto valueWidth = renderer->getTextDimensions(m_valuePart, false, 16).first;
renderer->drawString(labelPart, false, xPos, this->getY() + 14 + 16, 16, ((!this->m_focused || !ult::useSelectionText) ? (defaultTextColor) : (selectedTextColor)));
renderer->drawString(m_valuePart, false, this->getWidth() -17 - valueWidth, this->getY() + 14 + 16, 16,
(this->m_focused && ult::useSelectionValue) ? selectedValueTextColor : onTextColor);
if (m_lastBottomBound != this->getTopBound())
renderer->drawRect(this->getX() + 4+20-1, this->getTopBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor));
renderer->drawRect(this->getX() + 4+20-1, this->getBottomBound(), this->getWidth() + 6 + 10+20 +4, 1, a(separatorColor));
m_lastBottomBound = this->getBottomBound();
}
virtual void layout(u16 parentX, u16 parentY, u16 parentWidth, u16 parentHeight) override {
this->setBoundaries(this->getX() - 16 , this->getY(), this->getWidth()+20+4, tsl::style::TrackBarDefaultHeight );
}
virtual void drawFocusBackground(gfx::Renderer *renderer) {
}
virtual void drawHighlight(gfx::Renderer *renderer) override {
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
const double timeInSeconds = static_cast<double>(currentTime_ns) / 1000000000.0;
progress = ((std::cos(2.0 * ult::_M_PI * std::fmod(timeInSeconds, 1.0) - ult::_M_PI / 2) + 1.0) / 2.0);
Color clickColor1 = highlightColor1;
Color clickColor2 = clickColor;
if (triggerClick && !m_clickActive) {
m_clickStartTime_ns = currentTime_ns;
m_clickActive = true;
if (progress >= 0.5) {
clickColor1 = clickColor;
clickColor2 = highlightColor2;
}
}
if (m_lastLabel != m_label) {
m_clickActive = false;
triggerClick = false;
}
m_lastLabel = m_label;
if (m_clickActive) {
const u64 elapsedTime_ns = currentTime_ns - m_clickStartTime_ns;
if (elapsedTime_ns < 500000000ULL) {
highlightColor = {
static_cast<u8>((clickColor1.r - clickColor2.r) * progress + clickColor2.r + 0.5),
static_cast<u8>((clickColor1.g - clickColor2.g) * progress + clickColor2.g + 0.5),
static_cast<u8>((clickColor1.b - clickColor2.b) * progress + clickColor2.b + 0.5),
0xF
};
} else {
m_clickActive = false;
triggerClick = false;
}
} else {
const bool shouldAppearLocked = m_unlockedTrackbar && m_keyRHeld;
if ((ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) && !shouldAppearLocked) {
highlightColor = {
static_cast<u8>((highlightColor1.r - highlightColor2.r) * progress + highlightColor2.r + 0.5),
static_cast<u8>((highlightColor1.g - highlightColor2.g) * progress + highlightColor2.g + 0.5),
static_cast<u8>((highlightColor1.b - highlightColor2.b) * progress + highlightColor2.b + 0.5),
0xF
};
} else {
highlightColor = {
static_cast<u8>((highlightColor3.r - highlightColor4.r) * progress + highlightColor4.r + 0.5),
static_cast<u8>((highlightColor3.g - highlightColor4.g) * progress + highlightColor4.g + 0.5),
static_cast<u8>((highlightColor3.b - highlightColor4.b) * progress + highlightColor4.b + 0.5),
0xF
};
}
}
x = 0;
y = 0;
if (this->m_highlightShaking) {
t_ns = currentTime_ns - this->m_highlightShakingStartTime;
if (t_ns >= 100000000ULL)
this->m_highlightShaking = false;
else {
amplitude = std::rand() % 5 + 5;
switch (this->m_highlightShakingDirection) {
case FocusDirection::Up:
y -= shakeAnimation(t_ns, amplitude);
break;
case FocusDirection::Down:
y += shakeAnimation(t_ns, amplitude);
break;
case FocusDirection::Left:
x -= shakeAnimation(t_ns, amplitude);
break;
case FocusDirection::Right:
x += shakeAnimation(t_ns, amplitude);
break;
default:
break;
}
x = std::clamp(x, -amplitude, amplitude);
y = std::clamp(y, -amplitude, amplitude);
}
}
if (!m_drawFrameless) {
if (ult::useSelectionBG) {
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor));
else
renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(selectionBGColor));
}
renderer->drawBorderedRoundedRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11, this->getHeight(), 5, 5, a(highlightColor));
} else {
if (ult::useSelectionBG) {
if (ult::expandedMemory)
renderer->drawRectMultiThreaded(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor));
else
renderer->drawRect(this->getX() + x +19, this->getY() + y, this->getWidth()-11-4, this->getHeight(), aWithOpacity(clickColor));
}
}
ult::onTrackBar.store(true, std::memory_order_release);
if (m_clickActive) {
const u64 elapsedTime_ns = currentTime_ns - m_clickStartTime_ns;
auto clickAnimationProgress = tsl::style::ListItemHighlightLength * (1.0f - (static_cast<float>(elapsedTime_ns) / 500000000.0f));
if (clickAnimationProgress < 0.0f) {
clickAnimationProgress = 0.0f;
}
if (clickAnimationProgress > 0.0f) {
const u8 saturation = tsl::style::ListItemHighlightSaturation * (float(clickAnimationProgress) / float(tsl::style::ListItemHighlightLength));
Color animColor = {0xF, 0xF, 0xF, 0xF};
if (invertBGClickColor) {
animColor.r = 15 - saturation;
animColor.g = 15 - saturation;
animColor.b = 15 - saturation;
} else {
animColor.r = saturation;
animColor.g = saturation;
animColor.b = saturation;
}
animColor.a = selectionBGColor.a;
renderer->drawRect(this->getX() +22, this->getY(), this->getWidth() -22, this->getHeight(), aWithOpacity(animColor));
}
}
}
virtual inline u8 getProgress() {
return this->m_value;
}
virtual void setProgress(u8 value) {
this->m_value = value;
}
void setValueChangedListener(std::function<void(u8)> valueChangedListener) {
this->m_valueChangedListener = valueChangedListener;
}
protected:
std::string m_label;
std::string m_packagePath;
std::string m_selection;
s16 m_value = 0;
s16 m_minValue = 0;
s16 m_maxValue = 100;
std::string m_units;
bool m_interactionLocked = false;
bool m_keyRHeld = false;
std::function<void(u8)> m_valueChangedListener = [](u8) {};
std::function<bool(std::vector<std::vector<std::string>>&&, const std::string&, const std::string&)> interpretAndExecuteCommands;
std::function<std::vector<std::vector<std::string>>(const std::vector<std::vector<std::string>>&, const std::string&, size_t, const std::string&)> getSourceReplacement;
std::vector<std::vector<std::string>> commands;
std::string selectedCommand;
bool m_usingStepTrackbar = false;
bool m_usingNamedStepTrackbar = false;
s16 m_numSteps = 2;
s16 m_index = 0;
bool m_unlockedTrackbar = false;
bool m_executeOnEveryTick = false;
bool touchInSliderBounds = false;
bool triggerClick = false;
std::function<void()> m_scriptKeyListener;
// Instance variables replacing static ones
float m_lastBottomBound = 0.0f;
std::string m_valuePart = "";
u64 m_clickStartTime_ns = 0;
bool m_clickActive = false;
std::string m_lastLabel = "";
bool m_holding = false;
u64 m_holdStartTime_ns = 0;
u64 m_prevKeysHeld = 0;
bool m_wasLastHeld = false;
bool m_drawFrameless = false;
};
/**
* @brief A customizable analog trackbar going from 0% to 100% but using discrete steps (Like the volume slider)
*
*/
class StepTrackBarV2 : public TrackBarV2 {
public:
/**
* @brief Constructor
*
* @param icon Icon shown next to the track bar
* @param numSteps Number of steps the track bar has
*/
StepTrackBarV2(std::string label, std::string packagePath, size_t numSteps, s16 minValue, s16 maxValue, std::string units,
std::function<bool(std::vector<std::vector<std::string>>&&, const std::string&, const std::string&)> executeCommands = nullptr,
std::function<std::vector<std::vector<std::string>>(const std::vector<std::vector<std::string>>&, const std::string&, size_t, const std::string&)> sourceReplacementFunc = nullptr,
std::vector<std::vector<std::string>> cmd = {}, const std::string& selCmd = "", bool usingNamedStepTrackbar = false, bool unlockedTrackbar = false, bool executeOnEveryTick = false)
: TrackBarV2(label, packagePath, minValue, maxValue, units, executeCommands, sourceReplacementFunc, cmd, selCmd, !usingNamedStepTrackbar, usingNamedStepTrackbar, numSteps, unlockedTrackbar, executeOnEveryTick) {}
virtual ~StepTrackBarV2() {}
virtual inline bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) override {
static u32 tick = 0;
static bool holding = false;
static u64 prevKeysHeld = 0;
const u64 keysReleased = prevKeysHeld & ~keysHeld;
prevKeysHeld = keysHeld;
static bool wasLastHeld = false;
// ADD THIS LINE: Update KEY_R state for visual appearance
m_keyRHeld = (keysHeld & KEY_R) != 0;
if ((keysHeld & KEY_R)) {
//auto currentFocus = currentGui->getFocusedElement();
if (keysDown & KEY_UP && !(keysHeld & ~KEY_UP & ~KEY_R & ALL_KEYS_MASK))
this->shakeHighlight(FocusDirection::Up);
else if (keysDown & KEY_DOWN && !(keysHeld & ~KEY_DOWN & ~KEY_R & ALL_KEYS_MASK))
this->shakeHighlight(FocusDirection::Down);
else if (keysDown & KEY_LEFT && !(keysHeld & ~KEY_LEFT & ~KEY_R & ALL_KEYS_MASK)){
this->shakeHighlight(FocusDirection::Left);
}
else if (keysDown & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ~KEY_R & ALL_KEYS_MASK)) {
this->shakeHighlight(FocusDirection::Right);
}
return true;
}
// Check if KEY_A is pressed to toggle ult::allowSlide
if ((keysDown & KEY_A) && !(keysHeld & ~KEY_A & ALL_KEYS_MASK)) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerEnterSound.store(true, std::memory_order_release);
triggerEnterFeedback();
if (!m_unlockedTrackbar) {
ult::atomicToggle(ult::allowSlide);
holding = false; // Reset holding state when KEY_A is pressed
}
if (m_unlockedTrackbar || (!m_unlockedTrackbar && !ult::allowSlide.load(std::memory_order_acquire))) {
updateAndExecute();
triggerClick = true;
}
return true;
}
//if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) {
// triggerRumbleDoubleClick.store(true, std::memory_order_release);
// triggerExitSound.store(true, std::memory_order_release);
//}
// Handle SCRIPT_KEY press
if ((keysDown & SCRIPT_KEY) && !(keysHeld & ~SCRIPT_KEY & ALL_KEYS_MASK)) {
if (m_scriptKeyListener) {
m_scriptKeyListener();
}
return true;
}
if (ult::allowSlide.load(std::memory_order_acquire) || m_unlockedTrackbar) {
if (((keysReleased & KEY_LEFT) || (keysReleased & KEY_RIGHT)) ||
(wasLastHeld && !(keysHeld & (KEY_LEFT | KEY_RIGHT)))) {
updateAndExecute();
holding = false;
wasLastHeld = false;
tick = 0;
return true;
}
if (keysHeld & KEY_LEFT && keysHeld & KEY_RIGHT) {
tick = 0;
return true;
}
if (keysHeld & (KEY_LEFT | KEY_RIGHT)) {
if (!holding) {
holding = true;
tick = 0;
}
if ((tick == 0 || tick > 20) && (tick % 3) == 0) {
const float stepSize = static_cast<float>(m_maxValue - m_minValue) / (this->m_numSteps - 1);
if (keysHeld & KEY_LEFT && this->m_index > 0) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
this->m_index--;
this->m_value = static_cast<s16>(std::round(m_minValue + m_index * stepSize));
} else if (keysHeld & KEY_RIGHT && this->m_index < this->m_numSteps-1) {
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerNavigationSound.store(true, std::memory_order_release);
triggerNavigationFeedback();
this->m_index++;
this->m_value = static_cast<s16>(std::round(m_minValue + m_index * stepSize));
} else {
return false;
}
this->m_valueChangedListener(this->getProgress());
if (m_executeOnEveryTick)
updateAndExecute(false);
wasLastHeld = true;
}
tick++;
return true;
} else {
holding = false;
tick = 0;
}
}
return false;
}
/**
* @brief Gets the current value of the trackbar
*
* @return State
*/
virtual inline u8 getProgress() override {
return this->m_value / (100 / (this->m_numSteps - 1));
}
/**
* @brief Sets the current state of the toggle. Updates the Value
*
* @param state State
*/
virtual void setProgress(u8 value) override {
value = std::min(value, u8(this->m_numSteps - 1));
this->m_value = value * (100 / (this->m_numSteps - 1));
}
//protected:
//u8 m_numSteps = 1;
};
/**
* @brief A customizable trackbar with multiple discrete steps with specific names. Name gets displayed above the bar
*
*/
class NamedStepTrackBarV2 : public StepTrackBarV2 {
public:
u16 trackBarWidth, stepWidth, currentDescIndex;
u32 descWidth, descHeight;
/**
* @brief Constructor
*
* @param icon Icon shown next to the track bar
* @param stepDescriptions Step names displayed above the track bar
*/
NamedStepTrackBarV2(std::string label, std::string packagePath, std::vector<std::string>& stepDescriptions,
std::function<bool(std::vector<std::vector<std::string>>&&, const std::string&, const std::string&)> executeCommands = nullptr,
std::function<std::vector<std::vector<std::string>>(const std::vector<std::vector<std::string>>&, const std::string&, size_t, const std::string&)> sourceReplacementFunc = nullptr,
std::vector<std::vector<std::string>> cmd = {}, const std::string& selCmd = "", bool unlockedTrackbar = false, bool executeOnEveryTick = false)
: StepTrackBarV2(label, packagePath, stepDescriptions.size(), 0, (stepDescriptions.size()-1), "", executeCommands, sourceReplacementFunc, cmd, selCmd, true, unlockedTrackbar, executeOnEveryTick), m_stepDescriptions(stepDescriptions) {
//usingNamedStepTrackbar = true;
//logMessage("on initialization");
// Initialize the selection with the current index
if (!m_stepDescriptions.empty() && m_index >= 0 && m_index < static_cast<s16>(m_stepDescriptions.size())) {
this->m_selection = m_stepDescriptions[m_index];
currentDescIndex = m_index;
}
}
virtual ~NamedStepTrackBarV2() {}
virtual void draw(gfx::Renderer *renderer) override {
// Cache frequently used values
const u16 trackBarWidth = this->getWidth() - 95;
const u16 baseX = this->getX() + 59;
const u16 baseY = this->getY() + 44; // 50 - 3
const u8 numSteps = this->m_numSteps;
const u8 halfNumSteps = (numSteps - 1) / 2;
const u16 lastStepX = baseX + trackBarWidth - 1;
// Pre-calculate step spacing
const float stepSpacing = static_cast<float>(trackBarWidth) / (numSteps - 1);
// Cache color for multiple drawRect calls
const auto stepColor = a(trackBarEmptyColor);
// Draw step rectangles - optimized loop
u16 stepX;
for (u8 i = 0; i < numSteps; i++) {
if (i == numSteps - 1) {
// Last step - avoid overshooting
stepX = lastStepX;
} else {
stepX = baseX + static_cast<u16>(std::round(i * stepSpacing));
// Adjust for steps on right side of center
if (i > halfNumSteps) {
stepX -= 1;
}
}
renderer->drawRect(stepX, baseY, 1, 8, stepColor);
}
// Update selection (only if index changed - optional optimization)
if (currentDescIndex != this->m_index) {
currentDescIndex = this->m_index;
this->m_selection = this->m_stepDescriptions[currentDescIndex];
}
// Draw the parent trackbar
StepTrackBarV2::draw(renderer);
}
protected:
std::vector<std::string> m_stepDescriptions;
};
}
// Global state and event system
static inline Event notificationEvent;
static inline std::mutex notificationJsonMutex;
static inline std::atomic<uint32_t> notificationGeneration{0};
struct NotificationFile {
std::string filename;
std::string fullPath;
time_t creationTime;
int priority;
};
class NotificationPrompt {
public:
NotificationPrompt()
: enabled_(true),
is_active_(false),
//pending_event_fire_(false),
generation_(notificationGeneration.load(std::memory_order_acquire))
{}
~NotificationPrompt() {
shutdown(); // safe cleanup
}
enum class PromptState {
Inactive,
SlidingIn,
Visible,
SlidingOut
};
struct NotificationData {
std::string text;
std::string fileName;
size_t fontSize = 28;
s32 promptWidth = 448;
s32 promptHeight = 88;
u32 durationMs = 2500;
u32 priority = 20;
u64 arrivalNs = 0;
NotificationData() = default;
NotificationData(const std::string& t, const std::string& f = "",
size_t fs = 28, s32 w = 448, s32 h = 88,
u32 dur = 2500, u32 prio = 20)
: text(t), fileName(f), fontSize(fs), promptWidth(w), promptHeight(h),
durationMs(dur), priority(prio), arrivalNs(0) {}
};
struct NotificationCompare {
bool operator()(const NotificationData& a, const NotificationData& b) const {
if (a.priority == b.priority) {
return a.arrivalNs > b.arrivalNs; // FIFO
}
return a.priority > b.priority; // Max-heap
}
};
struct NotificationState {
std::string activeText;
std::string fileName;
size_t fontSize = 28;
s32 promptWidth = 448;
s32 promptHeight = 88;
PromptState state = PromptState::Inactive;
u64 expireNs = 0;
u64 stateStartNs = 0;
NotificationState() = default;
bool isTextEmpty() const { return activeText.empty(); }
};
// ---------------- Public Methods ----------------
void show(const std::string& msg, size_t fontSize = 26, u32 priority = 20,
const std::string& fileName = "", u32 durationMs = 2500,
s32 promptWidth = 448, s32 promptHeight = 88)
{
if (msg.empty()) return;
// Quick reject using atomics (fast-path)
if (!enabled_.load(std::memory_order_acquire)) return;
if (!ult::useNotifications) return;
if (generation_ != notificationGeneration.load(std::memory_order_acquire)) return;
NotificationData data;
data.text = msg;
data.fileName = fileName;
data.fontSize = std::clamp(fontSize, size_t(8), size_t(48));
data.promptWidth = std::clamp(promptWidth, s32(100), s32(1280));
data.promptHeight = std::clamp(promptHeight, s32(50), s32(720));
data.durationMs = std::clamp(durationMs, 500u, 30000u);
data.priority = priority;
data.arrivalNs = armTicksToNs(armGetSystemTick());
std::lock_guard<std::mutex> lg(state_mutex_);
// Re-check under lock to avoid TOCTOU
if (!enabled_.load(std::memory_order_acquire)) return;
if (generation_ != notificationGeneration.load(std::memory_order_acquire)) return;
if (pending_queue_.size() >= MAX_NOTIFS) return;
pending_queue_.push(data);
if (!is_active_) {
startNext_NoLock();
//pending_event_fire_.store(true, std::memory_order_release);
eventFire(&notificationEvent);
#if IS_STATUS_MONITOR_DIRECTIVE
if (isRendering) {
isRendering = false;
wasRendering = true;
leventSignal(&renderingStopEvent);
}
#endif
}
}
void draw(gfx::Renderer* renderer, bool promptOnly = false) {
if (ult::launchingOverlay.load(std::memory_order_acquire) ||
generation_ != notificationGeneration.load(std::memory_order_acquire)) return;
if (!enabled_.load(std::memory_order_acquire)) return;
NotificationState copy;
{
std::lock_guard<std::mutex> lg(state_mutex_);
if (current_state_.state == PromptState::Inactive || current_state_.activeText.empty()) return;
copy = current_state_;
}
const u64 now = armTicksToNs(armGetSystemTick());
const u64 elapsedMs = (now - copy.stateStartNs) / 1'000'000ULL;
s32 x = 0, y = 0;
switch (copy.state) {
case PromptState::SlidingIn: {
const float t = std::min(1.0f, float(elapsedMs) / SLIDE_DURATION_MS);
x = ult::useRightAlignment ?
(tsl::cfg::FramebufferWidth - copy.promptWidth + static_cast<s32>((1.0f - t) * copy.promptWidth)) :
static_cast<s32>(-copy.promptWidth + t * copy.promptWidth);
break;
}
case PromptState::Visible:
x = ult::useRightAlignment ? (tsl::cfg::FramebufferWidth - copy.promptWidth) : 0;
break;
case PromptState::SlidingOut: {
const float t = std::min(1.0f, float(elapsedMs) / SLIDE_DURATION_MS);
x = ult::useRightAlignment ?
(tsl::cfg::FramebufferWidth - copy.promptWidth + static_cast<s32>(t * copy.promptWidth)) :
static_cast<s32>(-t * copy.promptWidth);
break;
}
default: return;
}
const s32 scissorX = std::max(0, x);
const s32 scissorW = std::min(copy.promptWidth, tsl::cfg::FramebufferWidth - scissorX);
if (scissorX >= 0 && scissorW > 0 && copy.promptHeight > 0) {
renderer->enableScissoring(scissorX, y, scissorW, copy.promptHeight);
#if IS_STATUS_MONITOR_DIRECTIVE
renderer->drawRect(x, y, copy.promptWidth, copy.promptHeight, defaultBackgroundColor);
#else
if (!promptOnly && ult::expandedMemory)
renderer->drawRectMultiThreaded(x, y, copy.promptWidth, copy.promptHeight, defaultBackgroundColor);
else
renderer->drawRect(x, y, copy.promptWidth, copy.promptHeight, defaultBackgroundColor);
#endif
if (!copy.activeText.empty()) {
std::vector<std::string> lines;
const std::string& text = copy.activeText;
size_t start = 0;
while (start < text.size() && lines.size() < 8) {
// Look for escaped "\n"
const size_t pos = text.find("\\n", start);
if (pos == std::string::npos) {
// No more "\n", take the rest
lines.emplace_back(text.substr(start));
break;
} else {
// Extract line up to the escape sequence
lines.emplace_back(text.substr(start, pos - start));
start = pos + 2; // Skip past "\n"
}
}
const auto fm = tsl::gfx::FontManager::getFontMetricsForCharacter('A', copy.fontSize);
const s32 startY = y + (copy.promptHeight - static_cast<int>(lines.size()) * fm.lineHeight) / 2 + fm.ascent;
for (size_t i = 0; i < lines.size(); ++i) {
const std::string& line = lines[i];
#if IS_LAUNCHER_DIRECTIVE
// Check if line contains "Ultrahand" (case insensitive)
const bool hasUltrahand = (line.find(ult::CAPITAL_ULTRAHAND_PROJECT_NAME) != std::string::npos);
if (hasUltrahand) {
// Draw line with dynamic Ultrahand effect
drawUltrahandLine(renderer, line, x, startY + static_cast<int>(i) * fm.lineHeight,
copy.fontSize, copy.promptWidth);
} else {
// Draw normal line
const auto [lw, lh] = renderer->getNotificationTextDimensions(line, false, copy.fontSize);
renderer->drawNotificationString(
line, false,
x + (copy.promptWidth - lw) / 2,
startY + static_cast<int>(i) * fm.lineHeight,
copy.fontSize, notificationTextColor
);
}
#else
// Draw normal line
const auto [lw, lh] = renderer->getNotificationTextDimensions(line, false, copy.fontSize);
renderer->drawNotificationString(
line, false,
x + (copy.promptWidth - lw) / 2,
startY + static_cast<int>(i) * fm.lineHeight,
copy.fontSize, notificationTextColor
);
#endif
}
}
if (!ult::useRightAlignment) {
renderer->drawRect(x + copy.promptWidth - 1, y, 1, copy.promptHeight, edgeSeparatorColor);
renderer->drawRect(x, y + copy.promptHeight - 1, copy.promptWidth, 1, edgeSeparatorColor);
} else {
renderer->drawRect(x, y, 1, copy.promptHeight, edgeSeparatorColor);
renderer->drawRect(x, y + copy.promptHeight - 1, copy.promptWidth, 1, edgeSeparatorColor);
}
renderer->disableScissoring();
}
}
#if IS_LAUNCHER_DIRECTIVE
void drawUltrahandLine(gfx::Renderer* renderer, const std::string& line, s32 x, s32 y,
u32 fontSize, s32 promptWidth) {
// Find position of "Ultrahand" in the line (case insensitive)
size_t ultrahandPos = std::string::npos;
std::string ultrahandToReplace;
// Check for "Ultrahand" first
ultrahandPos = line.find(ult::CAPITAL_ULTRAHAND_PROJECT_NAME);
if (ultrahandPos != std::string::npos) {
ultrahandToReplace = ult::CAPITAL_ULTRAHAND_PROJECT_NAME;
}
if (ultrahandPos == std::string::npos) {
// Fallback to normal drawing if not found
const auto [lw, lh] = renderer->getNotificationTextDimensions(line, false, fontSize);
renderer->drawNotificationString(line, false, x + (promptWidth - lw) / 2, y, fontSize, notificationTextColor);
return;
}
// Split the line into parts
const std::string before = line.substr(0, ultrahandPos);
const std::string hand = ult::SPLIT_PROJECT_NAME_2;
const std::string after = line.substr(ultrahandPos + ultrahandToReplace.length());
// Calculate individual part widths to get accurate total width
s32 beforeWidth = 0, handWidth = 0, afterWidth = 0;
if (!before.empty()) {
const auto [bw, bh] = renderer->getNotificationTextDimensions(before, false, fontSize);
beforeWidth = bw;
}
if (!after.empty()) {
const auto [aw, ah] = renderer->getNotificationTextDimensions(after, false, fontSize);
afterWidth = aw;
}
const auto [hw, hh] = renderer->getNotificationTextDimensions(hand, false, fontSize);
handWidth = hw;
// Use shared utility to calculate Ultra width
const s32 ultraWidth = tsl::elm::calculateUltraTextWidth(renderer, fontSize, true);
// Calculate total width and starting position for centering
const s32 totalWidth = beforeWidth + ultraWidth + handWidth + afterWidth;
s32 currentX = x + (promptWidth - totalWidth) / 2;
// Draw each part in sequence
// Draw "before" part
if (!before.empty()) {
renderer->drawNotificationString(before, false, currentX, y, fontSize, notificationTextColor);
currentX += beforeWidth;
}
// Draw dynamic "Ultra" part using shared utility
currentX = tsl::elm::drawDynamicUltraText(renderer, currentX, y, fontSize, logoColor1, true);
// Draw static "hand" part
renderer->drawNotificationString(hand, false, currentX, y, fontSize, logoColor2);
currentX += handWidth;
// Draw "after" part
if (!after.empty()) {
renderer->drawNotificationString(after, false, currentX, y, fontSize, notificationTextColor);
}
}
#endif
void update() {
if (!isActive()) {
return;
}
std::lock_guard<std::mutex> lg(state_mutex_);
// Optional extra safety: skip if already inactive and queue empty
if (ult::launchingOverlay.load(std::memory_order_acquire) ||
(!is_active_ && current_state_.activeText.empty() && pending_queue_.empty())) {
return;
}
//std::lock_guard<std::mutex> lg(state_mutex_);
if (generation_ != notificationGeneration.load(std::memory_order_acquire) ||
!enabled_.load(std::memory_order_acquire))
{
current_state_ = NotificationState{};
is_active_ = false;
return;
}
const u64 now = armTicksToNs(armGetSystemTick());
const u64 elapsedMs = (current_state_.stateStartNs == 0) ? 0 : (now - current_state_.stateStartNs) / 1'000'000ULL;
switch (current_state_.state) {
case PromptState::SlidingIn:
if (elapsedMs >= SLIDE_DURATION_MS) {
current_state_.state = PromptState::Visible;
current_state_.stateStartNs = now;
}
break;
case PromptState::Visible:
if (now >= current_state_.expireNs) {
current_state_.state = PromptState::SlidingOut;
current_state_.stateStartNs = now;
}
break;
case PromptState::SlidingOut:
if (elapsedMs >= SLIDE_DURATION_MS) {
const std::string fileToDelete = current_state_.fileName;
// Delete the JSON file safely
if (!fileToDelete.empty()) {
std::lock_guard<std::mutex> lg(notificationJsonMutex);
const std::string fullPath = ult::NOTIFICATIONS_PATH + fileToDelete;
remove(fullPath.c_str()); // ignore errors for now
}
current_state_ = NotificationState{};
const bool hadNext = startNext_NoLock();
if (!hadNext) {
is_active_ = false;
}
}
break;
default: break;
}
}
bool isActive() const {
if (!ult::useNotifications) return false;
if (generation_ != notificationGeneration.load(std::memory_order_acquire)) return false;
std::lock_guard<std::mutex> lg(state_mutex_);
if (is_active_) return true;
if (!pending_queue_.empty()) return true;
//if (pending_event_fire_.load(std::memory_order_acquire)) return true;
if (!current_state_.activeText.empty() && current_state_.state != PromptState::Inactive) return true;
return false;
}
void shutdown() {
enabled_.store(false, std::memory_order_release);
notificationGeneration.fetch_add(1, std::memory_order_acq_rel);
generation_ = notificationGeneration.load(std::memory_order_acquire);
std::lock_guard<std::mutex> lg(state_mutex_);
while (!pending_queue_.empty()) pending_queue_.pop();
current_state_ = NotificationState{};
is_active_ = false;
//pending_event_fire_.store(false, std::memory_order_release);
}
void forceShutdown() {
enabled_.store(false, std::memory_order_release);
//pending_event_fire_.store(false, std::memory_order_release);
}
//void forceCompleteTransition() {
// std::lock_guard<std::mutex> lg(state_mutex_);
// current_state_ = NotificationState{};
// while (!pending_queue_.empty()) pending_queue_.pop();
// is_active_ = false;
// //pending_event_fire_.store(false, std::memory_order_release);
//}
//
//void freezeState() {
// generation_++;
// enabled_.store(false, std::memory_order_release);
// {
// std::lock_guard<std::mutex> lg(state_mutex_);
// is_active_ = false;
// }
// //pending_event_fire_.store(false, std::memory_order_release);
//}
private:
static constexpr size_t MAX_NOTIFS = 30;
static constexpr u32 SLIDE_DURATION_MS = 200;
//static constexpr double cycleDuration = 1.6;
mutable std::mutex state_mutex_;
NotificationState current_state_;
std::priority_queue<NotificationData, std::vector<NotificationData>, NotificationCompare> pending_queue_;
std::atomic<bool> enabled_{true};
bool is_active_{false}; // protected by mutex
//std::atomic<bool> pending_event_fire_{false};
uint32_t generation_{0};
bool startNext_NoLock() {
if (pending_queue_.empty()) return false;
const NotificationData next = pending_queue_.top();
pending_queue_.pop();
const u64 now = armTicksToNs(armGetSystemTick());
current_state_.activeText = next.text;
current_state_.fileName = next.fileName;
current_state_.fontSize = next.fontSize;
current_state_.promptWidth = next.promptWidth;
current_state_.promptHeight = next.promptHeight;
current_state_.state = PromptState::SlidingIn;
current_state_.stateStartNs = now;
current_state_.expireNs = now + static_cast<u64>(SLIDE_DURATION_MS) * 1'000'000ULL
+ static_cast<u64>(next.durationMs) * 1'000'000ULL;
is_active_ = true;
return true;
}
};
// Optional: pointer to global notification
static inline NotificationPrompt* notification = nullptr;
// GUI
/**
* @brief The top level Gui class
* @note The main menu and every sub menu are a separate Gui. Create your own Gui class that extends from this one to create your own menus
*
*/
class Gui {
public:
Gui() {
#if IS_LAUNCHER_DIRECTIVE
#else
{
#if INITIALIZE_IN_GUI_DIRECTIVE // for different project structures
tsl::initializeThemeVars();
// Load the bitmap file into memory
ult::loadWallpaperFileWhenSafe();
#endif
}
#endif
}
virtual ~Gui() {
if (this->m_topElement != nullptr)
delete this->m_topElement;
if (this->m_bottomElement != nullptr)
delete this->m_bottomElement;
}
/**
* @brief Creates all elements present in this Gui
* @note Implement this function and let it return a heap allocated element used as the top level element. This is usually some kind of frame e.g \ref OverlayFrame
*
* @return Top level element
*/
virtual elm::Element* createUI() = 0;
/**
* @brief Called once per frame to update values
*
*/
virtual void update() {}
/**
* @brief Called once per frame with the latest HID inputs
*
* @param keysDown Buttons pressed in the last frame
* @param keysHeld Buttons held down longer than one frame
* @param touchInput Last touch position
* @param leftJoyStick Left joystick position
* @param rightJoyStick Right joystick position
* @return Weather or not the input has been consumed
*/
virtual inline bool handleInput(u64 keysDown, u64 keysHeld, const HidTouchState &touchPos, HidAnalogStickState leftJoyStick, HidAnalogStickState rightJoyStick) {
return false;
}
/**
* @brief Gets the top level element
*
* @return Top level element
*/
elm::Element* getTopElement() {
return this->m_topElement;
}
/**
* @brief Gets the bottom level element
*
* @return Bottom level element
*/
elm::Element* getBottomElement() {
return this->m_bottomElement;
}
/**
* @brief Get the currently focused element
*
* @return Focused element
*/
elm::Element* getFocusedElement() {
return this->m_focusedElement;
}
/**
* @brief Requests focus to a element
* @note Use this function when focusing a element outside of a element's requestFocus function
*
* @param element Element to focus
* @param direction Focus direction
*/
inline void requestFocus(elm::Element *element, FocusDirection direction, bool shake = true) {
elm::Element *oldFocus = this->m_focusedElement;
if (element != nullptr) {
this->m_focusedElement = element->requestFocus(oldFocus, direction);
if (oldFocus != nullptr)
oldFocus->setFocused(false);
if (this->m_focusedElement != nullptr) {
this->m_focusedElement->setFocused(true);
}
}
if (shake && oldFocus == this->m_focusedElement && this->m_focusedElement != nullptr)
this->m_focusedElement->shakeHighlight(direction);
}
/**
* @brief Removes focus from a element
*
* @param element Element to remove focus from. Pass nullptr to remove the focus unconditionally
*/
inline void removeFocus(elm::Element* element = nullptr) {
if (element == nullptr || element == this->m_focusedElement) {
if (this->m_focusedElement != nullptr) {
this->m_focusedElement->setFocused(false);
this->m_focusedElement = nullptr;
}
}
}
inline void restoreFocus() {
this->m_initialFocusSet = false;
}
protected:
constexpr static inline auto a = &gfx::Renderer::a;
constexpr static inline auto aWithOpacity = &gfx::Renderer::aWithOpacity;
private:
elm::Element *m_focusedElement = nullptr;
elm::Element *m_topElement = nullptr;
elm::Element *m_bottomElement = nullptr;
bool m_initialFocusSet = false;
friend class Overlay;
friend class gfx::Renderer;
//// Function to recursively find the bottom element
//void findBottomElement(elm::Element* currentElement) {
// // Base case: if the current element has no children, it is the bottom element
// if (currentElement->getChildren().empty()) {
// m_bottomElement = currentElement;
// return;
// }
//
// // Recursive case: traverse through all children elements
// for (elm::Element* child : currentElement->getChildren()) {
// findBottomElement(child);
// }
//}
/**
* @brief Draws the Gui
*
* @param renderer
*/
void draw(gfx::Renderer *renderer) {
if (this->m_topElement != nullptr)
this->m_topElement->draw(renderer);
}
inline bool initialFocusSet() {
return this->m_initialFocusSet;
}
inline void markInitialFocusSet() {
this->m_initialFocusSet = true;
}
};
// Overlay
/**
* @brief The top level Overlay class
* @note Every Tesla overlay should have exactly one Overlay class initializing services and loading the default Gui
*/
class Overlay {
protected:
/**
* @brief Constructor
* @note Called once when the Overlay gets loaded
*/
Overlay() {}
public:
/**
* @brief Deconstructor
* @note Called once when the Overlay exits
*
*/
virtual ~Overlay() {}
/**
* @brief Initializes services
* @note Called once at the start to initializes services. You have a sm session available during this call, no need to initialize sm yourself
*/
virtual void initServices() {}
/**
* @brief Exits services
* @note Make sure to exit all services you initialized in \ref Overlay::initServices() here to prevent leaking handles
*/
virtual void exitServices() {}
/**
* @brief Called before overlay changes from invisible to visible state
*
*/
virtual void onShow() {}
/**
* @brief Called before overlay changes from visible to invisible state
*
*/
virtual void onHide() {}
/**
* @brief Loads the default Gui
* @note This function should return the initial Gui to load using the \ref Gui::initially<T>(Args.. args) function
* e.g `return initially<GuiMain>();`
*
* @return Default Gui
*/
virtual std::unique_ptr<tsl::Gui> loadInitialGui() = 0;
/**
* @brief Gets a reference to the current Gui on top of the Gui stack
*
* @return Current Gui reference
*/
std::unique_ptr<tsl::Gui>& getCurrentGui() {
return this->m_guiStack.top();
}
/**
* @brief Shows the Gui
*
*/
void show() {
if (this->m_disableNextAnimation) {
this->m_animationCounter = MAX_ANIMATION_COUNTER;
this->m_disableNextAnimation = false;
}
else {
this->m_fadeInAnimationPlaying = true;
this->m_animationCounter = 0;
}
ult::isHidden.store(false);
this->onShow();
triggerRumbleClick.store(true, std::memory_order_release);
// reinitialize audio for changes from handheld to docked and vise versa
if (ult::expandedMemory && ult::useSoundEffects)
ult::AudioPlayer::reloadIfDockedChanged();
//if (auto& currGui = this->getCurrentGui(); currGui != nullptr) // TESTING DISABLED (EFFECTS NEED TO BE VERIFIED)
// currGui->restoreFocus();
}
/**
* @brief Hides the Gui
*
*/
void hide(bool useNoFade = false) {
if (useNoFade) {
// Immediately hide overlay
ult::isHidden.store(true);
this->m_shouldHide = true;
return;
}
#if IS_STATUS_MONITOR_DIRECTIVE
if (FullMode && !deactivateOriginalFooter) {
if (this->m_disableNextAnimation) {
this->m_animationCounter = 0;
this->m_disableNextAnimation = false;
}
else {
this->m_fadeOutAnimationPlaying = true;
this->m_animationCounter = MAX_ANIMATION_COUNTER;
}
ult::isHidden.store(true);
this->onHide();
}
#else
if (this->m_disableNextAnimation) {
this->m_animationCounter = 0;
this->m_disableNextAnimation = false;
}
else {
this->m_fadeOutAnimationPlaying = true;
this->m_animationCounter = MAX_ANIMATION_COUNTER;
}
ult::isHidden.store(true);
this->onHide();
#endif
triggerRumbleClick.store(true, std::memory_order_release);
}
/**
* @brief Returns whether fade animation is playing
*
* @return whether fade animation is playing
*/
bool fadeAnimationPlaying() {
return this->m_fadeInAnimationPlaying || this->m_fadeOutAnimationPlaying;
}
/**
* @brief Closes the Gui
* @note This makes the Tesla overlay exit and return back to the Tesla-Menu
*
*/
void close(bool forceClose = false) {
if (!forceClose && notification && notification->isActive()) {
this->closeAfter();
this->hide(true);
return;
}
this->m_shouldClose = true;
}
/**
* @brief Closes the Gui
* @note This makes the Tesla overlay exit and return back to the Tesla-Menu
*
*/
void closeAfter() {
this->m_shouldCloseAfter = true;
}
/**
* @brief Gets the Overlay instance
*
* @return Overlay instance
*/
static inline Overlay* const get() {
return Overlay::s_overlayInstance;
}
/**
* @brief Creates the initial Gui of an Overlay and moves the object to the Gui stack
*
* @tparam T
* @tparam Args
* @param args
* @return constexpr std::unique_ptr<T>
*/
template<typename T, typename ... Args>
constexpr inline std::unique_ptr<T> initially(Args&&... args) {
return std::make_unique<T>(args...);
}
private:
using GuiPtr = std::unique_ptr<tsl::Gui>;
std::stack<GuiPtr, std::list<GuiPtr>> m_guiStack;
static inline Overlay *s_overlayInstance = nullptr;
bool m_fadeInAnimationPlaying = false, m_fadeOutAnimationPlaying = false;
u8 m_animationCounter = 0;
static constexpr int MAX_ANIMATION_COUNTER = 5; // Define the maximum animation counter value
bool m_shouldHide = false;
bool m_shouldClose = false;
bool m_shouldCloseAfter = false;
bool m_disableNextAnimation = false;
bool m_closeOnExit;
static inline std::atomic<bool> isNavigatingBackwards{false};
bool justNavigated = false;
/**
* @brief Initializes the Renderer
*
*/
void initScreen() {
gfx::Renderer::get().init();
}
/**
* @brief Exits the Renderer
*
*/
void exitScreen() {
gfx::Renderer::get().exit();
}
/**
* @brief Weather or not the Gui should get hidden
*
* @return should hide
*/
bool shouldHide() {
return this->m_shouldHide;
}
/**
* @brief Weather or not hte Gui should get closed
*
* @return should close
*/
bool shouldClose() {
return this->m_shouldClose;
}
/**
* @brief Weather or not hte Gui should get closed after
*
* @return should close after
*/
bool shouldCloseAfter() {
return this->m_shouldCloseAfter;
}
/**
* @brief Quadratic ease-in-out function
*
* @param t Normalized time (0 to 1)
* @return Eased value
*/
float calculateEaseInOut(float t) {
if (t < 0.5) {
return 2 * t * t;
} else {
return -1 + (4 - 2 * t) * t;
}
}
/**
* @brief Handles fade in and fade out animations of the Overlay
*
*/
void animationLoop() {
if (this->m_fadeInAnimationPlaying) {
if (this->m_animationCounter < MAX_ANIMATION_COUNTER) {
this->m_animationCounter++;
}
if (this->m_animationCounter >= MAX_ANIMATION_COUNTER) {
this->m_fadeInAnimationPlaying = false;
}
}
if (this->m_fadeOutAnimationPlaying) {
if (this->m_animationCounter > 0) {
this->m_animationCounter--;
}
if (this->m_animationCounter == 0) {
this->m_fadeOutAnimationPlaying = false;
this->m_shouldHide = true;
}
}
// Calculate and set the opacity using an easing function
//float opacity = calculateEaseInOut(static_cast<float>(this->m_animationCounter) / MAX_ANIMATION_COUNTER);
gfx::Renderer::setOpacity(calculateEaseInOut(static_cast<float>(this->m_animationCounter) / MAX_ANIMATION_COUNTER));
}
/**
* @brief Overlay Main loop
*
*/
void loop(bool promptOnly = false) {
// Early exit check - avoid all work if shutting down
if (ult::launchingOverlay.load(std::memory_order_acquire)) {
return;
}
// CRITICAL: Initialize to TRUE because stacks are added in init()!
static std::atomic<bool> screenshotStacksAdded{true};
static std::atomic<bool> notificationCacheNeedsClearing{false};
auto& renderer = gfx::Renderer::get();
renderer.startFrame();
// Handle main UI rendering
if (!promptOnly) {
// In normal mode, ensure screenshots are enabled
// Only re-add if they were removed AND force-disable is not set
if (!screenshotStacksAdded.load(std::memory_order_acquire) &&
!screenshotsAreForceDisabled.load(std::memory_order_acquire)) {
if (!screenshotStacksAdded.exchange(true, std::memory_order_acq_rel)) {
renderer.addScreenshotStacks(false);
}
}
this->animationLoop();
this->getCurrentGui()->update();
this->getCurrentGui()->draw(&renderer);
//notificationCacheNeedsClearing.store(true, std::memory_order_release);
} else {
// Prompt-only mode - temporarily remove screenshots
if (screenshotStacksAdded.load(std::memory_order_acquire) &&
!screenshotsAreDisabled.load(std::memory_order_acquire) &&
!screenshotsAreForceDisabled.load(std::memory_order_acquire)) {
if (screenshotStacksAdded.exchange(false, std::memory_order_acq_rel)) {
renderer.removeScreenshotStacks(false);
}
}
renderer.clearScreen();
}
// Notification handling — safe, consistent, and null-guarded
{
if (notification && notification->isActive()) {
notification->update();
notification->draw(&renderer, promptOnly);
// Only set flag if it's not already set
notificationCacheNeedsClearing.exchange(true, std::memory_order_acq_rel);
} else if (notificationCacheNeedsClearing.exchange(false, std::memory_order_acq_rel)) {
tsl::gfx::FontManager::clearNotificationCache();
#if IS_STATUS_MONITOR_DIRECTIVE
if (wasRendering) {
wasRendering = false;
isRendering = true;
leventClear(&renderingStopEvent);
}
#endif
}
}
renderer.endFrame();
}
// Calculate transition using ease-in-out curve instead of linear
float easeInOutCubic(float t) {
return t < 0.5f ? 4.0f * t * t * t : 1.0f - pow(-2.0f * t + 2.0f, 3.0f) / 2.0f;
}
void handleInput(u64 keysDown, u64 keysHeld, bool touchDetected, const HidTouchState &touchPos, HidAnalogStickState joyStickPosLeft, HidAnalogStickState joyStickPosRight) {
if (!ult::internalTouchReleased.load(std::memory_order_acquire) || ult::launchingOverlay.load(std::memory_order_acquire))
return;
// Static variables to maintain state between function calls
static HidTouchState initialTouchPos = { 0 };
static HidTouchState oldTouchPos = { 0 };
static bool oldTouchDetected = false;
static elm::TouchEvent touchEvent, oldTouchEvent;
static u64 buttonPressTime_ns = 0, lastKeyEventTime_ns = 0, keyEventInterval_ns = 67000000ULL;
static bool singlePressHandled = false;
static constexpr u64 CLICK_THRESHOLD_NS = 340000000ULL; // 340ms in nanoseconds
static bool hasScrolled = false;
static void* lastGuiPtr = nullptr; // Use void* instead
auto& currentGui = this->getCurrentGui();
// Return early if current GUI is not available or internal touch is not released
if (!currentGui) {
elm::Element::setInputMode(InputMode::Controller);
oldTouchPos = { 0 };
initialTouchPos = { 0 };
touchEvent = elm::TouchEvent::None;
ult::stillTouching.store(false, std::memory_order_release);
ult::interruptedTouch.store(false, std::memory_order_release);
return;
}
// Retrieve current focus and top/bottom elements of the GUI
auto currentFocus = currentGui->getFocusedElement();
const bool interpreterIsRunning = ult::runningInterpreter.load(std::memory_order_acquire);
#if !IS_STATUS_MONITOR_DIRECTIVE
if (interpreterIsRunning) {
if (keysDown & KEY_UP && !(keysHeld & ~KEY_UP & ALL_KEYS_MASK)) {
currentFocus->shakeHighlight(FocusDirection::Up);
return;
}
else if (keysDown & KEY_DOWN && !(keysHeld & ~KEY_DOWN & ALL_KEYS_MASK)) {
currentFocus->shakeHighlight(FocusDirection::Down);
return;
}
else if (keysDown & KEY_LEFT && !(keysHeld & ~KEY_LEFT & ALL_KEYS_MASK)) {
currentFocus->shakeHighlight(FocusDirection::Left);
return;
}
else if (keysDown & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ALL_KEYS_MASK)) {
currentFocus->shakeHighlight(FocusDirection::Right);
return;
}
}
#endif
#if IS_STATUS_MONITOR_DIRECTIVE
if (FullMode && !deactivateOriginalFooter) {
if (ult::simulatedSelect.exchange(false, std::memory_order_acq_rel))
keysDown |= KEY_A;
if (ult::simulatedBack.exchange(false, std::memory_order_acq_rel))
keysDown |= KEY_B;
if (!overrideBackButton) {
if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) {
if (!currentGui->handleInput(KEY_B,0,{},{},{})) {
this->goBack();
if (this->m_guiStack.size() >= 1) {
//triggerRumbleDoubleClick.store(true, std::memory_order_release);
//triggerExitSound.store(true, std::memory_order_release);
triggerExitFeedback();
}
//ult::simulatedBackComplete = true;
}
return;
}
}
} else {
ult::simulatedSelect.exchange(false, std::memory_order_acq_rel);
ult::simulatedBack.exchange(false, std::memory_order_acq_rel);
}
#else
if (ult::simulatedSelect.exchange(false, std::memory_order_acq_rel))
keysDown |= KEY_A;
if (ult::simulatedBack.exchange(false, std::memory_order_acq_rel))
keysDown |= KEY_B;
if (!overrideBackButton) {
if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) {
if (!currentGui->handleInput(KEY_B,0,{},{},{})) {
this->goBack();
if (this->m_guiStack.size() >= 1 && !interpreterIsRunning) {
//triggerRumbleDoubleClick.store(true, std::memory_order_release);
//triggerExitSound.store(true, std::memory_order_release);
triggerExitFeedback();
}
//ult::simulatedBackComplete = true;
}
return;
}
} else {
if (keysDown & KEY_B && !(keysHeld & ~KEY_B & ALL_KEYS_MASK)) {
if (this->m_guiStack.size() >= 1 && !interpreterIsRunning) {
//triggerRumbleDoubleClick.store(true, std::memory_order_release);
//triggerExitSound.store(true, std::memory_order_release);
triggerExitFeedback();
}
}
}
#endif
// Reset touch state when GUI changes
if (currentGui.get() != lastGuiPtr) { // or just currentGui != lastGuiPtr if it's not a smart pointer
hasScrolled = false;
oldTouchEvent = elm::TouchEvent::None;
oldTouchDetected = false;
oldTouchPos = { 0 };
initialTouchPos = { 0 };
lastGuiPtr = currentGui.get(); // or just currentGui
}
auto topElement = currentGui->getTopElement();
const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
if (!currentFocus && !ult::simulatedBack.load(std::memory_order_acquire) && !ult::stillTouching.load(std::memory_order_acquire) && !oldTouchDetected && !interpreterIsRunning) {
if (!topElement) return;
if (!currentGui->initialFocusSet() || keysDown & (KEY_UP | KEY_DOWN | KEY_LEFT | KEY_RIGHT)) {
currentGui->requestFocus(topElement, FocusDirection::None);
currentGui->markInitialFocusSet();
}
}
if (isNavigatingBackwards.load(std::memory_order_acquire) && !currentFocus && topElement && keysDown & (KEY_UP | KEY_DOWN | KEY_LEFT | KEY_RIGHT)) {
currentGui->requestFocus(topElement, FocusDirection::None);
currentGui->markInitialFocusSet();
isNavigatingBackwards.store(false, std::memory_order_release);
// Reset navigation timing to prevent fast scrolling
buttonPressTime_ns = currentTime_ns;
lastKeyEventTime_ns = buttonPressTime_ns;
singlePressHandled = false;
}
if (!currentFocus && !touchDetected && (!oldTouchDetected || oldTouchEvent == elm::TouchEvent::Scroll)) {
if (!isNavigatingBackwards.load(std::memory_order_acquire) &&
!ult::shortTouchAndRelease.load(std::memory_order_acquire) &&
!ult::longTouchAndRelease.load(std::memory_order_acquire) &&
!ult::simulatedSelect.load(std::memory_order_acquire) &&
!ult::simulatedBack.load(std::memory_order_acquire) &&
!ult::simulatedNextPage.load(std::memory_order_acquire)
&& topElement) {
if (oldTouchEvent == elm::TouchEvent::Scroll) {
hasScrolled = true;
}
if (!hasScrolled) {
currentGui->removeFocus();
currentGui->requestFocus(topElement, FocusDirection::None);
}
} else if (ult::longTouchAndRelease.exchange(false, std::memory_order_acq_rel)) {
hasScrolled = true;
} else if (ult::shortTouchAndRelease.exchange(false, std::memory_order_acq_rel)) {
hasScrolled = true;
}
}
bool handled = false;
elm::Element* parentElement = currentFocus;
while (!handled && parentElement) {
handled = parentElement->onClick(keysDown) || parentElement->handleInput(keysDown, keysHeld, touchPos, joyStickPosLeft, joyStickPosRight);
parentElement = parentElement->getParent();
}
if (currentGui != this->getCurrentGui()) return;
handled |= currentGui->handleInput(keysDown, keysHeld, touchPos, joyStickPosLeft, joyStickPosRight);
// Navigational boundary cases for handling wrapping
static bool lastDirectionPressed = true;
const bool directionPressed = ((keysHeld & KEY_UP) || (keysHeld & KEY_DOWN) || (keysHeld & KEY_LEFT) || (keysHeld & KEY_RIGHT));
if (!directionPressed && lastDirectionPressed)
tsl::elm::s_directionalKeyReleased.store(true, std::memory_order_release);
else if (directionPressed && lastDirectionPressed)
tsl::elm::s_directionalKeyReleased.store(false, std::memory_order_release);
lastDirectionPressed = directionPressed;
const float currentScrollVelocity = tsl::elm::s_currentScrollVelocity.load(std::memory_order_acquire);
if (hasScrolled) {
const bool singleArrowKeyPress = ((keysHeld & KEY_UP) != 0) + ((keysHeld & KEY_DOWN) != 0) + ((keysHeld & KEY_LEFT) != 0) + ((keysHeld & KEY_RIGHT) != 0) == 1 && !(keysHeld & ~((currentScrollVelocity != 0.0f ? KEY_A | KEY_UP : KEY_UP) | KEY_DOWN | KEY_LEFT | KEY_RIGHT) & ALL_KEYS_MASK);
if (singleArrowKeyPress) {
// const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
buttonPressTime_ns = currentTime_ns;
lastKeyEventTime_ns = currentTime_ns;
hasScrolled = false;
isNavigatingBackwards.store(false, std::memory_order_release);
}
} else {
if (!touchDetected && !oldTouchDetected && !handled && currentFocus && !ult::stillTouching.load(std::memory_order_acquire) && !interpreterIsRunning) {
static bool shouldShake = true;
const bool singleArrowKeyPress = ((keysHeld & KEY_UP) != 0) + ((keysHeld & KEY_DOWN) != 0) + ((keysHeld & KEY_LEFT) != 0) + ((keysHeld & KEY_RIGHT) != 0) == 1 && !(keysHeld & ~((currentScrollVelocity != 0.0f ? KEY_A | KEY_UP: KEY_UP) | KEY_DOWN | KEY_LEFT | KEY_RIGHT) & ALL_KEYS_MASK);
if (singleArrowKeyPress) {
//const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
if (keysDown) {
buttonPressTime_ns = currentTime_ns;
lastKeyEventTime_ns = currentTime_ns;
singlePressHandled = false;
// Immediate single press action
if (keysHeld & KEY_UP && !(keysHeld & ~KEY_UP & ALL_KEYS_MASK))
currentGui->requestFocus(topElement, FocusDirection::Up, shouldShake);
else if (keysHeld & KEY_DOWN && !(keysHeld & ~KEY_DOWN & ALL_KEYS_MASK)) {
currentGui->requestFocus(currentFocus->getParent(), FocusDirection::Down, shouldShake);
//isTopElement = false;
}
else if (keysHeld & KEY_LEFT && !(keysHeld & ~KEY_LEFT & ALL_KEYS_MASK))
currentGui->requestFocus(currentFocus->getParent(), FocusDirection::Left, shouldShake);
else if (keysHeld & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ALL_KEYS_MASK))
currentGui->requestFocus(currentFocus->getParent(), FocusDirection::Right, shouldShake);
}
if (keysHeld & ~KEY_DOWN & ~KEY_UP & ~KEY_LEFT & ~KEY_RIGHT & ALL_KEYS_MASK) // reset
buttonPressTime_ns = currentTime_ns;
const u64 durationSincePress_ns = currentTime_ns - buttonPressTime_ns;
const u64 durationSinceLastEvent_ns = currentTime_ns - lastKeyEventTime_ns;
if (!singlePressHandled && durationSincePress_ns >= CLICK_THRESHOLD_NS) {
singlePressHandled = true;
}
if (!tsl::elm::isTableScrolling.load(std::memory_order_acquire)) {
// Calculate transition factor (t) from 0 to 1 based on how far we are from the transition point
static constexpr u64 transitionPoint_ns = 2000000000ULL; // 2000ms in nanoseconds
static constexpr u64 initialInterval_ns = 67000000ULL; // 67ms in nanoseconds
static constexpr u64 shortInterval_ns = 10000000ULL; // 10ms in nanoseconds
const float t = (durationSincePress_ns >= transitionPoint_ns) ? 1.0f :
(float)durationSincePress_ns / (float)transitionPoint_ns;
// Smooth transition between intervals using linear interpolation
keyEventInterval_ns = ((1.0f - t) * initialInterval_ns + t * shortInterval_ns);
} else {
// Table scrolling - faster timing
static constexpr u64 transitionPoint_ns = 200000000ULL; // 300ms (faster transition)
static constexpr u64 initialInterval_ns = 33000000ULL; // 33ms (faster initial)
static constexpr u64 shortInterval_ns = 5000000ULL; // 5ms (faster sustained)
const float t = (durationSincePress_ns >= transitionPoint_ns) ? 1.0f :
(float)durationSincePress_ns / (float)transitionPoint_ns;
// Smooth transition between intervals using linear interpolation
keyEventInterval_ns = ((1.0f - t) * initialInterval_ns + t * shortInterval_ns);
}
if (singlePressHandled && durationSinceLastEvent_ns >= keyEventInterval_ns) {
lastKeyEventTime_ns = currentTime_ns;
if (keysHeld & KEY_UP && !(keysHeld & ~((currentScrollVelocity != 0.0f ? KEY_A | KEY_UP: KEY_UP)) & ALL_KEYS_MASK))
currentGui->requestFocus(topElement, FocusDirection::Up, false);
else if (keysHeld & KEY_DOWN && !(keysHeld & ~((currentScrollVelocity != 0.0f ? KEY_A | KEY_DOWN: KEY_DOWN)) & ALL_KEYS_MASK)) {
currentGui->requestFocus(currentFocus->getParent(), FocusDirection::Down, false);
//isTopElement = false;
}
else if (keysHeld & KEY_LEFT && !(keysHeld & ~KEY_LEFT & ALL_KEYS_MASK))
currentGui->requestFocus(currentFocus->getParent(), FocusDirection::Left, false);
else if (keysHeld & KEY_RIGHT && !(keysHeld & ~KEY_RIGHT & ALL_KEYS_MASK))
currentGui->requestFocus(currentFocus->getParent(), FocusDirection::Right, false);
}
#if !IS_STATUS_MONITOR_DIRECTIVE
} else {
buttonPressTime_ns = lastKeyEventTime_ns = currentTime_ns;
#endif
}
}
}
#if !IS_STATUS_MONITOR_DIRECTIVE
if (!touchDetected && !interpreterIsRunning && topElement) {
#else
if (!disableJumpTo && !touchDetected && !interpreterIsRunning && topElement) {
#endif
// Shared constants used by ZL/ZR buttons
static constexpr u64 INITIAL_HOLD_THRESHOLD_NS = 400000000ULL;
static constexpr u64 HOLD_THRESHOLD_NS = 300000000ULL; // 300ms to start continuous
static constexpr u64 RAPID_CLICK_WINDOW_NS = 500000000ULL; // 500ms window for rapid clicking
static constexpr u64 RAPID_MODE_TIMEOUT_NS = 1000000000ULL; // 1s timeout to exit rapid mode
// Acceleration timing constants
static constexpr u64 ACCELERATION_POINT_NS = 1500000000ULL; // 1.5s transition point
static constexpr u64 INITIAL_INTERVAL_NS = 67000000ULL; // 67ms initial interval
static constexpr u64 FAST_INTERVAL_NS = 10000000ULL; // 10ms fast interval
//const u64 currentTime_ns = armTicksToNs(armGetSystemTick());
// Detect PHYSICAL key states (whether key is actually pressed)
const bool lKeyPressed = (keysHeld & KEY_L);
const bool rKeyPressed = (keysHeld & KEY_R);
const bool zlKeyPressed = (keysHeld & KEY_ZL);
const bool zrKeyPressed = (keysHeld & KEY_ZR);
// Detect if other keys are pressed (for preventing timer resets)
const bool notlKeyPressed = (keysHeld & ~KEY_L & ALL_KEYS_MASK);
const bool notrKeyPressed = (keysHeld & ~KEY_R & ALL_KEYS_MASK);
const bool notzlKeyPressed = (keysHeld & ~KEY_ZL & ALL_KEYS_MASK);
const bool notzrKeyPressed = (keysHeld & ~KEY_ZR & ALL_KEYS_MASK);
// Handle L button (simple jump to top on release, but not if held too long)
{
static bool lKeyWasPressed = false;
static bool lWasIsolated = false; // Track if L was isolated when first pressed
static u64 lButtonPressStart_ns = 0;
if (lKeyPressed) {
if (!lKeyWasPressed) {
// L key physically pressed for the first time (start timer)
lButtonPressStart_ns = currentTime_ns;
lWasIsolated = !notlKeyPressed; // Remember if it started isolated
}
// Don't reset timer if other keys are pressed after L was already held
lKeyWasPressed = true;
} else {
if (lKeyWasPressed) {
// L key physically released - only jump to top if was isolated when first pressed and not held too long
if (lWasIsolated && !(keysHeld & ~KEY_L & ALL_KEYS_MASK)) { // Was isolated initially and no other keys held at release
const u64 holdDuration = currentTime_ns - lButtonPressStart_ns;
if (holdDuration < INITIAL_HOLD_THRESHOLD_NS) {
jumpToTop.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
}
}
}
lKeyWasPressed = false;
lWasIsolated = false;
}
}
// Handle R button (simple jump to bottom on release, but not if held too long)
{
static bool rKeyWasPressed = false;
static bool rWasIsolated = false; // Track if R was isolated when first pressed
static u64 rButtonPressStart_ns = 0;
if (rKeyPressed) {
if (!rKeyWasPressed) {
// R key physically pressed for the first time (start timer)
rButtonPressStart_ns = currentTime_ns;
rWasIsolated = !notrKeyPressed; // Remember if it started isolated
}
// Don't reset timer if other keys are pressed after R was already held
rKeyWasPressed = true;
} else {
if (rKeyWasPressed) {
// R key physically released - only jump to bottom if was isolated when first pressed and not held too long
if (rWasIsolated && !(keysHeld & ~KEY_R & ALL_KEYS_MASK)) { // Was isolated initially and no other keys held at release
const u64 holdDuration = currentTime_ns - rButtonPressStart_ns;
if (holdDuration < INITIAL_HOLD_THRESHOLD_NS) {
jumpToBottom.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
}
}
}
rKeyWasPressed = false;
rWasIsolated = false;
}
}
// Handle ZL button (skip up with hold)
{
static u64 zlLastClickTime_ns = 0;
static bool zlKeyWasPressed = false;
static bool zlWasIsolated = false; // Track if ZL was isolated when first pressed
static bool zlInRapidClickMode = false;
static u64 zlFirstClickPressStart_ns = 0; // Track timing for first clicks only
// Check if we should exit rapid click mode due to timeout
if (zlInRapidClickMode && (currentTime_ns - zlLastClickTime_ns) > RAPID_MODE_TIMEOUT_NS) {
zlInRapidClickMode = false;
}
if (zlKeyPressed) {
if (!zlKeyWasPressed) {
// ZL key physically pressed for the first time
const u64 timeSinceLastClick = currentTime_ns - zlLastClickTime_ns;
zlWasIsolated = !notzlKeyPressed; // Remember if it started isolated
// Track press start time for first clicks (when not in rapid mode)
if (!zlInRapidClickMode) {
zlFirstClickPressStart_ns = currentTime_ns;
}
// Enter rapid click mode if clicking within window
if (timeSinceLastClick <= RAPID_CLICK_WINDOW_NS) {
zlInRapidClickMode = true;
}
// Only trigger immediately if in rapid click mode AND was isolated initially
if (zlInRapidClickMode && zlWasIsolated) {
skipUp.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
zlLastClickTime_ns = currentTime_ns;
}
}
// Check for hold behavior - ONLY if in rapid click mode AND was isolated initially
if (zlInRapidClickMode && zlWasIsolated) {
static u64 zlButtonPressStart_ns = 0;
static u64 zlLastHoldTrigger_ns = 0;
static bool zlHoldTriggered = false;
// Initialize on new press
if (!zlKeyWasPressed) {
zlButtonPressStart_ns = currentTime_ns;
zlLastHoldTrigger_ns = currentTime_ns;
zlHoldTriggered = false;
}
const u64 holdDuration = currentTime_ns - zlButtonPressStart_ns;
if (holdDuration >= HOLD_THRESHOLD_NS) {
// Calculate dynamic interval based on hold duration (accelerating)
const float t = (holdDuration >= ACCELERATION_POINT_NS) ? 1.0f :
(float)holdDuration / (float)ACCELERATION_POINT_NS;
const u64 currentInterval = ((1.0f - t) * INITIAL_INTERVAL_NS + t * FAST_INTERVAL_NS);
const u64 timeSinceLastHoldTrigger = currentTime_ns - zlLastHoldTrigger_ns;
if (!zlHoldTriggered || timeSinceLastHoldTrigger >= currentInterval) {
// Trigger skip
skipUp.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
zlHoldTriggered = true;
zlLastHoldTrigger_ns = currentTime_ns;
zlLastClickTime_ns = currentTime_ns; // Keep rapid mode active
}
}
}
zlKeyWasPressed = true;
} else {
if (zlKeyWasPressed) {
// ZL key physically released - only trigger if was isolated initially and no other keys held at release
if (!zlInRapidClickMode && zlWasIsolated && !(keysHeld & ~KEY_ZL & ALL_KEYS_MASK)) {
const u64 holdDuration = currentTime_ns - zlFirstClickPressStart_ns;
// Only trigger if not held too long
if (holdDuration < INITIAL_HOLD_THRESHOLD_NS) {
skipUp.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
zlLastClickTime_ns = currentTime_ns;
zlInRapidClickMode = true; // Enter rapid mode after first release
}
}
}
zlKeyWasPressed = false;
zlWasIsolated = false;
}
}
// Handle ZR button (skip down with hold)
{
static u64 zrLastClickTime_ns = 0;
static bool zrKeyWasPressed = false;
static bool zrWasIsolated = false; // Track if ZR was isolated when first pressed
static bool zrInRapidClickMode = false;
static u64 zrFirstClickPressStart_ns = 0; // Track timing for first clicks only
// Check if we should exit rapid click mode due to timeout
if (zrInRapidClickMode && (currentTime_ns - zrLastClickTime_ns) > RAPID_MODE_TIMEOUT_NS) {
zrInRapidClickMode = false;
}
if (zrKeyPressed) {
if (!zrKeyWasPressed) {
// ZR key physically pressed for the first time
const u64 timeSinceLastClick = currentTime_ns - zrLastClickTime_ns;
zrWasIsolated = !notzrKeyPressed; // Remember if it started isolated
// Track press start time for first clicks (when not in rapid mode)
if (!zrInRapidClickMode) {
zrFirstClickPressStart_ns = currentTime_ns;
}
// Enter rapid click mode if clicking within window
if (timeSinceLastClick <= RAPID_CLICK_WINDOW_NS) {
zrInRapidClickMode = true;
}
// Only trigger immediately if in rapid click mode AND was isolated initially
if (zrInRapidClickMode && zrWasIsolated) {
skipDown.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
zrLastClickTime_ns = currentTime_ns;
}
}
// Check for hold behavior - ONLY if in rapid click mode AND was isolated initially
if (zrInRapidClickMode && zrWasIsolated) {
static u64 zrButtonPressStart_ns = 0;
static u64 zrLastHoldTrigger_ns = 0;
static bool zrHoldTriggered = false;
// Initialize on new press
if (!zrKeyWasPressed) {
zrButtonPressStart_ns = currentTime_ns;
zrLastHoldTrigger_ns = currentTime_ns;
zrHoldTriggered = false;
}
const u64 holdDuration = currentTime_ns - zrButtonPressStart_ns;
if (holdDuration >= HOLD_THRESHOLD_NS) {
// Calculate dynamic interval based on hold duration (accelerating)
const float t = (holdDuration >= ACCELERATION_POINT_NS) ? 1.0f :
(float)holdDuration / (float)ACCELERATION_POINT_NS;
const u64 currentInterval = ((1.0f - t) * INITIAL_INTERVAL_NS + t * FAST_INTERVAL_NS);
const u64 timeSinceLastHoldTrigger = currentTime_ns - zrLastHoldTrigger_ns;
if (!zrHoldTriggered || timeSinceLastHoldTrigger >= currentInterval) {
// Trigger skip
skipDown.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
zrHoldTriggered = true;
zrLastHoldTrigger_ns = currentTime_ns;
zrLastClickTime_ns = currentTime_ns; // Keep rapid mode active
}
}
}
zrKeyWasPressed = true;
} else {
if (zrKeyWasPressed) {
// ZR key physically released - only trigger if was isolated initially and no other keys held at release
if (!zrInRapidClickMode && zrWasIsolated && !(keysHeld & ~KEY_ZR & ALL_KEYS_MASK)) {
const u64 holdDuration = currentTime_ns - zrFirstClickPressStart_ns;
// Only trigger if not held too long
if (holdDuration < INITIAL_HOLD_THRESHOLD_NS) {
skipDown.store(true, std::memory_order_release);
currentGui->requestFocus(topElement, FocusDirection::None);
zrLastClickTime_ns = currentTime_ns;
zrInRapidClickMode = true; // Enter rapid mode after first release
}
}
}
zrKeyWasPressed = false;
zrWasIsolated = false;
}
}
}
//if (keysDown & KEY_ZL) {
// //while (tsl::notification && tsl::notification->isActive()) {
// // tsl::notification->update(true, true); // No file ops, allow state transitions
// // svcSleepThread(10'000'000); // 1ms sleep
// //}
// if (notification)
// notification->forceShutdown();
//}
if (!touchDetected && oldTouchDetected && currentGui && topElement) {
topElement->onTouch(elm::TouchEvent::Release, oldTouchPos.x, oldTouchPos.y, oldTouchPos.x, oldTouchPos.y, initialTouchPos.x, initialTouchPos.y);
}
// Cache common calculations
// Use consistent edge padding equal to halfGap (matching drawing code)
const float edgePadding = ult::halfGap.load(std::memory_order_acquire) - 5;
const float buttonStartX = edgePadding;
// Calculate button positions matching the drawing code
const float backLeftEdge = buttonStartX + ult::layerEdge;
const float backRightEdge = backLeftEdge + ult::backWidth.load(std::memory_order_acquire);
const float selectLeftEdge = backRightEdge;
const float selectRightEdge = selectLeftEdge + ult::selectWidth.load(std::memory_order_acquire);
const float nextPageLeftEdge = ult::noClickableItems.load(std::memory_order_acquire) ? backRightEdge : selectRightEdge;
const float nextPageRightEdge = nextPageLeftEdge + ult::nextPageWidth.load(std::memory_order_acquire);
const float menuRightEdge = 245.0f + ult::layerEdge - 13;
const u32 footerY = cfg::FramebufferHeight - 73U + 1;
static std::vector<bool> lastSimulatedTouch = {false, false, false, false};
// Touch region calculations
const bool backTouched = (touchPos.x >= backLeftEdge && touchPos.x < backRightEdge && touchPos.y > footerY) &&
(initialTouchPos.x >= backLeftEdge && initialTouchPos.x < backRightEdge && initialTouchPos.y > footerY);
const bool selectTouched = !ult::noClickableItems.load(std::memory_order_acquire) &&
(touchPos.x >= selectLeftEdge && touchPos.x < selectRightEdge && touchPos.y > footerY) &&
(initialTouchPos.x >= selectLeftEdge && initialTouchPos.x < selectRightEdge && initialTouchPos.y > footerY);
const bool nextPageTouched = (touchPos.x >= nextPageLeftEdge && touchPos.x < nextPageRightEdge && touchPos.y > footerY) &&
(initialTouchPos.x >= nextPageLeftEdge && initialTouchPos.x < nextPageRightEdge && initialTouchPos.y > footerY);
const bool menuTouched = (touchPos.x > ult::layerEdge+7U && touchPos.x <= menuRightEdge && touchPos.y > 10U && touchPos.y <= 83U) &&
(initialTouchPos.x > ult::layerEdge+7U && initialTouchPos.x <= menuRightEdge && initialTouchPos.y > 10U && initialTouchPos.y <= 83U);
ult::touchingBack.store(backTouched, std::memory_order_release);
ult::touchingSelect.store(selectTouched, std::memory_order_release);
ult::touchingNextPage.store(nextPageTouched, std::memory_order_release);
ult::touchingMenu.store(menuTouched, std::memory_order_release);
if (touchDetected) {
// Update lastSimulatedTouch with current touch states
lastSimulatedTouch = {
backTouched,
selectTouched,
nextPageTouched,
menuTouched
};
ult::interruptedTouch.store(((keysHeld & ALL_KEYS_MASK) != 0), std::memory_order_release);
const u32 xDistance = std::abs(static_cast<s32>(initialTouchPos.x) - static_cast<s32>(touchPos.x));
const u32 yDistance = std::abs(static_cast<s32>(initialTouchPos.y) - static_cast<s32>(touchPos.y));
const bool isScroll = (xDistance * xDistance + yDistance * yDistance) > 1000;
if (isScroll) {
elm::Element::setInputMode(InputMode::TouchScroll);
touchEvent = elm::TouchEvent::Scroll;
} else {
if (touchEvent != elm::TouchEvent::Scroll) {
touchEvent = elm::TouchEvent::Hold;
}
}
if (!oldTouchDetected) {
initialTouchPos = touchPos;
elm::Element::setInputMode(InputMode::Touch);
if (!interpreterIsRunning) {
ult::touchInBounds = (initialTouchPos.y <= footerY && initialTouchPos.y > 73U &&
initialTouchPos.x <= ult::layerEdge + cfg::FramebufferWidth - 30U &&
initialTouchPos.x > 40U + ult::layerEdge);
if (ult::touchInBounds) currentGui->removeFocus();
}
touchEvent = elm::TouchEvent::Touch;
}
if (currentGui && topElement && !interpreterIsRunning) {
topElement->onTouch(touchEvent, touchPos.x, touchPos.y, oldTouchPos.x, oldTouchPos.y, initialTouchPos.x, initialTouchPos.y);
if (touchPos.x > 40U + ult::layerEdge && touchPos.x <= cfg::FramebufferWidth - 30U + ult::layerEdge &&
touchPos.y > 73U && touchPos.y <= footerY) {
currentGui->removeFocus();
}
}
oldTouchPos = touchPos;
if ((touchPos.x < ult::layerEdge || touchPos.x > cfg::FramebufferWidth + ult::layerEdge) && tsl::elm::Element::getInputMode() == tsl::InputMode::Touch) {
oldTouchPos = { 0 };
initialTouchPos = { 0 };
#if IS_STATUS_MONITOR_DIRECTIVE
if (FullMode && !deactivateOriginalFooter) {
this->hide();
}
#else
this->hide();
#endif
}
ult::stillTouching.store(true, std::memory_order_release);
} else {
// Process touch release using stored touch states - no need to recalculate boundaries
for (int i = 0; i < 4; ++i) {
if (lastSimulatedTouch[i]) {
if (!ult::interruptedTouch.load(std::memory_order_acquire) && !interpreterIsRunning) {
switch (i) {
case 0: // Back button
ult::simulatedBack.store(true, std::memory_order_release);
break;
case 1: // Select button
ult::simulatedSelect.store(true, std::memory_order_release);
break;
case 2: // Next page button
ult::simulatedNextPage.store(true, std::memory_order_release);
break;
case 3: // Menu button
ult::simulatedMenu.store(true, std::memory_order_release);
break;
}
} else if (interpreterIsRunning) {
switch (i) {
case 0: // Back button when interpreter is running
this->hide();
break;
case 1: // Select button when interpreter is running
ult::externalAbortCommands.store(true, std::memory_order_release);
break;
// cases 2 and 3 don't have interpreter running logic in original code
}
}
}
}
// Update lastSimulatedTouch with current touch states
lastSimulatedTouch = {
false,
false,
false,
false
};
elm::Element::setInputMode(InputMode::Controller);
oldTouchPos = { 0 };
initialTouchPos = { 0 };
touchEvent = elm::TouchEvent::None;
ult::stillTouching.store(false, std::memory_order_release);
ult::interruptedTouch.store(false, std::memory_order_release);
}
oldTouchDetected = touchDetected;
oldTouchEvent = touchEvent;
}
/**
* @brief Clears the screen
*
*/
void clearScreen() {
auto& renderer = gfx::Renderer::get();
renderer.startFrame();
renderer.clearScreen();
renderer.endFrame();
}
/**
* @brief Reset hide and close flags that were previously set by \ref Overlay::close() or \ref Overlay::hide()
*
*/
void resetFlags() {
this->m_shouldHide = false;
this->m_shouldClose = false;
this->m_shouldCloseAfter = false;
}
/**
* @brief Disables the next animation that would play
*
*/
void disableNextAnimation() {
this->m_disableNextAnimation = true;
}
/**
* @brief Changes to a different Gui
*
* @param gui Gui to change to
* @return Reference to the Gui
*/
std::unique_ptr<tsl::Gui>& changeTo(std::unique_ptr<tsl::Gui>&& gui, bool clearGlyphCache = false) {
if (this->m_guiStack.top() != nullptr && this->m_guiStack.top()->m_focusedElement != nullptr)
this->m_guiStack.top()->m_focusedElement->resetClickAnimation();
isNavigatingBackwards.store(false, std::memory_order_release);
// cache frame for forward rendering using external list method (to be implemented)
// Create the top element of the new Gui
gui->m_topElement = gui->createUI();
// Push the new Gui onto the stack
this->m_guiStack.push(std::move(gui));
//if (clearGlyphCache)
// tsl::gfx::FontManager::clearCache();
return this->m_guiStack.top();
}
/**
* @brief Creates a new Gui and changes to it
*
* @tparam G Gui to create
* @tparam Args Arguments to pass to the Gui
* @param args Arguments to pass to the Gui
* @return Reference to the newly created Gui
*/
// Template version without clearGlyphCache (for backward compatibility)
template<typename G, typename ...Args>
std::unique_ptr<tsl::Gui>& changeTo(Args&&... args) {
return this->changeTo(std::make_unique<G>(std::forward<Args>(args)...), false);
}
/**
* @brief Swaps to a different Gui
*
* @param gui Gui to change to
* @return Reference to the Gui
*/
std::unique_ptr<tsl::Gui>& swapTo(std::unique_ptr<tsl::Gui>&& gui, u32 count = 1) {
//isNavigatingBackwards = true;
isNavigatingBackwards.store(true, std::memory_order_release);
// Clamp count to available stack size to prevent underflow
const u32 actualCount = std::min(count, static_cast<u32>(this->m_guiStack.size()));
if (actualCount > 1) {
tsl::elm::skipDeconstruction.store(true, std::memory_order_release);
// Pop the specified number of GUIs
for (u32 i = 0; i < actualCount; ++i) {
this->m_guiStack.pop();
}
tsl::elm::skipDeconstruction.store(false, std::memory_order_release);
} else {
this->m_guiStack.pop();
}
if (this->m_guiStack.top() != nullptr && this->m_guiStack.top()->m_focusedElement != nullptr)
this->m_guiStack.top()->m_focusedElement->resetClickAnimation();
isNavigatingBackwards.store(false, std::memory_order_release);
// cache frame for forward rendering using external list method (to be implemented)
// Create the top element of the new Gui
gui->m_topElement = gui->createUI();
// Push the new Gui onto the stack
this->m_guiStack.push(std::move(gui));
//if (clearGlyphCache)
// tsl::gfx::FontManager::clearCache();
return this->m_guiStack.top();
}
/**
* @brief Creates a new Gui and changes to it
*
* @tparam G Gui to create
* @tparam Args Arguments to pass to the Gui
* @param args Arguments to pass to the Gui
* @return Reference to the newly created Gui
*/
// Template version without clearGlyphCache (for backward compatibility)
template<typename G, typename ...Args>
std::unique_ptr<tsl::Gui>& swapTo(SwapDepth depth, Args&&... args) {
return this->swapTo(std::make_unique<G>(std::forward<Args>(args)...), depth.value);
}
template<typename G, typename ...Args>
std::unique_ptr<tsl::Gui>& swapTo(Args&&... args) {
return this->swapTo(std::make_unique<G>(std::forward<Args>(args)...), 1);
}
/**
* @brief Pops the top Gui(s) from the stack and goes back count number of times
* @param count Number of Guis to pop from the stack (default: 1)
* @note The Overlay gets closed once there are no more Guis on the stack
*/
void goBack(u32 count = 1) {
tsl::elm::g_disableMenuCacheOnReturn.store(true, std::memory_order_release);
// If there is exactly one GUI and an active notification, handle that first
if (this->m_guiStack.size() == 1 && notification && notification->isActive()) {
this->close();
return;
}
isNavigatingBackwards.store(true, std::memory_order_release);
// Clamp count to available stack size to prevent underflow
const u32 actualCount = std::min(count, static_cast<u32>(this->m_guiStack.size()));
// Special case: if we don't close on exit and popping everything would leave us with 0 or 1 GUI
if (!this->m_closeOnExit && this->m_guiStack.size() <= actualCount) {
this->hide();
return;
}
if (actualCount > 1)
tsl::elm::skipDeconstruction.store(true, std::memory_order_release);
// Pop the specified number of GUIs
for (u32 i = 0; i < actualCount && !this->m_guiStack.empty(); ++i) {
this->m_guiStack.pop();
}
tsl::elm::skipDeconstruction.exchange(false, std::memory_order_acq_rel);
// Close overlay if stack is empty
if (this->m_guiStack.empty()) {
this->close();
} else {
//triggerRumbleDoubleClick.store(true, std::memory_order_release);
//triggerExitSound.store(true, std::memory_order_release);
}
}
void pop(u32 count = 1) {
isNavigatingBackwards.store(true, std::memory_order_release);
// Clamp count to available stack size to prevent underflow
const u32 actualCount = std::min(count, static_cast<u32>(this->m_guiStack.size()));
if (actualCount > 1) {
tsl::elm::skipDeconstruction.store(true, std::memory_order_release);
// Pop the specified number of GUIs
for (u32 i = 0; i < actualCount; ++i) {
this->m_guiStack.pop();
}
tsl::elm::skipDeconstruction.store(false, std::memory_order_release);
} else {
this->m_guiStack.pop();
}
}
template<typename G, typename ...Args>
friend std::unique_ptr<tsl::Gui>& changeTo(Args&&... args);
template<typename G, typename ...Args>
friend std::unique_ptr<tsl::Gui>& swapTo(Args&&... args);
template<typename G, typename ...Args>
friend std::unique_ptr<tsl::Gui>& swapTo(SwapDepth depth, Args&&... args);
friend void goBack(u32 count);
friend void pop(u32 count);
template<typename, tsl::impl::LaunchFlags>
friend int loop(int argc, char** argv);
friend class tsl::Gui;
};
namespace impl {
static constexpr const char* TESLA_CONFIG_FILE = "/config/tesla/config.ini";
static constexpr const char* ULTRAHAND_CONFIG_FILE = "/config/ultrahand/config.ini";
/**
* @brief Data shared between the different ult::renderThreads
*
*/
struct SharedThreadData {
std::atomic<bool> running = false;
Event comboEvent = { 0 };
std::atomic<bool> overlayOpen = false;
std::mutex dataMutex;
u64 keysDown = 0;
u64 keysDownPending = 0;
u64 keysHeld = 0;
HidTouchScreenState touchState = { 0 };
HidAnalogStickState joyStickPosLeft = { 0 }, joyStickPosRight = { 0 };
};
/**
* @brief Extract values from Tesla settings file
*
*/
static void parseOverlaySettings() {
hlp::ini::IniData parsedConfig = hlp::ini::readOverlaySettings(ULTRAHAND_CONFIG_FILE);
u64 decodedKeys = hlp::comboStringToKeys(parsedConfig[ult::ULTRAHAND_PROJECT_NAME][ult::KEY_COMBO_STR]); // CUSTOM MODIFICATION
if (decodedKeys)
tsl::cfg::launchCombo = decodedKeys;
else {
parsedConfig = hlp::ini::readOverlaySettings(TESLA_CONFIG_FILE);
decodedKeys = hlp::comboStringToKeys(parsedConfig["tesla"][ult::KEY_COMBO_STR]);
if (decodedKeys)
tsl::cfg::launchCombo = decodedKeys;
}
//#if USING_WIDGET_DIRECTIVE
ult::datetimeFormat = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["datetime_format"]; // read datetime_format
ult::removeQuotes(ult::datetimeFormat);
if (ult::datetimeFormat.empty()) {
ult::datetimeFormat = ult::DEFAULT_DT_FORMAT;
ult::removeQuotes(ult::datetimeFormat);
}
std::string tempStr;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["hide_clock"];
ult::removeQuotes(tempStr);
ult::hideClock = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["hide_battery"];
ult::removeQuotes(tempStr);
ult::hideBattery = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["hide_pcb_temp"];
ult::removeQuotes(tempStr);
ult::hidePCBTemp = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["hide_soc_temp"];
ult::removeQuotes(tempStr);
ult::hideSOCTemp = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["dynamic_widget_colors"];
ult::removeQuotes(tempStr);
ult::dynamicWidgetColors = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["hide_widget_backdrop"];
ult::removeQuotes(tempStr);
ult::hideWidgetBackdrop = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["center_widget_alignment"];
ult::removeQuotes(tempStr);
ult::centerWidgetAlignment = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["extended_widget_backdrop"];
ult::removeQuotes(tempStr);
ult::extendedWidgetBackdrop = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["dynamic_logo"];
ult::removeQuotes(tempStr);
ult::useDynamicLogo = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["selection_bg"];
ult::removeQuotes(tempStr);
ult::useSelectionBG = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["selection_text"];
ult::removeQuotes(tempStr);
ult::useSelectionText = tempStr != ult::FALSE_STR;
tempStr = parsedConfig[ult::ULTRAHAND_PROJECT_NAME]["selection_value"];
ult::removeQuotes(tempStr);
ult::useSelectionValue = tempStr != ult::FALSE_STR;
//#endif
}
/**
* @brief Update and save launch combo keys
*
* @param keys the new combo keys
*/
[[maybe_unused]] static void updateCombo(u64 keys) {
tsl::cfg::launchCombo = keys;
hlp::ini::updateOverlaySettings({
{ ult::TESLA_STR, { // CUSTOM MODIFICATION
{ ult::KEY_COMBO_STR , tsl::hlp::keysToComboString(keys) }
}}
}, TESLA_CONFIG_FILE);
hlp::ini::updateOverlaySettings({
{ ult::ULTRAHAND_PROJECT_NAME, { // CUSTOM MODIFICATION
{ ult::KEY_COMBO_STR , tsl::hlp::keysToComboString(keys) }
}}
}, ULTRAHAND_CONFIG_FILE);
}
/**
* @brief Background event polling loop thread
*
* @param args Used to pass in a pointer to a \ref SharedThreadData struct
*/
static void backgroundEventPoller(void *args) {
tsl::hlp::loadEntryKeyCombos();
ult::launchingOverlay.store(false, std::memory_order_release);
SharedThreadData *shData = static_cast<SharedThreadData*>(args);
// To prevent focus glitchout, close the overlay immediately when the home button gets pressed
Event homeButtonPressEvent = {};
hidsysAcquireHomeButtonEventHandle(&homeButtonPressEvent, false);
eventClear(&homeButtonPressEvent);
tsl::hlp::ScopeGuard homeButtonEventGuard([&] { eventClose(&homeButtonPressEvent); });
// To prevent focus glitchout, close the overlay immediately when the power button gets pressed
Event powerButtonPressEvent = {};
hidsysAcquireSleepButtonEventHandle(&powerButtonPressEvent, false);
eventClear(&powerButtonPressEvent);
tsl::hlp::ScopeGuard powerButtonEventGuard([&] { eventClose(&powerButtonPressEvent); });
// For handling screenshots color alpha
Event captureButtonPressEvent = {};
hidsysAcquireCaptureButtonEventHandle(&captureButtonPressEvent, false);
eventClear(&captureButtonPressEvent);
hidsysAcquireCaptureButtonEventHandle(&captureButtonPressEvent, false);
eventClear(&captureButtonPressEvent);
tsl::hlp::ScopeGuard captureButtonEventGuard([&] { eventClose(&captureButtonPressEvent); });
// Parse Tesla settings
impl::parseOverlaySettings();
// Allow only Player 1 and handheld mode
HidNpadIdType id_list[2] = { HidNpadIdType_No1, HidNpadIdType_Handheld };
// Configure HID system to only listen to these IDs
hidSetSupportedNpadIdType(id_list, 2);
// Configure input for up to 2 supported controllers (P1 + Handheld)
padConfigureInput(2, HidNpadStyleSet_NpadStandard | HidNpadStyleTag_NpadSystemExt);
// Initialize separate pad states for both controllers
PadState pad_p1;
PadState pad_handheld;
padInitialize(&pad_p1, HidNpadIdType_No1);
padInitialize(&pad_handheld, HidNpadIdType_Handheld);
// Touch screen init
hidInitializeTouchScreen();
// Clear any stale input from both controllers
padUpdate(&pad_p1);
padUpdate(&pad_handheld);
//ult::initRumble(); // initialize rumble
enum WaiterObject {
WaiterObject_HomeButton,
WaiterObject_PowerButton,
WaiterObject_CaptureButton,
WaiterObject_Count
};
// Construct waiter
Waiter objects[3] = {
[WaiterObject_HomeButton] = waiterForEvent(&homeButtonPressEvent),
[WaiterObject_PowerButton] = waiterForEvent(&powerButtonPressEvent),
[WaiterObject_CaptureButton] = waiterForEvent(&captureButtonPressEvent),
};
u64 currentTouchTick = 0;
auto lastTouchX = 0;
auto lastTouchY = 0;
// Preset touch boundaries
constexpr int SWIPE_RIGHT_BOUND = 16; // 16 + 80
constexpr int SWIPE_LEFT_BOUND = (1280 - 16);
constexpr u64 TOUCH_THRESHOLD_NS = 150'000'000ULL; // 150ms in nanoseconds
constexpr u64 FAST_SWAP_THRESHOLD_NS = 150'000'000ULL;
// Global underscan monitoring - run at most once every 300ms
auto lastUnderscanPixels = std::make_pair(0, 0);
bool firstUnderscanCheck = true;
u64 lastUnderscanCheckNs = 0; // store last execution in nanoseconds
constexpr u64 UNDERSCAN_INTERVAL_NS = 300'000'000ULL; // 300ms in ns
s32 idx;
Result rc;
std::string currentTitleID;
u64 lastPollTick = 0;
u64 resetStartTick = armGetSystemTick();
const u64 startNs = armTicksToNs(resetStartTick);
ult::lastTitleID = ult::getTitleIdAsString();
//u64 elapsedTime_ns;
// Notification variables
u64 lastNotifCheck = 0;
std::vector<std::string> shownFiles;
std::string text;
int fontSize;
int priority;
time_t creationTime;
while (shData->running.load(std::memory_order_acquire)) {
const u64 nowTick = armGetSystemTick();
const u64 nowNs = armTicksToNs(nowTick);
// Scan for input changes from both controllers
padUpdate(&pad_p1);
padUpdate(&pad_handheld);
// Read in HID values
{
// Poll Title ID every 1 seconds
if (!ult::resetForegroundCheck.load(std::memory_order_acquire)) {
const u64 elapsedNs = armTicksToNs(nowTick - lastPollTick);
if (elapsedNs >= 1'000'000'000ULL) {
lastPollTick = nowTick;
currentTitleID = ult::getTitleIdAsString();
if (currentTitleID != ult::lastTitleID) {
ult::lastTitleID = currentTitleID;
ult::resetForegroundCheck.store(true, std::memory_order_release);
resetStartTick = nowTick;
}
}
}
// If a reset is scheduled, trigger after 3.5s delay
if (ult::resetForegroundCheck.load(std::memory_order_acquire)) {
const u64 resetElapsedNs = armTicksToNs(nowTick - resetStartTick);
if (resetElapsedNs >= 3'500'000'000ULL) {
if (shData->overlayOpen && ult::currentForeground.load(std::memory_order_acquire)) {
#if IS_STATUS_MONITOR_DIRECTIVE
if (!isValidOverlayMode())
hlp::requestForeground(true, false);
#else
hlp::requestForeground(true, false);
#endif
}
ult::resetForegroundCheck.store(false, std::memory_order_release);
}
}
if (firstUnderscanCheck || (nowNs - lastUnderscanCheckNs) >= UNDERSCAN_INTERVAL_NS) {
const auto currentUnderscanPixels = tsl::gfx::getUnderscanPixels();
if (firstUnderscanCheck || currentUnderscanPixels != lastUnderscanPixels) {
// Update layer dimensions without destroying state
tsl::gfx::Renderer::get().updateLayerSize();
lastUnderscanPixels = currentUnderscanPixels;
firstUnderscanCheck = false;
}
lastUnderscanCheckNs = nowNs;
}
//bool expected = true;
//if (fireNotificationEvent.compare_exchange_strong(expected, false, std::memory_order_acq_rel)) {
// if (ult::launchingOverlay.load(std::memory_order_acquire))
// return;
// eventFire(&shData->notificationEvent); // wake the loop
//}
// Process notification files every 300ms
{
std::lock_guard<std::mutex> jsonLock(notificationJsonMutex);
if (armTicksToNs(nowTick - lastNotifCheck) >= 300'000'000ULL) {
lastNotifCheck = nowTick;
DIR* dir = opendir(ult::NOTIFICATIONS_PATH.c_str());
if (dir) {
if (ult::useNotifications) {
const std::string& notifPath = ult::NOTIFICATIONS_PATH;
// --- Prune missing files from shownFiles ---
for (auto it = shownFiles.begin(); it != shownFiles.end();) {
const std::string fullPath = notifPath + *it;
if (access(fullPath.c_str(), F_OK) != 0) {
it = shownFiles.erase(it);
} else {
++it;
}
}
// Reuse existing variables - track best file as we scan
static std::string bestFilename;
static std::string bestFullPath;
static time_t bestCreationTime;
static int bestPriority;
bestFilename.clear();
bestFullPath.clear();
bestPriority = -1;
bestCreationTime = 0;
bool foundAny = false;
struct dirent* entry;
// --- Find the best notification file in one pass ---
while ((entry = readdir(dir)) != nullptr) {
if (entry->d_type != DT_REG) continue;
const char* fname = entry->d_name;
const size_t filenameLen = strlen(fname);
// Must end with ".notify"
if (filenameLen <= 7 || strcmp(fname + filenameLen - 7, ".notify") != 0)
continue;
// Skip if already shown
if (std::find(shownFiles.begin(), shownFiles.end(), fname) != shownFiles.end())
continue;
// --- Build path ---
static std::string fullPath;
fullPath = notifPath;
fullPath += fname;
// --- Get file creation/modification time ---
struct stat fileStat;
creationTime = 0;
if (stat(fullPath.c_str(), &fileStat) == 0) {
creationTime = fileStat.st_mtime;
}
// --- Read priority from JSON ---
priority = 20; // default (reuse existing variable)
std::unique_ptr<ult::json_t, ult::JsonDeleter> root(
ult::readJsonFromFile(fullPath), ult::JsonDeleter());
if (root) {
cJSON* croot = reinterpret_cast<cJSON*>(root.get());
cJSON* priorityObj = cJSON_GetObjectItemCaseSensitive(croot, "priority");
if (priorityObj && cJSON_IsNumber(priorityObj)) {
priority = static_cast<int>(priorityObj->valuedouble);
}
}
// --- Is this better than current best? ---
const bool isBetter = !foundAny ||
(priority > bestPriority) ||
(priority == bestPriority && creationTime < bestCreationTime);
if (isBetter) {
bestFilename = fname;
bestFullPath = fullPath;
bestCreationTime = creationTime;
bestPriority = priority;
foundAny = true;
}
}
closedir(dir);
// --- Process the best file ---
if (foundAny) {
text = ult::getStringFromJsonFile(bestFullPath, "text");
if (!text.empty()) {
fontSize = 28; // default (reuse existing variable)
std::unique_ptr<ult::json_t, ult::JsonDeleter> root(
ult::readJsonFromFile(bestFullPath), ult::JsonDeleter());
if (root) {
cJSON* croot = reinterpret_cast<cJSON*>(root.get());
cJSON* fontSizeObj = cJSON_GetObjectItemCaseSensitive(croot, "font_size");
if (fontSizeObj && cJSON_IsNumber(fontSizeObj)) {
fontSize = std::clamp(static_cast<int>(fontSizeObj->valuedouble), 1, 34);
}
}
// --- Show notification safely ---
if (notification) {
notification->show(text, fontSize, bestPriority, bestFilename);
}
// Mark file as shown
shownFiles.push_back(bestFilename);
}
}
} else {
// --- Notifications disabled: delete all files ---
struct dirent* entry;
static std::string fullPath;
while ((entry = readdir(dir)) != nullptr) {
if (entry->d_type != DT_REG) continue;
const char* fname = entry->d_name;
const size_t len = strlen(fname);
if (len > 7 && strcmp(fname + len - 7, ".notify") == 0) {
fullPath.clear();
fullPath = ult::NOTIFICATIONS_PATH;
fullPath.append(fname, len);
remove(fullPath.c_str());
}
}
closedir(dir);
}
}
}
}
if (ult::launchingOverlay.load(std::memory_order_acquire))
break;
std::scoped_lock lock(shData->dataMutex);
if (ult::launchingOverlay.load(std::memory_order_acquire))
break;
// Flush any pending rumble triggers when feedback is off
if (!ult::useHapticFeedback) {
triggerRumbleClick.exchange(false, std::memory_order_acq_rel);
triggerRumbleDoubleClick.exchange(false, std::memory_order_acq_rel);
} else {
ult::checkAndReinitRumble();
if (triggerRumbleDoubleClick.exchange(false)) {
if (!ult::doubleClickActive.load(std::memory_order_acquire)) {
ult::rumbleDoubleClick();
}
triggerRumbleClick.exchange(false);
} else if (triggerRumbleClick.exchange(false)) {
ult::rumbleClick();
}
//const u64 _nowNs = armTicksToNs(armGetSystemTick());
ult::processRumbleStop(nowNs);
ult::processRumbleDoubleClick(nowNs);
}
// Flush any pending sound triggers when effects are off
if (ult::expandedMemory) {
if (!ult::useSoundEffects || disableSound.load(std::memory_order_acquire)) {
triggerNavigationSound.exchange(false, std::memory_order_acq_rel);
triggerEnterSound.exchange(false, std::memory_order_acq_rel);
triggerExitSound.exchange(false, std::memory_order_acq_rel);
triggerWallSound.exchange(false, std::memory_order_acq_rel);
triggerOnSound.exchange(false, std::memory_order_acq_rel);
triggerOffSound.exchange(false, std::memory_order_acq_rel);
triggerSettingsSound.exchange(false, std::memory_order_acq_rel);
triggerMoveSound.exchange(false, std::memory_order_acq_rel);
} else {
if (reloadSoundCacheNow.exchange(false, std::memory_order_acq_rel)) {
ult::AudioPlayer::reloadAllSounds();
}
if (triggerNavigationSound.exchange(false)) {
ult::AudioPlayer::playNavigateSound();
} else if (triggerEnterSound.exchange(false)) {
ult::AudioPlayer::playEnterSound();
} else if (triggerExitSound.exchange(false)) {
ult::AudioPlayer::playExitSound();
} else if (triggerWallSound.exchange(false)) {
ult::AudioPlayer::playWallSound();
} else if (triggerOnSound.exchange(false)) {
ult::AudioPlayer::playOnSound();
} else if (triggerOffSound.exchange(false)) {
ult::AudioPlayer::playOffSound();
} else if (triggerSettingsSound.exchange(false)) {
ult::AudioPlayer::playSettingsSound();
} else if (triggerMoveSound.exchange(false)) {
ult::AudioPlayer::playMoveSound();
}
//if (clearSoundCacheNow.exchange(false, std::memory_order_acq_rel)) {
// //ult::AudioPlayer::unloadAllSounds(ult::AudioPlayer::SoundType::Wall);
// ult::AudioPlayer::unloadAllSounds({ult::AudioPlayer::SoundType::Wall});
// //ult::AudioPlayer::unloadAllSounds();
// //clearSoundCacheNow.store(false, std::memory_order_release);
// clearSoundCacheNow.notify_all();
//}
}
}
//else if (triggerNavigationSound.exchange(false)) {
// ult::AudioPlayer::playSlideSound();
//}
// Combine inputs from both controllers
const u64 kDown_p1 = padGetButtonsDown(&pad_p1);
const u64 kHeld_p1 = padGetButtons(&pad_p1);
const u64 kDown_handheld = padGetButtonsDown(&pad_handheld);
const u64 kHeld_handheld = padGetButtons(&pad_handheld);
shData->keysDown = kDown_p1 | kDown_handheld;
shData->keysHeld = kHeld_p1 | kHeld_handheld;
// For joysticks, prioritize handheld if available, otherwise use P1
const HidAnalogStickState leftStick_handheld = padGetStickPos(&pad_handheld, 0);
const HidAnalogStickState rightStick_handheld = padGetStickPos(&pad_handheld, 1);
// Check if handheld has any stick input (not at center position)
const bool handheldHasInput = (leftStick_handheld.x != 0 || leftStick_handheld.y != 0 ||
rightStick_handheld.x != 0 || rightStick_handheld.y != 0);
if (handheldHasInput) {
shData->joyStickPosLeft = leftStick_handheld;
shData->joyStickPosRight = rightStick_handheld;
} else {
shData->joyStickPosLeft = padGetStickPos(&pad_p1, 0);
shData->joyStickPosRight = padGetStickPos(&pad_p1, 1);
}
// Read in touch positions
if (hidGetTouchScreenStates(&shData->touchState, 1) > 0) { // Check if any touch event is present
if (!shData->overlayOpen) {
//ult::internalTouchReleased = false;
ult::internalTouchReleased.store(false, std::memory_order_release);
}
const HidTouchState& currentTouch = shData->touchState.touches[0]; // Correct type is HidTouchPoint
const u64 elapsedTime_ns = armTicksToNs(nowTick - currentTouchTick);
// Check if the touch is within bounds for left-to-right swipe within the time window
if (ult::useSwipeToOpen && elapsedTime_ns <= TOUCH_THRESHOLD_NS) {
if ((lastTouchX != 0 && lastTouchY != 0) && (currentTouch.x != 0 || currentTouch.y != 0)) {
if (ult::layerEdge == 0 && currentTouch.x > SWIPE_RIGHT_BOUND + 84 && lastTouchX <= SWIPE_RIGHT_BOUND) {
eventFire(&shData->comboEvent);
mainComboHasTriggered.store(true, std::memory_order_release);
}
// Check if the touch is within bounds for right-to-left swipe within the time window
else if (ult::layerEdge > 0 && currentTouch.x < SWIPE_LEFT_BOUND - 84 && lastTouchX >= SWIPE_LEFT_BOUND) {
eventFire(&shData->comboEvent);
mainComboHasTriggered.store(true, std::memory_order_release);
}
}
}
// Handle touch release state
if (currentTouch.x == 0 && currentTouch.y == 0) {
ult::internalTouchReleased.store(true, std::memory_order_release);
//ult::internalTouchReleased = true; // Indicate that the touch has been released
//ult::internalTouchReleased.store(true, std::memory_order_release);
lastTouchX = 0;
lastTouchY = 0;
}
// If this is the first touch of a gesture, store lastTouchX
else if ((lastTouchX == 0 && lastTouchY == 0) && (currentTouch.x != 0 || currentTouch.y != 0)) {
currentTouchTick = nowTick;
lastTouchX = currentTouch.x;
lastTouchY = currentTouch.y;
}
} else {
// Reset touch state if no touch is present
shData->touchState = { 0 };
//ult::internalTouchReleased = true;
ult::internalTouchReleased.store(true, std::memory_order_release);
//ult::internalTouchReleased.store(true, std::memory_order_release);
// Reset touch history to invalid state
lastTouchX = 0;
lastTouchY = 0;
// Reset time tracking
//currentTouchTick = nowTick;
}
#if IS_STATUS_MONITOR_DIRECTIVE
if (triggerExitNow) {
ult::launchingOverlay.store(true, std::memory_order_release);
ult::setIniFileValue(
ult::ULTRAHAND_CONFIG_INI_PATH,
ult::ULTRAHAND_PROJECT_NAME,
ult::IN_OVERLAY_STR,
ult::FALSE_STR
);
tsl::setNextOverlay(
ult::OVERLAY_PATH + "ovlmenu.ovl"
);
tsl::Overlay::get()->close();
//tsl::goBack();
//triggerExitNow = false;
break;
}
#endif
//if ((shData->keysDown & KEY_ZL && shData->keysHeld & KEY_L) || (shData->keysDown & KEY_L && shData->keysHeld & KEY_ZL)) {
// notification->show("Hello world! ¯\\_(ツ)_/¯");
// eventFire(&shData->notificationEvent); // wake the loop
//}
// Check main launch combo first (highest priority)
if ((((shData->keysHeld & tsl::cfg::launchCombo) == tsl::cfg::launchCombo) && shData->keysDown & tsl::cfg::launchCombo)) {
#if IS_LAUNCHER_DIRECTIVE
if (ult::updateMenuCombos) {
ult::setIniFileValue(ult::ULTRAHAND_CONFIG_INI_PATH, ult::ULTRAHAND_PROJECT_NAME, ult::KEY_COMBO_STR , ult::ULTRAHAND_COMBO_STR);
ult::setIniFileValue(ult::TESLA_CONFIG_INI_PATH, ult::TESLA_STR, ult::KEY_COMBO_STR , ult::ULTRAHAND_COMBO_STR);
ult::updateMenuCombos = false;
}
#endif
#if IS_STATUS_MONITOR_DIRECTIVE
isRendering = false;
leventSignal(&renderingStopEvent);
#endif
if (shData->overlayOpen) {
tsl::Overlay::get()->hide();
shData->overlayOpen = false;
}
else {
eventFire(&shData->comboEvent);
mainComboHasTriggered.store(true, std::memory_order_release);
}
}
#if IS_LAUNCHER_DIRECTIVE
else if (ult::updateMenuCombos && (((shData->keysHeld & tsl::cfg::launchCombo2) == tsl::cfg::launchCombo2) && shData->keysDown & tsl::cfg::launchCombo2)) {
std::swap(tsl::cfg::launchCombo, tsl::cfg::launchCombo2); // Swap the two launch combos
ult::setIniFileValue(ult::ULTRAHAND_CONFIG_INI_PATH, ult::ULTRAHAND_PROJECT_NAME, ult::KEY_COMBO_STR , ult::TESLA_COMBO_STR);
ult::setIniFileValue(ult::TESLA_CONFIG_INI_PATH, ult::TESLA_STR, ult::KEY_COMBO_STR , ult::TESLA_COMBO_STR);
eventFire(&shData->comboEvent);
mainComboHasTriggered.store(true, std::memory_order_release);
ult::updateMenuCombos = false;
}
else if (ult::overlayLaunchRequested.load(std::memory_order_acquire) && !ult::runningInterpreter.load(std::memory_order_acquire) && ult::settingsInitialized.load(std::memory_order_acquire) && (nowNs - startNs) >= FAST_SWAP_THRESHOLD_NS) {
std::string requestedPath, requestedArgs;
// Get the request data safely
{
std::lock_guard<std::mutex> lock(ult::overlayLaunchMutex);
requestedPath = ult::requestedOverlayPath;
requestedArgs = ult::requestedOverlayArgs;
ult::overlayLaunchRequested.store(false, std::memory_order_release);
}
if (!requestedPath.empty()) {
const std::string overlayFileName = ult::getNameFromPath(requestedPath);
// Set overlay state for ovlmenu.ovl
// OPTIMIZED: Batch INI file writes
{
auto iniData = ult::getParsedDataFromIniFile(ult::ULTRAHAND_CONFIG_INI_PATH);
auto& section = iniData[ult::ULTRAHAND_PROJECT_NAME];
section[ult::IN_OVERLAY_STR] = ult::TRUE_STR;
section["to_packages"] = ult::TRUE_STR;
ult::saveIniFileData(ult::ULTRAHAND_CONFIG_INI_PATH, iniData);
}
// Reset navigation state variables (these control slide navigation)
ult::allowSlide.store(false, std::memory_order_release);
ult::unlockedSlide.store(false, std::memory_order_release);
eventClose(&homeButtonPressEvent);
eventClose(&powerButtonPressEvent);
eventClose(&captureButtonPressEvent);
//hidExit();
// Launch the overlay using the same mechanism as key combos
//shData->overlayOpen = false;
ult::launchingOverlay.store(true, std::memory_order_release);
tsl::setNextOverlay(requestedPath, requestedArgs+" --direct");
tsl::Overlay::get()->close();
eventFire(&shData->comboEvent);
launchComboHasTriggered.store(true, std::memory_order_release);
return;
}
}
#endif
// Check overlay key combos (only when overlay is not open, keys are pressed, and not conflicting with main combos)
//else if (!shData->overlayOpen && shData->keysDown != 0) {
else if (shData->keysDown != 0 && ult::useLaunchCombos) {
if (shData->keysHeld != tsl::cfg::launchCombo) {
// Lookup both path and optional mode launch args
const auto comboInfo = tsl::hlp::getEntryForKeyCombo(shData->keysHeld);
const std::string& overlayPath = comboInfo.path;
#if IS_LAUNCHER_DIRECTIVE
if (!overlayPath.empty() && (shData->keysHeld) && !ult::runningInterpreter.load(std::memory_order_acquire) && ult::settingsInitialized.load(std::memory_order_acquire) && (armTicksToNs(nowTick) - startNs) >= FAST_SWAP_THRESHOLD_NS) {
#else
if (!overlayPath.empty() && (shData->keysHeld) && (nowNs - startNs) >= FAST_SWAP_THRESHOLD_NS) {
#endif
const std::string& modeArg = comboInfo.launchArg;
const std::string overlayFileName = ult::getNameFromPath(overlayPath);
// hideHidden check
if (hideHidden) {
const auto hideStatus = ult::parseValueFromIniSection(
ult::OVERLAYS_INI_FILEPATH, overlayFileName, ult::HIDE_STR);
if (hideStatus == ult::TRUE_STR) {
shData->keysDownPending |= shData->keysDown;
continue;
}
}
#if IS_STATUS_MONITOR_DIRECTIVE
isRendering = false;
leventSignal(&renderingStopEvent);
#endif
#if !IS_LAUNCHER_DIRECTIVE
if (lastOverlayFilename == overlayFileName && lastOverlayMode == modeArg) {
#else
if (lastOverlayFilename == overlayFileName && lastOverlayMode == modeArg && lastOverlayMode.find("--package") != std::string::npos) {
#endif
ult::setIniFileValue(
ult::ULTRAHAND_CONFIG_INI_PATH,
ult::ULTRAHAND_PROJECT_NAME,
ult::IN_OVERLAY_STR,
ult::TRUE_STR
);
//shData->overlayOpen = false;
//hidExit();
eventClose(&homeButtonPressEvent);
eventClose(&powerButtonPressEvent);
eventClose(&captureButtonPressEvent);
ult::launchingOverlay.store(true, std::memory_order_release);
tsl::setNextOverlay(ult::OVERLAY_PATH + "ovlmenu.ovl", "--direct --comboReturn");
tsl::Overlay::get()->close();
eventFire(&shData->comboEvent);
launchComboHasTriggered.store(true, std::memory_order_release);
return;
}
// Compose launch args
std::string finalArgs;
if (!modeArg.empty()) {
finalArgs = modeArg;
} else {
// Only check overlay-specific launch args for non-ovlmenu entries
if (overlayFileName.compare("ovlmenu.ovl") != 0) {
// OPTIMIZED: Single INI read for both values
auto overlaysIniData = ult::getParsedDataFromIniFile(ult::OVERLAYS_INI_FILEPATH);
std::string useArgs = "";
std::string launchArgs = "";
auto sectionIt = overlaysIniData.find(overlayFileName);
if (sectionIt != overlaysIniData.end()) {
auto useArgsIt = sectionIt->second.find(ult::USE_LAUNCH_ARGS_STR);
if (useArgsIt != sectionIt->second.end()) {
useArgs = useArgsIt->second;
}
auto argsIt = sectionIt->second.find(ult::LAUNCH_ARGS_STR);
if (argsIt != sectionIt->second.end()) {
launchArgs = argsIt->second;
}
}
if (useArgs == ult::TRUE_STR) {
finalArgs = launchArgs;
ult::removeQuotes(finalArgs);
}
}
}
if (finalArgs.empty()) {
finalArgs = "--direct";
} else {
finalArgs += " --direct";
}
if (overlayFileName.compare("ovlmenu.ovl") == 0) {
finalArgs += " --comboReturn";
ult::setIniFileValue(
ult::ULTRAHAND_CONFIG_INI_PATH,
ult::ULTRAHAND_PROJECT_NAME,
ult::IN_OVERLAY_STR,
ult::TRUE_STR
);
}
//shData->overlayOpen = false;
//hidExit();
eventClose(&homeButtonPressEvent);
eventClose(&powerButtonPressEvent);
eventClose(&captureButtonPressEvent);
ult::launchingOverlay.store(true, std::memory_order_release);
tsl::setNextOverlay(overlayPath, finalArgs);
tsl::Overlay::get()->close();
eventFire(&shData->comboEvent);
launchComboHasTriggered.store(true, std::memory_order_release);
return;
}
}
}
//#endif
shData->keysDownPending |= shData->keysDown;
}
//20 ms
//s32 idx = 0;
rc = waitObjects(&idx, objects, WaiterObject_Count, 20'000'000ul);
if (R_SUCCEEDED(rc)) {
#if IS_STATUS_MONITOR_DIRECTIVE
if (idx == WaiterObject_HomeButton || idx == WaiterObject_PowerButton) { // Changed condition to exclude capture button
if (shData->overlayOpen && !isValidOverlayMode()) {
tsl::Overlay::get()->hide();
shData->overlayOpen = false;
}
}
#else
if (idx == WaiterObject_HomeButton || idx == WaiterObject_PowerButton) { // Changed condition to exclude capture button
if (shData->overlayOpen) {
tsl::Overlay::get()->hide();
shData->overlayOpen = false;
}
}
#endif
switch (idx) {
case WaiterObject_HomeButton:
eventClear(&homeButtonPressEvent);
break;
case WaiterObject_PowerButton:
eventClear(&powerButtonPressEvent);
// Perform any necessary cleanup
hidExit();
// Reinitialize resources
ASSERT_FATAL(hidInitialize()); // Reinitialize HID to reset states
// Reinitialize both controllers
padInitialize(&pad_p1, HidNpadIdType_No1);
padInitialize(&pad_handheld, HidNpadIdType_Handheld);
hidInitializeTouchScreen();
// Update both controllers
padUpdate(&pad_p1);
padUpdate(&pad_handheld);
break;
case WaiterObject_CaptureButton:
if (screenshotsAreDisabled) {
eventClear(&captureButtonPressEvent);
break;
}
#if IS_STATUS_MONITOR_DIRECTIVE
bool inOverlayMode = isValidOverlayMode();
if (inOverlayMode) {
delayUpdate = true;
isRendering = false;
leventSignal(&renderingStopEvent);
}
#endif
ult::disableTransparency = true;
eventClear(&captureButtonPressEvent);
svcSleepThread(1'500'000'000);
ult::disableTransparency = false;
#if IS_STATUS_MONITOR_DIRECTIVE
if (inOverlayMode) {
isRendering = true;
leventClear(&renderingStopEvent);
delayUpdate = false;
}
#endif
break;
}
} else if (rc != KERNELRESULT(TimedOut)) {
ASSERT_FATAL(rc);
}
}
//hidExit();
eventClose(&homeButtonPressEvent);
eventClose(&powerButtonPressEvent);
eventClose(&captureButtonPressEvent);
}
}
/**
* @brief Creates a new Gui and changes to it
*
* @tparam G Gui to create
* @tparam Args Arguments to pass to the Gui
* @param args Arguments to pass to the Gui
* @return Reference to the newly created Gui
*/
template<typename G, typename ...Args>
std::unique_ptr<tsl::Gui>& changeTo(Args&&... args) {
return Overlay::get()->changeTo<G, Args...>(std::forward<Args>(args)...);
}
template<typename G, typename ...Args>
std::unique_ptr<tsl::Gui>& swapTo(Args&&... args) {
return Overlay::get()->swapTo<G, Args...>(std::forward<Args>(args)...);
}
template<typename G, typename ...Args>
std::unique_ptr<tsl::Gui>& swapTo(SwapDepth depth, Args&&... args) {
return Overlay::get()->swapTo<G, Args...>(depth, std::forward<Args>(args)...);
}
/**
* @brief Pops the top Gui from the stack and goes back to the last one
* @note The Overlay gets closed once there are no more Guis on the stack
*/
void goBack(u32 count) {
Overlay::get()->goBack(count);
}
void pop(u32 count) {
Overlay::get()->pop(count);
}
static inline std::mutex setNextOverlayMutex;
static inline std::string nextOverlayName;
static void setNextOverlay(const std::string& ovlPath, std::string origArgs) {
std::lock_guard lk(setNextOverlayMutex);
char buffer[512];
char* p = buffer;
char* bufferEnd = buffer + sizeof(buffer) - 1; // Leave room for null terminator
// Store filename and copy it
const std::string filenameStr = ult::getNameFromPath(ovlPath);
nextOverlayName = filenameStr;
const char* filename = filenameStr.c_str();
while (*filename && p < bufferEnd) *p++ = *filename++;
if (p < bufferEnd) *p++ = ' ';
// Single-pass argument filtering
const char* src = origArgs.c_str();
const char* end = src + origArgs.length();
bool hasSkipCombo = false;
while (src < end && p < bufferEnd) {
// Skip whitespace
while (src < end && *src == ' ' && p < bufferEnd) {
*p++ = *src++;
}
if (src >= end || p >= bufferEnd) break;
// Check for flags to filter/detect
if (src[0] == '-' && src[1] == '-') {
// Check what flag this is
if (strncmp(src, "--skipCombo", 11) == 0 && (src[11] == ' ' || src[11] == '\0')) {
hasSkipCombo = true;
// Copy this flag
while (src < end && *src != ' ' && p < bufferEnd) *p++ = *src++;
}
else if (strncmp(src, "--foregroundFix", 15) == 0) {
// Skip this flag and its value
src += 15;
while (src < end && *src == ' ') src++; // Skip spaces
if (src < end && (*src == '0' || *src == '1')) src++; // Skip value
}
else if (strncmp(src, "--lastTitleID", 13) == 0) {
// Skip this flag and its value
src += 13;
while (src < end && *src == ' ') src++; // Skip spaces
while (src < end && *src != ' ' && *src != '\0') src++; // Skip title ID
}
else {
// Copy unknown flag
while (src < end && *src != ' ' && p < bufferEnd) *p++ = *src++;
}
}
else {
// Copy regular argument
while (src < end && *src != ' ' && p < bufferEnd) *p++ = *src++;
}
}
// Add required flags with bounds checking
if (!hasSkipCombo && (p + 12) < bufferEnd) {
memcpy(p, " --skipCombo", 12);
p += 12;
}
// Add foreground flag with bounds checking
if ((p + 17) < bufferEnd) {
memcpy(p, " --foregroundFix ", 17);
p += 17;
if (p < bufferEnd) {
*p++ = (ult::resetForegroundCheck.load(std::memory_order_acquire) || ult::lastTitleID != ult::getTitleIdAsString()) ? '1' : '0';
}
}
// Add last title ID with bounds checking
if ((p + 15 + ult::lastTitleID.length()) < bufferEnd) {
memcpy(p, " --lastTitleID ", 15);
p += 15;
const char* titleId = ult::lastTitleID.c_str();
while (*titleId && p < bufferEnd) *p++ = *titleId++;
}
// Safety check - if we're at the end, we might have truncated
if (p >= bufferEnd) {
p = bufferEnd;
}
*p = '\0';
//isLaunchingNextOverlay.store(true, std::memory_order_release);
envSetNextLoad(ovlPath.c_str(), buffer);
}
struct option_entry {
const char* name;
u8 len;
u8 action;
};
static const struct option_entry options[] = {
{"direct", 6, 1},
{"skipCombo", 9, 2},
{"lastTitleID", 11, 3},
{"foregroundFix", 13, 4},
{"package", 7, 5},
{"lastSelectedItem", 16, 6},
{"comboReturn", 11, 7} // new option
};
/**
* @brief libtesla's main function
* @note Call it directly from main passing in argc and argv and returning it e.g `return tsl::loop<OverlayTest>(argc, argv);`
*
* @tparam TOverlay Your overlay class
* @tparam launchFlags \ref LaunchFlags
* @param argc argc
* @param argv argv
* @return int result
*/
template<typename TOverlay, impl::LaunchFlags launchFlags>
static inline int loop(int argc, char** argv) {
static_assert(std::is_base_of_v<tsl::Overlay, TOverlay>, "tsl::loop expects a type derived from tsl::Overlay");
#if IS_STATUS_MONITOR_DIRECTIVE
leventClear(&renderingStopEvent);
#endif
// Initialize buffer sizes based on expanded memory setting
if (ult::expandedMemory) {
ult::COPY_BUFFER_SIZE = 262144;
ult::HEX_BUFFER_SIZE = 8192;
ult::UNZIP_READ_BUFFER = 262144;
ult::UNZIP_WRITE_BUFFER = 131072;
ult::DOWNLOAD_READ_BUFFER = 262144/2;
ult::DOWNLOAD_WRITE_BUFFER = 131072;
}
if (argc > 0) {
g_overlayFilename = ult::getNameFromPath(argv[0]);
lastOverlayFilename = g_overlayFilename;
lastOverlayMode.clear();
bool skip;
for (u8 arg = 1; arg < argc; arg++) {
const char* s = argv[arg];
skip = false;
if (arg > 1) {
const char* prev = argv[arg - 1];
if (prev[0] == '-' && prev[1] == '-') {
if (strcmp(prev, "--lastTitleID") == 0 || strcmp(prev, "--foregroundFix") == 0) {
skip = true;
}
}
}
if (!skip && s[0] == '-' && s[1] == '-') {
if (strcmp(s, "--direct") == 0 ||
strcmp(s, "--skipCombo") == 0 ||
strcmp(s, "--lastTitleID") == 0 ||
strcmp(s, "--foregroundFix") == 0) {
skip = true;
}
}
if (!skip) {
if (strcmp(s, "--package") == 0) {
lastOverlayMode = "--package";
arg++;
if (arg < argc) {
lastOverlayMode += " ";
lastOverlayMode += argv[arg];
arg++;
while (arg < argc && argv[arg][0] != '-') {
lastOverlayMode += " ";
lastOverlayMode += argv[arg];
arg++;
}
}
} else {
lastOverlayMode = s;
}
break;
}
}
}
bool skipCombo = false;
#if IS_LAUNCHER_DIRECTIVE
bool comboReturn = false;
bool directMode = true;
#else
bool directMode = false;
#endif
bool usingPackageLauncher = false;
for (u8 arg = 0; arg < argc; arg++) {
const char* s = argv[arg];
if (s[0] != '-' || s[1] != '-') continue;
const char* opt = s + 2;
for (u8 i = 0; i < 7; i++) { // now 6 instead of 5
if (memcmp(opt, options[i].name, options[i].len) == 0 && opt[options[i].len] == '\0') {
switch (options[i].action) {
case 1: // direct
directMode = true;
g_overlayFilename = "";
jumpItemName = "";
jumpItemValue = "";
jumpItemExactMatch.store(true, std::memory_order_release);
break;
case 2: // skipCombo
skipCombo = true;
ult::firstBoot = false;
break;
case 3: // lastTitleID
if (++arg < argc) {
const char* providedID = argv[arg];
if (ult::getTitleIdAsString() != providedID) {
ult::resetForegroundCheck.store(true, std::memory_order_release);
}
}
break;
case 4: // foregroundFix
if (++arg < argc) {
ult::resetForegroundCheck.store(
ult::resetForegroundCheck.load(std::memory_order_acquire) ||
(argv[arg][0] == '1'), std::memory_order_release);
}
break;
case 5: // package
usingPackageLauncher = true;
break;
case 6: // lastSelectedItem
#if IS_STATUS_MONITOR_DIRECTIVE
lastMode = "returning";
#endif
break;
case 7: // comboReturn
#if IS_LAUNCHER_DIRECTIVE
comboReturn = true;
#endif
break;
}
}
}
}
impl::SharedThreadData shData;
shData.running.store(true, std::memory_order_release);
Thread backgroundThread;
threadCreate(&backgroundThread, impl::backgroundEventPoller, &shData, nullptr, 0x2000, 0x2c, -2);
threadStart(&backgroundThread);
eventCreate(&shData.comboEvent, false);
auto& overlay = tsl::Overlay::s_overlayInstance;
overlay = new TOverlay();
overlay->m_closeOnExit = (u8(launchFlags) & u8(impl::LaunchFlags::CloseOnExit)) == u8(impl::LaunchFlags::CloseOnExit);
tsl::hlp::doWithSmSession([&overlay]{
overlay->initServices();
});
#if !IS_LAUNCHER_DIRECTIVE
tsl::initializeUltrahandSettings();
#endif
// Initialize the audio service
if (ult::useSoundEffects && ult::expandedMemory) {
ult::AudioPlayer::initialize();
}
overlay->initScreen();
overlay->changeTo(overlay->loadInitialGui());
bool shouldFireEvent = false;
#if IS_LAUNCHER_DIRECTIVE
{
bool inOverlay;
auto configData = ult::getParsedDataFromIniFile(ult::ULTRAHAND_CONFIG_INI_PATH);
bool needsUpdate = false;
if (ult::firstBoot) {
configData[ult::ULTRAHAND_PROJECT_NAME][ult::IN_OVERLAY_STR] = ult::FALSE_STR;
needsUpdate = true;
}
auto projectIt = configData.find(ult::ULTRAHAND_PROJECT_NAME);
if (projectIt != configData.end()) {
auto overlayIt = projectIt->second.find(ult::IN_OVERLAY_STR);
inOverlay = (overlayIt == projectIt->second.end() || overlayIt->second != ult::FALSE_STR);
} else {
inOverlay = true;
}
if (inOverlay && skipCombo) {
configData[ult::ULTRAHAND_PROJECT_NAME][ult::IN_OVERLAY_STR] = ult::FALSE_STR;
needsUpdate = true;
shouldFireEvent = true;
}
if (needsUpdate) {
ult::saveIniFileData(ult::ULTRAHAND_CONFIG_INI_PATH, configData);
}
if (shouldFireEvent) {
eventFire(&shData.comboEvent);
}
}
#else
{
auto configData = ult::getParsedDataFromIniFile(ult::ULTRAHAND_CONFIG_INI_PATH);
auto projectIt = configData.find(ult::ULTRAHAND_PROJECT_NAME);
if (projectIt != configData.end()) {
auto overlayIt = projectIt->second.find(ult::IN_OVERLAY_STR);
const bool inOverlay = (overlayIt == projectIt->second.end() || overlayIt->second != ult::FALSE_STR);
if (inOverlay && directMode) {
configData[ult::ULTRAHAND_PROJECT_NAME][ult::IN_OVERLAY_STR] = ult::FALSE_STR;
ult::saveIniFileData(ult::ULTRAHAND_CONFIG_INI_PATH, configData);
}
}
}
if (skipCombo) {
eventFire(&shData.comboEvent);
shouldFireEvent = true;
}
#endif
overlay->disableNextAnimation();
{
Handle handles[2] = { shData.comboEvent.revent, notificationEvent.revent };
s32 index = -1;
bool exitAfterPrompt = false;
bool comboBreakout = false;
bool firstLoop = !ult::firstBoot;
while (shData.running.load(std::memory_order_acquire)) {
// Early exit if launching new overlay
if (ult::launchingOverlay.load(std::memory_order_acquire)) {
//std::scoped_lock lock(shData.dataMutex);
shData.running.store(false, std::memory_order_release);
shData.overlayOpen.store(false, std::memory_order_release);
break;
}
// Wait for events only if no active notification
if (!(notification && notification->isActive())) {
svcWaitSynchronization(&index, handles, 2, UINT64_MAX);
//eventClear(&notificationEvent);
//eventClear(&shData.comboEvent);
}
eventClear(&notificationEvent);
eventClear(&shData.comboEvent);
if ((notification && notification->isActive() && !firstLoop) || index == 1) {
comboBreakout = false;
while (shData.running.load(std::memory_order_acquire)) {
{
//std::scoped_lock lock(shData.dataMutex);
if (ult::launchingOverlay.load(std::memory_order_acquire)) {
shData.running.store(false, std::memory_order_release);
shData.overlayOpen.store(false, std::memory_order_release);
break;
}
overlay->loop(true); // Draw prompts while hidden
}
if (mainComboHasTriggered.exchange(false, std::memory_order_acq_rel)) {
comboBreakout = true;
exitAfterPrompt = false;
break;
}
if (launchComboHasTriggered.load(std::memory_order_acquire)) {
exitAfterPrompt = true;
usingPackageLauncher = false;
directMode = false;
break;
}
if (!(notification && notification->isActive())) {
break;
}
}
if (!comboBreakout || !shData.running.load(std::memory_order_acquire)) {
{
//std::scoped_lock lock(shData.dataMutex);
if (!ult::launchingOverlay.load(std::memory_order_acquire)) {
overlay->clearScreen();
}
}
if (exitAfterPrompt) {
std::scoped_lock lock(shData.dataMutex);
exitAfterPrompt = false;
shData.running.store(false, std::memory_order_release);
shData.overlayOpen.store(false, std::memory_order_release);
ult::launchingOverlay.store(true, std::memory_order_release);
launchComboHasTriggered.store(true, std::memory_order_release); // for isolating sound effect
if (usingPackageLauncher || directMode) {
tsl::setNextOverlay(ult::OVERLAY_PATH + "ovlmenu.ovl");
}
hlp::requestForeground(false);
break;
}
continue;
}
}
{
//std::scoped_lock lock(shData.dataMutex);
if (ult::launchingOverlay.load(std::memory_order_acquire)) {
shData.running.store(false, std::memory_order_release);
shData.overlayOpen.store(false, std::memory_order_release);
break;
}
firstLoop = false;
shData.overlayOpen.store(true, std::memory_order_release);
#if IS_STATUS_MONITOR_DIRECTIVE
if (!isValidOverlayMode())
hlp::requestForeground(true);
#else
hlp::requestForeground(true);
#endif
overlay->show();
if (!comboBreakout && !(notification && notification->isActive()))
overlay->clearScreen();
{
std::scoped_lock lock(shData.dataMutex);
// Clear derived states that the overlay loop will use
shData.keysDown = 0;
shData.keysHeld = 0;
// Clear any queued pending keys so nothing gets processed one frame late
shData.keysDownPending = 0;
}
}
while (shData.running.load(std::memory_order_acquire)) {
{
if (ult::launchingOverlay.load(std::memory_order_acquire)) {
shData.running.store(false, std::memory_order_release);
shData.overlayOpen.store(false, std::memory_order_release);
break;
}
overlay->loop();
{
std::scoped_lock lock(shData.dataMutex);
if (!overlay->fadeAnimationPlaying()) {
overlay->handleInput(shData.keysDownPending, shData.keysHeld, shData.touchState.count, shData.touchState.touches[0], shData.joyStickPosLeft, shData.joyStickPosRight);
}
shData.keysDownPending = 0;
}
#if IS_LAUNCHER_DIRECTIVE
if (shouldFireEvent) {
shouldFireEvent = false;
if (!comboReturn) {
//triggerRumbleDoubleClick.store(true, std::memory_order_release);
//triggerExitSound.store(true, std::memory_order_release);
triggerExitFeedback();
//} else {
// triggerRumbleClick.store(true, std::memory_order_release);
}
}
#else
if (!directMode && shouldFireEvent) {
shouldFireEvent = false;
#if IS_STATUS_MONITOR_DIRECTIVE
if (lastMode.compare("returning") == 0) {
//triggerRumbleDoubleClick.store(true, std::memory_order_release);
//triggerExitSound.store(true, std::memory_order_release);
triggerExitFeedback();
} else {
//triggerRumbleClick.store(true, std::memory_order_release);
triggerEnterSound.store(true, std::memory_order_release);
}
#else
//triggerRumbleClick.store(true, std::memory_order_release);
//triggerEnterSound.store(true, std::memory_order_release);
triggerEnterFeedback();
#endif
}
#endif
}
#if IS_STATUS_MONITOR_DIRECTIVE
if (pendingExit && wasRendering) {
pendingExit = false;
wasRendering = false;
isRendering = true;
leventClear(&renderingStopEvent);
}
#endif
if (overlay->shouldHide()) {
if (overlay->shouldCloseAfter()) {
if (!directMode) {
//std::scoped_lock lock(shData.dataMutex);
shData.running.store(false, std::memory_order_release);
shData.overlayOpen.store(false, std::memory_order_release);
break;
} else {
exitAfterPrompt = true;
#if IS_STATUS_MONITOR_DIRECTIVE
pendingExit = true;
#endif
}
}
break;
}
if (overlay->shouldClose()) {
//std::scoped_lock lock(shData.dataMutex);
shData.running.store(false, std::memory_order_release);
shData.overlayOpen.store(false, std::memory_order_release);
break;
}
}
if (shData.running.load(std::memory_order_acquire)) {
//std::scoped_lock lock(shData.dataMutex);
if (!(notification && notification->isActive()))
overlay->clearScreen();
overlay->resetFlags();
hlp::requestForeground(false);
shData.overlayOpen.store(false, std::memory_order_release);
mainComboHasTriggered.store(false, std::memory_order_acquire);
launchComboHasTriggered.store(false, std::memory_order_acquire);
eventClear(&shData.comboEvent);
}
}
// Ensure background thread is fully stopped before overlay cleanup
shData.running.store(false, std::memory_order_release);
threadWaitForExit(&backgroundThread);
threadClose(&backgroundThread);
// Cleanup overlay resources
tsl::elm::fullDeconstruction.store(true, std::memory_order_release);
hlp::requestForeground(false);
overlay->exitScreen();
overlay->exitServices();
delete overlay;
eventClose(&shData.comboEvent);
if (directMode && !launchComboHasTriggered.load(std::memory_order_acquire)) {
if (!disableSound.load(std::memory_order_acquire) && ult::useSoundEffects)
ult::AudioPlayer::playExitSound();
if (ult::useHapticFeedback) {
ult::rumbleDoubleClickStandalone();
}
}
// Brief delay to ensure thread quiescence before nx-ovlloader transition
//svcSleepThread(100'000'000); // 100ms
return 0;
}
}
}
#ifdef TESLA_INIT_IMPL
namespace tsl::cfg {
u16 LayerWidth = 0;
u16 LayerHeight = 0;
u16 LayerPosX = 0;
u16 LayerPosY = 0;
u16 FramebufferWidth = 0;
u16 FramebufferHeight = 0;
u64 launchCombo = KEY_ZL | KEY_ZR | KEY_DDOWN;
u64 launchCombo2 = KEY_L | KEY_DDOWN | KEY_RSTICK;
}
extern "C" void __libnx_init_time(void);
extern "C" {
u32 __nx_applet_type = AppletType_None;
u32 __nx_fs_num_sessions = 1;
u32 __nx_nv_transfermem_size = 0x15000;
ViLayerFlags __nx_vi_stray_layer_flags = (ViLayerFlags)0;
/**
* @brief libtesla service initializing function to override libnx's
*
*/
void __appInit(void) {
ASSERT_FATAL(smInitialize()); // needed to prevent issues with powering device into sleep
//tsl::hlp::doWithSmSession([]{
ASSERT_FATAL(fsInitialize());
ASSERT_FATAL(hidInitialize()); // Controller inputs and Touch
if (hosversionAtLeast(16,0,0)) {
ASSERT_FATAL(plInitialize(PlServiceType_User)); // Font data. Use pl:u for 16.0.0+
} else {
ASSERT_FATAL(plInitialize(PlServiceType_System)); // Use pl:s for 15.0.1 and below to prevent qlaunch/overlaydisp session exhaustion
}
ASSERT_FATAL(pmdmntInitialize()); // PID querying
ASSERT_FATAL(hidsysInitialize()); // Focus control
ASSERT_FATAL(setsysInitialize()); // Settings querying
// Time initializations
if R_SUCCEEDED(timeInitialize()) {
__libnx_init_time();
timeExit();
}
#if USING_WIDGET_DIRECTIVE
ult::powerInit();
i2cInitialize();
#endif
fsdevMountSdmc();
splInitialize();
spsmInitialize();
//i2cInitialize();
//ASSERT_FATAL(socketInitializeDefault());
//ASSERT_FATAL(nifmInitialize(NifmServiceType_User));
//});
#if IS_STATUS_MONITOR_DIRECTIVE
Service *plSrv = plGetServiceSession();
Service plClone;
ASSERT_FATAL(serviceClone(plSrv, &plClone));
serviceClose(plSrv);
*plSrv = plClone;
#endif
eventCreate(&tsl::notificationEvent, false);
tsl::notification = new tsl::NotificationPrompt();
//tsl::notification = nullptr;
}
/**
* @brief libtesla service exiting function to override libnx's
*
*/
void __appExit(void) {
delete tsl::notification;
eventClose(&tsl::notificationEvent);
//deinitRumble();
if (ult::expandedMemory)
ult::AudioPlayer::exit();
//socketExit();
//nifmExit();
spsmExit();
splExit();
fsdevUnmountAll();
#if USING_WIDGET_DIRECTIVE
i2cExit();
ult::powerExit(); // CUSTOM MODIFICATION
#endif
fsExit();
hidExit();
plExit();
pmdmntExit();
hidsysExit();
setsysExit();
smExit();
// Final cleanup
tsl::gfx::FontManager::cleanup();
}
}
#endif
Reference in New Issue View Git Blame Copy Permalink