| """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 |
|
|
