bauiv1lib.settings.gamepad

   1# Released under the MIT License. See LICENSE for details.
   2#
   3# pylint: disable=too-many-lines
   4"""Settings UI functionality related to gamepads."""
   5
   6from __future__ import annotations
   7
   8import logging
   9from typing import TYPE_CHECKING
  10
  11from bauiv1lib.popup import PopupMenuWindow
  12import bascenev1 as bs
  13import bauiv1 as bui
  14
  15if TYPE_CHECKING:
  16    from typing import Any, Callable
  17    from bauiv1lib.popup import PopupWindow
  18
  19
  20class GamepadSettingsWindow(bui.Window):
  21    """Window for configuring a gamepad."""
  22
  23    # pylint: disable=too-many-public-methods
  24
  25    def __init__(
  26        self,
  27        gamepad: bs.InputDevice,
  28        is_main_menu: bool = True,
  29        transition: str = 'in_right',
  30        transition_out: str = 'out_right',
  31        settings: dict | None = None,
  32    ):
  33        self._input = gamepad
  34
  35        # If our input-device went away, just return an empty zombie.
  36        if not self._input:
  37            return
  38
  39        self._name = self._input.name
  40
  41        self._r = 'configGamepadWindow'
  42        self._transition_out = transition_out
  43
  44        # We're a secondary gamepad if supplied with settings.
  45        self._is_secondary = settings is not None
  46        self._ext = '_B' if self._is_secondary else ''
  47        self._is_main_menu = is_main_menu
  48        self._displayname = self._name
  49        self._width = 700 if self._is_secondary else 730
  50        self._height = 440 if self._is_secondary else 450
  51        self._spacing = 40
  52        assert bui.app.classic is not None
  53        uiscale = bui.app.ui_v1.uiscale
  54        super().__init__(
  55            root_widget=bui.containerwidget(
  56                size=(self._width, self._height),
  57                scale=(
  58                    1.63
  59                    if uiscale is bui.UIScale.SMALL
  60                    else 1.35 if uiscale is bui.UIScale.MEDIUM else 1.0
  61                ),
  62                stack_offset=(
  63                    (-20, -16) if uiscale is bui.UIScale.SMALL else (0, 0)
  64                ),
  65                transition=transition,
  66            )
  67        )
  68
  69        self._settings: dict[str, int] = {}
  70        if not self._is_secondary:
  71            self._get_config_mapping()
  72        # Don't ask to config joysticks while we're in here.
  73        self._rebuild_ui()
  74
  75    def _get_config_mapping(self, default: bool = False) -> None:
  76        for button in [
  77            'buttonJump',
  78            'buttonJump_B',
  79            'buttonPunch',
  80            'buttonPunch_B',
  81            'buttonBomb',
  82            'buttonBomb_B',
  83            'buttonPickUp',
  84            'buttonPickUp_B',
  85            'buttonStart',
  86            'buttonStart_B',
  87            'buttonStart2',
  88            'buttonStart2_B',
  89            'buttonUp',
  90            'buttonUp_B',
  91            'buttonDown',
  92            'buttonDown_B',
  93            'buttonLeft',
  94            'buttonLeft_B',
  95            'buttonRight',
  96            'buttonRight_B',
  97            'buttonRun1',
  98            'buttonRun1_B',
  99            'buttonRun2',
 100            'buttonRun2_B',
 101            'triggerRun1',
 102            'triggerRun1_B',
 103            'triggerRun2',
 104            'triggerRun2_B',
 105            'buttonIgnored',
 106            'buttonIgnored_B',
 107            'buttonIgnored2',
 108            'buttonIgnored2_B',
 109            'buttonIgnored3',
 110            'buttonIgnored3_B',
 111            'buttonIgnored4',
 112            'buttonIgnored4_B',
 113            'buttonVRReorient',
 114            'buttonVRReorient_B',
 115            'analogStickDeadZone',
 116            'analogStickDeadZone_B',
 117            'dpad',
 118            'dpad_B',
 119            'unassignedButtonsRun',
 120            'unassignedButtonsRun_B',
 121            'startButtonActivatesDefaultWidget',
 122            'startButtonActivatesDefaultWidget_B',
 123            'uiOnly',
 124            'uiOnly_B',
 125            'ignoreCompletely',
 126            'ignoreCompletely_B',
 127            'autoRecalibrateAnalogStick',
 128            'autoRecalibrateAnalogStick_B',
 129            'analogStickLR',
 130            'analogStickLR_B',
 131            'analogStickUD',
 132            'analogStickUD_B',
 133            'enableSecondary',
 134        ]:
 135            assert bui.app.classic is not None
 136            val = bui.app.classic.get_input_device_mapped_value(
 137                self._input, button, default
 138            )
 139            if val != -1:
 140                self._settings[button] = val
 141
 142    def _rebuild_ui(self, is_reset: bool = False) -> None:
 143        # pylint: disable=too-many-statements
 144
 145        assert bui.app.classic is not None
 146
 147        # Clear existing UI.
 148        for widget in self._root_widget.get_children():
 149            widget.delete()
 150
 151        self._textwidgets: dict[str, bui.Widget] = {}
 152
 153        back_button: bui.Widget | None
 154
 155        if self._is_secondary:
 156            back_button = bui.buttonwidget(
 157                parent=self._root_widget,
 158                position=(self._width - 180, self._height - 65),
 159                autoselect=True,
 160                size=(160, 60),
 161                label=bui.Lstr(resource='doneText'),
 162                scale=0.9,
 163                on_activate_call=self._save,
 164            )
 165            bui.containerwidget(
 166                edit=self._root_widget,
 167                start_button=back_button,
 168                on_cancel_call=back_button.activate,
 169            )
 170            cancel_button = None
 171        else:
 172            cancel_button = bui.buttonwidget(
 173                parent=self._root_widget,
 174                position=(51, self._height - 65),
 175                autoselect=True,
 176                size=(160, 60),
 177                label=bui.Lstr(resource='cancelText'),
 178                scale=0.9,
 179                on_activate_call=self._cancel,
 180            )
 181            bui.containerwidget(
 182                edit=self._root_widget, cancel_button=cancel_button
 183            )
 184
 185        save_button: bui.Widget | None
 186        if not self._is_secondary:
 187            save_button = bui.buttonwidget(
 188                parent=self._root_widget,
 189                position=(self._width - 195, self._height - 65),
 190                size=(180, 60),
 191                autoselect=True,
 192                label=bui.Lstr(resource='saveText'),
 193                scale=0.9,
 194                on_activate_call=self._save,
 195            )
 196            bui.containerwidget(
 197                edit=self._root_widget, start_button=save_button
 198            )
 199        else:
 200            save_button = None
 201
 202        if not self._is_secondary:
 203            v = self._height - 59
 204            bui.textwidget(
 205                parent=self._root_widget,
 206                position=(0, v + 5),
 207                size=(self._width, 25),
 208                text=bui.Lstr(resource=self._r + '.titleText'),
 209                color=bui.app.ui_v1.title_color,
 210                maxwidth=310,
 211                h_align='center',
 212                v_align='center',
 213            )
 214            v -= 48
 215
 216            bui.textwidget(
 217                parent=self._root_widget,
 218                position=(0, v + 3),
 219                size=(self._width, 25),
 220                text=self._name,
 221                color=bui.app.ui_v1.infotextcolor,
 222                maxwidth=self._width * 0.9,
 223                h_align='center',
 224                v_align='center',
 225            )
 226            v -= self._spacing * 1
 227
 228            bui.textwidget(
 229                parent=self._root_widget,
 230                position=(50, v + 10),
 231                size=(self._width - 100, 30),
 232                text=bui.Lstr(resource=self._r + '.appliesToAllText'),
 233                maxwidth=330,
 234                scale=0.65,
 235                color=(0.5, 0.6, 0.5, 1.0),
 236                h_align='center',
 237                v_align='center',
 238            )
 239            v -= 70
 240            self._enable_check_box = None
 241        else:
 242            v = self._height - 49
 243            bui.textwidget(
 244                parent=self._root_widget,
 245                position=(0, v + 5),
 246                size=(self._width, 25),
 247                text=bui.Lstr(resource=self._r + '.secondaryText'),
 248                color=bui.app.ui_v1.title_color,
 249                maxwidth=300,
 250                h_align='center',
 251                v_align='center',
 252            )
 253            v -= self._spacing * 1
 254
 255            bui.textwidget(
 256                parent=self._root_widget,
 257                position=(50, v + 10),
 258                size=(self._width - 100, 30),
 259                text=bui.Lstr(resource=self._r + '.secondHalfText'),
 260                maxwidth=300,
 261                scale=0.65,
 262                color=(0.6, 0.8, 0.6, 1.0),
 263                h_align='center',
 264            )
 265            self._enable_check_box = bui.checkboxwidget(
 266                parent=self._root_widget,
 267                position=(self._width * 0.5 - 80, v - 73),
 268                value=self.get_enable_secondary_value(),
 269                autoselect=True,
 270                on_value_change_call=self._enable_check_box_changed,
 271                size=(200, 30),
 272                text=bui.Lstr(resource=self._r + '.secondaryEnableText'),
 273                scale=1.2,
 274            )
 275            v = self._height - 205
 276
 277        h_offs = 160
 278        dist = 70
 279        d_color = (0.4, 0.4, 0.8)
 280        sclx = 1.2
 281        scly = 0.98
 282        dpm = bui.Lstr(resource=self._r + '.pressAnyButtonOrDpadText')
 283        dpm2 = bui.Lstr(resource=self._r + '.ifNothingHappensTryAnalogText')
 284        self._capture_button(
 285            pos=(h_offs, v + scly * dist),
 286            color=d_color,
 287            button='buttonUp' + self._ext,
 288            texture=bui.gettexture('upButton'),
 289            scale=1.0,
 290            message=dpm,
 291            message2=dpm2,
 292        )
 293        self._capture_button(
 294            pos=(h_offs - sclx * dist, v),
 295            color=d_color,
 296            button='buttonLeft' + self._ext,
 297            texture=bui.gettexture('leftButton'),
 298            scale=1.0,
 299            message=dpm,
 300            message2=dpm2,
 301        )
 302        self._capture_button(
 303            pos=(h_offs + sclx * dist, v),
 304            color=d_color,
 305            button='buttonRight' + self._ext,
 306            texture=bui.gettexture('rightButton'),
 307            scale=1.0,
 308            message=dpm,
 309            message2=dpm2,
 310        )
 311        self._capture_button(
 312            pos=(h_offs, v - scly * dist),
 313            color=d_color,
 314            button='buttonDown' + self._ext,
 315            texture=bui.gettexture('downButton'),
 316            scale=1.0,
 317            message=dpm,
 318            message2=dpm2,
 319        )
 320
 321        dpm3 = bui.Lstr(resource=self._r + '.ifNothingHappensTryDpadText')
 322        self._capture_button(
 323            pos=(h_offs + 130, v - 125),
 324            color=(0.4, 0.4, 0.6),
 325            button='analogStickLR' + self._ext,
 326            maxwidth=140,
 327            texture=bui.gettexture('analogStick'),
 328            scale=1.2,
 329            message=bui.Lstr(resource=self._r + '.pressLeftRightText'),
 330            message2=dpm3,
 331        )
 332
 333        self._capture_button(
 334            pos=(self._width * 0.5, v),
 335            color=(0.4, 0.4, 0.6),
 336            button='buttonStart' + self._ext,
 337            texture=bui.gettexture('startButton'),
 338            scale=0.7,
 339        )
 340
 341        h_offs = self._width - 160
 342
 343        self._capture_button(
 344            pos=(h_offs, v + scly * dist),
 345            color=(0.6, 0.4, 0.8),
 346            button='buttonPickUp' + self._ext,
 347            texture=bui.gettexture('buttonPickUp'),
 348            scale=1.0,
 349        )
 350        self._capture_button(
 351            pos=(h_offs - sclx * dist, v),
 352            color=(0.7, 0.5, 0.1),
 353            button='buttonPunch' + self._ext,
 354            texture=bui.gettexture('buttonPunch'),
 355            scale=1.0,
 356        )
 357        self._capture_button(
 358            pos=(h_offs + sclx * dist, v),
 359            color=(0.5, 0.2, 0.1),
 360            button='buttonBomb' + self._ext,
 361            texture=bui.gettexture('buttonBomb'),
 362            scale=1.0,
 363        )
 364        self._capture_button(
 365            pos=(h_offs, v - scly * dist),
 366            color=(0.2, 0.5, 0.2),
 367            button='buttonJump' + self._ext,
 368            texture=bui.gettexture('buttonJump'),
 369            scale=1.0,
 370        )
 371
 372        self._more_button = bui.buttonwidget(
 373            parent=self._root_widget,
 374            autoselect=True,
 375            label='...',
 376            text_scale=0.9,
 377            color=(0.45, 0.4, 0.5),
 378            textcolor=(0.65, 0.6, 0.7),
 379            position=(self._width - 300, 30),
 380            size=(130, 40),
 381            on_activate_call=self._do_more,
 382        )
 383
 384        try:
 385            if cancel_button is not None and save_button is not None:
 386                bui.widget(edit=cancel_button, right_widget=save_button)
 387                bui.widget(edit=save_button, left_widget=cancel_button)
 388                if is_reset:
 389                    bui.containerwidget(
 390                        edit=self._root_widget,
 391                        selected_child=self._more_button,
 392                    )
 393        except Exception:
 394            logging.exception('Error wiring up gamepad config window.')
 395
 396    def get_r(self) -> str:
 397        """(internal)"""
 398        return self._r
 399
 400    def get_advanced_button(self) -> bui.Widget:
 401        """(internal)"""
 402        return self._more_button
 403
 404    def get_is_secondary(self) -> bool:
 405        """(internal)"""
 406        return self._is_secondary
 407
 408    def get_settings(self) -> dict[str, Any]:
 409        """(internal)"""
 410        assert self._settings is not None
 411        return self._settings
 412
 413    def get_ext(self) -> str:
 414        """(internal)"""
 415        return self._ext
 416
 417    def get_input(self) -> bs.InputDevice:
 418        """(internal)"""
 419        return self._input
 420
 421    def _do_advanced(self) -> None:
 422        # pylint: disable=cyclic-import
 423        from bauiv1lib.settings import gamepadadvanced
 424
 425        gamepadadvanced.GamepadAdvancedSettingsWindow(self)
 426
 427    def _enable_check_box_changed(self, value: bool) -> None:
 428        assert self._settings is not None
 429        if value:
 430            self._settings['enableSecondary'] = 1
 431        else:
 432            # Just clear since this is default.
 433            if 'enableSecondary' in self._settings:
 434                del self._settings['enableSecondary']
 435
 436    def get_unassigned_buttons_run_value(self) -> bool:
 437        """(internal)"""
 438        assert self._settings is not None
 439        val = self._settings.get('unassignedButtonsRun', True)
 440        assert isinstance(val, bool)
 441        return val
 442
 443    def set_unassigned_buttons_run_value(self, value: bool) -> None:
 444        """(internal)"""
 445        assert self._settings is not None
 446        if value:
 447            if 'unassignedButtonsRun' in self._settings:
 448                # Clear since this is default.
 449                del self._settings['unassignedButtonsRun']
 450                return
 451        self._settings['unassignedButtonsRun'] = False
 452
 453    def get_start_button_activates_default_widget_value(self) -> bool:
 454        """(internal)"""
 455        assert self._settings is not None
 456        val = self._settings.get('startButtonActivatesDefaultWidget', True)
 457        assert isinstance(val, bool)
 458        return val
 459
 460    def set_start_button_activates_default_widget_value(
 461        self, value: bool
 462    ) -> None:
 463        """(internal)"""
 464        assert self._settings is not None
 465        if value:
 466            if 'startButtonActivatesDefaultWidget' in self._settings:
 467                # Clear since this is default.
 468                del self._settings['startButtonActivatesDefaultWidget']
 469                return
 470        self._settings['startButtonActivatesDefaultWidget'] = False
 471
 472    def get_ui_only_value(self) -> bool:
 473        """(internal)"""
 474        assert self._settings is not None
 475        val = self._settings.get('uiOnly', False)
 476        assert isinstance(val, bool)
 477        return val
 478
 479    def set_ui_only_value(self, value: bool) -> None:
 480        """(internal)"""
 481        assert self._settings is not None
 482        if not value:
 483            if 'uiOnly' in self._settings:
 484                # Clear since this is default.
 485                del self._settings['uiOnly']
 486                return
 487        self._settings['uiOnly'] = True
 488
 489    def get_ignore_completely_value(self) -> bool:
 490        """(internal)"""
 491        assert self._settings is not None
 492        val = self._settings.get('ignoreCompletely', False)
 493        assert isinstance(val, bool)
 494        return val
 495
 496    def set_ignore_completely_value(self, value: bool) -> None:
 497        """(internal)"""
 498        assert self._settings is not None
 499        if not value:
 500            if 'ignoreCompletely' in self._settings:
 501                # Clear since this is default.
 502                del self._settings['ignoreCompletely']
 503                return
 504        self._settings['ignoreCompletely'] = True
 505
 506    def get_auto_recalibrate_analog_stick_value(self) -> bool:
 507        """(internal)"""
 508        assert self._settings is not None
 509        val = self._settings.get('autoRecalibrateAnalogStick', False)
 510        assert isinstance(val, bool)
 511        return val
 512
 513    def set_auto_recalibrate_analog_stick_value(self, value: bool) -> None:
 514        """(internal)"""
 515        assert self._settings is not None
 516        if not value:
 517            if 'autoRecalibrateAnalogStick' in self._settings:
 518                # Clear since this is default.
 519                del self._settings['autoRecalibrateAnalogStick']
 520        else:
 521            self._settings['autoRecalibrateAnalogStick'] = True
 522
 523    def get_enable_secondary_value(self) -> bool:
 524        """(internal)"""
 525        assert self._settings is not None
 526        if not self._is_secondary:
 527            raise RuntimeError('Enable value only applies to secondary editor.')
 528        val = self._settings.get('enableSecondary', False)
 529        assert isinstance(val, bool)
 530        return val
 531
 532    def show_secondary_editor(self) -> None:
 533        """(internal)"""
 534        GamepadSettingsWindow(
 535            self._input,
 536            is_main_menu=False,
 537            settings=self._settings,
 538            transition='in_scale',
 539            transition_out='out_scale',
 540        )
 541
 542    def get_control_value_name(self, control: str) -> str | bui.Lstr:
 543        """(internal)"""
 544        # pylint: disable=too-many-return-statements
 545        assert self._settings is not None
 546        if control == 'analogStickLR' + self._ext:
 547            # This actually shows both LR and UD.
 548            sval1 = (
 549                self._settings['analogStickLR' + self._ext]
 550                if 'analogStickLR' + self._ext in self._settings
 551                else 5 if self._is_secondary else None
 552            )
 553            sval2 = (
 554                self._settings['analogStickUD' + self._ext]
 555                if 'analogStickUD' + self._ext in self._settings
 556                else 6 if self._is_secondary else None
 557            )
 558            assert isinstance(sval1, (int, type(None)))
 559            assert isinstance(sval2, (int, type(None)))
 560            if sval1 is not None and sval2 is not None:
 561                return (
 562                    self._input.get_axis_name(sval1)
 563                    + ' / '
 564                    + self._input.get_axis_name(sval2)
 565                )
 566            return bui.Lstr(resource=self._r + '.unsetText')
 567
 568        # If they're looking for triggers.
 569        if control in ['triggerRun1' + self._ext, 'triggerRun2' + self._ext]:
 570            if control in self._settings:
 571                return self._input.get_axis_name(self._settings[control])
 572            return bui.Lstr(resource=self._r + '.unsetText')
 573
 574        # Dead-zone.
 575        if control == 'analogStickDeadZone' + self._ext:
 576            if control in self._settings:
 577                return str(self._settings[control])
 578            return str(1.0)
 579
 580        # For dpad buttons: show individual buttons if any are set.
 581        # Otherwise show whichever dpad is set.
 582        dpad_buttons = [
 583            'buttonLeft' + self._ext,
 584            'buttonRight' + self._ext,
 585            'buttonUp' + self._ext,
 586            'buttonDown' + self._ext,
 587        ]
 588        if control in dpad_buttons:
 589            # If *any* dpad buttons are assigned, show only button assignments.
 590            if any(b in self._settings for b in dpad_buttons):
 591                if control in self._settings:
 592                    return self._input.get_button_name(self._settings[control])
 593                return bui.Lstr(resource=self._r + '.unsetText')
 594
 595            # No dpad buttons - show the dpad number for all 4.
 596            dpadnum = (
 597                self._settings['dpad' + self._ext]
 598                if 'dpad' + self._ext in self._settings
 599                else 2 if self._is_secondary else None
 600            )
 601            assert isinstance(dpadnum, (int, type(None)))
 602            if dpadnum is not None:
 603                return bui.Lstr(
 604                    value='${A} ${B}',
 605                    subs=[
 606                        ('${A}', bui.Lstr(resource=self._r + '.dpadText')),
 607                        (
 608                            '${B}',
 609                            str(dpadnum),
 610                        ),
 611                    ],
 612                )
 613            return bui.Lstr(resource=self._r + '.unsetText')
 614
 615        # Other buttons.
 616        if control in self._settings:
 617            return self._input.get_button_name(self._settings[control])
 618        return bui.Lstr(resource=self._r + '.unsetText')
 619
 620    def _gamepad_event(
 621        self,
 622        control: str,
 623        event: dict[str, Any],
 624        dialog: AwaitGamepadInputWindow,
 625    ) -> None:
 626        # pylint: disable=too-many-branches
 627        assert self._settings is not None
 628        ext = self._ext
 629
 630        # For our dpad-buttons we're looking for either a button-press or a
 631        # hat-switch press.
 632        if control in [
 633            'buttonUp' + ext,
 634            'buttonLeft' + ext,
 635            'buttonDown' + ext,
 636            'buttonRight' + ext,
 637        ]:
 638            if event['type'] in ['BUTTONDOWN', 'HATMOTION']:
 639                # If its a button-down.
 640                if event['type'] == 'BUTTONDOWN':
 641                    value = event['button']
 642                    self._settings[control] = value
 643
 644                # If its a dpad.
 645                elif event['type'] == 'HATMOTION':
 646                    # clear out any set dir-buttons
 647                    for btn in [
 648                        'buttonUp' + ext,
 649                        'buttonLeft' + ext,
 650                        'buttonRight' + ext,
 651                        'buttonDown' + ext,
 652                    ]:
 653                        if btn in self._settings:
 654                            del self._settings[btn]
 655                    if event['hat'] == (2 if self._is_secondary else 1):
 656                        self._settings['dpad' + ext] = event['hat']
 657
 658                # Update the 4 dpad button txt widgets.
 659                bui.textwidget(
 660                    edit=self._textwidgets['buttonUp' + ext],
 661                    text=self.get_control_value_name('buttonUp' + ext),
 662                )
 663                bui.textwidget(
 664                    edit=self._textwidgets['buttonLeft' + ext],
 665                    text=self.get_control_value_name('buttonLeft' + ext),
 666                )
 667                bui.textwidget(
 668                    edit=self._textwidgets['buttonRight' + ext],
 669                    text=self.get_control_value_name('buttonRight' + ext),
 670                )
 671                bui.textwidget(
 672                    edit=self._textwidgets['buttonDown' + ext],
 673                    text=self.get_control_value_name('buttonDown' + ext),
 674                )
 675                bui.getsound('gunCocking').play()
 676                dialog.die()
 677
 678        elif control == 'analogStickLR' + ext:
 679            if event['type'] == 'AXISMOTION':
 680                # Ignore small values or else we might get triggered by noise.
 681                if abs(event['value']) > 0.5:
 682                    axis = event['axis']
 683                    if axis == (5 if self._is_secondary else 1):
 684                        self._settings['analogStickLR' + ext] = axis
 685                    bui.textwidget(
 686                        edit=self._textwidgets['analogStickLR' + ext],
 687                        text=self.get_control_value_name('analogStickLR' + ext),
 688                    )
 689                    bui.getsound('gunCocking').play()
 690                    dialog.die()
 691
 692                    # Now launch the up/down listener.
 693                    AwaitGamepadInputWindow(
 694                        self._input,
 695                        'analogStickUD' + ext,
 696                        self._gamepad_event,
 697                        bui.Lstr(resource=self._r + '.pressUpDownText'),
 698                    )
 699
 700        elif control == 'analogStickUD' + ext:
 701            if event['type'] == 'AXISMOTION':
 702                # Ignore small values or else we might get triggered by noise.
 703                if abs(event['value']) > 0.5:
 704                    axis = event['axis']
 705
 706                    # Ignore our LR axis.
 707                    if 'analogStickLR' + ext in self._settings:
 708                        lr_axis = self._settings['analogStickLR' + ext]
 709                    else:
 710                        lr_axis = 5 if self._is_secondary else 1
 711                    if axis != lr_axis:
 712                        if axis == (6 if self._is_secondary else 2):
 713                            self._settings['analogStickUD' + ext] = axis
 714                        bui.textwidget(
 715                            edit=self._textwidgets['analogStickLR' + ext],
 716                            text=self.get_control_value_name(
 717                                'analogStickLR' + ext
 718                            ),
 719                        )
 720                        bui.getsound('gunCocking').play()
 721                        dialog.die()
 722        else:
 723            # For other buttons we just want a button-press.
 724            if event['type'] == 'BUTTONDOWN':
 725                value = event['button']
 726                self._settings[control] = value
 727
 728                # Update the button's text widget.
 729                bui.textwidget(
 730                    edit=self._textwidgets[control],
 731                    text=self.get_control_value_name(control),
 732                )
 733                bui.getsound('gunCocking').play()
 734                dialog.die()
 735
 736    def _capture_button(
 737        self,
 738        pos: tuple[float, float],
 739        color: tuple[float, float, float],
 740        texture: bui.Texture,
 741        button: str,
 742        scale: float = 1.0,
 743        message: bui.Lstr | None = None,
 744        message2: bui.Lstr | None = None,
 745        maxwidth: float = 80.0,
 746    ) -> bui.Widget:
 747        if message is None:
 748            message = bui.Lstr(resource=self._r + '.pressAnyButtonText')
 749        base_size = 79
 750        btn = bui.buttonwidget(
 751            parent=self._root_widget,
 752            position=(
 753                pos[0] - base_size * 0.5 * scale,
 754                pos[1] - base_size * 0.5 * scale,
 755            ),
 756            autoselect=True,
 757            size=(base_size * scale, base_size * scale),
 758            texture=texture,
 759            label='',
 760            color=color,
 761        )
 762
 763        # Make this in a timer so that it shows up on top of all other buttons.
 764
 765        def doit() -> None:
 766            uiscale = 0.9 * scale
 767            txt = bui.textwidget(
 768                parent=self._root_widget,
 769                position=(pos[0] + 0.0 * scale, pos[1] - 58.0 * scale),
 770                color=(1, 1, 1, 0.3),
 771                size=(0, 0),
 772                h_align='center',
 773                v_align='center',
 774                scale=uiscale,
 775                text=self.get_control_value_name(button),
 776                maxwidth=maxwidth,
 777            )
 778            self._textwidgets[button] = txt
 779            bui.buttonwidget(
 780                edit=btn,
 781                on_activate_call=bui.Call(
 782                    AwaitGamepadInputWindow,
 783                    self._input,
 784                    button,
 785                    self._gamepad_event,
 786                    message,
 787                    message2,
 788                ),
 789            )
 790
 791        bui.pushcall(doit)
 792        return btn
 793
 794    def _cancel(self) -> None:
 795        from bauiv1lib.settings.controls import ControlsSettingsWindow
 796
 797        # no-op if our underlying widget is dead or on its way out.
 798        if not self._root_widget or self._root_widget.transitioning_out:
 799            return
 800
 801        bui.containerwidget(
 802            edit=self._root_widget, transition=self._transition_out
 803        )
 804        if self._is_main_menu:
 805            assert bui.app.classic is not None
 806            bui.app.ui_v1.set_main_menu_window(
 807                ControlsSettingsWindow(transition='in_left').get_root_widget(),
 808                from_window=self._root_widget,
 809            )
 810
 811    def _reset(self) -> None:
 812        from bauiv1lib.confirm import ConfirmWindow
 813
 814        assert bui.app.classic is not None
 815
 816        # efro note: I think it's ok to reset without a confirm here
 817        # because the user can see pretty clearly what changes and can
 818        # cancel out of the settings window without saving if they want.
 819        if bool(False):
 820            ConfirmWindow(
 821                # TODO: Implement a translation string for this!
 822                'Are you sure you want to reset your button mapping?\n'
 823                'This will also reset your advanced mappings\n'
 824                'and secondary controller button mappings.',
 825                self._do_reset,
 826                width=490,
 827                height=150,
 828            )
 829        else:
 830            self._do_reset()
 831
 832    def _do_reset(self) -> None:
 833        """Resets the input's mapping settings."""
 834        from babase import InputDeviceNotFoundError
 835
 836        self._settings = {}
 837        # Unplugging the controller while performing a
 838        # mapping reset makes things go bonkers a little.
 839        try:
 840            self._get_config_mapping(default=True)
 841        except InputDeviceNotFoundError:
 842            pass
 843
 844        self._rebuild_ui(is_reset=True)
 845        bui.getsound('gunCocking').play()
 846
 847    def _do_more(self) -> None:
 848        """Show a burger menu with extra settings."""
 849        # pylint: disable=cyclic-import
 850        choices: list[str] = [
 851            'advanced',
 852            'reset',
 853        ]
 854        choices_display: list[bui.Lstr] = [
 855            bui.Lstr(resource=self._r + '.advancedText'),
 856            bui.Lstr(resource='settingsWindowAdvanced.resetText'),
 857        ]
 858
 859        uiscale = bui.app.ui_v1.uiscale
 860        PopupMenuWindow(
 861            position=self._more_button.get_screen_space_center(),
 862            scale=(
 863                2.3
 864                if uiscale is bui.UIScale.SMALL
 865                else 1.65 if uiscale is bui.UIScale.MEDIUM else 1.23
 866            ),
 867            width=150,
 868            choices=choices,
 869            choices_display=choices_display,
 870            current_choice='advanced',
 871            delegate=self,
 872        )
 873
 874    def popup_menu_selected_choice(
 875        self, popup_window: PopupMenuWindow, choice: str
 876    ) -> None:
 877        """Called when a choice is selected in the popup."""
 878        del popup_window  # unused
 879        if choice == 'reset':
 880            self._reset()
 881        elif choice == 'advanced':
 882            self._do_advanced()
 883        else:
 884            print(f'invalid choice: {choice}')
 885
 886    def popup_menu_closing(self, popup_window: PopupWindow) -> None:
 887        """Called when the popup is closing."""
 888
 889    def _save(self) -> None:
 890        classic = bui.app.classic
 891        assert classic is not None
 892
 893        # no-op if our underlying widget is dead or on its way out.
 894        if not self._root_widget or self._root_widget.transitioning_out:
 895            return
 896
 897        bui.containerwidget(
 898            edit=self._root_widget, transition=self._transition_out
 899        )
 900
 901        # If we're a secondary editor we just go away (we were editing our
 902        # parent's settings dict).
 903        if self._is_secondary:
 904            return
 905
 906        assert self._settings is not None
 907        if self._input:
 908            dst = classic.get_input_device_config(self._input, default=True)
 909            dst2: dict[str, Any] = dst[0][dst[1]]
 910            dst2.clear()
 911
 912            # Store any values that aren't -1.
 913            for key, val in list(self._settings.items()):
 914                if val != -1:
 915                    dst2[key] = val
 916
 917            # If we're allowed to phone home, send this config so we can
 918            # generate more defaults in the future.
 919            inputhash = classic.get_input_device_map_hash(self._input)
 920            classic.master_server_v1_post(
 921                'controllerConfig',
 922                {
 923                    'ua': classic.legacy_user_agent_string,
 924                    'b': bui.app.env.build_number,
 925                    'name': self._name,
 926                    'inputMapHash': inputhash,
 927                    'config': dst2,
 928                    'v': 2,
 929                },
 930            )
 931            bui.app.config.apply_and_commit()
 932            bui.getsound('gunCocking').play()
 933        else:
 934            bui.getsound('error').play()
 935
 936        if self._is_main_menu:
 937            from bauiv1lib.settings.controls import ControlsSettingsWindow
 938
 939            assert bui.app.classic is not None
 940            bui.app.ui_v1.set_main_menu_window(
 941                ControlsSettingsWindow(transition='in_left').get_root_widget(),
 942                from_window=self._root_widget,
 943            )
 944
 945
 946class AwaitGamepadInputWindow(bui.Window):
 947    """Window for capturing a gamepad button press."""
 948
 949    def __init__(
 950        self,
 951        gamepad: bs.InputDevice,
 952        button: str,
 953        callback: Callable[[str, dict[str, Any], AwaitGamepadInputWindow], Any],
 954        message: bui.Lstr | None = None,
 955        message2: bui.Lstr | None = None,
 956    ):
 957        if message is None:
 958            print('AwaitGamepadInputWindow message is None!')
 959            # Shouldn't get here.
 960            message = bui.Lstr(value='Press any button...')
 961        self._callback = callback
 962        self._input = gamepad
 963        self._capture_button = button
 964        width = 400
 965        height = 150
 966        assert bui.app.classic is not None
 967        uiscale = bui.app.ui_v1.uiscale
 968        super().__init__(
 969            root_widget=bui.containerwidget(
 970                scale=(
 971                    2.0
 972                    if uiscale is bui.UIScale.SMALL
 973                    else 1.9 if uiscale is bui.UIScale.MEDIUM else 1.0
 974                ),
 975                size=(width, height),
 976                transition='in_scale',
 977            ),
 978        )
 979        bui.textwidget(
 980            parent=self._root_widget,
 981            position=(0, (height - 60) if message2 is None else (height - 50)),
 982            size=(width, 25),
 983            text=message,
 984            maxwidth=width * 0.9,
 985            h_align='center',
 986            v_align='center',
 987        )
 988        if message2 is not None:
 989            bui.textwidget(
 990                parent=self._root_widget,
 991                position=(width * 0.5, height - 60),
 992                size=(0, 0),
 993                text=message2,
 994                maxwidth=width * 0.9,
 995                scale=0.47,
 996                color=(0.7, 1.0, 0.7, 0.6),
 997                h_align='center',
 998                v_align='center',
 999            )
1000        self._counter = 5
1001        self._count_down_text = bui.textwidget(
1002            parent=self._root_widget,
1003            h_align='center',
1004            position=(0, height - 110),
1005            size=(width, 25),
1006            color=(1, 1, 1, 0.3),
1007            text=str(self._counter),
1008        )
1009        self._decrement_timer: bui.AppTimer | None = bui.AppTimer(
1010            1.0, bui.Call(self._decrement), repeat=True
1011        )
1012        bs.capture_gamepad_input(bui.WeakCall(self._event_callback))
1013
1014    def __del__(self) -> None:
1015        pass
1016
1017    def die(self) -> None:
1018        """Kill the window."""
1019
1020        # This strong-refs us; killing it allow us to die now.
1021        self._decrement_timer = None
1022        bs.release_gamepad_input()
1023        if self._root_widget:
1024            bui.containerwidget(edit=self._root_widget, transition='out_scale')
1025
1026    def _event_callback(self, event: dict[str, Any]) -> None:
1027        input_device = event['input_device']
1028        assert isinstance(input_device, bs.InputDevice)
1029
1030        # Update - we now allow *any* input device of this type.
1031        if (
1032            self._input
1033            and input_device
1034            and input_device.name == self._input.name
1035        ):
1036            self._callback(self._capture_button, event, self)
1037
1038    def _decrement(self) -> None:
1039        self._counter -= 1
1040        if self._counter >= 1:
1041            if self._count_down_text:
1042                bui.textwidget(
1043                    edit=self._count_down_text, text=str(self._counter)
1044                )
1045        else:
1046            bui.getsound('error').play()
1047            self.die()