More natural instantiation

Author: almarklein

rendercanvas/base.py

@@ -37,37 +37,27 @@ class BaseRenderCanvas:
 
     """
 
-    #
-    __canvas_kwargs = dict(
+    def __init__(
+        self,
+        *args,
         size=(640, 480),
         title="$backend",
         update_mode="ondemand",
         min_fps=1.0,
         max_fps=30.0,
         vsync=True,
         present_method=None,
-    )
-
-    def __init__(self, *args, **kwargs):
-        # Extract canvas kwargs
-        canvas_kwargs = {}
-        for key, default in BaseRenderCanvas.__canvas_kwargs.items():
-            val = kwargs.pop(key, default)
-            if val is None:
-                val = default
-            canvas_kwargs[key] = val
-
+        **kwargs,
+    ):
         # Initialize superclass. Note that super() can be e.g. a QWidget, RemoteFrameBuffer, or object.
         super().__init__(*args, **kwargs)
 
-        # If this is a wrapper, it should pass the canvas kwargs to the subwidget.
+        # If this is a wrapper, no need to initialize furher
         if isinstance(self, WrapperRenderCanvas):
-            self._rc_init(**canvas_kwargs)
-            self._events = self._subwidget._events
             return
 
         # The vsync is not-so-elegantly strored on the canvas, and picked up by wgou's canvas contex.
-        self._vsync = bool(canvas_kwargs["vsync"])
+        self._vsync = bool(vsync)
 
         # Variables and flags used internally
         self.__is_drawing = False
@@ -86,17 +76,32 @@ def __init__(self, *args, **kwargs):
                 self,
                 self._events,
                 self._rc_get_loop(),
-                min_fps=canvas_kwargs["min_fps"],
-                max_fps=canvas_kwargs["max_fps"],
-                mode=canvas_kwargs["update_mode"],
+                min_fps=min_fps,
+                max_fps=max_fps,
+                mode=update_mode,
             )
 
-        # Initialze the canvas subclass
-        self._rc_init(**canvas_kwargs)
+        # We cannot initialize the size and title now, because the subclass may not have done
+        # the initialization to support this. So we require the subclass to call _final_canvas_init.
+        self.__kwargs_for_later = dict(size=size, title=title)
+
+    def _final_canvas_init(self):
+        """Must be called by the subclasses at the end of their ``__init__``.
 
-        # Finalize the initialization
-        self.set_logical_size(*canvas_kwargs["size"])
-        self.set_title(canvas_kwargs["title"])
+        This sets the canvas size and title, which must happen *after* the widget itself
+        is initialized. Doing this automatically can be done with a metaclass, but let's keep it simple.
+        """
+        # Pop kwargs
+        try:
+            kwargs = self.__kwargs_for_later
+        except AttributeError:
+            return
+        else:
+            del self.__kwargs_for_later
+        # Apply
+        if not isinstance(self, WrapperRenderCanvas):
+            self.set_logical_size(*kwargs["size"])
+            self.set_title(kwargs["title"])
 
     def __del__(self):
         # On delete, we call the custom close method.
@@ -366,14 +371,6 @@ def set_title(self, title):
 
     # %% Methods for the subclass to implement
 
-    def _rc_init(self, **canvas_kwargs):
-        """Method to initialize the canvas.
-
-        This method is called near the end of the initialization
-        process, but before setting things like size and title.
-        """
-        pass
-
     def _rc_get_loop(self):
         """Get the loop instance for this backend.
 
@@ -438,6 +435,9 @@ def _rc_set_logical_size(self, width, height):
     def _rc_close(self):
         """Close the canvas.
 
+        For widgets that are wrapped by a WrapperRenderCanvas, this should probably
+        close the wrapper instead.
+
         Note that ``BaseRenderCanvas`` implements the ``close()`` method, which
         is a rather common name; it may be necessary to re-implement that too.
         """
@@ -450,6 +450,9 @@ def _rc_is_closed(self):
     def _rc_set_title(self, title):
         """Set the canvas title. May be ignored when it makes no sense.
 
+        For widgets that are wrapped by a WrapperRenderCanvas, this should probably
+        set the title of the wrapper instead.
+
         The default implementation does nothing.
         """
         pass
@@ -462,6 +465,17 @@ class WrapperRenderCanvas(BaseRenderCanvas):
     Wrapper classes should not implement any of the ``_rc_`` methods.
     """
 
+    # Events
+
+    def add_event_handler(self, *args, **kwargs):
+        return self._subwidget._events.add_handler(*args, **kwargs)
+
+    def remove_event_handler(self, *args, **kwargs):
+        return self._subwidget._events.remove_handler(*args, **kwargs)
+
+    def submit_event(self, event):
+        return self._subwidget._events.submit(event)
+
     # Must implement
 
     def get_context(self, *args, **kwargs):

rendercanvas/glfw.py

@@ -146,7 +146,9 @@ class GlfwRenderCanvas(BaseRenderCanvas):
 
     # See https://www.glfw.org/docs/latest/group__window.html
 
-    def _rc_init(self, *, present_method, **_):
+    def __init__(self, *args, present_method=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
         loop.init_glfw()
 
         if present_method == "image":
@@ -195,6 +197,9 @@ def _rc_init(self, *, present_method, **_):
         self._pixel_ratio = -1
         self._screen_size_is_logical = False
 
+        # Set size, title, etc.
+        self._final_canvas_init()
+
     def _on_window_dirty(self, *args):
         self.request_draw()
 

rendercanvas/jupyter.py

@@ -17,7 +17,9 @@
 class JupyterRenderCanvas(BaseRenderCanvas, RemoteFrameBuffer):
     """An ipywidgets widget providing a render canvas. Needs the jupyter_rfb library."""
 
-    def _rc_init(self, **_):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
         # Internal variables
         self._last_image = None
         self._pixel_ratio = 1
@@ -28,6 +30,9 @@ def _rc_init(self, **_):
         # Register so this can be display'ed when run() is called
         loop._pending_jupyter_canvases.append(weakref.ref(self))
 
+        # Set size, title, etc.
+        self._final_canvas_init()
+
     def get_frame(self):
         # The _draw_frame_and_present() does the drawing and then calls
         # present_context.present(), which calls our present() method.

rendercanvas/offscreen.py

@@ -10,10 +10,9 @@ class ManualOffscreenRenderCanvas(BaseRenderCanvas):
     def __init__(self, *args, pixel_ratio=1.0, **kwargs):
         super().__init__(*args, **kwargs)
         self._pixel_ratio = pixel_ratio
-
-    def _rc_init(self, **_):
         self._closed = False
         self._last_image = None
+        self._final_canvas_init()
 
     # %% Methods to implement RenderCanvas
 

rendercanvas/qt.py

@@ -147,7 +147,9 @@ def enable_hidpi():
 class QRenderWidget(BaseRenderCanvas, QtWidgets.QWidget):
     """A QWidget representing a render canvas that can be embedded in a Qt application."""
 
-    def _rc_init(self, *, present_method, **_):
+    def __init__(self, *args, present_method=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
         # Determine present method
         self._surface_ids = None
         if not present_method:
@@ -175,6 +177,9 @@ def _rc_init(self, *, present_method, **_):
         self.setMouseTracking(True)
         self.setFocusPolicy(FocusPolicy.StrongFocus)
 
+        # Set size, title, etc.
+        self._final_canvas_init()
+
     def _get_surface_ids(self):
         if sys.platform.startswith("win") or sys.platform.startswith("darwin"):
             return {
@@ -466,14 +471,13 @@ class QRenderCanvas(WrapperRenderCanvas, QtWidgets.QWidget):
     # size can be set to subpixel (logical) values, without being able to
     # detect this. See https://github.com/pygfx/wgpu-py/pull/68
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, parent=None, **kwargs):
         # When using Qt, there needs to be an
         # application before any widget is created
         loop.init_qt()
-        super().__init__(*args, **kwargs)
+        super().__init__(parent)
 
-    def _rc_init(self, **canvas_kwargs):
-        self._subwidget = QRenderWidget(self, **canvas_kwargs)
+        self._subwidget = QRenderWidget(self, **kwargs)
 
         self.setAttribute(WA_DeleteOnClose, True)
         self.setMouseTracking(True)
@@ -487,7 +491,9 @@ def _rc_init(self, **canvas_kwargs):
         layout.setContentsMargins(0, 0, 0, 0)
         self.setLayout(layout)
         layout.addWidget(self._subwidget)
+
         self.show()
+        self._final_canvas_init()
 
     # Qt methods
 

rendercanvas/wx.py

@@ -128,7 +128,9 @@ def enable_hidpi():
 class WxRenderWidget(BaseRenderCanvas, wx.Window):
     """A wx Window representing a render canvas that can be embedded in a wx application."""
 
-    def _rc_init(self, present_method=None, **_):
+    def __init__(self, *args, present_method=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
         # Determine present method
         self._surface_ids = None
         if not present_method:
@@ -161,6 +163,7 @@ def _rc_init(self, present_method=None, **_):
         self.Bind(wx.EVT_MOTION, self._on_mouse_move)
 
         self.Show()
+        self._final_canvas_init()
 
     def _on_resize_done(self, *args):
         self._draw_lock = False
@@ -425,14 +428,14 @@ class WxRenderCanvas(WrapperRenderCanvas, wx.Frame):
 
     # Most of this is proxying stuff to the inner widget.
 
-    def __init__(self, *, parent=None, **kwargs):
+    def __init__(self, parent=None, **kwargs):
         loop.init_wx()
-        super().__init__(parent, **kwargs)
+        super().__init__(parent)
 
-    def _rc_init(self, **canvas_kwargs):
-        self._subwidget = WxRenderWidget(parent=self, **canvas_kwargs)
+        self._subwidget = WxRenderWidget(parent=self, **kwargs)
         self.Bind(wx.EVT_CLOSE, lambda e: self.Destroy())
         self.Show()
+        self._final_canvas_init()
 
     # wx methods