Bump version to 5.4.0

dist/better-xcloud.meta.js

@@ -1,5 +1,5 @@
 // ==UserScript==
 // @name         Better xCloud
 // @namespace    https://github.com/redphx
-// @version      5.3.0
+// @version      5.4.0
 // ==/UserScript==

src/assets/css/button.styl

@@ -83,24 +83,24 @@
         overflow: hidden;
         white-space: nowrap;
     }
+}
 
-    &.bx-focusable {
+.bx-focusable {
-        position: relative;
+    position: relative;
 
-        &::after {
+    &::after {
-            border: 2px solid transparent;
+        border: 2px solid transparent;
-            border-radius: 4px;
+        border-radius: 4px;
-        }
+    }
 
-        &:focus::after {
+    &:focus::after {
-            content: '';
+        content: '';
-            border-color: white;
+        border-color: white;
-            position: absolute;
+        position: absolute;
-            top: 0;
+        top: 0;
-            left: 0;
+        left: 0;
-            right: 0;
+        right: 0;
-            bottom: 0;
+        bottom: 0;
-        }
     }
 }
 
@@ -111,3 +111,9 @@ a.bx-button {
         text-align: center;
     }
 }
+
+button.bx-inactive {
+    pointer-events: none;
+    opacity: 0.2;
+    background: transparent !important;
+}

src/assets/css/global-settings.styl

@@ -17,11 +17,13 @@
 }
 
 .bx-settings-wrapper {
-    width: 450px;
+    min-width: 450px;
+    max-width: 600px;
     margin: auto;
     padding: 12px 6px;
 
     @media screen and (max-width: 450px) {
+        min-width: unset;
         width: 100%;
     }
 
@@ -100,9 +102,14 @@
     position: relative;
 
     label {
-        flex: 1;
         align-self: center;
-        margin-bottom: 0;
+        margin: 0 4px 0;
+    }
+
+    .bx-setting-control {
+        flex: 1;
+        display: flex;
+        justify-content: right;
     }
 
 
@@ -129,14 +136,19 @@
         }
     }
 
-    input[type=checkbox], select {
+    input[type=checkbox] {
+        cursor: pointer;
+    }
+
+    input[type=checkbox],
+    select {
         &:focus {
             filter: drop-shadow(1px 0 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 1px 0 #fff) drop-shadow(0 -1px 0 #fff);
         }
     }
 
 
-    &:has(input:focus), &:has(select:focus) {
+    &:has(input:focus), &:has(select:focus), &:has(button:focus) {
         &::before {
             content: ' ';
             border-radius: 4px;

src/assets/css/number-stepper.styl

@@ -5,14 +5,15 @@
         display: inline-block;
         min-width: 40px;
         font-family: var(--bx-monospaced-font);
-        font-size: 14px;
+        font-size: 12px;
+        margin: 0 4px;
     }
 
     button {
         border: none;
         width: 24px;
         height: 24px;
-        margin: 0 4px;
+        margin: 0;
         line-height: 24px;
         background-color: var(--bx-default-button-color);
         color: #fff;

src/assets/css/root.styl

@@ -105,6 +105,10 @@ div[class^=HUDButton-module__hiddenContainer] ~ div:not([class^=HUDButton-module
     font-family: var(--bx-promptfont-font);
 }
 
+.bx-line-through {
+    text-decoration: line-through
+}
+
 select[multiple] {
     overflow: auto;
 }

src/assets/css/stream-settings.styl

@@ -49,6 +49,11 @@
             background: #2f2f2f;
             border-color: #484848;
         }
+
+        &:focus {
+            border-color: #fff;
+            outline: none;
+        }
     }
 }
 
@@ -70,13 +75,14 @@
     box-shadow: 0px 0px 6px #000;
     overflow: overlay;
 
-    > div[data-group=mkb] {
+    > div[data-tab-group=mkb] {
         display: flex;
         flex-direction: column;
         height: 100%;
         overflow: hidden;
     }
 
+    &:focus,
     *:focus {
         outline: none !important;
     }
@@ -106,8 +112,23 @@
 .bx-stream-settings-row {
     display: flex;
     border-bottom: 1px solid #40404080;
-    margin-bottom: 16px;
+    padding: 16px 8px;
-    padding-bottom: 16px;
+    border-left: 2px solid transparent;
+
+    &:hover, &:focus-within {
+        background-color: #242424;
+    }
+
+    input[type=checkbox],
+    select {
+        &:focus {
+            filter: drop-shadow(1px 0 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 1px 0 #fff) drop-shadow(0 -1px 0 #fff);
+        }
+    }
+
+    &:has(input:focus), &:has(select:focus), &:has(button:focus) {
+        border-left-color: white;
+    }
 
     > label {
         font-size: 16px;
@@ -120,6 +141,10 @@
 
     input {
         accent-color: var(--bx-primary-button-color);
+
+        &:focus {
+            accent-color: var(--bx-danger-button-color);
+        }
     }
 
     select:disabled {
@@ -143,7 +168,7 @@
 }
 
 .bx-stream-settings-tab-contents {
-    div[data-group="shortcuts"] {
+    div[data-tab-group="shortcuts"] {
         > div {
             &[data-has-gamepad=true] {
                 > div:first-of-type {
@@ -170,10 +195,10 @@
             width: 100%;
             height: 36px;
             display: block;
-            margin-bottom: 10px;
         }
 
         .bx-shortcut-note {
+            margin-top: 10px;
             font-size: 14px;
         }
 

src/assets/css/web-components.styl

@@ -1,19 +1,27 @@
 .bx-select {
+    display: flex;
+    align-items: center;
+    flex: 0 1 auto;
+
     select {
-        display: none;
+        display: none !important;
     }
 
-    > div {
+    > div, button.bx-select-value {
-        display: inline-block;
         min-width: 110px;
         text-align: center;
-        margin: 0 10px;
+        margin: 0 8px;
         line-height: 24px;
         vertical-align: middle;
         background: #fff;
         color: #000;
         border-radius: 4px;
-        padding: 2px 4px;
+        padding: 2px 8px;
+        flex: 1;
+    }
+
+    > div {
+        display: inline-block;
 
         input {
             display: inline-block;
@@ -22,25 +30,62 @@
 
         label {
             margin-bottom: 0;
+            font-size: 14px;
+            width: 100%;
+
+            span {
+                display: block;
+                font-size: 10px;
+                font-weight: bold;
+                text-align: left;
+                line-height: initial;
+            }
         }
     }
 
-    button {
+    button.bx-select-value {
+        border: none;
+        display: inline-flex;
+        cursor: pointer;
+        min-height: 30px;
+        font-size: 0.9rem;
+        align-items: center;
+
+        span {
+            flex: 1;
+            text-align: center;
+            display: inline-block;
+        }
+
+        input {
+            margin: 0 4px;
+            accent-color: var(--bx-primary-button-color);
+        }
+
+        &:hover,
+        &:focus {
+            input {
+                accent-color: var(--bx-danger-button-color);
+            }
+
+            &::after {
+                border-color: #4d4d4d !important;
+            }
+        }
+    }
+
+    button.bx-button {
         border: none;
-        width: 24px;
         height: 24px;
+        width: 24px;
+        padding: 0;
         line-height: 24px;
         color: #fff;
         border-radius: 4px;
         font-weight: bold;
-        font-size: 14px;
+        font-size: 12px;
         font-family: var(--bx-monospaced-font);
 
-        &.bx-inactive {
-            pointer-events: none;
-            opacity: 0.2;
-        }
-
         span {
             line-height: unset;
         }

src/enums/bypass-servers.ts

@@ -0,0 +1,13 @@
+export const BypassServers = {
+    'br': 'Brazil',
+    'jp': 'Japan',
+    'pl': 'Poland',
+    'us': 'United States',
+}
+
+export const BypassServerIps = {
+    'br': '169.150.198.66',
+    'jp': '138.199.21.239',
+    'pl': '45.134.212.66',
+    'us': '143.244.47.65',
+}

src/index.ts

@@ -92,8 +92,8 @@ if (BX_FLAGS.SafariWorkaround && document.readyState !== 'loading') {
     throw new Error('[Better xCloud] Executing workaround for Safari');
 }
 
-// Automatically reload the page when running into the "We are sorry..." error message
 window.addEventListener('load', e => {
+    // Automatically reload the page when running into the "We are sorry..." error message
     window.setTimeout(() => {
         if (document.body.classList.contains('legacyBackground')) {
             // Has error message -> reload page
@@ -102,18 +102,29 @@ window.addEventListener('load', e => {
             window.location.reload(true);
         }
     }, 3000);
-
 });
 
-// Hide "Play with Friends" skeleton section
+document.addEventListener('readystatechange', e => {
-if (getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.FRIENDS)) {
+    if (document.readyState !== 'interactive') {
-    document.addEventListener('readystatechange', e => {
+        return;
-        if (document.readyState === 'interactive') {
+    }
-            const $parent = document.querySelector('div[class*=PlayWithFriendsSkeleton]')?.closest('div[class*=HomePage-module]') as HTMLElement;
+
-            $parent && ($parent.style.display = 'none');
+    STATES.isSignedIn = (window as any).xbcUser.isSignedIn;
-        }
+
-    })
+    if (STATES.isSignedIn) {
-}
+        // Preload Remote Play
+        getPref(PrefKey.REMOTE_PLAY_ENABLED) && BX_FLAGS.PreloadRemotePlay && RemotePlay.preload();
+    } else {
+        // Show Settings button in the header when not signed
+        HeaderSection.watchHeader();
+    }
+
+    // Hide "Play with Friends" skeleton section
+    if (getPref(PrefKey.UI_HIDE_SECTIONS).includes(UiSection.FRIENDS)) {
+        const $parent = document.querySelector('div[class*=PlayWithFriendsSkeleton]')?.closest('div[class*=HomePage-module]') as HTMLElement;
+        $parent && ($parent.style.display = 'none');
+    }
+})
 
 window.BX_EXPOSED = BxExposed;
 
@@ -342,9 +353,6 @@ function main() {
         BxLogger.info('startPointerServer', 'Port', STATES.pointerServerPort.toString());
     }
 
-    // Preload Remote Play
-    getPref(PrefKey.REMOTE_PLAY_ENABLED) && BX_FLAGS.PreloadRemotePlay && RemotePlay.preload();
-
     // Show wait time in game card
     getPref(PrefKey.UI_GAME_CARD_SHOW_WAIT_TIME) && GameTile.setup();
 }

src/modules/controller-shortcut.ts

@@ -11,6 +11,7 @@ import { PrefKey, getPref } from "@utils/preferences";
 import { SoundShortcut } from "./shortcuts/shortcut-sound";
 import { BxEvent } from "@/utils/bx-event";
 import { AppInterface } from "@/utils/global";
+import { BxSelectElement } from "@/web-components/bx-select";
 
 enum ShortcutAction {
     STREAM_SCREENSHOT_CAPTURE = 'stream-screenshot-capture',
@@ -211,6 +212,8 @@ export class ControllerShortcut {
     }
 
     static renderSettings() {
+        const PREF_CONTROLLER_FRIENDLY_UI = getPref(PrefKey.UI_CONTROLLER_FRIENDLY);
+
         // Read actions from localStorage
         ControllerShortcut.#ACTIONS = JSON.parse(window.localStorage.getItem(ControllerShortcut.#STORAGE_KEY) || '{}');
 
@@ -287,23 +290,23 @@ export class ControllerShortcut {
         }
 
         let $remap: HTMLElement;
-        let $selectProfile: HTMLSelectElement;
+        const $selectProfile = CE<HTMLSelectElement>('select', {class: 'bx-shortcut-profile', autocomplete: 'off'});
 
         const $container = CE('div', {'data-has-gamepad': 'false'},
             CE('div', {},
-                CE('p', {'class': 'bx-shortcut-note'}, t('controller-shortcuts-connect-note')),
+                CE('p', {class: 'bx-shortcut-note'}, t('controller-shortcuts-connect-note')),
             ),
 
             $remap = CE('div', {},
-                $selectProfile = CE('select', {'class': 'bx-shortcut-profile', autocomplete: 'off'}),
+                PREF_CONTROLLER_FRIENDLY_UI ? CE('div', {'data-focus-container': 'true'}, BxSelectElement.wrap($selectProfile)) : $selectProfile,
-                CE('p', {'class': 'bx-shortcut-note'},
+                CE('p', {class: 'bx-shortcut-note'},
-                    CE('span', {'class': 'bx-prompt'}, PrompFont.HOME),
+                    CE('span', {class: 'bx-prompt'}, PrompFont.HOME),
                     ': ' + t('controller-shortcuts-xbox-note'),
                 ),
             ),
         );
 
-        $selectProfile.addEventListener('change', e => {
+        $selectProfile.addEventListener('input', e => {
             ControllerShortcut.#switchProfile($selectProfile.value);
         });
 
@@ -314,38 +317,51 @@ export class ControllerShortcut {
             const button: unknown = $target.dataset.button;
             const action = $target.value as ShortcutAction;
 
-            const $fakeSelect = $target.previousElementSibling! as HTMLSelectElement;
+            if (!PREF_CONTROLLER_FRIENDLY_UI) {
-            let fakeText = '---';
+                const $fakeSelect = $target.previousElementSibling! as HTMLSelectElement;
-            if (action) {
+                let fakeText = '---';
-                const $selectedOption =  $target.options[$target.selectedIndex];
+                if (action) {
-                const $optGroup = $selectedOption.parentElement as HTMLOptGroupElement;
+                    const $selectedOption =  $target.options[$target.selectedIndex];
-                fakeText = $optGroup.label + ' ❯ ' + $selectedOption.text;
+                    const $optGroup = $selectedOption.parentElement as HTMLOptGroupElement;
+                    fakeText = $optGroup.label + ' ❯ ' + $selectedOption.text;
+                }
+                ($fakeSelect.firstElementChild as HTMLOptionElement).text = fakeText;
             }
-            ($fakeSelect.firstElementChild as HTMLOptionElement).text = fakeText;
 
             !(e as any).ignoreOnChange && ControllerShortcut.#updateAction(profile, button as GamepadKey, action);
         };
 
+
         // @ts-ignore
         for (const [button, prompt] of buttons) {
-            const $row = CE('div', {'class': 'bx-shortcut-row'});
+            const $row = CE('div', {
+                class: 'bx-shortcut-row',
+                'data-focus-container': 'true',
+            });
 
-            const $label = CE('label', {'class': 'bx-prompt'}, `${PrompFont.HOME} + ${prompt}`);
+            const $label = CE('label', {class: 'bx-prompt'}, `${PrompFont.HOME} + ${prompt}`);
 
-            const $div = CE('div', {'class': 'bx-shortcut-actions'});
+            const $div = CE('div', {class: 'bx-shortcut-actions'});
 
-            const $fakeSelect = CE<HTMLSelectElement>('select', {autocomplete: 'off'},
+            if (!PREF_CONTROLLER_FRIENDLY_UI) {
-                CE('option', {}, '---'),
+                const $fakeSelect = CE<HTMLSelectElement>('select', {autocomplete: 'off'},
-            );
+                    CE('option', {}, '---'),
-            $div.appendChild($fakeSelect);
+                );
+
+                $div.appendChild($fakeSelect);
+            }
 
             const $select = $baseSelect.cloneNode(true) as HTMLSelectElement;
             $select.dataset.button = button.toString();
-            $select.addEventListener('change', onActionChanged);
+            $select.addEventListener('input', onActionChanged);
 
             ControllerShortcut.#$selectActions[button] = $select;
 
-            $div.appendChild($select);
+            if (PREF_CONTROLLER_FRIENDLY_UI) {
+                $div.appendChild(BxSelectElement.wrap($select));
+            } else {
+                $div.appendChild($select);
+            }
 
             $row.appendChild($label);
             $row.appendChild($div);

src/modules/patcher.ts

@@ -452,6 +452,17 @@ BxEvent.dispatch(window, BxEvent.XCLOUD_POLLING_MODE_CHANGED, {mode: e});
         return str;
     },
 
+    patchGamepadPolling(str: string) {
+        let index = str.indexOf('.shouldHandleGamepadInput)())return void');
+        if (index === -1) {
+            return false;
+        }
+
+        index = str.indexOf('{', index - 20) + 1;
+        str = str.substring(0, index) + 'if (window.BX_EXPOSED.disableGamepadPolling) return;' + str.substring(index);
+        return str;
+    },
+
     patchXcloudTitleInfo(str: string) {
         const text = 'async cloudConnect';
         let index = str.indexOf(text);
@@ -803,6 +814,7 @@ let PATCH_ORDERS: PatchArray = [
     'disableStreamGate',
     'overrideSettings',
     'broadcastPollingMode',
+    'patchGamepadPolling',
 
     'exposeStreamSession',
     'exposeDialogRoutes',

src/modules/patches/controller-shortcuts.js

@@ -1,3 +1,8 @@
+if (window.BX_EXPOSED.disableGamepadPolling) {
+    this.inputConfiguration.useIntervalWorkerThreadForInput && this.intervalWorker ? this.intervalWorker.scheduleTimer(50) : this.pollGamepadssetTimeoutTimerID = setTimeout(this.pollGamepads, 50);
+    return;
+}
+
 const currentGamepad = ${gamepadVar};
 
 // Share button on XS controller

src/modules/stream-player.ts

@@ -68,7 +68,7 @@ export class StreamPlayer {
         const filters = [];
 
         const sharpness = this.#options.sharpness || 0;
-        if (sharpness != 0) {
+        if (this.#options.processing === StreamVideoProcessing.USM && sharpness != 0) {
             const level = (7 - ((sharpness / 2) - 1) * 0.5).toFixed(1); // 5, 5.5, 6, 6.5, 7
             const matrix = `0 -1 0 -1 ${level} -1 0 -1 0`;
             this.#$usmMatrix?.setAttributeNS(null, 'kernelMatrix', matrix);

src/modules/stream/stream-settings.ts

@@ -11,9 +11,23 @@ import { SoundShortcut } from "../shortcuts/shortcut-sound";
 import { TouchController } from "../touch-controller";
 import { VibrationManager } from "../vibration-manager";
 import { StreamStats } from "./stream-stats";
-import { BX_FLAGS } from "@/utils/bx-flags";
 import { BxSelectElement } from "@/web-components/bx-select";
 import { onChangeVideoPlayerType, updateVideoPlayer } from "./stream-settings-utils";
+import { GamepadKey } from "@/enums/mkb";
+import { EmulatedMkbHandler } from "../mkb/mkb-handler";
+
+enum NavigationDirection {
+    UP = 1,
+    RIGHT,
+    DOWN,
+    LEFT,
+}
+
+enum FocusContainer {
+    OUTSIDE,
+    TABS,
+    SETTINGS,
+}
 
 export class StreamSettings {
     private static instance: StreamSettings;
@@ -26,7 +40,38 @@ export class StreamSettings {
         return StreamSettings.instance;
     }
 
+    static readonly MAIN_CLASS = 'bx-stream-settings-dialog';
+
+    private static readonly GAMEPAD_POLLING_INTERVAL = 50;
+    private static readonly GAMEPAD_KEYS = [
+        GamepadKey.UP,
+        GamepadKey.DOWN,
+        GamepadKey.LEFT,
+        GamepadKey.RIGHT,
+        GamepadKey.A,
+        GamepadKey.B,
+        GamepadKey.LB,
+        GamepadKey.RB,
+    ];
+
+    private static readonly GAMEPAD_DIRECTION_MAP = {
+        [GamepadKey.UP]: NavigationDirection.UP,
+        [GamepadKey.DOWN]: NavigationDirection.DOWN,
+        [GamepadKey.LEFT]: NavigationDirection.LEFT,
+        [GamepadKey.RIGHT]: NavigationDirection.RIGHT,
+
+        [GamepadKey.LS_UP]: NavigationDirection.UP,
+        [GamepadKey.LS_DOWN]: NavigationDirection.DOWN,
+        [GamepadKey.LS_LEFT]: NavigationDirection.LEFT,
+        [GamepadKey.LS_RIGHT]: NavigationDirection.RIGHT,
+    };
+
+    private gamepadPollingIntervalId: number | null = null;
+    private gamepadLastButtons: Array<GamepadKey | null> = [];
+
     private $container: HTMLElement | undefined;
+    private $tabs: HTMLElement | undefined;
+    private $settings: HTMLElement | undefined;
     private $overlay: HTMLElement | undefined;
 
     readonly SETTINGS_UI = [{
@@ -245,44 +290,351 @@ export class StreamSettings {
         window.addEventListener(BxEvent.XCLOUD_GUIDE_MENU_SHOWN, e => this.hide());
     }
 
+    isShowing() {
+        return this.$container && !this.$container.classList.contains('bx-gone');
+    }
+
     show(tabId?: string) {
         const $container = this.$container!;
         // Select tab
         if (tabId) {
-            const $tab = $container.querySelector(`.bx-stream-settings-tabs svg[data-group=${tabId}]`);
+            const $tab = $container.querySelector(`.bx-stream-settings-tabs svg[data-tab-group=${tabId}]`);
             $tab && $tab.dispatchEvent(new Event('click'));
         }
 
+        // Show overlay
         this.$overlay!.classList.remove('bx-gone');
         this.$overlay!.dataset.isPlaying = STATES.isPlaying.toString();
 
+        // Show dialog
         $container.classList.remove('bx-gone');
+        // Lock scroll bar
         document.body.classList.add('bx-no-scroll');
 
+        // Focus the first visible setting
+        this.#focusDirection(NavigationDirection.DOWN);
+
+        // Add event listeners
+        $container.addEventListener('keydown', this);
+
+        // Start gamepad polling
+        this.#startGamepadPolling();
+
+        // Disable xCloud's navigation polling
+        (window as any).BX_EXPOSED.disableGamepadPolling = true;
+
         BxEvent.dispatch(window, BxEvent.XCLOUD_DIALOG_SHOWN);
     }
 
     hide() {
+        // Hide overlay
         this.$overlay!.classList.add('bx-gone');
+        // Hide dialog
         this.$container!.classList.add('bx-gone');
-
+        // Show scroll bar
         document.body.classList.remove('bx-no-scroll');
 
+        // Remove event listeners
+        this.$container!.removeEventListener('keydown', this);
+
+        // Stop gamepad polling();
+        this.#stopGamepadPolling();
+
+        // Enable xCloud's navigation polling
+        (window as any).BX_EXPOSED.disableGamepadPolling = false;
+
         BxEvent.dispatch(window, BxEvent.XCLOUD_DIALOG_DISMISSED);
     }
 
+    #focusCurrentTab() {
+        const $currentTab = this.$tabs!.querySelector('.bx-active') as HTMLElement;
+        $currentTab && $currentTab.focus();
+    }
+
+    #pollGamepad() {
+        const gamepads = window.navigator.getGamepads();
+
+        let direction: NavigationDirection | null = null;
+        for (const gamepad of gamepads) {
+            if (!gamepad || !gamepad.connected) {
+                continue;
+            }
+
+            // Ignore virtual controller
+            if (gamepad.id === EmulatedMkbHandler.VIRTUAL_GAMEPAD_ID) {
+                continue;
+            }
+
+            const axes = gamepad.axes;
+            const buttons = gamepad.buttons;
+
+            let lastButton = this.gamepadLastButtons[gamepad.index];
+            let pressedButton: GamepadKey | null = null;
+            let holdingButton: GamepadKey | null = null;
+
+            for (const key of StreamSettings.GAMEPAD_KEYS) {
+                if (typeof lastButton === 'number') {
+                    // Key released
+                    if (lastButton === key && !buttons[key].pressed) {
+                        pressedButton = key;
+                        break;
+                    }
+                } else if (buttons[key].pressed) {
+                    // Key pressed
+                    holdingButton = key;
+                    break;
+                }
+            }
+
+            if (holdingButton === null && pressedButton === null && axes && axes.length >= 2) {
+                // Check sticks
+                // LEFT left-right, LEFT up-down
+
+                if (typeof lastButton === 'number') {
+                    const releasedHorizontal = Math.abs(axes[0]) < 0.1 && (lastButton === GamepadKey.LS_LEFT || lastButton === GamepadKey.LS_RIGHT);
+                    const releasedVertical = Math.abs(axes[1]) < 0.1 && (lastButton === GamepadKey.LS_UP || lastButton === GamepadKey.LS_DOWN);
+
+                    if (releasedHorizontal || releasedVertical) {
+                        pressedButton = lastButton;
+                    }
+                } else {
+                    if (axes[0] < -0.5) {
+                        holdingButton = GamepadKey.LS_LEFT;
+                    } else if (axes[0] > 0.5) {
+                        holdingButton = GamepadKey.LS_RIGHT;
+                    } else if (axes[1] < -0.5) {
+                        holdingButton = GamepadKey.LS_UP;
+                    } else if (axes[1] > 0.5) {
+                        holdingButton = GamepadKey.LS_DOWN;
+                    }
+                }
+            }
+
+            if (holdingButton !== null) {
+                this.gamepadLastButtons[gamepad.index] = holdingButton;
+            }
+
+            if (pressedButton === null) {
+                continue;
+            }
+
+            this.gamepadLastButtons[gamepad.index] = null;
+
+            if (pressedButton === GamepadKey.A) {
+                document.activeElement && document.activeElement.dispatchEvent(new MouseEvent('click'));
+                return;
+            } else if (pressedButton === GamepadKey.B) {
+                this.hide();
+                return;
+            } else if (pressedButton === GamepadKey.LB || pressedButton === GamepadKey.RB) {
+                // Focus setting tabs
+                this.#focusCurrentTab();
+                return;
+            }
+
+            direction = StreamSettings.GAMEPAD_DIRECTION_MAP[pressedButton as keyof typeof StreamSettings.GAMEPAD_DIRECTION_MAP];
+            if (direction) {
+                let handled = false;
+                if (document.activeElement instanceof HTMLInputElement && document.activeElement.type === 'range') {
+                    const $range = document.activeElement;
+                    if (direction === NavigationDirection.LEFT || direction === NavigationDirection.RIGHT) {
+                        $range.value = (parseInt($range.value) + parseInt($range.step) * (direction === NavigationDirection.LEFT ? -1 : 1)).toString();
+                        $range.dispatchEvent(new InputEvent('input'));
+                        handled = true;
+                    }
+                }
+
+                if (!handled) {
+                    this.#focusDirection(direction);
+                }
+            }
+
+            return;
+        }
+    }
+
+    #startGamepadPolling() {
+        this.#stopGamepadPolling();
+
+        this.gamepadPollingIntervalId = window.setInterval(this.#pollGamepad.bind(this), StreamSettings.GAMEPAD_POLLING_INTERVAL);
+    }
+
+    #stopGamepadPolling() {
+        this.gamepadLastButtons = [];
+
+        this.gamepadPollingIntervalId && window.clearInterval(this.gamepadPollingIntervalId);
+        this.gamepadPollingIntervalId = null;
+    }
+
+    #handleTabsNavigation($focusing: HTMLElement, direction: NavigationDirection) {
+        if (direction === NavigationDirection.UP || direction === NavigationDirection.DOWN) {
+            let $sibling = $focusing;
+            const siblingProperty = direction === NavigationDirection.UP ? 'previousElementSibling' : 'nextElementSibling';
+
+            while ($sibling[siblingProperty]) {
+                $sibling = $sibling[siblingProperty] as HTMLElement;
+                $sibling && $sibling.focus();
+                return;
+            }
+        } else if (direction === NavigationDirection.RIGHT) {
+            this.#focusFirstVisibleSetting();
+        }
+    }
+
+    #handleSettingsNavigation($focusing: HTMLElement, direction: NavigationDirection) {
+        // If current element's tabIndex property is not 0
+        if ($focusing.tabIndex !== 0) {
+            // Find first visible setting
+            const $childSetting = $focusing.querySelector('div[data-tab-group]:not(.bx-gone) [tabindex="0"]:not(a)') as HTMLElement;
+            if ($childSetting) {
+                $childSetting.focus();
+                return;
+            }
+        }
+
+        // Current element is setting -> Find the next one
+        // Find parent
+        let $parent = $focusing.closest('[data-focus-container]');
+
+        if (!$parent) {
+            return;
+        }
+
+        // Find sibling setting
+        let $sibling = $parent;
+        if (direction === NavigationDirection.UP || direction === NavigationDirection.DOWN) {
+            const siblingProperty = direction === NavigationDirection.UP ? 'previousElementSibling' : 'nextElementSibling';
+
+            while ($sibling[siblingProperty]) {
+                $sibling = $sibling[siblingProperty];
+                const $childSetting = $sibling.querySelector('[tabindex="0"]:last-of-type') as HTMLElement;
+                if ($childSetting) {
+                    $childSetting.focus();
+                    return;
+                }
+            }
+        } else if (direction === NavigationDirection.LEFT || direction === NavigationDirection.RIGHT) {
+            // Find all child elements with tabindex
+            const children = Array.from($parent.querySelectorAll('[tabindex="0"]'));
+            const index = children.indexOf($focusing);
+            let nextIndex;
+            if (direction === NavigationDirection.LEFT) {
+                nextIndex = index - 1;
+            } else {
+                nextIndex = index + 1;
+            }
+
+            nextIndex = Math.max(-1, Math.min(nextIndex, children.length - 1));
+            if (nextIndex === -1) {
+                // Focus setting tabs
+                const $tab = this.$tabs!.querySelector('svg.bx-active') as HTMLElement;
+                $tab && $tab.focus();
+            } else if (nextIndex !== index) {
+                (children[nextIndex] as HTMLElement).focus();
+            }
+        }
+    }
+
+    #focusFirstVisibleSetting() {
+        // Focus the first visible tab content
+        const $tab = this.$settings!.querySelector('div[data-tab-group]:not(.bx-gone)') as HTMLElement;
+
+        if ($tab) {
+            // Focus on the first focusable setting
+            const $control = $tab.querySelector('[tabindex="0"]:not(a)') as HTMLElement;
+            if ($control) {
+                $control.focus();
+            } else {
+                // Focus tab
+                $tab.focus();
+            }
+        }
+    }
+
+    #focusDirection(direction: NavigationDirection) {
+        const $tabs = this.$tabs!;
+        const $settings = this.$settings!;
+
+        // Get current focused element
+        let $focusing = document.activeElement as HTMLElement;
+
+        let focusContainer = FocusContainer.OUTSIDE;
+        if ($focusing) {
+            if ($settings.contains($focusing)) {
+                focusContainer = FocusContainer.SETTINGS;
+            } else if ($tabs.contains($focusing)) {
+                focusContainer = FocusContainer.TABS;
+            }
+        }
+
+        // If not focusing any element or the focused element is not inside the dialog
+        if (focusContainer === FocusContainer.OUTSIDE) {
+            this.#focusFirstVisibleSetting();
+            return;
+        } else if (focusContainer === FocusContainer.SETTINGS) {
+            this.#handleSettingsNavigation($focusing, direction);
+        } else if (focusContainer === FocusContainer.TABS) {
+            this.#handleTabsNavigation($focusing, direction);
+        }
+    }
+
+    handleEvent(event: Event) {
+        switch (event.type) {
+            case 'keydown':
+                const $target = event.target as HTMLElement;
+                const keyboardEvent = event as KeyboardEvent;
+                const keyCode = keyboardEvent.code || keyboardEvent.key;
+
+                let handled = false;
+
+                if (keyCode === 'ArrowUp' || keyCode === 'ArrowDown') {
+                    handled = true;
+                    this.#focusDirection(keyCode === 'ArrowUp' ? NavigationDirection.UP : NavigationDirection.DOWN);
+                } else if (keyCode === 'ArrowLeft' || keyCode === 'ArrowRight') {
+                    if (($target as any).type !== 'range') {
+                        handled = true;
+                        this.#focusDirection(keyCode === 'ArrowLeft' ? NavigationDirection.LEFT : NavigationDirection.RIGHT);
+                    }
+                } else if (keyCode === 'Enter' || keyCode === 'Space') {
+                    if ($target instanceof SVGElement) {
+                        handled = true;
+                        $target.dispatchEvent(new Event('click'));
+                    }
+                } else if (keyCode === 'Tab') {
+                    handled = true;
+                    this.#focusCurrentTab();
+                } else if (keyCode === 'Escape') {
+                    handled = true;
+                    this.hide();
+                }
+
+                if (handled) {
+                    event.preventDefault();
+                    event.stopPropagation();
+                }
+
+                break;
+        }
+    }
+
     #setupDialog() {
         let $tabs: HTMLElement;
         let $settings: HTMLElement;
 
-        const $overlay = CE('div', {'class': 'bx-stream-settings-overlay bx-gone'});
+        const $overlay = CE('div', {class: 'bx-stream-settings-overlay bx-gone'});
         this.$overlay = $overlay;
 
-        const $container = CE('div', {'class': 'bx-stream-settings-dialog bx-gone'},
+        const $container = CE('div', {class: StreamSettings.MAIN_CLASS + ' bx-gone'},
-                $tabs = CE('div', {'class': 'bx-stream-settings-tabs'}),
+                $tabs = CE('div', {class: 'bx-stream-settings-tabs'}),
-                $settings = CE('div', {'class': 'bx-stream-settings-tab-contents'}),
+                $settings = CE('div', {
+                    class: 'bx-stream-settings-tab-contents',
+                    tabindex: 10,
+                }),
             );
+
         this.$container = $container;
+        this.$tabs = $tabs;
+        this.$settings = $settings;
 
         // Close dialog when clicking on the overlay
         $overlay.addEventListener('click', e => {
@@ -297,10 +649,12 @@ export class StreamSettings {
             }
 
             const $svg = createSvgIcon(settingTab.icon);
+            $svg.tabIndex = 0;
+
             $svg.addEventListener('click', e => {
                 // Switch tab
                 for (const $child of Array.from($settings.children)) {
-                    if ($child.getAttribute('data-group') === settingTab.group) {
+                    if ($child.getAttribute('data-tab-group') === settingTab.group) {
                         $child.classList.remove('bx-gone');
                     } else {
                         $child.classList.add('bx-gone');
@@ -317,20 +671,21 @@ export class StreamSettings {
 
             $tabs.appendChild($svg);
 
-            const $group = CE('div', {'data-group': settingTab.group, 'class': 'bx-gone'});
+            const $group = CE('div', {'data-tab-group': settingTab.group, 'class': 'bx-gone'});
 
             for (const settingGroup of settingTab.items) {
                 if (!settingGroup) {
                     continue;
                 }
 
-                $group.appendChild(CE('h2', {},
+                $group.appendChild(CE('h2', {'data-focus-container': 'true'},
                         CE('span', {}, settingGroup.label),
                         settingGroup.help_url && createButton({
                                 icon: BxIcon.QUESTION,
-                                style: ButtonStyle.GHOST,
+                                style: ButtonStyle.GHOST | ButtonStyle.FOCUSABLE,
                                 url: settingGroup.help_url,
                                 title: t('help'),
+                                tabIndex: 0,
                             }),
                     ));
                 if (settingGroup.note) {
@@ -362,7 +717,8 @@ export class StreamSettings {
                     } else if (!setting.unsupported) {
                         $control = toPrefElement(pref, setting.onChange, setting.params);
 
-                        if ($control instanceof HTMLSelectElement && BX_FLAGS.ScriptUi === 'tv') {
+                        // Replace <select> with controller-friendly one
+                        if ($control instanceof HTMLSelectElement && getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
                             $control = BxSelectElement.wrap($control);
                         }
                     }
@@ -370,7 +726,11 @@ export class StreamSettings {
                     const label = Preferences.SETTINGS[pref as PrefKey]?.label || setting.label;
                     const note = Preferences.SETTINGS[pref as PrefKey]?.note || setting.note;
 
-                    const $content = CE('div', {'class': 'bx-stream-settings-row', 'data-type': settingGroup.group},
+                    const $content = CE('div', {
+                        class: 'bx-stream-settings-row',
+                        'data-type': settingGroup.group,
+                        'data-focus-container': 'true',
+                    },
                         CE('label', {for: `bx_setting_${pref}`},
                             label,
                             note && CE('div', {'class': 'bx-stream-settings-dialog-note'}, note),
@@ -393,5 +753,8 @@ export class StreamSettings {
 
         document.documentElement.appendChild($overlay);
         document.documentElement.appendChild($container);
+
+        // Update video's settings
+        onChangeVideoPlayerType();
     }
 }

src/modules/ui/global-settings.ts

@@ -7,7 +7,6 @@ import { getPref, Preferences, PrefKey, setPref, toPrefElement } from "@utils/pr
 import { t, Translations } from "@utils/translation";
 import { PatcherCache } from "../patcher";
 import { UserAgentProfile } from "@enums/user-agent";
-import { BX_FLAGS } from "@/utils/bx-flags";
 import { BxSelectElement } from "@/web-components/bx-select";
 import { StreamSettings } from "../stream/stream-settings";
 
@@ -16,6 +15,7 @@ const SETTINGS_UI = {
         items: [
             PrefKey.BETTER_XCLOUD_LOCALE,
             PrefKey.SERVER_BYPASS_RESTRICTION,
+            PrefKey.UI_CONTROLLER_FRIENDLY,
             PrefKey.REMOTE_PLAY_ENABLED,
         ],
     },
@@ -162,7 +162,7 @@ export function setupSettingsUi() {
     }
 
     // "Stream settings" button
-    topButtons.push(createButton({
+    (STATES.supportedRegion && STATES.isSignedIn) && topButtons.push(createButton({
         label: t('stream-settings'),
         icon: BxIcon.STREAM_SETTINGS,
         style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
@@ -203,6 +203,8 @@ export function setupSettingsUi() {
         $wrapper.appendChild($div);
     }
 
+    let localeSwitchingTimeout: number | null;
+
     const onChange = async (e: Event) => {
         // Clear PatcherCache;
         PatcherCache.clear();
@@ -214,12 +216,17 @@ export function setupSettingsUi() {
         $btnHeaderSettings && $btnHeaderSettings.classList.add('bx-danger');
 
         if ((e.target as HTMLElement).id === 'bx_setting_' + PrefKey.BETTER_XCLOUD_LOCALE) {
-            // Update locale
+            if (getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
-            Translations.refreshCurrentLocale();
+                localeSwitchingTimeout && window.clearTimeout(localeSwitchingTimeout);
-            await Translations.updateTranslations();
+                localeSwitchingTimeout = window.setTimeout(() => {
+                    Translations.refreshCurrentLocale();
+                    Translations.updateTranslations();
+                }, 1000);
+            } else {
+                // Update locale
+                Translations.refreshCurrentLocale();
+                await Translations.updateTranslations();
 
-            // Don't refresh the page on TV
-            if (BX_FLAGS.ScriptUi !== 'tv') {
                 $btnReload.textContent = t('settings-reloading');
                 $btnReload.click();
             }
@@ -228,6 +235,11 @@ export function setupSettingsUi() {
 
     // Render settings
     for (let groupLabel in SETTINGS_UI) {
+        // Don't render other settings when not signed in
+        if (groupLabel !== 'Better xCloud' && (!STATES.supportedRegion || !STATES.isSignedIn)) {
+            continue;
+        }
+
         const $group = CE('span', {'class': 'bx-settings-group-label'}, groupLabel);
 
         // Render note
@@ -376,22 +388,26 @@ export function setupSettingsUi() {
                 $control.setAttribute('tabindex', -1);
             }
 
-            const $label = CE('label', labelAttrs, settingLabel);
+            const $label = CE<HTMLLabelElement>('label', labelAttrs, settingLabel);
             if (settingNote) {
                 $label.appendChild(CE('b', {}, settingNote));
             }
 
             let $elm: HTMLElement;
 
-            if ($control instanceof HTMLSelectElement && BX_FLAGS.ScriptUi === 'tv') {
+            if ($control instanceof HTMLSelectElement && getPref(PrefKey.UI_CONTROLLER_FRIENDLY)) {
-                $elm = CE('div', {'class': 'bx-settings-row'},
+                // Controller-friendly <select>
+                $elm = CE('div', {'class': 'bx-settings-row', 'data-group': 0},
                     $label,
-                    BxSelectElement.wrap($control),
+                    CE('div', {class: 'bx-setting-control'}, BxSelectElement.wrap($control)),
                 );
             } else {
-                $elm = CE('div', {'class': 'bx-settings-row'},
+                $elm = CE('div', {'class': 'bx-settings-row', 'data-group': 0},
                     $label,
-                    $control,
+                    $control instanceof HTMLInputElement ? CE('label', {
+                        class: 'bx-setting-control',
+                        for: $label.getAttribute('for'),
+                    }, $control) : CE('div', {class: 'bx-setting-control'}, $control),
                 );
             }
 

src/modules/ui/guide-menu.ts

@@ -43,11 +43,18 @@ export class GuideMenu {
             },
         }),
 
-        reloadStream: createButton({
+        reloadPage: createButton({
-            label: t('reload-stream'),
+            label: t('reload-page'),
             style: ButtonStyle.FULL_WIDTH | ButtonStyle.FOCUSABLE,
             onClick: e => {
-                confirm(t('confirm-reload-stream')) && window.location.reload();
+                if (STATES.isPlaying) {
+                    confirm(t('confirm-reload-stream')) && window.location.reload();
+                } else {
+                    window.location.reload();
+                }
+
+                // Close all xCloud's dialogs
+                window.BX_EXPOSED.dialogRoutes.closeAll();
             },
         }),
 
@@ -88,6 +95,9 @@ export class GuideMenu {
             buttons.push(GuideMenu.#BUTTONS.closeApp);
         }
 
+        // Reload page
+        buttons.push(GuideMenu.#BUTTONS.reloadPage);
+
         const $buttons = GuideMenu.#renderButtons(buttons);
 
         const $lastDivider = $dividers[$dividers.length - 1];
@@ -105,8 +115,8 @@ export class GuideMenu {
         buttons.push(GuideMenu.#BUTTONS.streamSetting);
         AppInterface && buttons.push(GuideMenu.#BUTTONS.appSettings);
 
-        // Reload stream
+        // Reload page
-        buttons.push(GuideMenu.#BUTTONS.reloadStream);
+        buttons.push(GuideMenu.#BUTTONS.reloadPage);
 
         // Back to home
         buttons.push(GuideMenu.#BUTTONS.backToHome);

src/types/index.d.ts

@@ -28,7 +28,7 @@ type BxStates = {
     serverRegions: any;
     selectedRegion: any;
     gsToken: string;
-
+    isSignedIn: boolean;
 
     isPlaying: boolean;
     appContext: any | null;

src/types/preferences.d.ts

@@ -1,5 +1,6 @@
 export type PreferenceSetting = {
     default: any;
+    optionsGroup?: string;
     options?: {[index: string]: string};
     multipleOptions?: {[index: string]: string};
     unsupported?: string | boolean;

src/utils/bx-exposed.ts

@@ -4,6 +4,7 @@ import { deepClone, STATES } from "@utils/global";
 import { getPref, PrefKey } from "@utils/preferences";
 import { BxLogger } from "./bx-logger";
 import { BX_FLAGS } from "./bx-flags";
+import { StreamSettings } from "@/modules/stream/stream-settings";
 
 export enum InputType {
     CONTROLLER = 'Controller',
@@ -115,4 +116,16 @@ export const BxExposed = {
             hasCompletedOnboarding: true,
         },
     },
+
+    disableGamepadPolling: false,
+
+    backButtonPressed: () => {
+        const streamSettings = StreamSettings.getInstance();
+        if (streamSettings.isShowing()) {
+            streamSettings.hide();
+            return true;
+        }
+
+        return false;
+    },
 };

src/utils/bx-flags.ts

@@ -10,8 +10,6 @@ type BxFlags = Partial<{
     ForceNativeMkbTitles: string[];
     FeatureGates: {[key: string]: boolean} | null,
 
-    ScriptUi: 'default' | 'tv',
-
     IsSupportedTvBrowser: boolean,
 }>
 
@@ -27,8 +25,6 @@ const DEFAULT_FLAGS: BxFlags = {
 
     ForceNativeMkbTitles: [],
     FeatureGates: null,
-
-    ScriptUi: 'default',
 }
 
 export const BX_FLAGS: BxFlags = Object.assign(DEFAULT_FLAGS, window.BX_FLAGS || {});

src/utils/global.ts

@@ -17,6 +17,7 @@ export const STATES: BxStates = {
     serverRegions: {},
     selectedRegion: {},
     gsToken: '',
+    isSignedIn: false,
 
     isPlaying: false,
     appContext: {},

src/utils/history.ts

@@ -2,6 +2,7 @@ import { BxEvent } from "@utils/bx-event";
 import { LoadingScreen } from "@modules/loading-screen";
 import { RemotePlay } from "@modules/remote-play";
 import { HeaderSection } from "@/modules/ui/header";
+import { StreamSettings } from "@/modules/stream/stream-settings";
 
 export function patchHistoryMethod(type: 'pushState' | 'replaceState') {
     const orig = window.history[type];
@@ -25,11 +26,17 @@ export function onHistoryChanged(e: PopStateEvent) {
 
     window.setTimeout(RemotePlay.detect, 10);
 
+    // Hide Global settings
     const $settings = document.querySelector('.bx-settings-container');
     if ($settings) {
         $settings.classList.add('bx-gone');
     }
 
+    // Hide Stream settings
+    if (document.querySelector('.' + StreamSettings.MAIN_CLASS)) {
+        StreamSettings.getInstance().hide();
+    }
+
     // Hide Remote Play popup
     RemotePlay.detachPopup();
 

src/utils/html.ts

@@ -9,6 +9,7 @@ type BxButton = {
     title?: string;
     disabled?: boolean;
     onClick?: EventListener;
+    tabIndex?: number;
     attributes?: {[key: string]: any},
 }
 
@@ -94,6 +95,7 @@ export const createButton = <T=HTMLButtonElement>(options: BxButton): T => {
     options.title && $btn.setAttribute('title', options.title);
     options.disabled && (($btn as HTMLButtonElement).disabled = true);
     options.onClick && $btn.addEventListener('click', options.onClick);
+    typeof options.tabIndex === 'number' && ($btn.tabIndex = options.tabIndex!);
 
     for (const key in options.attributes) {
         if (!$btn.hasOwnProperty(key)) {

src/utils/preferences.ts

@@ -8,6 +8,7 @@ import { AppInterface, STATES } from "@utils/global";
 import { StreamPlayerType, StreamVideoProcessing } from "@enums/stream-player";
 import { UserAgentProfile } from "@/enums/user-agent";
 import { UiSection } from "@/enums/ui-sections";
+import { BypassServers } from "@/enums/bypass-servers";
 
 export enum PrefKey {
     LAST_UPDATE_CHECK = 'version_last_check',
@@ -71,6 +72,7 @@ export enum PrefKey {
     UI_LOADING_SCREEN_WAIT_TIME = 'ui_loading_screen_wait_time',
     UI_LOADING_SCREEN_ROCKET = 'ui_loading_screen_rocket',
 
+    UI_CONTROLLER_FRIENDLY = 'ui_controller_friendly',
     UI_LAYOUT = 'ui_layout',
     UI_SCROLLBAR_HIDE = 'ui_scrollbar_hide',
     UI_HIDE_SECTIONS = 'ui_hide_sections',
@@ -127,8 +129,12 @@ export class Preferences {
         },
         [PrefKey.SERVER_BYPASS_RESTRICTION]: {
             label: t('bypass-region-restriction'),
-            note: t('use-this-at-your-own-risk'),
+            note: '⚠️ ' + t('use-this-at-your-own-risk'),
-            default: false,
+            default: 'off',
+            optionsGroup: t('region'),
+            options: Object.assign({
+                'off': t('off'),
+            }, BypassServers),
         },
 
         [PrefKey.STREAM_PREFERRED_LOCALE]: {
@@ -548,6 +554,12 @@ export class Preferences {
                 hide: t('rocket-always-hide'),
             },
         },
+
+        [PrefKey.UI_CONTROLLER_FRIENDLY]: {
+            label: t('controller-friendly-ui'),
+            default: false,
+        },
+
         [PrefKey.UI_LAYOUT]: {
             label: t('layout'),
             default: 'default',
@@ -632,7 +644,7 @@ export class Preferences {
             min: 0,
             max: 10,
             params: {
-                hideSlider: true,
+                exactTicks: 2,
                 customTextValue: (value: any) => {
                     value = parseInt(value);
                     return value === 0 ? t('off') : value.toString();
@@ -702,6 +714,7 @@ export class Preferences {
             default: 100,
             min: 0,
             max: 600,
+            steps: 20,
             params: {
                 suffix: '%',
                 ticks: 100,
@@ -760,6 +773,7 @@ export class Preferences {
             default: 80,
             min: 50,
             max: 100,
+            steps: 10,
             params: {
                 suffix: '%',
                 ticks: 10,

src/utils/settings.ts

@@ -30,11 +30,20 @@ export class SettingElement {
                 // title: setting.label,
                 tabindex: 0,
             }) as HTMLSelectElement;
+
+        let $parent: HTMLElement;
+        if (setting.optionsGroup) {
+            $parent = CE('optgroup', {'label': setting.optionsGroup});
+            $control.appendChild($parent);
+        } else {
+            $parent = $control;
+        }
+
         for (let value in setting.options) {
             const label = setting.options[value];
 
             const $option = CE<HTMLOptionElement>('option', {value: value}, label);
-            $control.appendChild($option);
+            $parent.appendChild($option);
         }
 
         $control.value = currentValue;
@@ -158,21 +167,23 @@ export class SettingElement {
         };
 
         const updateButtonsVisibility = () => {
-            $btnDec.classList.toggle('bx-hidden', controlValue === MIN);
+            $btnDec.classList.toggle('bx-inactive', controlValue === MIN);
-            $btnInc.classList.toggle('bx-hidden', controlValue === MAX);
+            $btnInc.classList.toggle('bx-inactive', controlValue === MAX);
         }
 
         const $wrapper = CE('div', {'class': 'bx-number-stepper', id: `bx_setting_${key}`},
                 $btnDec = CE('button', {
                         'data-type': 'dec',
                         type: 'button',
-                        tabindex: -1,
+                        class: options.hideSlider ? 'bx-focusable' : '',
+                        tabindex: options.hideSlider ? 0 : -1,
                     }, '-') as HTMLButtonElement,
                 $text = CE('span', {}, renderTextValue(value)) as HTMLSpanElement,
                 $btnInc = CE('button', {
                         'data-type': 'inc',
                         type: 'button',
-                        tabindex: -1,
+                        class: options.hideSlider ? 'bx-focusable' : '',
+                        tabindex: options.hideSlider ? 0 : -1,
                     }, '+') as HTMLButtonElement,
             );
 
@@ -189,10 +200,16 @@ export class SettingElement {
 
             $range.addEventListener('input', e => {
                 value = parseInt((e.target as HTMLInputElement).value);
+                const valueChanged = controlValue !== value;
+
+                if (!valueChanged) {
+                    return;
+                }
+
                 controlValue = value;
                 updateButtonsVisibility();
-
                 $text.textContent = renderTextValue(value);
+
                 !(e as any).ignoreOnChange && onChange && onChange(e, value);
             });
             $wrapper.appendChild($range);
@@ -223,10 +240,10 @@ export class SettingElement {
 
         if (options.disabled) {
             $btnInc.disabled = true;
-            $btnInc.classList.add('bx-hidden');
+            $btnInc.classList.add('bx-inactive');
 
             $btnDec.disabled = true;
-            $btnDec.classList.add('bx-hidden');
+            $btnDec.classList.add('bx-inactive');
             return $wrapper;
         }
 

src/utils/translation.ts

@@ -20,6 +20,7 @@ export const SUPPORTED_LANGUAGES = {
     'uk-UA': 'українська',
     'vi-VN': 'Tiếng Việt',
     'zh-CN': '中文(简体)',
+    'zh-TW': '中文(繁體)',
 };
 
 const Texts = {
@@ -69,6 +70,7 @@ const Texts = {
     "console-connect": "Connect",
     "contrast": "Contrast",
     "controller": "Controller",
+    "controller-friendly-ui": "Controller-friendly UI",
     "controller-shortcuts": "Controller shortcuts",
     "controller-shortcuts-connect-note": "Connect a controller to use this feature",
     "controller-shortcuts-xbox-note": "Button to open the Guide menu",
@@ -173,12 +175,13 @@ const Texts = {
         (e: any) => `Натисніть ${e.key} щоб перемкнути цю функцію`,
         (e: any) => `Nhấn ${e.key} để bật/tắt tính năng này`,
         (e: any) => `按下 ${e.key} 来切换此功能`,
+        (e: any) => `按下 ${e.key} 來啟用此功能`,
     ],
     "press-to-bind": "Press a key or do a mouse click to bind...",
     "prompt-preset-name": "Preset's name:",
     "reduce-animations": "Reduce UI animations",
     "region": "Region",
-    "reload-stream": "Reload stream",
+    "reload-page": "Reload page",
     "remote-play": "Remote Play",
     "rename": "Rename",
     "renderer": "Renderer",
@@ -269,6 +272,7 @@ const Texts = {
         (e: any) => `Розташування сенсорного керування від ${e.name}`,
         (e: any) => `Bố cục điều khiển cảm ứng tạo bởi ${e.name}`,
         (e: any) => `由 ${e.name} 提供的虚拟按键样式`,
+        (e: any) => `觸控遊玩佈局由 ${e.name} 提供`,
     ],
     "touch-controller": "Touch controller",
     "transparent-background": "Transparent background",
@@ -371,6 +375,7 @@ export class Translations {
     static async updateTranslations(async=false) {
         // Don't have to download en-US
         if (Translations.#selectedLocale === Translations.#EN_US) {
+            localStorage.removeItem(Translations.#KEY_TRANSLATIONS);
             return;
         }
 

src/utils/xcloud-interceptor.ts

@@ -8,12 +8,15 @@ import { STATES } from "./global";
 import { patchIceCandidates } from "./network";
 import { getPref, PrefKey } from "./preferences";
 import { getPreferredServerRegion } from "./region";
+import { BypassServerIps } from "@/enums/bypass-servers";
 
 export
 class XcloudInterceptor {
     static async #handleLogin(request: RequestInfo | URL, init?: RequestInit) {
-        if (getPref(PrefKey.SERVER_BYPASS_RESTRICTION)) {
+        const bypassServer = getPref(PrefKey.SERVER_BYPASS_RESTRICTION);
-            (request as Request).headers.set('X-Forwarded-For', '9.9.9.9');
+        if (bypassServer !== 'off') {
+            const ip = BypassServerIps[bypassServer as keyof typeof BypassServerIps];
+            ip && (request as Request).headers.set('X-Forwarded-For', ip);
         }
 
         const response = await NATIVE_FETCH(request, init);

src/web-components/bx-select.ts

@@ -2,6 +2,9 @@ import { ButtonStyle, CE, createButton } from "@utils/html";
 
 export class BxSelectElement {
     static wrap($select: HTMLSelectElement) {
+        // Remove "tabindex" attribute from <select>
+        $select.removeAttribute('tabindex');
+
         const $btnPrev = createButton({
             label: '<',
             style: ButtonStyle.FOCUSABLE,
@@ -23,23 +26,36 @@ export class BxSelectElement {
         let $checkBox: HTMLInputElement;
         let $label: HTMLElement;
 
-        const $content = CE('div', {},
+        let $content;
-            $checkBox = CE('input', {type: 'checkbox', id: $select.id + '_checkbox'}),
-            $label = CE('label', {for: $select.id + '_checkbox'}, ''),
-        );
 
-        isMultiple && $checkBox.addEventListener('input', e => {
+        if (isMultiple) {
-            const $option = getOptionAtIndex(visibleIndex);
+            $content = CE('button', {
-            $option && ($option.selected = (e.target as HTMLInputElement).checked);
+                class: 'bx-select-value bx-focusable',
+                tabindex: 0,
+            },
+                $checkBox = CE('input', {type: 'checkbox'}),
+                $label = CE('span', {}, ''),
+            );
 
-            $select.dispatchEvent(new Event('input'));
+            $content.addEventListener('click', e => {
-        });
+                $checkBox.click();
+            });
 
-        // Only show checkbox in "multiple" <select>
+            $checkBox.addEventListener('input', e => {
-        $checkBox.classList.toggle('bx-gone', !isMultiple);
+                const $option = getOptionAtIndex(visibleIndex);
+                $option && ($option.selected = (e.target as HTMLInputElement).checked);
+
+                $select.dispatchEvent(new Event('input'));
+            });
+        } else {
+            $content = CE('div', {},
+                $label = CE('label', {for: $select.id + '_checkbox'}, ''),
+            );
+        }
 
         const getOptionAtIndex = (index: number): HTMLOptionElement | undefined => {
-            return $select.querySelector(`option:nth-of-type(${visibleIndex + 1})`) as HTMLOptionElement;
+            const options = Array.from($select.querySelectorAll('option'));
+            return options[index];
         }
 
         const render = () => {
@@ -51,22 +67,38 @@ export class BxSelectElement {
             let content = '';
             if ($option) {
                 content = $option.textContent || '';
+
+                if (content && $option.parentElement!.tagName === 'OPTGROUP') {
+                    $label.innerHTML = '';
+                    const fragment = document.createDocumentFragment();
+                    fragment.appendChild(CE('span', {}, ($option.parentElement as HTMLOptGroupElement).label));
+                    fragment.appendChild(document.createTextNode(content));
+
+                    $label.appendChild(fragment);
+                } else {
+                    $label.textContent = content;
+                }
+            } else {
+                $label.textContent = content;
             }
 
-            $label.textContent = content;
+            // Add line-through on disabled option
+            $label.classList.toggle('bx-line-through', $option && $option.disabled);
 
             // Hide checkbox when the selection is empty
-            isMultiple && ($checkBox.checked = $option?.selected || false);
+            if (isMultiple) {
-            $checkBox.classList.toggle('bx-gone', !isMultiple || !content);
+                $checkBox.checked = $option?.selected || false;
+                $checkBox.classList.toggle('bx-gone', !content);
+            }
 
             const disablePrev = visibleIndex <= 0;
             const disableNext = visibleIndex === $select.querySelectorAll('option').length - 1;
 
             $btnPrev.classList.toggle('bx-inactive', disablePrev);
-            disablePrev && $btnNext.focus();
+            // disablePrev && document.activeElement === $btnPrev && $btnNext.focus();
 
             $btnNext.classList.toggle('bx-inactive', disableNext);
-            disableNext && $btnPrev.focus();
+            // disableNext && document.activeElement === $btnNext &&$btnPrev.focus();
         }
 
         const normalizeIndex = (index: number): number => {
@@ -94,13 +126,16 @@ export class BxSelectElement {
 
         const observer = new MutationObserver((mutationList, observer) => {
             mutationList.forEach(mutation => {
-                mutation.type === 'childList' && render();
+                if (mutation.type === 'childList' || mutation.type === 'attributes') {
+                    render();
+                }
             });
         });
 
         observer.observe($select, {
             subtree: true,
             childList: true,
+            attributes: true,
         });
 
         render();