pyglet 2.0.8__zip → 2.0.10__zip

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/font/win32.py

@@ -4,6 +4,8 @@ import math
 import warnings
 
 from sys import byteorder
+from typing import Optional
+
 import pyglet
 from pyglet.font import base
 from pyglet.font import win32query
@@ -25,7 +27,10 @@ def str_ucs2(text):
         text = text.encode('utf_16_le')   # explicit endian avoids BOM
     return create_string_buffer(text + '\0')
 
+
 _debug_dir = 'debug_font'
+
+
 def _debug_filename(base, extension):
     import os
     if not os.path.exists(_debug_dir):
@@ -36,20 +41,24 @@ def _debug_filename(base, extension):
         num += 1
     return name.format(num, extension)
 
+
 def _debug_image(image, name):
     filename = _debug_filename(name, 'png')
     image.save(filename)
     _debug(f'Saved image {image} to {filename}')
 
+
 _debug_logfile = None
+
+
 def _debug(msg):
     global _debug_logfile
     if not _debug_logfile:
         _debug_logfile = open(_debug_filename('log', 'txt'), 'wt')
     _debug_logfile.write(msg + '\n')
 
-class Win32GlyphRenderer(base.GlyphRenderer):
 
+class Win32GlyphRenderer(base.GlyphRenderer):
 
     def __init__(self, font):
         self._bitmap = None
@@ -67,13 +76,15 @@ class Win32GlyphRenderer(base.GlyphRenderer):
 
         gdi32.SelectObject(self._dc, self.font.hfont)
 
-    def _create_bitmap(self, width, height):
+    def _create_bitmap(self, width, height) -> None:
         pass
 
-    def render(self, text):
+    def render(self, text: str) -> pyglet.font.base.Glyph:
         raise NotImplementedError('abstract')
 
+
 class GDIGlyphRenderer(Win32GlyphRenderer):
+
     def __del__(self):
         try:
             if self._dc:
@@ -83,18 +94,22 @@ class GDIGlyphRenderer(Win32GlyphRenderer):
         except:
             pass
 
-    def render(self, text):
+    def render(self, text: str) -> pyglet.font.base.Glyph:
         # Attempt to get ABC widths (only for TrueType)
         abc = ABC()
-        if gdi32.GetCharABCWidthsW(self._dc,
-            ord(text), ord(text), byref(abc)):
+        if gdi32.GetCharABCWidthsW(
+            self._dc,
+            ord(text), ord(text), byref(abc)
+        ):
             width = abc.abcB
             lsb = abc.abcA
             advance = abc.abcA + abc.abcB + abc.abcC
+
         else:
             width_buf = c_int()
-            gdi32.GetCharWidth32W(self._dc,
-                ord(text), ord(text), byref(width_buf))
+            gdi32.GetCharWidth32W(
+                self._dc, ord(text), ord(text), byref(width_buf))
+
             width = width_buf.value
             lsb = 0
             advance = width
@@ -120,7 +135,7 @@ class GDIGlyphRenderer(Win32GlyphRenderer):
 
         return glyph
 
-    def _get_image(self, text, width, height, lsb):
+    def _get_image(self, text: str, width: int, height: int, lsb: int) -> pyglet.image.ImageData:
         # There's no such thing as a greyscale bitmap format in GDI.  We can
         # create an 8-bit palette bitmap with 256 shades of grey, but
         # unfortunately antialiasing will not work on such a bitmap.  So, we
@@ -134,16 +149,20 @@ class GDIGlyphRenderer(Win32GlyphRenderer):
 
         # Draw to DC
         user32.FillRect(self._dc, byref(self._bitmap_rect), self._black)
-        gdi32.ExtTextOutA(self._dc, -lsb, 0, 0, None, text,
+        gdi32.ExtTextOutA(
+            self._dc, -lsb, 0, 0, None, text,
             len(text), None)
+
         gdi32.GdiFlush()
 
         # Create glyph object and copy bitmap data to texture
-        image = pyglet.image.ImageData(width, height,
+        image = pyglet.image.ImageData(
+            width, height,
             'AXXX', self._bitmap_data, self._bitmap_rect.right * 4)
+
         return image
 
-    def _create_bitmap(self, width, height):
+    def _create_bitmap(self, width: int, height: int) -> None:
         self._black = gdi32.GetStockObject(BLACK_BRUSH)
         self._white = gdi32.GetStockObject(WHITE_BRUSH)
 
@@ -163,7 +182,8 @@ class GDIGlyphRenderer(Win32GlyphRenderer):
         info.bmiHeader.biCompression = BI_RGB
 
         self._dc = gdi32.CreateCompatibleDC(None)
-        self._bitmap = gdi32.CreateDIBSection(None,
+        self._bitmap = gdi32.CreateDIBSection(
+            None,
             byref(info), DIB_RGB_COLORS, byref(data), None,
             0)
         # Spookiness: the above line causes a "not enough storage" error,
@@ -186,10 +206,17 @@ class GDIGlyphRenderer(Win32GlyphRenderer):
             _debug(f'pitch = {pitch}')
             _debug(f'info.bmiHeader.biSize = {info.bmiHeader.biSize}')
 
+
 class Win32Font(base.Font):
+
     glyph_renderer_class = GDIGlyphRenderer
 
-    def __init__(self, name, size, bold=False, italic=False, stretch=False, dpi=None):
+    def __init__(
+            self,
+            name: str, size: int,
+            bold: bool = False, italic: bool = False, stretch: bool = False,
+            dpi: Optional[float] = None
+    ):
         super(Win32Font, self).__init__()
 
         self.logfont = self.get_logfont(name, size, bold, italic, dpi)
@@ -208,16 +235,35 @@ class Win32Font(base.Font):
         gdi32.DeleteObject(self.hfont)
 
     @staticmethod
-    def get_logfont(name, size, bold, italic, dpi):
+    def get_logfont(name: str, size: float, bold: bool, italic: bool, dpi: Optional[float] = None) -> LOGFONTW:
+        """Get a raw Win32 :py:class:`.LOGFONTW` struct for the given arguments.
+
+        Args:
+            name: The name of the font
+            size: The font size in points
+            bold: Whether to request the font as bold
+            italic: Whether to request the font as italic
+            dpi: The screen dpi
+
+        Returns:
+            LOGFONTW: a ctypes binding of a Win32 LOGFONTW struct
+        """
+
         # Create a dummy DC for coordinate mapping
         with device_context(None) as dc:
+
+            # Default to 96 DPI unless otherwise specified
             if dpi is None:
                 dpi = 96
-            logpixelsy = dpi
+            log_pixels_y = dpi
 
+            # Create LOGFONTW font description struct
             logfont = LOGFONTW()
-            # Conversion of point size to device pixels
-            logfont.lfHeight = int(-size * logpixelsy // 72)
+
+            # Convert point size to actual device pixels
+            logfont.lfHeight = int(-size * log_pixels_y // 72)
+
+            # Configure the LOGFONTW's font properties
             if bold:
                 logfont.lfWeight = FW_BOLD
             else:
@@ -229,7 +275,7 @@ class Win32Font(base.Font):
         return logfont
 
     @classmethod
-    def have_font(cls, name):
+    def have_font(cls, name) -> bool:
         # [ ] add support for loading raster fonts
         return win32query.have_font(name)
 
@@ -243,8 +289,8 @@ class Win32Font(base.Font):
             raise ctypes.WinError()
 
 
-# --- GDI+ font rendering ---
 
+# --- GDI+ font rendering ---
 from pyglet.image.codecs.gdiplus import PixelFormat32bppARGB, gdiplus, Rect
 from pyglet.image.codecs.gdiplus import ImageLockModeRead, BitmapData
 
@@ -263,6 +309,7 @@ StringFormatFlagsNoWrap = 0x00001000
 StringFormatFlagsLineLimit = 0x00002000
 StringFormatFlagsNoClip = 0x00004000
 
+
 class Rectf(ctypes.Structure):
     _fields_ = [
         ('x', ctypes.c_float),
@@ -271,6 +318,7 @@ class Rectf(ctypes.Structure):
         ('height', ctypes.c_float),
     ]
 
+
 class GDIPlusGlyphRenderer(Win32GlyphRenderer):
     def __del__(self):
         try:
@@ -288,7 +336,7 @@ class GDIPlusGlyphRenderer(Win32GlyphRenderer):
             pass
 
     def _create_bitmap(self, width, height):
-        self._data = (ctypes.c_byte * (4 * width * height))()
+        self._data = (BYTE * (4 * width * height))()
         self._bitmap = ctypes.c_void_p()
         self._format = PixelFormat32bppARGB
         gdiplus.GdipCreateBitmapFromScan0(width, height, width * 4,
@@ -305,11 +353,9 @@ class GDIPlusGlyphRenderer(Win32GlyphRenderer):
         gdiplus.GdipSetTextRenderingHint(self._graphics,
             TextRenderingHintAntiAliasGridFit)
 
-
         self._brush = ctypes.c_void_p()
         gdiplus.GdipCreateSolidFill(0xffffffff, ctypes.byref(self._brush))
 
-
         self._matrix = ctypes.c_void_p()
         gdiplus.GdipCreateMatrix(ctypes.byref(self._matrix))
 
@@ -429,11 +475,13 @@ class GDIPlusGlyphRenderer(Win32GlyphRenderer):
                                ctypes.byref(rect),
                                fmt,
                                self._brush)
+
         gdiplus.GdipFlush(self._graphics, 1)
         gdiplus.GdipDeleteStringFormat(fmt)
 
         bitmap_data = BitmapData()
-        gdiplus.GdipBitmapLockBits(self._bitmap,
+        gdiplus.GdipBitmapLockBits(
+            self._bitmap,
             byref(self._rect), ImageLockModeRead, self._format,
             byref(bitmap_data))
 
@@ -445,7 +493,8 @@ class GDIPlusGlyphRenderer(Win32GlyphRenderer):
         # Unlock data
         gdiplus.GdipBitmapUnlockBits(self._bitmap, byref(bitmap_data))
 
-        image = pyglet.image.ImageData(width, height,
+        image = pyglet.image.ImageData(
+            width, height,
             'BGRA', buffer, -bitmap_data.Stride)
 
         glyph = self.font.create_glyph(image)
@@ -454,11 +503,13 @@ class GDIPlusGlyphRenderer(Win32GlyphRenderer):
         glyph.set_bearings(-self.font.descent, lsb, advance)
         return glyph
 
+
 FontStyleBold = 1
 FontStyleItalic = 2
 UnitPixel = 2
 UnitPoint = 3
 
+
 class GDIPlusFont(Win32Font):
     glyph_renderer_class = GDIPlusGlyphRenderer
 
@@ -481,6 +532,12 @@ class GDIPlusFont(Win32Font):
         self._name = name
 
         family = ctypes.c_void_p()
+
+        # GDI will add @ in front of a localized font for some Asian languages. However, GDI will also not find it
+        # based on that name (???). Here we remove it before checking font collections.
+        if name[0] == "@":
+            name = name[1:]
+
         name = ctypes.c_wchar_p(name)
 
         # Look in private collection first:
@@ -489,6 +546,9 @@ class GDIPlusFont(Win32Font):
 
         # Then in system collection:
         if not family:
+            if _debug_font:
+                print(f"Warning: Font '{name}' was not found. Defaulting to: {self._default_name}")
+
             gdiplus.GdipCreateFontFamilyFromName(name, None, ctypes.byref(family))
 
         # Nothing found, use default font.

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/gl/base.py

@@ -1,4 +1,10 @@
+import weakref
+
 from enum import Enum
+import threading
+from typing import Tuple
+
+import pyglet
 
 from pyglet import gl
 from pyglet.gl import gl_info
@@ -162,7 +168,7 @@ class Config:
 
 
 class CanvasConfig(Config):
-    """OpenGL configuration for a particular canvas.
+    """An OpenGL configuration for a particular canvas.
 
     Use `Config.match` to obtain an instance of this class.
 
@@ -204,16 +210,16 @@ class CanvasConfig(Config):
 
 class ObjectSpace:
     def __init__(self):
-        # Textures and buffers scheduled for deletion
-        # the next time this object space is active.
+        # Objects scheduled for deletion the next time this object space is active.
         self.doomed_textures = []
         self.doomed_buffers = []
-        self.doomed_vaos = []
         self.doomed_shader_programs = []
+        self.doomed_shaders = []
+        self.doomed_renderbuffers = []
 
 
 class Context:
-    """OpenGL context for drawing.
+    """An OpenGL context for drawing.
 
     Use `CanvasConfig.create_context` to create a context.
 
@@ -231,14 +237,25 @@ class Context:
         self.context_share = context_share
         self.canvas = None
 
+        self.doomed_vaos = []
+        self.doomed_framebuffers = []
+
         if context_share:
             self.object_space = context_share.object_space
         else:
             self.object_space = ObjectSpace()
 
+        self._cached_programs = weakref.WeakValueDictionary()
+
     def __repr__(self):
         return f"{self.__class__.__name__}(id={id(self)}, share={self.context_share})"
 
+    def __enter__(self):
+        self.set_current()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return
+
     def attach(self, canvas):
         if self.canvas is not None:
             self.detach()
@@ -263,28 +280,49 @@ class Context:
             self._info = gl_info.GLInfo()
             self._info.set_active_context()
 
-        # Release Textures, Buffers, and VAOs on this context scheduled for
-        # deletion. Note that the garbage collector may introduce a race
-        # condition, so operate on a copy, and clear the list afterwards.
         if self.object_space.doomed_textures:
-            textures = self.object_space.doomed_textures[:]
-            textures = (gl.GLuint * len(textures))(*textures)
-            gl.glDeleteTextures(len(textures), textures)
-            self.object_space.doomed_textures.clear()
+            self._delete_objects(self.object_space.doomed_textures, gl.glDeleteTextures)
         if self.object_space.doomed_buffers:
-            buffers = self.object_space.doomed_buffers[:]
-            buffers = (gl.GLuint * len(buffers))(*buffers)
-            gl.glDeleteBuffers(len(buffers), buffers)
-            self.object_space.doomed_buffers.clear()
-        if self.object_space.doomed_vaos:
-            vaos = self.object_space.doomed_vaos[:]
-            vaos = (gl.GLuint * len(vaos))(*vaos)
-            gl.glDeleteVertexArrays(len(vaos), vaos)
-            self.object_space.doomed_vaos.clear()
+            self._delete_objects(self.object_space.doomed_buffers, gl.glDeleteBuffers)
         if self.object_space.doomed_shader_programs:
-            for program_id in self.object_space.doomed_shader_programs:
-                gl.glDeleteProgram(program_id)
-            self.object_space.doomed_shader_programs.clear()
+            self._delete_objects_one_by_one(self.object_space.doomed_shader_programs,
+                                            gl.glDeleteProgram)
+        if self.object_space.doomed_shaders:
+            self._delete_objects_one_by_one(self.object_space.doomed_shaders, gl.glDeleteShader)
+        if self.object_space.doomed_renderbuffers:
+            self._delete_objects(self.object_space.doomed_renderbuffers, gl.glDeleteRenderbuffers)
+
+        if self.doomed_vaos:
+            self._delete_objects(self.doomed_vaos, gl.glDeleteVertexArrays)
+        if self.doomed_framebuffers:
+            self._delete_objects(self.doomed_framebuffers, gl.glDeleteFramebuffers)
+
+    # For the functions below:
+    # The garbage collector introduces a race condition.
+    # The provided list might be appended to (and only appended to) while this
+    # method runs, as it's a `doomed_*` list either on the context or its
+    # object space. If `count` wasn't stored in a local, this method might
+    # leak objects.
+    def _delete_objects(self, list_, deletion_func):
+        """Release all OpenGL objects in the given list using the supplied
+        deletion function with the signature ``(GLuint count, GLuint *names)``.
+        """
+        count = len(list_)
+        to_delete = list_[:count]
+        del list_[:count]
+
+        deletion_func(count, (gl.GLuint * count)(*to_delete))
+
+    def _delete_objects_one_by_one(self, list_, deletion_func):
+        """Similar to ``_delete_objects``, but assumes the deletion functions's
+        signature to be ``(GLuint name)``, calling it once for each object.
+        """
+        count = len(list_)
+        to_delete = list_[:count]
+        del list_[:count]
+
+        for name in to_delete:
+            deletion_func(gl.GLuint(name))
 
     def destroy(self):
         """Release the context.
@@ -304,26 +342,80 @@ class Context:
             if gl._shadow_window is not None:
                 gl._shadow_window.switch_to()
 
+    def _safe_to_operate_on_object_space(self):
+        """Return whether it is safe to interact with this context's object
+        space.
+
+        This is considered to be the case if the currently active context's
+        object space is the same as this context's object space and this
+        method is called from the main thread.
+        """
+        return (
+            self.object_space is gl.current_context.object_space and
+            threading.current_thread() is threading.main_thread()
+        )
+
+    def _safe_to_operate_on(self):
+        """Return whether it is safe to interact with this context.
+
+        This is considered to be the case if it's the current context and this
+        method is called from the main thread.
+        """
+        return gl.current_context is self and threading.current_thread() is threading.main_thread()
+
+    def create_program(self, *sources: Tuple[str, str], program_class=None):
+        """Create a ShaderProgram from OpenGL GLSL source.
+
+        This is a convenience method that takes one or more tuples of
+        (source_string, shader_type), and returns a
+        :py:class:`~pyglet.graphics.shader.ShaderProgram` instance.
+
+        `source_string` is OpenGL GLSL source code as a str, and `shader_type`
+        is the OpenGL shader type, such as "vertex" or "fragment". See
+        :py:class:`~pyglet.graphics.shader.Shader` for more information.
+
+        .. note:: This method is cached. Given the same shader sources, the
+                  same ShaderProgram instance will be returned. For more
+                  control over the ShaderProgram lifecycle, it is recommended
+                  to manually create Shaders and link ShaderPrograms.
+
+        .. versionadded:: 2.0.10
+        """
+        if program := self._cached_programs.get(str(sources)):
+            return program
+
+        program_class = program_class or pyglet.graphics.shader.ShaderProgram
+        shaders = (pyglet.graphics.shader.Shader(src, srctype) for (src, srctype) in sources)
+        program = program_class(*shaders)
+        self._cached_programs[str(sources)] = program
+
+        return program
+
     def delete_texture(self, texture_id):
-        """Safely delete a Texture belonging to this context.
+        """Safely delete a Texture belonging to this context's object space.
 
-        Usually, the Texture is released immediately using
-        ``glDeleteTextures``, however if another context that does not share
-        this context's object space is currently active, the deletion will
-        be deferred until an appropriate context is activated.
+        This method will delete the texture immediately via
+        ``glDeleteTextures`` if the current context's object space is the same
+        as this context's object space and it is called from the main thread.
+
+        Otherwise, the texture will only be marked for deletion, postponing
+        it until any context with the same object space becomes active again.
+
+        This makes it safe to call from anywhere, including other threads.
 
         :Parameters:
             `texture_id` : int
                 The OpenGL name of the Texture to delete.
 
         """
-        if self.object_space is gl.current_context.object_space:
+        if self._safe_to_operate_on_object_space():
             gl.glDeleteTextures(1, gl.GLuint(texture_id))
         else:
             self.object_space.doomed_textures.append(texture_id)
 
     def delete_buffer(self, buffer_id):
-        """Safely delete a Buffer object belonging to this context.
+        """Safely delete a Buffer object belonging to this context's object
+        space.
 
         This method behaves similarly to `delete_texture`, though for
         ``glDeleteBuffers`` instead of ``glDeleteTextures``.
@@ -334,16 +426,73 @@ class Context:
 
         .. versionadded:: 1.1
         """
-        if self.object_space is gl.current_context.object_space and False:
+        if self._safe_to_operate_on_object_space():
             gl.glDeleteBuffers(1, gl.GLuint(buffer_id))
         else:
             self.object_space.doomed_buffers.append(buffer_id)
 
+    def delete_shader_program(self, program_id):
+        """Safely delete a Shader Program belonging to this context's
+        object space.
+
+        This method behaves similarly to `delete_texture`, though for
+        ``glDeleteProgram`` instead of ``glDeleteTextures``.
+
+        :Parameters:
+            `program_id` : int
+                The OpenGL name of the Shader Program to delete.
+
+        .. versionadded:: 2.0
+        """
+        if self._safe_to_operate_on_object_space():
+            gl.glDeleteProgram(gl.GLuint(program_id))
+        else:
+            self.object_space.doomed_shader_programs.append(program_id)
+
+    def delete_shader(self, shader_id):
+        """Safely delete a Shader belonging to this context's object space.
+
+        This method behaves similarly to `delete_texture`, though for
+        ``glDeleteShader`` instead of ``glDeleteTextures``.
+
+        :Parameters:
+            `shader_id` : int
+                The OpenGL name of the Shader to delete.
+
+        .. versionadded:: 2.0.10
+        """
+        if self._safe_to_operate_on_object_space():
+            gl.glDeleteShader(gl.GLuint(shader_id))
+        else:
+            self.object_space.doomed_shaders.append(shader_id)
+
+    def delete_renderbuffer(self, rbo_id):
+        """Safely delete a Renderbuffer Object belonging to this context's
+        object space.
+
+        This method behaves similarly to `delete_texture`, though for
+        ``glDeleteRenderbuffers`` instead of ``glDeleteTextures``.
+
+        :Parameters:
+            `rbo_id` : int
+                The OpenGL name of the Shader Program to delete.
+
+        .. versionadded:: 2.0.10
+        """
+        if self._safe_to_operate_on_object_space():
+            gl.glDeleteRenderbuffers(1, gl.GLuint(rbo_id))
+        else:
+            self.object_space.doomed_renderbuffers.append(rbo_id)
+
     def delete_vao(self, vao_id):
         """Safely delete a Vertex Array Object belonging to this context.
 
-        This method behaves similarly to `delete_texture`, though for
-        ``glDeleteVertexArrays`` instead of ``glDeleteTextures``.
+        If this context is not the current context or this method is not
+        called from the main thread, its deletion will be postponed until
+        this context is next made active again.
+
+        Otherwise, this method will immediately delete the VAO via
+        ``glDeleteVertexArrays``.
 
         :Parameters:
             `vao_id` : int
@@ -351,27 +500,27 @@ class Context:
 
         .. versionadded:: 2.0
         """
-        if gl.current_context and self.object_space is gl.current_context.object_space and False:
+        if self._safe_to_operate_on():
             gl.glDeleteVertexArrays(1, gl.GLuint(vao_id))
         else:
-            self.object_space.doomed_vaos.append(vao_id)
+            self.doomed_vaos.append(vao_id)
 
-    def delete_shader_program(self, program_id):
-        """Safely delete a Shader Program belonging to this context.
+    def delete_framebuffer(self, fbo_id):
+        """Safely delete a Framebuffer Object belonging to this context.
 
-        This method behaves similarly to `delete_texture`, though for
-        ``glDeleteProgram`` instead of ``glDeleteTextures``.
+        This method behaves similarly to `delete_vao`, though for
+        ``glDeleteFramebuffers`` instead of ``glDeleteVertexArrays``.
 
         :Parameters:
-            `program_id` : int
-                The OpenGL name of the Shader Program to delete.
+            `fbo_id` : int
+                The OpenGL name of the Framebuffer Object to delete.
 
-        .. versionadded:: 2.0
+        .. versionadded:: 2.0.10
         """
-        if gl.current_context is self:
-            gl.glDeleteProgram(program_id)
+        if self._safe_to_operate_on():
+            gl.glDeleteFramebuffers(1, gl.GLuint(fbo_id))
         else:
-            self.object_space.doomed_shader_programs.append(program_id)
+            self.doomed_framebuffers.append(fbo_id)
 
     def get_info(self):
         """Get the OpenGL information for this context.

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/gl/gl_info.py

@@ -63,10 +63,12 @@ class GLInfo:
 
         This method is called automatically for the default context.
         """
-        from pyglet.gl.gl import glGetString, glGetStringi, GL_NUM_EXTENSIONS
-
         self._have_context = True
+
         if not self._have_info:
+
+            from pyglet.gl.gl import glGetString, glGetStringi, GL_NUM_EXTENSIONS
+
             self.vendor = asstr(cast(glGetString(GL_VENDOR), c_char_p).value)
             self.renderer = asstr(cast(glGetString(GL_RENDERER), c_char_p).value)
             self.version = asstr(cast(glGetString(GL_VERSION), c_char_p).value)

{pyglet-2.0.8 → pyglet-2.0.10}/pyglet/gl/lib.py

@@ -62,8 +62,7 @@ def errcheck(result, func, arguments):
             print(name)
 
     from pyglet import gl
-    context = gl.current_context
-    if not context:
+    if not gl.current_context:
         raise GLException('No GL context; create a Window first')
     error = gl.glGetError()
     if error: