Tidy UIElement typehinting

Step 2 of splitting mega-PR into smaller easier to review PRs

Co-authored-by: GimLala <gimpylala@gmail.com>

Author: MyreMylar

pygame_gui/core/interfaces/__init__.py

@@ -1,7 +1,7 @@
 from pygame_gui.core.interfaces.colour_gradient_interface import IColourGradientInterface
 from pygame_gui.core.interfaces.font_dictionary_interface import IUIFontDictionaryInterface
 from pygame_gui.core.interfaces.appearance_theme_interface import IUIAppearanceThemeInterface
-from pygame_gui.core.interfaces.element_interface import IUIElementInterface
+from pygame_gui.core.interfaces.element_interface import IUIElementInterface, Coordinate
 from pygame_gui.core.interfaces.container_interface import IUIContainerInterface
 from pygame_gui.core.interfaces.container_interface import IContainerLikeInterface
 from pygame_gui.core.interfaces.window_interface import IWindowInterface
@@ -25,4 +25,5 @@
            'IUIManagerInterface',
            'IUITextOwnerInterface',
            'IGUIFontInterface',
-           'IGUISpriteInterface']
+           'IGUISpriteInterface',
+           'Coordinate']

pygame_gui/core/interfaces/container_interface.py

@@ -170,14 +170,22 @@ def get_image_clipping_rect(self) -> Union[pygame.Rect, None]:
 
         """
 
-    def on_anchor_target_changed(self, target: IUIElementInterface):
+    def on_contained_elements_changed(self, target: IUIElementInterface) -> None:
         """
         Update the contents of this container that one of their layout anchors may have moved, or
         been resized.
 
         :param target: the UI element that has been benn moved or resized.
         """
 
+    def calc_add_element_changes_thickness(self, element: IUIElementInterface):
+        """
+        This function checks if a single added element will increase the containers thickness
+        and if so updates containers recursively.
+
+        :param element: the element to check.
+        """
+
 
 class IContainerLikeInterface(metaclass=ABCMeta):
     """

pygame_gui/core/interfaces/element_interface.py

@@ -5,6 +5,8 @@
 
 from pygame_gui.core.interfaces.gui_sprite_interface import IGUISpriteInterface
 
+Coordinate = Union[pygame.math.Vector2, Tuple[int, int], Tuple[float, float]]
+
 
 class IUIElementInterface(IGUISpriteInterface, metaclass=ABCMeta):
     """
@@ -71,9 +73,7 @@ def update_containing_rect_position(self):
         """
 
     @abstractmethod
-    def set_relative_position(self, position: Union[pygame.math.Vector2,
-                                                    Tuple[int, int],
-                                                    Tuple[float, float]]):
+    def set_relative_position(self, position: Coordinate):
         """
         Method to directly set the relative rect position of an element.
 
@@ -82,9 +82,7 @@ def set_relative_position(self, position: Union[pygame.math.Vector2,
         """
 
     @abstractmethod
-    def set_position(self, position: Union[pygame.math.Vector2,
-                                           Tuple[int, int],
-                                           Tuple[float, float]]):
+    def set_position(self, position: Coordinate):
         """
         Method to directly set the absolute screen rect position of an element.
 
@@ -93,10 +91,7 @@ def set_position(self, position: Union[pygame.math.Vector2,
         """
 
     @abstractmethod
-    def set_dimensions(self, dimensions: Union[pygame.math.Vector2,
-                                               Tuple[int, int],
-                                               Tuple[float, float]],
-                       clamp_to_container: bool = False):
+    def set_dimensions(self, dimensions: Coordinate, clamp_to_container: bool = False):
         """
         Method to directly set the dimensions of an element.
 

pygame_gui/core/interfaces/gui_font_interface.py

@@ -5,13 +5,13 @@
 
 class IGUIFontInterface(metaclass=ABCMeta):
     """
-    A font interface so we can easily switch between pygame.freetype.Font and pygame.Font.
+    A font interface, so we can easily switch between pygame.freetype.Font and pygame.Font.
     """
 
     @abstractmethod
     def render_premul(self, text: str, text_color: Color) -> Surface:
         """
-        Draws text to a surface ready for premultiplied alpha-blending
+        Draws text to a surface ready for pre-multiplied alpha-blending
         """
 
     def render_premul_to(self, text: str, text_colour: Color, surf_size: Tuple[int, int], surf_position: Tuple[int, int]):
@@ -92,4 +92,3 @@ def get_direction(self) -> int:
 
         :return:
         """
-

pygame_gui/core/interfaces/manager_interface.py

@@ -9,11 +9,12 @@
 from pygame_gui.core.interfaces.window_stack_interface import IUIWindowStackInterface
 from pygame_gui.core.interfaces.tool_tip_interface import IUITooltipInterface
 from pygame_gui.core.object_id import ObjectID
+from pygame_gui.core.layered_gui_group import LayeredGUIGroup
 
 
 class IUIManagerInterface(metaclass=ABCMeta):
     """
-    A meta class that defines the interface that a UI Manager uses.
+    A metaclass that defines the interface that a UI Manager uses.
 
     Interfaces like this help us evade cyclical import problems by allowing us to define the
     actual manager class later on and have it make use of the classes that use the interface.
@@ -45,7 +46,7 @@ def get_theme(self) -> IUIAppearanceThemeInterface:
         """
 
     @abstractmethod
-    def get_sprite_group(self) -> pygame.sprite.LayeredDirty:
+    def get_sprite_group(self) -> LayeredGUIGroup:
         """
         Gets the sprite group used by the entire UI to keep it in the correct order for drawing and
         processing input.
@@ -219,7 +220,7 @@ def get_universal_empty_surface(self) -> pygame.surface.Surface:
         Sometimes we want to hide sprites or just have sprites with no visual component, when we
         do we can just use this empty surface to save having lots of empty surfaces all over memory.
 
-        :return: An empty, and therefore invisible pygame.surface.Surface
+        :return: An empty and therefore invisible pygame.surface.Surface
 
         """
 
@@ -265,15 +266,15 @@ def get_locale(self) -> str:
         """
         Get the locale language code being used in the UIManager
 
-        :return: A two letter ISO 639-1 code for the current locale.
+        :return: A two-letter ISO 639-1 code for the current locale.
         """
 
     @abstractmethod
     def set_text_input_hovered(self, hovering_text_input: bool):
         """
         Set to true when hovering an area text can be input into.
 
-        Currently switches the cursor to the I-Beam cursor.
+        Currently, switches the cursor to the I-Beam cursor.
 
         :param hovering_text_input: set to True to toggle the I-Beam cursor
         """

pygame_gui/core/layered_gui_group.py

@@ -227,6 +227,7 @@ class LayeredGUIGroup(LayeredUpdates):
     """
     A sprite group specifically for the GUI. Similar to pygame's LayeredDirty group but with the
     dirty flag stuff removed for simplicity and speed.
+    TODO: sever this entirely from LayeredUpdates at some point to fix the type hinting
     """
     def __init__(self, *sprites):
         """initialize group.
@@ -237,7 +238,7 @@ def __init__(self, *sprites):
         self.visible = []
         self.should_update_visibility = True
 
-    def add_internal(self, sprite, layer=None):
+    def add_internal(self, sprite: GUISprite, layer=None):
         """Do not use this method directly.
 
         It is used by the group to add a sprite internally.
@@ -258,7 +259,7 @@ def remove_internal(self, sprite):
         LayeredUpdates.remove_internal(self, sprite)
         self.should_update_visibility = True
 
-    def change_layer(self, sprite, new_layer):
+    def change_layer(self, sprite: GUISprite, new_layer):
         LayeredUpdates.change_layer(self, sprite, new_layer)
         self.should_update_visibility = True
 

pygame_gui/core/ui_container.py

@@ -10,21 +10,21 @@
 
 class UIContainer(UIElement, IUIContainerInterface, IContainerLikeInterface):
     """
-    A UI Container holds any number of other UI elements inside of a rectangle. When we move the
+    A UI Container holds any number of other UI elements inside a rectangle. When we move the
     UIContainer all the UI elements contained within it can be moved as well.
 
     This class helps us make UI Windows, but likely will have wider uses as well as the GUI
     system develops.
 
     :param relative_rect: A pygame.Rect whose position is relative to whatever UIContainer it is
-                          inside of, if any.
+                          inside, if any.
     :param manager: The UIManager that manages this UIElement.
-    :param starting_height: The starting layer height for this element above it's container.
+    :param starting_height: The starting layer height for this element above its container.
     :param is_window_root_container: True/False flag for whether this container is the root
                                      container for a UI window.
     :param container: The UIContainer that this UIElement is contained within.
     :param parent_element: The element this element 'belongs to' in the theming hierarchy.
-    :param object_id: A custom defined ID for fine tuning of theming.
+    :param object_id: A custom defined ID for fine-tuning of theming.
     :param anchors: A dictionary describing what this element's relative_rect is relative to.
     :param visible: Whether the container and its children are visible by default.
                     Warning - it's parent container visibility may override this.
@@ -132,7 +132,7 @@ def recalculate_container_layer_thickness(self):
         if new_thickness != self.layer_thickness:
             self.layer_thickness = new_thickness
             if self.ui_container is not None and self.ui_container != self:
-                self.ui_container.recalculate_container_layer_thickness()
+                self.ui_container.get_container().recalculate_container_layer_thickness()
 
     def calc_add_element_changes_thickness(self, element: IUIElementInterface):
         """
@@ -148,7 +148,7 @@ def calc_add_element_changes_thickness(self, element: IUIElementInterface):
             self.max_element_top_layer = element.get_top_layer()
             self.layer_thickness = self.max_element_top_layer - self._layer
             if self.ui_container is not None and self.ui_container != self:
-                self.ui_container.calc_add_element_changes_thickness(self)
+                self.ui_container.get_container().calc_add_element_changes_thickness(self)
 
     def change_layer(self, new_layer: int):
         """
@@ -292,7 +292,7 @@ def check_hover(self, time_delta: float, hovered_higher_element: bool) -> bool:
 
     def disable(self):
         """
-        Disables all elements in the container so they are no longer interactive.
+        Disables all elements in the container, so they are no longer interactive.
         """
         if self.is_enabled:
             self.is_enabled = False
@@ -301,7 +301,7 @@ def disable(self):
 
     def enable(self):
         """
-        Enables all elements in the container so they are interactive again.
+        Enables all elements in the container, so they are interactive again.
         """
         if not self.is_enabled:
             self.is_enabled = True
@@ -334,13 +334,14 @@ def hide(self):
 
             self.visible = False
 
-    def on_anchor_target_changed(self, target: IUIElementInterface):
+    def on_contained_elements_changed(self, target: IUIElementInterface) -> None:
         """
-        Update the contents of this container that one of their layout anchors may have moved, or
-        been resized.
+        Update the positioning of the contained elements of this container. To be called when one of the contained
+        elements may have moved, been resized or changed its anchors.
 
-        :param target: the UI element that has been benn moved or resized.
+        :param target: the UI element that has been benn moved resized or changed its anchors.
         """
         for element in self.elements:
             if target in element.get_anchor_targets():
                 element.update_containing_rect_position()
+                self.on_contained_elements_changed(element)