|
|
"""Base class for GLU callback-caching structures""" |
|
|
import ctypes |
|
|
import weakref |
|
|
from OpenGL._bytes import long, integer_types |
|
|
|
|
|
class GLUStruct( object ): |
|
|
"""Mix-in class for GLU Structures that want to retain references to callbacks |
|
|
|
|
|
Also provides original-object-return for the "datapointer" style paremters |
|
|
|
|
|
Each sub-class must override: |
|
|
CALLBACK_TYPES -- maps a "which" constant to a function type |
|
|
CALLBACK_FUNCTION_REGISTRARS -- maps a "which" constant to the |
|
|
registration function for functions of that type |
|
|
WRAPPER_METHODS -- maps a "which" consant to a method of the structure |
|
|
that produces a callable around the function which takes care of |
|
|
input/output arguments, data conversions, error handling and the |
|
|
like. |
|
|
Creates a dictionary member dataPointers if original-object-return is used |
|
|
Creates a dictionary member callbacks if callback registration is used |
|
|
""" |
|
|
def getAsParam( self ): |
|
|
"""Gets as a ctypes pointer to the underlying structure""" |
|
|
return ctypes.pointer( self ) |
|
|
_as_parameter_ = property( getAsParam ) |
|
|
CALLBACK_TYPES = None |
|
|
CALLBACK_FUNCTION_REGISTRARS = None |
|
|
WRAPPER_METHODS = None |
|
|
def noteObject( self, object ): |
|
|
"""Note object for later retrieval as a Python object pointer |
|
|
|
|
|
This is the registration point for "original object return", returns |
|
|
a void pointer to the Python object, though this is, effectively, an |
|
|
opaque value. |
|
|
""" |
|
|
identity = id(object) |
|
|
try: |
|
|
self.dataPointers[ identity ] = object |
|
|
except AttributeError as err: |
|
|
self.dataPointers = { identity: object } |
|
|
return identity |
|
|
def originalObject( self, voidPointer ): |
|
|
"""Given a void-pointer, try to find our original Python object""" |
|
|
if isinstance( voidPointer, integer_types): |
|
|
identity = voidPointer |
|
|
elif voidPointer is None: |
|
|
return None |
|
|
else: |
|
|
try: |
|
|
identity = voidPointer.value |
|
|
except AttributeError as err: |
|
|
identity = voidPointer[0] |
|
|
try: |
|
|
return self.dataPointers[ identity ] |
|
|
except (KeyError,AttributeError) as err: |
|
|
return voidPointer |
|
|
def addCallback( self, which, function ): |
|
|
"""Register a callback for this structure object""" |
|
|
callbackType = self.CALLBACK_TYPES.get( which ) |
|
|
if not callbackType: |
|
|
raise ValueError( |
|
|
"""Don't have a registered callback type for %r"""%( |
|
|
which, |
|
|
) |
|
|
) |
|
|
wrapperMethod = self.WRAPPER_METHODS.get( which ) |
|
|
if wrapperMethod is not None: |
|
|
function = getattr(self,wrapperMethod)( function ) |
|
|
cCallback = callbackType( function ) |
|
|
|
|
|
try: |
|
|
self.CALLBACK_FUNCTION_REGISTRARS[which]( self, which, cCallback ) |
|
|
except ctypes.ArgumentError as err: |
|
|
err.args += (which,cCallback) |
|
|
raise |
|
|
|
|
|
|
|
|
if getattr( self, 'callbacks', None ) is None: |
|
|
self.callbacks = {} |
|
|
self.callbacks[ which ] = cCallback |
|
|
return cCallback |
|
|
def ptrAsArray( self, ptr, length, type ): |
|
|
"""Copy length values from ptr into new array of given type""" |
|
|
result = type.zeros( (length,) ) |
|
|
for i in range(length): |
|
|
result[i] = ptr[i] |
|
|
return result |
|
|
|
