sunnypilot/system/ui/widgets/__init__.py

from __future__ import annotations

import abc
import pyray as rl
from enum import IntEnum
from typing import TypeVar
from collections.abc import Callable
from openpilot.system.ui.lib.application import gui_app, MousePos, MAX_TOUCH_SLOTS, MouseEvent

try:
  from openpilot.selfdrive.ui.ui_state import device
except ImportError:
  class Device:
    awake = True
  device = Device()

W = TypeVar('W', bound='Widget')

DEBUG = False


class DialogResult(IntEnum):
  CANCEL = 0
  CONFIRM = 1
  NO_ACTION = -1


class Widget(abc.ABC):
  def __init__(self):
    self._rect: rl.Rectangle = rl.Rectangle(0, 0, 0, 0)
    self._parent_rect: rl.Rectangle | None = None
    self._children: list[Widget] = []

    self._enabled: bool | Callable[[], bool] = True
    self._is_visible: bool | Callable[[], bool] = True

    self.__is_pressed = [False] * MAX_TOUCH_SLOTS
    # if current mouse/touch down started within the widget's rectangle
    self.__tracking_is_pressed = [False] * MAX_TOUCH_SLOTS
    self._touch_valid_callback: Callable[[], bool] | None = None
    self._click_delay: float | None = None  # seconds to hold is_pressed after release
    self._click_release_time: float | None = None
    self._click_callback: Callable[[], None] | None = None
    self._multi_touch = False
    self.__was_awake = True

  @property
  def rect(self) -> rl.Rectangle:
    return self._rect

  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)
    self._rect = rect
    if changed:
      self._update_layout_rects()

  def set_parent_rect(self, parent_rect: rl.Rectangle) -> None:
    """Can be used like size hint in QT"""
    self._parent_rect = parent_rect

  @property
  def is_pressed(self) -> bool:
    # if actually pressed or holding after release
    return any(self.__is_pressed) or self._click_release_time is not None

  @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_click_callback(self, click_callback: Callable[[], None] | None) -> None:
    """Set a callback to be called when the widget is clicked."""
    self._click_callback = click_callback

  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 = rl.Rectangle(x, y, self._rect.width, self._rect.height)
    if changed:
      self._update_layout_rects()

  @property
  def _hit_rect(self) -> rl.Rectangle:
    # restrict touches to within parent rect if set, useful inside Scroller
    if self._parent_rect is None:
      return self._rect
    return rl.get_collision_rec(self._rect, self._parent_rect)

  def render(self, rect: rl.Rectangle | None = None) -> bool | int | None:
    if rect is not None:
      self.set_rect(rect)

    self._update_state()

    if self._click_release_time is not None and rl.get_time() >= self._click_release_time:
      self._click_release_time = None

    if not self.is_visible:
      return None

    self._layout()
    ret = self._render(self._rect)

    if gui_app.show_touches:
      self._draw_debug_rect()

    # Keep track of whether mouse down started within the widget's rectangle
    if self.enabled and self.__was_awake:
      self._process_mouse_events()
    else:
      # TODO: ideally we emit release events when going disabled
      self.__is_pressed = [False] * MAX_TOUCH_SLOTS
      self.__tracking_is_pressed = [False] * MAX_TOUCH_SLOTS

    self.__was_awake = device.awake

    return ret

  def _draw_debug_rect(self) -> None:
    rl.draw_rectangle_lines(int(self._rect.x), int(self._rect.y),
                            max(int(self._rect.width), 1), max(int(self._rect.height), 1), rl.RED)

  def _process_mouse_events(self) -> None:
    hit_rect = self._hit_rect
    touch_valid = self._touch_valid()

    for mouse_event in gui_app.mouse_events:
      if not self._multi_touch and mouse_event.slot != 0:
        continue

      mouse_in_rect = rl.check_collision_point_rec(mouse_event.pos, hit_rect)
      # Ignores touches/presses that start outside our rect
      # Allows touch to leave the rect and come back in focus if mouse did not release
      if mouse_event.left_pressed and touch_valid:
        if mouse_in_rect:
          self._handle_mouse_press(mouse_event.pos)
          self.__is_pressed[mouse_event.slot] = True
          self.__tracking_is_pressed[mouse_event.slot] = True
          self._handle_mouse_event(mouse_event)

      # Callback such as scroll panel signifies user is scrolling
      elif not touch_valid:
        self.__is_pressed[mouse_event.slot] = False
        self.__tracking_is_pressed[mouse_event.slot] = False

      elif mouse_event.left_released:
        self._handle_mouse_event(mouse_event)
        if self.__is_pressed[mouse_event.slot] and mouse_in_rect:
          self._handle_mouse_release(mouse_event.pos)
        self.__is_pressed[mouse_event.slot] = False
        self.__tracking_is_pressed[mouse_event.slot] = False

      # Mouse/touch is still within our rect
      elif mouse_in_rect:
        if self.__tracking_is_pressed[mouse_event.slot]:
          self.__is_pressed[mouse_event.slot] = True
          self._handle_mouse_event(mouse_event)

      # Mouse/touch left our rect but may come back into focus later
      elif not mouse_in_rect:
        self.__is_pressed[mouse_event.slot] = False
        self._handle_mouse_event(mouse_event)

  def _layout(self) -> None:
    """Optionally lay out child widgets separately. This is called before rendering."""

  def _update_state(self):
    """Optionally update the widget's non-layout state. This is called before rendering."""

  @abc.abstractmethod
  def _render(self, rect: rl.Rectangle) -> bool | int | None:
    """Render the widget within the given rectangle."""

  def _update_layout_rects(self) -> None:
    """Optionally update any layout rects on Widget rect change."""

  def _handle_mouse_press(self, mouse_pos: MousePos) -> None:
    """Optionally handle mouse press events."""

  def _handle_mouse_release(self, mouse_pos: MousePos) -> None:
    """Optionally handle mouse release events."""
    if self._click_delay is not None:
      self._click_release_time = rl.get_time() + self._click_delay
    if self._click_callback:
      self._click_callback()

  def _handle_mouse_event(self, mouse_event: MouseEvent) -> None:
    """Optionally handle mouse events. This is called before rendering."""
    # Default implementation does nothing, can be overridden by subclasses

  def _child(self, widget: W) -> W:
    """
    Register a widget as a child. Lifecycle events (show/hide) propagate to registered children.
    - If the widget is pushed onto the nav stack, do NOT register it (gui_app manages its lifecycle).
    - If the widget is rendered inline in _render(), register it.
    """
    assert widget not in self._children, f"{type(widget).__name__} already a child of {type(self).__name__}"
    self._children.append(widget)
    return widget

  _show_hide_depth = 0

  def show_event(self):
    """Called when widget becomes visible. Propagates to registered children."""
    if DEBUG:
      print(f"{'  ' * Widget._show_hide_depth}show_event: {type(self).__name__}")
      Widget._show_hide_depth += 1
    for child in self._children:
      child.show_event()
    if DEBUG:
      Widget._show_hide_depth -= 1

  def hide_event(self):
    """Called when widget is hidden. Propagates to registered children."""
    if DEBUG:
      print(f"{'  ' * Widget._show_hide_depth}hide_event: {type(self).__name__}")
      Widget._show_hide_depth += 1
    for child in self._children:
      child.hide_event()
    if DEBUG:
      Widget._show_hide_depth -= 1

  def dismiss(self, callback: Callable[[], None] | None = None):
    """Immediately dismiss the widget, firing the callback after."""
    gui_app.pop_widget()
    if callback:
      callback()