classes.c90_render_view

  1import objc
  2import vanilla
  3from vanilla import dialogs
  4from vanilla.test.testTools import executeVanillaTest
  5import drawBot
  6from drawBot.ui.drawView import DrawView
  7from AppKit import (
  8    NSObject,
  9    NSScreen,
 10    NSEvent,
 11)
 12from typing import Any, Callable
 13from time import perf_counter
 14from loguru import logger
 15from lib import layout
 16import sys
 17import inspect
 18from classes.c91_render_panel_manager import RenderPanelManager
 19
 20
 21class _PaintDebouncer(NSObject):
 22    """Cocoa-native debouncer that delays a callback using the main run loop."""
 23
 24    @objc.python_method
 25    def setup(self, callback):
 26        self._callback = callback
 27        return self
 28
 29    @objc.python_method
 30    def schedule(self, delay: float):
 31        """Schedule callback after delay, cancelling any pending invocation."""
 32        type(self).cancelPreviousPerformRequestsWithTarget_selector_object_(
 33            self, "fire:", None
 34        )
 35        self.performSelector_withObject_afterDelay_("fire:", None, delay)
 36
 37    @objc.python_method
 38    def cancel(self):
 39        """Cancel any pending invocation."""
 40        type(self).cancelPreviousPerformRequestsWithTarget_selector_object_(
 41            self, "fire:", None
 42        )
 43
 44    def fire_(self, _):
 45        if hasattr(self, "_callback") and self._callback:
 46            self._callback()
 47
 48
 49class RenderView:
 50    """Execute a function in a GUI window using DrawBot and Vanilla."""
 51
 52    UI_PANEL_HEIGHT = 26
 53    AUTO_FIT_MARGIN = 0.992  # Keep a safety margin to avoid overflow scrollbars.
 54
 55    @staticmethod
 56    def _isRunningInDrawBotApp() -> bool:
 57        """Detect whether this code is running inside DrawBot.app."""
 58        executable = (sys.executable or "").lower()
 59        argv0 = (sys.argv[0] if sys.argv else "").lower()
 60        drawbot_file = (getattr(drawBot, "__file__", "") or "").lower()
 61        return (
 62            "drawbot.app/contents/macos/drawbot" in executable
 63            or executable.endswith("/drawbot")
 64            or "drawbot.app" in argv0
 65            or "drawbot.app" in drawbot_file
 66        )
 67
 68    def __init__(
 69        self,
 70        func: Callable,
 71        windowRatio: layout.AspectRatioInput = 2 / 3,
 72        windowScale: int = 1,
 73        canvasScale: int = 1,
 74        ui: bool = True,
 75        panelManager: RenderPanelManager | None = None,
 76        debounceDelay: float = 0.5,
 77    ):
 78        """
 79        Initialize a GUI environment.
 80
 81        Args:
 82            func: The function to execute and display in the GUI.
 83            windowRatio: The width/height ratio of the window.
 84            windowScale: The scaling factor for the window size relative to the screen. (0-1)
 85            canvasScale: The scale factor for the canvas rendering.
 86            ui: Whether to show UI controls (refresh and save buttons).
 87            panelManager: Optional side panel manager object.
 88            debounceDelay: Seconds to wait after a panel change before re-rendering (default: 0.5).
 89        """
 90        self._windowRatio = layout.parseAspectRatio(windowRatio)
 91        if windowScale <= 0 or windowScale > 1:
 92            raise ValueError(
 93                "windowScale must be between 0 (exclusive) and 1 (inclusive)."
 94            )
 95        self._windowScale = windowScale
 96        self._canvasScale = canvasScale
 97        self._ui = ui
 98        self._panelManager = panelManager
 99        self._debounceDelay = debounceDelay
100        self._lastRenderedState: dict | None = None
101        self._lastRenderedPDF = None
102        self._debouncer: _PaintDebouncer | None = None
103
104        if self._isRunningInDrawBotApp():
105            self.run(func)
106        else:
107            executeVanillaTest(self.run(func))
108
109    def getPanelState(self) -> dict[str, Any]:
110        """Return active panel plugin state, or an empty dict."""
111        if self._panelManager is None:
112            return {}
113        return self._panelManager.getState()
114
115    def _invokeRenderFunction(self, func: Callable):
116        """Call renderer with optional panel state if function accepts arguments."""
117        if self._panelManager is None:
118            return func()
119
120        panelState = self.getPanelState()
121        try:
122            sig = inspect.signature(func)
123            params = list(sig.parameters.values())
124        except (TypeError, ValueError):
125            return func()
126
127        if not params:
128            return func()
129
130        first = params[0]
131        if first.kind in (
132            inspect.Parameter.POSITIONAL_ONLY,
133            inspect.Parameter.POSITIONAL_OR_KEYWORD,
134            inspect.Parameter.VAR_POSITIONAL,
135        ):
136            return func(panelState)
137
138        return func()
139
140    def run(self, func):
141        """
142        Set up and run the GUI window, rendering the provided function.
143
144        Args:
145            func: The function to execute and render on the canvas.
146        """
147
148        def getPlacementScreen():
149            """Determine which screen the mouse is currently on to place the window there."""
150            if self._isRunningInDrawBotApp():
151                logger.debug("DrawBot.app mode: using main screen (no mouse probe)")
152                return NSScreen.mainScreen()
153            try:
154                mouse = NSEvent.mouseLocation()
155                screens = NSScreen.screens()
156                for screen in screens:
157                    frame = screen.frame()
158                    left = frame.origin.x
159                    bottom = frame.origin.y
160                    right = left + frame.size.width
161                    top = bottom + frame.size.height
162                    if left <= mouse.x <= right and bottom <= mouse.y <= top:
163                        return screen
164            except Exception as e:
165                logger.warning(
166                    f"Failed to get placement screen from mouse position: {e}"
167                )
168            return NSScreen.mainScreen()
169
170        def getWindowChromeHeight():
171            """Measure current window chrome height (frame minus content) in points."""
172            if self._isRunningInDrawBotApp():
173                logger.debug(
174                    "DrawBot.app mode: skipping chrome probe, using fallback 28"
175                )
176                return 28
177
178            probe = None
179            try:
180                probe = vanilla.Window((200, 200))
181                nsWindow = probe.getNSWindow()
182                frame = nsWindow.frame()
183                content = nsWindow.contentRectForFrameRect_(frame)
184                return frame.size.height - content.size.height
185            except Exception as e:
186                logger.warning(
187                    f"Failed to measure window chrome height, using fallback 28: {e}"
188                )
189                return 28
190            finally:
191                if probe is not None:
192                    try:
193                        probe.close()
194                    except Exception:
195                        pass
196
197        windowChromeH = getWindowChromeHeight()
198
199        def getScreenSize():
200            """
201            Calculate the window size based on usable screen area (without MacOS menu bar and dock) and windowRatio/windowScale.
202
203            Returns:
204                tuple: (window width, window height)
205            """
206            try:
207                visible = getPlacementScreen().visibleFrame()
208                availW, availH = visible.size.width, visible.size.height
209
210                contentAvailH = (
211                    availH - windowChromeH
212                )  # Subtract space for OS window chrome
213                if self._ui:
214                    contentAvailH -= self.UI_PANEL_HEIGHT  # Subtract space for UI panel
215
216                # Use usable width/height so left/right dock positions are accounted for.
217                screenAspectRatio = availW / contentAvailH
218
219                isWiderThanScreen = self._windowRatio > screenAspectRatio
220
221                if isWiderThanScreen:
222                    w = availW * self._windowScale
223                    h = w / self._windowRatio
224                else:
225                    h = contentAvailH * self._windowScale
226                    w = h * self._windowRatio
227
228                h += windowChromeH  # Add back space for OS window chrome
229                if self._ui:
230                    h += self.UI_PANEL_HEIGHT  # Add back space for UI panel
231
232                if self._panelManager is not None:
233                    w += self._panelManager.getRightInset()
234
235                return w, h
236            except Exception as e:
237                logger.warning(f"Failed to compute screen-based window size: {e}")
238                return 900, 600
239
240        def paintCanvas(sender=None):
241            """
242            Render the function output to the canvas and update the PDF document.
243            """
244            start = perf_counter()
245
246            # Phase 2: Skip expensive PDF re-render if panel state is unchanged.
247            currentState = self._getRenderableState()
248            if currentState != self._lastRenderedState:
249                logger.trace("Panel state changed — re-rendering PDF")
250                drawBot.newDrawing()
251                self._invokeRenderFunction(func)
252                self._lastRenderedPDF = drawBot.pdfImage()
253                drawBot.endDrawing()
254                self._lastRenderedState = currentState
255            else:
256                logger.trace("State unchanged — skipping PDF render")
257
258            # Set the unflipped PDF directly — flip is handled via layer transform below.
259            if self._lastRenderedPDF is not None:
260                logger.trace("Updating canvas PDF document")
261                self.w.canvas.setPDFDocument(self._lastRenderedPDF)
262
263            # Always re-fit scale: canvas area may have changed (e.g. panel toggle).
264            nsView = self.w.canvas.getNSView()
265            fitScale = nsView.scaleFactorForSizeToFit()
266            targetScale = (
267                fitScale * self.AUTO_FIT_MARGIN
268                if self._canvasScale == 1
269                else self._canvasScale
270            )
271            self.w.canvas.setScale(targetScale)
272
273            # Apply flip AFTER setScale so the layer transform isn't overwritten.
274            panelState = self.getPanelState()
275            flipX = bool(panelState.get("flipX", False))
276            flipY = bool(panelState.get("flipY", False))
277            self._applyFlipTransform(flipX, flipY)
278
279            logger.trace(
280                "Canvas fit metrics: targetScale={:.4f}, fitScale={:.4f}, canvasScale={:.4f}",
281                targetScale,
282                fitScale,
283                self._canvasScale,
284            )
285
286            elapsed = perf_counter() - start
287            logger.info(f"⏱️ Paint took {elapsed:.4f} seconds")
288
289        def forceRender(sender=None):
290            """Force a full re-render, bypassing the state-diff optimisation."""
291            self._debouncer.cancel()
292            self._lastRenderedState = None
293            paintCanvas()
294
295        # Phase 1: set up Cocoa-native debouncer for panel changes.
296        self._debouncer = _PaintDebouncer.alloc().init()
297        self._debouncer.setup(paintCanvas)
298
299        def onPanelChanged(immediate=False):
300            if self._panelManager is not None:
301                self._panelManager.applyUILayout()
302            if immediate:
303                self._debouncer.cancel()
304                paintCanvas()
305            else:
306                self._debouncer.schedule(self._debounceDelay)
307
308        self.w = vanilla.Window(
309            getScreenSize(),
310            minSize=(400, 400),
311        )
312
313        if self._ui:
314            self.w.refreshBtn = vanilla.Button(
315                (-196, -22, 60, 14),
316                "Refresh",
317                sizeStyle="mini",
318                callback=forceRender,
319            )
320            self.w.saveBtn = vanilla.Button(
321                (-132, -22, 60, 14),
322                "Save File",
323                sizeStyle="mini",
324                callback=self.savePdf,
325            )
326            self.w.printBtn = vanilla.Button(
327                (-68, -22, 60, 14),
328                "Print",
329                sizeStyle="mini",
330                callback=self.printImage,
331            )
332            canvasH = -self.UI_PANEL_HEIGHT
333        else:
334            canvasH = -0
335
336        self.w.canvas = DrawView((0, 0, -0, canvasH))
337
338        if self._panelManager is not None:
339            self._panelManager.build(
340                self.w,
341                canvasH,
342                onPanelChanged,
343                onForceRender=forceRender,
344            )
345
346        paintCanvas()
347
348        self.w.open()
349        self.w.center()
350
351    def _getRenderableState(self) -> dict:
352        """Panel state excluding view-transform keys that don't affect PDF content."""
353        state = self.getPanelState()
354        return {k: v for k, v in state.items() if k not in ("flipX", "flipY")}
355
356    def _applyFlipTransform(self, flipX: bool, flipY: bool):
357        """Flip the canvas view via a CALayer affine transform — no PDF rewriting."""
358        try:
359            from Quartz import CGAffineTransformMakeScale
360
361            nsView = self.w.canvas.getNSView()
362            nsView.setWantsLayer_(True)
363            layer = nsView.layer()
364            if layer is None:
365                return
366
367            # Compute the layer's frame center in parent coords regardless of the
368            # current anchor point (AppKit-backed layers often anchor at (0,0)).
369            bounds = layer.bounds()
370            pos = layer.position()
371            anchor = layer.anchorPoint()
372            bw, bh = bounds.size.width, bounds.size.height
373            cx = (pos.x - anchor.x * bw) + bw / 2.0
374            cy = (pos.y - anchor.y * bh) + bh / 2.0
375
376            # Pin anchor to center so scale(±1) flips around the middle of the view.
377            layer.setAnchorPoint_((0.5, 0.5))
378            layer.setPosition_((cx, cy))
379
380            sx = -1.0 if flipX else 1.0
381            sy = -1.0 if flipY else 1.0
382            layer.setAffineTransform_(CGAffineTransformMakeScale(sx, sy))
383        except Exception as e:
384            logger.warning(f"Failed to apply flip transform: {e}")
385
386    def savePdf(self, sender):
387        """
388        Save the current canvas as a PDF, SVG, or PNG file.
389        """
390        path = dialogs.putFile(fileTypes=["pdf", "svg", "png"])
391        if path:
392            drawBot.saveImage(path)
393
394    def printImage(self, sender):
395        """Send the current drawing to the system print dialog."""
396        drawBot.printImage()