implement the keybinds menu

Author: apple1417

src/willow1_mod_menu/options.py

@@ -18,6 +18,8 @@
     from .util import WillowGFxMenu
 
 CUSTOM_OPTIONS_MENU_TAG = "willow1-mod-menu:custom-option"
+CUSTOM_KEYBINDS_MENU_TAG = "willow1-mod-menu:custom-keybinds"
+
 RE_SELECTED_IDX = re.compile(r"^_level\d+\.(menu\.selections|content)\.mMenu\.mList\.item(\d+)$")
 
 populator_stack: list[Populator] = []
@@ -58,9 +60,20 @@ def create_nested_options_menu(menu: WillowGFxMenu, option: NestedOption) -> Non
     open_new_generic_menu(menu)
 
 
+def create_keybinds_menu(menu: WillowGFxMenu) -> None:
+    """
+    Creates a new menu holding a mod's keybinds.
+
+    Args:
+        menu: The current menu to create the new one under.
+    """
+    create_keybinds_menu_impl(menu)
+
+
 # ==================================================================================================
 
 # Avoid circular imports
+from .populators import LOCKED_KEY_PREFIX  # noqa: E402
 from .populators.mod_list import ModListPopulator  # noqa: E402
 from .populators.mod_options import ModOptionPopulator  # noqa: E402
 from .populators.options import OptionPopulator  # noqa: E402
@@ -240,16 +253,22 @@ def reactivate_upper_screen(
 
 
 # ==================================================================================================
-# experimental
 
 
-def create_keybinds_menu(obj: WillowGFxMenu) -> None:
+def create_keybinds_menu_impl(obj: WillowGFxMenu) -> None:
     keybinds_frame = unrealsdk.construct_object("WillowGFxMenuScreenFrameKeyBinds", outer=obj)
+    keybinds_frame.MenuTag = CUSTOM_KEYBINDS_MENU_TAG
     keybinds_frame.FrameTag = "PCBindings"
-    keybinds_frame.MenuTag = "PCBindings"
-    keybinds_frame.CaptionMarkup = "My Mod"
+    keybinds_frame.CaptionMarkup = "Keybinds"
     keybinds_frame.Tip = "<Strings:WillowMenu.TitleMenu.SelBackBar>"
 
+    init_keybinds_frame.enable()
+    init_bind_list.enable()
+    bind_keybind_start.enable()
+    bind_keybind_finish.enable()
+    reset_keybinds.enable()
+    localize_key_name.enable()
+
     keybinds_frame.Init(obj, 0)
 
     obj.ScreenStack.append(keybinds_frame)
@@ -264,28 +283,111 @@ def init_keybinds_frame(
     _ret: Any,
     func: BoundFunction,
 ) -> type[Block]:
+    init_keybinds_frame.disable()
+
     super_class = obj.Class.SuperField
     assert super_class is not None
     super_func = super_class._find(func.func.Name)
     assert isinstance(super_func, UFunction)
     BoundFunction(super_func, obj)(args.Frame)
 
-    obj.ActiveItems.emplace_struct(
-        Tag="action_mod_kb_0",
-        Caption="kb caption",
-        CaptionMarkup="kb markup",
-    )
-    obj.Keybinds.emplace_struct(Bind="kb bind", Keys=["P"])
-    obj.Keybinds[-1].Keys.append("T")
+    active_items = obj.ActiveItems
+    keybinds = obj.Keybinds
 
-    obj.ActiveItems.emplace_struct(
-        Tag="action_mod_option_0",
-        Caption="opt caption",
-        CaptionMarkup="opt markup",
-    )
-    obj.Keybinds.emplace_struct()
+    active_items.clear()
+    keybinds.clear()
+
+    populator_stack[-1].populate_keybinds(obj)
+
+    return Block
+
+
+# This function deletes the existing keys from the list, so we just block it to keep them
+@hook("WillowGame.WillowGFxMenuScreenFrameKeyBinds:InitBind")
+def init_bind_list(*_: Any) -> type[Block]:
+    return Block
+
+
+@hook("WillowGame.WillowGFxMenuScreenFrameKeyBinds:DoBind")
+def bind_keybind_start(
+    obj: UObject,
+    _args: WrappedStruct,
+    _ret: Any,
+    _func: BoundFunction,
+) -> type[Block] | None:
+    if (idx := obj.Selection.Current) == 0:
+        # Reset keybinds, always allowed, continue
+        return None
+
+    if populator_stack[-1].may_bind_key(idx):
+        # Allowed to bind, continue
+        return None
+
+    # Not allowed, block it
+    return Block
 
+
+@hook("WillowGame.WillowGFxMenuScreenFrameKeyBinds:Bind")
+def bind_keybind_finish(
+    obj: UObject,
+    args: WrappedStruct,
+    _ret: Any,
+    _func: BoundFunction,
+) -> type[Block]:
+    populator_stack[-1].on_bind_key(obj, obj.Selection.Current, args.Key)
+    return Block
+
+
+@hook("WillowGame.WillowGFxMenuScreenFrameKeyBinds:ResetBindings_Clicked")
+def reset_keybinds(
+    obj: UObject,
+    args: WrappedStruct,
+    _ret: Any,
+    _func: BoundFunction,
+) -> type[Block]:
+    if args.Dlg.DialogResult != "Yes":
+        return Block
+
+    populator_stack[-1].on_reset_keybinds(obj)
     return Block
 
 
-init_keybinds_frame.disable()
+@hook("WillowGame.WillowGFxMenuScreenFrameKeyBinds:LocalizeKeyName")
+def localize_key_name(
+    _obj: UObject,
+    args: WrappedStruct,
+    _ret: Any,
+    func: BoundFunction,
+) -> tuple[type[Block], str] | None:
+    key: str = args.Key
+
+    if not key.startswith(LOCKED_KEY_PREFIX):
+        # Normal, non locked key, use the standard function
+        return None
+
+    without_prefix = key.removeprefix(LOCKED_KEY_PREFIX)
+    if not without_prefix:
+        # Locked key bound to nothing
+        return Block, "[ -- ]"
+
+    # Locked key bound to something
+    with unrealsdk.hooks.prevent_hooking_direct_calls():
+        localized = func(without_prefix)
+    return Block, f"[ {localized} ]"
+
+
+@hook("WillowGame.WillowGFxMenuScreenFrameKeyBinds:Screen_Deactivate", immediately_enable=True)
+def keybind_screen_deactivate(
+    obj: UObject,
+    _args: WrappedStruct,
+    _ret: Any,
+    _func: BoundFunction,
+) -> None:
+    if obj.MenuTag == CUSTOM_KEYBINDS_MENU_TAG and populator_stack:
+        init_bind_list.disable()
+        bind_keybind_start.disable()
+        bind_keybind_finish.disable()
+        reset_keybinds.disable()
+        localize_key_name.disable()
+
+        reactivate_upper_screen.enable()

src/willow1_mod_menu/populators/__init__.py

@@ -6,11 +6,20 @@
 from unrealsdk import logging
 from unrealsdk.unreal import UObject
 
-from mods_base import BaseOption, BoolOption, DropdownOption, SliderOption, SpinnerOption
+from mods_base import (
+    BaseOption,
+    BoolOption,
+    DropdownOption,
+    KeybindOption,
+    SliderOption,
+    SpinnerOption,
+)
 from willow1_mod_menu.util import WillowGFxMenu, find_focused_item
 
 type WillowGFxLobbyTools = UObject
+type WillowGFxMenuScreenFrameKeyBinds = UObject
 
+LOCKED_KEY_PREFIX = "!LOCKED!"
 
 RE_INVALID_SPINNER_CHARS = re.compile("[:,]")
 
@@ -23,11 +32,16 @@ class Populator(ABC):
         repr=False,
         default_factory=list[BaseOption],
     )
+    drawn_keybinds: list[KeybindOption | None] = field(
+        init=False,
+        repr=False,
+        default_factory=list[KeybindOption | None],
+    )
 
     @abstractmethod
     def populate(self, tools: WillowGFxLobbyTools) -> None:
         """
-        Populates the menu with the appropriate contents.
+        Populates the menu with the appropriate options.
 
         Args:
             tools: The lobby tools which may be used to add to the menu.
@@ -43,6 +57,20 @@ def handle_activate(self, menu: WillowGFxMenu, option: BaseOption) -> None:
             menu: The currently open menu.
             option: The option which was activate.
         """
+        raise NotImplementedError
+
+    def populate_keybinds(self, kb_frame: WillowGFxMenuScreenFrameKeyBinds) -> None:
+        """
+        Populates the menu with the appropriate keybinds.
+
+        Args:
+            kb_frame: The keybinds frame object which may be used to add binds.
+        """
+        raise NotImplementedError
+
+    def handle_reset_keybinds(self) -> None:
+        """Handles the reset keybind menu being activated."""
+        raise NotImplementedError
 
     # ==============================================================================================
 
@@ -190,3 +218,92 @@ def on_slider_spinner_change(self, menu: WillowGFxMenu, idx: int, value: float)
                     f"Option '{option.identifier}' of unknown type {type(option)} unexpectedly got"
                     f" a slider/spinner change event",
                 )
+
+    def draw_keybind(
+        self,
+        kb_frame: WillowGFxMenuScreenFrameKeyBinds,
+        name: str,
+        key: str | None = None,
+        is_rebindable: bool = True,
+        option: KeybindOption | None = None,
+    ) -> None:
+        """
+        Adds an individual keybind to the menu.
+
+        Args:
+            kb_frame: The keybinds frame object to add to.
+            name: The name of the bind.
+            key: The key the bind is bound to.
+            is_rebindable: True if the key is rebindable.
+            option: The option to use during the callback, or None.
+        """
+        kb_frame.ActiveItems.emplace_struct(Caption=name)
+
+        key_list: list[str]
+        if key is None:
+            key_list = [] if is_rebindable else [LOCKED_KEY_PREFIX]
+        else:
+            key_list = [key] if is_rebindable else [LOCKED_KEY_PREFIX + key]
+
+        kb_frame.Keybinds.emplace_struct(Keys=key_list)
+
+        self.drawn_keybinds.append(option)
+
+    def may_bind_key(self, idx: int) -> bool:
+        """
+        Checks if we're allowed to bind the given key.
+
+        Args:
+            idx: The index of the key to check.
+        Returns:
+            True if we're allowed to bind this key index.
+        """
+        try:
+            option = self.drawn_keybinds[idx]
+        except IndexError:
+            return False
+
+        if option is None:
+            return False
+
+        return option.is_rebindable
+
+    def on_bind_key(self, kb_frame: WillowGFxMenuScreenFrameKeyBinds, idx: int, key: str) -> None:
+        """
+        Handles a raw key bind event.
+
+        Args:
+            kb_frame: The keybinds frame object to update with the new key.
+            idx: The index of the key which was bound.
+            key: The new value the key was requested to be set to.
+        """
+        try:
+            option = self.drawn_keybinds[idx]
+        except IndexError:
+            return
+        if option is None or not option.is_rebindable:
+            return
+
+        if key == option.value:
+            option.value = None
+        else:
+            option.value = key
+
+        kb_frame.Keybinds[idx].Keys = [] if option.value is None else [option.value]
+
+    def on_reset_keybinds(self, kb_frame: WillowGFxMenuScreenFrameKeyBinds) -> None:
+        """
+        Handles a raw reset keybinds event.
+
+        Args:
+            kb_frame: The keybinds frame object to update with the new key.
+        """
+        self.handle_reset_keybinds()
+
+        keybinds = kb_frame.Keybinds
+        for idx, option in enumerate(self.drawn_keybinds):
+            if option is None:
+                continue
+            keybinds[idx].Keys = [] if option.value is None else [option.value]
+
+        kb_frame.ApplyPageContent()