batframework 1.0.8a1__py3-none-any.whl → 1.0.8a3__py3-none-any.whl

batFramework/gui/dialogueBox.py

@@ -14,11 +14,14 @@ class DialogueBox(Label):
         self.set_alignment(bf.alignment.LEFT)
         super().__init__("")
 
-    def pause(self)->Self:
+    def __str__(self) -> str:
+        return "DialogueBox"
+
+    def pause(self) -> Self:
         self.is_paused = True
         return self
-    
-    def resume(self)->Self:
+
+    def resume(self) -> Self:
         self.is_paused = False
         return self
 
@@ -28,40 +31,40 @@ class DialogueBox(Label):
 
     def cut_text_to_width(self, text: str) -> list[str]:
         w = self.get_padded_width()
-        if text == "" or not self.font_object or  w < self.font_object.point_size:
+        if text == "" or not self.font_object or w < self.font_object.point_size:
             return [text]
         left = 0
         for index in range(len(text)):
             width = self.font_object.size(text[left:index])[0]
-            
+
             if width > w:
                 cut_point_start = index - 1
                 cut_point_end = index - 1
-                last_space = text.rfind(' ', 0, cut_point_start)
-                last_nline = text.rfind('\n', 0, cut_point_start)
+                last_space = text.rfind(" ", 0, cut_point_start)
+                last_nline = text.rfind("\n", 0, cut_point_start)
 
-                if last_space != -1 or last_nline!= -1:  # space was found !:
-                    cut_point_start = max(last_space,last_nline)
+                if last_space != -1 or last_nline != -1:  # space was found !:
+                    cut_point_start = max(last_space, last_nline)
                     cut_point_end = cut_point_start + 1
                 res = [text[:cut_point_start].strip()]
                 res.extend(self.cut_text_to_width(text[cut_point_end:].strip()))
                 return res
-            elif text[index] == '\n':
+            elif text[index] == "\n":
                 left = index
         return [text]
 
-    def paint(self)->None:
-        if self.font_object and self.message_queue :
+    def paint(self) -> None:
+        if self.font_object and self.message_queue:
             message = self.message_queue.pop(0)
             message = "\n".join(self.cut_text_to_width(message))
-            self.message_queue.insert(0,message)
+            self.message_queue.insert(0, message)
         super().paint()
- 
-    def say(self, message: str) ->Self:
+
+    def say(self, message: str) -> Self:
         self.message_queue.append(message)
         self.is_over = False
         return self
-    
+
     def is_queue_empty(self) -> bool:
         return not self.message_queue
 
@@ -80,7 +83,7 @@ class DialogueBox(Label):
         self.set_text("")
         return self
 
-    def skip_current_message(self)->Self:
+    def skip_current_message(self) -> Self:
         self.cursor_position = len(self.message_queue[0])
         self.dirty_shape = True
 

batFramework/gui/draggableWidget.py

@@ -17,19 +17,21 @@ class DraggableWidget(InteractiveWidget):
     def do_reset_actions(self) -> None:
         self.drag_action.reset()
 
-    def do_on_drag(self,drag_start:tuple[float,float],drag_end: tuple[float,float])->None:
-        self.set_position(drag_end[0]-self.offset[0],drag_end[1]-self.offset[1])
+    def do_on_drag(
+        self, drag_start: tuple[float, float], drag_end: tuple[float, float]
+    ) -> None:
+        self.set_position(drag_end[0] - self.offset[0], drag_end[1] - self.offset[1])
 
     def update(self, dt: float):
         if self.drag_action.active and self.is_clicked_down:
             r = self.get_root()
             x, y = r.drawing_camera.screen_to_world(pygame.mouse.get_pos())
             if self.drag_start == None and self.drag_action.active:
-                self.offset = x-self.rect.x,y-self.rect.y
-                self.drag_start = x,y
+                self.offset = x - self.rect.x, y - self.rect.y
+                self.drag_start = x, y
                 return
             else:
-                self.do_on_drag(self.drag_start,(x,y))
+                self.do_on_drag(self.drag_start, (x, y))
                 return
         else:
             self.drag_start = None

batFramework/gui/image.py

@@ -1,47 +1,59 @@
 import batFramework as bf
 from .widget import Widget
+from .shape import Shape
 import pygame
 from typing import Self
 
 
-class Image(Widget):
+class Image(Shape):
     def __init__(
         self,
         path: str = None,
         convert_alpha=True,
     ):
         self.original_surface = None
-        super().__init__(convert_alpha = convert_alpha)
+        super().__init__(convert_alpha=convert_alpha)
         if path is not None:
             self.from_path(path)
 
+    def __str__(self) -> str:
+        return "Image"
+
     def paint(self) -> None:
         super().paint()
-        self.surface.fill((0,0,0,0 if self.convert_alpha else 255))
+        # self.surface.fill((0,0,0,0 if self.convert_alpha else 255))
+        if self.original_surface is None:
+            return
         if self.rect.size != self.original_surface.get_size():
-            self.surface.blit(pygame.transform.scale(self.original_surface,self.rect.size),(0,0))
+            self.surface.blit(
+                pygame.transform.scale(self.original_surface, self.rect.size), (0, 0)
+            )
         else:
-            self.surface.blit(self.original_surface,(0,0))
-
+            self.surface.blit(self.original_surface, (0, 0))
 
-    def from_path(self,path:str)->Self:
-        tmp = bf.ResourceManager().get_image(path,self.convert_alpha)
+    def from_path(self, path: str) -> Self:
+        tmp = bf.ResourceManager().get_image(path, self.convert_alpha)
         if tmp is None:
             return self
         self.original_surface = tmp
         size = self.original_surface.get_size()
-        if not self.autoresize_h : size[0] = None
-        if not self.autoresize_h : size[1] = None
+        if not self.autoresize_h:
+            size[0] = None
+        if not self.autoresize_h:
+            size[1] = None
         self.set_size(size)
         self.dirty_surface = True
         return self
 
-    def from_surface(self,surface: pygame.Surface)->Self:
-        if surface is None : return self
+    def from_surface(self, surface: pygame.Surface) -> Self:
+        if surface is None:
+            return self
         self.original_surface = surface
         size = self.original_surface.get_size()
-        if not self.autoresize_h : size[0] = None
-        if not self.autoresize_h : size[1] = None
+        if not self.autoresize_h:
+            size[0] = None
+        if not self.autoresize_h:
+            size[1] = None
         self.set_size(size)
         self.dirty_surface = True
-        return self
+        return self

batFramework/gui/indicator.py

@@ -23,7 +23,6 @@ class Indicator(Shape):
     def get_value(self) -> Any:
         pass
 
-
     def top_at(self, x, y):
         return None
 
@@ -31,7 +30,7 @@ class Indicator(Shape):
 class ToggleIndicator(Indicator):
     def __init__(self, default_value: bool) -> None:
         self.value: bool = default_value
-        self.callback = lambda val : self.set_color("green" if val else "red")
+        self.callback = lambda val: self.set_color("green" if val else "red")
         super().__init__((20, 20))
         self.set_value(default_value)
 
@@ -56,5 +55,3 @@ class ToggleIndicator(Indicator):
         if r is self:
             return None
         return r
-
-        

batFramework/gui/interactiveWidget.py

@@ -23,7 +23,7 @@ class InteractiveWidget(Widget):
         return self
 
     def allow_focus_to_self(self) -> bool:
-        return True
+        return self.visible
 
     def get_focus(self) -> bool:
         if self.focusable and ((r := self.get_root()) is not None):
@@ -47,22 +47,90 @@ class InteractiveWidget(Widget):
         self.is_focused = False
         self.do_on_lose_focus()
 
-    def on_key_down(self,key):
+    def focus_next_tab(self, previous_widget):
+
+        if previous_widget != self and self.visible:
+            if (
+                isinstance(self, InteractiveWidget)
+                and not isinstance(self, bf.Container)
+                and self.allow_focus_to_self()
+            ):
+                self.focus_next_sibling()
+                return
+            i_children = [
+                c
+                for c in self.children
+                if isinstance(c, InteractiveWidget) and c.visible
+            ]
+            if i_children:
+                index = i_children.index(previous_widget)
+                if index < len(i_children) - 1:
+
+                    i_children[index + 1].get_focus()
+                    return
+
+        if self.parent:
+            self.parent.focus_next_tab(self)
+
+    def focus_prev_tab(self, previous_widget):
+        if previous_widget != self and self.visible:
+            if (
+                isinstance(self, InteractiveWidget)
+                and not isinstance(self, bf.Container)
+                and self.allow_focus_to_self()
+            ):
+                self.get_focus()
+                return
+            i_children = [
+                c
+                for c in self.children
+                if isinstance(c, InteractiveWidget) and c.visible
+            ]
+
+            if i_children:
+                index = i_children.index(previous_widget)
+                if index > 0:
+                    i_children[index - 1].get_focus()
+                    return
+
+        if self.parent:
+            self.parent.focus_prev_tab(self)
+
+    def focus_next_sibling(self) -> None:
+        if isinstance(self.parent, bf.Container):
+            self.parent.focus_next_child()
+
+    def focus_prev_sibling(self) -> None:
+        if isinstance(self.parent, bf.Container):
+            self.parent.focus_prev_child()
+
+    def on_key_down(self, key) -> bool:
         if key == pygame.K_DOWN:
             self.focus_next_sibling()
         elif key == pygame.K_UP:
             self.focus_prev_sibling()
+        elif key == pygame.K_TAB and self.parent:
+            keys = pygame.key.get_pressed()
+            if keys[pygame.K_LSHIFT] or keys[pygame.K_RSHIFT]:
+
+                self.focus_prev_tab(self)
+            else:
+                self.focus_next_tab(self)
+
         else:
-            self.do_on_key_down(key)
 
-    def on_key_up(self, key):
-        self.do_on_key_up(key)
+            return self.do_on_key_down(key)
 
-    def do_on_key_down(self, key):
-        pass
+        return False
 
-    def do_on_key_up(self, key):
-        pass
+    def on_key_up(self, key) -> bool:
+        return self.do_on_key_up(key)
+
+    def do_on_key_down(self, key) -> bool:
+        return False
+
+    def do_on_key_up(self, key) -> bool:
+        return False
 
     def do_on_get_focus(self) -> None:
         pass
@@ -70,27 +138,19 @@ class InteractiveWidget(Widget):
     def do_on_lose_focus(self) -> None:
         pass
 
-    def focus_next_sibling(self) -> None:
-        if isinstance(self.parent, bf.Container):
-            self.parent.focus_next_child()
-
-    def focus_prev_sibling(self) -> None:
-        if isinstance(self.parent, bf.Container):
-            self.parent.focus_prev_child()
-
-    def on_click_down(self, button: int) -> None:
+    def on_click_down(self, button: int) -> bool:
         self.is_clicked_down = True
-        self.do_on_click_down(button)
+        return self.do_on_click_down(button)
 
-    def on_click_up(self, button: int) -> None:
+    def on_click_up(self, button: int) -> bool:
         self.is_clicked_down = False
-        self.do_on_click_up(button)
+        return self.do_on_click_up(button)
 
-    def do_on_click_down(self, button: int) -> None:
-        pass
+    def do_on_click_down(self, button: int) -> bool:
+        return False
 
-    def do_on_click_up(self, button: int) -> None:
-        pass
+    def do_on_click_up(self, button: int) -> bool:
+        return False
 
     def on_enter(self) -> None:
         self.is_hovered = True
@@ -108,18 +168,19 @@ class InteractiveWidget(Widget):
         pass
 
     def on_mouse_motion(self, x, y) -> None:
-        self.do_on_mouse_motion(x,y)
+        self.do_on_mouse_motion(x, y)
 
-    def do_on_mouse_motion(self,x,y)->None:
+    def do_on_mouse_motion(self, x, y) -> None:
         pass
 
     def set_focused_child(self, child: "InteractiveWidget"):
         pass
 
-    def draw_focused(self, camera: bf.Camera) -> None: 
-        delta = 4 + ((2*cos(pygame.time.get_ticks()/100)) //2) * 2
+    def draw_focused(self, camera: bf.Camera) -> None:
+        delta = 4 + ((2 * cos(pygame.time.get_ticks() / 100)) // 2) * 2
         pygame.draw.rect(
             camera.surface,
             "white",
-            self.rect.move(-camera.rect.x,-camera.rect.y).inflate(delta,delta),1
+            self.rect.move(-camera.rect.x, -camera.rect.y).inflate(delta, delta),
+            1,
         )

batFramework/gui/label.py

@@ -7,8 +7,8 @@ from typing import Self
 class Label(Shape):
     _text_cache = {}
 
-    def __init__(self, text: str) -> None:
-        self.text = ""
+    def __init__(self, text: str = "") -> None:
+        self.text = text
 
         self.resized_flag: bool = False
 
@@ -34,7 +34,7 @@ class Label(Shape):
         # reference to the font object
         self.font_object = None
         # Rect containing the text of the label
-        self.text_rect = pygame.FRect(0,0,0,0)
+        self.text_rect = pygame.FRect(0, 0, 0, 0)
         # text surface (result of font.render)
         self.text_surface: pygame.Surface = pygame.Surface((0, 0))
         self.do_caching: bool = False
@@ -53,12 +53,14 @@ class Label(Shape):
         self.set_color("gray50")
         self.set_autoresize(True)
         self.set_font(force=True)
-        self.set_text(text)
 
     @staticmethod
     def clear_cache():
         Label._text_cache = {}
 
+    def __str__(self) -> str:
+        return f"Label({self.text})"
+
     def enable_caching(self) -> Self:
         self.do_caching = True
         return self
@@ -76,7 +78,7 @@ class Label(Shape):
         if value == self.is_italic:
             return self
         self.is_italic = value
-        if self.autoresize_h or self.autoresize_w: 
+        if self.autoresize_h or self.autoresize_w:
             self.dirty_shape = True
         else:
             self.dirty_surface = True
@@ -86,7 +88,7 @@ class Label(Shape):
         if value == self.is_bold:
             return self
         self.is_bold = value
-        if self.autoresize_h or self.autoresize_w: 
+        if self.autoresize_h or self.autoresize_w:
             self.dirty_shape = True
         else:
             self.dirty_surface = True
@@ -123,9 +125,6 @@ class Label(Shape):
         self.dirty_surface = True
         return self
 
-    def __str__(self) -> str:
-        return f"Label({self.text})"
-
     def set_alignment(self, alignment: bf.alignment) -> "Label":
         self.alignment = alignment
         self.dirty_surface = True
@@ -133,22 +132,23 @@ class Label(Shape):
 
     def set_auto_wraplength(self, val: bool) -> "Label":
         self.auto_wraplength = val
-        if self.autoresize_h or self.autoresize_w: 
+        if self.autoresize_h or self.autoresize_w:
             self.dirty_shape = True
         else:
             self.dirty_surface = True
         return self
 
     def get_debug_outlines(self):
+        if self.visible:
+            yield (self.text_rect.move(*self.rect.topleft), "purple")
         yield from super().get_debug_outlines()
-        yield (self.text_rect.move(*self.rect.topleft),"purple")
-        
+
     def set_font(self, font_name: str = None, force: bool = False) -> Self:
         if font_name == self.font_name and not force:
             return self
         self.font_name = font_name
         self.font_object = bf.FontManager().get_font(self.font_name, self.text_size)
-        if self.autoresize_h or self.autoresize_w: 
+        if self.autoresize_h or self.autoresize_w:
             self.dirty_shape = True
         else:
             self.dirty_surface = True
@@ -160,7 +160,7 @@ class Label(Shape):
             return self
         self.text_size = text_size
         self.font_object = bf.FontManager().get_font(self.font_name, self.text_size)
-        if self.autoresize_h or self.autoresize_w: 
+        if self.autoresize_h or self.autoresize_w:
             self.dirty_shape = True
         return self
 
@@ -182,8 +182,8 @@ class Label(Shape):
         self.dirty_shape = True
         return self
 
-    def get_min_required_size(self)->tuple[float,float]:
-        if not (self.autoresize_w or  self.autoresize_h) : 
+    def get_min_required_size(self) -> tuple[float, float]:
+        if not (self.autoresize_w or self.autoresize_h):
             return self.rect.size
         if not self.text_rect:
             params = {
@@ -192,13 +192,17 @@ class Label(Shape):
                 "antialias": False,
                 "color": "white",
                 "bgcolor": "black",  # if (self.has_alpha_color() or self.draw_mode == bf.drawMode.TEXTURED) else self.color,
-                "wraplength": int(self.get_padded_width()) if self.auto_wraplength else 0,
+                "wraplength": (
+                    int(self.get_padded_width()) if self.auto_wraplength else 0
+                ),
             }
 
             self.text_rect.size = self._render_font(params).get_size()
-        res = self.inflate_rect_by_padding((0,0,*self.text_rect.size)).size
+        res = self.inflate_rect_by_padding((0, 0, *self.text_rect.size)).size
         # return res
-        return res[0] if self.autoresize_w else self.rect.w, res[1] if self.autoresize_h else self.rect.h
+        return res[0] if self.autoresize_w else self.rect.w, (
+            res[1] if self.autoresize_h else self.rect.h
+        )
 
     def get_text(self) -> str:
         return self.text
@@ -212,19 +216,19 @@ class Label(Shape):
             if cached_value is None:
                 params.pop("font_name")
 
-                #save old settings                
+                # save old settings
                 old_italic = self.font_object.get_italic()
                 old_bold = self.font_object.get_bold()
                 old_underline = self.font_object.get_underline()
 
-                #setup font
+                # setup font
                 self.font_object.set_italic(self.is_italic)
                 self.font_object.set_bold(self.is_bold)
                 self.font_object.set_underline(self.is_underlined)
-                
+
                 surf = self.font_object.render(**params)
 
-                # reset font 
+                # reset font
                 self.font_object.set_italic(old_italic)
                 self.font_object.set_bold(old_bold)
                 self.font_object.set_underline(old_underline)
@@ -251,16 +255,18 @@ class Label(Shape):
         }
 
         self.text_rect.size = self._render_font(params).get_size()
-        if self.autoresize_h or self.autoresize_w: 
-            target_rect = self.inflate_rect_by_padding((0,0,*self.text_rect.size))
-            if not self.autoresize_w : target_rect.w = self.rect.w
-            if not self.autoresize_h : target_rect.h = self.rect.h
+        if self.autoresize_h or self.autoresize_w:
+            target_rect = self.inflate_rect_by_padding((0, 0, *self.text_rect.size))
+            if not self.autoresize_w:
+                target_rect.w = self.rect.w
+            if not self.autoresize_h:
+                target_rect.h = self.rect.h
             if self.rect.size != target_rect.size:
                 self.set_size(target_rect.size)
                 self.build()
                 return
-        padded = self.get_padded_rect().move(-self.rect.x,-self.rect.y)
-        self.align_text(self.text_rect,padded,self.alignment)
+        padded = self.get_padded_rect().move(-self.rect.x, -self.rect.y)
+        self.align_text(self.text_rect, padded, self.alignment)
 
     def _paint_text(self) -> None:
         if self.font_object is None:
@@ -284,7 +290,6 @@ class Label(Shape):
                 .to_surface(setcolor=self.text_outline_color, unsetcolor=(0, 0, 0, 0))
             )
 
-
         l = []
         if self.show_text_outline:
             l.append(
@@ -298,18 +303,22 @@ class Label(Shape):
         )
         self.surface.fblits(l)
 
-    def align_text(self,text_rect:pygame.FRect,area:pygame.FRect,alignment: bf.alignment):
-        if alignment == bf.alignment.LEFT : alignment = bf.alignment.MIDLEFT
-        elif alignment == bf.alignment.MIDRIGHT : alignment = bf.alignment.MIDRIGHT
+    def align_text(
+        self, text_rect: pygame.FRect, area: pygame.FRect, alignment: bf.alignment
+    ):
+        if alignment == bf.alignment.LEFT:
+            alignment = bf.alignment.MIDLEFT
+        elif alignment == bf.alignment.MIDRIGHT:
+            alignment = bf.alignment.MIDRIGHT
 
         pos = area.__getattribute__(alignment.value)
-        text_rect.__setattr__(alignment.value,pos)
+        text_rect.__setattr__(alignment.value, pos)
 
     def build(self) -> None:
         super().build()
         self._build_layout()
 
-    def paint(self)->None:
+    def paint(self) -> None:
         super().paint()
         if self.font_object:
             self._paint_text()