vispy 0.14.0__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

vispy/app/backends/_sdl2.py

@@ -0,0 +1,444 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+"""vispy backend for sdl2."""
+
+from __future__ import division
+
+import atexit
+import ctypes
+from time import sleep
+import warnings
+import gc
+
+from ..base import (BaseApplicationBackend, BaseCanvasBackend,
+                    BaseTimerBackend)
+from ...util import keys, logger
+from ...util.ptime import time
+from ... import config
+
+USE_EGL = config['gl_backend'].lower().startswith('es')
+
+
+# -------------------------------------------------------------------- init ---
+
+try:
+    with warnings.catch_warnings(record=True):  # can throw warnings
+        import sdl2
+        import sdl2.ext
+
+    # Map native keys to vispy keys
+    KEYMAP = {
+        # http://www.ginkgobitter.org/sdl/?SDL_Keycode
+        sdl2.SDLK_LSHIFT: keys.SHIFT,
+        sdl2.SDLK_RSHIFT: keys.SHIFT,
+        sdl2.SDLK_LCTRL: keys.CONTROL,
+        sdl2.SDLK_RCTRL: keys.CONTROL,
+        sdl2.SDLK_LALT: keys.ALT,
+        sdl2.SDLK_RALT: keys.ALT,
+        sdl2.SDLK_LGUI: keys.META,
+        sdl2.SDLK_RGUI: keys.META,
+
+        sdl2.SDLK_LEFT: keys.LEFT,
+        sdl2.SDLK_UP: keys.UP,
+        sdl2.SDLK_RIGHT: keys.RIGHT,
+        sdl2.SDLK_DOWN: keys.DOWN,
+        sdl2.SDLK_PAGEUP: keys.PAGEUP,
+        sdl2.SDLK_PAGEDOWN: keys.PAGEDOWN,
+
+        sdl2.SDLK_INSERT: keys.INSERT,
+        sdl2.SDLK_DELETE: keys.DELETE,
+        sdl2.SDLK_HOME: keys.HOME,
+        sdl2.SDLK_END: keys.END,
+
+        sdl2.SDLK_ESCAPE: keys.ESCAPE,
+        sdl2.SDLK_BACKSPACE: keys.BACKSPACE,
+
+        sdl2.SDLK_F1: keys.F1,
+        sdl2.SDLK_F2: keys.F2,
+        sdl2.SDLK_F3: keys.F3,
+        sdl2.SDLK_F4: keys.F4,
+        sdl2.SDLK_F5: keys.F5,
+        sdl2.SDLK_F6: keys.F6,
+        sdl2.SDLK_F7: keys.F7,
+        sdl2.SDLK_F8: keys.F8,
+        sdl2.SDLK_F9: keys.F9,
+        sdl2.SDLK_F10: keys.F10,
+        sdl2.SDLK_F11: keys.F11,
+        sdl2.SDLK_F12: keys.F12,
+
+        sdl2.SDLK_SPACE: keys.SPACE,
+        sdl2.SDLK_RETURN: keys.ENTER,
+        sdl2.SDLK_TAB: keys.TAB,
+    }
+
+    BUTTONMAP = {sdl2.SDL_BUTTON_LEFT: 1,
+                 sdl2.SDL_BUTTON_MIDDLE: 2,
+                 sdl2.SDL_BUTTON_RIGHT: 3
+                 }
+except Exception as exp:
+    available, testable, why_not, which = False, False, str(exp), None
+else:
+    if USE_EGL:
+        available, testable, why_not = False, False, 'EGL not supported'
+    else:
+        available, testable, why_not = True, True, None
+    which = 'sdl2 %d.%d.%d' % sdl2.version_info[:3]
+
+_SDL2_INITIALIZED = False
+_VP_SDL2_ALL_WINDOWS = {}
+
+
+def _get_sdl2_windows():
+    return list(_VP_SDL2_ALL_WINDOWS.values())
+
+
+# -------------------------------------------------------------- capability ---
+
+capability = dict(  # things that can be set by the backend
+    title=True,
+    size=True,
+    position=True,
+    show=True,
+    vsync=True,
+    resizable=True,
+    decorate=True,
+    fullscreen=True,
+    context=True,
+    multi_window=True,
+    scroll=True,
+    parent=False,
+    always_on_top=False,
+)
+
+
+# ------------------------------------------------------- set_configuration ---
+
+def _set_config(c):
+    """Set gl configuration for SDL2"""
+    func = sdl2.SDL_GL_SetAttribute
+    func(sdl2.SDL_GL_RED_SIZE, c['red_size'])
+    func(sdl2.SDL_GL_GREEN_SIZE, c['green_size'])
+    func(sdl2.SDL_GL_BLUE_SIZE, c['blue_size'])
+    func(sdl2.SDL_GL_ALPHA_SIZE, c['alpha_size'])
+    func(sdl2.SDL_GL_DEPTH_SIZE, c['depth_size'])
+    func(sdl2.SDL_GL_STENCIL_SIZE, c['stencil_size'])
+    func(sdl2.SDL_GL_DOUBLEBUFFER, 1 if c['double_buffer'] else 0)
+    samps = c['samples']
+    func(sdl2.SDL_GL_MULTISAMPLEBUFFERS, 1 if samps > 0 else 0)
+    func(sdl2.SDL_GL_MULTISAMPLESAMPLES, samps if samps > 0 else 0)
+    func(sdl2.SDL_GL_STEREO, c['stereo'])
+
+
+# ------------------------------------------------------------- application ---
+
+class ApplicationBackend(BaseApplicationBackend):
+
+    def __init__(self):
+        BaseApplicationBackend.__init__(self)
+        self._timers = list()
+
+    def _add_timer(self, timer):
+        if timer not in self._timers:
+            self._timers.append(timer)
+
+    def _vispy_get_backend_name(self):
+        return 'SDL2'
+
+    def _vispy_process_events(self):
+        events = sdl2.ext.get_events()
+        while len(events) > 0:
+            for event in events:
+                _id = event.window.windowID
+                if _id in _VP_SDL2_ALL_WINDOWS:
+                    win = _VP_SDL2_ALL_WINDOWS[_id]
+                    win._on_event(event)
+            events = sdl2.ext.get_events()
+        for timer in self._timers:
+            timer._tick()
+        wins = _get_sdl2_windows()
+        for win in wins:
+            if win._needs_draw:
+                win._needs_draw = False
+                win._on_draw()
+
+    def _vispy_run(self):
+        wins = _get_sdl2_windows()
+        while any(w._id is not None for w in wins):
+            self._vispy_process_events()
+        self._vispy_quit()  # to clean up
+
+    def _vispy_quit(self):
+        # Close windows
+        wins = _get_sdl2_windows()
+        for win in wins:
+            win._vispy_close()
+        # tear down timers
+        for timer in self._timers:
+            timer._vispy_stop()
+        self._timers = []
+
+    def _vispy_get_native_app(self):
+        global _SDL2_INITIALIZED
+        if not _SDL2_INITIALIZED:
+            sdl2.ext.init()
+            atexit.register(sdl2.ext.quit)
+            _SDL2_INITIALIZED = True
+        return sdl2
+
+
+# ------------------------------------------------------------------ canvas ---
+
+class CanvasBackend(BaseCanvasBackend):
+    """SDL2 backend for Canvas abstract class."""
+
+    def __init__(self, vispy_canvas, **kwargs):
+        BaseCanvasBackend.__init__(self, vispy_canvas)
+        p = self._process_backend_kwargs(kwargs)
+        self._initialized = False
+
+        # Deal with config
+        _set_config(p.context.config)
+        # Deal with context
+        p.context.shared.add_ref('sdl2', self)
+        if p.context.shared.ref is self:
+            share = None
+        else:
+            other = p.context.shared.ref
+            share = other._id.window, other._native_context
+            sdl2.SDL_GL_MakeCurrent(*share)
+            sdl2.SDL_GL_SetAttribute(sdl2.SDL_GL_SHARE_WITH_CURRENT_CONTEXT, 1)
+
+        sdl2.SDL_GL_SetSwapInterval(1 if p.vsync else 0)
+        flags = sdl2.SDL_WINDOW_OPENGL
+        flags |= sdl2.SDL_WINDOW_SHOWN  # start out shown
+        flags |= sdl2.SDL_WINDOW_ALLOW_HIGHDPI
+        flags |= sdl2.SDL_WINDOW_RESIZABLE if p.resizable else 0
+        flags |= sdl2.SDL_WINDOW_BORDERLESS if not p.decorate else 0
+        if p.fullscreen is not False:
+            self._fullscreen = True
+            if p.fullscreen is not True:
+                logger.warning('Cannot specify monitor number for SDL2 '
+                               'fullscreen, using default')
+            flags |= sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP
+        else:
+            self._fullscreen = False
+        self._mods = list()
+        if p.position is None:
+            position = [sdl2.SDL_WINDOWPOS_UNDEFINED] * 2
+        else:
+            position = None
+        self._id = sdl2.ext.Window(p.title, p.size, position, flags)
+        if not self._id.window:
+            raise RuntimeError('Could not create window')
+        if share is None:
+            self._native_context = sdl2.SDL_GL_CreateContext(self._id.window)
+        else:
+            self._native_context = sdl2.SDL_GL_CreateContext(share[0])
+        self._sdl_id = sdl2.SDL_GetWindowID(self._id.window)
+        _VP_SDL2_ALL_WINDOWS[self._sdl_id] = self
+
+        # Init
+        self._initialized = True
+        self._needs_draw = False
+        self._vispy_canvas.set_current()
+        self._vispy_canvas.events.initialize()
+        if not p.show:
+            self._vispy_set_visible(False)
+
+    def _vispy_warmup(self):
+        etime = time() + 0.1
+        while time() < etime:
+            sleep(0.01)
+            self._vispy_canvas.set_current()
+            self._vispy_canvas.app.process_events()
+
+    def _vispy_set_current(self):
+        if self._id is None:
+            return
+        # Make this the current context
+        sdl2.SDL_GL_MakeCurrent(self._id.window, self._native_context)
+
+    def _vispy_swap_buffers(self):
+        if self._id is None:
+            return
+        # Swap front and back buffer
+        sdl2.SDL_GL_SwapWindow(self._id.window)
+
+    def _vispy_set_title(self, title):
+        if self._id is None:
+            return
+        # Set the window title. Has no effect for widgets
+        sdl2.SDL_SetWindowTitle(self._id.window, title.encode('UTF-8'))
+
+    def _vispy_set_size(self, w, h):
+        if self._id is None:
+            return
+        # Set size of the widget or window
+        sdl2.SDL_SetWindowSize(self._id.window, w, h)
+
+    def _vispy_set_position(self, x, y):
+        if self._id is None:
+            return
+        # Set position of the widget or window. May have no effect for widgets
+        sdl2.SDL_SetWindowPosition(self._id.window, x, y)
+
+    def _vispy_set_visible(self, visible):
+        # Show or hide the window or widget
+        if self._id is None:
+            return
+        if visible:
+            self._id.show()
+            # this ensures that the show takes effect
+            self._vispy_update()
+        else:
+            self._id.hide()
+
+    def _vispy_update(self):
+        # Invoke a redraw, passing it on to the canvas
+        if self._vispy_canvas is None or self._id is None:
+            return
+        # Mark that this window wants to be drawn on the next loop iter
+        self._needs_draw = True
+
+    def _vispy_close(self):
+        # Force the window or widget to shut down
+        if self._id is not None:
+            _id = self._id.window
+            self._vispy_canvas = None
+            self._id = None
+            sdl2.SDL_DestroyWindow(_id)
+            del _VP_SDL2_ALL_WINDOWS[self._sdl_id]
+            self._sdl_id = None
+            gc.collect()  # enforce gc to help context get destroyed
+
+    def _vispy_get_size(self):
+        if self._id is None:
+            return
+        w, h = ctypes.c_int(), ctypes.c_int()
+        sdl2.SDL_GetWindowSize(self._id.window,
+                               ctypes.byref(w), ctypes.byref(h))
+        w, h = w.value, h.value
+        return w, h
+
+    def _vispy_get_fullscreen(self):
+        return self._fullscreen
+
+    def _vispy_set_fullscreen(self, fullscreen):
+        self._fullscreen = bool(fullscreen)
+        flags = sdl2.SDL_WINDOW_FULLSCREEN_DESKTOP if self._fullscreen else 0
+        sdl2.SDL_SetWindowFullscreen(self._id.window, flags)
+
+    def _vispy_get_position(self):
+        if self._id is None:
+            return
+        x, y = ctypes.c_int(), ctypes.c_int()
+        sdl2.SDL_GetWindowPosition(self._id.window,
+                                   ctypes.byref(x), ctypes.byref(y))
+        x, y = x.value, y.value
+        return x, y
+
+    ##########################################
+    # Notify vispy of events triggered by SDL2
+    def _get_mouse_position(self):
+        if self._id is None:
+            return (0, 0)
+        x, y = ctypes.c_int(), ctypes.c_int()
+        sdl2.SDL_GetMouseState(ctypes.byref(x), ctypes.byref(y))
+        return x.value, y.value
+
+    def _on_draw(self):
+        if self._vispy_canvas is None or self._id is None:
+            return
+        self._vispy_canvas.set_current()
+        self._vispy_canvas.events.draw(region=None)  # (0, 0, w, h))
+
+    def _on_event(self, event):
+        if self._vispy_canvas is None:
+            return
+        # triage event to proper handler
+        if event.type == sdl2.SDL_QUIT:
+            self._vispy_canvas.close()
+        elif event.type == sdl2.SDL_WINDOWEVENT:
+            if event.window.event == sdl2.SDL_WINDOWEVENT_RESIZED:
+                w, h = event.window.data1, event.window.data2
+                self._vispy_canvas.events.resize(size=(w, h))
+            elif event.window.event == sdl2.SDL_WINDOWEVENT_CLOSE:
+                self._vispy_canvas.close()
+        elif event.type == sdl2.SDL_MOUSEMOTION:
+            x, y = event.motion.x, event.motion.y
+            self._vispy_mouse_move(pos=(x, y), modifiers=self._mods)
+        elif event.type in (sdl2.SDL_MOUSEBUTTONDOWN,
+                            sdl2.SDL_MOUSEBUTTONUP):
+            x, y = event.button.x, event.button.y
+            button = event.button.button
+            if button in BUTTONMAP:
+                button = BUTTONMAP.get(button, 0)
+                if event.type == sdl2.SDL_MOUSEBUTTONDOWN:
+                    func = self._vispy_mouse_press
+                else:
+                    func = self._vispy_mouse_release
+                func(pos=(x, y), button=button, modifiers=self._mods)
+        elif event.type == sdl2.SDL_MOUSEWHEEL:
+            pos = self._get_mouse_position()
+            delta = float(event.wheel.x), float(event.wheel.y)
+            self._vispy_canvas.events.mouse_wheel(pos=pos, delta=delta,
+                                                  modifiers=self._mods)
+        elif event.type in (sdl2.SDL_KEYDOWN, sdl2.SDL_KEYUP):
+            down = (event.type == sdl2.SDL_KEYDOWN)
+            keysym = event.key.keysym
+            mods = keysym.mod
+            key = keysym.sym
+            self._process_mod(mods, down)
+            if key in KEYMAP:
+                key, text = KEYMAP[key], ''
+            elif key >= 32 and key <= 127:
+                key, text = keys.Key(chr(key)), chr(key)
+            else:
+                key, text = None, ''
+            if down:
+                fun = self._vispy_canvas.events.key_press
+            else:
+                fun = self._vispy_canvas.events.key_release
+            fun(key=key, text=text, modifiers=self._mods)
+
+    def _process_mod(self, key, down):
+        _modifiers = list()
+        if key & (sdl2.SDLK_LSHIFT | sdl2.SDLK_RSHIFT):
+            _modifiers.append(keys.SHIFT)
+        if key & (sdl2.SDLK_LCTRL | sdl2.SDLK_RCTRL):
+            _modifiers.append(keys.CONTROL)
+        if key & (sdl2.SDLK_LALT | sdl2.SDLK_RALT):
+            _modifiers.append(keys.ALT)
+        if key & (sdl2.SDLK_LGUI | sdl2.SDLK_RGUI):
+            _modifiers.append(keys.META)
+        for mod in _modifiers:
+            if mod not in self._mods:
+                if down:
+                    self._mods.append(mod)
+            elif not down:
+                self._mods.pop(self._mods.index(mod))
+
+# ------------------------------------------------------------------- timer ---
+
+
+# XXX should probably use SDL_Timer (and SDL_INIT_TIMER)
+
+class TimerBackend(BaseTimerBackend):
+
+    def __init__(self, vispy_timer):
+        BaseTimerBackend.__init__(self, vispy_timer)
+        vispy_timer._app._backend._add_timer(self)
+        self._vispy_stop()
+
+    def _vispy_start(self, interval):
+        self._interval = interval
+        self._next_time = time() + self._interval
+
+    def _vispy_stop(self):
+        self._next_time = float('inf')
+
+    def _tick(self):
+        if time() >= self._next_time:
+            self._vispy_timer._timeout()
+            self._next_time = time() + self._interval

vispy/app/backends/_template.py

@@ -0,0 +1,244 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+"""This module provides an template for creating backends for vispy.
+It clearly indicates what methods should be implemented and what events
+should be emitted.
+"""
+
+from __future__ import division
+
+from ..base import (BaseApplicationBackend, BaseCanvasBackend,
+                    BaseTimerBackend)
+from ...util import keys
+from ... import config
+
+USE_EGL = config['gl_backend'].lower().startswith('es')
+
+
+# -------------------------------------------------------------------- init ---
+
+# Map native keys to vispy keys
+KEYMAP = {
+    -1: keys.SHIFT,
+    -2: keys.CONTROL,
+    -3: keys.ALT,
+    -4: keys.META,
+
+    -5: keys.LEFT,
+    -6: keys.UP,
+    -7: keys.RIGHT,
+    -8: keys.DOWN,
+    -9: keys.PAGEUP,
+    -10: keys.PAGEDOWN,
+
+    -11: keys.INSERT,
+    -12: keys.DELETE,
+    -13: keys.HOME,
+    -14: keys.END,
+
+    -15: keys.ESCAPE,
+    -16: keys.BACKSPACE,
+
+    -17: keys.SPACE,
+    -18: keys.ENTER,
+    -19: keys.TAB,
+
+    -20: keys.F1,
+    -21: keys.F2,
+    -22: keys.F3,
+    -23: keys.F4,
+    -24: keys.F5,
+    -25: keys.F6,
+    -26: keys.F7,
+    -27: keys.F8,
+    -28: keys.F9,
+    -29: keys.F10,
+    -30: keys.F11,
+    -31: keys.F12,
+}
+
+
+# -------------------------------------------------------------- capability ---
+
+# These are all booleans. Note that they mirror many of the kwargs to
+# the initialization of the Canvas class.
+capability = dict(
+    # if True they mean:
+    title=False,          # can set title on the fly
+    size=False,           # can set size on the fly
+    position=False,       # can set position on the fly
+    show=False,           # can show/hide window XXX ?
+    vsync=False,          # can set window to sync to blank
+    resizable=False,      # can toggle resizability (e.g., no user resizing)
+    decorate=False,       # can toggle decorations
+    fullscreen=False,     # fullscreen window support
+    context=False,        # can share contexts between windows
+    multi_window=False,   # can use multiple windows at once
+    scroll=False,         # scroll-wheel events are supported
+    parent=False,         # can pass native widget backend parent
+    always_on_top=False,  # can be made always-on-top
+)
+
+
+# ------------------------------------------------------- set_configuration ---
+def _set_config(c):
+    """Set gl configuration for template"""
+    raise NotImplementedError
+
+
+# ------------------------------------------------------------- application ---
+
+class ApplicationBackend(BaseApplicationBackend):
+
+    def __init__(self):
+        BaseApplicationBackend.__init__(self)
+
+    def _vispy_get_backend_name(self):
+        return 'ThisBackendsName'
+
+    def _vispy_process_events(self):
+        raise NotImplementedError()
+
+    def _vispy_run(self):
+        raise NotImplementedError()
+
+    def _vispy_quit(self):
+        raise NotImplementedError()
+
+    def _vispy_get_native_app(self):
+        raise NotImplementedError()
+
+
+# ------------------------------------------------------------------ canvas ---
+
+# You can mix this class with the native widget
+class CanvasBackend(BaseCanvasBackend):
+    """Template backend
+
+    Events to emit are shown below. Most backends will probably
+    have one method for each event:
+
+        self._vispy_canvas.events.initialize()
+        self._vispy_canvas.events.resize(size=(w, h))
+        self._vispy_canvas.events.draw(region=None)
+        self._vispy_canvas.close()
+        self._vispy_canvas.events.mouse_press(pos=(x, y), button=1,
+                                              modifiers=())
+        self._vispy_canvas.events.mouse_release(pos=(x, y), button=1,
+                                                modifiers=())
+        self._vispy_canvas.events.mouse_double_click(pos=(x, y), button=1,
+                                                     modifiers=())
+        self._vispy_canvas.events.mouse_move(pos=(x, y), modifiers=())
+        self._vispy_canvas.events.mouse_wheel(pos=(x, y), delta=(0, 0),
+                                              modifiers=())
+        self._vispy_canvas.events.key_press(key=key, text=text, modifiers=())
+        self._vispy_canvas.events.key_release(key=key, text=text, modifiers=())
+
+    In most cases, if the window-cross is clicked, a native close-event is
+    generated, which should then call canvas.close(). The Canvas class is
+    responsible for firing the close event and calling
+    backend_canvas._vispy_close, which closes the native widget.
+    If this happens to result in a second close event, canvas.close() gets
+    called again, but Canvas knows it is closing so it stops there.
+
+    If canvas.close() is called (by the user), it calls
+    backend_canvas._vispy_close, which closes the native widget,
+    and we get the same stream of actions as above. This deviation from
+    having events come from the CanvasBackend is necessitated by how
+    different backends handle close events, and the various ways such
+    events can be triggered.
+    """
+
+    def __init__(self, vispy_canvas, **kwargs):
+        BaseCanvasBackend.__init__(self, vispy_canvas)
+        # We use _process_backend_kwargs() to "serialize" the kwargs
+        # and to check whether they match this backend's capability
+        p = self._process_backend_kwargs(kwargs)
+
+        # Deal with config
+        # ... use context.config
+        # Deal with context
+        p.context.shared.add_ref('backend-name', self)
+        if p.context.shared.ref is self:
+            self._native_context = None  # ...
+        else:
+            self._native_context = p.context.shared.ref._native_context
+
+        # NativeWidgetClass.__init__(self, foo, bar)
+
+    def _vispy_set_current(self):
+        # Make this the current context
+        raise NotImplementedError()
+
+    def _vispy_swap_buffers(self):
+        # Swap front and back buffer
+        raise NotImplementedError()
+
+    def _vispy_set_title(self, title):
+        # Set the window title. Has no effect for widgets
+        raise NotImplementedError()
+
+    def _vispy_set_size(self, w, h):
+        # Set size of the widget or window
+        raise NotImplementedError()
+
+    def _vispy_set_position(self, x, y):
+        # Set location of the widget or window. May have no effect for widgets
+        raise NotImplementedError()
+
+    def _vispy_set_visible(self, visible):
+        # Show or hide the window or widget
+        raise NotImplementedError()
+
+    def _vispy_set_fullscreen(self, fullscreen):
+        # Set the current fullscreen state
+        raise NotImplementedError()
+
+    def _vispy_update(self):
+        # Invoke a redraw
+        raise NotImplementedError()
+
+    def _vispy_close(self):
+        # Force the window or widget to shut down
+        raise NotImplementedError()
+
+    def _vispy_get_size(self):
+        # Should return widget size
+        raise NotImplementedError()
+
+    def _vispy_get_position(self):
+        # Should return widget position
+        raise NotImplementedError()
+
+    def _vispy_get_fullscreen(self):
+        # Should return the current fullscreen state
+        raise NotImplementedError()
+
+    def _vispy_get_native_canvas(self):
+        # Should return the native widget object.
+        # If this is self, this method can be omitted.
+        return self
+
+
+# ------------------------------------------------------------------- timer ---
+
+class TimerBackend(BaseTimerBackend):  # Can be mixed with native timer class
+
+    def __init__(self, vispy_timer):
+        BaseTimerBackend.__init__(self, vispy_timer)
+
+    def _vispy_start(self, interval):
+        raise NotImplementedError()
+
+    def _vispy_stop(self):
+        raise NotImplementedError()
+
+    def _vispy_timeout(self):
+        raise NotImplementedError()
+
+    def _vispy_get_native_timer(self):
+        # Should return the native widget object.
+        # If this is self, this method can be omitted.
+        return self

vispy/app/backends/_test.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) Vispy Development Team. All Rights Reserved.
+# Distributed under the (new) BSD License. See LICENSE.txt for more info.
+
+available = False
+why_not = 'test backend should be skipped'
+testable = False
+which = None