salabim 25.0.9.post4__tar.gz → 25.0.11__tar.gz

{salabim-25.0.9.post4 → salabim-25.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salabim
-Version: 25.0.9.post4
+Version: 25.0.11
 Summary: salabim - discrete event simulation in Python
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://salabim.org

{salabim-25.0.9.post4 → salabim-25.0.11}/pyproject.toml

@@ -10,7 +10,7 @@ authors = [
     { name = "Ruud van der Ham", email = "rt.van.der.ham@gmail.com" },
 ]
 description = "salabim - discrete event simulation in Python"
-version = "25.0.9.post4"
+version = "25.0.11"
 readme = "README.md"
 requires-python = ">=3.7"
 dependencies = []

{salabim-25.0.9.post4 → salabim-25.0.11}/salabim/salabim.py

@@ -1,13 +1,13 @@
-#               _         _      _               ____   ____       ___       ___
-#   ___   __ _ | |  __ _ | |__  (_) _ __ ___    |___ \ | ___|     / _ \     / _ \
-#  / __| / _` || | / _` || '_ \ | || '_ ` _ \     __) ||___ \    | | | |   | (_) |
-#  \__ \| (_| || || (_| || |_) || || | | | | |   / __/  ___) | _ | |_| | _  \__, |
-#  |___/ \__,_||_| \__,_||_.__/ |_||_| |_| |_|  |_____||____/ (_) \___/ (_)   /_/
+#               _         _      _               ____   ____       ___      _  _
+#   ___   __ _ | |  __ _ | |__  (_) _ __ ___    |___ \ | ___|     / _ \    / |/ |
+#  / __| / _` || | / _` || '_ \ | || '_ ` _ \     __) ||___ \    | | | |   | || |
+#  \__ \| (_| || || (_| || |_) || || | | | | |   / __/  ___) | _ | |_| | _ | || |
+#  |___/ \__,_||_| \__,_||_.__/ |_||_| |_| |_|  |_____||____/ (_) \___/ (_)|_||_|
 #                    discrete event simulation
 #
 #  see www.salabim.org for more information, the documentation and license information
 
-__version__ = "25.0.9"
+__version__ = "25.0.11"
 import heapq
 import random
 import time
@@ -43,7 +43,6 @@ import base64
 import zipfile
 from pathlib import Path
 
-
 from typing import Any, Union, Iterable, Tuple, List, Callable, TextIO, Dict, Set, Type, Hashable, Optional
 
 dataframe = None  # to please PyLance
@@ -52,6 +51,7 @@ ColorType = Union[str, Iterable[float]]
 
 Pythonista = sys.platform == "ios"
 Windows = sys.platform.startswith("win")
+MacOS = platform.system == "Darwin"
 PyPy = platform.python_implementation() == "PyPy"
 Chromebook = "penguin" in platform.uname()
 Xlwings = "xlwings" in sys.modules
@@ -110,6 +110,7 @@ def a_log(*args):
 
 class g: ...
 
+
 if Pythonista:
     try:
         import scene  # type: ignore
@@ -2889,6 +2890,14 @@ class Monitor:
 
             if False (default), the normal 2D plane will be used.
 
+        screen_coordinates : bool
+            use screen_coordinates
+
+            if True (default), screen_coordinates will be used instead.
+
+            if False, all parameters are scaled for positioning and scaling
+            objects.
+            
         Returns
         -------
         reference to AnimateMonitor object : AnimateMonitor
@@ -3665,11 +3674,11 @@ class AnimateMonitor(DynamicClass):
     screen_coordinates : bool
         use screen_coordinates
 
-        if False,  the scale parameters are use for positioning and scaling
-        objects.
-
-        if True (default), screen_coordinates will be used.
+        if True (default), screen_coordinates will be used instead.
 
+        if False, all parameters are scaled for positioning and scaling
+        objects.
+        
     Note
     ----
     All measures are in screen coordinates
@@ -3714,9 +3723,9 @@ class AnimateMonitor(DynamicClass):
         as_points: bool = None,
         over3d: bool = None,
         layer: Union[float, Callable] = 0,
+        screen_coordinates=True,
         visible: Union[bool, Callable] = True,
         keep: Union[bool, Callable] = True,
-        screen_coordinates: bool = True,
         arg: Any = None,
     ):
         super().__init__()
@@ -4396,6 +4405,14 @@ class Queue:
 
             default: self (instance itself)
 
+        screen_coordinates : bool
+            use screen_coordinates
+
+            if True (default), screen_coordinates will be used instead.
+
+            if False, all parameters are scaled for positioning and scaling
+            objects.
+            
         Returns
         -------
         reference to AnimationQueue object : AnimationQueue
@@ -7204,7 +7221,7 @@ by adding at the end:
 
     overridden_lineno = None
 
-    def animation_objects(self, id: Any) -> Tuple:
+    def animation_objects(self, id: Any, screen_coordinates: bool = True) -> Tuple:
         """
         defines how to display a component in AnimateQueue
 
@@ -7234,7 +7251,9 @@ by adding at the end:
         """
         size_x = 50
         size_y = 50
-        ao0 = AnimateRectangle(text=str(self.sequence_number()), textcolor="bg", spec=(-20, -20, 20, 20), linewidth=0, fillcolor="fg")
+        ao0 = AnimateRectangle(
+            text=str(self.sequence_number()), textcolor="bg", spec=(-20, -20, 20, 20), linewidth=0, fillcolor="fg", screen_coordinates=screen_coordinates
+        )
         return (size_x, size_y, ao0)
 
     def animation3d_objects(self, id: Any) -> Tuple:
@@ -10583,6 +10602,8 @@ class Environment:
         self._step_pressed = False
         self.stopped = False
         self._paused = False
+        self._zoom_factor = 1.1
+
         self.last_s0 = ""
         if Xlwings:
             if blind_animation is None:
@@ -10711,6 +10732,23 @@ class Environment:
         """
         if self._ui:
             self._handle_ui_event()
+        self._x0_org = self._x0
+        self._x1_org = self._x1
+        self._y0_org = self._y0
+        self._y1_org = self._y1
+        self._scale_org = self._scale
+        self._x0 = self._x0z
+        self._y0 = self._y0z
+        self._x1 = self._x1z  # 0+self._width/self._scale
+        self._y1 = self._y1z  # +self._height/self._scale
+        self._scale = self._scalez
+
+        # midx=self._x0+self._panx*(self._x1-self._x0)
+        # self._x0, self._x1= midx-(1/self._zoom)*(self._x1-self._x0)/2,midx+(1/self._zoom)*(self._x1-self._x0)/2
+
+        # midy=self._y0+self._pany*(self._y1-self._y0)
+        # self._y0, self._y1 = midy-(1/self._zoom)*(self._y1-self._y0)/2, midy+(1/self._zoom)*(self._y1-self._y0)/2
+        # self._scale = self._width / (self._x1 - self._x0)
 
     def animation_post_tick(self, t: float) -> None:
         """
@@ -10723,7 +10761,12 @@ class Environment:
         t : float
             Current (animation) time.
         """
-        ...
+        self._x0 = self._x0_org
+        self._x1 = self._x1_org
+        self._y0 = self._y0_org
+        self._y1 = self._y1_org
+        self._scale = self._scale_org
+        self._last_scalez = self._scalez
 
     def animation_pre_tick_sys(self, t: float) -> None:
         for ao in self.sys_objects.copy():  # copy required as ao's may be removed due to keep
@@ -11248,6 +11291,61 @@ class Environment:
     def on_closing(self):
         self.an_quit()
 
+    def on_mousewheel(self, event):
+        x_mouse = self.root.winfo_pointerx() - self.root.winfo_rootx()
+        y_mouse = self.height() - self.root.winfo_pointery() + self.root.winfo_rooty()
+        x = (x_mouse / self._scale) + self._x0z
+        y = (y_mouse / self._scale) + self._y0z
+
+        if Windows:
+            delta = int(event.delta / 120)  # normalize to ticks
+        elif MacOS:
+            delta = int(event.delta)  # already small, usually ±1
+        else:
+            delta = 0  # fallback
+        for _ in range(abs(delta)):
+            if delta < 0:
+                zoom_factor = self._zoom_factor
+
+            else:
+                zoom_factor = 1 / self._zoom_factor
+
+            # min_zoom = min(
+            #     (self._x0 - x) / (self._x0z - x),
+            #     (self._x0 - x) / (self._x0z - x),
+            #     (self._x1 - x) / (self._x1z - x),
+            #     (self._y0 - y) / (self._y0z - y),
+            #     (self._y1 - y) / (self._y1z - y),
+            # )
+
+            # zoom_factor = min(zoom_factor, min_zoom)
+
+            self._scalez /= zoom_factor
+            self._x0z = x - (x - self._x0z) * zoom_factor
+            self._y0z = y - (y - self._y0z) * zoom_factor
+            self._x1z = x - (x - self._x1z) * zoom_factor
+            self._y1z = y - (y - self._y1z) * zoom_factor
+
+    def start_pan(self, event):
+        g.canvas.config(cursor="fleur")  # Change cursor to "move" style
+        self.lastx = event.x
+        self.lasty = event.y
+        self.lastx0 = self._x0z
+        self.lasty0 = self._y0z
+
+    def do_pan(self, event):
+        dx = -((event.x - self.lastx) / self._scale)
+        dy = (event.y - self.lasty) / self._scale
+        # self._x0z = max(self._x0,self.lastx0 + dx)
+        # self._y0z = max(self._y0,self.lasty0 + dy)
+        self._x0z = self.lastx0 + dx
+        self._y0z = self.lasty0 + dy
+        self._x1z = self._x0z + (self._x1 - self._x0)
+        self._y1z = self._y0z + (self._y1 - self._y0)
+
+    def end_pan(self, event):
+        g.canvas.config(cursor="")  # Reset to default
+
     def animation_parameters(
         self,
         animate: Union[bool, str] = None,
@@ -11850,6 +11948,10 @@ class Environment:
                         self.root.bind("<space>", lambda self: g.animation_env.an_menu_go())
                         self.root.bind("s", lambda self: g.animation_env.an_single_step())
                         self.root.bind("<Control-c>", lambda self: g.animation_env.an_quit())
+                        self.root.bind("<MouseWheel>", self.on_mousewheel)
+                        self.root.bind("<ButtonPress-1>", self.start_pan)
+                        self.root.bind("<B1-Motion>", self.do_pan)
+                        self.root.bind("<ButtonRelease-1>", self.end_pan)
 
                         g.canvas = tkinter.Canvas(self.root, width=self._width, height=self._height)
                         g.canvas.configure(background=self.colorspec_to_hex("bg", False))
@@ -11857,6 +11959,11 @@ class Environment:
                         g.canvas_objects = []
                         g.canvas_object_overflow_image = None
 
+                        # g.canvas.move("all", 1, 1)
+                        # g.canvas.update()
+                        # g.canvas.move("all", -1, -1)
+                        # g.canvas.update()
+
                     self.uninstall_uios()  # this causes all ui objects to be (re)installed
 
                     if self._show_menu_buttons and not self._ui:
@@ -13313,6 +13420,12 @@ class Environment:
                 raise SimulationStopped
         else:
             self.root.after(0, self.simulate_and_animate_loop)
+            self._x0z = self._x0
+            self._y0z = self._y0
+            self._x1z = self._x1
+            self._y1z = self._y1
+
+            self._scalez = self._last_scalez = self._scale
             self.root.mainloop()
             if self._animate and self.running:
                 if self._video:
@@ -13822,19 +13935,19 @@ class Environment:
             if screen_coordinates:
                 return 0
             else:
-                return self._x0 / scale
+                return self._x0_org / scale
 
         if xy_anchor in ("n", "c", "center", "s"):
             if screen_coordinates:
                 return (width / 2) / scale
             else:
-                return ((self._x0 + self._x1) / 2) / scale
+                return ((self._x0_org + self._x1_org) / 2) / scale
 
         if xy_anchor in ("ne", "e", "se", ""):
             if screen_coordinates:
                 return width / scale
             else:
-                return self._x1 / scale
+                return self._x1_org / scale
 
         raise ValueError("incorrect xy_anchor", xy_anchor)
 
@@ -13849,19 +13962,19 @@ class Environment:
             if screen_coordinates:
                 return height / scale
             else:
-                return self._y1 / scale
+                return self._y1_org / scale
 
         if xy_anchor in ("w", "c", "center", "e"):
             if screen_coordinates:
                 return (height / 2) / scale
             else:
-                return ((self._y0 + self._y1) / 2) / scale
+                return ((self._y0_org + self._y1_org) / 2) / scale
 
         if xy_anchor in ("sw", "s", "se", ""):
             if screen_coordinates:
                 return 0
             else:
-                return self._y0 / scale
+                return self._y0_org / scale
 
         raise ValueError("incorrect xy_anchor", xy_anchor)
 
@@ -18180,6 +18293,7 @@ class AnimateQueue(DynamicClass):
         if not self.keep(t):
             self.remove()
             return
+        screen_coordinates = self.screen_coordinates
         prev_aos = self.current_aos
         self.current_aos = {}
         xy_anchor = self.xy_anchor(t)
@@ -18201,8 +18315,8 @@ class AnimateQueue(DynamicClass):
         titleoffsetx = self.titleoffsetx(t)
         titleoffsety = self.titleoffsety(t)
 
-        x += self._queue.env.xy_anchor_to_x(xy_anchor, screen_coordinates=True, over3d=self.over3d)
-        y += self._queue.env.xy_anchor_to_y(xy_anchor, screen_coordinates=True, over3d=self.over3d)
+        x += self._queue.env.xy_anchor_to_x(xy_anchor, screen_coordinates=screen_coordinates, over3d=self.over3d)
+        y += self._queue.env.xy_anchor_to_y(xy_anchor, screen_coordinates=screen_coordinates, over3d=self.over3d)
 
         if direction == "e":
             self.x_t = x + (-25 if titleoffsetx is None else titleoffsetx)
@@ -18234,20 +18348,21 @@ class AnimateQueue(DynamicClass):
             if ((max_length is not None) and n >= max_length) or not self.visible_t:
                 break
 
-            if c not in prev_aos:
-                nargs = c.animation_objects.__code__.co_argcount
-                if nargs == 1:
-                    animation_objects = self.current_aos[c] = c.animation_objects()
-                else:
-                    animation_objects = self.current_aos[c] = c.animation_objects(self.id(t))
-            else:
+            if c in prev_aos and self.env._scalez != self.env._last_scalez: # if scale changed (due to zooming), rerender the animation_objects
                 animation_objects = self.current_aos[c] = prev_aos[c]
                 del prev_aos[c]
+            else:
+                parameters = inspect.signature(c.animation_objects).parameters
+                kwargs = {}
+                if "id" in parameters:
+                    kwargs["id"] = self.id(t)
+                if "screen_coordinates" in parameters:
+                    kwargs["screen_coordinates"] = self.screen_coordinates
+                animation_objects = self.current_aos[c] = c.animation_objects(**kwargs)
 
             dimx = _call(animation_objects[0], t, c)
             dimy = _call(animation_objects[1], t, c)
             for ao in animation_objects[2:]:
-                ao.screen_coordinates = self.screen_coordinates
                 if isinstance(ao, AnimateClassic):
                     if direction == "t":
                         ao.x0 = xt + trajectory.x(t=x * 1.00, _t0=0)
@@ -18373,9 +18488,17 @@ class Animate3dQueue(DynamicClass):
         if given, the animation object will be removed
         automatically when the parent component is no longer accessible
 
+    screen_coordinates : bool
+        use screen_coordinates
+
+        if True (default), screen_coordinates will be used instead.
+
+        if False, all parameters are scaled for positioning and scaling
+        objects.
+        
     Note
     ----
-    All parameters, apart from queue, id, arg and parent can be specified as:
+    All parameters, apart from queue, id, arg, screen_coordinates and parent can be specified as:
 
     - a scalar, like 10
 

{salabim-25.0.9.post4 → salabim-25.0.11}/salabim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: salabim
-Version: 25.0.9.post4
+Version: 25.0.11
 Summary: salabim - discrete event simulation in Python
 Author-email: Ruud van der Ham <rt.van.der.ham@gmail.com>
 Project-URL: Homepage, https://salabim.org