Skip to content

Xbox Cloud Gaming app for PS5 Homebrew

C
61.5 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 RafaelNGP
#include "ui/app_ui_internal.h"

namespace xc::ui {

void AppUi::handleHome(const NavInput& in, UiEvent& ev) {
    // Caller holds mutex_.
    if ((in.scrollRows || in.scrollCards) && !(searching_ && searchOnKeys_)) {
        // Smooth scrolling: the rows and cards it moved by since the last
        // pass, one step at a time (the view glides after the focus).
        auto steps = [&](int n, bool vertical) {
            NavInput step;
            step.nowMs = in.nowMs;
            (vertical ? (n > 0 ? step.down : step.up) : (n > 0 ? step.right : step.left)) = true;
            for (int k = 0; k < std::abs(n); ++k) {
                // In the search's results, sideways stops at the row's edge
                // (left of it is the keyboard).
                if (searching_ && !vertical && (n < 0 ? resultFocus_ % kResultCols == 0
                                                      : (resultFocus_ + 1) % kResultCols == 0))
                    break;
                handleHome(step, ev);
            }
        };
        if (in.scrollRows) steps(in.scrollRows, true);
        if (in.scrollCards) steps(in.scrollCards, false);
        return;
    }
    if (in.l1 || in.r1) {
        // Game Pass, Your games, My consoles, round.
        int n = static_cast<int>(tab_) + (in.r1 ? 1 : 2);
        tab_ = static_cast<Tab>(n % 3);
        searching_ = false;
        dirty_ = true;
        if (tab_ == Tab::Consoles) ev.action = Action::ConsolesShown;
        return;
    }
    if (in.l3 && !searching_) {
        ev.action = Action::RefreshLibrary;
        return;
    }
    if (in.options) {
        screen_ = Screen::Settings;
        settingsRow_ = 0;
        settingsFromError_ = false;
        settingsCountry_ = settings_.loginCountry;
        dropdownOpen_ = false;
        filterList_ = -1;
        dirty_ = true;
        return;
    }
    if (in.triangle && !searching_ && tab_ != Tab::Consoles) {  // search this tab
        searching_ = true;
        searchOnKeys_ = true;
        query_.clear();
        runSearch();
        dirty_ = true;
        return;
    }
    if (searching_) {
        if (searchOnKeys_) {
            if ((in.back || in.triangle) && filterList_ < 0) {  // close the search (Circle closes an open list first)
                searching_ = false;
                dirty_ = true;
                return;
            }
            handleSearchKeys(in);
            return;
        }
        if (in.back || in.triangle || (in.left && resultFocus_ % kResultCols == 0)) {  // back to the keys
            searchOnKeys_ = true;
            dirty_ = true;
            return;
        }
        if (in.square && !query_.empty()) {  // delete without going back to the keys
            query_.pop_back();
            runSearch();
            searchOnKeys_ = results_.empty();
            dirty_ = true;
            return;
        }
        if (moveInGrid(resultFocus_, static_cast<int>(results_.size()), kResultCols, in)) {
            resultScroll_.target = gridTarget(resultFocus_, kResultCols);
            dirty_ = true;
        }
        if (in.accept && resultFocus_ < static_cast<int>(results_.size()))
            openDetails(results_[static_cast<size_t>(resultFocus_)]);
        return;
    }
    switch (tab_) {
        case Tab::Consoles: {
            int n = static_cast<int>(consoles_.size());
            // Search again: Cross with none listed, Triangle otherwise.
            if (consolesKnown_ && ((n == 0 && in.accept) || in.triangle)) {
                if (n == 0) consolesKnown_ = false;  // the spinner while it looks
                ev.action = Action::ConsolesShown;
                dirty_ = true;
                break;
            }
            if (n == 0) break;
            int before = consoleFocus_;
            if (in.right && consoleFocus_ + 1 < n) ++consoleFocus_;
            if (in.left && consoleFocus_ > 0) --consoleFocus_;
            if (consoleFocus_ != before) dirty_ = true;
            if (in.accept) {
                const ConsoleTile& con = consoles_[static_cast<size_t>(consoleFocus_)];
                ev.action = Action::Play;
                ev.game.titleId = con.serverId;
                ev.game.name = con.name.empty() ? "Xbox" : con.name;
                ev.game.homeConsole = true;
            }
            break;
        }
        case Tab::GamePass: {
            if (rows_.empty()) break;
            int rows = static_cast<int>(rows_.size());
            const GameRow& curRow = rows_[static_cast<size_t>(focusRow_)];
            int& col = focusCol_[static_cast<size_t>(focusRow_)];
            int count = static_cast<int>(curRow.tiles.size());

            if (curRow.isGrid) {
                if (in.up && col < kLibraryCols) {
                    if (focusRow_ > 0) {
                        --focusRow_;
                        int upCols = static_cast<int>(rows_[static_cast<size_t>(focusRow_)].tiles.size());
                        focusCol_[static_cast<size_t>(focusRow_)] = std::clamp(focusCol_[static_cast<size_t>(focusRow_)], 0, upCols - 1);
                    }
                } else if (in.down && col + kLibraryCols >= count && col / kLibraryCols == (count - 1) / kLibraryCols) {
                    if (focusRow_ + 1 < rows) {
                        ++focusRow_;
                        int downCols = static_cast<int>(rows_[static_cast<size_t>(focusRow_)].tiles.size());
                        focusCol_[static_cast<size_t>(focusRow_)] = std::clamp(focusCol_[static_cast<size_t>(focusRow_)], 0, downCols - 1);
                    }
                } else {
                    moveInGrid(col, count, kLibraryCols, in);
                }
            } else {
                if (in.down && focusRow_ + 1 < rows) {
                    ++focusRow_;
                    if (rows_[static_cast<size_t>(focusRow_)].isGrid) {
                        int gCols = static_cast<int>(rows_[static_cast<size_t>(focusRow_)].tiles.size());
                        int targetCol = std::min(col % kLibraryCols, gCols - 1);
                        focusCol_[static_cast<size_t>(focusRow_)] = std::max(0, targetCol);
                    }
                }
                if (in.up && focusRow_ > 0) --focusRow_;
                if (in.right && col + 1 < count) ++col;
                if (in.left && col > 0) --col;
            }
            if (in.up || in.down || in.left || in.right) {
                retarget();
                dirty_ = true;
            }
            if (in.accept && focusedTile()) openDetails(*focusedTile());
            if (in.square && focusedTile()) toggleHidden(*focusedTile(), ev);
            break;
        }
        case Tab::Library: {
            if (!libraryTile(0)) break;
            const LibraryLayout& L = libraryLayout();
            int count = static_cast<int>(L.rowOf.size());
            int f = std::min(gridFocus_, count - 1), before = f;
            int row = L.rowOf[static_cast<size_t>(f)], col = L.colOf[static_cast<size_t>(f)];
            int rows = static_cast<int>(L.rowY.size());
            auto rowLen = [&](int r) {
                int next = r + 1 < rows ? L.rowFirst[static_cast<size_t>(r + 1)] : count;
                return next - L.rowFirst[static_cast<size_t>(r)];
            };
            if (in.right && f + 1 < count && L.rowOf[static_cast<size_t>(f + 1)] == row) ++f;
            if (in.left && col > 0) --f;
            if (in.down && row + 1 < rows) f = L.rowFirst[static_cast<size_t>(row + 1)] + std::min(col, rowLen(row + 1) - 1);
            if (in.up && row > 0) f = L.rowFirst[static_cast<size_t>(row - 1)] + std::min(col, rowLen(row - 1) - 1);
            if (f != before) {
                gridFocus_ = f;
                int y = L.rowY[static_cast<size_t>(L.rowOf[static_cast<size_t>(f)])];
                gridScroll_.target = static_cast<float>(std::max(0, y - kGridPitchY - 40));
                dirty_ = true;
            }
            if (in.accept && libraryTile(f)) openDetails(*libraryTile(f));
            if (in.square && libraryTile(f)) {
                GameTile t = *libraryTile(f);
                toggleHidden(t, ev);
            }
            if (in.l2 || in.r2) {
                // Jump between sections: the account's games, games to buy,
                // hidden games. L2 goes to the start of this section first.
                int starts[3] = {0, static_cast<int>(owned_.size()),
                                 static_cast<int>(owned_.size() + purchasable_.size())};
                int total = starts[2] + static_cast<int>(hiddenTiles_.size());
                int section = f >= starts[2] ? 2 : f >= starts[1] ? 1 : 0;
                int target = f;
                if (in.r2) {
                    for (int k = section + 1; k < 3; ++k)
                        if (starts[k] < total && (k == 2 ? !hiddenTiles_.empty() : starts[k] < starts[k + 1])) {
                            target = starts[k];
                            break;
                        }
                } else if (f != starts[section]) {
                    target = starts[section];
                } else {
                    for (int k = section - 1; k >= 0; --k)
                        if (starts[k] < starts[k + 1]) {
                            target = starts[k];
                            break;
                        }
                }
                if (target != f) {
                    gridFocus_ = target;
                    int section2 = target >= starts[2] ? 2 : target >= starts[1] ? 1 : 0;
                    gridScroll_.target = static_cast<float>(L.headerY[section2]);  // its heading at the top
                    dirty_ = true;
                }
            }
            if (in.r3) {  // next sort order
                librarySort_ = static_cast<LibrarySort>((static_cast<int>(librarySort_) + 1) %
                                                         static_cast<int>(LibrarySort::Count));
                rebuild(true);  // same place on screen, not back to the top
                prefsEvent(ev);
            }
            break;
        }
    }
}

void AppUi::setMouseCursor(float x, float y, bool visible) {
    std::lock_guard<std::mutex> lock(mutex_);
    mouseCursorX_ = std::clamp(x, 0.0f, 1919.0f);
    mouseCursorY_ = std::clamp(y, 0.0f, 1079.0f);
    mouseCursorVisible_ = visible;
    if (visible) {
        mouseCursorVisibleUntil_ = platform::nowMs() + 3000;
    }
    dirty_ = true;
}

UiEvent AppUi::onMouseMove(float x, float y) {
    std::lock_guard<std::mutex> lock(mutex_);
    UiEvent ev;
    mouseCursorX_ = std::clamp(x, 0.0f, 1919.0f);
    mouseCursorY_ = std::clamp(y, 0.0f, 1079.0f);
    mouseCursorVisible_ = true;
    mouseCursorVisibleUntil_ = platform::nowMs() + 3000;
    dirty_ = true;
    if (screen_ == Screen::Streaming || screen_ == Screen::Splash) {
        return ev;
    }
    if (screen_ == Screen::Home && !searching_ && !reportOpen_ && !updatePrompt_ && !quitPrompt_) {
        if (tab_ == Tab::GamePass && y >= 140 && y < kH - 80) {
            constexpr int kGridW = kLibraryCols * kCardPitch - kCardGap;
            const int gridLeft = (kW - kGridW) / 2;
            int afterGridOffset = 0;
            for (size_t r = 0; r < rows_.size(); ++r) {
                float rel = static_cast<float>(r) - rowY_.value;
                int rowBaseY = kRowTop + static_cast<int>(std::lround(rel * kRowPitch)) + afterGridOffset;
                const GameRow& row = rows_[r];
                if (row.isGrid) {
                    int offset = static_cast<int>(std::lround(rowScroll_[r].value));
                    int cardY = rowBaseY - offset + 48;
                    for (size_t i = 0; i < row.tiles.size(); ++i) {
                        int c_col = static_cast<int>(i) % kLibraryCols;
                        int c_row = static_cast<int>(i) / kLibraryCols;
                        int cy = cardY + c_row * kGridPitchY;
                        int cx = gridLeft + c_col * kCardPitch;
                        if (x >= cx && x < cx + kCard && y >= cy && y < cy + kCard) {
                            if (focusRow_ != static_cast<int>(r) || focusCol_[r] != static_cast<int>(i)) {
                                focusRow_ = static_cast<int>(r);
                                focusCol_[r] = static_cast<int>(i);
                                retarget();
                                dirty_ = true;
                            }
                            return ev;
                        }
                    }
                    int gridHeight = 48 + ((static_cast<int>(row.tiles.size()) + kLibraryCols - 1) / kLibraryCols) * kGridPitchY;
                    afterGridOffset += gridHeight - offset - kRowPitch;
                } else {
                    int cardY = rowBaseY + 48;
                    int scroll = static_cast<int>(std::lround(rowScroll_[r].value));
                    int firstCol = std::max(0, scroll / kCardPitch - 1);
                    for (size_t col = static_cast<size_t>(firstCol); col < row.tiles.size(); ++col) {
                        int cx = kMargin + static_cast<int>(col) * kCardPitch - scroll;
                        if (cx > kW) break;
                        if (x >= cx && x < cx + kCard && y >= cardY && y < cardY + kCard) {
                            if (focusRow_ != static_cast<int>(r) || focusCol_[r] != static_cast<int>(col)) {
                                focusRow_ = static_cast<int>(r);
                                focusCol_[r] = static_cast<int>(col);
                                retarget();
                                dirty_ = true;
                            }
                            return ev;
                        }
                    }
                }
            }
        } else if (tab_ == Tab::Library && y >= 150 && y < kH - 80) {
            constexpr int kGridW = kLibraryCols * kCardPitch - kCardGap;
            const int left = (kW - kGridW) / 2;
            const LibraryLayout& L = libraryLayout();
            int offset = static_cast<int>(std::lround(gridScroll_.value));
            for (size_t i = 0; i < L.rowOf.size(); ++i) {
                int cy = kLibraryTop + L.rowY[static_cast<size_t>(L.rowOf[i])] - offset;
                int cx = left + L.colOf[i] * kCardPitch;
                if (x >= cx && x < cx + kCard && y >= cy && y < cy + kCard) {
                    if (gridFocus_ != static_cast<int>(i)) {
                        gridFocus_ = static_cast<int>(i);
                        dirty_ = true;
                    }
                    return ev;
                }
            }
        }
    } else if (screen_ == Screen::Settings) {
        if (dropdownOpen_ || tester_ != Tester::None || pickerOpen_ || countryPickerOpen_ || reportOpen_) {
            return ev;
        }
        constexpr int kRowW = 1140, kRowH = 30, kGap = 2, kGroupGap = 4;
        int curY = 184;
        for (const auto& [i, groupStart] : visibleSettingsRows(caps_)) {
            if (groupStart) curY += kGroupGap;
            if (x >= kMargin && x < kMargin + kRowW && y >= curY && y < curY + kRowH) {
                if (settingsRow_ != i) {
                    settingsRow_ = i;
                    dirty_ = true;
                }
                return ev;
            }
            curY += kRowH + kGap;
        }
    } else if (screen_ == Screen::Details) {
        if (achievementsOpen_ || reportOpen_) {
            return ev;
        }
        if (gameSettingsOpen_) {
            constexpr int kModalW = 1140, kModalH = 960;
            constexpr int kRowH = 38, kGap = 4, kGroupGap = 7;
            const auto rows = visibleGameSettingsRows(caps_, activeGameHasCustom_, activeGameMouseSupported_);
            const auto most = visibleGameSettingsRows(caps_, true, activeGameMouseSupported_), all = visibleGameSettingsRows(UiCaps{}, true, true);
            auto groups = [](const std::vector<SettingsRowPos>& v) {
                return static_cast<int>(std::count_if(v.begin(), v.end(), [](const SettingsRowPos& r) { return r.groupStart; }));
            };
            const int modalH = kModalH - static_cast<int>(all.size() - most.size()) * (kRowH + kGap) -
                               (groups(all) - groups(most)) * kGroupGap;
            Rect panel{(kW - kModalW) / 2, (kH - modalH) / 2, kModalW, modalH};
            int curY = panel.y + 92;
            for (int pos = 0; pos < static_cast<int>(rows.size()); ++pos) {
                if (rows[static_cast<size_t>(pos)].groupStart) curY += kGroupGap;
                Rect r{panel.x + 50, curY, panel.w - 100, kRowH};
                if (x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h) {
                    if (gameSettingsRow_ != pos) {
                        gameSettingsRow_ = pos;
                        dirty_ = true;
                    }
                    return ev;
                }
                curY += kRowH + kGap;
            }
            return ev;
        }
        auto inRect = [&](const Rect& r) {
            return r.w > 0 && r.h > 0 && x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h;
        };
        Rect play = playRect_.w > 0 ? playRect_ : Rect{kMargin, 620, 300, 76};
        if (inRect(play) || inRect(claimRect_)) {
            if (detailButtonFocus_ != 0) {
                detailButtonFocus_ = 0;
                dirty_ = true;
            }
        } else if (inRect(achRect_)) {
            if (detailButtonFocus_ != 1) {
                detailButtonFocus_ = 1;
                dirty_ = true;
            }
        }
    }
    return ev;
}

UiEvent AppUi::onMouseDown(float x, float y, int button) {
    std::lock_guard<std::mutex> lock(mutex_);
    UiEvent ev;
    mouseCursorX_ = std::clamp(x, 0.0f, 1919.0f);
    mouseCursorY_ = std::clamp(y, 0.0f, 1079.0f);
    mouseCursorVisible_ = true;
    mouseCursorVisibleUntil_ = platform::nowMs() + 3000;
    dirty_ = true;
    if (screen_ == Screen::Streaming || screen_ == Screen::Splash) {
        return ev;
    }
    if (button == 3) {
        // Right click: Back
        if (reportOpen_) {
            reportOpen_ = false;
            dirty_ = true;
            return ev;
        }
        if (screen_ == Screen::Home && updatePrompt_) {
            if (showingUpdateNotes_) {
                showingUpdateNotes_ = false;
            } else {
                ev.action = Action::UpdateLater;
                updatePrompt_ = false;
            }
            dirty_ = true;
            return ev;
        }
        if (countryPickerOpen_) {
            countryPickerOpen_ = false;
            dirty_ = true;
            return ev;
        }
        if (screen_ == Screen::Home && quitPrompt_) {
            quitPrompt_ = false;
            dirty_ = true;
            return ev;
        }
        if (screen_ == Screen::Settings) {
            if (pickerOpen_) {
                handleColourPicker(NavInput{.back = true});
                dirty_ = true;
                return ev;
            }
            if (tester_ == Tester::SignInCheck || tester_ == Tester::NetworkTest || tester_ == Tester::Donation) {
                tester_ = Tester::None;
                dirty_ = true;
                return ev;
            }
            if (tester_ != Tester::None) {
                handleTester(NavInput{.back = true});
                if (tester_ == Tester::None) {
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                }
                dirty_ = true;
                return ev;
            }
        }
        if (dropdownOpen_) {
            dropdownOpen_ = false;
            dirty_ = true;
            return ev;
        }
        if (achievementsOpen_) {
            achievementsOpen_ = false;
            dirty_ = true;
            return ev;
        }
        if (gameSettingsOpen_) {
            handleGameSettings(NavInput{.back = true}, ev);
            return ev;
        }
        if (searching_) {
            searching_ = false;
            dirty_ = true;
            return ev;
        }
        if (screen_ == Screen::Settings) {
            resetSettingsHoldStart_ = 0;
            screen_ = settingsFromError_ ? Screen::Error : Screen::Home;
            dirty_ = true;
            ev.action = settings_.loginCountry != settingsCountry_ ? Action::LoginCountry : Action::SettingsChanged;
            ev.settings = settings_;
            return ev;
        }
        if (screen_ == Screen::Details) {
            syncHeroToRowsLocked(detail_.productId, detail_.titleId, detail_.heroUrl, detail_.description, detail_.publisher, detail_.categories);
            screen_ = Screen::Home;
            dirty_ = true;
            return ev;
        }
        return ev;
    }
    if (button != 1) return ev;

    if (reportOpen_ || countryPickerOpen_ || (screen_ == Screen::Home && (updatePrompt_ || quitPrompt_))) {
        return ev;
    }

    // Check avatar / profile click to open settings
    if (screen_ == Screen::Home && !searching_) {
        constexpr int kAvatar = 52;
        if (x >= kW - kMargin - kAvatar && x <= kW - kMargin && y >= 40 && y <= 100) {
            screen_ = Screen::Settings;
            settingsRow_ = 0;
            settingsFromError_ = false;
            settingsCountry_ = settings_.loginCountry;
            dropdownOpen_ = false;
            filterList_ = -1;
            dirty_ = true;
            return ev;
        }
    }

    // Check top bar tabs
    if (screen_ == Screen::Home && !searching_ && y >= 45 && y <= 95) {
        const char* labels[3] = {tr(Str::TabGamePass), tr(Str::YourGames), tr(Str::TabConsoles)};
        constexpr int kPx = 22, kPad = 26, kGap = 12, kH = 44, kY = 50;
        int widths[3], total = 0;
        for (int i = 0; i < 3; ++i) {
            widths[i] = fonts_.semibold.measure(labels[i], kPx) + 2 * kPad;
            total += widths[i + 0] + (i ? kGap : 0);
        }
        int tabX = (kW - total) / 2;
        for (int i = 0; i < 3; ++i) {
            if (x >= tabX && x < tabX + widths[i] && y >= kY && y < kY + kH) {
                tab_ = static_cast<Tab>(i);
                searching_ = false;
                dirty_ = true;
                if (tab_ == Tab::Consoles) ev.action = Action::ConsolesShown;
                return ev;
            }
            tabX += widths[i] + kGap;
        }
    }

    if (screen_ == Screen::Home && !searching_) {
        if (tab_ == Tab::GamePass && y >= 140 && y < kH - 80) {
            constexpr int kGridW = kLibraryCols * kCardPitch - kCardGap;
            const int gridLeft = (kW - kGridW) / 2;
            int afterGridOffset = 0;
            for (size_t r = 0; r < rows_.size(); ++r) {
                float rel = static_cast<float>(r) - rowY_.value;
                int rowBaseY = kRowTop + static_cast<int>(std::lround(rel * kRowPitch)) + afterGridOffset;
                const GameRow& row = rows_[r];
                if (row.isGrid) {
                    int offset = static_cast<int>(std::lround(rowScroll_[r].value));
                    int cardY = rowBaseY - offset + 48;
                    for (size_t i = 0; i < row.tiles.size(); ++i) {
                        int c_col = static_cast<int>(i) % kLibraryCols;
                        int c_row = static_cast<int>(i) / kLibraryCols;
                        int cy = cardY + c_row * kGridPitchY;
                        int cx = gridLeft + c_col * kCardPitch;
                        if (x >= cx && x < cx + kCard && y >= cy && y < cy + kCard) {
                            focusRow_ = static_cast<int>(r);
                            focusCol_[r] = static_cast<int>(i);
                            openDetails(row.tiles[i]);
                            return ev;
                        }
                    }
                    int gridHeight = 48 + ((static_cast<int>(row.tiles.size()) + kLibraryCols - 1) / kLibraryCols) * kGridPitchY;
                    afterGridOffset += gridHeight - offset - kRowPitch;
                } else {
                    int cardY = rowBaseY + 48;
                    int scroll = static_cast<int>(std::lround(rowScroll_[r].value));
                    int firstCol = std::max(0, scroll / kCardPitch - 1);
                    for (size_t col = static_cast<size_t>(firstCol); col < row.tiles.size(); ++col) {
                        int cx = kMargin + static_cast<int>(col) * kCardPitch - scroll;
                        if (cx > kW) break;
                        if (x >= cx && x < cx + kCard && y >= cardY && y < cardY + kCard) {
                            focusRow_ = static_cast<int>(r);
                            focusCol_[r] = static_cast<int>(col);
                            openDetails(row.tiles[col]);
                            return ev;
                        }
                    }
                }
            }
        } else if (tab_ == Tab::Library) {
            if (y >= 150 && y < kH - 80) {
                constexpr int kGridW = kLibraryCols * kCardPitch - kCardGap;
                const int left = (kW - kGridW) / 2;
                const LibraryLayout& L = libraryLayout();
                int offset = static_cast<int>(std::lround(gridScroll_.value));
                for (size_t i = 0; i < L.rowOf.size(); ++i) {
                    int cy = kLibraryTop + L.rowY[static_cast<size_t>(L.rowOf[i])] - offset;
                    int cx = left + L.colOf[i] * kCardPitch;
                    if (x >= cx && x < cx + kCard && y >= cy && y < cy + kCard) {
                        gridFocus_ = static_cast<int>(i);
                        const GameTile* t = libraryTile(static_cast<int>(i));
                        if (t) openDetails(*t);
                        return ev;
                    }
                }
            }
            constexpr int kAvatar = 52;
            int right = kW - kMargin - kAvatar - 16;
            if (x >= right - 200 && x <= right && y >= 110 && y <= 145) {
                librarySort_ = static_cast<LibrarySort>((static_cast<int>(librarySort_) + 1) %
                                                       static_cast<int>(LibrarySort::Count));
                rebuild(true);
                prefsEvent(ev);
                dirty_ = true;
                return ev;
            }
        }
    } else if (screen_ == Screen::Details) {
        if (gameSettingsOpen_) {
            constexpr int kModalW = 1140, kModalH = 960;
            constexpr int kRowH = 38, kGap = 4, kGroupGap = 7;
            const auto rows = visibleGameSettingsRows(caps_, activeGameHasCustom_, activeGameMouseSupported_);
            const auto most = visibleGameSettingsRows(caps_, true, activeGameMouseSupported_), all = visibleGameSettingsRows(UiCaps{}, true, true);
            auto groups = [](const std::vector<SettingsRowPos>& v) {
                return static_cast<int>(std::count_if(v.begin(), v.end(), [](const SettingsRowPos& r) { return r.groupStart; }));
            };
            const int modalH = kModalH - static_cast<int>(all.size() - most.size()) * (kRowH + kGap) -
                               (groups(all) - groups(most)) * kGroupGap;
            Rect panel{(kW - kModalW) / 2, (kH - modalH) / 2, kModalW, modalH};
            int curY = panel.y + 92;
            for (int pos = 0; pos < static_cast<int>(rows.size()); ++pos) {
                if (rows[static_cast<size_t>(pos)].groupStart) curY += kGroupGap;
                Rect r{panel.x + 50, curY, panel.w - 100, kRowH};
                if (x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h) {
                    gameSettingsRow_ = pos;
                    handleGameSettings(NavInput{.accept = true}, ev);
                    dirty_ = true;
                    return ev;
                }
                curY += kRowH + kGap;
            }
            if (x < panel.x || x >= panel.x + panel.w || y < panel.y || y >= panel.y + panel.h) {
                handleGameSettings(NavInput{.back = true}, ev);
            }
            return ev;
        }
        if (achievementsOpen_) {
            return ev;
        }
        const GameTile* g = &detail_;
        if (g->productId.empty() && g->titleId.empty()) return ev;
        bool isF2P = isFreeGame(*g);
        bool effectivePlayable = isEffectivePlayableLocked(*g);
        auto inRect = [&](const Rect& r) {
            return r.w > 0 && r.h > 0 && x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h;
        };
        if (!effectivePlayable && isF2P && !g->playable) {
            Rect claim = claimRect_.w > 0 ? claimRect_ : Rect{kMargin, 620, 380, 68};
            if (inRect(claim)) {
                detailButtonFocus_ = 0;
                ev.action = Action::ClaimFreeGame;
                ev.game = detail_;
                ev.game.freeInStore = true;
                return ev;
            }
        } else if (effectivePlayable) {
            Rect play = playRect_.w > 0 ? playRect_ : Rect{kMargin, 620, 300, 76};
            if (inRect(play)) {
                detailButtonFocus_ = 0;
                ev.action = Action::Play;
                ev.game = detail_;
                return ev;
            }
            if (inRect(achRect_) && !detail_.xboxTitleId.empty()) {
                detailButtonFocus_ = 1;
                openAchievements();
                return ev;
            }
        }
    } else if (screen_ == Screen::Settings) {
        if (trophyDisclaimerOpen_) {
            Rect panel{(kW - 1100) / 2, (kH - 520) / 2 - 30, 1100, 520};
            constexpr int kBtnW = 260, kBtnH = 58, kBtnGap = 40;
            int totalBtnsW = 2 * kBtnW + kBtnGap;
            int btnStartX = panel.x + (panel.w - totalBtnsW) / 2;
            int btnY = panel.y + panel.h - 90;
            Rect btn0{btnStartX, btnY, kBtnW, kBtnH};
            Rect btn1{btnStartX + kBtnW + kBtnGap, btnY, kBtnW, kBtnH};
            auto inRect = [&](const Rect& r) { return x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h; };
            if (inRect(btn0)) {
                settings_.syncTrophies = true;
                trophyDisclaimerOpen_ = false;
                dirty_ = true;
                ev.action = Action::SyncTrophies;
                ev.settings = settings_;
            } else if (inRect(btn1) || !inRect(panel)) {
                trophyDisclaimerOpen_ = false;
                dirty_ = true;
            }
            return ev;
        }
        if (removeTrophiesConfirmOpen_) {
            Rect panel{(kW - 1100) / 2, (kH - 480) / 2 - 30, 1100, 480};
            constexpr int kBtnW = 260, kBtnH = 58, kBtnGap = 40;
            int totalBtnsW = 2 * kBtnW + kBtnGap;
            int btnStartX = panel.x + (panel.w - totalBtnsW) / 2;
            int btnY = panel.y + panel.h - 90;
            Rect btn0{btnStartX, btnY, kBtnW, kBtnH};
            Rect btn1{btnStartX + kBtnW + kBtnGap, btnY, kBtnW, kBtnH};
            auto inRect = [&](const Rect& r) { return x >= r.x && x < r.x + r.w && y >= r.y && y < r.y + r.h; };
            if (inRect(btn0)) {
                settings_.syncTrophies = false;
                removeTrophiesConfirmOpen_ = false;
                dirty_ = true;
                ev.action = Action::RemoveTrophies;
                ev.settings = settings_;
            } else if (inRect(btn1) || !inRect(panel)) {
                removeTrophiesConfirmOpen_ = false;
                dirty_ = true;
            }
            return ev;
        }
        if (tester_ != Tester::None || pickerOpen_) {
            return ev;
        }
        if (dropdownOpen_) {
            auto options = settingOptions(settingsRow_);
            constexpr int kItemH = 62, kVisible = 8, kListW = 640;
            int n = static_cast<int>(options.size());
            int visible = std::min(n, kVisible);
            constexpr int kRowW = 1140, kRowH = 30, kGap = 2, kGroupGap = 4;
            Rect panel{kMargin + kRowW - kListW, 184, kListW, visible * kItemH + 16};
            int curY = 184;
            for (const auto& [i, groupStart] : visibleSettingsRows(caps_)) {
                if (groupStart) curY += kGroupGap;
                if (i == settingsRow_) {
                    panel.y = curY + kRowH + 8;
                    break;
                }
                curY += kRowH + kGap;
            }
            if (panel.y + panel.h > kH - 100) panel.y = std::max(120, kH - 100 - panel.h);

            if (x >= panel.x && x < panel.x + panel.w && y >= panel.y && y < panel.y + panel.h) {
                for (int k = 0; k < visible; ++k) {
                    int i = dropdownTop_ + k;
                    Rect item{panel.x + 8, panel.y + 8 + k * kItemH, panel.w - 16, kItemH};
                    if (x >= item.x && x < item.x + item.w && y >= item.y && y < item.y + item.h && i < n) {
                        int before = settingSelected(settingsRow_);
                        applySetting(settingsRow_, i);
                        dropdownOpen_ = false;
                        dirty_ = true;
                        if (settingsRow_ == 6 && i == 1) {
                            openColourPicker(before);
                        } else if (settingsRow_ != 8) {
                            ev.action = Action::SettingsChanged;
                            ev.settings = settings_;
                        }
                        return ev;
                    }
                }
            } else {
                dropdownOpen_ = false;
                dirty_ = true;
                return ev;
            }
        }
        constexpr int kRowW = 1140, kRowH = 30, kGap = 2, kGroupGap = 4;
        int curY = 184;
        for (const auto& [i, groupStart] : visibleSettingsRows(caps_)) {
            if (groupStart) curY += kGroupGap;
            if (x >= kMargin && x < kMargin + kRowW && y >= curY && y < curY + kRowH) {
                settingsRow_ = i;
                if (i == 14) {
                    openPadTester();
                    return ev;
                } else if (i == 3 || i == 4 || i == 12) {
                    openTester(i == 3 ? Tester::Sticks : i == 4 ? Tester::Triggers : Tester::Keys);
                    return ev;
                } else if (i == 17) {
                    openTester(Tester::SignInCheck);
                    ev.action = Action::CheckSignIn;
                    return ev;
                } else if (i == 18) {
                    openTester(Tester::NetworkTest);
                    ev.action = Action::RunNetworkTest;
                    return ev;
                } else if (i == 24) {
                    if (!settings_.syncTrophies) {
                        trophyDisclaimerOpen_ = true;
                        trophyDisclaimerFocus_ = 0;
                    } else {
                        settings_.syncTrophies = false;
                        ev.action = Action::SettingsChanged;
                        ev.settings = settings_;
                    }
                    dirty_ = true;
                    return ev;
                } else if (i == 25) {
                    removeTrophiesConfirmOpen_ = true;
                    removeTrophiesFocus_ = 1;
                    dirty_ = true;
                    return ev;
                } else if (i == 19) {
                    openTester(Tester::Donation);
                    return ev;
                } else if (i == 7) {
                    if (!caps_.selfUpdate) {
                        if (caps_.openUrl) {
                            ev.action = Action::OpenUrl;
                            ev.url = kReleasesPage;
                        }
                    } else if (!updateAvailable_.empty() && !updateChecking_) {
                        ev.action = Action::UpdateNow;
                        ev.settings = settings_;
                    }
                    return ev;
                } else if (i == 10) {
                    int n = static_cast<int>(settingOptions(10).size());
                    if (n > 0) applySetting(10, (settingSelected(10) + 1) % n);
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                    dirty_ = true;
                    return ev;
                } else if (i == 23) {
                    return ev;
                } else if (i == 5) {
                    settings_.circleConfirms = !settings_.circleConfirms;
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                    dirty_ = true;
                    return ev;
                } else {
                    auto opts = settingOptions(i);
                    if (opts.size() > 2) {
                        dropdownOpen_ = true;
                        dropdownIndex_ = settingSelected(i);
                        dropdownTop_ = std::max(0, dropdownIndex_ - 4);
                        dirty_ = true;
                        return ev;
                    }
                    changeSetting(1);
                    if (i != 8) {
                        ev.action = Action::SettingsChanged;
                        ev.settings = settings_;
                    }
                    dirty_ = true;
                    return ev;
                }
            }
            curY += kRowH + kGap;
        }
    }
    return ev;
}

UiEvent AppUi::onMouseWheel(float dx, float dy) {
    std::lock_guard<std::mutex> lock(mutex_);
    UiEvent ev;
    mouseCursorVisible_ = true;
    mouseCursorVisibleUntil_ = platform::nowMs() + 3000;
    dirty_ = true;
    if (screen_ == Screen::Streaming || screen_ == Screen::Splash) {
        return ev;
    }
    if (screen_ == Screen::Home && updatePrompt_ && showingUpdateNotes_) {
        updateNotesScroll_ = std::clamp(updateNotesScroll_ - static_cast<int>(dy * 2), 0, updateNotesMaxScroll_);
        dirty_ = true;
        return ev;
    }
    if (screen_ == Screen::Home && !searching_ && !updatePrompt_ && !quitPrompt_ && !reportOpen_) {
        if (tab_ == Tab::Library) {
            const LibraryLayout& L = libraryLayout();
            float maxScroll = L.rowY.empty() ? 0.0f : static_cast<float>(std::max(0, L.rowY.back() + kGridPitchY - (kH - kLibraryTop)));
            gridScroll_.target = std::clamp(gridScroll_.target - dy * 140.0f, 0.0f, maxScroll);
            animating_ = true;
            dirty_ = true;
        } else if (tab_ == Tab::GamePass) {
            if (!rows_.empty()) {
                const GameRow& curRow = rows_[static_cast<size_t>(focusRow_)];
                if (curRow.isGrid) {
                    int totalRows = (static_cast<int>(curRow.tiles.size()) + kLibraryCols - 1) / kLibraryCols;
                    float maxScroll = std::max(0.0f, static_cast<float>(totalRows * kGridPitchY - (kH - kRowTop - 48)));
                    if (dy > 0 && rowScroll_[static_cast<size_t>(focusRow_)].target <= 0.0f) {
                        if (focusRow_ > 0) {
                            --focusRow_;
                            retarget();
                            animating_ = true;
                            dirty_ = true;
                        }
                    } else {
                        rowScroll_[static_cast<size_t>(focusRow_)].target =
                            std::clamp(rowScroll_[static_cast<size_t>(focusRow_)].target - dy * 140.0f, 0.0f, maxScroll);
                        animating_ = true;
                        dirty_ = true;
                    }
                } else {
                    if (std::abs(dy) > std::abs(dx)) {
                        int nextRow = std::clamp(static_cast<int>(rowY_.target - dy), 0, static_cast<int>(rows_.size()) - 1);
                        if (nextRow != focusRow_) {
                            focusRow_ = nextRow;
                            retarget();
                            animating_ = true;
                            dirty_ = true;
                        }
                    } else if (dx != 0.0f) {
                        float maxScroll = std::max(0.0f, static_cast<float>(static_cast<int>(curRow.tiles.size()) * kCardPitch - (kW - kMargin)));
                        rowScroll_[static_cast<size_t>(focusRow_)].target =
                            std::clamp(rowScroll_[static_cast<size_t>(focusRow_)].target - dx * 160.0f, 0.0f, maxScroll);
                        animating_ = true;
                        dirty_ = true;
                    }
                }
            }
        }
    } else if (screen_ == Screen::Details && achievementsOpen_) {
        achScroll_ = std::max(0, achScroll_ - static_cast<int>(dy * 3));
        dirty_ = true;
    }
    return ev;
}

UiEvent AppUi::handle(const NavInput& in) {
    std::lock_guard<std::mutex> lock(mutex_);
    UiEvent ev;
    if (screen_ == Screen::Splash) {
        return ev;
    }
    if (reportOpen_) {  // the report's QR code: Circle (or Cross) closes it
        if (in.accept && caps_.openUrl) {
            // A desktop: Cross opens the form in the browser (the panel stays).
            ev.action = Action::OpenUrl;
            ev.url = reportUrl_;
        } else if (in.back || in.accept) {
            reportOpen_ = false, dirty_ = true;
        }
        return ev;
    }
    if (screen_ == Screen::Home && updatePrompt_) {
        if (showingUpdateNotes_) {
            if (in.up) {
                if (updateNotesScroll_ > 0) {
                    --updateNotesScroll_;
                    dirty_ = true;
                }
            } else if (in.down) {
                if (updateNotesScroll_ < updateNotesMaxScroll_) {
                    ++updateNotesScroll_;
                    dirty_ = true;
                }
            } else if (in.l1 || in.l2) {
                if (updateNotesScroll_ > 0) {
                    updateNotesScroll_ = std::max(0, updateNotesScroll_ - 5);
                    dirty_ = true;
                }
            } else if (in.r1 || in.r2) {
                if (updateNotesScroll_ < updateNotesMaxScroll_) {
                    updateNotesScroll_ = std::min(updateNotesMaxScroll_, updateNotesScroll_ + 5);
                    dirty_ = true;
                }
            } else if (in.scrollRows != 0) {
                int next = std::clamp(updateNotesScroll_ + in.scrollRows, 0, updateNotesMaxScroll_);
                if (next != updateNotesScroll_) {
                    updateNotesScroll_ = next;
                    dirty_ = true;
                }
            } else if (in.back || in.accept || in.square) {
                showingUpdateNotes_ = false;
                dirty_ = true;
            }
            return ev;
        }
        // 3 buttons: 0 Update now, 1 What's new, 2 Not now
        if (in.square) {
            showingUpdateNotes_ = true;
            updateNotesScroll_ = 0;
            formatUpdateNotes();
            dirty_ = true;
            return ev;
        }
        if (in.left) {
            promptFocus_ = (promptFocus_ + 2) % 3;
            dirty_ = true;
        } else if (in.right) {
            promptFocus_ = (promptFocus_ + 1) % 3;
            dirty_ = true;
        }
        if (in.accept) {
            if (promptFocus_ == 0) {
                ev.action = Action::UpdateNow;
                updatePrompt_ = false;
                dirty_ = true;
            } else if (promptFocus_ == 1) {
                showingUpdateNotes_ = true;
                updateNotesScroll_ = 0;
                formatUpdateNotes();
                dirty_ = true;
            } else {
                ev.action = Action::UpdateLater;
                updatePrompt_ = false;
                dirty_ = true;
            }
        } else if (in.back) {
            ev.action = Action::UpdateLater;
            updatePrompt_ = false;
            dirty_ = true;
        }
        return ev;
    }
    if (countryPickerOpen_) {
        // "Sign in as another country": up / down, Cross signs in as the
        // one chosen, Circle closes it unchanged.
        int n = 1 + static_cast<int>(std::size(kLoginCountries));
        if (in.down && countryIndex_ + 1 < n) ++countryIndex_, dirty_ = true;
        if (in.up && countryIndex_ > 0) --countryIndex_, dirty_ = true;
        if (in.accept) {
            settings_.loginCountry = countryIndex_ ? kLoginCountries[countryIndex_ - 1] : "";
            ev.action = Action::LoginCountry;
            ev.settings = settings_;
        }
        if (in.accept || in.back) countryPickerOpen_ = false, dirty_ = true;
        return ev;
    }
    switch (screen_) {
        case Screen::Home:
            if (quitPrompt_) {  // two buttons, Close / Cancel: left / right picks, Cross presses, Circle cancels
                if (in.left || in.right) promptFocus_ = in.left ? 0 : 1, dirty_ = true;
                if (in.accept && promptFocus_ == 0) ev.action = Action::Quit;
                if (in.accept || in.back) quitPrompt_ = false, dirty_ = true;
                break;
            }
            // A desktop window has no system menu to close it from (fullscreen,
            // a controller in hand): Circle / Esc at the top of the home screen
            // asks. On the PS5 the system closes the app; Circle does nothing here.
            if (caps_.desktopWindow && in.back && !searching_) {
                quitPrompt_ = true;
                promptFocus_ = 1;  // Cancel first: a second Circle / Esc never closes by accident
                dirty_ = true;
                break;
            }
            handleHome(in, ev);
            break;
        case Screen::SignIn:
            // A desktop: Cross (Enter) opens the sign-in page in the browser.
            if (in.accept && caps_.openUrl) {
                ev.action = Action::OpenUrl;
                ev.url = codeUrl_.empty() ? "https://www.microsoft.com/link" : codeUrl_;
            }
            break;
        case Screen::Settings:
            if (trophyDisclaimerOpen_) {
                if (in.left || in.right) {
                    trophyDisclaimerFocus_ ^= 1;
                    dirty_ = true;
                } else if (in.back) {
                    trophyDisclaimerOpen_ = false;
                    dirty_ = true;
                } else if (in.accept) {
                    if (trophyDisclaimerFocus_ == 0) {
                        settings_.syncTrophies = true;
                        trophyDisclaimerOpen_ = false;
                        dirty_ = true;
                        ev.action = Action::SyncTrophies;
                        ev.settings = settings_;
                    } else {
                        trophyDisclaimerOpen_ = false;
                        dirty_ = true;
                    }
                }
                break;
            }
            if (removeTrophiesConfirmOpen_) {
                if (in.left || in.right) {
                    removeTrophiesFocus_ ^= 1;
                    dirty_ = true;
                } else if (in.back) {
                    removeTrophiesConfirmOpen_ = false;
                    dirty_ = true;
                } else if (in.accept) {
                    if (removeTrophiesFocus_ == 0) {
                        settings_.syncTrophies = false;
                        removeTrophiesConfirmOpen_ = false;
                        dirty_ = true;
                        ev.action = Action::RemoveTrophies;
                        ev.settings = settings_;
                    } else {
                        removeTrophiesConfirmOpen_ = false;
                        dirty_ = true;
                    }
                }
                break;
            }
            if (pickerOpen_) {
                handleColourPicker(in);
                if (!pickerOpen_ && in.accept) {
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                }
                break;
            }
            if (tester_ == Tester::SignInCheck) {
                if (in.back) {
                    tester_ = Tester::None;
                    dirty_ = true;
                } else if (in.accept && !signInCheck_.running) {
                    signInCheck_.running = true;
                    signInCheck_.stages = {
                        {"1. Account Storage", false, true, "Checking..."},
                        {"2. Microsoft OAuth (MSA)", false, true, "Waiting..."},
                        {"3. Xbox Live User Token", false, true, "Waiting..."},
                        {"4. XSTS Security Token", false, true, "Waiting..."},
                        {"5. xCloud Offering (xgpuweb)", false, true, "Waiting..."},
                        {"6. Recursos Preview (xCloud & Ads)", false, true, "Waiting..."},
                    };
                    dirty_ = true;
                    ev.action = Action::CheckSignIn;
                }
                break;
            }
            if (tester_ == Tester::NetworkTest) {
                if (in.back) {
                    tester_ = Tester::None;
                    dirty_ = true;
                } else if (in.accept && !networkTest_.running) {
                    networkTest_.running = true;
                    networkTest_.natStatus = "Probing UDP STUN...";
                    for (auto& reg : networkTest_.regions) {
                        reg.rttMs = -1;
                        reg.jitterMs = -1;
                    }
                    dirty_ = true;
                    ev.action = Action::RunNetworkTest;
                }
                break;
            }
            if (tester_ == Tester::Donation) {
                if (in.back || in.accept) {
                    tester_ = Tester::None;
                    dirty_ = true;
                }
                break;
            }
            if (tester_ != Tester::None) {
                handleTester(in);
                if (tester_ == Tester::None) {
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                }
                break;
            }
            if (dropdownOpen_) {
                // The list: up / down, Cross picks, Circle closes it unchanged.
                int n = static_cast<int>(settingOptions(settingsRow_).size());
                if (in.down && dropdownIndex_ + 1 < n) ++dropdownIndex_;
                if (in.up && dropdownIndex_ > 0) --dropdownIndex_;
                int before = settingSelected(settingsRow_);
                if (in.accept) applySetting(settingsRow_, dropdownIndex_);
                if (in.accept || in.back) dropdownOpen_ = false;
                if (in.accept && settingsRow_ == 6 && dropdownIndex_ == 1) {
                    openColourPicker(before);
                } else if (in.accept && settingsRow_ != 8) {
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                }
                dirty_ = true;
                break;
            }
            if (auto rows = visibleSettingsRows(caps_); true) {  // the rows on screen, in their order
                int pos = posOf(rows, settingsRow_);
                if (in.down && pos + 1 < static_cast<int>(rows.size())) {
                    settingsRow_ = rows[static_cast<size_t>(pos + 1)].row;
                    resetSettingsHoldStart_ = 0;
                    dirty_ = true;
                } else if (in.up && pos > 0) {
                    settingsRow_ = rows[static_cast<size_t>(pos - 1)].row;
                    resetSettingsHoldStart_ = 0;
                    dirty_ = true;
                }
            }
            if (settingsRow_ == 23) {
                if (in.acceptHeld) {
                    if (!resetSettingsHoldStart_) resetSettingsHoldStart_ = in.nowMs ? in.nowMs : 1;
                    if (in.nowMs - resetSettingsHoldStart_ >= 5000) {
                        ev.action = Action::ResetSettings;
                        resetSettingsHoldStart_ = 0;
                    }
                    animating_ = true;
                    dirty_ = true;
                } else if (resetSettingsHoldStart_) {
                    resetSettingsHoldStart_ = 0;
                    dirty_ = true;
                }
            } else {
                resetSettingsHoldStart_ = 0;
            }
            if (in.right && settingsRow_ != 23 && settingsRow_ != 25) {
                changeSetting(+1);
                if (settingsRow_ != 8) {
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                }
            }
            if (in.left && settingsRow_ != 23 && settingsRow_ != 25) {
                changeSetting(-1);
                if (settingsRow_ != 8) {
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                }
            }
            if (in.square && settingsRow_ == 16) {
                ev.action = Action::TestQueueAlert;
            }
            if (in.square && settingsRow_ == 24) {
                if (trophySyncing_) {
                    // Sync already in progress; ignore repeated triggers
                } else if (settings_.syncTrophies) {
                    ev.action = Action::SyncTrophies;
                    ev.settings = settings_;
                } else {
                    trophyDisclaimerOpen_ = true;
                    trophyDisclaimerFocus_ = 0;
                    dirty_ = true;
                }
            }
            if (in.accept && settingsRow_ == 14) {
                openPadTester();  // controller buttons: their own screen
            } else if (in.accept && (settingsRow_ == 3 || settingsRow_ == 4 || settingsRow_ == 12)) {
                // Dead zone, trigger vibration, keyboard keys: their own screens instead of a list.
                openTester(settingsRow_ == 3 ? Tester::Sticks : settingsRow_ == 4 ? Tester::Triggers : Tester::Keys);
            } else if (in.accept && settingsRow_ == 17) {
                openTester(Tester::SignInCheck);
                ev.action = Action::CheckSignIn;
            } else if (in.accept && settingsRow_ == 18) {
                openTester(Tester::NetworkTest);
                ev.action = Action::RunNetworkTest;
            } else if (in.accept && settingsRow_ == 24) {
                if (!settings_.syncTrophies) {
                    trophyDisclaimerOpen_ = true;
                    trophyDisclaimerFocus_ = 0;
                    dirty_ = true;
                } else {
                    settings_.syncTrophies = false;
                    dirty_ = true;
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                }
            } else if (in.accept && settingsRow_ == 25) {
                removeTrophiesConfirmOpen_ = true;
                removeTrophiesFocus_ = 1;
                dirty_ = true;
            } else if (in.accept && settingsRow_ == 19) {
                openTester(Tester::Donation);
            } else if (in.accept && settingsRow_ == 7) {
                // Updates: a newer version is installed (the settings saved
                // first). Where the app doesn't install it, the release's
                // page opens in the browser instead.
                if (!caps_.selfUpdate) {
                    if (caps_.openUrl) {
                        ev.action = Action::OpenUrl;
                        ev.url = kReleasesPage;
                    }
                } else if (!updateAvailable_.empty() && !updateChecking_) {
                    ev.action = Action::UpdateNow;
                    ev.settings = settings_;
                }
            } else if (in.accept && settingsRow_ == 10) {
                // Inline bitrate slider: cycles to next option, no dropdown modal
                int n = static_cast<int>(settingOptions(10).size());
                if (n > 0) {
                    applySetting(10, (settingSelected(10) + 1) % n);
                    ev.action = Action::SettingsChanged;
                    ev.settings = settings_;
                    dirty_ = true;
                }
            } else if (in.accept && settingsRow_ == 23) {
                // Handled via hold
            } else if (in.accept) {
                dropdownOpen_ = true;
                dropdownIndex_ = settingSelected(settingsRow_);
                dropdownTop_ = 0;
                dirty_ = true;
            }
            if (in.back || in.options) {
                resetSettingsHoldStart_ = 0;
                // Back where Settings was opened. A new sign-in country
                // takes a new sign-in.
                screen_ = settingsFromError_ ? Screen::Error : Screen::Home;
                dirty_ = true;
                ev.action = settings_.loginCountry != settingsCountry_ ? Action::LoginCountry : Action::SettingsChanged;
                ev.settings = settings_;
            } else if (in.triangle) {
                ev.action = Action::Report;  // "Report a problem"
            }
            break;
        case Screen::Details:
            if (achievementsOpen_) {
                if (in.up && achScroll_ > 0) {
                    achScroll_--;
                    dirty_ = true;
                }
                int maxScroll = 0;
                if (auto it = achievements_.find(detail_.xboxTitleId); it != achievements_.end()) {
                    maxScroll = std::max(0, static_cast<int>(it->second.items.size()) - 5);
                }
                if (in.down && achScroll_ < maxScroll) {
                    achScroll_++;
                    dirty_ = true;
                }
                if (in.back || in.l3) {
                    achievementsOpen_ = false;
                    dirty_ = true;
                }
                break;
            }
            if (gameSettingsOpen_) {
                handleGameSettings(in, ev);
                break;
            }
            if (in.options) {
                openGameSettings();
                dirty_ = true;
                break;
            }
            {
                bool isF2P = isFreeGame(detail_);
                bool effectivePlayable = isEffectivePlayableLocked(detail_);
                bool hasAchievements = effectivePlayable && !detail_.xboxTitleId.empty();
                if (!hasAchievements && detailButtonFocus_ == 1) {
                    detailButtonFocus_ = 0;
                }
                if (in.right && hasAchievements && detailButtonFocus_ == 0) {
                    detailButtonFocus_ = 1;
                    dirty_ = true;
                } else if (in.left && detailButtonFocus_ == 1) {
                    detailButtonFocus_ = 0;
                    dirty_ = true;
                }
                if (in.accept) {
                    if (detailButtonFocus_ == 1 && hasAchievements) {
                        openAchievements();
                    } else if (!effectivePlayable && isF2P && !detail_.playable) {
                        ev.action = Action::ClaimFreeGame;
                        ev.game = detail_;
                        ev.game.freeInStore = true;
                    } else if (effectivePlayable) {
                        ev.action = Action::Play;
                        ev.game = detail_;
                    }
                }
            }
            if (in.square) toggleHidden(detail_, ev);  // the page stays open
            if (in.triangle) toggleFavorite(detail_, ev);
            if (in.r3 && !isAcquired(detail_)) toggleWishlist(detail_, ev);
            if (in.l3 && !detail_.xboxTitleId.empty()) openAchievements();
            if (in.back) {
                syncHeroToRowsLocked(detail_.productId, detail_.titleId, detail_.heroUrl, detail_.description, detail_.publisher, detail_.categories);
                screen_ = Screen::Home;
                dirty_ = true;
            }
            break;
        case Screen::Launching:
            if (in.back) ev.action = Action::CancelLaunch;
            break;
        case Screen::Error:
            if (!errorGame_.titleId.empty() || !errorGame_.productId.empty()) {
                if (in.accept) {
                    if ((isFreeGame(errorGame_) || errorGame_.freeInStore) && !errorGame_.playable) {
                        ev.action = Action::ClaimFreeGame;
                        ev.game = errorGame_;
                        ev.game.freeInStore = true;
                    } else if (errorGame_.playable && !errorGame_.titleId.empty()) {
                        ev.action = Action::Play;
                        ev.game = errorGame_;
                    } else {
                        openDetails(errorGame_);
                    }
                } else if (in.back && errorGame_.homeConsole) {
                    screen_ = Screen::Home;  // back to My consoles
                    tab_ = Tab::Consoles;
                    dirty_ = true;
                } else if (in.back) {
                    openDetails(errorGame_);
                }
            } else if (in.accept) {
                ev.action = Action::Retry;
            } else if ((in.square || in.back) && !regionRefused_ && (!rows_.empty() || !owned_.empty())) {
                screen_ = Screen::Home;
                loading_ = false;
                dirty_ = true;
            }
            if (regionRefused_ && in.square) {
                countryPickerOpen_ = true;
                countryIndex_ = settingSelected(8);
                dirty_ = true;
            } else if (regionRefused_ && in.options) {  // Settings, on the sign-in country
                screen_ = Screen::Settings;
                settingsRow_ = 8;
                settingsFromError_ = true;
                settingsCountry_ = settings_.loginCountry;
                dropdownOpen_ = false;
                dirty_ = true;
            }
            if (in.triangle) {  // "Report a problem", with the error shown
                ev.action = Action::Report;
                ev.reportWhat = error_;
            }
            break;
        default: break;
    }
    // Sign out: hold TOUCHPAD for 5 s on the home or error screen.
    bool canSignOut = screen_ == Screen::Home || screen_ == Screen::Error;
    if (canSignOut && in.touchpad && !signOutLatched_) {
        if (!signOutHoldStart_) signOutHoldStart_ = in.nowMs ? in.nowMs : 1;
        if (in.nowMs - signOutHoldStart_ >= kSignOutHoldMs) {
            ev.action = Action::SignOut;
            signOutHoldStart_ = 0;
            signOutLatched_ = true;
        }
        dirty_ = true;
    } else if (!in.touchpad || !canSignOut) {
        if (signOutHoldStart_) dirty_ = true;
        signOutHoldStart_ = 0;
        if (!in.touchpad) signOutLatched_ = false;
    }
    if (displayModeChanged_) {
        // A desktop's display mode applies (and is saved) as it is picked,
        // not when Settings closes.
        displayModeChanged_ = false;
        if (ev.action == Action::None) {
            ev.action = Action::SettingsChanged;
            ev.settings = settings_;
        }
    }
    return ev;
}

// --- Rendering -----------------------------------------------------------------

}  // namespace xc::ui