Files
PortProtonQt/tests/test_input_manager.py
Boria138 0391b894ee
Code check / Check code (push) Successful in 2m52s
feat: support multiple Run After executables and scripts
Signed-off-by: Boris Yumankulov <boria138@altlinux.org>
2026-10-31 00:41:47 +05:00

1660 lines
61 KiB
Python

"""Tests for gamepad input navigation."""
from inspect import signature
from types import SimpleNamespace
from typing import Any, cast
from unittest.mock import MagicMock
from PySide6.QtCore import QEvent, QObject, QStringListModel, Qt
from PySide6.QtWidgets import QApplication, QCheckBox, QComboBox, QDialog, QFrame, QHBoxLayout, QLineEdit, QListView, QMenu, QPushButton, QSlider, QStackedWidget, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget
from pytest import MonkeyPatch, raises, mark
from shiboken6 import delete
import portprotonqt.input_manager as input_manager
import portprotonqt.input_manager.buttons as input_buttons
import portprotonqt.input_manager.dpad as input_dpad
import portprotonqt.input_manager.runtime as input_runtime
import portprotonqt.native_gamepad as native_gamepad
from portprotonqt.input_manager.constants import (
GamepadType,
KEY_LEFT,
PAD_BUTTON_SOUTH,
PAD_BUTTON_SELECT,
PAD_BUTTON_GUIDE,
PAD_BUTTON_START,
SDL_GAMEPAD_TYPE_PS5,
SDL_GAMEPAD_BUTTON_DPAD_DOWN,
SDL_GAMEPAD_BUTTON_DPAD_UP,
)
from portprotonqt.input_manager import InputManager, MainWindowProtocol, PAD_DPAD_X, PAD_DPAD_Y
from portprotonqt.game_library_manager import FullLibraryTile
from portprotonqt.native_gamepad import GamepadBackendError, SDLGamepad
from portprotonqt.themes.standart.styles.constants import GAME_CARD_ANIMATION
FIRST_CARD_X = 0
HIDDEN_CARD_X = 20
NEXT_CARD_X = 40
@mark.parametrize("event_type", [QEvent.Type.Destroy, QEvent.Type.ChildRemoved, QEvent.Type.DeferredDelete])
def test_keyboard_filter_ignores_deleted_layout(event_type: QEvent.Type) -> None:
app = QApplication.instance() or QApplication([])
manager = InputManager.__new__(InputManager)
QObject.__init__(manager)
layout = QVBoxLayout()
delete(layout)
assert manager.eventFilter(layout, QEvent(event_type)) is False
assert app is not None
@mark.parametrize("event_type", [QEvent.Type.Destroy, QEvent.Type.ChildRemoved, QEvent.Type.DeferredDelete])
def test_keyboard_filter_teardown_does_not_lookup_application(
monkeypatch: MonkeyPatch, event_type: QEvent.Type,
) -> None:
app = QApplication.instance() or QApplication([])
manager = InputManager.__new__(InputManager)
QObject.__init__(manager)
watched = QObject()
lookup = MagicMock(side_effect=AssertionError("Application lookup during teardown"))
monkeypatch.setattr(QApplication, "instance", lookup)
assert manager.eventFilter(watched, QEvent(event_type)) is False
lookup.assert_not_called()
assert app is not None
@mark.parametrize("initial", [True, False])
def test_gamepad_auto_fullscreen_shows_boot_on_hotplug(monkeypatch: MonkeyPatch, initial: bool) -> None:
app = QApplication.instance() or QApplication([])
window = cast(Any, QWidget())
window.start_boot_animation = MagicMock()
manager: Any = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager._parent = window
manager._is_fullscreen = False
manager._initial_gamepad_check = initial
manager._gamepad_polling_suspended = False
manager.gamepad = None
manager.find_gamepad = lambda: SimpleNamespace(path="test", name="test")
manager.detect_gamepad_axes = MagicMock()
manager._reset_input_state = MagicMock()
manager._refresh_gamepad_ui = MagicMock()
manager._get_effective_gamepad_type = MagicMock()
manager.toggle_fullscreen.connect(manager.handle_fullscreen_slot)
monkeypatch.setattr(input_runtime.display_config, "get_auto_fullscreen_gamepad", lambda: True)
monkeypatch.setattr(input_runtime.display_config, "get_fullscreen", lambda: False)
monkeypatch.setattr(input_manager.window_config, "set_geometry", MagicMock())
monkeypatch.setattr(input_manager.window_config, "get_geometry", lambda: (640, 480))
manager.check_gamepad()
assert window.isFullScreen() is (not initial)
assert window.start_boot_animation.call_count == (0 if initial else 1)
if not initial:
manager.handle_fullscreen_slot(True)
assert window.start_boot_animation.call_count == 1
window.boot_animation = MagicMock()
manager.handle_fullscreen_slot(False)
window.boot_animation.finish.assert_called_once_with()
assert not window.isFullScreen()
window.close()
assert app is not None
def _tile_theme() -> Any:
return SimpleNamespace(
fullLibraryTileSize=(180, 180),
fullLibraryTileColumns=2,
fullLibraryTileRows=2,
fullLibraryTileRadius=10,
GAME_CARD_HORIZONTAL={},
GAME_CARD_ANIMATION=GAME_CARD_ANIMATION,
)
def test_dpad_first_repeat_uses_long_press_delay() -> None:
parameters = signature(InputManager).parameters
assert parameters["initial_axis_move_delay"].default == 0.5
def test_theme_tab_focusables_include_delete_button(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
manager = InputManager.__new__(InputManager)
widgets = [QWidget() for _index in range(5)]
cast(Any, manager)._parent = SimpleNamespace(
themesCombo=widgets[0],
themeVariantCombo=widgets[1],
screenshotsCarousel=widgets[2],
applyButton=widgets[3],
deleteThemeButton=widgets[4],
)
monkeypatch.setattr(manager, "_is_theme_store_visible", lambda: False)
monkeypatch.setattr(manager, "_is_visible_enabled_widget", lambda _widget: True)
assert manager._get_theme_tab_focusables() == widgets
assert app is not None
def test_native_gamepad_result_preserves_python_interface(monkeypatch: MonkeyPatch) -> None:
controller = 42
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_find", lambda: controller)
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_close", lambda _handle: None)
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_get_instance_id", lambda _handle: 7)
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_get_name", lambda _handle: b"DualSense")
monkeypatch.setattr(
native_gamepad._library,
"portproton_gamepad_get_type",
lambda _handle: SDL_GAMEPAD_TYPE_PS5,
)
gamepad = native_gamepad.find_gamepad()
assert gamepad is not None
assert gamepad.controller == controller
assert gamepad.name == "DualSense"
assert gamepad.path == "sdl3-gamepad:7"
manager = InputManager.__new__(InputManager)
assert manager._detect_gamepad_type(gamepad) == GamepadType.PLAYSTATION
gamepad.close()
def test_native_gamepad_update_passes_collection_handle(monkeypatch: MonkeyPatch) -> None:
updated_handles: list[int] = []
gamepad = SDLGamepad(42, "Gamepads", "sdl3-gamepad:7", 7, 1)
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_close", lambda _handle: None)
monkeypatch.setattr(
native_gamepad._library,
"portproton_gamepad_update",
updated_handles.append,
)
monkeypatch.setattr(
native_gamepad._library,
"portproton_gamepad_get_active_instance_id",
lambda _handle: 9,
)
monkeypatch.setattr(
native_gamepad._library,
"portproton_gamepad_get_type",
lambda _handle: SDL_GAMEPAD_TYPE_PS5,
)
changed = gamepad.update()
assert updated_handles == [42]
assert changed is True
assert gamepad.active_instance_id == 9
assert gamepad.sdl_type == SDL_GAMEPAD_TYPE_PS5
assert gamepad.update() is False
gamepad.close()
def test_native_gamepad_reports_sdl_discovery_error(monkeypatch: MonkeyPatch) -> None:
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_find", lambda: None)
monkeypatch.setattr(
native_gamepad._library,
"portproton_gamepad_get_error",
lambda: b"SDL gamepad initialization failed",
)
with raises(GamepadBackendError, match="SDL gamepad initialization failed"):
native_gamepad.find_gamepad()
def test_native_gamepad_absence_is_not_an_error(monkeypatch: MonkeyPatch) -> None:
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_find", lambda: None)
monkeypatch.setattr(native_gamepad._library, "portproton_gamepad_get_error", lambda: b"")
assert native_gamepad.find_gamepad() is None
def test_repeated_gamepad_backend_error_is_logged_once(monkeypatch: MonkeyPatch) -> None:
logged_errors: list[tuple[object, ...]] = []
manager = InputManager.__new__(InputManager)
manager._last_gamepad_error = None
def fail_discovery() -> None:
raise GamepadBackendError("SDL initialization failed")
monkeypatch.setattr(input_runtime, "find_gamepad", fail_discovery)
monkeypatch.setattr(
input_runtime.logger,
"error",
lambda *args, **_kwargs: logged_errors.append(args),
)
assert manager.find_gamepad() is None
assert manager.find_gamepad() is None
assert len(logged_errors) == 1
def test_qt_event_to_input_key_supports_cyrillic() -> None:
event = cast(
QEvent,
SimpleNamespace(
nativeScanCode=lambda: 0,
text=lambda: "Я",
key=lambda: 0,
),
)
manager = InputManager.__new__(InputManager)
assert manager._qt_event_to_input_key(event) == ord("я")
def test_sdl_dpad_vertical_directions() -> None:
emitted: list[tuple[int, int, float]] = []
pressed_button = SDL_GAMEPAD_BUTTON_DPAD_UP
gamepad = cast(
SDLGamepad,
SimpleNamespace(get_button=lambda button: int(button == pressed_button)),
)
manager = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager._hat_states = {}
manager.mouse_emulation_enabled = False
manager.emulation_active = False
manager.emulation_triggered = False
manager.dpad_moved.connect(lambda code, value, now: emitted.append((code, value, now)))
InputManager._poll_hat_events(manager, gamepad, 1.0)
pressed_button = SDL_GAMEPAD_BUTTON_DPAD_DOWN
InputManager._poll_hat_events(manager, gamepad, 2.0)
assert emitted == [(PAD_DPAD_Y, -1, 1.0), (PAD_DPAD_Y, 1, 2.0)]
def test_disabling_mouse_emulation_keeps_gamepad_events_working() -> None:
emitted: list[tuple[int, int]] = []
manager = InputManager.__new__(InputManager)
QObject.__init__(manager)
cast(Any, manager)._parent = SimpleNamespace(boot_animation=None)
manager._button_states = {}
manager.mouse_emulation_enabled = True
manager.emulation_active = True
manager.emulation_triggered = True
manager.start_held = True
manager.select_held = False
manager.pending_menu_fullscreen_time = 0.0
manager.button_event.connect(lambda code, value: emitted.append((code, value)))
manager._handle_button_value(0, PAD_BUTTON_SELECT, 1, 1.0)
manager._handle_button_value(1, PAD_BUTTON_SOUTH, 1, 2.0)
assert manager.emulation_triggered is False
assert emitted == [(PAD_BUTTON_SOUTH, 1)]
@mark.parametrize("partner", [PAD_BUTTON_GUIDE, PAD_BUTTON_START])
def test_sdl_simultaneous_button_combinations(partner: int) -> None:
app = QApplication.instance() or QApplication([])
manager: Any = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager._parent = SimpleNamespace(refreshGames=MagicMock(), isActiveWindow=lambda: True)
manager._button_states = {}
manager.guide_held = manager.select_held = manager.start_held = False
manager.guide_pressed_time = manager.select_pressed_time = 0
manager.guide_combination_timeout = 0.3
manager.in_guide_combination_attempt = False
manager.guide_timer = SimpleNamespace(start=MagicMock(), stop=MagicMock())
manager.pending_menu_fullscreen_time = 0.0
manager._is_gamescope_session = False
manager.mouse_emulation_enabled = False
manager.emulation_triggered = False
manager.button_event.connect(
lambda code, value: manager._handle_guide_combination(code, 1.0) if value else None,
Qt.ConnectionType.QueuedConnection,
)
pressed: set[int] = set()
gamepad = cast(SDLGamepad, SimpleNamespace(
get_button=lambda index: int(input_runtime.SDL_CONTROLLER_BUTTON_TO_PAD[index] in pressed),
))
manager._poll_button_events(gamepad, 0.0)
app.processEvents()
for expected_emulation in (True, False):
pressed.update((PAD_BUTTON_SELECT, partner))
manager._poll_button_events(gamepad, 1.0)
app.processEvents()
assert manager.pending_menu_fullscreen_time == 0.0
if partner == PAD_BUTTON_START:
assert manager.emulation_triggered is expected_emulation
manager._parent.refreshGames.assert_not_called()
else:
manager._parent.refreshGames.assert_called_once()
manager._parent.refreshGames.reset_mock()
pressed.clear()
manager._poll_button_events(gamepad, 1.1)
app.processEvents()
class DummyCard(QFrame):
def __init__(self, parent: QWidget, x_pos: int) -> None:
super().__init__(parent)
self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
self.setGeometry(x_pos, 0, 10, 10)
def test_game_card_navigation_skips_hidden_cards(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
container = QWidget()
container.show()
next_card = DummyCard(container, NEXT_CARD_X)
hidden_card = DummyCard(container, HIDDEN_CARD_X)
first_card = DummyCard(container, FIRST_CARD_X)
first_card.show()
hidden_card.hide()
next_card.show()
app.processEvents()
monkeypatch.setattr(input_manager, "AnimatedCard", DummyCard)
monkeypatch.setattr(input_dpad, "AnimatedCard", DummyCard)
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, SimpleNamespace(tabButtons={0: QWidget()}))
first_card.setFocus(Qt.FocusReason.OtherFocusReason)
manager._navigate_game_cards(container, 0, PAD_DPAD_X, 1)
assert QApplication.focusWidget() is next_card
manager._navigate_game_cards(container, 0, PAD_DPAD_X, -1)
assert QApplication.focusWidget() is first_card
def test_card_grid_navigation_uses_visual_rows() -> None:
app = QApplication.instance() or QApplication([])
container = QWidget()
container.show()
bottom_right = DummyCard(container, NEXT_CARD_X)
bottom_right.move(NEXT_CARD_X, 20)
top_left = DummyCard(container, FIRST_CARD_X)
bottom_left = DummyCard(container, FIRST_CARD_X)
bottom_left.move(FIRST_CARD_X, 20)
top_right = DummyCard(container, NEXT_CARD_X)
for card in (bottom_right, top_left, bottom_left, top_right):
card.show()
app.processEvents()
manager = InputManager.__new__(InputManager)
top_left.setFocus(Qt.FocusReason.OtherFocusReason)
assert manager._navigate_card_grid(
[bottom_right, top_left, bottom_left, top_right], PAD_DPAD_X, 1
)
assert QApplication.focusWidget() is top_right
assert manager._navigate_card_grid(
[bottom_right, top_left, bottom_left, top_right], PAD_DPAD_Y, 1
)
assert QApplication.focusWidget() is bottom_right
def test_horizontal_library_navigation_wraps_at_both_ends() -> None:
app = QApplication.instance() or QApplication([])
container = QWidget()
layout = QHBoxLayout(container)
cards: list[QWidget] = [QPushButton() for _index in range(3)]
for card in cards:
layout.addWidget(card)
card.show()
container.show()
app.processEvents()
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(
game_library_manager=SimpleNamespace(
layout_mode="horizontal",
gamesListLayout=layout,
)
),
)
cards[-1].setFocus(Qt.FocusReason.OtherFocusReason)
assert manager._navigate_horizontal_library(cards, 0, PAD_DPAD_X, 1)
assert QApplication.focusWidget() is cards[0]
assert manager._navigate_horizontal_library(cards, 0, PAD_DPAD_X, -1)
assert QApplication.focusWidget() is cards[-1]
tile = FullLibraryTile(_tile_theme())
tile.setParent(container)
layout.addWidget(tile)
tile.show()
manager._parent.game_library_manager.layout_mode = "horizontal_top"
manager._parent.game_library_manager.fullLibraryTile = tile
navigable_cards = [*cards, tile]
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, 1)
assert QApplication.focusWidget() is tile
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, -1)
assert QApplication.focusWidget() is cards[-1]
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, 1)
assert QApplication.focusWidget() is tile
assert manager._navigate_horizontal_library(navigable_cards, 0, PAD_DPAD_X, 1)
assert QApplication.focusWidget() is cards[0]
def test_horizontal_autoinstall_navigation_uses_its_layout() -> None:
app = QApplication.instance() or QApplication([])
container = QWidget()
layout = QHBoxLayout(container)
cards: list[QWidget] = [QPushButton() for _index in range(3)]
for card in cards:
layout.addWidget(card)
card.show()
container.show()
app.processEvents()
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(
theme=SimpleNamespace(LIBRARY_LAYOUT_MODE="horizontal"),
autoInstallContainerLayout=layout,
),
)
cards[0].setFocus(Qt.FocusReason.OtherFocusReason)
assert manager._navigate_horizontal_library(cards, 1, PAD_DPAD_X, 1)
assert QApplication.focusWidget() is cards[1]
def test_full_library_tile_arrow_does_not_switch_tabs() -> None:
app = QApplication.instance() or QApplication([])
tile = FullLibraryTile(_tile_theme())
tile.show()
tile.setFocus(Qt.FocusReason.OtherFocusReason)
app.processEvents()
manager = InputManager.__new__(InputManager)
manager.file_explorer = None
switch_tab = MagicMock()
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(switchTab=switch_tab),
)
assert not manager._handle_input_tab_key(KEY_LEFT)
switch_tab.assert_not_called()
def test_backspace_uses_standard_back_navigation() -> None:
manager = InputManager.__new__(InputManager)
standard_back = MagicMock()
cast(Any, manager)._handle_standard_back = standard_back
assert manager._handle_input_back_key(QWidget())
standard_back.assert_called_once_with()
def test_library_toolbar_navigation_includes_delete_missing_button() -> None:
app = QApplication.instance() or QApplication([])
toolbar = QWidget()
toolbar.show()
widgets = []
for _index in range(5):
widget = QWidget(toolbar)
widget.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
widget.show()
widgets.append(widget)
app.processEvents()
parent = SimpleNamespace(
quickLaunchButton=widgets[0],
addGameButton=widgets[1],
searchEdit=widgets[2],
refreshButton=widgets[3],
deleteMissingExeButton=widgets[4],
libraryControlsButton=QWidget(toolbar),
stackedWidget=QStackedWidget(),
tabButtons={0: QWidget()},
)
parent.stackedWidget.addWidget(QWidget())
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, parent)
widgets[3].setFocus(Qt.FocusReason.OtherFocusReason)
handled = manager._handle_toolbar_navigation(PAD_DPAD_X, 1)
assert handled is True
assert QApplication.focusWidget() is widgets[4]
def test_library_filter_navigation_includes_only_installed_checkbox() -> None:
app = QApplication.instance() or QApplication([])
controls = QWidget()
controls.show()
widgets = [QComboBox(controls) for _ in range(4)] + [QCheckBox(controls)]
for widget in widgets:
widget.show()
app.processEvents()
parent = SimpleNamespace(
libraryControlsWidget=controls,
gamesSortCombo=widgets[0],
gamesDisplayCombo=widgets[1],
gamesBadgeViewCombo=widgets[2],
gamesLayoutCombo=widgets[3],
onlyInstalledCheckBox=widgets[4],
stackedWidget=SimpleNamespace(currentIndex=lambda: 0),
libraryControlsButton=QWidget(controls),
)
parent.libraryControlsButton.show()
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, parent)
assert manager._get_library_filter_widgets() == widgets
manager._get_library_toolbar_widgets = lambda: []
manager._focused_widget = QApplication.focusWidget
manager._focus_first_library_card = MagicMock(return_value=True)
widgets[0].setFocus()
for widget in widgets[1:]:
assert manager._handle_toolbar_navigation(PAD_DPAD_Y, 1)
assert QApplication.focusWidget() is widget
assert manager._handle_toolbar_navigation(PAD_DPAD_Y, 1)
manager._focus_first_library_card.assert_called_once()
for widget in reversed(widgets[:-1]):
assert manager._handle_toolbar_navigation(PAD_DPAD_Y, -1)
assert QApplication.focusWidget() is widget
assert manager._handle_toolbar_navigation(PAD_DPAD_Y, -1)
assert QApplication.focusWidget() is parent.libraryControlsButton
widgets[-1].hide()
assert manager._get_library_filter_widgets() == widgets[:-1]
controls.close()
def test_library_size_adjustment_uses_original_step() -> None:
app = QApplication.instance() or QApplication([])
slider = QSlider()
slider.setRange(100, 300)
slider.setValue(200)
slider.setTickInterval(25)
callbacks: list[bool] = []
parent = SimpleNamespace(
stackedWidget=SimpleNamespace(currentIndex=lambda: 0),
system_tab_index=4,
game_library_manager=SimpleNamespace(sizeSlider=slider),
on_slider_released=lambda: callbacks.append(True),
)
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, parent)
assert manager._adjust_active_slider(1)
assert slider.value() == 210
assert callbacks == [True]
assert app is not None
def test_system_volume_adjustment_uses_original_step() -> None:
app = QApplication.instance() or QApplication([])
section_stack = QStackedWidget()
for _index in range(5):
section_stack.addWidget(QWidget())
section_stack.setCurrentIndex(4)
slider = QSlider()
slider.setRange(0, 100)
slider.setValue(50)
slider.setPageStep(17)
callbacks: list[bool] = []
parent = SimpleNamespace(
stackedWidget=SimpleNamespace(currentIndex=lambda: 3),
system_tab_index=3,
systemSectionStack=section_stack,
audioVolumeSlider=slider,
_applySelectedAudioVolume=lambda: callbacks.append(True),
)
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, parent)
assert manager._adjust_active_slider(-1)
assert slider.value() == 45
assert callbacks == [True]
assert app is not None
def test_context_menu_button_routes_to_table_current_item() -> None:
app = QApplication.instance() or QApplication([])
table = QTableWidget(1, 1)
table.setItem(0, 0, QTableWidgetItem("Game"))
table.setCurrentCell(0, 0)
emitted = []
table.customContextMenuRequested.connect(emitted.append)
manager = InputManager.__new__(InputManager)
context_button = next(iter(input_manager.BUTTONS["context_menu"]))
assert manager._open_focused_context_menu(table, context_button)
item = table.item(0, 0)
assert item is not None
assert emitted == [table.visualItemRect(item).center()]
assert app is not None
def test_context_menu_button_ignores_widget_without_custom_menu() -> None:
app = QApplication.instance() or QApplication([])
widget = QWidget()
manager = InputManager.__new__(InputManager)
context_button = next(iter(input_manager.BUTTONS["context_menu"]))
assert not manager._open_focused_context_menu(widget, context_button)
assert app is not None
def test_popup_menu_buttons_activate_and_close_menu() -> None:
app = QApplication.instance() or QApplication([])
menu = QMenu()
action = menu.addAction("Launch")
triggered = []
action.triggered.connect(lambda: triggered.append(True))
menu.setActiveAction(action)
manager = InputManager.__new__(InputManager)
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
back_button = next(iter(input_manager.BUTTONS["back"]))
assert manager._handle_popup_menu_button(menu, confirm_button)
assert manager._handle_popup_menu_button(menu, back_button)
assert triggered == [True]
assert app is not None
def test_confirm_button_opens_combo_popup() -> None:
app = QApplication.instance() or QApplication([])
combo = QComboBox()
combo.addItems(["First", "Second"])
manager = InputManager.__new__(InputManager)
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
assert manager._handle_combo_button(combo, confirm_button)
assert combo.view().isVisible()
combo.hidePopup()
assert app is not None
@mark.parametrize("table_name", ["advanced_table", "favorites_table"])
def test_settings_gamepad_skips_separator_and_activates_download(
monkeypatch: MonkeyPatch, table_name: str,
) -> None:
from portprotonqt.dialogs.settings_dialog import ExeSettingsDialog
from portprotonqt.input_manager.constants import BUTTONS
from portprotonqt.input_manager.settings import SettingsInputMixin
app = QApplication.instance() or QApplication([])
dialog = QDialog()
table = QTableWidget(1, 2, dialog)
combo = QComboBox()
combo.addItem("Proton")
combo.insertSeparator(1)
combo.addItem("Download Wine/Proton...", "download_wine")
table.setCellWidget(0, 1, combo)
table.setCurrentCell(0, 1)
highlighted = []
combo.highlighted.connect(highlighted.append)
settings = SimpleNamespace(
original_display_values={"PW_WINE_USE": "Proton"},
portproton_path=None, input_manager=None,
)
opened = MagicMock()
monkeypatch.setattr("portprotonqt.dialogs.settings_dialog.show_proton_manager", opened)
combo.activated.connect(lambda index: ExeSettingsDialog._open_wine_manager_from_combo(
cast(ExeSettingsDialog, settings), index, combo, "PW_WINE_USE",
))
manager = SimpleNamespace(
settings_dialog=SimpleNamespace(advanced_table=None, settings_table=None, favorites_table=None),
_is_current_settings_tool_tab=lambda: False,
_handle_table_action_navigation=lambda *_args: False,
_get_dialog_action_buttons=lambda _dialog: [],
_get_current_settings_table=lambda: table,
_get_open_settings_combo=lambda: combo,
_handle_common_ui_elements=lambda _code: False,
)
setattr(manager.settings_dialog, table_name, table)
dialog.show()
combo.showPopup()
app.processEvents()
SettingsInputMixin.handle_settings_dpad(cast(SettingsInputMixin, manager), PAD_DPAD_Y, 1, 0)
assert combo.view().currentIndex().row() == 2
assert combo.currentText() == "Proton"
SettingsInputMixin.handle_settings_button(
cast(SettingsInputMixin, manager), next(iter(BUTTONS["confirm"])), 1,
)
opened.assert_called_once()
assert combo.currentText() == "Proton"
assert not combo.view().isVisible()
dialog.close()
def test_settings_combo_navigation_with_keyboard_events_intercepted() -> None:
from portprotonqt.input_manager.settings import SettingsInputMixin
class KeyFilter(QObject):
def eventFilter(self, obj: QObject, event: QEvent) -> bool:
return event.type() == QEvent.Type.KeyPress
app = QApplication.instance() or QApplication([])
dialog = QDialog()
table = QTableWidget(1, 2, dialog)
combo = QComboBox()
combo.addItems(["First", "Second", "Third"])
table.setCellWidget(0, 1, combo)
table.setCurrentCell(0, 1)
manager = SimpleNamespace(
settings_dialog=SimpleNamespace(advanced_table=table, settings_table=None),
_is_current_settings_tool_tab=lambda: False,
_handle_table_action_navigation=lambda *_args: False,
_get_dialog_action_buttons=lambda _dialog: [],
_get_current_settings_table=lambda: table,
)
key_filter = KeyFilter()
app.installEventFilter(key_filter)
try:
dialog.show()
combo.showPopup()
app.processEvents()
for direction, expected in ((1, 1), (1, 2), (1, 2), (-1, 1), (-1, 0), (-1, 0)):
SettingsInputMixin.handle_settings_dpad(cast(SettingsInputMixin, manager), PAD_DPAD_Y, direction, 0)
assert combo.currentIndex() == 0
assert combo.view().currentIndex().row() == expected
assert combo.view().isVisible()
finally:
app.removeEventFilter(key_filter)
combo.hidePopup()
dialog.close()
def test_user_conf_table_combo_gets_focus_and_opens() -> None:
app = QApplication.instance() or QApplication([])
table = QTableWidget(1, 2)
combo = QComboBox()
combo.addItems(["Default", "Yes", "No"])
table.setCellWidget(0, 1, combo)
table.setCurrentCell(0, 1)
table.show()
combo.show()
app.processEvents()
manager = InputManager.__new__(InputManager)
manager.settings_dialog = SimpleNamespace(settings_table=table)
manager._focus_settings_advanced_value_widget(table, 0)
assert QApplication.focusWidget() is combo
assert manager.handle_table_confirm(table)
assert combo.view().isVisible()
combo.hidePopup()
assert app is not None
def test_back_button_closes_visible_combo_popup() -> None:
app = QApplication.instance() or QApplication([])
combo = QComboBox()
combo.addItems(["First", "Second"])
combo.showPopup()
manager = InputManager.__new__(InputManager)
back_button = next(iter(input_manager.BUTTONS["back"]))
assert manager._handle_combo_button(combo, back_button)
assert not combo.view().isVisible()
assert app is not None
def test_list_confirm_emits_selection_actions() -> None:
app = QApplication.instance() or QApplication([])
view = QListView()
model = QStringListModel(["First", "Second"])
view.setModel(model)
view.setCurrentIndex(model.index(1, 0))
activated = []
clicked = []
view.activated.connect(activated.append)
view.clicked.connect(clicked.append)
manager = InputManager.__new__(InputManager)
manager._activate_list_view_selection(view)
assert [index.row() for index in activated] == [1]
assert [index.row() for index in clicked] == [1]
assert app is not None
def test_list_back_preserves_dialog_fallthrough() -> None:
app = QApplication.instance() or QApplication([])
view = QListView()
model = QStringListModel(["First"])
view.setModel(model)
view.setCurrentIndex(model.index(0, 0))
manager = InputManager.__new__(InputManager)
back_button = next(iter(input_manager.BUTTONS["back"]))
assert not manager._handle_list_view_button(view, back_button)
assert not view.selectionModel().hasSelection()
assert app is not None
def test_system_table_button_routes_action_and_sound(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
actions = []
sounds = []
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(
handleSystemTableGamepadAction=lambda _table, action: actions.append(action) or True,
),
)
monkeypatch.setattr(input_manager, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
monkeypatch.setattr(input_buttons, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
table = QTableWidget()
back_button = next(iter(input_manager.BUTTONS["back"]))
assert manager._handle_system_table_button(table, back_button)
assert actions == ["back"]
assert sounds == ["back"]
assert app is not None
def test_confirm_button_activates_table_callback(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
table = QTableWidget(1, 1)
table.setItem(0, 0, QTableWidgetItem("Game"))
table.setCurrentCell(0, 0)
activated = []
table._on_confirm_callback = lambda _table, row, column: activated.append( # type: ignore[attr-defined]
(row, column)
)
manager = InputManager.__new__(InputManager)
monkeypatch.setattr(
input_buttons, "SoundManager", lambda: SimpleNamespace(play=lambda _sound: None)
)
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
assert manager._handle_table_button(table, confirm_button)
assert activated == [(0, 0)]
assert app is not None
def test_confirm_button_routes_line_edit_to_keyboard() -> None:
app = QApplication.instance() or QApplication([])
shown_for = []
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(keyboard=SimpleNamespace(show_for_widget=shown_for.append)),
)
line_edit = QLineEdit()
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
assert manager._route_button_to_text_input(QWidget(), line_edit, confirm_button)
assert shown_for == [line_edit]
assert app is not None
def test_prev_dir_button_focuses_search_for_current_tab() -> None:
app = QApplication.instance() or QApplication([])
window = QWidget()
search = QLineEdit(window)
window.show()
search.show()
app.processEvents()
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(
keyboard=None,
stackedWidget=SimpleNamespace(currentIndex=lambda: 0),
searchEdit=search,
),
)
prev_dir_button = next(iter(input_manager.BUTTONS["prev_dir"]))
assert manager._route_button_to_text_input(window, None, prev_dir_button)
assert search.hasFocus()
def test_system_quick_button_routes_add_game_and_sound(monkeypatch: MonkeyPatch) -> None:
actions = []
sounds = []
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(handleSystemGamepadAction=lambda action: actions.append(action) or True),
)
monkeypatch.setattr(input_manager, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
monkeypatch.setattr(input_buttons, "SoundManager", lambda: SimpleNamespace(play=sounds.append))
add_button = next(iter(input_manager.BUTTONS["add_game"]))
assert manager._handle_system_quick_button(add_button)
assert actions == ["add_game"]
assert sounds == ["open"]
def test_standard_confirm_activates_focused_widget(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
activations = []
sounds = []
focused = QWidget()
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(activateFocusedWidget=lambda: activations.append(True)),
)
monkeypatch.setattr(
input_manager,
"SoundManager",
lambda: SimpleNamespace(play_widget_sound=sounds.append),
)
monkeypatch.setattr(
input_buttons,
"SoundManager",
lambda: SimpleNamespace(play_widget_sound=sounds.append),
)
confirm_button = next(iter(input_manager.BUTTONS["confirm"]))
manager._handle_standard_button(focused, confirm_button, 1)
assert activations == []
app.processEvents()
assert activations == [True]
assert sounds == [focused]
def test_guide_select_combination_refreshes_games() -> None:
timer_events: list[str | int] = []
refreshes: list[bool] = []
manager: Any = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(refreshGames=lambda: refreshes.append(True)),
)
manager.guide_timer = SimpleNamespace(
start=lambda timeout: timer_events.append(timeout),
stop=lambda: timer_events.append("stop"),
)
manager.guide_combination_timeout = 0.3
manager.guide_held = False
manager.guide_pressed_time = 0
manager.select_pressed_time = 0
manager.in_guide_combination_attempt = False
guide_button = next(iter(input_manager.BUTTONS["guide"]))
menu_button = next(iter(input_manager.BUTTONS["menu"]))
assert manager._handle_guide_combination(guide_button, 1.0)
assert manager._handle_guide_combination(menu_button, 1.2)
assert timer_events == [300, "stop"]
assert refreshes == [True]
assert manager.guide_held is False
def test_dialog_surface_receives_connected_input_signals() -> None:
app = QApplication.instance() or QApplication([])
button_events: list[tuple[int, int]] = []
dpad_events: list[tuple[int, int, float]] = []
default_events: list[tuple[int, int]] = []
manager: Any = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager._parent = SimpleNamespace(boot_animation=None)
manager._input_surfaces = []
manager._input_surface_base_state = None
manager._gamepad_handling_enabled = False
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
manager.current_dpad_code = None
manager.current_dpad_value = 0
manager._handle_default_button = lambda code, value: default_events.append((code, value))
manager.button_event.connect(manager.handle_button_slot)
manager.dpad_moved.connect(manager.handle_dpad_slot)
manager._setup_mode_handlers(
object(),
lambda code, value: button_events.append((code, value)),
lambda code, value, now: dpad_events.append((code, value, now)),
"settings_dialog",
)
manager.button_event.emit(1, 1)
manager.dpad_moved.emit(PAD_DPAD_Y, 1, 2.0)
assert button_events == [(1, 1)]
assert dpad_events == [(PAD_DPAD_Y, 1, 2.0)]
assert default_events == []
manager._restore_original_handlers("settings_dialog")
manager.button_event.emit(2, 1)
assert default_events == [(2, 1)]
assert app is not None
def test_gamepad_ui_events_are_queued_after_polling() -> None:
app = QApplication.instance() or QApplication([])
events: list[tuple[int, int]] = []
manager: Any = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager._parent = SimpleNamespace(boot_animation=None)
manager._input_surfaces = []
manager._handle_default_button = lambda code, value: events.append((code, value))
manager.button_event.connect(
manager.handle_button_slot,
Qt.ConnectionType.QueuedConnection,
)
manager.button_event.emit(1, 1)
assert events == []
app.processEvents()
assert events == [(1, 1)]
def test_dialog_surface_disconnects_owned_callbacks() -> None:
callback_events: list[tuple[int, ...]] = []
manager: Any = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager._input_surfaces = []
manager._input_surface_base_state = None
manager._gamepad_handling_enabled = False
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
manager.current_dpad_code = None
manager.current_dpad_value = 0
manager._setup_mode_handlers(object(), lambda *_args: None, lambda *_args: None, "dialog")
manager.connect_surface_updates("dialog", lambda *args: callback_events.append(args))
manager.button_event.emit(1, 1)
manager._restore_original_handlers("dialog")
manager.button_event.emit(2, 1)
manager.dpad_moved.emit(PAD_DPAD_Y, 1, 2.0)
assert callback_events == [(1, 1)]
def test_nested_input_surfaces_restore_base_state() -> None:
manager: Any = InputManager.__new__(InputManager)
manager._input_surfaces = []
manager._input_surface_base_state = None
manager._gamepad_handling_enabled = False
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
manager.current_dpad_code = None
manager.current_dpad_value = 0
first_events: list[int] = []
second_events: list[int] = []
manager._setup_mode_handlers(
object(), lambda code, _value: first_events.append(code), lambda *_args: None,
"settings_dialog",
)
manager._setup_mode_handlers(
object(), lambda code, _value: second_events.append(code), lambda *_args: None,
"file_explorer",
)
manager._restore_original_handlers("settings_dialog")
assert manager._route_surface_button(1, 1)
assert first_events == []
assert second_events == [1]
assert manager._gamepad_handling_enabled is True
manager._restore_original_handlers("file_explorer")
assert manager._gamepad_handling_enabled is False
assert not manager._route_surface_button(2, 1)
def test_gamepad_polling_uses_qt_event_loop() -> None:
app = QApplication.instance() or QApplication([])
checks: list[bool] = []
manager: Any = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager.check_gamepad = lambda: checks.append(True)
manager.gamepad_hotplug.connect(lambda _action: None)
manager.init_gamepad()
assert checks == [True]
assert manager.gamepad_poll_timer.isActive()
assert manager.gamepad_poll_timer.interval() == 10
assert manager.gamepad_poll_timer.thread() is manager.thread()
manager.gamepad_poll_timer.stop()
assert app is not None
def test_gamepad_poll_reports_disconnected_device() -> None:
actions: list[str] = []
updates: list[bool] = []
manager: Any = InputManager.__new__(InputManager)
QObject.__init__(manager)
manager.running = True
manager._gamepad_polling_suspended = False
manager.gamepad = SimpleNamespace(
update=lambda: updates.append(True),
connected=lambda: False,
)
manager.gamepad_hotplug.connect(actions.append)
manager._poll_gamepad()
assert updates == [True]
assert actions == ["remove"]
def test_gamepad_poll_refreshes_type_when_active_device_changes(
monkeypatch: MonkeyPatch,
) -> None:
refreshed: list[bool] = []
manager: Any = InputManager.__new__(InputManager)
manager.running = True
manager._gamepad_polling_suspended = False
manager.gamepad = SimpleNamespace(
update=lambda: True,
connected=lambda: True,
active_instance_id=7,
sdl_type=SDL_GAMEPAD_TYPE_PS5,
)
manager._reset_input_state = lambda: setattr(
manager, "gamepad_type", GamepadType.UNKNOWN,
)
manager._refresh_gamepad_ui = lambda: refreshed.append(True)
manager._poll_button_events = lambda *_args: None
manager._handle_pending_menu_fullscreen = lambda *_args: None
manager._poll_hat_events = lambda *_args: None
manager._poll_axis_events = lambda *_args: None
manager.last_update = 0.0
manager.update_interval = float("inf")
monkeypatch.setattr(input_runtime.gamepad_config, "get_gamepad_type", lambda: "auto")
manager._poll_gamepad()
assert manager.gamepad_type == GamepadType.PLAYSTATION
assert refreshed == [True]
def test_suspend_gamepad_polling_sets_runtime_guard() -> None:
manager: Any = InputManager.__new__(InputManager)
manager._gamepad_polling_suspended = False
manager._gamepad_handling_enabled = True
manager.dpad_timer = SimpleNamespace(stop=lambda: None)
manager.nav_timer = SimpleNamespace(stop=lambda: None)
manager.suspend_gamepad_polling()
assert manager._gamepad_polling_suspended is True
assert manager._gamepad_handling_enabled is False
def test_dialog_dpad_moves_focus_forward() -> None:
app = QApplication.instance() or QApplication([])
dialog = QDialog()
first_button = QPushButton(dialog)
second_button = QPushButton(dialog)
first_button.move(0, 0)
second_button.move(0, 30)
dialog.show()
first_button.show()
second_button.show()
app.processEvents()
first_button.setFocus(Qt.FocusReason.OtherFocusReason)
manager = InputManager.__new__(InputManager)
assert manager._handle_dialog_dpad(dialog, PAD_DPAD_Y, 1)
assert QApplication.focusWidget() is second_button
def test_list_dpad_moves_current_row() -> None:
app = QApplication.instance() or QApplication([])
view = QListView()
model = QStringListModel(["First", "Second"])
view.setModel(model)
view.setCurrentIndex(model.index(0, 0))
manager = InputManager.__new__(InputManager)
assert manager._handle_list_dpad(view, PAD_DPAD_Y, 1)
assert view.currentIndex().row() == 1
assert app is not None
def test_first_card_row_moves_focus_to_toolbar(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
container = QWidget()
container.show()
card = DummyCard(container, FIRST_CARD_X)
toolbar_button = QWidget(container)
toolbar_button.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
toolbar_button.move(0, 30)
toolbar_button.show()
card.show()
app.processEvents()
card.setFocus(Qt.FocusReason.OtherFocusReason)
monkeypatch.setattr(input_manager, "AnimatedCard", DummyCard)
monkeypatch.setattr(input_dpad, "AnimatedCard", DummyCard)
parent = SimpleNamespace(
stackedWidget=SimpleNamespace(currentIndex=lambda: 0),
gamesListWidget=container,
)
manager: Any = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, parent)
manager._get_library_toolbar_widgets = lambda: [toolbar_button]
assert manager._focus_toolbar_from_first_card(PAD_DPAD_Y, -1)
assert QApplication.focusWidget() is toolbar_button
def test_system_section_horizontal_focuses_selected_button() -> None:
app = QApplication.instance() or QApplication([])
window = QWidget()
section_stack = QStackedWidget(window)
section_stack.addWidget(QWidget())
section_stack.addWidget(QWidget())
section_buttons = [QPushButton(window), QPushButton(window)]
section_buttons[1].move(0, 30)
window.show()
section_buttons[0].show()
section_buttons[1].show()
app.processEvents()
switched: list[int] = []
def switch_relative(step: int) -> bool:
switched.append(step)
section_stack.setCurrentIndex(1)
return True
parent = SimpleNamespace(
stackedWidget=SimpleNamespace(currentIndex=lambda: 3),
system_tab_index=3,
switchSystemSectionRelative=switch_relative,
systemSectionStack=section_stack,
systemSectionButtons=section_buttons,
)
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, parent)
assert manager._handle_system_section_horizontal(PAD_DPAD_X, 1, True)
assert switched == [1]
assert section_buttons[1].hasFocus()
assert app is not None
def test_detail_page_dpad_uses_visual_button_rows(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
page = QWidget()
buttons = [QPushButton(page) for _index in range(3)]
buttons[0].setGeometry(0, 0, 20, 20)
buttons[1].setGeometry(40, 0, 20, 20)
buttons[2].setGeometry(0, 40, 20, 20)
page.show()
for button in buttons:
button.show()
app.processEvents()
buttons[1].setFocus(Qt.FocusReason.OtherFocusReason)
monkeypatch.setattr(input_dpad, "AutoSizeButton", QPushButton)
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(
stackedWidget=SimpleNamespace(currentWidget=lambda: page),
currentDetailPage=page,
),
)
assert manager._handle_detail_page_dpad(PAD_DPAD_Y, 1)
assert QApplication.focusWidget() is buttons[2]
def test_page_vertical_dpad_moves_focus_forward() -> None:
app = QApplication.instance() or QApplication([])
page = QWidget()
first = QPushButton(page)
second = QPushButton(page)
second.move(0, 30)
page.show()
first.show()
second.show()
app.processEvents()
first.setFocus(Qt.FocusReason.OtherFocusReason)
manager = InputManager.__new__(InputManager)
manager._parent = cast(
MainWindowProtocol,
SimpleNamespace(stackedWidget=SimpleNamespace(currentWidget=lambda: page)),
)
assert manager._handle_page_vertical_dpad(PAD_DPAD_Y, 1)
assert QApplication.focusWidget() is second
def test_settings_grid_vertical_navigation_does_not_wrap_columns() -> None:
_app = QApplication.instance() or QApplication([])
dialog = QWidget()
checkboxes: list[QWidget] = [QCheckBox(dialog) for _index in range(4)]
for checkbox, position in zip(
checkboxes, ((0, 0), (100, 0), (0, 40), (100, 40)), strict=True
):
checkbox.move(*position)
manager = InputManager.__new__(InputManager)
manager.settings_dialog = dialog
assert manager._find_mangohud_vertical_grid_target(
checkboxes[0], 1, checkboxes
) is checkboxes[2]
assert manager._find_mangohud_vertical_grid_target(
checkboxes[2], 1, checkboxes
) is None
assert manager._find_mangohud_vertical_grid_target(
checkboxes[1], -1, checkboxes
) is None
@mark.parametrize("tool_tab", [False, True])
def test_settings_gamepad_reaches_clear_ppdb(monkeypatch: MonkeyPatch, tool_tab: bool) -> None:
app = QApplication.instance() or QApplication([])
dialog = QDialog()
layout = QHBoxLayout(dialog)
table = QTableWidget(1, 2)
table.setCurrentCell(0, 1)
layout.addWidget(table)
buttons = [QPushButton(name) for name in ("Apply", "Cancel", "Edit", "Clear")]
for button in buttons:
layout.addWidget(button)
manager = InputManager.__new__(InputManager)
settings = SimpleNamespace(
keyboard=None, advanced_table=table, settings_table=table,
mangohud_fps_widgets={}, mangohud_toggle_widgets={},
tab_widget=SimpleNamespace(currentWidget=lambda: table),
apply_button=buttons[0], cancel_button=buttons[1],
open_ppdb_button=buttons[2], clear_ppdb_button=buttons[3],
)
for name, value in vars(settings).items():
setattr(dialog, name, value)
manager.settings_dialog = cast(Any, dialog)
manager.dpad_timer = MagicMock()
manager.current_dpad_code = None
manager.current_dpad_value = 0
monkeypatch.setattr(manager, "_get_current_settings_table", lambda: table)
monkeypatch.setattr(manager, "_is_current_settings_tool_tab", lambda: tool_tab)
monkeypatch.setattr(manager, "_get_open_settings_combo", lambda: None)
monkeypatch.setattr(manager, "_get_mangohud_nav_sections", lambda: [[table]])
monkeypatch.setattr(manager, "_handle_common_ui_elements", lambda _code: False)
clicked = MagicMock()
buttons[3].clicked.connect(clicked)
dialog.show()
table.setFocus()
app.processEvents()
manager.handle_settings_dpad(PAD_DPAD_Y, 1, 0)
assert QApplication.focusWidget() is buttons[0]
for button in buttons[1:]:
manager.handle_settings_dpad(PAD_DPAD_X, 1, 0)
assert QApplication.focusWidget() is button
manager.handle_settings_button(next(iter(input_manager.BUTTONS["confirm"])), 1)
clicked.assert_called_once()
manager.handle_settings_dpad(PAD_DPAD_Y, -1, 0)
assert QApplication.focusWidget() is table
dialog.close()
@mark.parametrize("mode", ["winetricks", "proton_manager"])
@mark.parametrize("empty", [False, True])
def test_manager_gamepad_table_actions(mode: str, empty: bool, monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
dialog = QDialog()
layout = QHBoxLayout(dialog)
table = QTableWidget(0 if empty else 2, 1)
layout.addWidget(table)
if not empty:
table.setCurrentCell(0, 0)
table.setRowHidden(1, True)
buttons = [QPushButton(name) for name in ("First", "Disabled", "Last")]
for button in buttons:
layout.addWidget(button)
buttons[1].setEnabled(False)
manager = InputManager.__new__(InputManager)
setattr(manager, mode + "_dialog", dialog)
manager.dpad_timer = MagicMock()
manager.current_dpad_code = None
manager.current_dpad_value = 0
monkeypatch.setattr(manager, "_handle_common_ui_elements", lambda _code: False)
clicked = MagicMock()
buttons[-1].clicked.connect(clicked)
navigate = getattr(manager, "handle_" + mode + "_dpad")
confirm = getattr(manager, "handle_" + mode + "_button")
dialog.show()
table.setFocus()
app.processEvents()
navigate(PAD_DPAD_Y, 1, 0)
assert QApplication.focusWidget() is buttons[0]
navigate(PAD_DPAD_X, 1, 0)
assert QApplication.focusWidget() is buttons[-1]
confirm(next(iter(input_manager.BUTTONS["confirm"])), 1)
clicked.assert_called_once()
navigate(PAD_DPAD_X, -1, 0)
assert QApplication.focusWidget() is buttons[0]
navigate(PAD_DPAD_Y, -1, 0)
assert QApplication.focusWidget() is table
dialog.close()
@mark.parametrize("tool", ["mangohud", "vkbasalt", "gamescope"])
def test_settings_tool_gamepad_reaches_action_buttons(tool: str, monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
dialog = cast(Any, QDialog())
layout = QHBoxLayout(dialog)
tool_tab = QWidget()
tool_layout = QHBoxLayout(tool_tab)
control = QLineEdit()
tool_layout.addWidget(control)
layout.addWidget(tool_tab)
button = QPushButton("Clear")
layout.addWidget(button)
dialog.keyboard = None
dialog.tab_widget = SimpleNamespace(currentWidget=lambda: tool_tab)
setattr(dialog, tool + "_tab", tool_tab)
dialog.mangohud_widgets = {}
dialog.mangohud_fps_widgets = {}
manager = InputManager.__new__(InputManager)
manager.settings_dialog = dialog
manager.dpad_timer = MagicMock()
manager.current_dpad_code = None
manager.current_dpad_value = 0
monkeypatch.setattr(manager, "_get_current_settings_table", lambda: None)
monkeypatch.setattr(manager, "_get_open_settings_combo", lambda: None)
monkeypatch.setattr(manager, "_get_mangohud_nav_sections", lambda: [[control]])
dialog.show()
control.setFocus()
app.processEvents()
manager.handle_settings_dpad(PAD_DPAD_Y, 1, 0)
assert QApplication.focusWidget() is button
manager.handle_settings_dpad(PAD_DPAD_Y, -1, 0)
assert QApplication.focusWidget() is control
dialog.close()
def test_confirm_in_dialog_uses_its_own_keyboard() -> None:
app = QApplication.instance() or QApplication([])
dialog = cast(Any, QDialog())
field = QLineEdit(dialog)
shown_for = []
dialog.keyboard = SimpleNamespace(show_for_widget=shown_for.append)
main_keyboard = MagicMock()
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, SimpleNamespace(keyboard=main_keyboard))
confirm = next(iter(input_manager.BUTTONS["confirm"]))
assert manager._route_button_to_text_input(dialog, field, confirm)
assert shown_for == [field]
main_keyboard.show_for_widget.assert_not_called()
assert app is not None
def test_dpad_stays_on_active_dialog_keyboard(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
dialog = cast(Any, QDialog())
field = QLineEdit(dialog)
key = QPushButton("Key", dialog)
key.move(0, 40)
down = MagicMock(side_effect=key.setFocus)
dialog.keyboard = SimpleNamespace(isVisible=lambda: True, move_focus_left=MagicMock(), move_focus_right=MagicMock(),
move_focus_up=MagicMock(), move_focus_down=down)
dialog.show()
dialog.activateWindow()
app.processEvents()
field.setFocus()
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, SimpleNamespace(keyboard=None, gamesListWidget=QWidget()))
manager.axis_moving = False
manager._gamepad_handling_enabled = True
navigation = MagicMock()
monkeypatch.setattr(manager, "_start_dpad_repeat", MagicMock())
monkeypatch.setattr(manager, "_route_dpad_navigation", navigation)
monkeypatch.setattr(QApplication, "activeWindow", lambda: dialog)
manager._handle_default_dpad(PAD_DPAD_Y, 1, 0.0)
down.assert_called_once()
navigation.assert_not_called()
assert QApplication.focusWidget() is key
dialog.close()
@mark.parametrize("mode", ["import", "exe", "directory"])
def test_file_picker_x_does_not_put_folder_in_executable_field(
tmp_path: Any, monkeypatch: MonkeyPatch, mode: str,
) -> None:
from PySide6.QtWidgets import QListWidget
from portprotonqt.dialogs.base import FileSelectedSignal
app = QApplication.instance() or QApplication([])
folder = tmp_path / "Games"
folder.mkdir()
picker = cast(Any, QDialog())
picker.current_path = str(tmp_path)
picker.directory_only = mode == "directory"
picker.file_list = QListWidget(picker)
picker.file_list.addItem("Games/")
picker.file_list.setCurrentRow(0)
picker.file_signal = FileSelectedSignal()
selected = []
picker.file_signal.file_selected.connect(selected.append)
action = QPushButton(picker)
if mode == "import":
action.setObjectName("gamepadAddButton")
clicked = MagicMock()
action.clicked.connect(clicked)
picker.show()
app.processEvents()
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, SimpleNamespace(keyboard=None))
manager.file_explorer = picker
monkeypatch.setattr(QApplication, "activeWindow", lambda: picker)
monkeypatch.setattr(QApplication, "activePopupWidget", lambda: None)
manager.handle_file_explorer_button(next(iter(input_manager.BUTTONS["add_game"])), 1)
assert clicked.call_count == int(mode == "import")
assert selected == ([str(folder)] if mode == "directory" else [])
assert picker.result() == (QDialog.DialogCode.Accepted if mode == "directory" else QDialog.DialogCode.Rejected)
picker.close()
def test_x_edits_keyboard_without_triggering_dialog_action(monkeypatch: MonkeyPatch) -> None:
app = QApplication.instance() or QApplication([])
dialog = cast(Any, QDialog())
keyboard = QFrame(dialog)
dialog.keyboard = keyboard
action = QPushButton(dialog)
action.setObjectName("gamepadAddButton")
clicked = MagicMock()
action.clicked.connect(clicked)
dialog.show()
app.processEvents()
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, SimpleNamespace(keyboard=None))
handled = MagicMock()
monkeypatch.setattr(manager, "_handle_common_ui_elements", lambda _button: False)
monkeypatch.setattr(manager, "handle_virtual_keyboard", handled)
monkeypatch.setattr(input_buttons, "VirtualKeyboard", QFrame)
monkeypatch.setattr(QApplication, "activeWindow", lambda: dialog)
button = next(iter(input_manager.BUTTONS["add_game"]))
manager._handle_default_button(button, 1)
handled.assert_called_once_with(button, 1)
clicked.assert_not_called()
dialog.close()
@mark.parametrize("row", [0, 1])
def test_gamepad_combo_confirm_emits_activation(row: int) -> None:
application = QApplication.instance() or QApplication([])
combo = QComboBox()
combo.addItems(["GOG", "PortProton"])
activated = []
combo.activated.connect(activated.append)
combo.show()
combo.showPopup()
combo.view().setCurrentIndex(combo.model().index(row, 0))
manager = InputManager.__new__(InputManager)
confirm = next(iter(input_manager.BUTTONS["confirm"]))
assert manager._handle_list_view_button(combo.view(), confirm)
assert activated == [row]
assert combo.currentIndex() == row
assert not combo.view().isVisible()
combo.close()
application.processEvents()
def test_readonly_combo_confirm_opens_popup_without_keyboard() -> None:
application = QApplication.instance() or QApplication([])
combo = QComboBox()
combo.addItems(["GOG", "PortProton"])
combo.setEditable(True)
field = combo.lineEdit()
assert field is not None
field.setReadOnly(True)
keyboard = MagicMock()
manager = InputManager.__new__(InputManager)
manager._parent = cast(MainWindowProtocol, SimpleNamespace(keyboard=keyboard))
confirm = next(iter(input_manager.BUTTONS["confirm"]))
combo.show()
assert not manager._route_button_to_text_input(combo, field, confirm)
assert manager._handle_combo_button(field, confirm)
assert combo.view().isVisible()
keyboard.show_for_widget.assert_not_called()
combo.hidePopup()
combo.close()
application.processEvents()
def test_confirm_on_open_combo_activates_highlighted_row() -> None:
application = QApplication.instance() or QApplication([])
combo = QComboBox()
combo.addItems(["GOG", "PortProton"])
activated = []
combo.activated.connect(activated.append)
combo.show()
combo.showPopup()
combo.view().setCurrentIndex(combo.model().index(1, 0))
manager = InputManager.__new__(InputManager)
confirm = next(iter(input_manager.BUTTONS["confirm"]))
assert manager._handle_combo_button(combo, confirm)
assert activated == [1]
assert not combo.view().isVisible()
combo.close()
application.processEvents()
@mark.parametrize("direction", [-1, 1])
@mark.parametrize("column", [0, 1])
def test_run_after_dpad_reaches_delete_from_entry(direction: int, column: int) -> None:
from portprotonqt.input_manager.settings import SettingsInputMixin
app = QApplication.instance() or QApplication([])
table = QTableWidget(1, 2)
entry = QLineEdit("game.exe")
remove = QPushButton("delete")
table.setCellWidget(0, 0, entry)
table.setCellWidget(0, 1, remove)
manager = SimpleNamespace(settings_dialog=SimpleNamespace(advanced_table=table))
table.show()
table.activateWindow()
table.setCurrentCell(0, column)
entry.setFocus()
app.processEvents()
assert SettingsInputMixin._move_settings_inline_button_focus(cast(SettingsInputMixin, manager), table, direction)
assert QApplication.focusWidget() == remove
assert SettingsInputMixin._move_settings_inline_button_focus(cast(SettingsInputMixin, manager), table, -direction)
assert QApplication.focusWidget() == entry
table.close()
table.deleteLater()