e2D 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

e2D/envs.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Literal
+from typing import Literal, Optional
 
 from .utils import *
 import pygame as pg
@@ -42,13 +42,15 @@ class RootEnv:
                  quit_on_key_pressed : None|int = pg.K_x,
                  vsync : bool = True,
                  window_flags : int = pg.DOUBLEBUF,
+                 display_index : int = 0,
                  clear_screen_each_frame : bool = True) -> None:
         self.quit = False
         self.__screen_size__ :Vector2D= screen_size
 
         self.__vsync__ = vsync
         self.__flags__ = window_flags
-        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__)
+        self.__display_index__ = display_index
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
         self.clock = pg.time.Clock()
         self.keyboard = Keyboard()
@@ -56,17 +58,31 @@ class RootEnv:
 
         self.target_fps = target_fps
         self.current_fps = self.target_fps if self.target_fps != 0 else 1
+        self.__dt__ = 1 / self.current_fps
         self.current_frame = 0
         self.show_fps = show_fps
         self.events :list[pg.event.Event]= []
         
-        self.__background_color__ :Color= BLACK_COLOR_PYG
+        # Track start time for accurate runtime calculation (excluding compilation time)
+        self.set_starting_timer()
+        
+        self.__background_color__ :pg.Color= BLACK_COLOR_PYG
         
         self.clear_screen_each_frame = clear_screen_each_frame
         self.utils :dict[int|str, Util]= {}
         self.selected_util :Util|None = None
         self.__quit_on_key_pressed__ = quit_on_key_pressed
 
+        self.fps_label = Label(str(round(self.current_fps,2)), self.screen_size * .01, V2(250, 50), BLACK_COLOR_PYG, TRANSPARENT_COLOR_PYG, WHITE_COLOR_PYG, border_width=0, starting_hidden=(not self.show_fps), pivot_position="top_left", font=FONT_ARIAL_32)
+        self.add_utils(self.fps_label)
+
+    def set_starting_timer(self) -> None:
+        self.__start_time__ = pg.time.get_ticks()
+
+    def init_rec(self, fps:int=30, draw_on_screen:bool=True, path:str='output.mp4', font:pg.font.Font=FONT_MONOSPACE_16) -> None:
+        from .winrec import WinRec
+        self.__winrecorder__ = WinRec(self, fps=fps, draw_on_screen=draw_on_screen, path=path, font=font)
+
     @property
     def background_color(self) -> Color:
         return unpygamize_color(self.__background_color__)
@@ -81,46 +97,51 @@ class RootEnv:
     @screen_size.setter
     def screen_size(self, new_size:Vector2D) -> None:
         self.__screen_size__ = new_size
-        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__)
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
+
+    def update_screen_to_new_size(self) -> None:
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
     @property
-    def delta(self) -> int:
-        return self.clock.get_time() / 1000
+    def delta(self) -> float:
+        return self.__dt__
 
     def get_teoric_max_fps(self) -> float:
         rawdelta = self.clock.get_rawtime()
         return (1000 / rawdelta) if rawdelta != 0 else 1
 
-    def update_screen_mode(self, vsync:None|bool=None, flags=None) -> None:
-        self.__vsync__ = vsync
-        self.__flags__ = flags
+    def update_screen_mode(self, vsync:Optional[bool]=None, flags:Optional[int]=None, display_index:Optional[int]=None) -> None:
+        if vsync is not None: self.__vsync__ = vsync
+        if flags is not None: self.__flags__ = flags
+        if display_index is not None: self.__display_index__ = display_index
+        self.screen = pg.display.set_mode(self.__screen_size__(), vsync=self.__vsync__, flags=self.__flags__, display=self.__display_index__)
 
     def sleep(self, seconds:int|float, precise_delay=False) -> None:
         if precise_delay:
-            pg.time.delay(seconds * 1000)
+            pg.time.delay(int(seconds * 1000))
         else:
-            pg.time.wait(seconds * 1000)
+            pg.time.wait(int(seconds * 1000))
 
     def add_utils(self, *utils:Util) -> None:
         for util in utils:
             if util.surface == None: util.surface = self.screen
             util.rootEnv = self
             util.id = self.__new_util_id__()
-            util.render()
+            util.__render__()
             self.utils[util.id] = util
 
     def remove_utils(self, *utils:int|str|Util) -> None:
         for uid in utils:
-            if uid in self.utils:
-                del self.utils[uid]
-            elif isinstance(uid, Util):
+            if isinstance(uid, Util):
                 del self.utils[uid.id]
+            elif uid in self.utils:
+                del self.utils[uid]
             else:
                 raise Exception(f"Unknown util type: {uid}")
     
     def __new_util_id__(self) -> int:
         if not self.utils: return 0
-        else: return max(self.utils.keys()) + 1
+        else: return len(self.utils.keys()) + 1
 
     def get_util(self, uid:int|str) -> Util|None:
         if isinstance(uid, Util):
@@ -132,7 +153,7 @@ class RootEnv:
 
     @property
     def runtime_seconds(self) -> float:
-        return pg.time.get_ticks() / 1e3
+        return (pg.time.get_ticks() - self.__start_time__) / 1e3
 
     def init(self, sub_env:DefEnv) -> None:
         self.env = sub_env
@@ -155,38 +176,48 @@ class RootEnv:
               border_radius : int|list[int]|tuple[int,int,int,int] = -1,
               margin : Vector2D = Vector2D.zero(),
               personalized_surface : pg.Surface|None = None
-            ) -> None:
+            ) -> Vector2D:
 
         text_box = font.render(text, True, color)
         size = Vector2D(*text_box.get_size()) + margin * 2
         pivotted_position = position - size * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position] + margin
-        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius]*4
+        if not any(isinstance(border_radius, cls) for cls in {tuple, list}): border_radius = [border_radius] * 4
         surface = (self.screen if personalized_surface == None else personalized_surface)
         if bg_color != None:
             pg.draw.rect(surface, bg_color, (pivotted_position - margin)() + size(), 0, -1, *border_radius)
         if border_width:
             pg.draw.rect(surface, border_color, (pivotted_position - margin)() + size(), border_width, -1, *border_radius)
         surface.blit(text_box, pivotted_position())
+        return size
 
     def __draw__(self) -> None:
-        self.clock.tick(self.target_fps)
+        self.__dt__ = self.clock.tick(self.target_fps) / 1000.0
         self.current_fps = self.clock.get_fps()
+        self.fps_label.text = str(round(self.current_fps, 2))
+
         if self.clear_screen_each_frame: self.clear()
 
         self.env.draw()
-        for util in self.utils.values(): util.draw()
+        for util in self.utils.values(): util.__draw__()
+
+        # Save frame first (clean), then draw info overlay (not saved)
+        if hasattr(self, "__winrecorder__"):
+            self.__winrecorder__.update()  # Captures frame without stats
+            self.__winrecorder__.draw()     # Draws stats on screen only
 
-        if self.show_fps: self.print(str(round(self.current_fps,2)), self.screen_size * .01, bg_color=BLACK_COLOR_PYG)
         pg.display.flip()
 
     def __update__(self) -> None:
         self.mouse.update()
         self.keyboard.update()
         self.env.update()
-        for util in self.utils.values(): util.update()
+        for util in self.utils.values(): util.__update__()
 
     def frame(self) -> None:
-        self.events = pg.event.get()
+        try:
+            self.events = pg.event.get()
+        except SystemError:
+            raise Warning(f"Pygame error with event drivers. Try restarting the program. If the error persists, try restarting your computer.")
         self.current_frame += 1
         self.__update__()
         self.__draw__()
@@ -194,4 +225,5 @@ class RootEnv:
         for event in self.events:
             if event.type == pg.QUIT or ((event.type == pg.KEYDOWN and event.key == self.__quit_on_key_pressed__ and self.selected_util == None) if self.__quit_on_key_pressed__ != None else False):
                 pg.quit()
+                if hasattr(self, "__winrecorder__"): self.__winrecorder__.quit()
                 self.quit = True

e2D/utils.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 from typing import Any, Callable, Literal
 import pygame as pg
-from e2D import *
-from e2D.colors import *
+from e2D import * # type: ignore
+from e2D.colors import * # type: ignore
 
 import math as _mt
 
@@ -18,6 +18,10 @@ def NEW_FONT(size, name:__LITERAL_FONTS__="arial", bold:bool=False, italic:bool=
 FONT_ARIAL_16 = NEW_FONT(16)
 FONT_ARIAL_32 = NEW_FONT(32)
 FONT_ARIAL_64 = NEW_FONT(64)
+FONT_MONOSPACE_16 = NEW_FONT(16, "cascadiamonoregular")
+FONT_MONOSPACE_32 = NEW_FONT(32, "cascadiamonoregular")
+FONT_MONOSPACE_64 = NEW_FONT(64, "cascadiamonoregular")
+
 
 
 __LITERAL_PIVOT_POSITIONS__ = Literal["top_left", "top_center", "top_right", "center_left", "center_center", "center_right", "bottom_left", "bottom_center", "bottom_right"]
@@ -33,32 +37,51 @@ __PIVOT_POSITIONS_MULTIPLIER__ = dict(zip(("top_left", "top_center", "top_right"
 class Mouse:
     def __init__(self, parent) -> None:
         self.parent = parent
-        self.__last_frame_position_count__ = 0
-        self.__last_frame_position__ = Vector2D.new_zero()
-        self.__last_frame_movement_count__ = 0
-        self.__last_frame_movement__ = Vector2D.new_zero()
-        
+        self.__last_frame_position_number__ :int= 0
+        self.__last_frame_position__ :Vector2D= Vector2D.new_zero()
+        self.__last_frame_movement_number__ :int= 0
+        self.__last_frame_movement__ :Vector2D= Vector2D.new_zero()
+        self.__last_frame_wheel_number__ :int= 0
+        self.__last_frame_wheel_delta__ :int= 0
+
         self.__pressed__ : tuple[bool, bool, bool] = (False, False, False)
-        self.update()    
+        self.update()
+
+    @property
+    def wheel_delta(self) -> int:
+        for event in self.parent.events:
+            if event.type == pg.MOUSEWHEEL:
+                if self.__last_frame_wheel_number__ != self.parent.current_frame:
+                    self.__last_frame_wheel_delta__ = event.y
+                    self.__last_frame_wheel_number__ = self.parent.current_frame
+                return self.__last_frame_wheel_delta__
+        
+        self.__last_frame_wheel_delta__ = 0
+        self.__last_frame_wheel_number__ = self.parent.current_frame
+        return self.__last_frame_wheel_delta__
 
     @property
     def position(self) -> Vector2D:
-        if self.__last_frame_position_count__ != self.parent.current_frame:
+        if self.__last_frame_position_number__ != self.parent.current_frame:
             self.__last_frame_position__ = Vector2D(*pg.mouse.get_pos())
-            self.__last_frame_position_count__ = self.parent.current_frame
+            self.__last_frame_position_number__ = self.parent.current_frame
         return self.__last_frame_position__
     @position.setter
     def position(self, new_position:Vector2D) -> None:
-        self.__last_frame_position_count__ = self.parent.current_frame
+        self.__last_frame_position_number__ = self.parent.current_frame
         self.__last_frame_position__ = new_position
         pg.mouse.set_pos(self.__last_frame_position__())
     
     @property
     def last_frame_movement(self) -> Vector2D:
-        if self.__last_frame_movement_count__ != self.parent.current_frame:
+        if self.__last_frame_movement_number__ != self.parent.current_frame:
             self.__last_frame_movement__ = Vector2D(*pg.mouse.get_rel())
-            self.__last_frame_movement_count__ = self.parent.current_frame
+            self.__last_frame_movement_number__ = self.parent.current_frame
         return self.__last_frame_movement__
+    @last_frame_movement.setter
+    def last_frame_movement(self, new_movement:Vector2D) -> None:
+        self.__last_frame_movement_number__ = self.parent.current_frame
+        self.__last_frame_movement__ = new_movement
 
     def update(self) -> None:
         self.__last_pressed__ = self.__pressed__
@@ -95,8 +118,8 @@ class Keyboard:
 
 class Util:
     def __init__(self) -> None:
-        self.rootEnv = None
-        self.surface : pg.Surface = pg.SurfaceType
+        self.rootEnv : Any
+        self.surface : pg.Surface= None # type: ignore
         self.id : int|str
         self.is_hovered :bool= False
         self.hidden :bool= False
@@ -104,9 +127,9 @@ class Util:
         self.hidden = True
     def show(self) -> None:
         self.hidden = False
-    def render(self) -> None: pass
-    def draw(self) -> None: pass
-    def update(self) -> None: pass
+    def __render__(self) -> None: pass
+    def __draw__(self) -> None: pass
+    def __update__(self) -> None: pass
 
 class InputCell(Util):
     def __init__(self,
@@ -176,7 +199,7 @@ class InputCell(Util):
     def border_color(self, new_color:Color|pg.Color) -> None:
         self.__border_color__ = pygamize_color(new_color)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
         self.text_surface.fill(TRANSPARENT_COLOR_PYG)
         
@@ -194,7 +217,7 @@ class InputCell(Util):
 
         self.surface.blit(self.text_surface, self.position())
         
-    def update(self) -> None:
+    def __update__(self) -> None:
         if self.hidden: return
         self.is_hovered = self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and\
                           self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
@@ -261,7 +284,7 @@ class Slider(Util):
         self.text_pivot = text_pivot
 
         self.handleRadius = handleRadius
-        self.surface = personalized_surface
+        self.surface = personalized_surface # type: ignore
 
         self.hidden = False
 
@@ -281,21 +304,21 @@ class Slider(Util):
     def handleColour(self, new_color:Color|pg.Color) -> None:
         self.__handleColour__ = pygamize_color(new_color)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
-        pg.draw.rect(self.rootEnv.screen, self.__color__, self.position() + self.size())
+        pg.draw.rect(self.surface, self.__color__, self.position() + self.size())
 
         if self.radius:
-            pg.draw.circle(self.rootEnv.screen, self.__color__, (self.position.x, self.position.y + self.size.y // 2), self.radius)
-            pg.draw.circle(self.rootEnv.screen, self.__color__, (self.position.x + self.size.x, self.position.y + self.size.y // 2), self.radius)
+            pg.draw.circle(self.surface, self.__color__, (self.position.x, self.position.y + self.size.y // 2), self.radius)
+            pg.draw.circle(self.surface, self.__color__, (self.position.x + self.size.x, self.position.y + self.size.y // 2), self.radius)
 
         circle = V2(int(self.position.x + (self.value - self.min) / (self.max - self.min) * self.size.x), self.position.y + self.size.y // 2)
 
-        pg.draw.circle(self.rootEnv.screen, self.__color__, circle(), self.handleRadius * 1.25)
-        pg.draw.circle(self.rootEnv.screen, self.__handleColour__, circle(), self.handleRadius)
+        pg.draw.circle(self.surface, self.__color__, circle(), self.handleRadius * 1.25)
+        pg.draw.circle(self.surface, self.__handleColour__, circle(), self.handleRadius)
         self.rootEnv.print(self.text.format(round(self.value, 2)), self.position + self.size * self.text_offset, pivot_position=self.text_pivot)
     
-    def update(self) -> None:
+    def __update__(self) -> None:
         if self.hidden: return
         x,y = self.rootEnv.mouse.position
 
@@ -324,22 +347,22 @@ class Button(Util):
                 text : str,
                 position : V2|Vector2D,
                 size : V2|Vector2D,
-                callback : Callable[[...], None]|Callable[[], None],
-                default_color : Color|pg.Color,
-                hovered_color : Color|pg.Color,
-                border_color : Color|pg.Color,
+                callback : Callable[[], None]|Callable[[], None] = lambda: None,
+                default_bg_color : Color|pg.Color = BLUE_COLOR_PYG,
+                hovered_bg_color : Color|pg.Color = CYAN_COLOR_PYG,
+                border_color : Color|pg.Color = WHITE_COLOR_PYG,
                 text_color : Color|pg.Color = WHITE_COLOR_PYG,
                 font : pg.font.Font = FONT_ARIAL_32,
                 border_radius : float = 10,
                 border_width : float = 10,
-                starting_hiddden : bool = False,
+                starting_hidden : bool = False,
                 args : list = [],
                 activation_mode : __LITERAL_KEY_MODE_TYPES__ = "just_pressed",
                 pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
                 personalized_surface : pg.Surface|None = None,
             ) -> None:
         super().__init__()
-        
+
         self.text = text
         self.font = font
 
@@ -348,10 +371,11 @@ class Button(Util):
         self.border_radius = border_radius
         self.__size__ = size
         self.__border_width__ = border_width
-        
-        self.update_position(position, pivot_position)
 
-        self.hidden = starting_hiddden
+        self.pivot_position :__LITERAL_PIVOT_POSITIONS__= pivot_position    
+        self.update_position(position)
+
+        self.hidden = starting_hidden
         self.args = args
 
         self.activation_mode = activation_mode
@@ -359,19 +383,23 @@ class Button(Util):
         self.hovered = False
 
         self.text_color = text_color
-        self.default_color = default_color
+        self.default_bg_color = default_bg_color
         self.border_color = border_color
-        self.hovered_color = hovered_color
+        self.hovered_bg_color = hovered_bg_color
 
-        self.surface = personalized_surface
+        self.surface = personalized_surface #type: ignore
         self.update_surface()
     
-    def update_position(self, new_position:V2, pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
-        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position]
+    def update_position(self, new_position:V2) -> None:
+        self.position = new_position - self.__size__ * __PIVOT_POSITIONS_MULTIPLIER__[self.pivot_position]
+
+    def update_pivoting(self, new_pivot_position:__LITERAL_PIVOT_POSITIONS__) -> None:
+        self.pivot_position = new_pivot_position
+        self.update_position(self.position)
     
     def update_surface(self, render=False) -> None:
         self.buffer_surface = pg.Surface((self.__size__ + self.__border_width__ * 2)(), pg.SRCALPHA, 32).convert_alpha()
-        if render: self.render()
+        if render: self.__render__()
 
     @property
     def size(self) -> V2:
@@ -386,6 +414,7 @@ class Button(Util):
         return self.__border_width__
     @border_width.setter
     def border_width(self, new_width:float) -> None:
+        # self.position -= (self.__border_width__ - new_width) * .5
         self.__border_width__ = new_width
         self.update_surface(render=True)
     
@@ -396,11 +425,11 @@ class Button(Util):
     def text_color(self, new_color:Color|pg.Color) -> None:
         self.__text_color__ = pygamize_color(new_color)
     @property
-    def default_color(self) -> Color:
-        return unpygamize_color(self.__default_color__)
-    @default_color.setter
-    def default_color(self, new_color:Color|pg.Color) -> None:
-        self.__default_color__ = pygamize_color(new_color)
+    def default_bg_color(self) -> Color:
+        return unpygamize_color(self.__default_bg_color__)
+    @default_bg_color.setter
+    def default_bg_color(self, new_color:Color|pg.Color) -> None:
+        self.__default_bg_color__ = pygamize_color(new_color)
     @property
     def border_color(self) -> Color:
         return unpygamize_color(self.__border_color__)
@@ -408,27 +437,28 @@ class Button(Util):
     def border_color(self, new_color:Color|pg.Color) -> None:
         self.__border_color__ = pygamize_color(new_color)
     @property
-    def hovered_color(self) -> Color:
-        return unpygamize_color(self.__hovered_color__)
-    @hovered_color.setter
-    def hovered_color(self, new_color:Color|pg.Color) -> None:
-        self.__hovered_color__ = pygamize_color(new_color)
-
-    def render(self) -> None:
-        print("rendering button")
+    def hovered_bg_color(self) -> Color:
+        return unpygamize_color(self.__hovered_bg_color__)
+    @hovered_bg_color.setter
+    def hovered_bg_color(self, new_color:Color|pg.Color) -> None:
+        self.__hovered_bg_color__ = pygamize_color(new_color)
+
+    def __render__(self) -> None:
         self.buffer_surface.fill(TRANSPARENT_COLOR_PYG)
 
-        color = self.__hovered_color__ if self.hovered else self.__default_color__
+        color = self.__hovered_bg_color__ if self.hovered else self.__default_bg_color__
         pg.draw.rect(self.buffer_surface, self.__border_color__, V2.zero()() + (self.size + self.border_width * 2)(), border_radius=self.border_radius)
         pg.draw.rect(self.buffer_surface, color, (V2.zero() + self.border_width)() + self.size(), border_radius=self.border_radius)
 
+        # TODO:
+        # not only size * .5 but also internal pivoting on the corners and sides
         self.rootEnv.print(self.text, self.border_width + self.size * .5, color=self.__text_color__, font=self.font, pivot_position="center_center", personalized_surface=self.buffer_surface)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
         self.surface.blit(self.buffer_surface, (self.position)())
 
-    def update(self) -> None:
+    def __update__(self) -> None:
         if self.hidden: return
 
         old_overed = self.hovered
@@ -436,15 +466,15 @@ class Button(Util):
             self.position.x < self.rootEnv.mouse.position.x < self.position.x + self.size.x and \
             self.position.y < self.rootEnv.mouse.position.y < self.position.y + self.size.y
         if self.hovered != old_overed:
-            self.render()
+            self.__render__()
         
         if self.hovered and self.rootEnv.mouse.get_key(0, self.activation_mode):
             self.callback(*self.args)
             self.rootEnv.selected_util = self
-            self.render()
+            self.__render__()
         elif self.rootEnv.selected_util == self:
             self.rootEnv.selected_util = None
-            self.render()
+            self.__render__()
 
 class Label(Util):
     def __init__(self,
@@ -457,7 +487,7 @@ class Label(Util):
                 font : pg.font.Font = FONT_ARIAL_32,
                 border_radius : float = 10,
                 border_width : float = 10,
-                starting_hiddden : bool = False,
+                starting_hidden : bool = False,
                 personalized_surface : pg.Surface|None = None,
                 pivot_position : __LITERAL_PIVOT_POSITIONS__ = "top_left",
             ) -> None:
@@ -470,23 +500,28 @@ class Label(Util):
         self.__size__ = size
         self.__border_width__ = border_width
         
-        self.position = self.update_position(position, pivot_position)
+        self.pivot_position :__LITERAL_PIVOT_POSITIONS__= pivot_position
+        self.update_position(position)
 
-        self.hidden = starting_hiddden
+        self.hidden = starting_hidden
 
         self.text_color = text_color
         self.default_color = default_color
         self.border_color = border_color
 
-        self.surface = personalized_surface
+        self.surface = personalized_surface # type: ignore
         self.update_surface()
     
-    def update_position(self, new_position:V2, pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
-        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[pivot_position]
-    
+    def update_position(self, new_position:V2) -> None:
+        self.position = new_position - (self.__size__ + self.border_width * 2) * __PIVOT_POSITIONS_MULTIPLIER__[self.pivot_position]
+
+    def update_pivoting(self, new_pivot_position:__LITERAL_PIVOT_POSITIONS__="top_left") -> None:
+        self.pivot_position = new_pivot_position
+        self.update_position(self.position)
+
     def update_surface(self, render=False) -> None:
         self.buffer_surface = pg.Surface((self.__size__ + self.__border_width__ * 2)(), pg.SRCALPHA, 32).convert_alpha()
-        if render: self.render()
+        if render: self.__render__()
 
     @property
     def text(self) -> str:
@@ -494,7 +529,7 @@ class Label(Util):
     @text.setter
     def text(self, new_text:str) -> None:
         self.__text__ = new_text
-        self.render()
+        self.__render__()
 
     @property
     def size(self) -> V2:
@@ -531,15 +566,16 @@ class Label(Util):
     def border_color(self, new_color:Color|pg.Color) -> None:
         self.__border_color__ = pygamize_color(new_color)
 
-    def render(self) -> None:
-        print("rendering label")
+    def __render__(self) -> None:
         self.buffer_surface.fill(TRANSPARENT_COLOR_PYG)
 
         pg.draw.rect(self.buffer_surface, self.__border_color__, V2.zero()() + (self.size + self.border_width * 2)(), border_radius=self.border_radius)
         pg.draw.rect(self.buffer_surface, self.__default_color__, (V2.zero() + self.border_width)() + self.size(), border_radius=self.border_radius)
 
+        # TODO:
+        # not only size * .5 but also internal pivoting on the corners and sides
         self.rootEnv.print(self.text, self.border_width + self.size * .5, color=self.__text_color__, font=self.font, pivot_position="center_center", personalized_surface=self.buffer_surface)
 
-    def draw(self) -> None:
+    def __draw__(self) -> None:
         if self.hidden: return
         self.surface.blit(self.buffer_surface, (self.position)())