rendercanvas 2.7.1__tar.gz → 3.0.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (53) hide show
  1. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/PKG-INFO +7 -3
  2. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/README.md +4 -1
  3. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/_version.py +1 -1
  4. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/anywidget.py +15 -20
  5. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/asyncio.py +30 -18
  6. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/auto.py +5 -5
  7. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/base.py +81 -57
  8. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/contexts/_fullscreen.py +1 -1
  9. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/contexts/bitmapcontext.py +3 -3
  10. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/contexts/wgpucontext.py +22 -6
  11. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/coreutils.py +76 -58
  12. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/events.py +7 -4
  13. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/loop.py +276 -224
  14. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/renderview.js +31 -6
  15. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/scheduler.py +14 -14
  16. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/size.py +1 -0
  17. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/glfw.py +2 -6
  18. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/http.py +11 -17
  19. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/jupyter.py +1 -5
  20. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/offscreen.py +8 -11
  21. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/pyodide.py +9 -6
  22. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/qt.py +123 -38
  23. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/raw.py +17 -14
  24. rendercanvas-3.0.0/rendercanvas/stub.py +295 -0
  25. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/terminal.py +6 -11
  26. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/trio.py +18 -8
  27. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/utils/asyncadapter.py +4 -2
  28. rendercanvas-3.0.0/rendercanvas/utils/asyncs.py +114 -0
  29. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/wx.py +88 -69
  30. rendercanvas-2.7.1/rendercanvas/stub.py +0 -135
  31. rendercanvas-2.7.1/rendercanvas/utils/asyncs.py +0 -156
  32. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/LICENSE +0 -0
  33. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/pyproject.toml +0 -0
  34. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/__init__.py +0 -0
  35. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/__pyinstaller/__init__.py +0 -0
  36. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/__pyinstaller/conftest.py +0 -0
  37. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/__pyinstaller/hook-rendercanvas.py +0 -0
  38. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/__pyinstaller/test_rendercanvas.py +0 -0
  39. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/contexts/__init__.py +0 -0
  40. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/contexts/basecontext.py +0 -0
  41. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/__init__.py +0 -0
  42. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/encoders.py +0 -0
  43. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/enums.py +0 -0
  44. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/renderview-afm.js +0 -0
  45. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/renderview-client.js +0 -0
  46. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/renderview-pyodide.js +0 -0
  47. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/core/renderview.css +0 -0
  48. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/pyqt5.py +0 -0
  49. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/pyqt6.py +0 -0
  50. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/pyside2.py +0 -0
  51. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/pyside6.py +0 -0
  52. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/utils/__init__.py +0 -0
  53. {rendercanvas-2.7.1 → rendercanvas-3.0.0}/rendercanvas/utils/cube.py +0 -0
@@ -1,6 +1,6 @@
1
- Metadata-Version: 2.4
1
+ Metadata-Version: 2.5
2
2
  Name: rendercanvas
3
- Version: 2.7.1
3
+ Version: 3.0.0
4
4
  Summary: One canvas API, multiple backends
5
5
  Keywords: canvas,rendering,graphics,wgpu,qt,wx,glfw,jupyter
6
6
  Author: Almar Klein, Korijn van Golen
@@ -48,6 +48,7 @@ Provides-Extra: lint
48
48
  Provides-Extra: notebook
49
49
  Provides-Extra: terminal
50
50
  Provides-Extra: tests
51
+ Import-Name: rendercanvas
51
52
 
52
53
  [![CI](https://github.com/pygfx/rendercanvas/workflows/CI/badge.svg)](https://github.com/pygfx/rendercanvas/actions)
53
54
  [![Documentation Status](https://readthedocs.org/projects/rendercanvas/badge/?version=stable)](https://rendercanvas.readthedocs.io)
@@ -128,12 +129,14 @@ from rendercanvas.auto import RenderCanvas, loop
128
129
  canvas = RenderCanvas(update_mode="continuous")
129
130
  context = canvas.get_bitmap_context()
130
131
 
132
+
131
133
  @canvas.request_draw
132
134
  def animate():
133
135
  w, h = canvas.get_logical_size()
134
136
  bitmap = np.random.uniform(0, 255, (h, w)).astype(np.uint8)
135
137
  context.set_bitmap(bitmap)
136
138
 
139
+
137
140
  loop.run()
138
141
  ```
139
142
 
@@ -157,8 +160,8 @@ Embed in a Qt application:
157
160
  from PySide6 import QtWidgets
158
161
  from rendercanvas.qt import QRenderWidget
159
162
 
160
- class Main(QtWidgets.QWidget):
161
163
 
164
+ class Main(QtWidgets.QWidget):
162
165
  def __init__(self):
163
166
  super().__init__()
164
167
 
@@ -199,6 +202,7 @@ See the [contribution guide](CONTRIBUTING.md).
199
202
  * Use `ruff check` to check for linting errors.
200
203
  * Use `pytest tests` to run the tests.
201
204
  * Use `pytest examples` to run a subset of the examples.
205
+ * Use `pytest tests/test_backend_xx.py` to run backend-specific tests, e.g. for `glfw`, `qt`, `wx`.
202
206
 
203
207
  ### Code of Conduct
204
208
 
@@ -77,12 +77,14 @@ from rendercanvas.auto import RenderCanvas, loop
77
77
  canvas = RenderCanvas(update_mode="continuous")
78
78
  context = canvas.get_bitmap_context()
79
79
 
80
+
80
81
  @canvas.request_draw
81
82
  def animate():
82
83
  w, h = canvas.get_logical_size()
83
84
  bitmap = np.random.uniform(0, 255, (h, w)).astype(np.uint8)
84
85
  context.set_bitmap(bitmap)
85
86
 
87
+
86
88
  loop.run()
87
89
  ```
88
90
 
@@ -106,8 +108,8 @@ Embed in a Qt application:
106
108
  from PySide6 import QtWidgets
107
109
  from rendercanvas.qt import QRenderWidget
108
110
 
109
- class Main(QtWidgets.QWidget):
110
111
 
112
+ class Main(QtWidgets.QWidget):
111
113
  def __init__(self):
112
114
  super().__init__()
113
115
 
@@ -148,6 +150,7 @@ See the [contribution guide](CONTRIBUTING.md).
148
150
  * Use `ruff check` to check for linting errors.
149
151
  * Use `pytest tests` to run the tests.
150
152
  * Use `pytest examples` to run a subset of the examples.
153
+ * Use `pytest tests/test_backend_xx.py` to run backend-specific tests, e.g. for `glfw`, `qt`, `wx`.
151
154
 
152
155
  ### Code of Conduct
153
156
 
@@ -22,7 +22,7 @@ from pathlib import Path
22
22
 
23
23
  # This is the base version number, to be bumped before each release.
24
24
  # The build system detects this definition when building a distribution.
25
- __version__ = "2.7.1"
25
+ __version__ = "3.0.0"
26
26
 
27
27
  # Set this to your library name
28
28
  project_name = "rendercanvas"
@@ -4,31 +4,31 @@ A backend based on anywidget, supporting canvases inside a large variety of note
4
4
 
5
5
  __all__ = ["AnywidgetRenderCanvas", "RenderCanvas", "loop"]
6
6
 
7
- import time
8
7
  import asyncio
8
+ import time
9
9
  from base64 import encodebytes
10
10
  from importlib.resources import files as resource_files
11
11
 
12
- from .base import BaseCanvasGroup, BaseRenderCanvas, logger
13
- from .asyncio import loop
14
- from .core.encoders import encode_array, CAN_JPEG
15
- from .core.events import valid_event_types
16
-
17
- import numpy as np
18
12
  import anywidget
19
- from IPython.display import display, HTML
13
+ import numpy as np
14
+ from IPython.display import HTML, display
20
15
  from traitlets import Bool, Dict, Int, Unicode
21
16
 
17
+ from .asyncio import loop
18
+ from .base import BaseCanvasGroup, BaseRenderCanvas, logger
19
+ from .core.encoders import CAN_JPEG, encode_array
20
+ from .core.events import valid_event_types
21
+
22
22
 
23
23
  def _load_js_and_css():
24
24
  js = ""
25
25
  for fname in ["renderview.js", "renderview-afm.js"]:
26
26
  js_path = resource_files("rendercanvas.core").joinpath(fname)
27
- js += js_path.read_text() + "\n\n"
27
+ js += js_path.read_text(encoding="utf-8") + "\n\n"
28
28
 
29
29
  css_path = resource_files("rendercanvas.core").joinpath("renderview.css")
30
30
 
31
- return js, css_path.read_text()
31
+ return js, css_path.read_text(encoding="utf-8")
32
32
 
33
33
 
34
34
  JS, CSS = _load_js_and_css()
@@ -74,8 +74,6 @@ class AnywidgetRenderCanvas(BaseRenderCanvas, anywidget.AnyWidget):
74
74
 
75
75
  super().__init__(*args, **kwargs)
76
76
 
77
- self._is_closed = False
78
-
79
77
  self._rfb_draw_requested = False
80
78
  self._rfb_frame_index = 0
81
79
  self._rfb_last_confirmed_index = 0
@@ -109,7 +107,7 @@ class AnywidgetRenderCanvas(BaseRenderCanvas, anywidget.AnyWidget):
109
107
  if self._rfb_last_resize_event is None:
110
108
  w, h = self._last_set_logical_size
111
109
  r = float(pixel_ratio) if pixel_ratio is not None else 1.0
112
- pw, ph = int(w * r), (h * r)
110
+ pw, ph = int(w * r), int(h * r)
113
111
  event = {
114
112
  "type": "resize",
115
113
  "width": pw / r,
@@ -152,7 +150,7 @@ class AnywidgetRenderCanvas(BaseRenderCanvas, anywidget.AnyWidget):
152
150
  event = content
153
151
 
154
152
  if event_type == "resize":
155
- self._last_event = event
153
+ self._rfb_last_resize_event = event
156
154
  self._size_info.set_physical_size(
157
155
  event["pwidth"], event["pheight"], event["ratio"]
158
156
  )
@@ -209,8 +207,9 @@ class AnywidgetRenderCanvas(BaseRenderCanvas, anywidget.AnyWidget):
209
207
  handle.cancel()
210
208
 
211
209
  def _rfb_lossless_draw(self):
212
- array, _ = self._rfb_lossless_draw_info
213
- self._rfb_send_frame(array, True)
210
+ if self._lossless_draw_info is not None:
211
+ array, _ = self._rfb_lossless_draw_info
212
+ self._rfb_send_frame(array, True)
214
213
 
215
214
  def _rfb_send_frame(self, array, is_lossless_redraw=False):
216
215
  """Actually send a frame over to the client."""
@@ -370,10 +369,6 @@ class AnywidgetRenderCanvas(BaseRenderCanvas, anywidget.AnyWidget):
370
369
  def _rc_close(self):
371
370
  anywidget.AnyWidget.close(self)
372
371
  self._rfb_handle_msg(self, {"type": "close"}, [])
373
- self._is_closed = True
374
-
375
- def _rc_get_closed(self):
376
- return self._is_closed
377
372
 
378
373
  def _rc_set_title(self, title):
379
374
  self._title = str(title)
@@ -6,15 +6,17 @@ Also supports a asyncio-friendly way to run or wait for the loop using ``run_asy
6
6
  __all__ = ["AsyncioLoop", "loop"]
7
7
 
8
8
  from .base import BaseLoop
9
+ from .core.coreutils import IS_PYODIDE
9
10
  from .utils.asyncs import detect_current_async_lib
10
11
 
11
12
 
12
13
  class AsyncioLoop(BaseLoop):
14
+ _use_call_later_via_thread = not bool(IS_PYODIDE)
15
+
13
16
  def __init__(self):
14
17
  super().__init__()
15
18
  # Initialize, but don't even import asyncio yet
16
- self.__tasks = set()
17
- self.__pending_tasks = []
19
+ self.__pending_call_soons = []
18
20
  self._interactive_loop = None
19
21
  self._run_loop = None
20
22
  self._stop_event = None
@@ -58,9 +60,13 @@ class AsyncioLoop(BaseLoop):
58
60
  "Attempt to run AsyncioLoop with a different asyncio-loop than the initialized loop."
59
61
  )
60
62
 
61
- # Create tasks if necessary
62
- while self.__pending_tasks:
63
- self._rc_add_task(*self.__pending_tasks.pop(0))
63
+ # Call soon if necessary
64
+ while self.__pending_call_soons:
65
+ self._rc_call_soon_threadsafe(self.__pending_call_soons.pop(0))
66
+
67
+ # Only do one cycle of processing tasks if there are no canvases.
68
+ if not self.get_canvases():
69
+ self._run_loop.call_soon(self.stop)
64
70
 
65
71
  # Wait for loop to finish
66
72
  if self._stop_event is None:
@@ -68,10 +74,6 @@ class AsyncioLoop(BaseLoop):
68
74
  await self._stop_event.wait()
69
75
 
70
76
  def _rc_stop(self):
71
- # Clean up our tasks. This includes the loop-task and scheduler tasks.
72
- while self.__tasks:
73
- task = self.__tasks.pop()
74
- task.cancel() # is a no-op if the task is no longer running
75
77
  # Signal that we stopped
76
78
  if self._stop_event is not None:
77
79
  self._stop_event.set()
@@ -79,21 +81,31 @@ class AsyncioLoop(BaseLoop):
79
81
  self._run_loop = None
80
82
  # Note how we don't explicitly stop a loop, not the interactive loop, nor the running loop
81
83
 
82
- def _rc_add_task(self, func, name):
84
+ def _rc_call_soon(self, callback):
83
85
  loop = self._interactive_loop or self._run_loop
84
86
  if loop is None:
85
- self.__pending_tasks.append((func, name))
87
+ self.__pending_call_soons.append(callback)
86
88
  else:
87
- task = loop.create_task(func(), name=name)
88
- self.__tasks.add(task)
89
- task.add_done_callback(self.__tasks.discard)
90
-
91
- def _rc_call_later(self, delay, callback):
92
- raise NotImplementedError() # we implement _rc_add_task instead
89
+ loop.call_soon(callback)
93
90
 
94
91
  def _rc_call_soon_threadsafe(self, callback):
95
92
  loop = self._interactive_loop or self._run_loop
96
- loop.call_soon_threadsafe(callback)
93
+ if loop is None:
94
+ self.__pending_call_soons.append(callback)
95
+ else:
96
+ loop.call_soon_threadsafe(callback)
97
+
98
+ def _rc_call_later(self, delay, callback):
99
+ if self._use_call_later_via_thread:
100
+ # The default version has more accurate timing on Windows.
101
+ super()._rc_call_later(delay, callback)
102
+ else:
103
+ # For Pyodide we cannot use the default implementation, because it uses threading.
104
+ loop = self._interactive_loop or self._run_loop
105
+ if loop is None:
106
+ self.__pending_call_soons.append(callback)
107
+ else:
108
+ loop.call_later(delay, callback)
97
109
 
98
110
 
99
111
  loop = AsyncioLoop()
@@ -4,18 +4,18 @@ Automatic backend selection.
4
4
 
5
5
  __all__ = ["RenderCanvas", "loop"]
6
6
 
7
+ import importlib
7
8
  import os
8
9
  import sys
9
- import importlib
10
10
  from typing import cast
11
11
 
12
+ from .base import BaseLoop, BaseRenderCanvas
12
13
  from .core.coreutils import (
13
- logger,
14
14
  QT_MODULE_NAMES,
15
- get_imported_qt_lib,
16
15
  asyncio_is_running,
16
+ get_imported_qt_lib,
17
+ logger,
17
18
  )
18
- from .base import BaseRenderCanvas, BaseLoop
19
19
 
20
20
 
21
21
  def _load_backend(backend_name):
@@ -142,7 +142,7 @@ def backends_by_notebook():
142
142
  gui_module_name = app.__class__.__module__.split(".")[0]
143
143
  if gui_module_name in QT_MODULE_NAMES:
144
144
  yield "qt", "running on Jupyter with qt gui"
145
- elif "wx" in app.__class__.__name__.lower() == "wx":
145
+ elif "wx" in app.__class__.__name__.lower():
146
146
  yield "wx", "running on Jupyter with wx gui"
147
147
 
148
148
  yield "anywidget", "running on Jupyter"
@@ -8,19 +8,18 @@ import sys
8
8
  import weakref
9
9
  from typing import TYPE_CHECKING
10
10
 
11
+ from . import contexts
12
+ from .core.coreutils import log_exception, logger # noqa: F401
11
13
  from .core.enums import (
12
- EventTypeEnum,
13
- UpdateModeEnum,
14
14
  CursorShape,
15
15
  CursorShapeEnum,
16
+ EventTypeEnum,
17
+ UpdateModeEnum,
16
18
  )
17
- from . import contexts
18
- from .core.size import SizeInfo
19
19
  from .core.events import EventEmitter
20
20
  from .core.loop import BaseLoop
21
21
  from .core.scheduler import Scheduler
22
- from .core.coreutils import logger, log_exception
23
-
22
+ from .core.size import SizeInfo
24
23
 
25
24
  if TYPE_CHECKING:
26
25
  from typing import Callable, Literal, Optional
@@ -46,7 +45,7 @@ __all__ = ["BaseLoop", "BaseRenderCanvas", "WrapperRenderCanvas"]
46
45
  class BaseCanvasGroup:
47
46
  """Represents a group of canvas objects from the same class, that share a loop."""
48
47
 
49
- def __init__(self, default_loop: BaseLoop):
48
+ def __init__(self, default_loop: BaseLoop | None):
50
49
  self._canvases = weakref.WeakSet()
51
50
  self._loop = None
52
51
  self.select_loop(default_loop)
@@ -59,7 +58,11 @@ class BaseCanvasGroup:
59
58
  loop._register_canvas_group(self)
60
59
  loop.add_task(task, name="scheduler-task")
61
60
 
62
- def select_loop(self, loop: BaseLoop) -> None:
61
+ def _unregister_canvas(self, canvas):
62
+ """Used by the canvas to unregister itself when closed."""
63
+ self._canvases.discard(canvas)
64
+
65
+ def select_loop(self, loop: BaseLoop | None) -> None:
63
66
  """Select the loop to use for this group of canvases."""
64
67
  if not (loop is None or isinstance(loop, BaseLoop)):
65
68
  raise TypeError("select_loop() requires a loop instance or None.")
@@ -76,17 +79,8 @@ class BaseCanvasGroup:
76
79
  """Get the currently associated loop (can be None for canvases that don't run a scheduler)."""
77
80
  return self._loop
78
81
 
79
- def get_canvases(self, *, close_closed=False) -> list[BaseRenderCanvas]:
80
- if close_closed:
81
- closed_canvases = [
82
- canvas for canvas in self._canvases if canvas.get_closed()
83
- ]
84
- for canvas in closed_canvases:
85
- canvas.close()
86
- self._canvases.discard(canvas)
87
- return self._canvases
88
- else:
89
- return [canvas for canvas in self._canvases if not canvas.get_closed()]
82
+ def get_canvases(self) -> list[BaseRenderCanvas]:
83
+ return [canvas for canvas in self._canvases]
90
84
 
91
85
 
92
86
  class BaseRenderCanvas:
@@ -113,7 +107,7 @@ class BaseRenderCanvas:
113
107
 
114
108
  """
115
109
 
116
- _rc_canvas_group = None
110
+ _rc_canvas_group: BaseCanvasGroup | None = None
117
111
  """Class attribute that refers to the ``CanvasGroup`` instance to use for canvases of this class.
118
112
  It specifies what loop is used, and enables users to changing the used loop.
119
113
  """
@@ -126,7 +120,7 @@ class BaseRenderCanvas:
126
120
  group = cls._rc_canvas_group
127
121
  if group is None:
128
122
  raise NotImplementedError(
129
- "The {cls.__name__} does not have a canvas group, thus no loop."
123
+ f"The {cls.__name__} does not have a canvas group, thus no loop."
130
124
  )
131
125
  group.select_loop(loop)
132
126
 
@@ -177,15 +171,14 @@ class BaseRenderCanvas:
177
171
  self._present_to_screen: bool | None = None # set in .get_context()
178
172
 
179
173
  # Variables and flags used internally
174
+ self.__is_closed = False
180
175
  self.__is_drawing = False
181
176
  self.__title_info = {
182
177
  "raw": "",
183
178
  "fps": "?",
184
179
  "ms": "?",
185
180
  "backend": self.__class__.__name__,
186
- "loop": self._rc_canvas_group.get_loop().__class__.__name__
187
- if (self._rc_canvas_group and self._rc_canvas_group.get_loop())
188
- else "no-loop",
181
+ "loop": "no-loop", # set below in most cases
189
182
  }
190
183
  self._size_info = SizeInfo()
191
184
 
@@ -198,6 +191,9 @@ class BaseRenderCanvas:
198
191
  # Group, but no loop: no scheduling
199
192
  self._rc_canvas_group._register_canvas(self, None)
200
193
  else:
194
+ self.__title_info["loop"] = (
195
+ self._rc_canvas_group.get_loop().__class__.__name__
196
+ )
201
197
  self.__scheduler = Scheduler(
202
198
  self,
203
199
  self._events,
@@ -571,7 +567,7 @@ class BaseRenderCanvas:
571
567
  size_is_nill
572
568
  or context is None
573
569
  or self._draw_frame is None
574
- or self._rc_get_closed()
570
+ or self.__is_closed
575
571
  ):
576
572
  if scheduler is not None:
577
573
  scheduler.on_cancel_draw()
@@ -681,28 +677,44 @@ class BaseRenderCanvas:
681
677
 
682
678
  def close(self) -> None:
683
679
  """Close the canvas."""
680
+ # Note that this function may be called multiple times, and may even be re-entered.
681
+ if self.__is_closed:
682
+ return
683
+ self.__is_closed = True
684
+ errors = []
685
+ # Unregister
686
+ loop = None
687
+ if self._rc_canvas_group is not None:
688
+ loop = self._rc_canvas_group.get_loop()
689
+ self._rc_canvas_group._unregister_canvas(self)
690
+ # Close the native canvas
691
+ try:
692
+ self._rc_close()
693
+ except Exception as err:
694
+ errors.append(err)
684
695
  # Clear the draw-function, to avoid it holding onto e.g. wgpu objects.
685
696
  self._draw_frame = None # type: ignore
686
697
  # Clear the canvas context too.
687
698
  try:
688
- self._canvas_context._rc_close() # type: ignore
689
- except Exception:
690
- pass
699
+ if self._canvas_context is not None:
700
+ self._canvas_context._rc_close() # type: ignore
701
+ except Exception as err:
702
+ errors.append(err)
691
703
  self._canvas_context = None
692
- # Clean events. Should already have happened in loop, but the loop may not be running.
704
+ # Close the event at least after get_closed() would return True
693
705
  self._events.close()
694
- # Let the subclass clean up.
695
- self._rc_close()
706
+ # Stop the loop if this was the last canvas. It's important to do now,
707
+ # because the native loop may stop right after, giving us no flow to properly close.
708
+ if loop is not None:
709
+ if not loop.get_canvases():
710
+ loop.stop()
711
+ # Errors
712
+ if errors:
713
+ raise errors[0]
696
714
 
697
715
  def get_closed(self) -> bool:
698
716
  """Get whether the window is closed."""
699
- return self._rc_get_closed()
700
-
701
- def is_closed(self):
702
- logger.warning(
703
- "canvas.is_closed() is deprecated, use canvas.get_closed() instead."
704
- )
705
- return self._rc_get_closed()
717
+ return self.__is_closed
706
718
 
707
719
  # %% Secondary canvas management methods
708
720
 
@@ -757,7 +769,18 @@ class BaseRenderCanvas:
757
769
  # %% Methods for the subclass to implement
758
770
 
759
771
  def _rc_gui_poll(self):
760
- """Process native events."""
772
+ """Process native events.
773
+
774
+ This method is called by the base class before each draw to move
775
+ GUI events into the rendercanvas event system.
776
+
777
+ In some cases one can naturally assume that the 'native' backend is running
778
+ and events are already processed. E.g. when in a notebook-like env.
779
+
780
+ In cases where the backend comes with its own event loop that already processes
781
+ events, ``_rc_gui_poll`` only need to do a poll if the current loop is
782
+ *not* the backend's own loop. E.g. qt and wx.
783
+ """
761
784
  pass
762
785
 
763
786
  def _rc_get_present_info(self, present_methods: list[str]) -> dict | None:
@@ -806,6 +829,9 @@ class BaseRenderCanvas:
806
829
  instance, backends that implement 'remote' rendering can allow new
807
830
  frames based on the number of in-flight frames and downstream
808
831
  throughput.
832
+
833
+ Backends that render on the current machine should simply call
834
+ ``_time_to_draw()`` directly.
809
835
  """
810
836
  self._time_to_draw() # Simple default
811
837
 
@@ -844,8 +870,9 @@ class BaseRenderCanvas:
844
870
  raise NotImplementedError()
845
871
 
846
872
  def _rc_set_logical_size(self, width: float, height: float):
847
- """Set the logical size. May be ignored when it makes no sense.
873
+ """Set the size of the canvas in logical pixels.
848
874
 
875
+ May be ignored when it makes no sense.
849
876
  The default implementation does nothing.
850
877
  """
851
878
  pass
@@ -853,33 +880,33 @@ class BaseRenderCanvas:
853
880
  def _rc_close(self):
854
881
  """Close the canvas.
855
882
 
856
- Note that ``BaseRenderCanvas`` implements the ``close()`` method, which is a
857
- rather common name; it may be necessary to re-implement that too.
883
+ This is the place to delete the native widget. It is not necessary to
884
+ emit a close event, because the base class handles that.
858
885
 
859
- Backends should probably not mark the canvas as closed yet, but wait until the
860
- underlying system really closes the canvas. Otherwise the loop may end before a
861
- canvas gets properly cleaned up.
886
+ In a backend, all flows that lead to a close must call ``.close()``, so
887
+ that ``BaseRenderCanvas`` has a clear place to handle closing. It calls
888
+ ``_rc_close()`` from there. The base class will call this method exactly once.
862
889
 
863
- Backends can emit a closed event, either in this method, or when the real close
864
- happens, but this is optional, since the loop detects canvases getting closed
865
- and sends the close event if this has not happened yet.
890
+ Note that if this is the last canvas to close, the loop is stopped immediately,
891
+ and some backends need some explicit polling in this case. Also see wx and glfw backends.
892
+
893
+ Note that if this backend class inherits both the native class and BaseRenderCanvas,
894
+ and the native class has a ``close()`` method, it is overridden by BaseRenderCanvas.
866
895
  """
867
896
  pass
868
897
 
869
- def _rc_get_closed(self) -> bool:
870
- """Get whether the canvas is closed."""
871
- return False
872
-
873
898
  def _rc_set_title(self, title: str):
874
- """Set the canvas title. May be ignored when it makes no sense.
899
+ """Set the canvas title.
875
900
 
901
+ May be ignored when it makes no sense.
876
902
  The default implementation does nothing.
877
903
  """
878
904
  pass
879
905
 
880
906
  def _rc_set_cursor(self, cursor: str):
881
- """Set the cursor shape. May be ignored.
907
+ """Set the cursor shape.
882
908
 
909
+ May be ignored when it makes no sense.
883
910
  The default implementation does nothing.
884
911
  """
885
912
  pass
@@ -953,6 +980,3 @@ class WrapperRenderCanvas(BaseRenderCanvas):
953
980
 
954
981
  def get_closed(self) -> bool:
955
982
  return self._subwidget.get_closed()
956
-
957
- def is_closed(self):
958
- return self._subwidget.is_closed()
@@ -47,7 +47,7 @@ class FullscreenTexture:
47
47
  dtype = "u8"
48
48
  else:
49
49
  raise ValueError(
50
- "Unsupported bitmap dtype/format '{m.format}', expecting unsigned bytes ('B')."
50
+ f"Unsupported bitmap dtype/format '{m.format}', expecting unsigned bytes ('B')."
51
51
  )
52
52
 
53
53
  # Get color format
@@ -1,7 +1,6 @@
1
- from .basecontext import BaseContext
2
-
3
1
  import numpy as np
4
2
 
3
+ from .basecontext import BaseContext
5
4
 
6
5
  __all__ = ["BitmapContext", "BitmapContextToBitmap", "BitmapContextToScreen"]
7
6
 
@@ -57,7 +56,7 @@ class BitmapContext(BaseContext):
57
56
  dtype = "u8"
58
57
  else:
59
58
  raise ValueError(
60
- "Unsupported bitmap dtype '{arr.dtype}', expecting unsigned bytes."
59
+ f"Unsupported bitmap dtype '{arr.dtype}', expecting unsigned bytes."
61
60
  )
62
61
 
63
62
  # Get color format
@@ -132,6 +131,7 @@ class BitmapContextToScreen(BitmapContext):
132
131
 
133
132
  # Init wgpu
134
133
  import wgpu
134
+
135
135
  from ._fullscreen import FullscreenTexture
136
136
 
137
137
  adapter = wgpu.gpu.request_adapter_sync(power_preference="high-performance")