batframework 1.0.9a8__py3-none-any.whl → 1.0.9a9__py3-none-any.whl

batFramework/gui/layout.py

@@ -37,11 +37,11 @@ class Layout(ABC):
             self.parent.dirty_layout = True
 
     def update_children_rect(self):
-        if self.parent.children:
-            self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft,*self.parent.children[0].get_min_required_size())
+        if self.parent.get_layout_children():
+            self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft,*self.parent.get_layout_children()[0].get_min_required_size())
             
             self.children_rect.unionall(
-                [pygame.FRect(0,0,*c.get_min_required_size()) for c in self.parent.children[1:]]
+                [pygame.FRect(0,0,*c.get_min_required_size()) for c in self.parent.get_layout_children()[1:]]
             )
         else:
             self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft, 0, 0)
@@ -49,7 +49,7 @@ class Layout(ABC):
 
     def update_child_constraints(self):
         if self.parent:
-            for child in self.parent.children:
+            for child in self.parent.get_layout_children():
                 child.add_constraints(*self.child_constraints)
 
     def arrange(self) -> None:
@@ -62,7 +62,7 @@ class Layout(ABC):
         """
         Returns the size the container should have to encapsulate perfectly all of its widgets
         """
-        # print(self,self.parent,len(self.parent.children))
+        # print(self,self.parent,len(self.parent.get_layout_children()))
         self.update_children_rect()
         return self.children_rect.size
 
@@ -165,12 +165,12 @@ class Column(SingleAxisLayout):
         self.gap = gap
 
     def update_children_rect(self):
-        if self.parent.children:
-            width = max(child.get_min_required_size()[0] for child in self.parent.children )
-            height = sum(child.get_min_required_size()[1] for child in self.parent.children) + self.gap * (len(self.parent.children) - 1)
+        if self.parent.get_layout_children():
+            width = max(child.get_min_required_size()[0] for child in self.parent.get_layout_children() )
+            height = sum(child.get_min_required_size()[1] for child in self.parent.get_layout_children()) + self.gap * (len(self.parent.get_layout_children()) - 1)
 
-            # width = max(child.rect.w for child in self.parent.children )
-            # height = sum(child.rect.h for child in self.parent.children) + self.gap * (len(self.parent.children) - 1)
+            # width = max(child.rect.w for child in self.parent.get_layout_children() )
+            # height = sum(child.rect.h for child in self.parent.get_layout_children()) + self.gap * (len(self.parent.get_layout_children()) - 1)
 
 
             self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft, width, height)
@@ -179,7 +179,7 @@ class Column(SingleAxisLayout):
         self.children_rect.move_ip(-self.parent.scroll.x,-self.parent.scroll.y)
 
     def handle_event(self, event):
-        if not self.parent.children or not self.parent.children_has_focus():
+        if not self.parent.get_layout_children() or not self.parent.children_has_focus():
             return
 
         if event.type == pygame.KEYDOWN:
@@ -192,7 +192,7 @@ class Column(SingleAxisLayout):
     def arrange(self) -> None:
         self.update_children_rect()
         y = self.children_rect.y
-        for child in self.parent.children:
+        for child in self.parent.get_layout_children():
             child.set_position(self.children_rect.x, y)
             y += child.rect.height + self.gap
 
@@ -202,16 +202,16 @@ class Row(SingleAxisLayout):
         self.gap = gap
 
     def update_children_rect(self):
-        if self.parent.children:
-            height = max(child.get_min_required_size()[1] for child in self.parent.children)
-            width = sum(child.get_min_required_size()[0] for child in self.parent.children) + self.gap * (len(self.parent.children) - 1)
+        if self.parent.get_layout_children():
+            height = max(child.get_min_required_size()[1] for child in self.parent.get_layout_children())
+            width = sum(child.get_min_required_size()[0] for child in self.parent.get_layout_children()) + self.gap * (len(self.parent.get_layout_children()) - 1)
             self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft, width, height)
         else:
             self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft, 10,10)        
         self.children_rect.move_ip(-self.parent.scroll.x,-self.parent.scroll.y)
 
     def handle_event(self, event):
-        if not self.parent.children or not self.parent.children_has_focus():
+        if not self.parent.get_layout_children() or not self.parent.children_has_focus():
             return
 
         if event.type == pygame.KEYDOWN:
@@ -223,7 +223,7 @@ class Row(SingleAxisLayout):
     def arrange(self) -> None:
         self.update_children_rect()
         x = self.children_rect.x
-        for child in self.parent.children:
+        for child in self.parent.get_layout_children():
             child.set_position(x,self.children_rect.y)
             x += child.rect.width + self.gap
 
@@ -233,8 +233,8 @@ class RowFill(Row):
 
     def update_children_rect(self):
         parent_width = self.parent.get_inner_width()
-        if self.parent.children:
-            height = max(child.get_min_required_size()[1] for child in self.parent.children)
+        if self.parent.get_layout_children():
+            height = max(child.get_min_required_size()[1] for child in self.parent.get_layout_children())
             width = parent_width
             self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft, width, height)
         else:
@@ -248,17 +248,17 @@ class RowFill(Row):
         accounting for the gap between children.
         """
         self.update_children_rect()
-        for child in self.parent.children:
+        for child in self.parent.get_layout_children():
             child.set_autoresize_w(False)
         x = self.children_rect.x
         # available_height = self.children_rect.height
 
         # Calculate the width available for each child
-        total_gap = self.gap * (len(self.parent.children) - 1)
+        total_gap = self.gap * (len(self.parent.get_layout_children()) - 1)
         available_width = max(0, self.children_rect.width - total_gap)
-        child_width = available_width / len(self.parent.children) if self.parent.children else 0
+        child_width = available_width / len(self.parent.get_layout_children()) if self.parent.get_layout_children() else 0
 
-        for child in self.parent.children:
+        for child in self.parent.get_layout_children():
             child.set_size((child_width, None))  # Resize child to fill height
             child.set_position(x, self.children_rect.y)  # Position child
             x += child_width + self.gap
@@ -268,8 +268,8 @@ class ColumnFill(Column):
 
     def update_children_rect(self):
         parent_height = self.parent.get_inner_height()
-        if self.parent.children:
-            width = max(child.get_min_required_size()[0] for child in self.parent.children)
+        if self.parent.get_layout_children():
+            width = max(child.get_min_required_size()[0] for child in self.parent.get_layout_children())
             height = parent_height
             self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft, width, height)
         else:
@@ -282,16 +282,16 @@ class ColumnFill(Column):
         accounting for the gap between children.
         """
         self.update_children_rect()
-        for child in self.parent.children:
+        for child in self.parent.get_layout_children():
             child.set_autoresize_h(False)
         y = self.children_rect.y
 
         # Calculate the height available for each child
-        total_gap = self.gap * (len(self.parent.children) - 1)
+        total_gap = self.gap * (len(self.parent.get_layout_children()) - 1)
         available_height = max(0, self.children_rect.height - total_gap)
-        child_height = available_height / len(self.parent.children) if self.parent.children else 0
+        child_height = available_height / len(self.parent.get_layout_children()) if self.parent.get_layout_children() else 0
 
-        for child in self.parent.children:
+        for child in self.parent.get_layout_children():
             child.set_size((None, child_height))  # Resize child to fill width
             child.set_position(self.children_rect.x, y)  # Position child
             y += child_height + self.gap
@@ -304,10 +304,77 @@ class Grid(DoubleAxisLayout):
         self.cols = cols
         self.gap = gap
 
+    def focus_up_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        if not l:
+            return
+        current_index = self.parent.focused_index
+        if current_index == -1:
+            return
+        current_row = current_index // self.cols
+        target_index = max(0, current_index - self.cols)
+        if target_index // self.cols < current_row:
+            self.parent.focused_index = target_index
+            l[target_index].get_focus()
+
+    def focus_down_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        if not l:
+            return
+        current_index = self.parent.focused_index
+        if current_index == -1:
+            return
+        current_row = current_index // self.cols
+        target_index = min(len(l) - 1, current_index + self.cols)
+        if target_index // self.cols > current_row:
+            self.parent.focused_index = target_index
+            l[target_index].get_focus()
+
+    def focus_left_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        if not l:
+            return
+        current_index = self.parent.focused_index
+        if current_index == -1:
+            return
+        target_index = max(0, current_index - 1)
+        if target_index // self.cols == current_index // self.cols:
+            self.parent.focused_index = target_index
+            l[target_index].get_focus()
+
+    def focus_right_child(self) -> None:
+        l = self.parent.get_interactive_children()
+        if not l:
+            return
+        current_index = self.parent.focused_index
+        if current_index == -1:
+            return
+        target_index = min(len(l) - 1, current_index + 1)
+        if target_index // self.cols == current_index // self.cols:
+            self.parent.focused_index = target_index
+            l[target_index].get_focus()
+
+    def handle_event(self, event):
+        if not self.parent.get_layout_children() or not self.parent.children_has_focus():
+            return
+
+        if event.type == pygame.KEYDOWN:
+            if event.key in (pygame.K_RIGHT, pygame.K_LEFT, pygame.K_UP, pygame.K_DOWN):
+                if event.key == pygame.K_RIGHT:
+                    self.focus_right_child()
+                elif event.key == pygame.K_LEFT:
+                    self.focus_left_child()
+                elif event.key == pygame.K_UP:
+                    self.focus_up_child()
+                elif event.key == pygame.K_DOWN:
+                    self.focus_down_child()
+                
+                event.consumed = True
+
     def update_children_rect(self):
-        if self.parent.children:
-            cell_width = max(child.get_min_required_size()[0] for child in self.parent.children)
-            cell_height = max(child.get_min_required_size()[1] for child in self.parent.children)
+        if self.parent.get_layout_children():
+            cell_width = max(child.get_min_required_size()[0] for child in self.parent.get_layout_children())
+            cell_height = max(child.get_min_required_size()[1] for child in self.parent.get_layout_children())
             width = self.cols * cell_width + self.gap * (self.cols - 1)
             height = self.rows * cell_height + self.gap * (self.rows - 1)
             self.children_rect = pygame.FRect(*self.parent.get_inner_rect().topleft, width, height)
@@ -317,13 +384,13 @@ class Grid(DoubleAxisLayout):
 
     def arrange(self) -> None:
         self.update_children_rect()
-        if not self.parent.children:
+        if not self.parent.get_layout_children():
             return
 
         cell_width = (self.children_rect.width - self.gap * (self.cols - 1)) / self.cols
         cell_height = (self.children_rect.height - self.gap * (self.rows - 1)) / self.rows
 
-        for i, child in enumerate(self.parent.children):
+        for i, child in enumerate(self.parent.get_layout_children()):
             row = i // self.cols
             col = i % self.cols
             x = self.children_rect.x + col * (cell_width + self.gap)
@@ -333,19 +400,24 @@ class Grid(DoubleAxisLayout):
 
 
 class GridFill(Grid):
+    def update_children_rect(self):
+        self.children_rect = self.parent.get_inner_rect()
     def arrange(self) -> None:
         """
         Arranges children in a grid and resizes them to fill the parent's available space,
         accounting for the gap between children.
         """
         self.update_children_rect()
-        if not self.parent.children:
+            
+        if not self.parent.get_layout_children():
             return
+        for child in self.parent.get_layout_children():
+            child.set_autoresize(False)
 
         cell_width = (self.children_rect.width - self.gap * (self.cols - 1)) / self.cols
         cell_height = (self.children_rect.height - self.gap * (self.rows - 1)) / self.rows
 
-        for i, child in enumerate(self.parent.children):
+        for i, child in enumerate(self.parent.get_layout_children()):
             row = i // self.cols
             col = i % self.cols
             x = self.children_rect.x + col * (cell_width + self.gap)

batFramework/gui/meter.py

@@ -1,3 +1,4 @@
+import math
 import batFramework as bf
 from .shape import Shape
 from typing import Self
@@ -8,33 +9,18 @@ def custom_top_at(self, x, y):
         return self.parent
     return None
 
-
 class Meter(Shape):
     def __init__(self, min_value: float = 0, max_value: float = 1, step: float = 0.1):
         super().__init__()
-        self.axis: bf.axis = bf.axis.HORIZONTAL
         self.min_value, self.max_value = min_value, max_value
         self.step = step
         self.snap: bool = False
         self.value = self.max_value
-        self.content = Shape((0, 0)).set_color(bf.color.BLUE)
-        self.content.set_debug_color("cyan")
-        self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
-        self.add(self.content)
-        self.set_padding(4)
-        self.set_color("gray20")
-        self.set_outline_width(1)
-        self.set_outline_color(bf.color.BLACK)
         self.set_debug_color("pink")
 
     def __str__(self) -> str:
         return "Meter"
 
-    def set_axis(self,axis:bf.axis)->Self:
-        self.axis = axis
-        self.dirty_shape = True
-        return self
-
     def set_step(self, step: float) -> Self:
         self.step = step
         self.set_value(self.value)
@@ -47,10 +33,6 @@ class Meter(Shape):
         self.max_value = range_max
         self.dirty_shape = True
 
-    def get_debug_outlines(self):
-        yield from super().get_debug_outlines()
-        # yield from self.content.get_debug_outlines()
-
     def set_value(self, value: float) -> Self:
         value = max(self.min_value, min(self.max_value, value))
         value = round(value / self.step) * self.step
@@ -67,21 +49,47 @@ class Meter(Shape):
     def get_ratio(self) -> float:
         return (self.value-self.min_value) / (self.max_value - self.min_value)
 
+
+class BarMeter(Meter):
+    def __init__(self, min_value: float = 0, max_value: float = 1, step: float = 0.1):
+        super().__init__(min_value, max_value, step)
+        self.axis: bf.axis = bf.axis.HORIZONTAL
+        self.content = Shape((0, 0)).set_color(bf.color.BLUE)
+        self.content.set_debug_color("cyan")
+        self.content.top_at = lambda x, y: custom_top_at(self.content, x, y)
+        self.add(self.content)
+        self.set_padding(4)
+        self.set_color("gray20")
+        self.set_outline_width(1)
+        self.set_outline_color(bf.color.BLACK)
+        self.set_debug_color("pink")
+
+    def __str__(self) -> str:
+        return "BarMeter"
+
+    def set_axis(self,axis:bf.axis)->Self:
+        self.axis = axis
+        self.dirty_shape = True
+        return self
+
     def _build_content(self) -> None:
         padded = self.get_inner_rect()
         ratio = self.get_ratio()
 
-        if self.axis == bf.axis.HORIZONTAL:
-            width = padded.width * ratio
-            self.content.set_size((width, padded.height))
-            self.content.rect.topleft = padded.topleft
-
-        else:  # VERTICAL
-            height = padded.height * ratio
-            self.content.set_size((padded.width, height))
-            # Content grows from bottom up
-            self.content.rect.bottomleft = padded.bottomleft
+        self.content.set_border_radius(*[round(b/2) for b in self.border_radius])
 
+        if self.axis == bf.axis.HORIZONTAL:
+            width = (padded.width- self.outline_width *2) * ratio 
+            self.content.set_size((width, padded.height - self.outline_width*2))
+            self.content.rect.topleft = padded.move(self.outline_width, self.outline_width).topleft
+
+        else:  # vertical
+            height = (padded.height - self.outline_width * 2) * ratio
+            self.content.set_size((padded.width - self.outline_width * 2, height))
+            self.content.rect.bottomleft = (
+                padded.move(self.outline_width,-self.outline_width).bottomleft 
+            )
+            self.content.rect.height = math.ceil(self.content.rect.height)
 
     def build(self) -> None:
         self._build_content()

batFramework/gui/radioButton.py

@@ -1,83 +1,35 @@
 import batFramework as bf
 from typing import Self, Any, Callable
 from .toggle import Toggle
-
-
+from .syncedVar import SyncedVar
 
 
 class RadioButton(Toggle):
-    def __init__(self, text: str = "", radio_value: Any = None) -> None:
+    def __init__(self, text: str = "", radio_value: Any = None, synced_var: SyncedVar = None) -> None:
         super().__init__(text, None, False)
-        self.radio_value: Any = (
-            radio_value if radio_value is not None else text if text else None
-        )
-        self.radio_variable: RadioVariable = None
+        self.radio_value: Any = radio_value if radio_value is not None else text if text else None
+        self.synced_var : SyncedVar = None
+        if synced_var:
+            self.link(synced_var)
+
+    def link(self,synced_var:SyncedVar)->Self:
+        self.synced_var = synced_var
+        synced_var.bind_widget(self,self._update_state)
+        return self
 
     def __str__(self) -> str:
-        return (
-            f"RadioButton({self.radio_value}|{'Active' if self.value else 'Inactive'})"
-        )
+        return f"RadioButton({self.radio_value}|{'Active' if self.value else 'Inactive'})"
 
     def set_radio_value(self, value: Any) -> Self:
         self.radio_value = value
-
-        if self.radio_variable:
-            self.radio_variable.update_buttons()
         return self
 
-    def set_text(self, text: str) -> Self:
-        flag = False
-        if self.value == self.text or self.value is None:
-            flag = True
-        super().set_text(text)
-        if flag:
-            self.set_radio_value(self.text)
-        return self
-
-    def click(self) -> None:
-        if self.radio_variable is None:
-            return
-        self.radio_variable.set_value(self.radio_value)
-
-
-class RadioVariable:
-    def __init__(self) -> None:
-        self.buttons: list[RadioButton] = []
-        self.value = None
-        self.modify_callback: Callable[[bool],Any] = None
-
-    def set_modify_callback(self, callback:Callable[[bool],Any]) -> Self:
-        self.modify_callback = callback
-        return self
-
-    def link(self, *buttons: RadioButton) -> Self:
-        if not buttons:
-            return self
-        for b in buttons:
-            b.radio_variable = self
-        self.buttons.extend(buttons)
-
-        if self.value is None:
-            self.set_value(buttons[0].radio_value)
-        else:
-            self.update_buttons()
-        return self
-
-    def unlink(self, *buttons) -> Self:
-        for b in self.buttons:
-            if b in buttons:
-                b.radio_variable = None
-        self.buttons = [b for b in self.buttons if b not in buttons]
-        return self
-
-    def set_value(self, value: Any) -> Self:
-        if value == self.value:
-            return
-        self.value = value
-        if self.modify_callback:
-            self.modify_callback(value)
-        self.update_buttons()
-        return self
+    def set_value(self, value : bool, do_callback=False):
+        super().set_value(value, do_callback)
+        if value : self.synced_var.value = self.radio_value
 
-    def update_buttons(self):
-        _ = [b.set_value(b.radio_value == self.value, False) for b in self.buttons]
+    def _update_state(self, synced_value: Any) -> None:
+        """
+        Updates the state of the RadioButton based on the synced variable's value.
+        """
+        self.set_value(self.radio_value == synced_value, False)

batFramework/gui/root.py

@@ -109,13 +109,11 @@ class Root(InteractiveWidget):
         return self
 
     def process_event(self,event):
-        if event.consumed : return
-        self.do_handle_event_early(event)
-        if event.consumed : return
-        super().process_event(event)
+        if not event.consumed : self.do_handle_event_early(event)
+        if not event.consumed : super().process_event(event)
         
     def do_handle_event_early(self, event):
-        if event.type == pygame.VIDEORESIZE:
+        if event.type == pygame.VIDEORESIZE and not pygame.SCALED & bf.const.FLAGS:
             self.set_size((event.w,event.h),force=True)
         if self.focused:
             if event.type == pygame.KEYDOWN:
@@ -126,6 +124,7 @@ class Root(InteractiveWidget):
                 event.consumed = self.focused.on_key_up(event.key)
 
         if not self.hovered or (not isinstance(self.hovered, InteractiveWidget)):
+            event.consumed = True
             return
 
         if event.type == pygame.MOUSEBUTTONDOWN:
@@ -200,6 +199,7 @@ class Root(InteractiveWidget):
         # print("START updating tree")
         self.apply_updates("pre")
         self.apply_updates("post")
+
         self.apply_updates("pre")
         self.apply_updates("post")
 

batFramework/gui/selector.py

@@ -21,7 +21,6 @@ class Selector(Button):
         self.on_modify_callback : Callable[[str,int],Any] = None
         self.options = options if options else []
         self.gap : int = 2
-        self.indicator_height = 0
         text_value = ""
 
         
@@ -32,13 +31,11 @@ class Selector(Button):
         self.current_index = self.options.index(default_value)
 
         self.left_indicator : MyArrow = (MyArrow(bf.direction.LEFT)
-            .set_draw_stem(False)
             .set_color((0,0,0,0)).set_arrow_color(self.text_color)
             .set_callback(lambda : self.set_by_index(self.get_current_index()-1))
         )
 
         self.right_indicator:MyArrow =(MyArrow(bf.direction.RIGHT)
-            .set_draw_stem(False)
             .set_color((0,0,0,0)).set_arrow_color(self.text_color)
             .set_callback(lambda : self.set_by_index(self.get_current_index()+1))
         )
@@ -54,7 +51,12 @@ class Selector(Button):
         self.gap = value
         self.dirty_shape = True
         return self
-        
+    
+    def set_arrow_color(self,color)->Self:
+        self.left_indicator.set_arrow_color(color)
+        self.right_indicator.set_arrow_color(color)
+        return self
+
     def disable(self):
         super().disable()
         self.left_indicator.disable()
@@ -99,14 +101,13 @@ class Selector(Button):
         self.text = old_text
 
         # Ensure total_height is always an odd integer
-        total_height = max(8, max_text_size[1] * 1.5)
+        total_height = max(self.font_object.get_height()+1, max_text_size[1] * 1.5)
         total_height += self.unpressed_relief
         total_height += max(self.right_indicator.outline_width,self.left_indicator.outline_width)
-        self.indicator_height = total_height
 
         # Calculate total width and height
         total_width = (
-            self.indicator_height*2+
+            total_height*2+
             max_text_size[0] +  # Text width
             self.gap * 2      # Gaps between text and indicators
         )
@@ -115,8 +116,6 @@ class Selector(Button):
 
         return final_size
 
-
-
     def _align_content(self):
         """
         Builds the selector layout (places and resizes the indicators)
@@ -130,7 +129,7 @@ class Selector(Button):
         # left_size = self.left_indicator.rect.size
         right_size = self.right_indicator.rect.size
 
-        indicator_height = self.indicator_height
+        indicator_height = padded.h
 
         self.left_indicator.set_size((indicator_height,indicator_height))
         self.right_indicator.set_size((indicator_height,indicator_height))
@@ -143,11 +142,8 @@ class Selector(Button):
         self.right_indicator.set_position(padded.right - right_size[0], None)
         self.right_indicator.set_center(None, padded.centery)
 
-
-
-    def build(self):
-        
-        super().build()
+    def apply_post_updates(self, skip_draw = False):
+        super().apply_post_updates(skip_draw)
         self._align_content()
 
     def get_current_index(self)->int:
@@ -172,8 +168,6 @@ class Selector(Button):
         self.on_modify_callback = function
         return self
 
-    
-
     def set_by_index(self,index:int)->Self:
         if self.allow_cycle:
             index = index%len(self.options)
@@ -183,7 +177,6 @@ class Selector(Button):
         if index == self.current_index:
             return self
 
-
         self.current_index = index
         self.set_text(self.options[self.current_index])
         if self.on_modify_callback:
@@ -209,14 +202,14 @@ class Selector(Button):
             self.right_indicator.hide()
             
     def set_by_value(self,value:str)->Self:
-        if not self.enabled : return
+        if not self.is_enabled : return
         if value not in self.options : return self
         index = self.options.index(value)
         self.set_by_index(index)
         return self
 
     def on_key_down(self, key: int) -> bool:
-        if not self.enabled:
+        if not self.is_enabled:
             return False
 
         key_actions = {
@@ -226,14 +219,14 @@ class Selector(Button):
         }
 
         indicator = key_actions.get(key)
-        if indicator and indicator.visible and indicator.enabled:
+        if indicator and indicator.visible and indicator.is_enabled:
             indicator.on_click_down(1)
             return True
 
         return False
 
     def on_key_up(self, key: int) -> bool:
-        if not self.enabled:
+        if not self.is_enabled:
             return False
 
         key_actions = {
@@ -243,14 +236,14 @@ class Selector(Button):
         }
 
         indicator = key_actions.get(key)
-        if indicator and indicator.visible and indicator.enabled:
+        if indicator and indicator.visible and indicator.is_enabled:
             indicator.on_click_up(1)
             return True
 
         return False
     
     def do_on_click_down(self, button) -> None:
-        if self.enabled and button == 1:
+        if self.is_enabled and button == 1:
             if not self.get_focus():
                 return True
         return False