Widget: add enabled property (#35944)

* add enabled

* sort

* rename

* rest

* rm that

system/ui/lib/application.py

@@ -19,7 +19,7 @@ FPS_LOG_INTERVAL = 5  # Seconds between logging FPS drops
 FPS_DROP_THRESHOLD = 0.9  # FPS drop threshold for triggering a warning
 FPS_CRITICAL_THRESHOLD = 0.5  # Critical threshold for triggering strict actions
 MOUSE_THREAD_RATE = 140  # touch controller runs at 140Hz
-MAX_TOUCH_SLOT = 2
+MAX_TOUCH_SLOTS = 2
 
 ENABLE_VSYNC = os.getenv("ENABLE_VSYNC", "0") == "1"
 SHOW_FPS = os.getenv("SHOW_FPS") == "1"
@@ -69,7 +69,7 @@ class MouseEvent(NamedTuple):
 class MouseState:
   def __init__(self):
     self._events: deque[MouseEvent] = deque(maxlen=MOUSE_THREAD_RATE)  # bound event list
-    self._prev_mouse_event: list[MouseEvent | None] = [None] * MAX_TOUCH_SLOT
+    self._prev_mouse_event: list[MouseEvent | None] = [None] * MAX_TOUCH_SLOTS
 
     self._rk = Ratekeeper(MOUSE_THREAD_RATE)
     self._lock = threading.Lock()
@@ -100,7 +100,7 @@ class MouseState:
       self._rk.keep_time()
 
   def _handle_mouse_event(self):
-    for slot in range(MAX_TOUCH_SLOT):
+    for slot in range(MAX_TOUCH_SLOTS):
       mouse_pos = rl.get_touch_position(slot)
       ev = MouseEvent(
         MousePos(mouse_pos.x, mouse_pos.y),

system/ui/setup.py

@@ -65,14 +65,15 @@ class Setup(Widget):
     self._software_selection_openpilot_button = ButtonRadio("openpilot", self.checkmark, font_size=BODY_FONT_SIZE, text_padding=80)
     self._software_selection_custom_software_button = ButtonRadio("Custom Software", self.checkmark, font_size=BODY_FONT_SIZE, text_padding=80)
     self._software_selection_continue_button = Button("Continue", self._software_selection_continue_button_callback,
-                                                      button_style=ButtonStyle.PRIMARY, enabled=False)
+                                                      button_style=ButtonStyle.PRIMARY)
+    self._software_selection_continue_button.set_enabled(False)
     self._software_selection_back_button = Button("Back", self._software_selection_back_button_callback)
     self._download_failed_reboot_button = Button("Reboot device", HARDWARE.reboot)
     self._download_failed_startover_button = Button("Start over", self._download_failed_startover_button_callback, button_style=ButtonStyle.PRIMARY)
     self._network_setup_back_button = Button("Back", self._network_setup_back_button_callback)
     self._network_setup_continue_button = Button("Waiting for internet", self._network_setup_continue_button_callback,
-                                                 button_style=ButtonStyle.PRIMARY, enabled=False)
-
+                                                 button_style=ButtonStyle.PRIMARY)
+    self._network_setup_continue_button.set_enabled(False)
 
     try:
       with open("/sys/class/hwmon/hwmon1/in1_input") as f:
@@ -196,7 +197,7 @@ class Setup(Widget):
 
     # Check network connectivity status
     continue_enabled = self.network_connected.is_set()
-    self._network_setup_continue_button.enabled = continue_enabled
+    self._network_setup_continue_button.set_enabled(continue_enabled)
     continue_text = ("Continue" if self.wifi_connected.is_set() else "Continue without Wi-Fi") if continue_enabled else "Waiting for internet"
     self._network_setup_continue_button.set_text(continue_text)
     self._network_setup_continue_button.render(rl.Rectangle(rect.x + MARGIN + button_width + BUTTON_SPACING, button_y, button_width, BUTTON_HEIGHT))
@@ -208,20 +209,20 @@ class Setup(Widget):
     radio_height = 230
     radio_spacing = 30
 
-    self._software_selection_continue_button.enabled = False
+    self._software_selection_continue_button.set_enabled(False)
 
     openpilot_rect = rl.Rectangle(rect.x + MARGIN, rect.y + TITLE_FONT_SIZE + MARGIN * 2, rect.width - MARGIN * 2, radio_height)
     self._software_selection_openpilot_button.render(openpilot_rect)
 
     if self._software_selection_openpilot_button.selected:
-      self._software_selection_continue_button.enabled = True
+      self._software_selection_continue_button.set_enabled(True)
       self._software_selection_custom_software_button.selected = False
 
     custom_rect = rl.Rectangle(rect.x + MARGIN, rect.y + TITLE_FONT_SIZE + MARGIN * 2 + radio_height + radio_spacing, rect.width - MARGIN * 2, radio_height)
     self._software_selection_custom_software_button.render(custom_rect)
 
     if self._software_selection_custom_software_button.selected:
-      self._software_selection_continue_button.enabled = True
+      self._software_selection_continue_button.set_enabled(True)
       self._software_selection_openpilot_button.selected = False
 
     button_width = (rect.width - BUTTON_SPACING - MARGIN * 2) / 2

system/ui/widgets/__init__.py

@@ -2,7 +2,7 @@ import abc
 import pyray as rl
 from enum import IntEnum
 from collections.abc import Callable
-from openpilot.system.ui.lib.application import gui_app, MousePos, MAX_TOUCH_SLOT
+from openpilot.system.ui.lib.application import gui_app, MousePos, MAX_TOUCH_SLOTS
 
 
 class DialogResult(IntEnum):
@@ -15,34 +15,16 @@ class Widget(abc.ABC):
   def __init__(self):
     self._rect: rl.Rectangle = rl.Rectangle(0, 0, 0, 0)
     self._parent_rect: rl.Rectangle = rl.Rectangle(0, 0, 0, 0)
-    self._is_pressed = [False] * MAX_TOUCH_SLOT
-    self._multi_touch = False
+    self._is_pressed = [False] * MAX_TOUCH_SLOTS
+    self._enabled: bool | Callable[[], bool] = True
     self._is_visible: bool | Callable[[], bool] = True
     self._touch_valid_callback: Callable[[], bool] | None = None
-
-  def set_touch_valid_callback(self, touch_callback: Callable[[], bool]) -> None:
-    """Set a callback to determine if the widget can be clicked."""
-    self._touch_valid_callback = touch_callback
-
-  def _touch_valid(self) -> bool:
-    """Check if the widget can be touched."""
-    return self._touch_valid_callback() if self._touch_valid_callback else True
-
-  @property
-  def is_visible(self) -> bool:
-    return self._is_visible() if callable(self._is_visible) else self._is_visible
-
-  @property
-  def is_pressed(self) -> bool:
-    return any(self._is_pressed)
+    self._multi_touch = False
 
   @property
   def rect(self) -> rl.Rectangle:
     return self._rect
 
-  def set_visible(self, visible: bool | Callable[[], bool]) -> None:
-    self._is_visible = visible
-
   def set_rect(self, rect: rl.Rectangle) -> None:
     changed = (self._rect.x != rect.x or self._rect.y != rect.y or
                self._rect.width != rect.width or self._rect.height != rect.height)
@@ -54,6 +36,32 @@ class Widget(abc.ABC):
     """Can be used like size hint in QT"""
     self._parent_rect = parent_rect
 
+  @property
+  def is_pressed(self) -> bool:
+    return any(self._is_pressed)
+
+  @property
+  def enabled(self) -> bool:
+    return self._enabled() if callable(self._enabled) else self._enabled
+
+  def set_enabled(self, enabled: bool | Callable[[], bool]) -> None:
+    self._enabled = enabled
+
+  @property
+  def is_visible(self) -> bool:
+    return self._is_visible() if callable(self._is_visible) else self._is_visible
+
+  def set_visible(self, visible: bool | Callable[[], bool]) -> None:
+    self._is_visible = visible
+
+  def set_touch_valid_callback(self, touch_callback: Callable[[], bool]) -> None:
+    """Set a callback to determine if the widget can be clicked."""
+    self._touch_valid_callback = touch_callback
+
+  def _touch_valid(self) -> bool:
+    """Check if the widget can be touched."""
+    return self._touch_valid_callback() if self._touch_valid_callback else True
+
   def set_position(self, x: float, y: float) -> None:
     changed = (self._rect.x != x or self._rect.y != y)
     self._rect.x, self._rect.y = x, y

system/ui/widgets/button.py

@@ -172,7 +172,6 @@ class Button(Widget):
                border_radius: int = 10,
                text_alignment: TextAlignment = TextAlignment.CENTER,
                text_padding: int = 20,
-               enabled: bool = True,
                icon = None,
                multi_touch: bool = False,
                ):
@@ -187,7 +186,6 @@ class Button(Widget):
 
     self._click_callback = click_callback
     self._multi_touch = multi_touch
-    self.enabled = enabled
 
   def set_text(self, text):
     self._label.set_text(text)

system/ui/widgets/keyboard.py

@@ -187,10 +187,10 @@ class Keyboard(Widget):
         if key in self._key_icons:
           if key == SHIFT_ACTIVE_KEY and self._caps_lock:
             key = CAPS_LOCK_KEY
-          self._all_keys[key].enabled = is_enabled
+          self._all_keys[key].set_enabled(is_enabled)
           self._all_keys[key].render(key_rect)
         else:
-          self._all_keys[key].enabled = is_enabled
+          self._all_keys[key].set_enabled(is_enabled)
           self._all_keys[key].render(key_rect)
 
     return self._render_return_status

system/ui/widgets/network.py

@@ -150,14 +150,14 @@ class WifiManagerUI(Widget):
     match self.state:
       case StateConnecting(network=connecting):
         if connecting.ssid == network.ssid:
-          self._networks_buttons[network.ssid].enabled = False
+          self._networks_buttons[network.ssid].set_enabled(False)
           status_text = "CONNECTING..."
       case StateForgetting(network=forgetting):
         if forgetting.ssid == network.ssid:
-          self._networks_buttons[network.ssid].enabled = False
+          self._networks_buttons[network.ssid].set_enabled(False)
           status_text = "FORGETTING..."
       case _:
-        self._networks_buttons[network.ssid].enabled = True
+        self._networks_buttons[network.ssid].set_enabled(True)
 
     self._networks_buttons[network.ssid].render(ssid_rect)
 

system/ui/widgets/toggle.py

@@ -38,9 +38,6 @@ class Toggle(Widget):
     self._state = state
     self._target = 1.0 if state else 0.0
 
-  def set_enabled(self, enabled: bool):
-    self._enabled = enabled
-
   def is_enabled(self):
     return self._enabled