Merge pull request #347 from lxgr-linux/feat/342-improve-mousability-for-views

Feat/342 improve mousability for views

Author: lxgr-linux

src/pokete/__main__.py

@@ -25,7 +25,12 @@
     exception_propagating_periodic_event,
 )
 from pokete.base.input import ACTION_DIRECTIONS, Action, _ev, get_action
-from pokete.base.input_loops import ask_bool, ask_text, text_input
+from pokete.base.input_loops import (
+    ask_bool,
+    ask_text,
+)
+from pokete.base.input_loops.new_text_input import TextInput
+from pokete.base.mouse import mouse_interaction_manager
 from pokete.base.periodic_event_manager import PeriodicEventManager
 from pokete.base.single_event import single_event_periodic_event
 from pokete.base.tss import tss
@@ -363,7 +368,7 @@ def _game(_map: PlayMap, figure: Figure):
         notifier.notify("Weather", "Info", _map.weather.info)
     while True:
         # Directions are not being used yet
-        action = get_action()
+        action, _ = get_action()
         mouse_choosen = -1
         if mvp.movemap.mouse_choosen >= 0:
             mouse_choosen = mvp.movemap.mouse_choosen
@@ -384,16 +389,19 @@ def _game(_map: PlayMap, figure: Figure):
             _ev.clear()
             mvp.movemap.show(init=True)
         elif action.triggers(Action.CONSOLE):
-            inp = text_input(
-                ctx,
+            mvp.movemap.code_label.rechar(":")
+            text_input = TextInput(
                 mvp.movemap.code_label,
-                ":",
-                mvp.movemap.width,
+                mvp.movemap.width - 1,
                 (mvp.movemap.width - 2) * mvp.movemap.height - 1,
-            )[1:]
+            )
+            mouse_interaction_manager.attach([text_input])
+            inp = text_input(ctx)
+            ctx = change_ctx(ctx, mvp.movemap)
             mvp.movemap.code_label.outp(figure.map.pretty_name)
-            codes(inp, figure)
-            _ev.clear()
+            if inp is None:
+                continue
+            codes(inp[1:], figure)
         for statement, x, y in zip(
             [
                 figure.x + 6 > mvp.movemap.x + mvp.movemap.width,

src/pokete/base/color.py

@@ -1,9 +1,11 @@
 """Contains the color class"""
+
 from os import environ
 
 
 class Color:
     """Color class that provides all needed escape codes"""
+
     reset = "\033[0m"
     thicc = "\033[1m"
     underlined = "\033[4m"
@@ -30,6 +32,8 @@ class Color:
     cavegrey = "\033[38;5;236m"
     peach = "\033[38;5;216m"
 
+    bg_cyan = "\033[46m"
+
     if environ.get("TERM", "linux") == "linux":  # this fixes some colors on TTY
         gold = "\033[38;5;9m"
         cavegrey = "\033[38;5;7m"

src/pokete/base/input/event.py

@@ -1,6 +1,8 @@
 """Contains event var"""
 
-from typing import Callable
+from typing import Callable, Optional
+
+from pokete.base.input.key import Key
 
 EmitFn = Callable[[], None]
 
@@ -10,17 +12,17 @@ class Event:
     ARGS:
         event: Initial char"""
 
-    def __init__(self, event=""):
-        self._ev = event
+    def __init__(self, event=None):
+        self._ev: Optional[Key] = event
         self.emit_fn: EmitFn
 
-    def get(self):
+    def get(self) -> Optional[Key]:
         """Getter
         RETURNS:
             Current char"""
         return self._ev
 
-    def set(self, event):
+    def set(self, event: Key):
         """Setter
         ARGS:
             event: New char"""
@@ -29,7 +31,7 @@ def set(self, event):
 
     def clear(self):
         """Clears the event"""
-        self._ev = ""
+        self._ev = None
 
     def set_emit_fn(self, emit_fn: EmitFn):
         """Sets the method used to emit events to the timer"""

src/pokete/base/input/hotkeys.py

@@ -1,9 +1,12 @@
 """Contains everything related to input processing"""
 
+import logging
 import sys
 from collections import defaultdict
 from enum import Enum, auto
+from typing import Optional
 
+from pokete.base.input import key
 from pokete.util import liner
 
 from .event import _ev
@@ -60,7 +63,7 @@ class Action(Enum):
     INTERACT = auto()
 
     @property
-    def mapping(self):
+    def mapping(self) -> str:
         """Returns the current mapped char"""
         return get_mapping(self, hotkey_mappings)
 
@@ -102,7 +105,7 @@ def get_x_strength(self) -> int:
 ACTION_DIRECTIONS = (Action.LEFT, Action.RIGHT, Action.UP, Action.DOWN)
 ACTION_UP_DOWN = (Action.UP, Action.DOWN)
 
-hotkey_mappings = {
+hotkey_mappings: dict[str, ActionList] = {
     "1": ActionList([Action.ACT_1, Action.DECK, Action.CHOOSE_ATTACK]),
     "2": ActionList(
         [
@@ -167,12 +170,13 @@ def get_x_strength(self) -> int:
 }
 
 
-def get_mapping(action, keys):
+def get_mapping(action: Action, keys: dict[str, ActionList]) -> str:
     """Returns the current mapped char"""
-    for key, actions_list in keys.items():
+    for _key, actions_list in keys.items():
         if action in actions_list:
-            return key
-    return None
+            return _key
+    logging.warning("Unset mapping for Action '%s'", action.name)
+    return ""
 
 
 def hotkeys_save():
@@ -227,13 +231,16 @@ def hotkeys_from_save(ctx, save, version_change):
 
 
 # Returns an action, then clears input; all input is valid to read only once
-def get_action() -> ActionList:
+def get_action() -> tuple[ActionList, Optional[key.Key]]:
     """Returns the current actions list"""
     retval = EMPTY_ACTIONLIST
     raw_input = _ev.get()
-    if raw_input == "exit":
+    if raw_input is None:
+        return retval, None
+    if raw_input == key.EXIT:
         raise KeyboardInterrupt
-    if raw_input in hotkey_mappings:
-        retval = hotkey_mappings[raw_input]
+    marshall_input = raw_input.marshall()
+    if marshall_input in hotkey_mappings:
+        retval = hotkey_mappings[marshall_input]
     _ev.clear()
-    return retval
+    return retval, raw_input

src/pokete/base/input/key.py

@@ -0,0 +1,23 @@
+class Key:
+    def __init__(self, char="", rep=""):
+        self.char = char
+        self.__rep = rep
+
+    def marshall(self) -> str:
+        if self.__rep:
+            return f"Key.{self.__rep}"
+        return self.char
+
+    def has_char(self) -> bool:
+        return not not self.char
+
+
+UP = Key(rep="up")
+DOWN = Key(rep="down")
+LEFT = Key(rep="left")
+RIGHT = Key(rep="right")
+ENTER = Key(rep="enter")
+BACKSPACE = Key(rep="backspace")
+SPACE = Key(" ", rep="space")
+ESC = Key(rep="esc")
+EXIT = Key()

src/pokete/base/input/recogniser.py

@@ -6,37 +6,38 @@
 from pokete.base.exception_propagation.propagating_thread import (
     PropagatingThread,
 )
+from pokete.base.input import key
 
 from .event import _ev
 from .mouse import mouse_manager
 
 
 class Recogniser:
     ESCAPES: list[int] = [27, 0]
-    ESCAPED_KEY_MAPPING: dict[str, str] = {
-        "[A": "Key.up",
-        "[B": "Key.down",
-        "[C": "Key.right",
-        "[D": "Key.left",
-        "H": "Key.up",
-        "P": "Key.down",
-        "M": "Key.right",
-        "K": "Key.left",
+    ESCAPED_KEY_MAPPING: dict[str, key.Key] = {
+        "[A": key.UP,
+        "[B": key.DOWN,
+        "[C": key.RIGHT,
+        "[D": key.LEFT,
+        "H": key.UP,
+        "P": key.DOWN,
+        "M": key.RIGHT,
+        "K": key.LEFT,
     }
-    UNIX_KEY_MAPPING: dict[int, str] = {
-        13: "Key.enter",
-        127: "Key.backspace",
-        32: "Key.space",
-        27: "Key.esc",
-        3: "exit",
+    UNIX_KEY_MAPPING: dict[int, key.Key] = {
+        13: key.ENTER,
+        127: key.BACKSPACE,
+        32: key.SPACE,
+        27: key.ESC,
+        3: key.EXIT,
     }
-    WINDOWS_KEY_MAPPING: dict[int, str] = {
-        13: "Key.enter",
-        127: "Key.backspace",
-        8: "Key.backspace",
-        32: "Key.space",
-        27: "Key.esc",
-        3: "exit",
+    WINDOWS_KEY_MAPPING: dict[int, key.Key] = {
+        13: key.ENTER,
+        127: key.BACKSPACE,
+        8: key.BACKSPACE,
+        32: key.SPACE,
+        27: key.ESC,
+        3: key.EXIT,
     }
 
     def __init__(self):
@@ -88,12 +89,12 @@ def check_escape(self):
             self.__escape_event.clear()
             time.sleep(0.01)
             if self.__escape_input == "":
-                _ev.set("Key.esc")
+                _ev.set(key.ESC)
                 self.__escape_input = None
 
-    def set_event(self, char: str, key_mapping: dict[int, str]):
+    def set_event(self, char: str, key_mapping: dict[int, key.Key]):
         char_ord = ord(char)
-        key_mapping.setdefault(char_ord, f"{char.rstrip()}")
+        key_mapping.setdefault(char_ord, key.Key(f"{char.rstrip()}"))
         if char_ord in self.ESCAPES:
             self.__escape_input = ""
             self.__escape_event.set()

src/pokete/base/input_loops/__init__.py

@@ -1,2 +1 @@
 from .ask import ask_bool, ask_ok, ask_text
-from .text_input import text_input

src/pokete/base/input_loops/ask/__init__.py

@@ -2,23 +2,26 @@
 
 from threading import Event
 
+from scrap_engine.addable.misc.frame import Optional
+
 from pokete.base.change import change_ctx
+from pokete.base.ui.views.boxes import InfoBoxView, InputBoxView
 
 from ... import loops
 from ...context import Context
-from ...ui.elements import InfoBox, InputBox
-from ..text_input import text_input
 from .bool import ask_bool
 from .ok import ask_ok
 
 
 def wait_event(ctx: Context, text: str, event: Event):
     """Shows box until event is set"""
-    with InfoBox(text, info="", ctx=ctx):
+    with InfoBoxView(text, info=None, ctx=ctx):
         loops.event_wait(ctx, event)
 
 
-def ask_text(ctx: Context, infotext, introtext, text, name, max_len):
+def ask_text(
+    ctx: Context, infotext, introtext, text, name, max_len
+) -> Optional[str]:
     """Asks the player to input a text
     ARGS:
         ctx: Context
@@ -27,7 +30,11 @@ def ask_text(ctx: Context, infotext, introtext, text, name, max_len):
         text: The default text in the text field
         name: The boxes displayed name
         max_len: Max length of the text"""
-    with InputBox(infotext, introtext, text, max_len, name, ctx) as inputbox:
+
+    """
+    with InputBoxView(
+        infotext, introtext, text, max_len, name, ctx
+    ) as inputbox:
         ctx = change_ctx(ctx, inputbox)
         ret = text_input(
             ctx,
@@ -37,3 +44,5 @@ def ask_text(ctx: Context, infotext, introtext, text, name, max_len):
             max_len=max_len,
         )
     return ret
+    """
+    return InputBoxView(infotext, introtext, text, max_len, name)(ctx)

src/pokete/base/input_loops/ask/bool.py

@@ -59,7 +59,7 @@ def __call__(self, ctx: Context) -> bool:
         with self.center_add(self.map):
             ctx = change_ctx(ctx, self)
             while True:
-                action = get_action()
+                action, _ = get_action()
                 if action.triggers(Action.ACCEPT):
                     ret = True
                     break

src/pokete/base/input_loops/ask/ok.py

@@ -49,7 +49,7 @@ def __call__(self, ctx: Context):
         with self.center_add(self.map):
             ctx = change_ctx(ctx, self)
             while True:
-                action = get_action()
+                action, _ = get_action()
                 if action.triggers(Action.ACCEPT or action == Action.CANCEL):
                     break
                 loops.std(ctx)