CreativePython 1.1.5__py3-none-any.whl → 1.1.6__py3-none-any.whl

CreativePython/GuiRenderer.py

@@ -624,7 +624,30 @@ class _QPolygonItem(_QtGraphicsItemEventMixin, QtWidgets.QGraphicsPolygonItem):
    pass
 
 class _QPixmapItem(_QtGraphicsItemEventMixin, QtWidgets.QGraphicsPixmapItem):
-   pass
+   _colorFilter = None   # (r, g, b, a) set by IconMirror._applyColor; None = no filter
+
+   def paint(self, painter, option, widget=None):
+      if self._colorFilter is None:
+         super().paint(painter, option, widget)
+         return
+
+      pixmap = self.pixmap()
+      if pixmap.isNull():
+         return
+
+      r, g, b, a = self._colorFilter
+      image = pixmap.toImage().convertToFormat(QtGui.QImage.Format.Format_ARGB32)
+
+      filtered = QtGui.QImage(image.size(), QtGui.QImage.Format.Format_ARGB32)
+      filtered.fill(QtCore.Qt.GlobalColor.transparent)
+
+      p = QtGui.QPainter(filtered)
+      p.drawImage(0, 0, image)
+      p.setCompositionMode(QtGui.QPainter.CompositionMode.CompositionMode_SourceOver)
+      p.fillRect(image.rect(), QtGui.QColor(r, g, b, a))
+      p.end()
+
+      painter.drawImage(self.offset(), filtered)
 
 class _QGroupItem(_QtGraphicsItemEventMixin, QtWidgets.QGraphicsItemGroup):
    pass
@@ -1688,15 +1711,12 @@ class _DrawableMirror:
       self._rotation     = 0
       self._toolTipText  = None
 
-      # GuiRenderer only handles commands that alter an object visually,
-      # or that rely on hit testing.  Everything else is handled in gui.py
+      # GuiRenderer only handles commands that alter an object visually.
+      # Hit testing (contains/intersects/encloses) is handled entirely in gui.py.
       self._commandHandlers = {
          'setPosition':      self._setPosition,
          'setSize':          self._setSize,
          'setRotation':      self._setRotation,
-         'contains':         self._contains,
-         'intersects':       self._intersects,
-         'encloses':         self._encloses,
          'setToolTipText':   self._setToolTipText,
          'show':             self._show,
          'hide':             self._hide,
@@ -1759,43 +1779,6 @@ class _DrawableMirror:
       self.qObject.prepareGeometryChange()
       self.qObject.setRotation(qtDegree)
 
-   # ── Hit testing ────────────────────────────────────────────────────────────
-
-   def _contains(self, args, responseId):
-      """Returns True if the point (x, y) is inside this item."""
-      x           = args.get('x', 0)
-      y           = args.get('y', 0)
-      globalPoint = QtCore.QPointF(x, y)
-      localPoint  = self.qObject.mapFromScene(globalPoint)
-      result      = self.qObject.contains(localPoint)
-      self.guiRenderer.sendResponse(responseId, [result])
-
-   def _intersects(self, args, responseId):
-      """Returns True if this item intersects another item."""
-      otherObjectId = args.get('otherObjectId')
-      otherMirror   = self.guiRenderer._objectRegistry.get(otherObjectId)
-      result        = False
-
-      if otherMirror is not None:
-         pathA  = self.qObject.mapToScene(self.qObject.shape())
-         pathB  = otherMirror.qObject.mapToScene(otherMirror.qObject.shape())
-         result = pathA.intersects(pathB)
-
-      self.guiRenderer.sendResponse(responseId, [result])
-
-   def _encloses(self, args, responseId):
-      """Returns True if this item fully encloses another item."""
-      otherObjectId = args.get('otherObjectId')
-      otherMirror   = self.guiRenderer._objectRegistry.get(otherObjectId)
-      result        = False
-
-      if otherMirror is not None:
-         pathA  = self.qObject.mapToScene(self.qObject.shape())
-         pathB  = otherMirror.qObject.mapToScene(otherMirror.qObject.shape())
-         result = pathA.contains(pathB)
-
-      self.guiRenderer.sendResponse(responseId, [result])
-
    # ── Visibility ─────────────────────────────────────────────────────────────
 
    def _show(self, args, responseId):
@@ -2405,6 +2388,7 @@ class PolygonMirror(_GraphicsMirror):
 # IconMirror  —  mirror of gui.py's Icon
 #######################################################################################
 
+
 class IconMirror(_GraphicsMirror):
    """
    Mirror of gui.py's Icon.  Backed by a QGraphicsPixmapItem.
@@ -2474,16 +2458,25 @@ class IconMirror(_GraphicsMirror):
          'getPixels': self._getPixels,
          'setPixels': self._setPixels,
          'write':     self._write,
+         'setAlpha':  self._setAlpha,
       })
 
    def _applyColor(self):
-      """No-op — QGraphicsPixmapItem has no pen or brush."""
-      pass
+      r, g, b, a = self._color
+      if [r, g, b, a] == [0, 0, 0, 0]:
+         self.qObject._colorFilter = None
+      else:
+         self.qObject._colorFilter = (r, g, b, a)
+      self.qObject.update()
 
    def _applyThickness(self):
       """No-op — QGraphicsPixmapItem has no pen or brush."""
       pass
 
+   def _setAlpha(self, args, responseId):
+      alpha = args.get('alpha', 255)
+      self.qObject.setOpacity(alpha / 255.0)
+
    # ── Size ───────────────────────────────────────────────────────────────────
 
    def _getSize(self, args, responseId):
@@ -2922,8 +2915,7 @@ class _ControlMirror(_DrawableMirror):
    - dimensions: setRect(), setPath(), etc. -> setFixedSize()
    - color: [r, g, b] -> stylesheets
 
-   Controls have no hit-testing (contains/intersects/encloses) because QWidgets
-   handle their own input directly.
+   Controls handle their own input directly via Qt's widget event system.
 
    Concrete classes must:
      1. Call super().__init__(objectId, guiRenderer, args) first.
@@ -2964,48 +2956,6 @@ class _ControlMirror(_DrawableMirror):
    def _setRotation(self, args, responseId):
       pass   # Controls cannot be rotated; gui.py warns at the call site
 
-   # ── Hit testing ────────────────────────────────────────────────────────────
-
-   def _contains(self, args, responseId):
-      """Returns True if the point (x, y) is inside this widget's bounding box."""
-      x      = args.get('x', 0)
-      y      = args.get('y', 0)
-      rect   = QtCore.QRectF(self.qObject.geometry())
-      result = rect.contains(QtCore.QPointF(x, y))
-      self.guiRenderer.sendResponse(responseId, [result])
-
-   def _intersects(self, args, responseId):
-      """Returns True if this widget's bounding box intersects another item."""
-      otherObjectId = args.get('otherObjectId')
-      otherMirror   = self.guiRenderer._objectRegistry.get(otherObjectId)
-      result        = False
-
-      if otherMirror is not None:
-         rectA = QtCore.QRectF(self.qObject.geometry())
-         if isinstance(otherMirror, _ControlMirror):
-            rectB = QtCore.QRectF(otherMirror.qObject.geometry())
-         else:
-            rectB = otherMirror.qObject.sceneBoundingRect()
-         result = rectA.intersects(rectB)
-
-      self.guiRenderer.sendResponse(responseId, [result])
-
-   def _encloses(self, args, responseId):
-      """Returns True if this widget's bounding box fully encloses another item."""
-      otherObjectId = args.get('otherObjectId')
-      otherMirror   = self.guiRenderer._objectRegistry.get(otherObjectId)
-      result        = False
-
-      if otherMirror is not None:
-         rectA = QtCore.QRectF(self.qObject.geometry())
-         if isinstance(otherMirror, _ControlMirror):
-            rectB = QtCore.QRectF(otherMirror.qObject.geometry())
-         else:
-            rectB = otherMirror.qObject.sceneBoundingRect()
-         result = rectA.contains(rectB)
-
-      self.guiRenderer.sendResponse(responseId, [result])
-
    # ── Size ───────────────────────────────────────────────────────────────────
 
    def _getSize(self, args, responseId):

{creativepython-1.1.5.dist-info → creativepython-1.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 1.1.5
+Version: 1.1.6
 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.5.dist-info → creativepython-1.1.6.dist-info}/RECORD

@@ -1,14 +1,14 @@
-gui.py,sha256=U_mAXHFJeSyDPF0lz3vs2AExwsOEdK_slAImKKRm9eE,136824
+gui.py,sha256=io7p7aYK9EqcP9lBbBO3CBycaAvaHs3IxNw5BrOhhgs,154434
 iannix.py,sha256=jlBJhPzBcIl2iayG01ldoslAytxYOvP3z_vN-EgiJA4,17188
 image.py,sha256=wohpTTZH6QzN3wRfXI5ac7VTRsOKcwqk8_d3yha8oDw,3763
 markov.py,sha256=VhTXZfDDHETj6KhriFmOLHKNjgx08cWZvpLECuGRTG0,24653
-midi.py,sha256=g5qezyjD--oj92uUR7g91V4-IiYWhjrHQuIwV8XfQR8,27282
-music.py,sha256=H-4c03IZBmjaLeio6ZQTl0BZGGU-Ri6GdiOj2L-mmJI,268534
-osc.py,sha256=yUIIvPZmEmaxnpP2Q9FBh-sCL9aXR-qFDQk4N7998vk,8553
+midi.py,sha256=avVY6dyTHbFazt10w2Uy0zUPXvRYleZM2O89gDX3-h4,27203
+music.py,sha256=VyYcjxEIRYG7YWFzBIbSFaR4mVcO2fHDZnkdCh0G4sM,268532
+osc.py,sha256=GtjWV5LD4xiW9Yen3PzFYstWHhEZ_QyrKunAu-VsPrc,8353
 timer.py,sha256=uQ1BHWTjZ6DpJo-leGhxgOJcVcd1Lj0jvQQodXx1kw4,16341
 zipf.py,sha256=J6fWwUYz88LFAwanc0TmXJlU7VtpBM24_Rw5XJTOn9c,40312
 CreativePython/GuiHandler.py,sha256=ONnxhqivBrzCHQv7GcE4vkMgnONbuXXq7Fwe0Au5QPs,30974
-CreativePython/GuiRenderer.py,sha256=jqoKD2XSNeDJ4lAmQXfaEbtVrsL-4LublHhbUHbJRkk,139445
+CreativePython/GuiRenderer.py,sha256=XUXhPjtLRUA3D0Q05ZP85gb3gPqg8Zvs732bSYBOVo4,136843
 CreativePython/RealtimeAudioPlayer.py,sha256=tjqBjSOvSvH1kP0t6q35xsbKHPr0wuLUvGdxdWAY73E,44590
 CreativePython/__init__.py,sha256=bT1nZ-Fp8-7uiKqhVdnFeOwL-8Jps2rvE6BfoOE8fZ0,451
 CreativePython/notationRenderer.py,sha256=2KIMvInNLEUZyn_r1KMmyt7X2XDrfekVkggFeHLRu1M,35440
@@ -77,9 +77,9 @@ CreativePython/nevmuse/utilities/CSVWriter.py,sha256=k2GccvzD5IwdkmFdN5qtRA2qZX1
 CreativePython/nevmuse/utilities/PowerLawRandom.py,sha256=WIEI-p8wiiWhkkBR5pO9gJ2TwxZBw453T_xXzCNdKPY,3752
 CreativePython/nevmuse/utilities/__init__.py,sha256=pAGIMMGfLvR2DQfxr8qkfKQJ-4fIkVqlhnGK657JPL8,166
 bin/libportaudio.2.dylib,sha256=ooJlm7QeL7jYzc1c8YMmH-C8PhYHwDvBJZkNDVPFRbE,286592
-creativepython-1.1.5.dist-info/licenses/LICENSE,sha256=tz38qDa5RhHMqzZR1Q5QafqWdXn_EhheXYBP7FjgtEM,1992
-creativepython-1.1.5.dist-info/licenses/LICENSE-PSF,sha256=JN1jUPIsEUH1mq3AXxet-b1IdhAr-XzscXBZiz74c9c,3371
-creativepython-1.1.5.dist-info/METADATA,sha256=jesD86ZrXoIlpqmWVilNd9KtPsNsQEeP9UmEfMZEuzE,8703
-creativepython-1.1.5.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-creativepython-1.1.5.dist-info/top_level.txt,sha256=PzvvUyy-3YzTedVGnLS02ju1TCMuo76h1LuVd8XvHhA,69
-creativepython-1.1.5.dist-info/RECORD,,
+creativepython-1.1.6.dist-info/licenses/LICENSE,sha256=tz38qDa5RhHMqzZR1Q5QafqWdXn_EhheXYBP7FjgtEM,1992
+creativepython-1.1.6.dist-info/licenses/LICENSE-PSF,sha256=JN1jUPIsEUH1mq3AXxet-b1IdhAr-XzscXBZiz74c9c,3371
+creativepython-1.1.6.dist-info/METADATA,sha256=MGKp9oy0r3G1TsnJxa2M9WtRlP_4X7bGv-05HyB2z0s,8703
+creativepython-1.1.6.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+creativepython-1.1.6.dist-info/top_level.txt,sha256=PzvvUyy-3YzTedVGnLS02ju1TCMuo76h1LuVd8XvHhA,69
+creativepython-1.1.6.dist-info/RECORD,,

gui.py

@@ -529,9 +529,14 @@ class _Interactable:
    def _registerCallback(self, eventType, action):
       """
       Registers a single event callback via IPC to the renderer process.
+      Skips the IPC sendCommand if the event type is already registered,
+      since the renderer's _registeredEvents is a set (idempotent) and only
+      the callback stored locally needs updating.
       """
+      alreadyRegistered = eventType in self._actionList
       self._actionList[eventType] = action
-      _handler().registerEvent(self._objectId, eventType, action)
+      if not alreadyRegistered:
+         _handler().registerEvent(self._objectId, eventType, action)
 
    def onMouseClick(self, action):
       """
@@ -1123,6 +1128,155 @@ class Display(_Interactable):
       """
       self.drawLabel(text, x, y, color, font)
 
+#######################################################################################
+# Geometry helpers — used by contains(), intersects(), encloses()
+#######################################################################################
+
+def _pointInPolygon(x, y, points):
+   """
+   Returns True if (x, y) lies inside the closed polygon defined by points.
+   Uses the ray-casting (even-odd) algorithm.  Points are (x, y) tuples.
+   """
+   inside = False
+   n = len(points)
+   j = n - 1
+   for i in range(n):
+      xi, yi = points[i]
+      xj, yj = points[j]
+      if ((yi > y) != (yj > y)) and (x < (xj - xi) * (y - yi) / (yj - yi) + xi):
+         inside = not inside
+      j = i
+   return inside
+
+
+def _pointToSegmentDistSq(px, py, x1, y1, x2, y2):
+   """
+   Returns the squared distance from point (px, py) to segment (x1,y1)-(x2,y2).
+   """
+   dx, dy = x2 - x1, y2 - y1
+   lenSq  = dx * dx + dy * dy
+   if lenSq == 0:
+      return (px - x1) ** 2 + (py - y1) ** 2
+   t     = max(0.0, min(1.0, ((px - x1) * dx + (py - y1) * dy) / lenSq))
+   nearX = x1 + t * dx
+   nearY = y1 + t * dy
+   return (px - nearX) ** 2 + (py - nearY) ** 2
+
+
+def _pointNearPath(x, y, points, halfThickness):
+   """
+   Returns True if (x, y) is within halfThickness of any segment in points.
+   Used for open paths (Polyline, Arc OPEN) where the interior has no fill.
+   """
+   threshSq = halfThickness * halfThickness
+   result   = False
+   i        = 0
+   while not result and i < len(points) - 1:
+      x1, y1 = points[i]
+      x2, y2 = points[i + 1]
+      result = _pointToSegmentDistSq(x, y, x1, y1, x2, y2) <= threshSq
+      i += 1
+   return result
+
+
+def _segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4):
+   """
+   Returns True if segment (x1,y1)-(x2,y2) intersects segment (x3,y3)-(x4,y4).
+   Uses parametric intersection; parallel or collinear segments return False.
+   """
+   d1x, d1y = x2 - x1, y2 - y1
+   d2x, d2y = x4 - x3, y4 - y3
+   cross     = d1x * d2y - d1y * d2x
+   if cross == 0:
+      result = False   # parallel or collinear
+   else:
+      t      = ((x3 - x1) * d2y - (y3 - y1) * d2x) / cross
+      u      = ((x3 - x1) * d1y - (y3 - y1) * d1x) / cross
+      result = 0.0 <= t <= 1.0 and 0.0 <= u <= 1.0
+   return result
+
+
+def _polygonEdgesIntersect(polyA, polyB):
+   """
+   Returns True if any edge of polyA crosses any edge of polyB.
+   Each polygon is a list of (x, y) tuples; edges wrap from last to first.
+   """
+   nA     = len(polyA)
+   nB     = len(polyB)
+   result = False
+   i      = 0
+   while not result and i < nA:
+      x1, y1 = polyA[i]
+      x2, y2 = polyA[(i + 1) % nA]
+      j      = 0
+      while not result and j < nB:
+         x3, y3 = polyB[j]
+         x4, y4 = polyB[(j + 1) % nB]
+         result = _segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)
+         j += 1
+      i += 1
+   return result
+
+
+def _polygonsIntersect(polyA, polyB):
+   """
+   Returns True if two closed polygons overlap.
+   Covers three cases: edges crossing, A fully inside B, and B fully inside A.
+   """
+   result = (_polygonEdgesIntersect(polyA, polyB) or
+             _pointInPolygon(*polyA[0], polyB)    or
+             _pointInPolygon(*polyB[0], polyA))
+   return result
+
+
+def _openPathIntersectsPolygon(pathPoints, polyPoints):
+   """
+   Returns True if an open path intersects a closed polygon.
+   Checks whether any segment of the path crosses a polygon edge, or whether
+   any path point lies inside the polygon (path running through the interior).
+   """
+   nPath  = len(pathPoints)
+   nPoly  = len(polyPoints)
+   result = False
+   i      = 0
+   while not result and i < nPath - 1:
+      x1, y1 = pathPoints[i]
+      x2, y2 = pathPoints[i + 1]
+      j      = 0
+      while not result and j < nPoly:
+         x3, y3 = polyPoints[j]
+         x4, y4 = polyPoints[(j + 1) % nPoly]
+         result = _segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)
+         j += 1
+      i += 1
+   i = 0
+   while not result and i < nPath:
+      result = _pointInPolygon(*pathPoints[i], polyPoints)
+      i += 1
+   return result
+
+
+def _pathsIntersect(pathA, pathB):
+   """
+   Returns True if any segment of open path A crosses any segment of open path B.
+   """
+   nA     = len(pathA)
+   nB     = len(pathB)
+   result = False
+   i      = 0
+   while not result and i < nA - 1:
+      x1, y1 = pathA[i]
+      x2, y2 = pathA[i + 1]
+      j      = 0
+      while not result and j < nB - 1:
+         x3, y3 = pathB[j]
+         x4, y4 = pathB[j + 1]
+         result = _segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)
+         j += 1
+      i += 1
+   return result
+
+
 #######################################################################################
 # Drawable - items that can be added to a Display
 #######################################################################################
@@ -1150,6 +1304,7 @@ class _Drawable(_Interactable):
       self._anchorX        = None  # last used global rotation anchor (None = center)
       self._anchorY        = None  # ...
       self._toolTipText    = None  # text to Display on mouse over (None == disabled)
+      self._cachedBoundary = None  # lazily computed by _getBoundary(), cleared by _invalidateBoundary()
 
       # renderer visibility toggle
       # only used by Toggle and Push, but doesn't hurt to have as part of Drawable
@@ -1170,6 +1325,7 @@ class _Drawable(_Interactable):
       """
       self._localCornerX = localX
       self._localCornerY = localY
+      self._invalidateBoundary()
 
       _handler().sendCommand('setPosition', self._objectId, {'x': localX, 'y': localY})
       if isinstance(self._parent, Group):
@@ -1257,8 +1413,9 @@ class _Drawable(_Interactable):
          y2 =  (height / 2)
          corners  = [(x1, y1), (x2, y1), (x2, y2), (x1, y2)]
 
-         rotatedXs = [centerX + (px * cos) - (py * sin) for px, py in corners]
-         rotatedYs = [centerY + (px * sin) + (py * cos) for px, py in corners]
+         # visual CCW: x' = dx*cos + dy*sin, y' = -dx*sin + dy*cos
+         rotatedXs = [centerX + (px * cos) + (py * sin) for px, py in corners]
+         rotatedYs = [centerY - (px * sin) + (py * cos) for px, py in corners]
 
          # get bounding box dimensions
          x      = min(rotatedXs)
@@ -1268,6 +1425,28 @@ class _Drawable(_Interactable):
 
       return x, y, width, height
 
+   def _computeBoundary(self, n=32):
+      """
+      Computes this shape's boundary as a list of (x, y) tuples in global coordinates.
+      Default returns the 4 corners of the axis-aligned bounding box.
+      Subclasses override this for their exact geometry.
+      """
+      x, y, w, h = self._getBoundingBox()
+      return [(x, y), (x + w, y), (x + w, y + h), (x, y + h)]
+
+   def _getBoundary(self, n=32):
+      """
+      Returns this shape's boundary, computing and caching it on first call.
+      Invalidated by any change to position, size, or rotation.
+      """
+      if self._cachedBoundary is None:
+         self._cachedBoundary = self._computeBoundary(n)
+      return self._cachedBoundary
+
+   def _invalidateBoundary(self):
+      """Clears the cached boundary so it is recomputed on next access."""
+      self._cachedBoundary = None
+
    def _rotatePoints(self, xPoints, yPoints):
       """
       Rotates a list of global-coordinate points around this item's center.
@@ -1404,6 +1583,7 @@ class _Drawable(_Interactable):
       # update internal coordinates
       self._width  = localWidth
       self._height = localHeight
+      self._invalidateBoundary()
 
       # update rendering canvas
       _handler().sendCommand('setSize', self._objectId, {'width': localWidth, 'height': localHeight})
@@ -1492,6 +1672,7 @@ class _Drawable(_Interactable):
 
       # update internal rotation
       self._rotation = rotation
+      self._invalidateBoundary()
 
       # update the renderer
       _handler().sendCommand('setRotation', self._objectId, {
@@ -1500,38 +1681,67 @@ class _Drawable(_Interactable):
 
    # ── Hit testing ────────────────────────────────────────────────────────────
 
+   def _isOpen(self):
+      """
+      Returns True if this shape is an open path (no interior).
+      Open shapes use proximity-to-path tests rather than point-in-polygon.
+      Overridden by Polyline (always open) and Arc (open when style == OPEN).
+      """
+      return False
+
    def contains(self, x, y):
       """
       Returns True if the point (x, y) is inside the item.
+      Uses ray-casting on the shape's boundary polygon.
       """
-      result = _handler().sendQuery('contains', self._objectId, {'x': x, 'y': y})
-      return result[0]
+      return _pointInPolygon(x, y, self._getBoundary())
 
    def intersects(self, other):
       """
-      Returns True if this item intersects the other item.
+      Returns True if this item overlaps the other item.
+      Dispatches to the appropriate algorithm based on whether each shape is
+      an open path (Polyline, Arc OPEN) or a closed shape (everything else).
       """
-      result = None
-
       if not isinstance(other, _Drawable):
          raise TypeError(f'{type(self).__name__}.intersects(): other should be a Drawable object (it was {type(other).__name__})')
+
+      # AABB pre-check: if bounding boxes don't overlap, nothing can intersect.
+      ax, ay, aw, ah = self._getBoundingBox()
+      bx, by, bw, bh = other._getBoundingBox()
+      if ax + aw < bx or bx + bw < ax or ay + ah < by or by + bh < ay:
+         result = False
       else:
-         response = _handler().sendQuery('intersects', self._objectId, {'otherObjectId': other._objectId})
-         result = response[0]
+         boundaryA = self._getBoundary()
+         boundaryB = other._getBoundary()
+         selfOpen  = self._isOpen()
+         otherOpen = other._isOpen()
+
+         if not selfOpen and not otherOpen:
+            result = _polygonsIntersect(boundaryA, boundaryB)
+         elif selfOpen and not otherOpen:
+            result = _openPathIntersectsPolygon(boundaryA, boundaryB)
+         elif not selfOpen and otherOpen:
+            result = _openPathIntersectsPolygon(boundaryB, boundaryA)
+         else:
+            result = _pathsIntersect(boundaryA, boundaryB)
 
       return result
 
    def encloses(self, other):
       """
-      Returns True if this item fully encloses the other item.
+      Returns True if this item fully contains the other item.
+      An open path has no interior and cannot enclose anything.
+      Otherwise, checks that every point of other's boundary lies inside self.
       """
-      result = None
-
       if not isinstance(other, _Drawable):
          raise TypeError(f'{type(self).__name__}.encloses(): other should be a Drawable object (it was {type(other).__name__})')
+
+      if self._isOpen():
+         result = False
       else:
-         response = _handler().sendQuery('encloses', self._objectId, {'otherObjectId': other._objectId})
-         result = response[0]
+         boundaryA = self._getBoundary()
+         boundaryB = other._getBoundary()
+         result    = all(_pointInPolygon(px, py, boundaryA) for px, py in boundaryB)
 
       return result
 
@@ -1601,6 +1811,21 @@ class _Graphics(_Drawable):
       self._color = [r, g, b, a]
       _handler().sendCommand('setColor', self._objectId, {'color': [r, g, b, a]})
 
+   # ── Alpha ────────────────────────────────────────────────────────────────
+
+   def getAlpha(self):
+      """
+      Returns the item's transparency (0-255, where 0 is fully transparent).
+      """
+      return self._color[3]
+
+   def setAlpha(self, alpha):
+      """
+      Sets the item's transparency (0-255, where 0 is fully transparent).
+      """
+      self._color[3] = max(0, min(255, int(alpha)))
+      _handler().sendCommand('setColor', self._objectId, {'color': self._color})
+
    # ── Fill ────────────────────────────────────────────────────────────────
 
    def getFill(self):
@@ -1694,6 +1919,16 @@ class Rectangle(_Graphics):
       xPoints, yPoints = self._getEndpoints()
       return self._rotatePoints(xPoints, yPoints)
 
+   # ── Boundary ───────────────────────────────────────────────────────────────
+
+   def _computeBoundary(self, n=32):
+      """
+      Computes the 4 rotated corners of the rectangle as (x, y) tuples in global
+      coordinates.  Rotation is applied around the rectangle's center.
+      """
+      xPoints, yPoints = self.getEndpoints()
+      return list(zip(xPoints, yPoints))
+
 
 class Oval(_Graphics):
    """
@@ -1734,6 +1969,38 @@ class Oval(_Graphics):
       thickness = self.getThickness()
       return f'Oval(x1 = {x1}, y1 = {y1}, x2 = {x2}, y2 = {y2}, color = {color}, fill = {fill}, thickness = {thickness}, rotation = {rotation})'
 
+   # ── Boundary ───────────────────────────────────────────────────────────────
+
+   def _computeBoundary(self, n=32):
+      """
+      Computes n points around the ellipse boundary as (x, y) tuples in global
+      coordinates, with rotation applied around the ellipse's center.
+      Circle inherits this; its rotation is always 0 so the rotation branch
+      is never taken.
+      """
+      gx, gy = self._getGlobalCorner()
+      cx     = gx + self._width  / 2
+      cy     = gy + self._height / 2
+      rx     = self._width  / 2
+      ry     = self._height / 2
+
+      if self._rotation != 0:
+         rad = np.radians(self._rotation)
+         cos = np.cos(rad)
+         sin = np.sin(rad)
+         points = []
+         for i in range(n):
+            t  = 2 * np.pi * i / n
+            dx = rx * np.cos(t)
+            dy = ry * np.sin(t)
+            # visual CCW rotation: x' = dx*cos + dy*sin, y' = -dx*sin + dy*cos
+            points.append((cx + dx * cos + dy * sin,
+                           cy - dx * sin + dy * cos))
+         return points
+      else:
+         return [(cx + rx * np.cos(2 * np.pi * i / n),
+                  cy + ry * np.sin(2 * np.pi * i / n)) for i in range(n)]
+
 
 class Circle(Oval):
    """
@@ -1794,6 +2061,29 @@ class Circle(Oval):
       diameter = radius * 2
       self.setWidth(diameter)
 
+   # ── Hit testing ────────────────────────────────────────────────────────────
+
+   def intersects(self, other):
+      """
+      Returns True if this circle overlaps the other item.
+      For Circle-Circle pairs uses an exact O(1) distance check.
+      Falls back to the base-class AABB + polygon path for all other pairings.
+      """
+      if isinstance(other, Circle):
+         ax, ay  = self._getGlobalCorner()
+         bx, by  = other._getGlobalCorner()
+         selfCX  = ax + self._width  / 2
+         selfCY  = ay + self._height / 2
+         otherCX = bx + other._width  / 2
+         otherCY = by + other._height / 2
+         radiiSum = (self._width + other._width) / 2
+         dx       = selfCX - otherCX
+         dy       = selfCY - otherCY
+         result   = dx * dx + dy * dy <= radiiSum * radiiSum
+      else:
+         result = _Drawable.intersects(self, other)
+      return result
+
 
 class Point(Circle):
    """
@@ -1859,6 +2149,78 @@ class Arc(_Graphics):
       thickness  = self.getThickness()
       return f'Arc(x1 = {x1}, y1 = {y1}, x2 = {x2}, y2 = {y2}, startAngle = {startAngle}, endAngle = {endAngle}, style = {style}, color = {color}, fill = {fill}, thickness = {thickness}, rotation = {rotation})'
 
+   # ── Boundary ───────────────────────────────────────────────────────────────
+
+   def _computeBoundary(self, n=32):
+      """
+      Computes boundary points for the arc as (x, y) tuples in global coordinates,
+      with any outer rotation applied.
+
+      Angles are in degrees: 0 = east, positive = CCW visual.  The arc sweeps
+      from startAngle toward endAngle following the same path the renderer draws.
+
+      Returned point layout by style:
+        OPEN  — n+1 points along the arc curve only (open path).
+        CHORD — n+1 arc curve points; first and last are implicitly connected.
+        PIE   — center point followed by n+1 arc curve points; last connects
+                back to center to close the pie slice.
+
+      ArcCircle inherits this implementation.
+      """
+      gx, gy = self._getGlobalCorner()
+      cx     = gx + self._width  / 2
+      cy     = gy + self._height / 2
+      rx     = self._width  / 2
+      ry     = self._height / 2
+
+      # The renderer uses arcWidth = -(endAngle - startAngle) and passes it to
+      # Qt as the sweep, so the arc steps from startAngle by that delta.
+      # Replicating that here: t steps from startAngle_rad toward
+      # startAngle_rad + sweep_rad, where sweep = -(endAngle - startAngle).
+      startRad = np.radians(self._startAngle)
+      sweepRad = np.radians(-(self._endAngle - self._startAngle))
+
+      # Qt point formula for CCW-convention angles in a Y-down screen:
+      #   x = cx + rx * cos(t),  y = cy - ry * sin(t)
+      arcPoints = []
+      for i in range(n + 1):
+         t = startRad + sweepRad * i / n
+         arcPoints.append((cx + rx * np.cos(t),
+                           cy - ry * np.sin(t)))
+
+      if self._style == PIE:
+         points = [(cx, cy)] + arcPoints
+      else:
+         points = arcPoints   # OPEN and CHORD share the same point list;
+                              # CHORD's implicit closing segment is handled
+                              # by the polygon hit-test closing first-to-last.
+
+      # Apply outer rotation around the shape's center if set
+      if self._rotation != 0:
+         rad = np.radians(self._rotation)
+         cos = np.cos(rad)
+         sin = np.sin(rad)
+         points = [(cx + (px - cx) * cos + (py - cy) * sin,
+                    cy - (px - cx) * sin + (py - cy) * cos)
+                   for px, py in points]
+
+      return points
+
+   # ── Hit testing ────────────────────────────────────────────────────────────
+
+   def _isOpen(self):
+      return self._style == OPEN
+
+   def contains(self, x, y):
+      """
+      Returns True if (x, y) is inside the arc shape.
+      PIE and CHORD styles form closed polygons and use ray-casting.
+      OPEN style has no interior, so it uses a proximity-to-path check instead.
+      """
+      if self._isOpen():
+         return _pointNearPath(x, y, self._getBoundary(), max(self._thickness, 1) / 2)
+      return _pointInPolygon(x, y, self._getBoundary())
+
    # ── ArcWidth ────────────────────────────────────────────────────────────────
 
    def _setArcWidth(self, arcWidth):
@@ -1998,6 +2360,39 @@ class Line(_Graphics):
       xPoints, yPoints = self._getEndpoints()
       return self._rotatePoints(xPoints, yPoints)
 
+   # ── Boundary ───────────────────────────────────────────────────────────────
+
+   def _computeBoundary(self, n=32):
+      """
+      Computes the 4 corners of a thin rectangle enclosing the line as (x, y)
+      tuples in global coordinates.  The rectangle's width equals the line length
+      and its height equals the line's thickness (minimum 1), giving accurate
+      hit-test coverage for both thick and thin lines.  Any rotation is already
+      baked into the post-rotation endpoints returned by getEndpoints().
+      """
+      xs, ys = self.getEndpoints()
+      x1, x2 = xs
+      y1, y2 = ys
+
+      dx = x2 - x1
+      dy = y2 - y1
+      length = np.sqrt(dx * dx + dy * dy)
+
+      if length == 0:
+         return [(x1, y1)]
+
+      # unit vector along the line and its CCW perpendicular
+      ux, uy  = dx / length, dy / length
+      px, py  = -uy, ux
+      halfT   = max(self._thickness, 1) / 2
+
+      return [
+         (x1 + px * halfT, y1 + py * halfT),
+         (x1 - px * halfT, y1 - py * halfT),
+         (x2 - px * halfT, y2 - py * halfT),
+         (x2 + px * halfT, y2 + py * halfT),
+      ]
+
    # ── Length ────────────────────────────────────────────────────────────────
 
    def getLength(self):
@@ -2134,6 +2529,30 @@ class Polyline(_Graphics):
       xPoints, yPoints = self._getEndpoints()
       return self._rotatePoints(xPoints, yPoints)
 
+   # ── Boundary ───────────────────────────────────────────────────────────────
+
+   def _computeBoundary(self, n=32):
+      """
+      Computes the polyline's joint points as (x, y) tuples in global coordinates,
+      with rotation applied.  Forms an open path — the last point does not
+      implicitly connect back to the first.
+      """
+      xPoints, yPoints = self.getEndpoints()
+      return list(zip(xPoints, yPoints))
+
+   # ── Hit testing ────────────────────────────────────────────────────────────
+
+   def _isOpen(self):
+      return True
+
+   def contains(self, x, y):
+      """
+      Returns True if (x, y) lies within half the stroke thickness of any
+      segment.  A Polyline has no interior, so proximity to the path is the
+      correct containment test.
+      """
+      return _pointNearPath(x, y, self._getBoundary(), max(self._thickness, 1) / 2)
+
 
 class Polygon(_Graphics):
    """
@@ -2208,6 +2627,17 @@ class Polygon(_Graphics):
       xPoints, yPoints = self._getEndpoints()
       return self._rotatePoints(xPoints, yPoints)
 
+   # ── Boundary ───────────────────────────────────────────────────────────────
+
+   def _computeBoundary(self, n=32):
+      """
+      Computes the polygon's vertices as (x, y) tuples in global coordinates,
+      with rotation applied.  Forms a closed boundary (first point implicitly
+      connects back to last).
+      """
+      xPoints, yPoints = self.getEndpoints()
+      return list(zip(xPoints, yPoints))
+
 
 class Icon(_Graphics):
    """
@@ -2223,6 +2653,7 @@ class Icon(_Graphics):
 
       self._filename = filename
       self._rotation = rotation
+      self._alpha    = 255
 
       # width/height are resolved by the renderer (from the actual pixmap)
       # For now, cache what the user provided; the renderer will resolve None values.
@@ -2254,6 +2685,23 @@ class Icon(_Graphics):
       rotation      = self.getRotation()
       return f'Icon(filename = "{filename}", width = {width}, height = {height}, rotation = {rotation})'
 
+   # ── Alpha ────────────────────────────────────────────────────────────────
+
+   def getAlpha(self):
+      """
+      Returns the icon's global transparency (0-255, where 0 is fully transparent).
+      This is independent of the color filter set by setColor().
+      """
+      return self._alpha
+
+   def setAlpha(self, alpha):
+      """
+      Sets the icon's global transparency (0-255, where 0 is fully transparent).
+      This is independent of the color filter set by setColor().
+      """
+      self._alpha = max(0, min(255, int(alpha)))
+      _handler().sendCommand('setAlpha', self._objectId, {'alpha': self._alpha})
+
    # ── Save ────────────────────────────────────────────────────────────────
 
    def save(self, filename, width=None, height=None):

midi.py

@@ -62,8 +62,8 @@ notesCurrentlyPlaying = []   # (pitch, channel) tuples; prevents early note-off
 # Usage:
 #   midiIn = MidiIn()
 #
-#   def onEvent(msgType, msgChannel, msgData1, msgData2):
-#      print(msgType, msgChannel, msgData1, msgData2)
+#   def onEvent(eventType, channel, data1, data2):
+#      print(eventType, channel, data1, data2)
 #
 #   midiIn.onInput(ALL_EVENTS, onEvent)
 
@@ -411,54 +411,54 @@ class MidiOut:
                start     = int(startTime)
                duration  = int(note.getLength() * FACTOR)
                startTime += note.getDuration() * FACTOR
-               velocity  = note.getDynamic()
+               dynamic   = note.getDynamic()
 
                if frequency != REST:
-                  noteList.append((start, duration, frequency, velocity, channel, instrument, panning))
+                  noteList.append((start, duration, frequency, dynamic, channel, instrument, panning))
 
       # sort by start time so chords (same start time, duration=0) sort before their anchor note
       noteList.sort()
 
       # schedule all notes; chords are sequences of duration=0 notes followed by one note with the real duration
       chordNotes = []
-      for start, duration, pitch, velocity, channel, instrument, panning in noteList:
+      for start, duration, pitch, dynamic, channel, instrument, panning in noteList:
          self.setInstrument(instrument, channel)
 
          if duration == 0:   # chord member — collect it
-            chordNotes.append([start, duration, pitch, velocity, channel, panning])
+            chordNotes.append([start, duration, pitch, dynamic, channel, panning])
 
          elif chordNotes == []:   # regular solo note
-            self.note(pitch, start, duration, velocity, channel, panning)
+            self.note(pitch, start, duration, dynamic, channel, panning)
 
          else:   # final note of a chord — schedule all collected chord members with this duration
-            chordNotes.append([start, duration, pitch, velocity, channel, panning])
-            for start, _, pitch, velocity, channel, panning in chordNotes:
-               self.note(pitch, start, duration, velocity, channel, panning)
+            chordNotes.append([start, duration, pitch, dynamic, channel, panning])
+            for start, _, pitch, dynamic, channel, panning in chordNotes:
+               self.note(pitch, start, duration, dynamic, channel, panning)
             chordNotes = []
 
 
-   def noteOn(self, pitch, velocity=100, channel=0, panning=-1):
+   def noteOn(self, pitch, dynamic=100, channel=0, panning=-1):
       """Sends NOTE_ON for 'pitch' (MIDI int 0-127 or Hz float) on 'channel'."""
 
       if isinstance(pitch, int) and (0 <= pitch <= 127):
          if panning != -1:
             self.sendMidiMessage(CONTROL_CHANGE, channel, 10, panning)
-         self.sendMidiMessage(NOTE_ON, channel, pitch, velocity)
+         self.sendMidiMessage(NOTE_ON, channel, pitch, dynamic)
          notesCurrentlyPlaying.append((pitch, channel))
 
       elif isinstance(pitch, float):
-         self.frequencyOn(pitch, velocity, channel, panning)
+         self.frequencyOn(pitch, dynamic, channel, panning)
 
       else:
          print(f"MidiOut.noteOn(): Unrecognized pitch {pitch}, expected int 0-127 or float Hz 8.17-12600.0.")
 
 
-   def frequencyOn(self, frequency, velocity=100, channel=0, panning=-1):
+   def frequencyOn(self, frequency, dynamic=100, channel=0, panning=-1):
       """Sends NOTE_ON for 'frequency' (in Hz) on 'channel', applying pitch bend for microtones."""
       if isinstance(frequency, float) and (8.17 <= frequency <= 12600.0):
          pitch, bend = freqToNote(frequency)
          notesCurrentlyPlaying.append((pitch, channel))
-         self.noteOnPitchBend(pitch, bend, velocity, channel, panning)
+         self.noteOnPitchBend(pitch, bend, dynamic, channel, panning)
       else:
          print(f"MidiOut.frequencyOn(): Invalid frequency {frequency}, expected float Hz 8.17-12600.0.")
 
@@ -497,16 +497,16 @@ class MidiOut:
          print(f"MidiOut.frequencyOff(): Invalid frequency {frequency}, expected float Hz 8.17-12600.0.")
 
 
-   def note(self, pitch, start, duration, velocity=100, channel=0, panning=-1):
+   def note(self, pitch, start, duration, dynamic=100, channel=0, panning=-1):
       """Schedules a note to start at 'start' ms from now and last 'duration' ms."""
-      Timer(start,          self.noteOn,  [pitch, velocity, channel, panning], False).start()
-      Timer(start+duration, self.noteOff, [pitch, channel],                    False).start()
+      Timer(start,          self.noteOn,  [pitch, dynamic, channel, panning], False).start()
+      Timer(start+duration, self.noteOff, [pitch, channel],                   False).start()
 
 
-   def frequency(self, frequency, start, duration, velocity=100, channel=0, panning=-1):
+   def frequency(self, frequency, start, duration, dynamic=100, channel=0, panning=-1):
       """Schedules a frequency (in Hz) to start at 'start' ms from now and last 'duration' ms."""
-      Timer(start,          self.frequencyOn,  [frequency, velocity, channel, panning], False).start()
-      Timer(start+duration, self.frequencyOff, [frequency, channel],                    False).start()
+      Timer(start,          self.frequencyOn,  [frequency, dynamic, channel, panning], False).start()
+      Timer(start+duration, self.frequencyOff, [frequency, channel],                   False).start()
 
 
    def setPitchBend(self, bend=0, channel=0):
@@ -525,12 +525,12 @@ class MidiOut:
       return self.pitchBend[channel]
 
 
-   def noteOnPitchBend(self, pitch, bend=0, velocity=100, channel=0, panning=-1):
+   def noteOnPitchBend(self, pitch, bend=0, dynamic=100, channel=0, panning=-1):
       """Sends NOTE_ON for 'pitch' with 'bend' applied on 'channel'."""
       self.setPitchBend(bend, channel)
       if panning != -1:
          self.sendMidiMessage(CONTROL_CHANGE, channel, 10, panning)
-      self.sendMidiMessage(NOTE_ON, channel, pitch, velocity)
+      self.sendMidiMessage(NOTE_ON, channel, pitch, dynamic)
 
 
    def allNotesOff(self):
@@ -583,61 +583,61 @@ class MidiOut:
       return self.panning[channel]
 
 
-   def sendMidiMessage(self, msgType, msgChannel, msgData1, msgData2):
+   def sendMidiMessage(self, eventType, channel, data1, data2):
       """Sends a raw MIDI message to the output device."""
       try:
-         if msgType == NOTE_ON:
-            msg = mido.Message('note_on', channel=msgChannel, note=msgData1, velocity=msgData2)
+         if eventType == NOTE_ON:
+            msg = mido.Message('note_on', channel=channel, note=data1, velocity=data2)
 
-         elif msgType == NOTE_OFF:
-            msg = mido.Message('note_off', channel=msgChannel, note=msgData1, velocity=msgData2)
+         elif eventType == NOTE_OFF:
+            msg = mido.Message('note_off', channel=channel, note=data1, velocity=data2)
 
-         elif msgType == SET_INSTRUMENT:
-            msg = mido.Message('program_change', channel=msgChannel, program=msgData1)
+         elif eventType == SET_INSTRUMENT:
+            msg = mido.Message('program_change', channel=channel, program=data1)
 
-         elif msgType == CONTROL_CHANGE:
-            msg = mido.Message('control_change', channel=msgChannel, control=msgData1, value=msgData2)
+         elif eventType == CONTROL_CHANGE:
+            msg = mido.Message('control_change', channel=channel, control=data1, value=data2)
 
-         elif msgType == PITCH_BEND:
+         elif eventType == PITCH_BEND:
             # Recombine 7-bit LSB/MSB into a 14-bit value, then shift to mido's -8192..8191 range.
-            bendValue = ((msgData2 << 7) + msgData1) - PITCHBEND_NORMAL
-            msg = mido.Message('pitchwheel', channel=msgChannel, pitch=bendValue)
+            bendValue = ((data2 << 7) + data1) - PITCHBEND_NORMAL
+            msg = mido.Message('pitchwheel', channel=channel, pitch=bendValue)
 
-         elif msgType == AFTERTOUCH:
-            msg = mido.Message('aftertouch', channel=msgChannel, value=msgData1)
+         elif eventType == AFTERTOUCH:
+            msg = mido.Message('aftertouch', channel=channel, value=data1)
 
-         elif msgType == POLYTOUCH:
-            msg = mido.Message('polytouch', channel=msgChannel, note=msgData1, value=msgData2)
+         elif eventType == POLYTOUCH:
+            msg = mido.Message('polytouch', channel=channel, note=data1, value=data2)
 
-         elif msgType == SYSTEM_MESSAGE_VALUES['system_exclusive']:
-            msg = mido.Message('sysex', data=[msgData1, msgData2])
+         elif eventType == SYSTEM_MESSAGE_VALUES['system_exclusive']:
+            msg = mido.Message('sysex', data=[data1, data2])
 
-         elif msgType == SYSTEM_MESSAGE_VALUES['songpos']:
-            msg = mido.Message('songpos', pos=(msgData2 << 7) + msgData1)
+         elif eventType == SYSTEM_MESSAGE_VALUES['songpos']:
+            msg = mido.Message('songpos', pos=(data2 << 7) + data1)
 
-         elif msgType == SYSTEM_MESSAGE_VALUES['songsel']:
-            msg = mido.Message('songsel', song=msgData1)
+         elif eventType == SYSTEM_MESSAGE_VALUES['songsel']:
+            msg = mido.Message('songsel', song=data1)
 
-         elif msgType == SYSTEM_MESSAGE_VALUES['tune_request']:
+         elif eventType == SYSTEM_MESSAGE_VALUES['tune_request']:
             msg = mido.Message('tune_request')
 
-         elif msgType == SYSTEM_MESSAGE_VALUES['system_reset']:
+         elif eventType == SYSTEM_MESSAGE_VALUES['system_reset']:
             msg = mido.Message('reset')
 
-         elif msgType == REALTIME_MESSAGE_VALUES['clock']:
+         elif eventType == REALTIME_MESSAGE_VALUES['clock']:
             msg = mido.Message('clock')
 
-         elif msgType == REALTIME_MESSAGE_VALUES['start']:
+         elif eventType == REALTIME_MESSAGE_VALUES['start']:
             msg = mido.Message('start')
 
-         elif msgType == REALTIME_MESSAGE_VALUES['continue']:
+         elif eventType == REALTIME_MESSAGE_VALUES['continue']:
             msg = mido.Message('continue')
 
-         elif msgType == REALTIME_MESSAGE_VALUES['stop']:
+         elif eventType == REALTIME_MESSAGE_VALUES['stop']:
             msg = mido.Message('stop')
 
          else:
-            print(f"Unsupported MIDI message type: {msgType}")
+            print(f"Unsupported MIDI message type: {eventType}")
             return
 
          if self._port:

music.py

@@ -4696,7 +4696,7 @@ class AudioSample:
                delayMs=float(effectiveDelay),
                startValue=currentVolumeFactor,
                endValue=targetVolumeFactor,
-               function=rampCallback,
+               action=rampCallback,
                stepMs=stepMs
             )
             volumeRamp.start()   # start volume ramp

osc.py

@@ -63,10 +63,12 @@ class OscIn:
       alternativeIPs  = []
 
       try:
-         hostname       = socket.gethostname()
-         hostIP         = socket.gethostbyname(hostname)
-         allIPs         = socket.gethostbyname_ex(hostname)[2]
-         alternativeIPs = sorted(list(set(ip for ip in allIPs if ip != hostIP and ip != "127.0.0.1")))
+         hostname    = socket.gethostname()
+         allIPs      = socket.gethostbyname_ex(hostname)[2]
+         nonLoopback = sorted(set(ip for ip in allIPs if ip != "127.0.0.1"))
+         if nonLoopback:
+            hostIP         = nonLoopback[0]
+            alternativeIPs = nonLoopback[1:]
       except socket.gaierror:
          pass
 
@@ -79,8 +81,6 @@ class OscIn:
       print(f'Accepting OSC input on IP address {self.ipAddress}, at port {self.port}')
       if alternativeIPs:
          print(f'(Alternative IP addresses: {", ".join(alternativeIPs)})')
-      elif self.ipAddress != "127.0.0.1" and "127.0.0.1" in socket.gethostbyname_ex(socket.gethostname())[2]:
-         print('(Alternative IP addresses: 127.0.0.1)')
       print('Use this info to configure OSC clients.\n')
 
       self.showIncomingMessages = True
@@ -112,13 +112,12 @@ class OscIn:
       """Routes an incoming OSC message to all callbacks with a matching pattern."""
       address = rawMsg.addrpattern
       msg     = OscMessage(address, rawMsg.arguments)
-      printed = False
+
+      if self.showIncomingMessages:
+         self._printIncomingMessage(msg)
 
       for pattern, callback in self._handlers:
          if re.fullmatch(pattern, address):
-            if self.showIncomingMessages and not printed:
-               self._printIncomingMessage(msg)
-               printed = True
             self._executeCallback(callback, msg)
 
 
@@ -206,6 +205,7 @@ class OscOut:
       """Sends an OSC message to 'oscAddress' with optional 'args'."""
       message = oscbuildparse.OSCMessage(oscAddress, None, args)
       osc_send(message, self.client)
+      osc_process()
 
 
 #################### OscMessage #######################################################