CreativePython 1.1.0__tar.gz → 1.1.2__tar.gz

{creativepython-1.1.0/src/CreativePython.egg-info → creativepython-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 1.1.0
+Version: 1.1.2
 Summary: A Python-based software environment for developing algorithmic art projects.
 Author-email: "Dr. Bill Manaris" <manaris@cofc.edu>, Taj Ballinger <ballingertj@g.cofc.edu>, Trevor Ritchie <ritchiets@g.cofc.edu>
 License: MIT License

{creativepython-1.1.0 → creativepython-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "CreativePython"
-version = "1.1.0"
+version = "1.1.2"
 description = "A Python-based software environment for developing algorithmic art projects."
 readme = "README.md"
 license = { file = "LICENSE" }

{creativepython-1.1.0 → creativepython-1.1.2}/src/CreativePython/GuiHandler.py

@@ -61,16 +61,25 @@ def _createEvent(eventType, target, args=None):
 # Child process entry point
 #######################################################################################
 
-def _launchRenderer(childConn):
+def _launchRenderer(childConn, shutdownReadConn, shutdownWriteConn):
    """
    Entry point for the GuiRenderer child process.
    Defined here so GuiHandler can reference it without importing from GuiRenderer
    globally (which would also import Qt/PySide6 in the parent process).
 
+   shutdownReadConn is the read end of the dedicated shutdown pipe; the child
+   watches it with QSocketNotifier and shuts down when it becomes readable (EOF).
+   shutdownWriteConn is the write end inherited from the parent (fork) or passed
+   via pickling (forkserver/spawn); it is closed immediately so that only the
+   parent's copy of the write end remains open — ensuring the child sees EOF when
+   the parent closes its copy.
+
    At runtime this function only executes in the child process.
    """
    import sys, os
 
+   shutdownWriteConn.close()   # child must not hold the write end open
+
    # Suppress macOS system noise (stale XPC connections inherited via fork)
    # that would confuse students.  Redirect at the OS level (fd 2) so that
    # C-level libraries (Cocoa, XPC) are also silenced.
@@ -80,7 +89,7 @@ def _launchRenderer(childConn):
    sys.stderr = open(os.devnull, 'w')
 
    from CreativePython.GuiRenderer import GuiRenderer
-   renderer = GuiRenderer(childConn)
+   renderer = GuiRenderer(childConn, shutdownReadConn)
    renderer.run()
 
 
@@ -140,6 +149,15 @@ class GuiHandler:
          ctx = multiprocessing.get_context('forkserver')
       else:
          ctx = multiprocessing.get_context('fork')
+
+      # Dedicated one-directional shutdown pipe.  The parent holds the write
+      # end; the child holds the read end.  Closing the write end in the parent
+      # sends EOF to the child's read end, which Qt detects immediately via
+      # QSocketNotifier — independent of the command queue and independent of
+      # whether atexit runs (the OS closes the fd automatically on process death).
+      shutdownReadConn, shutdownWriteConn = multiprocessing.Pipe(duplex=False)
+      self._shutdownPipe = shutdownWriteConn
+
       # With 'spawn' on POSIX (fork+exec), the forked helper calls
       # get_preparation_data() which reads sys.modules['__main__'].__file__.
       # When a user script is running in PENCIL's subprocess, __main__.__file__
@@ -159,7 +177,7 @@ class GuiHandler:
       try:
          self.childProcess = ctx.Process(
             target = _launchRenderer,
-            args   = (childConn,),
+            args   = (childConn, shutdownReadConn, shutdownWriteConn),
             daemon = True   # child is killed automatically if parent dies unexpectedly
          )
          self.childProcess.start()
@@ -169,7 +187,8 @@ class GuiHandler:
                _main_mod.__file__ = _saved_file
             if _saved_spec is not _UNSET:
                _main_mod.__spec__ = _saved_spec
-      childConn.close()   # parent no longer needs the child end of the Pipe
+      childConn.close()        # parent no longer needs the child end of the command pipe
+      shutdownReadConn.close() # parent no longer needs the read end of the shutdown pipe
 
       # responseId counter — each sendQuery() call gets a unique ID so the
       # listener thread can route the response back to the correct caller
@@ -214,11 +233,10 @@ class GuiHandler:
 
    def _listenForMessages(self):
       """
-      Background thread.  Reads all incoming messages from GuiRenderer and
-      routes each one based on its type:
-        - 'responseId' key present → response for a waiting sendQuery() call
-        - 'type' key present       → event for a registered callback
-      Exits when the pipe is closed (EOFError).
+      Background thread.  Reads incoming messages from GuiRenderer and routes
+      each one: responses unblock waiting sendQuery() callers; events invoke
+      registered callbacks.  Exits when the child closes the pipe (EOFError)
+      and releases any sendQuery() callers still waiting for a response.
       """
       while True:
          try:
@@ -228,7 +246,11 @@ class GuiHandler:
             elif 'type' in message:
                self._dispatchEvent(message)
          except EOFError:
-            break   # pipe closed; thread exits cleanly
+            break
+      with self._pendingLock:
+         for slot in self._pendingResponses.values():
+            slot['values'] = ['shutdown']
+            slot['event'].set()
 
    def _handleResponse(self, responseDict):
       """
@@ -334,23 +356,14 @@ class GuiHandler:
 
    def _shutdown(self):
       """
-      Kills the child process immediately and closes the pipe.
+      Signals the child to shut down and waits for it to exit.
+      Closing the shutdown pipe delivers EOF to the child's QSocketNotifier,
+      which fires _onShutdownSignal on Qt's main thread immediately — even if
+      atexit does not run, since the OS closes the pipe fd on process death.
       Called automatically via atexit when the parent process exits.
-      The child is killed with SIGKILL so it does not drain its event queue —
-      exit() in the parent should return promptly.
       """
-      if self.childProcess.is_alive():
-         # SIGTERM is overridden in the child to call os._exit(0) immediately,
-         # bypassing Qt's graceful shutdown (which drains the event queue).
-         # Python delivers SIGTERM between bytecodes, so it fires within one
-         # iteration of the child's _pollPipe loop — far faster than SIGKILL,
-         # which macOS may defer while a Metal/GPU operation is in flight.
-         self.childProcess.terminate()
-         self.childProcess.join(timeout=0.5)   # should die in < 1 ms
-      if self.childProcess.is_alive():
-         self.childProcess.kill()              # backup: SIGKILL
-         self.childProcess.join(timeout=2.0)
-      self.connection.close()
+      self._shutdownPipe.close()
+      self.childProcess.join(timeout=1.0)
 
 
 #######################################################################################

{creativepython-1.1.0 → creativepython-1.1.2}/src/CreativePython/GuiRenderer.py

@@ -75,30 +75,20 @@ class GuiRenderer:
    Unknown targets and unknown actions are silently ignored.
    """
 
-   def __init__(self, childConn):
+   def __init__(self, childConn, shutdownReadConn):
       """
       Creates the QApplication and initializes all registries.
       """
-      self.connection = childConn
+      self.connection      = childConn
+      self._shutdownConn   = shutdownReadConn
 
       # QApplication must be created first; it owns the Qt event loop.
       self._app = QtWidgets.QApplication([])
 
-      # Do not quit when the last window is closed.  The default behaviour
-      # (quitOnLastWindowClosed = True) would exit the child process the
-      # moment the user closes a Display, breaking the IPC pipe and making
-      # it impossible to open new Displays without restarting Python.
-      # The child only exits when the parent sends a 'shutdown' command or
-      # kills the process directly.
+      # Do not quit when the last window is closed — the child stays alive
+      # until the parent closes the shutdown pipe, triggering _onShutdownSignal.
       self._app.setQuitOnLastWindowClosed(False)
 
-      # Qt installs a SIGTERM handler that drains the event queue before
-      # exiting (graceful shutdown).  When the parent kills this process,
-      # we want immediate exit — override Qt's handler after QApplication
-      # is constructed so ours takes precedence.
-      import signal, os as _os
-      signal.signal(signal.SIGTERM, lambda sig, frame: _os._exit(0))
-
       # maps objectId (int) -> mirror object (e.g. DisplayMirror, RectangleMirror)
       self._objectRegistry = {}
 
@@ -108,87 +98,58 @@ class GuiRenderer:
 
    def run(self):
       """
-      Starts the pipe-polling timer and enters Qt's event loop.
-      The QTimer fires _pollPipe() every 8ms (~120 Hz), draining any pending
-      commands without blocking the Qt event loop between frames.
+      Wires up the command-polling timer and the shutdown notifier, then enters
+      Qt's event loop.
+      _pollPipe fires every 8ms to process incoming commands in fixed batches.
+      _shutdownNotifier watches the dedicated shutdown pipe fd; when the parent
+      closes its write end (via _shutdown() or process death), Qt fires
+      _onShutdownSignal on the main thread immediately — independent of the
+      command queue and of whether atexit runs in the parent.
       """
       self._timer = QtCore.QTimer()
       self._timer.timeout.connect(self._pollPipe)
       self._timer.start(8)
-      self._app.exec()
 
-   _polling = False  # reentrancy guard
+      self._shutdownNotifier = QtCore.QSocketNotifier(
+         self._shutdownConn.fileno(),
+         QtCore.QSocketNotifier.Type.Read
+      )
+      self._shutdownNotifier.activated.connect(self._onShutdownSignal)
+
+      self._app.exec()
 
-   # # ── Option A: no batching (drain entire queue before rendering) ─────────
-   # def _pollPipe(self):
-   #    """
-   #    Drains all pending commands before returning to Qt's event loop.
-   #    """
-   #    while self.connection.poll():
-   #       message     = self.connection.recv()
-   #       keepRunning = self._routeCommand(message)
-   #       if not keepRunning:
-   #          break
+   # ── Command polling ───────────────────────────────────────────────────────
 
-   # ── Option B: fixed batch (let Qt render every N commands) ──────────────
    _BATCH_SIZE = 10
-   
+
    def _pollPipe(self):
       """
-      Drains pending commands, letting Qt process events every _BATCH_SIZE
-      commands so the display updates incrementally during large batches.
-      """
-      if self._polling:
-         return   # processEvents() fired the timer again — skip
-      self._polling = True
-      try:
-         count = 0
-         while self.connection.poll():
-            message     = self.connection.recv()
-            keepRunning = self._routeCommand(message)
-            if not keepRunning:
-               break
-            count += 1
-            if count % self._BATCH_SIZE == 0:
-               self._app.processEvents()
-      finally:
-         self._polling = False
-
-   # # ── Option C: adaptive batch (scales with scene complexity) ─────────────
-   # _BATCH_MIN = 10    # batch size when scene is empty
-   # _BATCH_MAX = 1000  # batch size ceiling
-   # _BATCH_PER = 25    # add this many to the batch per 1000 objects in scene
-
-   # def _pollPipe(self):
-   #    """
-   #    Drains pending commands, letting Qt process events at adaptive
-   #    intervals.  Small scenes get frequent updates (responsive feel);
-   #    large scenes batch more commands between repaints (less overhead
-   #    from increasingly expensive repaints).
-   #    """
-   #    if self._polling:
-   #       return   # processEvents() fired the timer again — skip
-   #    self._polling = True
-   #    try:
-   #       objectCount = len(self._objectRegistry)
-   #       batchSize   = min(self._BATCH_MAX,
-   #                         self._BATCH_MIN + objectCount * self._BATCH_PER)
-   #       count = 0
-   #       while self.connection.poll():
-   #          message     = self.connection.recv()
-   #          keepRunning = self._routeCommand(message)
-   #          if not keepRunning:
-   #             break
-   #          count += 1
-   #          if count % batchSize == 0:
-   #             self._app.processEvents()
-   #    finally:
-   #       self._polling = False
+      Processes up to _BATCH_SIZE pending commands per timer tick, then returns
+      control to Qt's event loop.  Keeping batches small lets Qt handle input
+      events and repaints between each batch, keeping the UI responsive during
+      heavy animation.
+      """
+      count = 0
+      while count < self._BATCH_SIZE and self.connection.poll():
+         try:
+            message = self.connection.recv()
+         except (EOFError, OSError):
+            # Command pipe closed — parent process died without sending a shutdown
+            # signal (e.g. killed by SIGTERM/SIGKILL, atexit didn't run).
+            # _onShutdownSignal may also fire if the OS released the shutdown pipe
+            # write end, but _app.quit() is safe to call from either path.
+            self._timer.stop()
+            self._shutdownNotifier.setEnabled(False)
+            self._app.quit()
+            return
+         self._routeCommand(message)
+         count += 1
 
    def _routeCommand(self, commandDict):
       """
       Routes an incoming command to the appropriate handler.
-      Returns False if the renderer should shut down, True otherwise.
+      Shutdown is handled out-of-band by _onShutdownSignal; unknown actions are
+      silently ignored.
       """
       action     = commandDict.get('action')
       target     = commandDict.get('target')
@@ -196,11 +157,7 @@ class GuiRenderer:
       responseId = commandDict.get('responseId')
 
       # ── Built-in actions ──────────────────────────────────────────────────
-      if action == 'shutdown':
-         self._handleShutdown()
-         return False
-
-      elif action == 'ping':
+      if action == 'ping':
          response = _createResponse(responseId, ['pong'])
          self.connection.send(response)
 
@@ -356,9 +313,32 @@ class GuiRenderer:
       event = _createEvent(eventType, objectId, args)
       self.connection.send(event)
 
-   def _handleShutdown(self):
-      """Stops the polling timer and quits the Qt event loop."""
+   def _onShutdownSignal(self):
+      """
+      Called by Qt when the shutdown pipe becomes readable — meaning the parent
+      has closed its write end (via _shutdown() or process death).
+      Fires immediately on the Qt main thread, independent of the command queue.
+      Drains any remaining commands from the command pipe, sending 'shutdown'
+      responses to release any sendQuery() callers blocking in the parent.
+      Fire-and-forget commands are discarded.  Then quits Qt's event loop
+      normally so Qt can clean up its own resources.
+      """
+      self._shutdownNotifier.setEnabled(False)
       self._timer.stop()
+
+      # Drain remaining commands.  Queries get a 'shutdown' response so that
+      # any sendQuery() call blocking in the parent is released immediately.
+      # Fire-and-forget commands are discarded.
+      # If the command pipe is already closed, the drain is skipped gracefully.
+      try:
+         while self.connection.poll():
+            message    = self.connection.recv()
+            responseId = message.get('responseId')
+            if responseId is not None:
+               self.connection.send(_createResponse(responseId, ['shutdown']))
+      except (EOFError, OSError):
+         pass  # command pipe already closed; listener releases pending queries
+
       self._app.quit()
 
 

{creativepython-1.1.0 → creativepython-1.1.2/src/CreativePython.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 1.1.0
+Version: 1.1.2
 Summary: A Python-based software environment for developing algorithmic art projects.
 Author-email: "Dr. Bill Manaris" <manaris@cofc.edu>, Taj Ballinger <ballingertj@g.cofc.edu>, Trevor Ritchie <ritchiets@g.cofc.edu>
 License: MIT License

{creativepython-1.1.0 → creativepython-1.1.2}/src/gui.py

@@ -2,7 +2,6 @@
 # gui.py       Version 1.0     13-Mar-2026
 # Taj Ballinger, Trevor Ritchie, Bill Manaris, and Dana Hughes
 #######################################################################################
-
 import numpy as np
 
 from CreativePython.GuiHandler import _createHandler
@@ -934,19 +933,19 @@ class Display(_Interactable):
          raise TypeError(f'{type(self).__name__}.addPopupMenu(): menu should be a Menu object (it was {type(menu).__name__})')
       _handler().sendCommand('addPopupMenu', self._objectId, {'menuId': menu._objectId})
 
-   def write(self, filename, width=None, height=None):
+   def save(self, filename, width=None, height=None):
       """
       Saves the display's currently visible canvas to an image file.
       The file format is determined by the filename extension (e.g. .png, .jpg).
       Optional width and height resize the saved image; omitting one preserves the aspect ratio.
-      Prints whether the write succeeded and the resolved file path.
+      Prints whether the save succeeded and the resolved file path.
       """
       result = _handler().sendQuery('write', self._objectId, {'filename': filename, 'width': width, 'height': height})
       success, resolvedPath = result[0], result[1]
       if success:
-         print(f'{type(self).__name__}.write(): saved to "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): saved canvas to "{resolvedPath}"')
       else:
-         print(f'{type(self).__name__}.write(): failed to save "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): failed to save to "{resolvedPath}"')
 
    def onClose(self, action):
       """
@@ -1312,6 +1311,34 @@ class _Drawable(_Interactable):
 
       return x, y, width, height
 
+   def _rotatePoints(self, xPoints, yPoints):
+      """
+      Rotates a list of global-coordinate points around this item's center.
+      Returns (xPoints, yPoints) — post-rotation, as lists of ints.
+      If rotation == 0, returns the inputs unchanged.
+      """
+      if self._rotation != 0:
+         globalX, globalY = self._getGlobalCorner()
+         cx = globalX + self._width  / 2
+         cy = globalY + self._height / 2
+
+         radians = np.radians(self._rotation)
+         cos     = np.cos(radians)
+         sin     = np.sin(radians)
+
+         rotatedXs = []
+         rotatedYs = []
+         for px, py in zip(xPoints, yPoints):
+            dx = px - cx
+            dy = py - cy
+            rotatedXs.append(int(cx + dx * cos + dy * sin))
+            rotatedYs.append(int(cy - dx * sin + dy * cos))
+         
+         xPoints = rotatedXs
+         yPoints = rotatedYs
+
+      return xPoints, yPoints
+
    # ── Position ───────────────────────────────────────────────────────────────
 
    def getCenter(self):
@@ -1677,9 +1704,9 @@ class Rectangle(_Graphics):
       })
 
    def __str__(self):
-      x1, y1    = self._getGlobalCorner()
-      x2        = x1 + self._width
-      y2        = y1 + self._height
+      xPoints, yPoints = self._getEndpoints()
+      x1, y1    = xPoints[0], yPoints[0]
+      x2, y2    = xPoints[2], yPoints[2]
       rotation  = self.getRotation()
       color     = self.getColor()
       fill      = self.getFilled()
@@ -1688,21 +1715,28 @@ class Rectangle(_Graphics):
 
    # ── Coordinates ────────────────────────────────────────────────────────────────
 
-   def getEndPoints(self):
+   def _getEndpoints(self):
       """
-      Returns [xPoints, yPoints]
+      Returns (xPoints, yPoints) — the four pre-rotation corners, in global coordinates.
+      Corner order: top-left, bottom-left, bottom-right, top-right.
       """
-      # rebuild global xPoints and yPoints, accounting for position and rotation changes
-      x1 = self._localCornerX
-      x2 = self._width
-      y1 = self._localCornerY
-      y2 = self._height
+      globalX, globalY = self._getGlobalCorner()
+      w = self._width
+      h = self._height
 
-      xPoints = [int(x1), int(x1), int(x2), int(x2)]
-      yPoints = [int(y1), int(y2), int(y2), int(y1)]
+      xPoints = [int(globalX), int(globalX),     int(globalX + w), int(globalX + w)]
+      yPoints = [int(globalY), int(globalY + h), int(globalY + h), int(globalY)]
 
       return xPoints, yPoints
 
+   def getEndpoints(self):
+      """
+      Returns (xPoints, yPoints) — the four corners after rotation, in global coordinates.
+      Original corner order: top-left, bottom-left, bottom-right, top-right.
+      """
+      xPoints, yPoints = self._getEndpoints()
+      return self._rotatePoints(xPoints, yPoints)
+
 
 class Oval(_Graphics):
    """
@@ -1976,7 +2010,7 @@ class Line(_Graphics):
       })
 
    def __str__(self):
-      xPoints, yPoints = self.getEndPoints()
+      xPoints, yPoints = self._getEndpoints()
       x1, x2    = xPoints
       y1, y2    = yPoints
       rotation  = self.getRotation()
@@ -1986,23 +2020,26 @@ class Line(_Graphics):
 
    # ── Coordinates ────────────────────────────────────────────────────────────────
 
-   def getEndPoints(self):
+   def _getEndpoints(self):
       """
-      Returns [x1, y1, x2, y2, rotation]
-      i.e. The values needed to construct a copy of this Line.
+      Returns ([x1, x2], [y1, y2]) — the two pre-rotation endpoints, in global coordinates.
       """
-      # rebuild global xPoints and yPoints, accounting for position, dimension, and rotation changes
       scaleX = 0 if (self._originalWidth  == 0) else (self._width  / self._originalWidth)
       scaleY = 0 if (self._originalHeight == 0) else (self._height / self._originalHeight)
 
       globalX, globalY = self._getGlobalCorner()
 
-      x1 = int(globalX + (self._xPoints[0] * scaleX))
-      y1 = int(globalY + (self._yPoints[0] * scaleY))
-      x2 = int(globalX + (self._xPoints[1] * scaleX))
-      y2 = int(globalY + (self._yPoints[1] * scaleY))
+      xPoints = [int(globalX + (self._xPoints[i] * scaleX)) for i in range(2)]
+      yPoints = [int(globalY + (self._yPoints[i] * scaleY)) for i in range(2)]
+
+      return xPoints, yPoints
 
-      return [x1, x2], [y1, y2]
+   def getEndpoints(self):
+      """
+      Returns ([x1, x2], [y1, y2]) — the two endpoints after rotation, in global coordinates.
+      """
+      xPoints, yPoints = self._getEndpoints()
+      return self._rotatePoints(xPoints, yPoints)
 
    # ── Length ────────────────────────────────────────────────────────────────
 
@@ -2017,7 +2054,7 @@ class Line(_Graphics):
       Sets the distance between the line's endpoints (in pixels).
       The line's second endpoint (x2, y2) moves to match.
       """
-      xPoints, yPoints = self.getEndPoints()
+      xPoints, yPoints = self.getEndpoints()
       x1, x2 = xPoints
       y1, y2 = yPoints
 
@@ -2111,7 +2148,7 @@ class Polyline(_Graphics):
       })
 
    def __str__(self):
-      xPoints, yPoints = self.getEndPoints()
+      xPoints, yPoints = self._getEndpoints()
       rotation  = self.getRotation()
       color     = self.getColor()
       thickness = self.getThickness()
@@ -2119,27 +2156,27 @@ class Polyline(_Graphics):
 
    # ── Coordinates ────────────────────────────────────────────────────────────────
 
-   def getEndPoints(self):
+   def _getEndpoints(self):
       """
-      Returns [xPoints, yPoints]
-      i.e. The values needed to construct a copy of this Polyline.
+      Returns (xPoints, yPoints) — all pre-rotation points, in global coordinates.
       """
-      # rebuild global xPoints and yPoints, accounting for position and dimension changes
       scaleX = 0 if (self._originalWidth  == 0) else (self._width  / self._originalWidth)
       scaleY = 0 if (self._originalHeight == 0) else (self._height / self._originalHeight)
 
       globalX, globalY = self._getGlobalCorner()
-      xPoints = []
-      yPoints = []
 
-      for i in range(len(self._xPoints)):
-         x = int(globalX + (self._xPoints[i] * scaleX))
-         y = int(globalY + (self._yPoints[i] * scaleY))
-         xPoints.append(x)
-         yPoints.append(y)
+      xPoints = [int(globalX + (self._xPoints[i] * scaleX)) for i in range(len(self._xPoints))]
+      yPoints = [int(globalY + (self._yPoints[i] * scaleY)) for i in range(len(self._yPoints))]
 
       return xPoints, yPoints
 
+   def getEndpoints(self):
+      """
+      Returns (xPoints, yPoints) — all points after rotation, in global coordinates.
+      """
+      xPoints, yPoints = self._getEndpoints()
+      return self._rotatePoints(xPoints, yPoints)
+
 
 class Polygon(_Graphics):
    """
@@ -2184,7 +2221,7 @@ class Polygon(_Graphics):
       })
 
    def __str__(self):
-      xPoints, yPoints = self.getEndPoints()
+      xPoints, yPoints = self._getEndpoints()
       rotation  = self.getRotation()
       color     = self.getColor()
       fill      = self.getFilled()
@@ -2193,26 +2230,27 @@ class Polygon(_Graphics):
 
    # ── Coordinates ────────────────────────────────────────────────────────────────
 
-   def getEndPoints(self):
+   def _getEndpoints(self):
       """
-      Returns [xPoints, yPoints, rotation]
+      Returns (xPoints, yPoints) — all pre-rotation points, in global coordinates.
       """
-      # rebuild global xPoints and yPoints, accounting for position and dimension changes
       scaleX = 0 if (self._originalWidth  == 0) else (self._width  / self._originalWidth)
       scaleY = 0 if (self._originalHeight == 0) else (self._height / self._originalHeight)
 
       globalX, globalY = self._getGlobalCorner()
-      xPoints = []
-      yPoints = []
 
-      for i in range(len(self._xPoints)):
-         x = int(globalX + (self._xPoints[i] * scaleX))
-         y = int(globalY + (self._yPoints[i] * scaleY))
-         xPoints.append(x)
-         yPoints.append(y)
+      xPoints = [int(globalX + (self._xPoints[i] * scaleX)) for i in range(len(self._xPoints))]
+      yPoints = [int(globalY + (self._yPoints[i] * scaleY)) for i in range(len(self._yPoints))]
 
       return xPoints, yPoints
 
+   def getEndpoints(self):
+      """
+      Returns (xPoints, yPoints) — all points after rotation, in global coordinates.
+      """
+      xPoints, yPoints = self._getEndpoints()
+      return self._rotatePoints(xPoints, yPoints)
+
 
 class Icon(_Graphics):
    """
@@ -2258,9 +2296,9 @@ class Icon(_Graphics):
       rotation      = self.getRotation()
       return f'Icon(filename = "{filename}", width = {width}, height = {height}, rotation = {rotation})'
 
-   # ── Write ────────────────────────────────────────────────────────────────
+   # ── Save ────────────────────────────────────────────────────────────────
 
-   def write(self, filename, width=None, height=None):
+   def save(self, filename, width=None, height=None):
       """
       Saves the icon to an image file.
       The file format is determined by the filename extension (e.g. .png, .jpg).
@@ -2270,9 +2308,9 @@ class Icon(_Graphics):
       result = _handler().sendQuery('write', self._objectId, {'filename': filename, 'width': width, 'height': height})
       success, resolvedPath = result[0], result[1]
       if success:
-         print(f'{type(self).__name__}.write(): saved to "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): saved canvas to "{resolvedPath}"')
       else:
-         print(f'{type(self).__name__}.write(): failed to save "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): failed to save "{resolvedPath}"')
 
    # ── Crop ────────────────────────────────────────────────────────────────
 

creativepython-1.1.2/src/image.py

@@ -0,0 +1,123 @@
+################################################################################
+# image.py       Version 1.0     30-Jan-2025
+# Taj Ballinger, Trevor Ritchie, and Bill Manaris
+#
+##############################################################
+##################
+
+from gui import Display, Icon
+
+class Image:
+   """
+   Display window for rendering images.
+   """
+   def __init__(self, arg1, arg2=None):
+      """
+      Creates a new image display.
+      """
+      # JythonMusic's Image class has overloaded constructors,
+      # but Python doesn't allow that.  We replicate an overload based on the
+      # data types of arg1 and arg2.
+      #
+      # (str, None) -> a filename for an image to load
+      # (str, int)  -> a filename for an image to load, scaled to a width
+      # (int, None) -> the width of a square, blank canvas
+      # (int, int)  -> the width and height of a blank canvas
+
+      self._display = Display()  # create a new, blank Display
+      self.read(arg1, arg2)      # read() handles loading the icon, plus setting the title and size of the Display
+
+   def show(self):
+      """
+      Shows the display window.
+      """
+      self._display.show()
+
+   def hide(self):
+      """
+      Hides the display window.
+      """
+      self._display.hide()
+
+   def getWidth(self):
+      """
+      Returns the display's canvas width (in pixels).
+      """
+      return self._display.getWidth()
+
+   def getHeight(self):
+      """
+      Returns the display's canvas height (in pixels).
+      """
+      return self._display.getHeight()
+
+   # pixel manipulation wrappers
+
+   def getPixel(self, col, row):
+      """
+      Returns the [r, g, b] color of a given pixel in the image.
+      """
+      return self._icon.getPixel(col, row)
+
+   def setPixel(self, col, row, RGBList):
+      """
+      Sets the [r, g, b] color of a given pixel in the image.
+      """
+      self._icon.setPixel(col, row, RGBList)
+
+   def getPixels(self):
+      """
+      Returns the [r, g, b] color of all pixels in the icon as a 2-dimensional array.
+      """
+      return self._icon.getPixels()
+
+   def setPixels(self, pixels):
+      """
+      Sets the [r, g, b] color of all pixels in the icon from a 2-dimensional array.
+      """
+      self._icon.setPixels(pixels)
+
+   def write(self, filename):
+      """
+      Saves the display's currently visible canvas to an image file.
+      The file format is determined by the filename extension (e.g. .png, .jpg).
+      """
+      self._display.save(filename)
+
+   def read(self, arg1, arg2=None):
+      """
+      Updates the image with a new filename.
+      arg1 and arg2 have the same overloaded behavior as Image's constructor.
+      (str, None) -> a filename for an image to load
+      (str, int)  -> a filename for an image to load, scaled to a width
+      (int, None) -> the width of a square, blank canvas
+      (int, int)  -> the width and height of a blank canvas
+      """
+      # first, load the icon
+      if isinstance(arg1, str):
+         # arg1 is a filename
+         title = arg1
+         icon  = Icon(arg1, arg2)  # load icon with optional resizing
+      else:
+         # arg1 is a image size
+         title = "Image"
+         icon  = Icon("", arg1, arg2)  # load blank icon, sized to given dimensions
+
+      # remove the previous icon, if needed
+      if self._icon is not None:
+         self._display.remove(self._icon)
+
+      # next, update the Display
+      width, height = icon.getSize()
+      self._display.setSize(width, height)
+      self._display.setTitle(title)
+
+      # finally, add new icon to the display
+      self._icon = icon
+      self._display.add(icon)
+
+
+###### Unit Tests ###################################
+
+if __name__ == "__main__":
+   pass

creativepython-1.1.0/src/image.py

@@ -1,70 +0,0 @@
-################################################################################
-# image.py       Version 1.0     30-Jan-2025
-# Taj Ballinger, Trevor Ritchie, and Bill Manaris
-#
-##############################################################
-##################
-
-from gui import Display, Icon
-
-class Image(Display):
-   """
-   Display window for rendering images.
-   """
-   def __init__(self, arg1, arg2=None):
-      """
-      Creates a new image display.
-      """
-      # JythonMusic's Image class has overloaded constructors,
-      # but Python doesn't allow that.  We replicate an overload based on the
-      # data types of arg1 and arg2.
-      #
-      # (str, None) -> a filename for an image to load
-      # (str, int)  -> a filename for an image to load, scaled to a width
-      # (int, None) -> the width of a square, blank canvas
-      # (int, int)  -> the width and height of a blank canvas
-
-      if isinstance(arg1, str):
-         # this is a filename
-         title = arg1
-         self._icon = Icon(arg1, arg2)  # load icon with optional parameter
-
-      else:
-         title = "Image"
-         self._icon = Icon("", arg1, arg2)  # load blank icon with given dimensions
-
-      width, height = self._icon.getSize()
-
-      Display.__init__(self, title, width, height)
-      self.add(self._icon)
-
-   # pixel manipulation wrappers
-
-   def getPixel(self, col, row):
-      """
-      Returns the [r, g, b] color of a given pixel in the image.
-      """
-      return self._icon.getPixel(col, row)
-
-   def setPixel(self, col, row, RGBList):
-      """
-      Sets the [r, g, b] color of a given pixel in the image.
-      """
-      self._icon.setPixel(col, row, RGBList)
-
-   def getPixels(self):
-      """
-      Returns the [r, g, b] color of all pixels in the icon as a 2-dimensional array.
-      """
-      return self._icon.getPixels()
-
-   def setPixels(self, pixels):
-      """
-      Sets the [r, g, b] color of all pixels in the icon from a 2-dimensional array.
-      """
-      self._icon.setPixels(pixels)
-
-###### Unit Tests ###################################
-
-if __name__ == "__main__":
-   pass