simple-graphics-lib 0.0.7__tar.gz → 0.0.9__tar.gz

{simple_graphics_lib-0.0.7 → simple_graphics_lib-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple-graphics-lib
-Version: 0.0.7
+Version: 0.0.9
 Summary: A simple graphics library for python learners
 Author-email: Max-Hillyer <maxhillyer7012@gmail.com>
 License-Expression: MIT
@@ -63,6 +63,8 @@ Arguments:
 | height | int | the height of the rect | 10 |
 | color | str | the color of the rect | "black" | 
 | outline | bool | whether the rect is just an outline | False | 
+| draggable | bool | whether the rect can be dragged | False | 
+| visible | bool | whether the rect is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -80,6 +82,8 @@ Arguments:
 | radius | int | the radius of the circle | 10 |
 | color | str | the color of the circle | "black" | 
 | outline | bool | whether the circle is just an outline | False | 
+| draggable | bool | whether the circle can be dragged | False | 
+| visible | bool | whether the circle is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -94,6 +98,8 @@ Arguments:
 | points | list[tuple] | the vertices of the polygon | None | 
 | color | str | the color of the polygon | "black" | 
 | outline | bool | whther the polygon is just an outline | False | 
+| draggable | bool | whether the polygon can be dragged | False | 
+| visible | bool | whether the polygon is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -107,6 +113,8 @@ Arguments:
 | points | list[tuple] |the points that the line will connect | None |
 | width | int | the width of the line | 10 | 
 | color | str | the color of the line | "black" | 
+| draggable | bool | whether the line can be dragged | False | 
+| visible | bool | whether the line is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -122,6 +130,8 @@ Arguments:
 | text | str | the text of the text | None | 
 | color | str | the color of the text | "black" | 
 | size | int | the size of the text | 36 | 
+| draggable | bool | whether the text can be dragged | False | 
+| visible | bool | whether the text is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -137,6 +147,8 @@ Arguments:
 | img_path | str | the path to the image | None |
 | width | int | the width of the image | the width from the image path | 
 | height | int | the height of the image | the height from the image path | 
+| draggable | bool | whether the image can be dragged | False | 
+| visible | bool | whether the image is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -160,7 +172,8 @@ group.color = "green"
 Arguments:
 | Argument | Type | Role | Default | 
 | :--- | :---: | :---: | ---: |
-| *shapes | list[Shape] | the shapes to group | None |
+| *shapes | list[Shape] | the shapes to group | None | 
+| visible | bool | whether shapes in group are drawn on screen | True |
 
 Methods:
 | Method | Purpose | Arguments | Returns | 
@@ -308,6 +321,33 @@ def print_click():
 run()
 ```
 
+### on_hover
+functions defined with the `@on_hover` decorator will run whenever the specified object is being hovered over
+
+the function below will run whenever the mouse is over the rectangle 
+```python
+r1 = Rect(200,200, 100, 100)
+
+@on_hover(r1)
+def p():
+    print("hovering")
+
+run(400,400)
+```
+
+### on_drag
+functions defined with the `@on_drag` decorator will run whenever the specified object is being dragged
+
+the function below will run whenevr the r1 rect is being dragged
+```python
+r1 = Rect(200,200,draggable = True)
+
+@on_drag(r1)
+def do_something():
+    print("dragging r1")
+
+run(400,400)
+```
 ---
 ## The mouse
 A mouse object is already initialized in the Simple Graphics import 
@@ -322,6 +362,15 @@ def main():
 
 run()
 ```
+
+## dragging 
+
+to make a shape draggable, add the keyword argument to the object initialization: 
+```python
+r = Rect(250,250, draggable = True)
+```
+this works for all shapes including images and text
+
 ---
 ## Miscellaneous Functions
 

{simple_graphics_lib-0.0.7 → simple_graphics_lib-0.0.9}/README.md

@@ -47,6 +47,8 @@ Arguments:
 | height | int | the height of the rect | 10 |
 | color | str | the color of the rect | "black" | 
 | outline | bool | whether the rect is just an outline | False | 
+| draggable | bool | whether the rect can be dragged | False | 
+| visible | bool | whether the rect is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -64,6 +66,8 @@ Arguments:
 | radius | int | the radius of the circle | 10 |
 | color | str | the color of the circle | "black" | 
 | outline | bool | whether the circle is just an outline | False | 
+| draggable | bool | whether the circle can be dragged | False | 
+| visible | bool | whether the circle is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -78,6 +82,8 @@ Arguments:
 | points | list[tuple] | the vertices of the polygon | None | 
 | color | str | the color of the polygon | "black" | 
 | outline | bool | whther the polygon is just an outline | False | 
+| draggable | bool | whether the polygon can be dragged | False | 
+| visible | bool | whether the polygon is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -91,6 +97,8 @@ Arguments:
 | points | list[tuple] |the points that the line will connect | None |
 | width | int | the width of the line | 10 | 
 | color | str | the color of the line | "black" | 
+| draggable | bool | whether the line can be dragged | False | 
+| visible | bool | whether the line is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -106,6 +114,8 @@ Arguments:
 | text | str | the text of the text | None | 
 | color | str | the color of the text | "black" | 
 | size | int | the size of the text | 36 | 
+| draggable | bool | whether the text can be dragged | False | 
+| visible | bool | whether the text is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -121,6 +131,8 @@ Arguments:
 | img_path | str | the path to the image | None |
 | width | int | the width of the image | the width from the image path | 
 | height | int | the height of the image | the height from the image path | 
+| draggable | bool | whether the image can be dragged | False | 
+| visible | bool | whether the image is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -144,7 +156,8 @@ group.color = "green"
 Arguments:
 | Argument | Type | Role | Default | 
 | :--- | :---: | :---: | ---: |
-| *shapes | list[Shape] | the shapes to group | None |
+| *shapes | list[Shape] | the shapes to group | None | 
+| visible | bool | whether shapes in group are drawn on screen | True |
 
 Methods:
 | Method | Purpose | Arguments | Returns | 
@@ -292,6 +305,33 @@ def print_click():
 run()
 ```
 
+### on_hover
+functions defined with the `@on_hover` decorator will run whenever the specified object is being hovered over
+
+the function below will run whenever the mouse is over the rectangle 
+```python
+r1 = Rect(200,200, 100, 100)
+
+@on_hover(r1)
+def p():
+    print("hovering")
+
+run(400,400)
+```
+
+### on_drag
+functions defined with the `@on_drag` decorator will run whenever the specified object is being dragged
+
+the function below will run whenevr the r1 rect is being dragged
+```python
+r1 = Rect(200,200,draggable = True)
+
+@on_drag(r1)
+def do_something():
+    print("dragging r1")
+
+run(400,400)
+```
 ---
 ## The mouse
 A mouse object is already initialized in the Simple Graphics import 
@@ -306,6 +346,15 @@ def main():
 
 run()
 ```
+
+## dragging 
+
+to make a shape draggable, add the keyword argument to the object initialization: 
+```python
+r = Rect(250,250, draggable = True)
+```
+this works for all shapes including images and text
+
 ---
 ## Miscellaneous Functions
 

{simple_graphics_lib-0.0.7 → simple_graphics_lib-0.0.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple-graphics-lib"
-version = "0.0.7"
+version = "0.0.9"
 authors = [
   { name="Max-Hillyer", email="maxhillyer7012@gmail.com" },
 ]

{simple_graphics_lib-0.0.7 → simple_graphics_lib-0.0.9}/src/simple_graphics/module.py

@@ -11,6 +11,9 @@ _ontick = []
 _key_funcs = {}
 _key_hold_funcs = {}
 _mouse_click_funcs = {}
+_hover_funcs = {}
+_dragging_funcs = {}
+_dragging_shape = None
 _bgcolor = "white"
 _font = "Arial"
 
@@ -18,6 +21,9 @@ pygame.init()
 
 
 class Mouse:
+    def __init__(self, hiding = False):
+        self.hiding = hiding
+
     @property
     def x(self):
         return pygame.mouse.get_pos()[0]
@@ -26,20 +32,46 @@ class Mouse:
     def y(self):
         return pygame.mouse.get_pos()[1]
 
+    def set_hiding(self, state: bool):
+        """Sets the mouse visibility"""
+        self.hiding = state
+        pygame.mouse.set_visible(self.hiding)
+        
 
 mouse = Mouse()
 
 
 class Shape:
-    def __init__(self, x, y, color="black", outline=False):
+    """Base class for all drawable shapes. Do not instantiate directly."""
+    def __init__(self, x, y, color="black", outline=False, draggable=False, visible = True):
+        """Initialize a shape at position (x, y).
+        
+        Args:
+            x: X coordinate (pixels from left)
+            y: Y coordinate (pixels from top)
+            color: Color as hex string (#RRGGBB) or name (default: "black")
+            outline: If True, draw outline only; if False, fill shape (default: False)
+            draggable: If True, shape can be moved by mouse (default: False)
+        """
         self.x = x
         self.y = y
         self.color = color
         self.outline = int(outline)
+        self.draggable = draggable
+        self.visible = visible
         _shapes.append(self)
 
     def __str__(self):
-        return self.__class__.__name__.lower()
+        """Return string representation showing shape type and parameters"""
+        class_name = self.__class__.__name__.lower()
+        sig = signature(self.__init__)
+        params = [p for p in sig.parameters if p != "self"]
+
+        values = {}
+        for p in params:
+            if hasattr(self, p):
+                values[p] = getattr(self, p)
+        return f"{class_name}: {values}"
 
 
 class Rect(Shape):
@@ -51,8 +83,10 @@ class Rect(Shape):
         height: int = 10,
         color: str = "black",
         outline: bool = False,
+        draggable: bool = False,
+        visible : bool = True
     ):
-        super().__init__(x, y, color, outline)
+        super().__init__(x, y, color, outline, draggable, visible)
         self.width = width
         self.height = height
 
@@ -61,6 +95,15 @@ class Rect(Shape):
         return (self.x, self.y, self.width, self.height)
 
     def is_obj_over(self, ox=None, oy=None):
+        """Check if a point is inside this rectangle.
+        
+        Args:
+            ox: X coordinate (default: current mouse x)
+            oy: Y coordinate (default: current mouse y)
+            
+        Returns:
+            bool: True if point is inside rectangle, False otherwise
+        """
         if ox == None:
             ox = pygame.mouse.get_pos()[0]
         if oy == None:
@@ -70,9 +113,11 @@ class Rect(Shape):
         return x_over and y_over
 
     def get_area(self):
+        """Calculate and return the area of the rectangle"""
         return self.width * self.height
 
     def get_perimeter(self):
+        """Calculate and return the perimeter of the rectangle"""
         return (2 * self.width) + (2 * self.height)
 
 
@@ -84,11 +129,22 @@ class Circle(Shape):
         radius: int = 10,
         color: str = "black",
         outline: bool = False,
+        draggable: bool = False,
+        visible: bool = True 
     ):
-        super().__init__(x, y, color, outline)
+        super().__init__(x, y, color, outline, draggable, visible)
         self.radius = radius
 
     def is_obj_over(self, ox=None, oy=None):
+        """Check if a point is inside this circle.
+        
+        Args:
+            ox: X coordinate (default: current mouse x)
+            oy: Y coordinate (default: current mouse y)
+            
+        Returns:
+            bool: True if point is inside circle, False otherwise
+        """
         if ox == None:
             ox = pygame.mouse.get_pos()[0]
         if oy == None:
@@ -97,19 +153,36 @@ class Circle(Shape):
         return inside
 
     def get_area(self):
+        """Calculate and return the area of the circle."""
         return pi * self.radius**2
 
 
 class Polygon(Shape):
     def __init__(
-        self, points: list[tuple], color: str = "black", outline: bool = False
+        self,
+        points: list[tuple],
+        color: str = "black",
+        outline: bool = False,
+        draggable: bool = False,
+        visible: bool = True
     ):
         self.color = color
         self.points = points
         self.outline = int(outline)
+        self.draggable = draggable
+        self.visible = visible
         _shapes.append(self)
 
     def is_obj_over(self, ox=None, oy=None):
+        """Check if a point is inside this polygon using ray casting algorithm.
+        
+        Args:
+            ox: X coordinate (default: current mouse x)
+            oy: Y coordinate (default: current mouse y)
+            
+        Returns:
+            bool: True if point is inside polygon, False otherwise
+        """
         if ox == None:
             ox = pygame.mouse.get_pos()[0]
         if oy == None:
@@ -133,13 +206,31 @@ class Polygon(Shape):
 
 
 class Line(Shape):
-    def __init__(self, points: list[tuple], width: int = 10, color: str = "black"):
+    def __init__(
+        self,
+        points: list[tuple],
+        width: int = 10,
+        color: str = "black",
+        draggable: bool = False,
+        visible: bool = True
+    ):
         self.color = color
         self.points = points
         self.width = width
+        self.draggable = draggable
+        self.visible = visible
         _shapes.append(self)
 
     def is_obj_over(self, ox=None, oy=None):
+        """Check if a point is near this line (within line width).
+        
+        Args:
+            ox: X coordinate (default: current mouse x)
+            oy: Y coordinate (default: current mouse y)
+            
+        Returns:
+            bool: True if point is within line width, False otherwise
+        """
         if ox == None:
             ox = pygame.mouse.get_pos()[0]
         if oy == None:
@@ -157,6 +248,7 @@ class Line(Shape):
         return False
 
     def _distance_to_segment(self, px, py, x1, y1, x2, y2):
+        """Calculate shortest distance from a point to a line segment."""
         dx = x2 - x1
         dy = y2 - y1
 
@@ -173,9 +265,16 @@ class Line(Shape):
 
 class Image(Shape):
     def __init__(
-        self, x: int, y: int, img_path: str, width: int = None, height: int = None
+        self,
+        x: int,
+        y: int,
+        img_path: str,
+        width: int = None,
+        height: int = None,
+        draggable: bool = False,
+        visible: bool = True
     ):
-        super().__init__(x, y)
+        super().__init__(x, y, draggable, visible)
         self.img_path = img_path
         self.original_img = pygame.image.load(self.img_path)
 
@@ -188,6 +287,15 @@ class Image(Shape):
         )
 
     def is_obj_over(self, ox=None, oy=None):
+        """Check if a point is inside this image rectangle.
+        
+        Args:
+            ox: X coordinate (default: current mouse x)
+            oy: Y coordinate (default: current mouse y)
+            
+        Returns:
+            bool: True if point is inside image bounds, False otherwise
+        """
         if ox is None:
             ox = pygame.mouse.get_pos()[0]
         if oy is None:
@@ -207,17 +315,29 @@ class Text(Shape):
         color: str = "black",
         font=_font,
         size: int = 36,
+        draggable: bool = False,
+        visible: bool = True
     ):
-        super().__init__(x, y, color)
+        super().__init__(x, y, color, False, draggable, visible)
         self.text = text
         self.size = size
         self.font = pygame.font.SysFont(font, size)
 
     @property
     def txtsurf(self):
+        """Render and return the text surface for drawing on screen."""
         return self.font.render(str(self.text), True, self.color)
 
     def is_obj_over(self, ox=None, oy=None):
+        """Check if a point is inside this text's bounding box.
+        
+        Args:
+            ox: X coordinate (default: current mouse x)
+            oy: Y coordinate (default: current mouse y)
+            
+        Returns:
+            bool: True if point is inside text bounds, False otherwise
+        """
         if ox == None:
             ox = pygame.mouse.get_pos()[0]
         if oy == None:
@@ -232,7 +352,17 @@ class Text(Shape):
 
 
 class Group:
-    def __init__(self, *shapes: list[Shape]):
+    """Container for grouping multiple shapes for batch operations.
+    
+    Allows moving, coloring, and interacting with multiple shapes as one unit.
+    Implements the full Python container protocol (__len__, __iter__, etc.).
+    """
+    def __init__(self, *shapes: list[Shape], visible:bool = True):
+        """Initialize group with optional initial shapes.
+        
+        Args:
+            *shapes: Variable number of Shape objects to add initially
+        """
         self.grouped = []
         self.add(*shapes)
 
@@ -271,37 +401,98 @@ class Group:
         for child in self.grouped:
             child.y += delta
 
+    def __getitem__(self, key):
+        return self.grouped[key]
+
+    def __len__(self):
+        return len(self.grouped)
+
+    def __iter__(self):
+        return iter(self.grouped)
+
+    def __contains__(self, item):
+        return item in self.grouped
+
+    def __setitem__(self, key, value):
+        self.grouped[key] = value
+
+    def __delitem__(self, key):
+        del self.grouped[key]
+
     def add(self, *shapes):
+        """Add one or more shapes to the group.
+        
+        Args:
+            *shapes: One or more Shape objects to add
+            
+        Raises:
+            TypeError: If any argument is not a Shape
+        """
         for s in shapes:
             if not isinstance(s, Shape):
                 raise TypeError(f"{s} must be Shape")
             self.grouped.append(s)
 
     def remove(self, *shapes):
+        """Remove one or more shapes from the group.
+        
+        Args:
+            *shapes: One or more Shape objects to remove
+        """
         for s in shapes:
             self.grouped.remove(s)
             _shapes.remove(s)
 
     def clear(self):
+        """Remove all shapes from the group."""
         self.grouped.clear()
 
     def is_obj_over(self, x, y):
+        """Check if any shape in group contains the point.
+        
+        Args:
+            x: X coordinate
+            y: Y coordinate
+            
+        Returns:
+            bool: True if any child shape contains point, False otherwise
+        """
         for i in self.grouped:
             if i.is_obj_over(x, y):
                 return True
         return False
 
-    def __str__(self):
-        return "group"
+    def __repr__(self):
+        shapes_str = ", ".join(str(s) for s in self.grouped)
+        return f"Group([{shapes_str}])"
+
+    # def __str__(self):
+    #     return "group"
 
 
 class CollisionManager:
+    """Static utility class containing collision detection for all shape combinations."""
     @staticmethod
     def rect_rect(rect1: Rect, rect2: Rect):
-        return pygame.Rect(*rect1.rect).colliderect(pygame.Rect(*rect2.rect))
+        """Check if two rectangles are colliding."""
+        for rect in [rect1, rect2]:
+            corners = [
+                (rect.x, rect.y),
+                (rect.x + rect.width, rect.y),
+                (rect.x, rect.y + rect.height),
+                (rect.x + rect.width, rect.y + rect.height),
+            ]
+            for other in [rect1, rect2]:
+                if other is rect:
+                    continue
+                for point in corners:
+                    if other.is_obj_over(*point):
+                        return True
+        return False
 
     @staticmethod
     def rect_circle(rect: Rect, circle: Circle):
+        """Check if a rectangle and circle are colliding."""
         closest_x = max(rect.x, min(circle.x, rect.x + rect.width))
         closest_y = max(rect.y, min(circle.y, rect.y + rect.height))
         dist = ((circle.x - closest_x) ** 2 + (circle.y - closest_y) ** 2) ** 0.5
@@ -309,11 +500,13 @@ class CollisionManager:
 
     @staticmethod
     def circle_circle(circle1: Circle, circle2: Circle):
+        """Check if two circles are colliding."""
         dist = ((circle1.x - circle2.x) ** 2 + (circle1.y - circle2.y) ** 2) ** 0.5
         return dist < circle1.radius + circle2.radius
 
     @staticmethod
     def rect_polygon(rect: Rect, polygon: Polygon):
+        """Check if a rectangle and polygon are colliding."""
         corners = [
             (rect.x, rect.y),
             (rect.x + rect.width, rect.y),
@@ -330,6 +523,7 @@ class CollisionManager:
 
     @staticmethod
     def circle_polygon(circle: Circle, polygon: Polygon):
+        """Check if a circle and polygon are colliding."""
         if polygon.is_obj_over(circle.x, circle.y):
             return True
         for px, py in polygon.points:
@@ -340,6 +534,7 @@ class CollisionManager:
 
     @staticmethod
     def rect_text(rect, text):
+        """Check if a rectangle and text are colliding."""
         text_width = text.txtsurf.get_width()
         text_height = text.txtsurf.get_height()
         return pygame.Rect(*rect.rect).colliderect(
@@ -348,6 +543,7 @@ class CollisionManager:
 
     @staticmethod
     def circle_text(circle, text):
+        """Check if a circle and text are colliding."""
         text_width = text.txtsurf.get_width()
         text_height = text.txtsurf.get_height()
         closest_x = max(text.x, min(circle.x, text.x + text_width))
@@ -357,12 +553,14 @@ class CollisionManager:
 
     @staticmethod
     def rect_image(rect, image):
+        """Check if a rectangle and image are colliding."""
         return pygame.Rect(*rect.rect).colliderect(
             pygame.Rect(image.x, image.y, image.width, image.height)
         )
 
     @staticmethod
     def circle_image(circle, image):
+        """Check if a circle and image are colliding."""
         closest_x = max(image.x, min(circle.x, image.x + image.width))
         closest_y = max(image.y, min(circle.y, image.y + image.height))
         dist = ((circle.x - closest_x) ** 2 + (circle.y - closest_y) ** 2) ** 0.5
@@ -370,6 +568,7 @@ class CollisionManager:
 
     @staticmethod
     def groupcollision(group, shape):
+        """Check if a group and any shape are colliding."""
         for child in group.grouped:
             if is_colliding(child, shape):
                 return True
@@ -380,6 +579,15 @@ class CollisionManager:
 
 
 def check_args(func, name):
+    """Validate that a decorator function takes no arguments.
+    
+    Args:
+        func: The function to validate
+        name: Name of the decorator (for error messages)
+        
+    Raises:
+        ValueError: If function has any parameters
+    """
     sig = signature(func)
     param_names = list(sig.parameters)
     if str(sig) != "()":
@@ -391,6 +599,13 @@ def check_args(func, name):
 # decorartors like this get weird: if you want to be able to pass arguments in you need to handle 2 cases
 # if theres no arguments then it just takes the function as the argument
 def on_tick(func: Callable):
+    """Decorator: call function every frame (60 times per second).
+    
+    Usage:
+        @on_tick
+        def update():
+            pass  # Runs every frame
+    """
     name = currentframe().f_code.co_name
     check_args(func, name)
     _ontick.append(func)
@@ -398,6 +613,15 @@ def on_tick(func: Callable):
 
 
 def on_press(target: Callable | str):
+    """Decorator: call function when a key is pressed.
+    
+    Usage:
+        @on_press  # Any key
+        def any_key(): pass
+        
+        @on_press("space, enter")  # Specific keys
+        def special(): pass
+    """
     if callable(target):
         func = target
         name = currentframe().f_code.co_name
@@ -435,6 +659,13 @@ def on_press(target: Callable | str):
 
 
 def on_hold(target: Callable | str):
+    """Decorator: call function every frame while a key is held down.
+    
+    Usage:
+        @on_hold("w")
+        def move_up():
+            pass  # Runs each frame while 'w' is held
+    """
     if callable(target):
         func = target
         name = currentframe().f_code.co_name
@@ -472,7 +703,15 @@ def on_hold(target: Callable | str):
 
 
 def on_click(target: Callable | Shape):
-
+    """Decorator: call function when mouse is clicked.
+    
+    Usage:
+        @on_click  # Any click
+        def click(): pass
+        
+        @on_click(my_shape)  # Click on specific shape
+        def shape_click(): pass
+    """
     if callable(target):
         name = currentframe().f_code.co_name
         check_args(target, name)
@@ -489,28 +728,82 @@ def on_click(target: Callable | Shape):
         return decorator
 
 
+def on_hover(shape: Shape):
+    """Decorator: call function every frame mouse hovers over a shape.
+    
+    Usage:
+        @on_hover(my_circle)
+        def hover(): pass
+    """
+    def decorator(func: Callable):
+        name = currentframe().f_code.co_name
+        check_args(func, name)
+        _hover_funcs[shape] = func
+        return func
+
+    return decorator
+
+
+def on_drag(shape: Shape):
+    """Decorator: call function every frame a draggable shape is being dragged.
+    
+    Usage:
+        @on_drag(my_rect)
+        def dragging(): pass
+    """
+    def decorator(func: Callable):
+        name = currentframe().f_code.co_name
+        check_args(func, name)
+        _dragging_funcs[shape] = func
+        return func
+
+    return decorator
+
+
 def set_bg(color: str):
+    """Set the background color of the window.
+    
+    Args:
+        color: Color as hex string (#RRGGBB) or name (e.g., 'white', 'red')
+    """
     global _bgcolor
     _bgcolor = color
 
 
 def clear_screen():
+    """Remove all shapes from the screen."""
     _shapes.clear()
 
 
 def erase(obj):
+    """Remove a specific shape from the screen.
+    
+    Args:
+        obj: The shape object to remove
+    """
     _shapes.remove(obj)
 
 
 def is_colliding(shape1: Shape, shape2: Shape) -> bool:
-    if "group" == str(shape1) or "group" == str(shape2):
+    """Check if two shapes are colliding.
+    
+    Args:
+        shape1: First shape
+        shape2: Second shape
+        
+    Returns:
+        bool: True if shapes overlap, False otherwise
+    """
+    shapeName1 = shape1.__class__.__name__.lower()
+    shapeName2 = shape2.__class__.__name__.lower()
+    if "group" == shapeName1 or "group" == shapeName2:
         method_name = "groupcollision"
         method = getattr(CollisionManager, method_name, None)
         return method(shape1, shape2)
-    method_name = f"{str(shape1)}_{str(shape2)}"
+    method_name = f"{shapeName1}_{shapeName2}"
     method = getattr(CollisionManager, method_name, None)
     if method is None:
-        method_name = f"{str(shape2)}_{str(shape1)}"
+        method_name = f"{shapeName2}_{shapeName1}"
         method = getattr(CollisionManager, method_name, None)
         if method is None:
             raise Exception(
@@ -526,7 +819,16 @@ def run(
     resizable: bool = True,
     caption: str = "SG window",
 ):
-
+    """Start the graphics window and begin the main game loop.
+    
+    This function blocks until the window is closed.
+    
+    Args:
+        width: Window width in pixels (default: 200)
+        height: Window height in pixels (default: 200)
+        resizable: Whether the window can be resized by user (default: True)
+        caption: Window title bar text (default: "SG window")
+    """
     global _bgcolor
 
     if resizable:
@@ -540,6 +842,7 @@ def run(
 
     def handle_events():
         nonlocal running
+        global _dragging_shape
 
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
@@ -564,6 +867,27 @@ def run(
                 for shape in _shapes:
                     if shape.is_obj_over() and shape in _mouse_click_funcs:
                         _mouse_click_funcs[shape]()
+                    if shape.draggable and shape.is_obj_over():
+                        _dragging_shape = shape
+                        break
+
+            if event.type == pygame.MOUSEBUTTONUP:
+                _dragging_shape = None
+
+            def _move_shape(_dragging_shape):
+                if _dragging_shape is not None:
+                    if hasattr(_dragging_shape, "points"):
+                        dx = mouse.x - _dragging_shape.points[0][0]
+                        dy = mouse.y - _dragging_shape.points[0][1]
+                        _dragging_shape.points = [
+                            (p[0] + dx, p[1] + dy) for p in _dragging_shape.points
+                        ]
+                    else:
+                        _dragging_shape.x = mouse.x
+                        _dragging_shape.y = mouse.y
+                        _dragging_funcs[_dragging_shape]()
+
+            _move_shape(_dragging_shape)
 
         keys_pressed = pygame.key.get_pressed()
         for pygame_key, func in _key_hold_funcs.items():
@@ -577,6 +901,9 @@ def run(
                     func(pygame.key.name(pygame_key))
                 else:
                     func()
+        for shape, func in _hover_funcs.items():
+            if shape.is_obj_over(mouse.x, mouse.y):
+                func()
 
         for func in _ontick:
             func()
@@ -587,20 +914,23 @@ def run(
         screen.fill(_bgcolor)
 
         for shape in _shapes:
-            if str(shape) == "circle":
+            if not shape.visible:
+                continue
+            shapeName = shape.__class__.__name__.lower()
+            if shapeName == "circle":
                 pygame.draw.circle(
                     screen, shape.color, (shape.x, shape.y), shape.radius, shape.outline
                 )
-            elif str(shape) == "rect":
+            elif shapeName == "rect":
                 pygame.draw.rect(
                     screen,
                     shape.color,
                     shape.rect,
                     shape.outline,
                 )
-            elif str(shape) == "polygon":
+            elif shapeName == "polygon":
                 pygame.draw.polygon(screen, shape.color, shape.points, shape.outline)
-            elif str(shape) == "line":
+            elif shapeName == "line":
                 for i in range(1, len(shape.points)):
                     pygame.draw.line(
                         screen,
@@ -609,11 +939,11 @@ def run(
                         shape.points[i],
                         shape.width,
                     )
-            elif str(shape) == "text":
+            elif shapeName == "text":
                 screen.blit(shape.txtsurf, (shape.x, shape.y))
-            elif str(shape) == "image":
+            elif shapeName == "image":
                 screen.blit(shape.surface, (shape.x, shape.y))
-            elif str(shape) == "group":
+            elif shapeName == "group":
                 pass  # this stops weird edgecases while keeping good rendering
 
         pygame.display.flip()

{simple_graphics_lib-0.0.7 → simple_graphics_lib-0.0.9}/src/simple_graphics_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple-graphics-lib
-Version: 0.0.7
+Version: 0.0.9
 Summary: A simple graphics library for python learners
 Author-email: Max-Hillyer <maxhillyer7012@gmail.com>
 License-Expression: MIT
@@ -63,6 +63,8 @@ Arguments:
 | height | int | the height of the rect | 10 |
 | color | str | the color of the rect | "black" | 
 | outline | bool | whether the rect is just an outline | False | 
+| draggable | bool | whether the rect can be dragged | False | 
+| visible | bool | whether the rect is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -80,6 +82,8 @@ Arguments:
 | radius | int | the radius of the circle | 10 |
 | color | str | the color of the circle | "black" | 
 | outline | bool | whether the circle is just an outline | False | 
+| draggable | bool | whether the circle can be dragged | False | 
+| visible | bool | whether the circle is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -94,6 +98,8 @@ Arguments:
 | points | list[tuple] | the vertices of the polygon | None | 
 | color | str | the color of the polygon | "black" | 
 | outline | bool | whther the polygon is just an outline | False | 
+| draggable | bool | whether the polygon can be dragged | False | 
+| visible | bool | whether the polygon is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -107,6 +113,8 @@ Arguments:
 | points | list[tuple] |the points that the line will connect | None |
 | width | int | the width of the line | 10 | 
 | color | str | the color of the line | "black" | 
+| draggable | bool | whether the line can be dragged | False | 
+| visible | bool | whether the line is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -122,6 +130,8 @@ Arguments:
 | text | str | the text of the text | None | 
 | color | str | the color of the text | "black" | 
 | size | int | the size of the text | 36 | 
+| draggable | bool | whether the text can be dragged | False | 
+| visible | bool | whether the text is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -137,6 +147,8 @@ Arguments:
 | img_path | str | the path to the image | None |
 | width | int | the width of the image | the width from the image path | 
 | height | int | the height of the image | the height from the image path | 
+| draggable | bool | whether the image can be dragged | False | 
+| visible | bool | whether the image is drawn on screen | True | 
 
 Methods: 
 | Method | Purpose | Arguments | Returns | 
@@ -160,7 +172,8 @@ group.color = "green"
 Arguments:
 | Argument | Type | Role | Default | 
 | :--- | :---: | :---: | ---: |
-| *shapes | list[Shape] | the shapes to group | None |
+| *shapes | list[Shape] | the shapes to group | None | 
+| visible | bool | whether shapes in group are drawn on screen | True |
 
 Methods:
 | Method | Purpose | Arguments | Returns | 
@@ -308,6 +321,33 @@ def print_click():
 run()
 ```
 
+### on_hover
+functions defined with the `@on_hover` decorator will run whenever the specified object is being hovered over
+
+the function below will run whenever the mouse is over the rectangle 
+```python
+r1 = Rect(200,200, 100, 100)
+
+@on_hover(r1)
+def p():
+    print("hovering")
+
+run(400,400)
+```
+
+### on_drag
+functions defined with the `@on_drag` decorator will run whenever the specified object is being dragged
+
+the function below will run whenevr the r1 rect is being dragged
+```python
+r1 = Rect(200,200,draggable = True)
+
+@on_drag(r1)
+def do_something():
+    print("dragging r1")
+
+run(400,400)
+```
 ---
 ## The mouse
 A mouse object is already initialized in the Simple Graphics import 
@@ -322,6 +362,15 @@ def main():
 
 run()
 ```
+
+## dragging 
+
+to make a shape draggable, add the keyword argument to the object initialization: 
+```python
+r = Rect(250,250, draggable = True)
+```
+this works for all shapes including images and text
+
 ---
 ## Miscellaneous Functions