aiden
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

FullscreenUI: Remove more redundancy

Browse Source
pull/3589/head
Stenzek 5 days ago
parent fab4b05bc8
commit e36ea9e3a8
No known key found for this signature in database
7 changed files with 217 additions and 293 deletions
Show Stats Download Patch File Download Diff File

12
src/common/string_util.h
Unescape Escape View File

@ -97,6 +97,18 @@ inline bool ContainsNoCase(std::string_view s1, std::string_view s2)
[](char lhs, char rhs) { return (ToLower(lhs) == ToLower(rhs)); }) != s1.end());
}
/// Constexpr version of strcmp, suitable for use in static_assert.
inline constexpr int ConstexprCompare(const char* s1, const char* s2)
{
const size_t len1 = std::char_traits<char>::length(s1);
const size_t len2 = std::char_traits<char>::length(s2);
const size_t clen = std::min(len1, len2);
if (const int res = std::char_traits<char>::compare(s1, s2, clen); res != 0)
return res;
return (len1 < len2) ? -1 : ((len1 > len2) ? 1 : 0);
}
/// Wrapper around std::from_chars
template<typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>
inline std::optional<T> FromChars(const std::string_view str, int base = 10)

104
src/core/achievements.cpp
Unescape Escape View File

@ -1413,8 +1413,7 @@ void Achievements::DisplayAchievementSummary()
if (!FullscreenUI::Initialize())
return;
FullscreenUI::AddNotification("AchievementsSummary", time, std::move(title), std::move(summary),
std::move(icon));
FullscreenUI::AddNotification("AchievementsSummary", time, std::move(title), std::move(summary), std::move(icon));
});
if (s_state.game_summary.num_unsupported_achievements > 0)
@ -1424,11 +1423,11 @@ void Achievements::DisplayAchievementSummary()
return;
FullscreenUI::AddNotification("UnsupportedAchievements", ACHIEVEMENT_SUMMARY_UNSUPPORTED_TIME,
TRANSLATE_STR("Achievements", "Unsupported Achievements"),
TRANSLATE_PLURAL_STR("Achievements",
"%n achievements are not supported by DuckStation.",
"Achievement popup", num_unsupported),
"images/warning.svg");
TRANSLATE_STR("Achievements", "Unsupported Achievements"),
TRANSLATE_PLURAL_STR("Achievements",
"%n achievements are not supported by DuckStation.",
"Achievement popup", num_unsupported),
"images/warning.svg");
});
}
}
@ -1447,8 +1446,8 @@ void Achievements::DisplayHardcoreDeferredMessage()
return;
FullscreenUI::ShowToast(std::string(),
TRANSLATE_STR("Achievements", "Hardcore mode will be enabled on system reset."),
Host::OSD_WARNING_DURATION);
TRANSLATE_STR("Achievements", "Hardcore mode will be enabled on system reset."),
Host::OSD_WARNING_DURATION);
});
}
}
@ -1483,7 +1482,7 @@ void Achievements::HandleUnlockEvent(const rc_client_event_t* event)
return;
FullscreenUI::AddNotification(fmt::format("achievement_unlock_{}", id), static_cast<float>(duration),
std::move(title), std::move(description), std::move(badge_path));
std::move(title), std::move(description), std::move(badge_path));
});
}
@ -1510,7 +1509,7 @@ void Achievements::HandleGameCompleteEvent(const rc_client_event_t* event)
return;
FullscreenUI::AddNotification("achievement_mastery", GAME_COMPLETE_NOTIFICATION_TIME, std::move(title),
std::move(message), std::move(icon));
std::move(message), std::move(icon));
});
}
}
@ -1547,7 +1546,7 @@ void Achievements::HandleSubsetCompleteEvent(const rc_client_event_t* event)
return;
FullscreenUI::AddNotification("achievement_mastery", GAME_COMPLETE_NOTIFICATION_TIME, std::move(title),
std::move(message), std::move(badge_path));
std::move(message), std::move(badge_path));
});
}
}
@ -1567,7 +1566,7 @@ void Achievements::HandleLeaderboardStartedEvent(const rc_client_event_t* event)
return;
FullscreenUI::AddNotification(fmt::format("leaderboard_{}", id), LEADERBOARD_STARTED_NOTIFICATION_TIME,
std::move(title), std::move(message), std::move(icon));
std::move(title), std::move(message), std::move(icon));
});
}
}
@ -1587,7 +1586,7 @@ void Achievements::HandleLeaderboardFailedEvent(const rc_client_event_t* event)
return;
FullscreenUI::AddNotification(fmt::format("leaderboard_{}", id), LEADERBOARD_FAILED_NOTIFICATION_TIME,
std::move(title), std::move(message), std::move(icon));
std::move(title), std::move(message), std::move(icon));
});
}
}
@ -1617,8 +1616,8 @@ void Achievements::HandleLeaderboardSubmittedEvent(const rc_client_event_t* even
if (!FullscreenUI::Initialize())
return;
FullscreenUI::AddNotification(fmt::format("leaderboard_{}", id),
static_cast<float>(g_settings.achievements_leaderboard_duration),
std::move(title), std::move(message), std::move(icon));
static_cast<float>(g_settings.achievements_leaderboard_duration), std::move(title),
std::move(message), std::move(icon));
});
}
@ -1654,8 +1653,8 @@ void Achievements::HandleLeaderboardScoreboardEvent(const rc_client_event_t* eve
return;
FullscreenUI::AddNotification(fmt::format("leaderboard_{}", id),
static_cast<float>(g_settings.achievements_leaderboard_duration),
std::move(title), std::move(message), std::move(icon));
static_cast<float>(g_settings.achievements_leaderboard_duration), std::move(title),
std::move(message), std::move(icon));
});
}
}
@ -1739,7 +1738,7 @@ void Achievements::HandleAchievementChallengeIndicatorShowEvent(const rc_client_
return;
FullscreenUI::AddNotification(fmt::format("AchievementChallenge{}", id), CHALLENGE_STARTED_NOTIFICATION_TIME,
std::move(title), std::move(description), std::move(badge_path));
std::move(title), std::move(description), std::move(badge_path));
});
}
@ -1777,7 +1776,7 @@ void Achievements::HandleAchievementChallengeIndicatorHideEvent(const rc_client_
return;
FullscreenUI::AddNotification(fmt::format("AchievementChallenge{}", id), CHALLENGE_FAILED_NOTIFICATION_TIME,
std::move(title), std::move(description), std::move(badge_path));
std::move(title), std::move(description), std::move(badge_path));
});
}
if (g_settings.achievements_challenge_indicator_mode == AchievementChallengeIndicatorMode::Notification ||
@ -1872,8 +1871,8 @@ void Achievements::HandleServerReconnectedEvent(const rc_client_event_t* event)
return;
FullscreenUI::ShowToast(TRANSLATE_STR("Achievements", "Achievements Reconnected"),
TRANSLATE_STR("Achievements", "All pending unlock requests have completed."),
Host::OSD_INFO_DURATION);
TRANSLATE_STR("Achievements", "All pending unlock requests have completed."),
Host::OSD_INFO_DURATION);
});
}
@ -1911,9 +1910,9 @@ void Achievements::OnHardcoreModeChanged(bool enabled, bool display_message, boo
return;
FullscreenUI::ShowToast(std::string(),
enabled ? TRANSLATE_STR("Achievements", "Hardcore mode is now enabled.") :
TRANSLATE_STR("Achievements", "Hardcore mode is now disabled."),
Host::OSD_INFO_DURATION);
enabled ? TRANSLATE_STR("Achievements", "Hardcore mode is now enabled.") :
TRANSLATE_STR("Achievements", "Hardcore mode is now disabled."),
Host::OSD_INFO_DURATION);
});
}
@ -2207,8 +2206,8 @@ void Achievements::ClientLoginWithTokenCallback(int result, const char* error_me
return;
FullscreenUI::AddNotification("AchievementsLoginFailed", Host::OSD_ERROR_DURATION,
TRANSLATE_STR("Achievements", "RetroAchievements Login Failed"),
std::move(message), "images/warning.svg");
TRANSLATE_STR("Achievements", "RetroAchievements Login Failed"),
std::move(message), "images/warning.svg");
});
}
@ -2257,7 +2256,7 @@ void Achievements::ShowLoginNotification()
return;
FullscreenUI::AddNotification("achievements_login", LOGIN_NOTIFICATION_TIME, std::move(title),
std::move(summary), std::move(badge_path));
std::move(summary), std::move(badge_path));
});
}
}
@ -2930,9 +2929,9 @@ void Achievements::DrawAchievementsWindow()
bool close_window = false;
if (FullscreenUI::BeginFullscreenWindow(ImVec2(), ImVec2(display_size.x, heading_height), "achievements_heading",
heading_background, 0.0f, ImVec2(10.0f, 10.0f),
ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoDecoration |
ImGuiWindowFlags_NoScrollWithMouse))
heading_background, 0.0f, ImVec2(10.0f, 10.0f),
ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoDecoration |
ImGuiWindowFlags_NoScrollWithMouse))
{
const ImVec2 pos = ImGui::GetCursorScreenPos() + ImGui::GetStyle().FramePadding;
const float spacing = FullscreenUI::LayoutScale(FullscreenUI::LAYOUT_MENU_ITEM_TITLE_SUMMARY_SPACING);
@ -3007,10 +3006,10 @@ void Achievements::DrawAchievementsWindow()
"Unsupported achievement count", s_state.game_summary.num_unsupported_achievements));
const ImRect unsupported_bb(ImVec2(left, top), ImVec2(right, top + UIStyle.MediumFontSize));
RenderShadowedTextClipped(
UIStyle.Font, UIStyle.MediumFontSize, UIStyle.BoldFontWeight, unsupported_bb.Min, unsupported_bb.Max,
ImGui::GetColorU32(FullscreenUI::DarkerColor(ImGui::GetStyle().Colors[ImGuiCol_Text])), text, nullptr,
ImVec2(0.0f, 0.0f), 0.0f, &unsupported_bb);
RenderShadowedTextClipped(UIStyle.Font, UIStyle.MediumFontSize, UIStyle.BoldFontWeight, unsupported_bb.Min,
unsupported_bb.Max,
ImGui::GetColorU32(FullscreenUI::DarkerColor(ImGui::GetStyle().Colors[ImGuiCol_Text])),
text, nullptr, ImVec2(0.0f, 0.0f), 0.0f, &unsupported_bb);
top += UIStyle.MediumFontSize + spacing;
}
@ -3043,10 +3042,10 @@ void Achievements::DrawAchievementsWindow()
}
const ImRect beaten_bb(ImVec2(left, top), ImVec2(right, top + UIStyle.MediumFontSize));
RenderShadowedTextClipped(
UIStyle.Font, UIStyle.MediumFontSize, UIStyle.BoldFontWeight, beaten_bb.Min, beaten_bb.Max,
ImGui::GetColorU32(FullscreenUI::DarkerColor(ImGui::GetStyle().Colors[ImGuiCol_Text])), text, nullptr,
ImVec2(0.0f, 0.0f), 0.0f, &beaten_bb);
RenderShadowedTextClipped(UIStyle.Font, UIStyle.MediumFontSize, UIStyle.BoldFontWeight, beaten_bb.Min,
beaten_bb.Max,
ImGui::GetColorU32(FullscreenUI::DarkerColor(ImGui::GetStyle().Colors[ImGuiCol_Text])),
text, nullptr, ImVec2(0.0f, 0.0f), 0.0f, &beaten_bb);
top += UIStyle.MediumFontSize + spacing;
}
@ -3145,13 +3144,12 @@ void Achievements::DrawAchievementsWindow()
});
FullscreenUI::SetFullscreenFooterText(
std::array{std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_XBOX_DPAD_UP_DOWN :
ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN,
ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN,
TRANSLATE_SV("Achievements", "Change Selection")),
std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_BUTTON_A : ICON_PF_ENTER,
TRANSLATE_SV("Achievements", "View Details")),
std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_BUTTON_B : ICON_PF_ESC,
TRANSLATE_SV("Achievements", "Back"))},
FullscreenUI::GetBackgroundAlpha());
TRANSLATE_SV("Achievements", "Back"))});
if (close_window)
FullscreenUI::ReturnToPreviousWindow();
@ -3194,7 +3192,7 @@ void Achievements::DrawAchievement(const rc_client_achievement_t* cheevo)
ImRect bb;
bool visible, hovered;
const bool clicked = FullscreenUI::MenuButtonFrame(TinyString::from_format("chv_{}", cheevo->id), content_height,
true, &bb, &visible, &hovered);
true, &bb, &visible, &hovered);
if (!visible)
return;
@ -3396,9 +3394,9 @@ void Achievements::DrawLeaderboardsWindow()
const float column_spacing = spacing * 2.0f;
if (FullscreenUI::BeginFullscreenWindow(ImVec2(), ImVec2(display_size.x, heading_height), "leaderboards_heading",
heading_background, 0.0f, ImVec2(10.0f, 10.0f),
ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoDecoration |
ImGuiWindowFlags_NoScrollWithMouse))
heading_background, 0.0f, ImVec2(10.0f, 10.0f),
ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoDecoration |
ImGuiWindowFlags_NoScrollWithMouse))
{
const ImVec2 heading_pos = ImGui::GetCursorScreenPos() + ImGui::GetStyle().FramePadding;
const float image_size = LayoutScale(85.0f);
@ -3615,13 +3613,12 @@ void Achievements::DrawLeaderboardsWindow()
FullscreenUI::SetFullscreenFooterText(
std::array{std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_XBOX_DPAD_UP_DOWN :
ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN,
ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN,
TRANSLATE_SV("Achievements", "Change Selection")),
std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_BUTTON_A : ICON_PF_ENTER,
TRANSLATE_SV("Achievements", "Open Leaderboard")),
std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_BUTTON_B : ICON_PF_ESC,
TRANSLATE_SV("Achievements", "Back"))},
FullscreenUI::GetBackgroundAlpha());
TRANSLATE_SV("Achievements", "Back"))});
}
else
{
@ -3679,16 +3676,15 @@ void Achievements::DrawLeaderboardsWindow()
FullscreenUI::SetFullscreenFooterText(
std::array{std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_XBOX_DPAD_LEFT_RIGHT :
ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT,
ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT,
TRANSLATE_SV("Achievements", "Change Page")),
std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_XBOX_DPAD_UP_DOWN :
ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN,
ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN,
TRANSLATE_SV("Achievements", "Change Selection")),
std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_BUTTON_A : ICON_PF_ENTER,
TRANSLATE_SV("Achievements", "View Profile")),
std::make_pair(FullscreenUI::IsGamepadInputSource() ? ICON_PF_BUTTON_B : ICON_PF_ESC,
TRANSLATE_SV("Achievements", "Back"))},
FullscreenUI::GetBackgroundAlpha());
TRANSLATE_SV("Achievements", "Back"))});
}
if (close_leaderboard_on_exit)
@ -4241,7 +4237,7 @@ void Achievements::RefreshAllProgressCallback(int result, const char* error_mess
return;
FullscreenUI::ShowToast({}, TRANSLATE_STR("Achievements", "Updated achievement progress database."),
Host::OSD_INFO_DURATION);
Host::OSD_INFO_DURATION);
});
}
}

214
src/core/fullscreenui.cpp
Unescape Escape View File

@ -129,7 +129,6 @@ static void ExitFullscreenAndOpenURL(std::string_view url);
static void CopyTextToClipboard(std::string title, std::string_view text);
static void DrawAboutWindow();
static void FixStateIfPaused();
static void GetStandardSelectionFooterText(SmallStringBase& dest, bool back_instead_of_cancel);
static bool CompileTransitionPipelines();
//////////////////////////////////////////////////////////////////////////
@ -353,26 +352,6 @@ static void SwitchToLeaderboards();
// Constants
//////////////////////////////////////////////////////////////////////////
static constexpr const std::array s_ps_button_mapping{
std::make_pair(ICON_PF_XBOX_DPAD_LEFT, ICON_PF_DPAD_LEFT),
std::make_pair(ICON_PF_XBOX_DPAD_UP, ICON_PF_DPAD_UP),
std::make_pair(ICON_PF_XBOX_DPAD_RIGHT, ICON_PF_DPAD_RIGHT),
std::make_pair(ICON_PF_XBOX_DPAD_DOWN, ICON_PF_DPAD_DOWN),
std::make_pair(ICON_PF_XBOX_DPAD_LEFT_RIGHT, ICON_PF_DPAD_LEFT_RIGHT),
std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, ICON_PF_DPAD_UP_DOWN),
std::make_pair(ICON_PF_BUTTON_A, ICON_PF_BUTTON_CROSS),
std::make_pair(ICON_PF_BUTTON_B, ICON_PF_BUTTON_CIRCLE),
std::make_pair(ICON_PF_BUTTON_X, ICON_PF_BUTTON_SQUARE),
std::make_pair(ICON_PF_BUTTON_Y, ICON_PF_BUTTON_TRIANGLE),
std::make_pair(ICON_PF_SHARE_CAPTURE, ICON_PF_DUALSHOCK_SHARE),
std::make_pair(ICON_PF_BURGER_MENU, ICON_PF_DUALSHOCK_OPTIONS),
std::make_pair(ICON_PF_XBOX, ICON_PF_PLAYSTATION),
std::make_pair(ICON_PF_LEFT_SHOULDER_LB, ICON_PF_LEFT_SHOULDER_L1),
std::make_pair(ICON_PF_LEFT_TRIGGER_LT, ICON_PF_LEFT_TRIGGER_L2),
std::make_pair(ICON_PF_RIGHT_SHOULDER_RB, ICON_PF_RIGHT_SHOULDER_R1),
std::make_pair(ICON_PF_RIGHT_TRIGGER_RT, ICON_PF_RIGHT_TRIGGER_R2),
};
static constexpr std::string_view RESUME_STATE_SELECTOR_DIALOG_NAME = "##resume_state_selector";
static constexpr std::string_view ABOUT_DIALOG_NAME = "##about_duckstation";
static constexpr std::string_view ACHIEVEMENTS_LOGIN_DIALOG_NAME = "##achievements_login";
@ -491,76 +470,6 @@ static WidgetsState s_state;
} // namespace FullscreenUI
//////////////////////////////////////////////////////////////////////////
// Utility
//////////////////////////////////////////////////////////////////////////
void FullscreenUI::GetStandardSelectionFooterText(SmallStringBase& dest, bool back_instead_of_cancel)
{
if (IsGamepadInputSource())
{
CreateFooterTextString(
dest,
std::array{std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, back_instead_of_cancel ? FSUI_VSTR("Back") : FSUI_VSTR("Cancel"))});
}
else
{
CreateFooterTextString(
dest, std::array{std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, back_instead_of_cancel ? FSUI_VSTR("Back") : FSUI_VSTR("Cancel"))});
}
}
void FullscreenUI::SetStandardSelectionFooterText(bool back_instead_of_cancel)
{
SmallString text;
GetStandardSelectionFooterText(text, back_instead_of_cancel);
SetFullscreenFooterText(text, GetBackgroundAlpha());
}
void FullscreenUI::GetChoiceDialogHelpText(SmallStringBase& dest)
{
FullscreenUI::GetStandardSelectionFooterText(dest, false);
}
void FullscreenUI::GetFileSelectorHelpText(SmallStringBase& dest)
{
if (IsGamepadInputSource())
{
CreateFooterTextString(dest, std::array{std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_BUTTON_Y, FSUI_VSTR("Parent Directory")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Cancel"))});
}
else
{
CreateFooterTextString(
dest,
std::array{std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_BACKSPACE, FSUI_VSTR("Parent Directory")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")), std::make_pair(ICON_PF_ESC, FSUI_VSTR("Cancel"))});
}
}
void FullscreenUI::GetInputDialogHelpText(SmallStringBase& dest)
{
if (IsGamepadInputSource())
{
CreateFooterTextString(dest, std::array{std::make_pair(ICON_PF_KEYBOARD, FSUI_VSTR("Enter Value")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Cancel"))});
}
else
{
CreateFooterTextString(dest, std::array{std::make_pair(ICON_PF_KEYBOARD, FSUI_VSTR("Enter Value")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Cancel"))});
}
}
//////////////////////////////////////////////////////////////////////////
// Main
//////////////////////////////////////////////////////////////////////////
@ -576,13 +485,6 @@ bool FullscreenUI::Initialize()
s_state.show_localized_titles = Host::GetBaseBoolSettingValue("Main", "FullscreenUIShowLocalizedTitles", true);
SetAnimations(Host::GetBaseBoolSettingValue("Main", "FullscreenUIAnimations", true));
SetSmoothScrolling(Host::GetBaseBoolSettingValue("Main", "FullscreenUISmoothScrolling", true));
SetMenuBorders(Host::GetBaseBoolSettingValue("Main", "FullscreenUIMenuBorders", false));
if (Host::GetBaseBoolSettingValue("Main", "FullscreenUIDisplayPSIcons", false))
SetFullscreenFooterTextIconMapping(s_ps_button_mapping);
if (!InitializeWidgets() || !LoadResources())
{
DestroyResources();
@ -2094,18 +1996,15 @@ void FullscreenUI::DrawLandingWindow()
std::make_pair(ICON_PF_BUTTON_X, FSUI_VSTR("Toggle Fullscreen")),
std::make_pair(ICON_PF_XBOX_DPAD_LEFT_RIGHT, FSUI_VSTR("Navigate")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Exit"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Exit"))});
}
else
{
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_F1, FSUI_VSTR("About")),
std::make_pair(ICON_PF_F3, FSUI_VSTR("Resume Last Session")),
std::make_pair(ICON_PF_F11, FSUI_VSTR("Toggle Fullscreen")),
std::make_pair(ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT, FSUI_VSTR("Navigate")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Exit"))},
GetBackgroundAlpha());
SetFullscreenFooterText(std::array{
std::make_pair(ICON_PF_F1, FSUI_VSTR("About")), std::make_pair(ICON_PF_F3, FSUI_VSTR("Resume Last Session")),
std::make_pair(ICON_PF_F11, FSUI_VSTR("Toggle Fullscreen")),
std::make_pair(ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT, FSUI_VSTR("Navigate")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")), std::make_pair(ICON_PF_ESC, FSUI_VSTR("Exit"))});
}
}
@ -2160,16 +2059,14 @@ void FullscreenUI::DrawStartGameWindow()
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_XBOX_DPAD_LEFT_RIGHT, FSUI_VSTR("Navigate")),
std::make_pair(ICON_PF_BUTTON_Y, FSUI_VSTR("Load Global State")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Back"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Back"))});
}
else
{
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT, FSUI_VSTR("Navigate")),
std::make_pair(ICON_PF_F1, FSUI_VSTR("Load Global State")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back"))});
}
}
@ -3912,16 +3809,14 @@ void FullscreenUI::DrawSettingsWindow()
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_XBOX_DPAD_LEFT_RIGHT, FSUI_VSTR("Change Page")),
std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, FSUI_VSTR("Navigate")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Back"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Back"))});
}
else
{
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT, FSUI_VSTR("Change Page")),
std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN, FSUI_VSTR("Navigate")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back"))});
}
}
@ -4064,38 +3959,27 @@ void FullscreenUI::DrawInterfaceSettingsPage()
FSUI_VSTR("When Big Picture mode is started, the game list will be displayed instead of the main menu."), "Main",
"FullscreenUIOpenToGameList", false);
if (DrawToggleSetting(
bsi, FSUI_ICONVSTR(ICON_PF_GAMEPAD, "Use DualShock/DualSense Button Icons"),
FSUI_VSTR(
"Displays DualShock/DualSense button icons in the footer and input binding, instead of Xbox buttons."),
"Main", "FullscreenUIDisplayPSIcons", false))
{
if (bsi->GetBoolValue("Main", "FullscreenUIDisplayPSIcons", false))
SetFullscreenFooterTextIconMapping(s_ps_button_mapping);
else
SetFullscreenFooterTextIconMapping({});
}
bool widgets_settings_changed = DrawToggleSetting(
bsi, FSUI_ICONVSTR(ICON_PF_GAMEPAD, "Use DualShock/DualSense Button Icons"),
FSUI_VSTR("Displays DualShock/DualSense button icons in the footer and input binding, instead of Xbox buttons."),
"Main", "FullscreenUIDisplayPSIcons", false);
if (DrawToggleSetting(bsi, FSUI_ICONVSTR(ICON_FA_WINDOW_RESTORE, "Window Animations"),
FSUI_VSTR("Animates windows opening/closing and changes between views in the Big Picture UI."),
"Main", "FullscreenUIAnimations", true))
{
SetAnimations(bsi->GetBoolValue("Main", "FullscreenUIAnimations", true));
}
widgets_settings_changed |=
DrawToggleSetting(bsi, FSUI_ICONVSTR(ICON_FA_WINDOW_RESTORE, "Window Animations"),
FSUI_VSTR("Animates windows opening/closing and changes between views in the Big Picture UI."),
"Main", "FullscreenUIAnimations", true);
if (DrawToggleSetting(bsi, FSUI_ICONVSTR(ICON_FA_LIST, "Smooth Scrolling"),
FSUI_VSTR("Enables smooth scrolling of menus in the Big Picture UI."), "Main",
"FullscreenUISmoothScrolling", true))
{
SetSmoothScrolling(bsi->GetBoolValue("Main", "FullscreenUISmoothScrolling", true));
}
widgets_settings_changed |= DrawToggleSetting(bsi, FSUI_ICONVSTR(ICON_FA_LIST, "Smooth Scrolling"),
FSUI_VSTR("Enables smooth scrolling of menus in the Big Picture UI."),
"Main", "FullscreenUISmoothScrolling", true);
widgets_settings_changed |=
DrawToggleSetting(bsi, FSUI_ICONVSTR(ICON_FA_BORDER_ALL, "Menu Borders"),
FSUI_VSTR("Draws a border around the currently-selected item for readability."), "Main",
"FullscreenUIMenuBorders", false);
if (DrawToggleSetting(bsi, FSUI_ICONVSTR(ICON_FA_BORDER_ALL, "Menu Borders"),
FSUI_VSTR("Draws a border around the currently-selected item for readability."), "Main",
"FullscreenUIMenuBorders", false))
{
SetMenuBorders(bsi->GetBoolValue("Main", "FullscreenUIMenuBorders", false));
}
// use transition to work around double lock
if (widgets_settings_changed)
BeginTransition(0.0f, &FullscreenUI::UpdateWidgetsSettings);
MenuHeading(FSUI_VSTR("Behavior"));
@ -7150,16 +7034,13 @@ void FullscreenUI::DrawPauseMenu()
{
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Return To Game"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Return To Game"))});
}
else
{
SetFullscreenFooterText(
std::array{std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Return To Game"))},
GetBackgroundAlpha());
SetFullscreenFooterText(std::array{
std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")), std::make_pair(ICON_PF_ESC, FSUI_VSTR("Return To Game"))});
}
}
@ -7571,8 +7452,7 @@ void FullscreenUI::DrawSaveStateSelector()
std::make_pair(ICON_PF_BUTTON_Y, FSUI_VSTR("Delete State")),
std::make_pair(ICON_PF_BUTTON_A, s_state.save_state_selector_loading ? FSUI_VSTR("Load State") :
FSUI_VSTR("Save State")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Cancel"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Cancel"))});
}
else
{
@ -7582,8 +7462,7 @@ void FullscreenUI::DrawSaveStateSelector()
std::make_pair(ICON_PF_F1, FSUI_VSTR("Delete State")),
std::make_pair(ICON_PF_ENTER, s_state.save_state_selector_loading ? FSUI_VSTR("Load State") :
FSUI_VSTR("Save State")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Cancel"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Cancel"))});
}
if (pressed_entry)
@ -7900,23 +7779,20 @@ void FullscreenUI::DrawGameListWindow()
std::make_pair(ICON_PF_BUTTON_X, FSUI_VSTR("Change View")),
std::make_pair(ICON_PF_BUTTON_Y, FSUI_VSTR("Launch Options")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Start Game")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Back"))},
GetBackgroundAlpha());
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Back"))});
}
else
{
SetFullscreenFooterText(
std::array{
std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT,
FSUI_VSTR("Select Game")),
std::make_pair(ICON_PF_F3, FSUI_VSTR("Resume Last Session")),
std::make_pair(ICON_PF_F2, FSUI_VSTR("Settings")),
std::make_pair(ICON_PF_F4, FSUI_VSTR("Change View")),
std::make_pair(ICON_PF_F1, FSUI_VSTR("Launch Options")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Start Game")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back")),
},
GetBackgroundAlpha());
SetFullscreenFooterText(std::array{
std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN ICON_PF_ARROW_LEFT ICON_PF_ARROW_RIGHT,
FSUI_VSTR("Select Game")),
std::make_pair(ICON_PF_F3, FSUI_VSTR("Resume Last Session")),
std::make_pair(ICON_PF_F2, FSUI_VSTR("Settings")),
std::make_pair(ICON_PF_F4, FSUI_VSTR("Change View")),
std::make_pair(ICON_PF_F1, FSUI_VSTR("Launch Options")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Start Game")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Back")),
});
}
}

1
src/core/fullscreenui.h
Unescape Escape View File

@ -75,7 +75,6 @@ void OpenDiscChangeMenu();
void OpenAchievementsWindow();
void OpenLeaderboardsWindow();
void ReturnToPreviousWindow();
void SetStandardSelectionFooterText(bool back_instead_of_cancel);
class BackgroundProgressCallback final : public ProgressCallback
{

158
src/core/fullscreenui_widgets.cpp
Unescape Escape View File

@ -28,6 +28,7 @@
#include "IconsEmoji.h"
#include "IconsFontAwesome6.h"
#include "IconsPromptFont.h"
#include "imgui_internal.h"
#include "imgui_stdlib.h"
@ -50,19 +51,12 @@ static constexpr float MENU_ITEM_BORDER_ROUNDING = 10.0f;
static constexpr float SMOOTH_SCROLLING_SPEED = 3.5f;
static constexpr u32 LOADING_PROGRESS_SAMPLE_COUNT = 30;
static constexpr std::array s_theme_display_names = {
FSUI_NSTR("Automatic"), FSUI_NSTR("Dark"), FSUI_NSTR("Light"), FSUI_NSTR("AMOLED"),
FSUI_NSTR("Cobalt Sky"), FSUI_NSTR("Grey Matter"), FSUI_NSTR("Green Giant"), FSUI_NSTR("Pinky Pals"),
FSUI_NSTR("Dark Ruby"), FSUI_NSTR("Purple Rain"),
};
static constexpr std::array s_theme_names = {
"", "Dark", "Light", "AMOLED", "CobaltSky", "GreyMatter", "GreenGiant", "PinkyPals", "DarkRuby", "PurpleRain",
};
static std::optional<Image> LoadTextureImage(std::string_view path, u32 svg_width, u32 svg_height);
static std::shared_ptr<GPUTexture> UploadTexture(std::string_view path, const Image& image);
static void CreateFooterTextString(SmallStringBase& dest,
std::span<const std::pair<const char*, std::string_view>> items);
static void DrawBackgroundProgressDialogs(ImVec2& position, float spacing);
static void UpdateLoadingScreenProgress(s32 progress_min, s32 progress_max, s32 progress_value);
static bool GetLoadingScreenTimeEstimate(SmallString& out_str);
@ -72,6 +66,47 @@ static void DrawNotifications(ImVec2& position, float spacing);
static void DrawToast();
static ImGuiID GetBackgroundProgressID(std::string_view str_id);
static constexpr std::array s_theme_display_names = {
FSUI_NSTR("Automatic"), FSUI_NSTR("Dark"), FSUI_NSTR("Light"), FSUI_NSTR("AMOLED"),
FSUI_NSTR("Cobalt Sky"), FSUI_NSTR("Grey Matter"), FSUI_NSTR("Green Giant"), FSUI_NSTR("Pinky Pals"),
FSUI_NSTR("Dark Ruby"), FSUI_NSTR("Purple Rain"),
};
static constexpr std::array s_theme_names = {
"", "Dark", "Light", "AMOLED", "CobaltSky", "GreyMatter", "GreenGiant", "PinkyPals", "DarkRuby", "PurpleRain",
};
static constexpr const std::array s_ps_button_mapping{
std::make_pair(ICON_PF_LEFT_TRIGGER_LT, ICON_PF_LEFT_TRIGGER_L2),
std::make_pair(ICON_PF_RIGHT_TRIGGER_RT, ICON_PF_RIGHT_TRIGGER_R2),
std::make_pair(ICON_PF_LEFT_SHOULDER_LB, ICON_PF_LEFT_SHOULDER_L1),
std::make_pair(ICON_PF_RIGHT_SHOULDER_RB, ICON_PF_RIGHT_SHOULDER_R1),
std::make_pair(ICON_PF_BUTTON_X, ICON_PF_BUTTON_SQUARE),
std::make_pair(ICON_PF_BUTTON_Y, ICON_PF_BUTTON_TRIANGLE),
std::make_pair(ICON_PF_BUTTON_B, ICON_PF_BUTTON_CIRCLE),
std::make_pair(ICON_PF_BUTTON_A, ICON_PF_BUTTON_CROSS),
std::make_pair(ICON_PF_SHARE_CAPTURE, ICON_PF_DUALSHOCK_SHARE),
std::make_pair(ICON_PF_BURGER_MENU, ICON_PF_DUALSHOCK_OPTIONS),
std::make_pair(ICON_PF_XBOX_DPAD_LEFT, ICON_PF_DPAD_LEFT),
std::make_pair(ICON_PF_XBOX_DPAD_UP, ICON_PF_DPAD_UP),
std::make_pair(ICON_PF_XBOX_DPAD_RIGHT, ICON_PF_DPAD_RIGHT),
std::make_pair(ICON_PF_XBOX_DPAD_DOWN, ICON_PF_DPAD_DOWN),
std::make_pair(ICON_PF_XBOX_DPAD_LEFT_RIGHT, ICON_PF_DPAD_LEFT_RIGHT),
std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, ICON_PF_DPAD_UP_DOWN),
std::make_pair(ICON_PF_XBOX, ICON_PF_PLAYSTATION),
};
static_assert(
[]() {
for (size_t i = 1; i < s_ps_button_mapping.size(); i++)
{
if (StringUtil::ConstexprCompare(s_ps_button_mapping[i - 1].first, s_ps_button_mapping[i].first) >= 0)
return false;
}
return true;
}(),
"PS button mapping is not sorted");
namespace {
enum class CloseButtonState
@ -259,7 +294,6 @@ struct ALIGN_TO_CACHE_LINE WidgetsState
CloseButtonState close_button_state = CloseButtonState::None;
ImGuiDir has_pending_nav_move = ImGuiDir_None;
FocusResetType focus_reset_queued = FocusResetType::None;
bool initialized = false;
u32 menu_button_index = 0;
ImVec2 horizontal_menu_button_size = {};
@ -272,9 +306,8 @@ struct ALIGN_TO_CACHE_LINE WidgetsState
SmallString last_fullscreen_footer_text;
SmallString left_fullscreen_footer_text;
SmallString last_left_fullscreen_footer_text;
std::vector<std::pair<std::string_view, std::string_view>> fullscreen_footer_icon_mapping;
std::span<const std::pair<const char*, const char*>> fullscreen_footer_icon_mapping;
float fullscreen_text_change_time;
float fullscreen_text_alpha;
ImGuiID enum_choice_button_id = 0;
s32 enum_choice_button_value = 0;
@ -338,15 +371,15 @@ bool FullscreenUI::InitializeWidgets()
if (!s_state.placeholder_texture)
return false;
s_state.initialized = true;
UpdateWidgetsSettings();
ResetMenuButtonFrame();
return true;
}
void FullscreenUI::ShutdownWidgets(bool clear_state)
{
std::unique_lock lock(s_state.shared_state_mutex);
s_state.initialized = false;
s_state.texture_upload_queue.clear();
s_state.placeholder_texture.reset();
UIStyle.Font = nullptr;
@ -370,19 +403,15 @@ void FullscreenUI::ShutdownWidgets(bool clear_state)
}
}
void FullscreenUI::SetAnimations(bool enabled)
void FullscreenUI::UpdateWidgetsSettings()
{
UIStyle.Animations = enabled;
}
UIStyle.Animations = Host::GetBaseBoolSettingValue("Main", "FullscreenUIAnimations", true);
UIStyle.SmoothScrolling = Host::GetBaseBoolSettingValue("Main", "FullscreenUISmoothScrolling", true);
UIStyle.MenuBorders = Host::GetBaseBoolSettingValue("Main", "FullscreenUIMenuBorders", false);
void FullscreenUI::SetSmoothScrolling(bool enabled)
{
UIStyle.SmoothScrolling = enabled;
}
void FullscreenUI::SetMenuBorders(bool enabled)
{
UIStyle.MenuBorders = enabled;
s_state.fullscreen_footer_icon_mapping = Host::GetBaseBoolSettingValue("Main", "FullscreenUIDisplayPSIcons", false) ?
s_ps_button_mapping :
std::span<const std::pair<const char*, const char*>>{};
}
const std::shared_ptr<GPUTexture>& FullscreenUI::GetPlaceholderTexture()
@ -553,8 +582,7 @@ GPUTexture* FullscreenUI::GetCachedTextureAsync(std::string_view name)
return;
std::unique_lock lock(s_state.shared_state_mutex);
if (s_state.initialized)
s_state.texture_upload_queue.emplace_back(std::move(path), std::move(image.value()));
s_state.texture_upload_queue.emplace_back(std::move(path), std::move(image.value()));
});
}
@ -586,8 +614,7 @@ GPUTexture* FullscreenUI::GetCachedTextureAsync(std::string_view name, u32 svg_w
return;
std::unique_lock lock(s_state.shared_state_mutex);
if (s_state.initialized)
s_state.texture_upload_queue.emplace_back(std::move(wh_name), std::move(image.value()));
s_state.texture_upload_queue.emplace_back(std::move(wh_name), std::move(image.value()));
});
}
@ -851,9 +878,6 @@ void FullscreenUI::EndFixedPopupDialog()
void FullscreenUI::RenderOverlays()
{
if (!s_state.initialized)
return;
const float margin = std::max(ImGuiManager::GetScreenMargin(), LayoutScale(10.0f));
const float spacing = LayoutScale(10.0f);
const float notification_vertical_pos = GetNotificationVerticalPosition();
@ -1181,17 +1205,14 @@ void FullscreenUI::CreateFooterTextString(SmallStringBase& dest,
}
}
void FullscreenUI::SetFullscreenFooterText(std::string_view text, float background_alpha)
void FullscreenUI::SetFullscreenFooterText(std::string_view text)
{
s_state.fullscreen_footer_text.assign(text);
s_state.fullscreen_text_alpha = background_alpha;
}
void FullscreenUI::SetFullscreenFooterText(std::span<const std::pair<const char*, std::string_view>> items,
float background_alpha)
void FullscreenUI::SetFullscreenFooterText(std::span<const std::pair<const char*, std::string_view>> items)
{
CreateFooterTextString(s_state.fullscreen_footer_text, items);
s_state.fullscreen_text_alpha = background_alpha;
}
void FullscreenUI::SetFullscreenStatusText(std::string_view text)
@ -1204,19 +1225,22 @@ void FullscreenUI::SetFullscreenStatusText(std::span<const std::pair<const char*
CreateFooterTextString(s_state.left_fullscreen_footer_text, items);
}
void FullscreenUI::SetFullscreenFooterTextIconMapping(std::span<const std::pair<const char*, const char*>> mapping)
void FullscreenUI::SetStandardSelectionFooterText(bool back_instead_of_cancel)
{
if (mapping.empty())
if (IsGamepadInputSource())
{
s_state.fullscreen_footer_icon_mapping = {};
return;
SetFullscreenFooterText(
std::array{std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, back_instead_of_cancel ? FSUI_VSTR("Back") : FSUI_VSTR("Cancel"))});
}
else
{
SetFullscreenFooterText(
std::array{std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, back_instead_of_cancel ? FSUI_VSTR("Back") : FSUI_VSTR("Cancel"))});
}
s_state.fullscreen_footer_icon_mapping.reserve(mapping.size());
for (const auto& [icon, mapped_icon] : mapping)
s_state.fullscreen_footer_icon_mapping.emplace_back(icon, mapped_icon);
std::sort(s_state.fullscreen_footer_icon_mapping.begin(), s_state.fullscreen_footer_icon_mapping.end(),
[](const auto& lhs, const auto& rhs) { return (lhs.first < rhs.first); });
}
void FullscreenUI::DrawFullscreenFooter()
@ -1235,10 +1259,11 @@ void FullscreenUI::DrawFullscreenFooter()
const float height = LayoutScale(LAYOUT_FOOTER_HEIGHT);
const ImVec2 shadow_offset = LayoutScale(LAYOUT_SHADOW_OFFSET, LAYOUT_SHADOW_OFFSET);
const u32 text_color = ImGui::GetColorU32(UIStyle.PrimaryTextColor);
const float bg_alpha = GetBackgroundAlpha();
ImDrawList* dl = ImGui::GetForegroundDrawList();
dl->AddRectFilled(ImVec2(0.0f, io.DisplaySize.y - height), io.DisplaySize,
ImGui::GetColorU32(ModAlpha(UIStyle.PrimaryColor, s_state.fullscreen_text_alpha)), 0.0f);
ImGui::GetColorU32(ModAlpha(UIStyle.PrimaryColor, bg_alpha)), 0.0f);
ImFont* const font = UIStyle.Font;
const float font_size = UIStyle.MediumFontSize;
@ -1312,9 +1337,6 @@ void FullscreenUI::DrawFullscreenFooter()
IMSTR_START_END(s_state.left_fullscreen_footer_text));
}
}
// for next frame
s_state.fullscreen_text_alpha = 1.0f;
}
void FullscreenUI::PrerenderMenuButtonBorder()
@ -3167,7 +3189,20 @@ void FullscreenUI::FileSelectorDialog::Draw()
EndMenuButtons();
GetFileSelectorHelpText(s_state.fullscreen_footer_text);
if (IsGamepadInputSource())
{
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_XBOX_DPAD_UP_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_BUTTON_Y, FSUI_VSTR("Parent Directory")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Cancel"))});
}
else
{
SetFullscreenFooterText(
std::array{std::make_pair(ICON_PF_ARROW_UP ICON_PF_ARROW_DOWN, FSUI_VSTR("Change Selection")),
std::make_pair(ICON_PF_BACKSPACE, FSUI_VSTR("Parent Directory")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")), std::make_pair(ICON_PF_ESC, FSUI_VSTR("Cancel"))});
}
EndRender();
@ -3342,7 +3377,7 @@ void FullscreenUI::ChoiceDialog::Draw()
EndMenuButtons();
}
GetChoiceDialogHelpText(s_state.fullscreen_footer_text);
SetStandardSelectionFooterText(false);
EndRender();
@ -3468,7 +3503,18 @@ void FullscreenUI::InputStringDialog::Draw()
EndMenuButtons();
GetInputDialogHelpText(s_state.fullscreen_footer_text);
if (IsGamepadInputSource())
{
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_KEYBOARD, FSUI_VSTR("Enter Value")),
std::make_pair(ICON_PF_BUTTON_A, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_BUTTON_B, FSUI_VSTR("Cancel"))});
}
else
{
SetFullscreenFooterText(std::array{std::make_pair(ICON_PF_KEYBOARD, FSUI_VSTR("Enter Value")),
std::make_pair(ICON_PF_ENTER, FSUI_VSTR("Select")),
std::make_pair(ICON_PF_ESC, FSUI_VSTR("Cancel"))});
}
EndRender();
}
@ -3534,7 +3580,7 @@ void FullscreenUI::MessageDialog::Draw()
EndMenuButtons();
GetChoiceDialogHelpText(s_state.fullscreen_footer_text);
SetStandardSelectionFooterText(false);
EndRender();

18
src/core/fullscreenui_widgets.h
Unescape Escape View File

@ -212,14 +212,14 @@ bool InitializeWidgets();
/// Shuts down, clearing all state.
void ShutdownWidgets(bool clear_state);
/// Loads settings from the settings interface.
void UpdateWidgetsSettings();
std::span<const char* const> GetThemeNames();
std::span<const char* const> GetThemeDisplayNames();
std::vector<std::string_view> GetLocalizedThemeDisplayNames();
void UpdateTheme();
void SetAnimations(bool enabled);
void SetSmoothScrolling(bool enabled);
void SetMenuBorders(bool enabled);
void SetFont(ImFont* ui_font);
bool UpdateLayoutScale();
@ -297,10 +297,9 @@ void SetWindowNavWrapping(bool allow_wrap_x = false, bool allow_wrap_y = true);
bool IsGamepadInputSource();
std::string_view GetControllerIconMapping(std::string_view icon);
void CreateFooterTextString(SmallStringBase& dest, std::span<const std::pair<const char*, std::string_view>> items);
void SetFullscreenFooterText(std::string_view text, float background_alpha);
void SetFullscreenFooterText(std::span<const std::pair<const char*, std::string_view>> items, float background_alpha);
void SetFullscreenFooterTextIconMapping(std::span<const std::pair<const char*, const char*>> mapping);
void SetFullscreenFooterText(std::string_view text);
void SetFullscreenFooterText(std::span<const std::pair<const char*, std::string_view>> items);
void SetStandardSelectionFooterText(bool back_instead_of_cancel);
void SetFullscreenStatusText(std::string_view text);
void SetFullscreenStatusText(std::span<const std::pair<const char*, std::string_view>> items);
void DrawFullscreenFooter();
@ -474,11 +473,6 @@ void ShowToast(std::string title, std::string message, float duration = 10.0f);
bool HasToast();
void ClearToast();
// Message callbacks.
void GetChoiceDialogHelpText(SmallStringBase& dest);
void GetFileSelectorHelpText(SmallStringBase& dest);
void GetInputDialogHelpText(SmallStringBase& dest);
// Wrapper for an animated popup dialog.
class PopupDialog
{

3
src/core/gpu_presenter.cpp
Unescape Escape View File

@ -1087,7 +1087,8 @@ bool GPUPresenter::PresentFrame(GPUPresenter* presenter, GPUBackend* backend, bo
ImGuiManager::RenderOSDMessages();
FullscreenUI::RenderOverlays();
if (FullscreenUI::IsInitialized())
FullscreenUI::RenderOverlays();
if (backend && !GPUThread::IsSystemPaused())
ImGuiManager::RenderSoftwareCursors();

Write Preview
Loading…
Cancel
Save