angle backend that I wrote about half a year ago and is tight to Qt

_angle.py

# -*- coding: utf-8 -*-
# Copyright (c) 2014, Vispy Development Team.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.

"""
vispy backend for Qt (PySide and PyQt4).
"""

from __future__ import division

from ... import config
from ..base import BaseApplicationBackend, BaseCanvasBackend, BaseTimerBackend
from ...util import keys
from . import ATTEMPTED_BACKENDS
from ...util.six import text_type

from . import _libegl as egl

# Get what qt lib to try
if len(ATTEMPTED_BACKENDS):
    qt_lib = ATTEMPTED_BACKENDS[-1].lower()
    if qt_lib.lower() == 'qt':
        qt_lib = config['qt_lib'].lower()
    # in case the last app we ran was something else (e.g., Pyglet)
    if qt_lib not in ['pyqt', 'pyqt4', 'pyside', 'qt']:
        qt_lib = 'any'
else:
    qt_lib = 'any'

# Import PySide or PyQt4
if qt_lib in ('any', 'qt'):
    try:
        from PyQt4 import QtGui, QtCore
    except ImportError:
        from PySide import QtGui, QtCore
elif qt_lib in ('pyqt', 'pyqt4'):
    from PyQt4 import QtGui, QtCore
elif qt_lib == 'pyside':
    from PySide import QtGui, QtCore
else:
    raise Exception("Do not recognize Qt library '%s'. Options are "
                    "'pyqt4', 'pyside', or 'qt'])." % str(qt_lib))

# todo: add support for distinguishing left and right shift/ctrl/alt keys.
# Linux scan codes:  (left, right)
#   Shift  50, 62
#   Ctrl   37, 105
#   Alt    64, 108
KEYMAP = {
    QtCore.Qt.Key_Shift: keys.SHIFT,
    QtCore.Qt.Key_Control: keys.CONTROL,
    QtCore.Qt.Key_Alt: keys.ALT,
    QtCore.Qt.Key_AltGr: keys.ALT,
    QtCore.Qt.Key_Meta: keys.META,

    QtCore.Qt.Key_Left: keys.LEFT,
    QtCore.Qt.Key_Up: keys.UP,
    QtCore.Qt.Key_Right: keys.RIGHT,
    QtCore.Qt.Key_Down: keys.DOWN,
    QtCore.Qt.Key_PageUp: keys.PAGEUP,
    QtCore.Qt.Key_PageDown: keys.PAGEDOWN,

    QtCore.Qt.Key_Insert: keys.INSERT,
    QtCore.Qt.Key_Delete: keys.DELETE,
    QtCore.Qt.Key_Home: keys.HOME,
    QtCore.Qt.Key_End: keys.END,

    QtCore.Qt.Key_Escape: keys.ESCAPE,
    QtCore.Qt.Key_Backspace: keys.BACKSPACE,

    QtCore.Qt.Key_F1: keys.F1,
    QtCore.Qt.Key_F2: keys.F2,
    QtCore.Qt.Key_F3: keys.F3,
    QtCore.Qt.Key_F4: keys.F4,
    QtCore.Qt.Key_F5: keys.F5,
    QtCore.Qt.Key_F6: keys.F6,
    QtCore.Qt.Key_F7: keys.F7,
    QtCore.Qt.Key_F8: keys.F8,
    QtCore.Qt.Key_F9: keys.F9,
    QtCore.Qt.Key_F10: keys.F10,
    QtCore.Qt.Key_F11: keys.F11,
    QtCore.Qt.Key_F12: keys.F12,

    QtCore.Qt.Key_Space: keys.SPACE,
    QtCore.Qt.Key_Enter: keys.ENTER,
    QtCore.Qt.Key_Return: keys.ENTER,
    QtCore.Qt.Key_Tab: keys.TAB,
}

BUTTONMAP = {0: 0, 1: 1, 2: 2, 4: 3, 8: 4, 16: 5}


class ApplicationBackend(BaseApplicationBackend):

    def __init__(self):
        BaseApplicationBackend.__init__(self)

    def _vispy_get_backend_name(self):
        if 'pyside' in QtCore.__name__.lower():
            return 'PySide (qt)'
        else:
            return 'PyQt4 (qt)'

    def _vispy_process_events(self):
        app = self._vispy_get_native_app()
        app.flush()
        app.processEvents()

    def _vispy_run(self):
        app = self._vispy_get_native_app()
        if hasattr(app, '_in_event_loop') and app._in_event_loop:
            pass  # Already in event loop
        else:
            return app.exec_()

    def _vispy_quit(self):
        return self._vispy_get_native_app().quit()

    def _vispy_get_native_app(self):
        # Get native app in save way. Taken from guisupport.py
        app = QtGui.QApplication.instance()
        if app is None:
            app = QtGui.QApplication([''])
        # Store so it won't be deleted, but not on a visvis object,
        # or an application may produce error when closed
        QtGui._qApp = app
        # Return
        return app


class CanvasBackend(QtGui.QWidget, BaseCanvasBackend):

    """Qt backend for Canvas abstract class."""

    def __init__(self, *args, **kwargs):
        BaseCanvasBackend.__init__(self)
        QtGui.QWidget.__init__(self, *args, **kwargs)
        self.setAttribute(QtCore.Qt.WA_PaintOnScreen, True)
        self.setMouseTracking(True)
        self.setAutoFillBackground(False)
        
        # flags
        self._is_initialized = False
        
        # Get window id
        w = egl.get_window_id(self)
        
        # Setup egl to use this widget
        self._egl_display = d = egl.eglGetDisplay()
        self._egl_version = egl.eglInitialize(d)
        self._egl_config = c = egl.eglChooseConfig(d)[0]  # pick first
        self._egl_surface = egl.eglCreateWindowSurface(d, c, w)
        self._egl_context = egl.eglCreateContext(d, c)
        # todo: maybe we should also clean up when window closes ...

    def _vispy_set_current(self):
        # Make this the current context
        egl.eglMakeCurrent(self._egl_display, self._egl_surface, 
                           self._egl_surface, self._egl_context)

    def _vispy_swap_buffers(self):
        # Swap front and back buffer
        egl.eglSwapBuffers(self._egl_display, self._egl_surface)

    def _vispy_set_title(self, title):
        # Set the window title. Has no effect for widgets
        self.setWindowTitle(title)

    def _vispy_set_size(self, w, h):
        # Set size of the widget or window
        self.resize(w, h)

    def _vispy_set_position(self, x, y):
        # Set location of the widget or window. May have no effect for widgets
        self.move(x, y)

    def _vispy_set_visible(self, visible):
        # Show or hide the window or widget
        if visible:
            self.show()
        else:
            self.hide()

    def _vispy_update(self):
        # Invoke a redraw
        self.update()

    def _vispy_close(self):
        # Force the window or widget to shut down
        self.close()

    def _vispy_get_position(self):
        g = self.geometry()
        return g.x(), g.y()

    def _vispy_get_size(self):
        g = self.geometry()
        return g.width(), g.height()

    def initializeGL(self):
        if self._vispy_canvas is None:
            return
        self._vispy_set_current()
        self._vispy_canvas.events.initialize()

    def resizeEvent(self, event):
        w, h = event.size().width(), event.size().height()
        if self._vispy_canvas is None:
            return
        self._vispy_canvas.events.resize(size=(w, h))

    def paintEngine(self):
        pass
    
    def paintEvent(self, event):
        if self._vispy_canvas is None:
            return
        if not self._is_initialized:
            self._is_initialized = True
            self.initializeGL()
        # (0, 0, self.width(), self.height()))
        self._vispy_canvas.events.paint(region=None)

    def closeEvent(self, ev):
        if self._vispy_canvas is None:
            return
        self._vispy_canvas.events.close()

    def mousePressEvent(self, ev):
        if self._vispy_canvas is None:
            return
        self._vispy_mouse_press(
            native=ev,
            pos=(ev.pos().x(), ev.pos().y()),
            button=BUTTONMAP.get(ev.button(), 0),
            modifiers = self._modifiers(ev),
        )

    def mouseReleaseEvent(self, ev):
        if self._vispy_canvas is None:
            return
        self._vispy_mouse_release(
            native=ev,
            pos=(ev.pos().x(), ev.pos().y()),
            button=BUTTONMAP[ev.button()],
            modifiers = self._modifiers(ev),
        )

    def mouseMoveEvent(self, ev):
        if self._vispy_canvas is None:
            return
        self._vispy_mouse_move(
            native=ev,
            pos=(ev.pos().x(), ev.pos().y()),
            modifiers=self._modifiers(ev),
        )

    def wheelEvent(self, ev):
        if self._vispy_canvas is None:
            return
        # Get scrolling
        deltax, deltay = 0.0, 0.0
        if ev.orientation == QtCore.Qt.Horizontal:
            deltax = ev.delta() / 120.0
        else:
            deltay = ev.delta() / 120.0
        # Emit event
        self._vispy_canvas.events.mouse_wheel(
            native=ev,
            delta=(deltax, deltay),
            pos=(ev.pos().x(), ev.pos().y()),
            modifiers=self._modifiers(ev),
        )

    def keyPressEvent(self, ev):
        self._vispy_canvas.events.key_press(
            native=ev,
            key=self._processKey(ev),
            text=text_type(ev.text()),
            modifiers=self._modifiers(ev),
        )

    def keyReleaseEvent(self, ev):
        # if ev.isAutoRepeat():
            # return # Skip release auto repeat events
        self._vispy_canvas.events.key_release(
            native=ev,
            key=self._processKey(ev),
            text=text_type(ev.text()),
            modifiers=self._modifiers(ev),
        )

    def _processKey(self, event):
        # evaluates the keycode of qt, and transform to vispy key.
        key = int(event.key())
        if key in KEYMAP:
            return KEYMAP[key]
        elif key >= 32 and key <= 127:
            return keys.Key(chr(key))
        else:
            return None

    def _modifiers(self, event):
        # Convert the QT modifier state into a tuple of active modifier keys.
        mod = ()
        qtmod = event.modifiers()
        if QtCore.Qt.ShiftModifier & qtmod:
            mod += keys.SHIFT,
        if QtCore.Qt.ControlModifier & qtmod:
            mod += keys.CONTROL,
        if QtCore.Qt.AltModifier & qtmod:
            mod += keys.ALT,
        if QtCore.Qt.MetaModifier & qtmod:
            mod += keys.META,
        return mod


# class QtMouseEvent(MouseEvent):
# special subclass of MouseEvent for propagating acceptance info back to Qt.
#     @MouseEvent.handled.setter
#     def handled(self, val):
#         self._handled = val
#         if val:
#             self.qt_event.accept()
#         else:
#             self.qt_event.ignore()
class TimerBackend(BaseTimerBackend, QtCore.QTimer):

    def __init__(self, vispy_timer):
        if QtGui.QApplication.instance() is None:
            global QAPP
            QAPP = QtGui.QApplication([])
        BaseTimerBackend.__init__(self, vispy_timer)
        QtCore.QTimer.__init__(self)
        self.timeout.connect(self._vispy_timeout)

    def _vispy_start(self, interval):
        self.start(interval * 1000.)

    def _vispy_stop(self):
        self.stop()

    def _vispy_timeout(self):
        self._vispy_timer._timeout()

_libegl.py

import ctypes
from ctypes import c_int as _c_int, POINTER as _POINTER

fname = r'C:\almar\projects\py\vispy\Qt5.2.1 64bit gl es2 libs\libEGL.dll'
_lib = ctypes.windll.LoadLibrary(fname)




## Constants

EGL_FALSE			= 0
EGL_TRUE			= 1

# Out-of-band handle values 
EGL_DEFAULT_DISPLAY		= 0
EGL_NO_CONTEXT			= 0
EGL_NO_DISPLAY			= 0
EGL_NO_SURFACE			= 0

# Out-of-band attribute value 
EGL_DONT_CARE		     = -1

# Errors / GetError return values 
EGL_SUCCESS			  = 0x3000
EGL_NOT_INITIALIZED		= 0x3001
EGL_BAD_ACCESS			= 0x3002
EGL_BAD_ALLOC			= 0x3003
EGL_BAD_ATTRIBUTE		= 0x3004
EGL_BAD_CONFIG			= 0x3005
EGL_BAD_CONTEXT			= 0x3006
EGL_BAD_CURRENT_SURFACE		= 0x3007
EGL_BAD_DISPLAY			= 0x3008
EGL_BAD_MATCH			= 0x3009
EGL_BAD_NATIVE_PIXMAP		= 0x300A
EGL_BAD_NATIVE_WINDOW		= 0x300B
EGL_BAD_PARAMETER		= 0x300C
EGL_BAD_SURFACE			= 0x300D
EGL_CONTEXT_LOST		= 0x300E	# EGL 1.1 - IMG_power_management 

# Reserved 0x300F-0x301F for additional errors 

# Config attributes 
EGL_BUFFER_SIZE			= 0x3020
EGL_ALPHA_SIZE			= 0x3021
EGL_BLUE_SIZE			= 0x3022
EGL_GREEN_SIZE			= 0x3023
EGL_RED_SIZE			= 0x3024
EGL_DEPTH_SIZE			= 0x3025
EGL_STENCIL_SIZE		= 0x3026
EGL_CONFIG_CAVEAT		= 0x3027
EGL_CONFIG_ID			= 0x3028
EGL_LEVEL			= 0x3029
EGL_MAX_PBUFFER_HEIGHT		= 0x302A
EGL_MAX_PBUFFER_PIXELS		= 0x302B
EGL_MAX_PBUFFER_WIDTH		= 0x302C
EGL_NATIVE_RENDERABLE		= 0x302D
EGL_NATIVE_VISUAL_ID		= 0x302E
EGL_NATIVE_VISUAL_TYPE		= 0x302F
EGL_SAMPLES			= 0x3031
EGL_SAMPLE_BUFFERS		= 0x3032
EGL_SURFACE_TYPE		= 0x3033
EGL_TRANSPARENT_TYPE		= 0x3034
EGL_TRANSPARENT_BLUE_VALUE	= 0x3035
EGL_TRANSPARENT_GREEN_VALUE	= 0x3036
EGL_TRANSPARENT_RED_VALUE	= 0x3037
EGL_NONE			= 0x3038	# Attrib list terminator 
EGL_BIND_TO_TEXTURE_RGB		= 0x3039
EGL_BIND_TO_TEXTURE_RGBA	= 0x303A
EGL_MIN_SWAP_INTERVAL		= 0x303B
EGL_MAX_SWAP_INTERVAL		= 0x303C
EGL_LUMINANCE_SIZE		= 0x303D
EGL_ALPHA_MASK_SIZE		= 0x303E
EGL_COLOR_BUFFER_TYPE		= 0x303F
EGL_RENDERABLE_TYPE		= 0x3040
EGL_MATCH_NATIVE_PIXMAP		= 0x3041	# Pseudo-attribute (not queryable) 
EGL_CONFORMANT			= 0x3042

# Reserved 0x3041-0x304F for additional config attributes 

# Config attribute values 
EGL_SLOW_CONFIG			= 0x3050	# EGL_CONFIG_CAVEAT value 
EGL_NON_CONFORMANT_CONFIG	= 0x3051	# EGL_CONFIG_CAVEAT value 
EGL_TRANSPARENT_RGB		= 0x3052	# EGL_TRANSPARENT_TYPE value 
EGL_RGB_BUFFER			= 0x308E	# EGL_COLOR_BUFFER_TYPE value 
EGL_LUMINANCE_BUFFER		= 0x308F	# EGL_COLOR_BUFFER_TYPE value 

# More config attribute values, for EGL_TEXTURE_FORMAT 
EGL_NO_TEXTURE			= 0x305C
EGL_TEXTURE_RGB			= 0x305D
EGL_TEXTURE_RGBA		= 0x305E
EGL_TEXTURE_2D			= 0x305F

# Config attribute mask bits 
EGL_PBUFFER_BIT			= 0x0001	# EGL_SURFACE_TYPE mask bits 
EGL_PIXMAP_BIT			= 0x0002	# EGL_SURFACE_TYPE mask bits 
EGL_WINDOW_BIT			= 0x0004	# EGL_SURFACE_TYPE mask bits 
EGL_VG_COLORSPACE_LINEAR_BIT	= 0x0020	# EGL_SURFACE_TYPE mask bits 
EGL_VG_ALPHA_FORMAT_PRE_BIT	= 0x0040	# EGL_SURFACE_TYPE mask bits 
EGL_MULTISAMPLE_RESOLVE_BOX_BIT = 0x0200	# EGL_SURFACE_TYPE mask bits 
EGL_SWAP_BEHAVIOR_PRESERVED_BIT = 0x0400	# EGL_SURFACE_TYPE mask bits 

EGL_OPENGL_ES_BIT		= 0x0001	# EGL_RENDERABLE_TYPE mask bits 
EGL_OPENVG_BIT			= 0x0002	# EGL_RENDERABLE_TYPE mask bits 
EGL_OPENGL_ES2_BIT		= 0x0004	# EGL_RENDERABLE_TYPE mask bits 
EGL_OPENGL_BIT			= 0x0008	# EGL_RENDERABLE_TYPE mask bits 

# QueryString targets 
EGL_VENDOR			= 0x3053
EGL_VERSION			= 0x3054
EGL_EXTENSIONS			= 0x3055
EGL_CLIENT_APIS			= 0x308D

# QuerySurface / SurfaceAttrib / CreatePbufferSurface targets 
EGL_HEIGHT			= 0x3056
EGL_WIDTH			= 0x3057
EGL_LARGEST_PBUFFER		= 0x3058
EGL_TEXTURE_FORMAT		= 0x3080
EGL_TEXTURE_TARGET		= 0x3081
EGL_MIPMAP_TEXTURE		= 0x3082
EGL_MIPMAP_LEVEL		= 0x3083
EGL_RENDER_BUFFER		= 0x3086
EGL_VG_COLORSPACE		= 0x3087
EGL_VG_ALPHA_FORMAT		= 0x3088
EGL_HORIZONTAL_RESOLUTION	= 0x3090
EGL_VERTICAL_RESOLUTION		= 0x3091
EGL_PIXEL_ASPECT_RATIO		= 0x3092
EGL_SWAP_BEHAVIOR		= 0x3093
EGL_MULTISAMPLE_RESOLVE		= 0x3099

# EGL_RENDER_BUFFER values / BindTexImage / ReleaseTexImage buffer targets 
EGL_BACK_BUFFER			= 0x3084
EGL_SINGLE_BUFFER		= 0x3085

# OpenVG color spaces 
EGL_VG_COLORSPACE_sRGB		= 0x3089	# EGL_VG_COLORSPACE value 
EGL_VG_COLORSPACE_LINEAR	= 0x308A	# EGL_VG_COLORSPACE value 

# OpenVG alpha formats 
EGL_VG_ALPHA_FORMAT_NONPRE	= 0x308B	# EGL_ALPHA_FORMAT value 
EGL_VG_ALPHA_FORMAT_PRE		= 0x308C	# EGL_ALPHA_FORMAT value 

# Constant scale factor by which fractional display resolutions &
# * aspect ratio are scaled when queried as integer values.
 
EGL_DISPLAY_SCALING		= 10000

# Unknown display resolution/aspect ratio 
EGL_UNKNOWN			= -1

# Back buffer swap behaviors 
EGL_BUFFER_PRESERVED		= 0x3094	# EGL_SWAP_BEHAVIOR value 
EGL_BUFFER_DESTROYED		= 0x3095	# EGL_SWAP_BEHAVIOR value 

# CreatePbufferFromClientBuffer buffer types 
EGL_OPENVG_IMAGE		= 0x3096

# QueryContext targets 
EGL_CONTEXT_CLIENT_TYPE		= 0x3097

# CreateContext attributes 
EGL_CONTEXT_CLIENT_VERSION	= 0x3098

# Multisample resolution behaviors 
EGL_MULTISAMPLE_RESOLVE_DEFAULT = 0x309A	# EGL_MULTISAMPLE_RESOLVE value 
EGL_MULTISAMPLE_RESOLVE_BOX	= 0x309B	# EGL_MULTISAMPLE_RESOLVE value 

# BindAPI/QueryAPI targets 
EGL_OPENGL_ES_API		= 0x30A0
EGL_OPENVG_API			= 0x30A1
EGL_OPENGL_API			= 0x30A2

# GetCurrentSurface targets 
EGL_DRAW			= 0x3059
EGL_READ			= 0x305A

# WaitNative engines 
EGL_CORE_NATIVE_ENGINE		= 0x305B

# EGL 1.2 tokens renamed for consistency in EGL 1.3 
EGL_COLORSPACE			= EGL_VG_COLORSPACE
EGL_ALPHA_FORMAT		= EGL_VG_ALPHA_FORMAT
EGL_COLORSPACE_sRGB		= EGL_VG_COLORSPACE_sRGB
EGL_COLORSPACE_LINEAR		= EGL_VG_COLORSPACE_LINEAR
EGL_ALPHA_FORMAT_NONPRE		= EGL_VG_ALPHA_FORMAT_NONPRE
EGL_ALPHA_FORMAT_PRE		= EGL_VG_ALPHA_FORMAT_PRE


## The functions



def eglGetError():
    """ Check for errors, returns an enum (int).
    """
    return _lib.eglGetError()


_lib.eglGetDisplay.argtypes = _c_int,
#
def eglGetDisplay(display=EGL_DEFAULT_DISPLAY):
    """ Connect to the EGL display server.
    """
    res = _lib.eglGetDisplay(display)
    if not res:
        raise RuntimeError('Could not create display')
    return res


_lib.eglInitialize.argtypes = _c_int, _POINTER(_c_int), _POINTER(_c_int),
#
def eglInitialize(display):
    """ Initialize EGL and return EGL version tuple.
    """
    majorVersion = (_c_int*1)()
    minorVersion = (_c_int*1)()
    res = _lib.eglInitialize(display, majorVersion, minorVersion)
    if res == EGL_FALSE:
        raise RuntimeError('Could not initialize')
    return majorVersion[0], minorVersion[0]


DEFAULT_ATTRIB_LIST = [EGL_BUFFER_SIZE, 32, 
                       EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
                       EGL_SURFACE_TYPE, EGL_WINDOW_BIT
                       ]
#
_lib.eglChooseConfig.argtypes = (_c_int, _POINTER(_c_int),
                                 _POINTER(_c_int), _c_int, _POINTER(_c_int))
#
def eglChooseConfig(display, attribList=None, maxConfigs=None):
    # Deal with attrib list
    attribList = attribList or DEFAULT_ATTRIB_LIST
    attribList = [a for a in attribList] + [EGL_NONE]
    attribList = (_c_int*len(attribList))(*attribList)
    #
    maxConfigs = maxConfigs or 32
    config = (_c_int*maxConfigs)()
    numConfigs = (_c_int*1)()
    _lib.eglChooseConfig(display, attribList, config, maxConfigs, numConfigs)
    n = numConfigs[0]
    if not n:
        raise RuntimeError('Could not find any suitable config.')
    return config[:n]


_lib.eglCreateWindowSurface.argtypes = _c_int, _c_int, _c_int, _POINTER(_c_int)
#
def eglCreateWindowSurface(display, config, window, attribList=None):
    # Deal with attrib list
    attribList = attribList or []
    attribList = [a for a in attribList] + [EGL_NONE]
    attribList = (_c_int*len(attribList))(*attribList)
    #
    res = _lib.eglCreateWindowSurface(display, config, window, attribList)
    if res == EGL_NO_SURFACE:
        e = eglGetError()
        if e == EGL_BAD_MATCH:
            raise ValueError('Cannot create surface: attributes do not match or given config cannot render in window.')
        elif e == EGL_BAD_CONFIG:
            raise ValueError('Cannot create surface: given config is not supported by this system.')
        elif e == EGL_BAD_NATIVE_WINDOW:
            raise ValueError('Cannot create surface: the given native window handle is invalid.')
        elif e == EGL_BAD_ALLOC:
            raise RuntimeError('Could not allocate surface: not enough resources or native window already associated with another config.')
        else:
            raise RuntimeError('Could not create window surface due to unknown error: %i' % e)
    return res
    

_lib.eglCreateContext.argtypes = _c_int, _c_int, _c_int, _POINTER(_c_int)
#
def eglCreateContext(display, config, shareContext=EGL_NO_CONTEXT, attribList=None):
    # Deal with attrib list
    attribList = attribList or [EGL_CONTEXT_CLIENT_VERSION, 2]
    attribList = [a for a in attribList] + [EGL_NONE]
    attribList = (_c_int*len(attribList))(*attribList)
    #
    res = _lib.eglCreateContext(display, config, shareContext, attribList)
    if res == EGL_NO_CONTEXT:
        if e == EGL_BAD_CONFIG:
            raise ValueError('Could not create context: given config is not supported by this system.')
        else:
            raise RuntimeError('Could not create context due to unknown error: %i' % e)
    return res
    

_lib.eglMakeCurrent.argtypes = _c_int, _c_int, _c_int, _c_int
#
def eglMakeCurrent(display, draw, read, context):
    res = _lib.eglMakeCurrent(display, draw, read, context)
    if res == EGL_FALSE:
        raise RuntimeError('Could not make the context current.')


_lib.eglSwapBuffers.argtypes = _c_int, _c_int
#
def eglSwapBuffers(display, surface):
    res = _lib.eglSwapBuffers(display, surface)
    if res == EGL_FALSE:
        raise RuntimeError('Could not swap buffers.')
    


##
# from PySide import QtGui, QtCore
# 
# class DxWidget(QtGui.QWidget):
#     def __init__(self, parent=None):
#         QtGui.QWidget.__init__(self, parent)
#         self.setAttribute(QtCore.Qt.WA_PaintOnScreen, True)
#     def onPaint(self):
#         pass
# 
# w = DxWidget()
# w.show()


def get_window_id(widget):
    """ Get the window id of a PySide Widget). Might also work for PyQt4.
    """
    # Get window id from stupid capsule thingy
    # http://translate.google.com/translate?hl=en&sl=zh-CN&u=http://www.cnblogs.com/Shiren-Y/archive/2011/04/06/2007288.html&prev=/search%3Fq%3Dpyside%2Bdirectx%26client%3Dfirefox-a%26hs%3DIsJ%26rls%3Dorg.mozilla:nl:official%26channel%3Dfflb%26biw%3D1366%26bih%3D614
    
    # Prepare
    ctypes.pythonapi.PyCapsule_GetName.restype = ctypes.c_char_p
    ctypes.pythonapi.PyCapsule_GetName.argtypes = [ctypes.py_object]
    ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
    ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p]
    # Extract handle from capsule thingy
    capsule = widget.winId()
    name = ctypes.pythonapi.PyCapsule_GetName(capsule)
    handle = ctypes.pythonapi.PyCapsule_GetPointer(capsule, name)
    return handle