home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / lib / site-packages / OpenGL / wrapper.py < prev   
Encoding:
Python Source  |  2009-01-03  |  40.6 KB  |  1,373 lines
  1. """The wrapping code for providing natural ctypes-based OpenGL interface"""
  2. import ctypes
  3. from OpenGL import platform, error
  4. glGetError = platform.OpenGL.glGetError
  5. from OpenGL import converters
  6. from OpenGL.converters import DefaultCConverter
  7. from OpenGL.converters import returnCArgument,returnPyArgument
  8. try:
  9.     from OpenGL_accelerate.wrapper import (
  10.         Wrapper as cWrapper,
  11.         CArgCalculator,
  12.         PyArgCalculator,
  13.         CArgumentCalculator,
  14.     )
  15. except ImportError, err:
  16.     cWrapper = None 
  17. NULL = object()
  18.  
  19. def asList( o ):
  20.     """Convert to a list if not already one"""
  21.     if not isinstance( o, list ):
  22.         return list(o)
  23.     return o
  24.  
  25. class Wrapper( object ):
  26.     """Wrapper around a ctypes cFunction object providing SWIG-like hooks
  27.     
  28.     Attributes:
  29.     
  30.         wrappedOperation -- base operation, normally a ctypes function 
  31.             with data-types and error-checking specified
  32.         pyConverters -- converters for incoming Python arguments,
  33.             provide 1:1 mapping to incoming Python arguments, can
  34.             suppress an argument from the argument-set as well
  35.                 see setPyConverter
  36.         pyConverterNames -- caching/storage of the argument names 
  37.             for the Python converters 
  38.         cConverters -- converters for incoming C-level arguments
  39.             produce Python-level objects in 1:1 mapping to ctypes
  40.             arguments from pyConverters results
  41.                 see setCConverter
  42.         cResolvers -- converters turning Python-level objects into 
  43.             ctypes-compatible data-types 
  44.                 see setCResolver
  45.     
  46.     Generic Attributes:
  47.     
  48.         {ARG1}_LOOKUP_{ARG2} -- lookup dictionaries to provide sizes for 
  49.             ARG1 output value from the value of ARG2, provided for 
  50.             documentation/reference
  51.         {ARG1}_FROM_{ARG2} -- lookup functions to provide sizes for ARG1
  52.             output value from the value of ARG2, provided for 
  53.             documentation/reference
  54.     """
  55.     localProperties = (
  56.         'wrappedOperation', 
  57.         '__file__',
  58.         'pyConverters',
  59.         'pyConverterNames',
  60.         'cConverters',
  61.         'cResolvers',
  62.         'storeValues',
  63.         'returnValues',
  64.     )
  65.     def __init__( self, wrappedOperation ):
  66.         """Initialise the wrapper, storing wrappedOperation"""
  67.         if isinstance( wrappedOperation, Wrapper ):
  68.             wrappedOperation = wrappedOperation.wrappedOperation
  69.         self.wrappedOperation = wrappedOperation
  70.     def __getattr__( self, key ):
  71.         """Delegate attribute lookup to our wrappedOperation"""
  72.         if key != 'wrappedOperation':
  73.             return getattr( self.wrappedOperation, key )
  74.         raise AttributeError( key )
  75.     def __nonzero__( self ):
  76.         """Is this function/wrapper available?"""
  77.         return bool( self.wrappedOperation )
  78.     def __setattr__( self, key, value ):
  79.         """Forward attribute setting to our wrappedOperation"""
  80.         if key in self.localProperties:
  81.             super( Wrapper, self ).__setattr__( key, value )
  82.         else:
  83.             return setattr( self.wrappedOperation, key, value )
  84.     def pyArgIndex( self, argName ):
  85.         """Return the Python-argument index for the given argument name"""
  86.         argNames = getattr( self, 'pyConverterNames', None )
  87.         if argNames is None:
  88.             argNames = self.wrappedOperation.argNames
  89.         try:
  90.             return asList( argNames ).index( argName )
  91.         except (ValueError,IndexError), err:
  92.             raise KeyError( """No argument %r in argument list %r"""%(
  93.                 argName, argNames
  94.             ))
  95.     def cArgIndex( self, argName ):
  96.         """Return the C-argument index for the given argument name"""
  97.         argNames = self.wrappedOperation.argNames
  98.         try:
  99.             return asList( argNames ).index( argName )
  100.         except (ValueError,IndexError), err:
  101.             raise KeyError( """No argument %r in argument list %r"""%(
  102.                 argName, argNames
  103.             ))
  104.     def setOutput( 
  105.         self, outArg, size=(1,), pnameArg=None, 
  106.         arrayType=None, oldStyleReturn=True,
  107.     ):
  108.         """Set the given argName to be an output array
  109.         
  110.         size -- either a tuple compatible with arrayType.zeros or 
  111.             a function taking pname to produce such a value.
  112.         arrayType -- array data-type used to generate the output 
  113.             array using the zeros class method...
  114.         pname -- optional argument passed into size function, that 
  115.             is, the name of the argument whose *value* will be passed 
  116.             to the size function, often the name of an input argument 
  117.             to be "sized" to match the output argument.
  118.         """
  119.         if arrayType is None:
  120.             # figure out from self.wrappedOperation's argtypes
  121.             index = self.cArgIndex( outArg )
  122.             arrayType = self.wrappedOperation.argtypes[ index ]
  123.         if pnameArg is None:
  124.             assert not callable( size )
  125.             conv = converters.Output(
  126.                 name=outArg,
  127.                 size=size,
  128.                 arrayType=arrayType,
  129.             )
  130.         else:
  131.             if isinstance( size, dict ):
  132.                 setattr( self, '%s_LOOKUP_%s'%(outArg,pnameArg), size )
  133.                 size = size.__getitem__
  134.             else:
  135.                 setattr( self, '%s_FROM_%s'%(outArg,pnameArg), size )
  136.             assert callable( size )
  137.             conv = converters.SizedOutput(
  138.                 name=outArg,
  139.                 specifier=pnameArg,
  140.                 lookup=size,
  141.                 arrayType=arrayType,
  142.             )
  143.         if oldStyleReturn:
  144.             returnObject = conv.oldStyleReturn
  145.         else:
  146.             returnObject = converters.returnCArgument( outArg )
  147.         return self.setPyConverter(
  148.             outArg
  149.         ).setCConverter(
  150.             outArg, conv,
  151.         ).setReturnValues(
  152.             returnObject
  153.         )
  154.     def setPyConverter( self, argName, function = NULL ):
  155.         """Set Python-argument converter for given argument
  156.         
  157.         argName -- the argument name which will be coerced to a usable internal
  158.             format using the function provided.
  159.         function -- None (indicating a simple copy), NULL (default) to eliminate
  160.             the argument from the Python argument-list, or a callable object with 
  161.             the signature:
  162.             
  163.                 converter(arg, wrappedOperation, args)
  164.             
  165.             where arg is the particular argument on which the convert is working,
  166.             wrappedOperation is the underlying wrapper, and args is the set of 
  167.             original Python arguments to the function.
  168.         
  169.         Note that you need exactly the same number of pyConverters as Python 
  170.         arguments.
  171.         """
  172.         if not hasattr( self, 'pyConverters' ):
  173.             self.pyConverters = [None]*len( self.wrappedOperation.argNames )
  174.             self.pyConverterNames = list(self.wrappedOperation.argNames)
  175.         try:
  176.             i = asList( self.pyConverterNames ).index( argName )
  177.         except ValueError:
  178.             raise AttributeError( """No argument named %r left in pyConverters for %r: %s"""%(
  179.                 argName, self.wrappedOperation.__name__, self.pyConverterNames,
  180.             ))
  181.         if function is NULL:
  182.             del self.pyConverters[i]
  183.             del self.pyConverterNames[i]
  184.         else:
  185.             self.pyConverters[i] = function 
  186.         return self
  187.     def setCConverter( self, argName, function ):
  188.         """Set C-argument converter for a given argument
  189.         
  190.         argName -- the argument name whose C-compatible representation will 
  191.             be calculated with the passed function.
  192.         function -- None (indicating a simple copy), a non-callable object to
  193.             be copied into the result-list itself, or a callable object with 
  194.             the signature:
  195.             
  196.                 converter( pyArgs, index, wrappedOperation )
  197.             
  198.             where pyArgs is the set of passed Python arguments, with the 
  199.             pyConverters already applied, index is the index of the C argument 
  200.             and wrappedOperation is the underlying function.
  201.         
  202.         C-argument converters are your chance to expand/contract a Python 
  203.         argument list (pyArgs) to match the number of arguments expected by
  204.         the ctypes baseOperation.  You can't have a "null" C-argument converter,
  205.         as *something* has to be passed to the C-level function in the 
  206.         parameter.
  207.         """
  208.         if not hasattr( self, 'cConverters' ):
  209.             self.cConverters = [None]*len( self.wrappedOperation.argNames )
  210.         try:
  211.             if not isinstance(self.wrappedOperation.argNames, list):
  212.                 self.wrappedOperation.argNames = list( self.wrappedOperation.argNames )
  213.             i = asList( self.wrappedOperation.argNames ).index( argName )
  214.         except ValueError:
  215.             raise AttributeError( """No argument named %r left in cConverters: %s"""%(
  216.                 argName, self.wrappedOperation.argNames,
  217.             ))
  218.         self.cConverters[i] = function 
  219.         return self
  220.     def setCResolver( self, argName, function=NULL ):
  221.         """Set C-argument converter for a given argument"""
  222.         if not hasattr( self, 'cResolvers' ):
  223.             self.cResolvers = [None]*len( self.wrappedOperation.argNames )
  224.         try:
  225.             if not isinstance(self.wrappedOperation.argNames, list):
  226.                 self.wrappedOperation.argNames = list( self.wrappedOperation.argNames )
  227.             i = asList( self.wrappedOperation.argNames).index( argName )
  228.         except ValueError:
  229.             raise AttributeError( """No argument named %r left in cConverters: %s"""%(
  230.                 argName, self.wrappedOperation.argNames,
  231.             ))
  232.         if function is NULL:
  233.             del self.cResolvers[i]
  234.         else:
  235.             self.cResolvers[i] = function 
  236.         return self
  237.     def setStoreValues( self, function=NULL ):
  238.         """Set the storage-of-arguments function for the whole wrapper"""
  239.         if function is NULL:
  240.             try:
  241.                 del self.storeValues
  242.             except Exception, err:
  243.                 pass
  244.         else:
  245.             self.storeValues = function
  246.         return self
  247.     def setReturnValues( self, function=NULL ):
  248.         """Set the return-of-results function for the whole wrapper"""
  249.         if function is NULL:
  250.             try:
  251.                 del self.returnValues
  252.             except Exception, err:
  253.                 pass
  254.         else:
  255.             self.returnValues = function
  256.         return self
  257.     def finalise( self ):
  258.         """Finalise our various elements into simple index-based operations"""
  259.         for attribute in ('pyConverters','cConverters','cResolvers' ):
  260.             value = getattr( self, attribute, None )
  261.             if value is not None:
  262.                 for i,item in enumerate(value):
  263.                     if hasattr( item, 'finalise' ):
  264.                         try:
  265.                             item.finalise( self )
  266.                         except Exception, err:
  267.                             raise error.Error(
  268.                                 """Error finalising item %s in %s for %s (%r): %s"""%(
  269.                                     i,attribute,self,item,err,
  270.                                 )
  271.                             )
  272.         if hasattr( self, 'cConverters' ):
  273.             for i,converter in enumerate( self.cConverters ):
  274.                 if isinstance( converter, (type(None),DefaultCConverter )):
  275.                     self.cConverters[i] = DefaultCConverter( self.pyArgIndex( self.argNames[i]) )
  276.         for attribute in ('storeValues','returnValues',):
  277.             item = getattr( self, attribute, None )
  278.             if hasattr( item, 'finalise' ):
  279.                 item.finalise( self )
  280.         callFunction = self.finaliseCall()
  281.         if not callFunction:
  282.             raise RuntimeError( """Missing finalised call type for %s"""%( self, ))
  283.         else:
  284.             self.__class__.__call__ = callFunction
  285.         return self
  286.     def finaliseCall( self ):
  287.         """Produce specialised versions of call for finalised wrapper object
  288.         
  289.         This returns a version of __call__ that only does that work which is
  290.         required by the particular wrapper object
  291.         
  292.         This is essentially a huge set of expanded nested functions, very 
  293.         inelegant...
  294.         """
  295.         pyConverters = getattr( self, 'pyConverters', None )
  296.         cConverters = getattr( self, 'cConverters', None )
  297.         cResolvers = getattr( self, 'cResolvers', None )
  298.         wrappedOperation = self.wrappedOperation
  299.         storeValues = getattr( self, 'storeValues', None )
  300.         returnValues = getattr( self, 'returnValues', None )
  301.         if pyConverters:
  302.             if cWrapper:
  303.                 calculate_pyArgs = PyArgCalculator(
  304.                     self,pyConverters,
  305.                 )
  306.             else:
  307.                 pyConverters_mapped = [
  308.                     (i,converter,(converter is None))
  309.                     for (i,converter) in enumerate( pyConverters )
  310.                 ]
  311.                 pyConverters_length = len(pyConverters)
  312.                 def calculate_pyArgs( args ):
  313.                     if pyConverters_length != len(args):
  314.                         raise ValueError(
  315.                             """%s requires %r arguments (%s), received %s: %r"""%(
  316.                                 wrappedOperation.__name__,
  317.                                 pyConverters_length,
  318.                                 ", ".join( self.pyConverterNames ),
  319.                                 len(args),
  320.                                 args
  321.                             )
  322.                         )
  323.                     for index,converter,isNone in pyConverters_mapped:
  324.                         if isNone:
  325.                             yield args[index]
  326.                         else:
  327.                             try:
  328.                                 yield converter(args[index], self, args)
  329.                             except Exception, err:
  330.                                 if hasattr( err, 'args' ):
  331.                                     err.args += ( converter, )
  332.                                 raise
  333.         else:
  334.             calculate_pyArgs = None
  335.         if cConverters:
  336.             if cWrapper:
  337.                 calculate_cArgs = CArgCalculator( self, cConverters )
  338.             else:
  339.                 cConverters_mapped = [
  340.                     (i,converter,callable(converter))
  341.                     for (i,converter) in enumerate( cConverters )
  342.                 ]
  343.                 def calculate_cArgs( pyArgs ):
  344.                     for index,converter,canCall in cConverters_mapped:
  345.                         if canCall:
  346.                             try:
  347.                                 yield converter( pyArgs, index, self )
  348.                             except Exception, err:
  349.                                 if hasattr( err, 'args' ):
  350.                                     err.args += (
  351.                                         """Failure in cConverter %r"""%(converter),
  352.                                         pyArgs, index, self,
  353.                                     )
  354.                                 raise
  355.                         else:
  356.                             yield converter
  357.         else:
  358.             calculate_cArgs = None
  359.         if cResolvers:
  360.             if cWrapper:
  361.                 calculate_cArguments = CArgumentCalculator( cResolvers )
  362.             else:
  363.                 cResolvers_mapped = list(enumerate(cResolvers))
  364.                 def calculate_cArguments( cArgs ):
  365.                     for i,converter in cResolvers_mapped:
  366.                         if converter is None:
  367.                             yield cArgs[i]
  368.                         else:
  369.                             try:
  370.                                 yield converter( cArgs[i] )
  371.                             except Exception, err:
  372.                                 err.args += (converter,)
  373.                                 raise
  374.         else:
  375.             calculate_cArguments = None
  376.         if cWrapper:
  377.             return staticmethod(cWrapper(
  378.                 wrappedOperation,
  379.                 calculate_pyArgs=calculate_pyArgs, 
  380.                 calculate_cArgs=calculate_cArgs,
  381.                 calculate_cArguments=calculate_cArguments, 
  382.                 storeValues=storeValues, 
  383.                 returnValues=returnValues,
  384.             ))
  385.         if pyConverters:
  386.             if cConverters:
  387.                 # create a map of index,converter, callable 
  388.                 if cResolvers:
  389.                     if storeValues:
  390.                         if returnValues:
  391.                             def wrapperCall( self, *args ):
  392.                                 """Wrapper with all possible operations"""
  393.                                 pyArgs = tuple( calculate_pyArgs( args ))
  394.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  395.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  396.                                 try:
  397.                                     result = self.wrappedOperation( *cArguments )
  398.                                 except ctypes.ArgumentError, err:
  399.                                     err.args = err.args + (cArguments,)
  400.                                     raise err
  401.                                 except error.GLError, err:
  402.                                     err.cArgs = cArgs 
  403.                                     err.pyArgs = pyArgs
  404.                                     raise err
  405.                                 # handle storage of persistent argument values...
  406.                                 storeValues(
  407.                                     result,
  408.                                     self,
  409.                                     pyArgs,
  410.                                     cArgs,
  411.                                 )
  412.                                 return returnValues(
  413.                                     result,
  414.                                     self,
  415.                                     pyArgs,
  416.                                     cArgs,
  417.                                 )
  418.                             return wrapperCall
  419.                         else:
  420.                             def wrapperCall( self, *args ):
  421.                                 """Wrapper with all save returnValues"""
  422.                                 pyArgs = tuple( calculate_pyArgs( args ))
  423.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  424.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  425.                                 try:
  426.                                     result = self.wrappedOperation( *cArguments )
  427.                                 except ctypes.ArgumentError, err:
  428.                                     err.args = err.args + (cArguments,)
  429.                                     raise err
  430.                                 except error.GLError, err:
  431.                                     err.cArgs = cArgs 
  432.                                     err.pyArgs = pyArgs
  433.                                     raise err
  434.                                 # handle storage of persistent argument values...
  435.                                 storeValues(
  436.                                     result,
  437.                                     self,
  438.                                     pyArgs,
  439.                                     cArgs,
  440.                                 )
  441.                                 return result 
  442.                             return wrapperCall
  443.                     else: # null storeValues
  444.                         if returnValues:
  445.                             def wrapperCall( self, *args ):
  446.                                 """Wrapper with all save storeValues"""
  447.                                 pyArgs = tuple( calculate_pyArgs( args ))
  448.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  449.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  450.                                 try:
  451.                                     result = self.wrappedOperation( *cArguments )
  452.                                 except ctypes.ArgumentError, err:
  453.                                     err.args = err.args + (cArguments,)
  454.                                     raise err
  455.                                 except error.GLError, err:
  456.                                     err.cArgs = cArgs 
  457.                                     err.pyArgs = pyArgs
  458.                                     raise err
  459.                                 return returnValues(
  460.                                     result,
  461.                                     self,
  462.                                     pyArgs,
  463.                                     cArgs,
  464.                                 )
  465.                             return wrapperCall
  466.                         else:
  467.                             def wrapperCall( self, *args ):
  468.                                 """Wrapper with all save returnValues and storeValues"""
  469.                                 pyArgs = tuple( calculate_pyArgs( args ))
  470.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  471.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  472.                                 try:
  473.                                     result = self.wrappedOperation( *cArguments )
  474.                                 except ctypes.ArgumentError, err:
  475.                                     err.args = err.args + (cArguments,)
  476.                                     raise err
  477.                                 except error.GLError, err:
  478.                                     err.cArgs = cArgs 
  479.                                     err.pyArgs = pyArgs
  480.                                     raise err
  481.                                 return result 
  482.                             return wrapperCall
  483.                 else:
  484.                     # null cResolvers
  485.                     if storeValues:
  486.                         if returnValues:
  487.                             def wrapperCall( self, *args ):
  488.                                 """Wrapper with all possible operations"""
  489.                                 pyArgs = tuple( calculate_pyArgs( args ))
  490.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  491.                                 cArguments = cArgs
  492.                                 try:
  493.                                     result = self.wrappedOperation( *cArguments )
  494.                                 except ctypes.ArgumentError, err:
  495.                                     err.args = err.args + (cArguments,)
  496.                                     raise err
  497.                                 except error.GLError, err:
  498.                                     err.cArgs = cArgs 
  499.                                     err.pyArgs = pyArgs
  500.                                     raise err
  501.                                 # handle storage of persistent argument values...
  502.                                 storeValues(
  503.                                     result,
  504.                                     self,
  505.                                     pyArgs,
  506.                                     cArgs,
  507.                                 )
  508.                                 return returnValues(
  509.                                     result,
  510.                                     self,
  511.                                     pyArgs,
  512.                                     cArgs,
  513.                                 )
  514.                             return wrapperCall
  515.                         else:
  516.                             def wrapperCall( self, *args ):
  517.                                 """Wrapper with all save returnValues"""
  518.                                 pyArgs = tuple( calculate_pyArgs( args ))
  519.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  520.                                 cArguments = cArgs
  521.                                 try:
  522.                                     result = self.wrappedOperation( *cArguments )
  523.                                 except ctypes.ArgumentError, err:
  524.                                     err.args = err.args + (cArguments,)
  525.                                     raise err
  526.                                 except error.GLError, err:
  527.                                     err.cArgs = cArgs 
  528.                                     err.pyArgs = pyArgs
  529.                                     raise err
  530.                                 # handle storage of persistent argument values...
  531.                                 storeValues(
  532.                                     result,
  533.                                     self,
  534.                                     pyArgs,
  535.                                     cArgs,
  536.                                 )
  537.                                 return result 
  538.                             return wrapperCall
  539.                     else: # null storeValues
  540.                         if returnValues:
  541.                             def wrapperCall( self, *args ):
  542.                                 """Wrapper with all save storeValues"""
  543.                                 pyArgs = tuple( calculate_pyArgs( args ))
  544.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  545.                                 cArguments = cArgs
  546.                                 try:
  547.                                     result = self.wrappedOperation( *cArguments )
  548.                                 except ctypes.ArgumentError, err:
  549.                                     err.args = err.args + (cArguments,)
  550.                                     raise err
  551.                                 except error.GLError, err:
  552.                                     err.cArgs = cArgs 
  553.                                     err.pyArgs = pyArgs
  554.                                     raise err
  555.                                 return returnValues(
  556.                                     result,
  557.                                     self,
  558.                                     pyArgs,
  559.                                     cArgs,
  560.                                 )
  561.                             return wrapperCall
  562.                         else:
  563.                             def wrapperCall( self, *args ):
  564.                                 """Wrapper with all save returnValues and storeValues"""
  565.                                 pyArgs = tuple( calculate_pyArgs( args ))
  566.                                 cArgs = tuple(calculate_cArgs( pyArgs ))
  567.                                 cArguments = cArgs
  568.                                 try:
  569.                                     result = self.wrappedOperation( *cArguments )
  570.                                 except ctypes.ArgumentError, err:
  571.                                     err.args = err.args + (cArguments,)
  572.                                     raise err
  573.                                 except error.GLError, err:
  574.                                     err.cArgs = cArgs 
  575.                                     err.pyArgs = pyArgs
  576.                                     raise err
  577.                                 return result 
  578.                             return wrapperCall
  579.             else:
  580.                 # null cConverters
  581.                 if cResolvers:
  582.                     if storeValues:
  583.                         if returnValues:
  584.                             def wrapperCall( self, *args ):
  585.                                 """Wrapper with all possible operations"""
  586.                                 pyArgs = tuple( calculate_pyArgs( args ))
  587.                                 cArgs = pyArgs
  588.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  589.                                 try:
  590.                                     result = self.wrappedOperation( *cArguments )
  591.                                 except ctypes.ArgumentError, err:
  592.                                     err.args = err.args + (cArguments,)
  593.                                     raise err
  594.                                 except error.GLError, err:
  595.                                     err.cArgs = cArgs 
  596.                                     err.pyArgs = pyArgs
  597.                                     raise err
  598.                                 # handle storage of persistent argument values...
  599.                                 storeValues(
  600.                                     result,
  601.                                     self,
  602.                                     pyArgs,
  603.                                     cArgs,
  604.                                 )
  605.                                 return returnValues(
  606.                                     result,
  607.                                     self,
  608.                                     pyArgs,
  609.                                     cArgs,
  610.                                 )
  611.                             return wrapperCall
  612.                         else:
  613.                             def wrapperCall( self, *args ):
  614.                                 """Wrapper with all save returnValues"""
  615.                                 pyArgs = tuple( calculate_pyArgs( args ))
  616.                                 cArgs = pyArgs
  617.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  618.                                 try:
  619.                                     result = self.wrappedOperation( *cArguments )
  620.                                 except ctypes.ArgumentError, err:
  621.                                     err.args = err.args + (cArguments,)
  622.                                     raise err
  623.                                 except error.GLError, err:
  624.                                     err.cArgs = cArgs 
  625.                                     err.pyArgs = pyArgs
  626.                                     raise err
  627.                                 # handle storage of persistent argument values...
  628.                                 storeValues(
  629.                                     result,
  630.                                     self,
  631.                                     pyArgs,
  632.                                     cArgs,
  633.                                 )
  634.                                 return result 
  635.                             return wrapperCall
  636.                     else: # null storeValues
  637.                         if returnValues:
  638.                             def wrapperCall( self, *args ):
  639.                                 """Wrapper with all save storeValues"""
  640.                                 pyArgs = tuple( calculate_pyArgs( args ))
  641.                                 cArgs = pyArgs
  642.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  643.                                 try:
  644.                                     result = self.wrappedOperation( *cArguments )
  645.                                 except ctypes.ArgumentError, err:
  646.                                     err.args = err.args + (cArguments,)
  647.                                     raise err
  648.                                 except error.GLError, err:
  649.                                     err.cArgs = cArgs 
  650.                                     err.pyArgs = pyArgs
  651.                                     raise err
  652.                                 return returnValues(
  653.                                     result,
  654.                                     self,
  655.                                     pyArgs,
  656.                                     cArgs,
  657.                                 )
  658.                             return wrapperCall
  659.                         else:
  660.                             def wrapperCall( self, *args ):
  661.                                 """Wrapper with all save returnValues and storeValues"""
  662.                                 pyArgs = tuple( calculate_pyArgs( args ))
  663.                                 cArgs = pyArgs
  664.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  665.                                 try:
  666.                                     result = self.wrappedOperation( *cArguments )
  667.                                 except ctypes.ArgumentError, err:
  668.                                     err.args = err.args + (cArguments,)
  669.                                     raise err
  670.                                 except error.GLError, err:
  671.                                     err.cArgs = cArgs 
  672.                                     err.pyArgs = pyArgs
  673.                                     raise err
  674.                                 return result 
  675.                             return wrapperCall
  676.                 else:
  677.                     # null cResolvers
  678.                     if storeValues:
  679.                         if returnValues:
  680.                             def wrapperCall( self, *args ):
  681.                                 """Wrapper with all possible operations"""
  682.                                 pyArgs = tuple( calculate_pyArgs( args ))
  683.                                 cArguments = pyArgs
  684.                                 try:
  685.                                     result = self.wrappedOperation( *cArguments )
  686.                                 except ctypes.ArgumentError, err:
  687.                                     err.args = err.args + (cArguments,)
  688.                                     raise err
  689.                                 except error.GLError, err:
  690.                                     err.cArgs = cArgs 
  691.                                     err.pyArgs = pyArgs
  692.                                     raise err
  693.                                 # handle storage of persistent argument values...
  694.                                 storeValues(
  695.                                     result,
  696.                                     self,
  697.                                     pyArgs,
  698.                                     cArgs,
  699.                                 )
  700.                                 return returnValues(
  701.                                     result,
  702.                                     self,
  703.                                     pyArgs,
  704.                                     cArgs,
  705.                                 )
  706.                             return wrapperCall
  707.                         else:
  708.                             def wrapperCall( self, *args ):
  709.                                 """Wrapper with all save returnValues"""
  710.                                 pyArgs = tuple( calculate_pyArgs( args ))
  711.                                 cArguments = pyArgs
  712.                                 try:
  713.                                     result = self.wrappedOperation( *cArguments )
  714.                                 except ctypes.ArgumentError, err:
  715.                                     err.args = err.args + (cArguments,)
  716.                                     raise err
  717.                                 except error.GLError, err:
  718.                                     err.cArgs = cArgs 
  719.                                     err.pyArgs = pyArgs
  720.                                     raise err
  721.                                 # handle storage of persistent argument values...
  722.                                 storeValues(
  723.                                     result,
  724.                                     self,
  725.                                     pyArgs,
  726.                                     cArgs,
  727.                                 )
  728.                                 return result 
  729.                             return wrapperCall
  730.                     else: # null storeValues
  731.                         if returnValues:
  732.                             def wrapperCall( self, *args ):
  733.                                 """Wrapper with all save storeValues"""
  734.                                 pyArgs = tuple( calculate_pyArgs( args ))
  735.                                 cArguments = pyArgs
  736.                                 try:
  737.                                     result = self.wrappedOperation( *cArguments )
  738.                                 except ctypes.ArgumentError, err:
  739.                                     err.args = err.args + (cArguments,)
  740.                                     raise err
  741.                                 except error.GLError, err:
  742.                                     err.cArgs = cArgs 
  743.                                     err.pyArgs = pyArgs
  744.                                     raise err
  745.                                 return returnValues(
  746.                                     result,
  747.                                     self,
  748.                                     pyArgs,
  749.                                     cArgs,
  750.                                 )
  751.                             return wrapperCall
  752.                         else:
  753.                             def wrapperCall( self, *args ):
  754.                                 """Wrapper with all save returnValues and storeValues"""
  755.                                 pyArgs = tuple( calculate_pyArgs( args ))
  756.                                 cArguments = pyArgs
  757.                                 try:
  758.                                     result = self.wrappedOperation( *cArguments )
  759.                                 except ctypes.ArgumentError, err:
  760.                                     err.args = err.args + (cArguments,)
  761.                                     raise err
  762.                                 except error.GLError, err:
  763.                                     err.cArgs = cArgs 
  764.                                     err.pyArgs = pyArgs
  765.                                     raise err
  766.                                 return result 
  767.                             return wrapperCall
  768.         else:
  769.             # null pyConverters
  770.             if cConverters:
  771.                 if cResolvers:
  772.                     if storeValues:
  773.                         if returnValues:
  774.                             def wrapperCall( self, *args ):
  775.                                 """Wrapper with all possible operations"""
  776.                                 pyArgs = args 
  777.                                 cArgs = []
  778.                                 for (index,converter) in enumerate( cConverters ):
  779.                                     # move enumerate out...
  780.                                     if not callable(converter):
  781.                                         cArgs.append( converter )
  782.                                     else:
  783.                                         try:
  784.                                             cArgs.append(
  785.                                                 converter( pyArgs, index, self )
  786.                                             )
  787.                                         except Exception, err:
  788.                                             if hasattr( err, 'args' ):
  789.                                                 err.args += (
  790.                                                     """Failure in cConverter %r"""%(converter),
  791.                                                     pyArgs, index, self,
  792.                                                 )
  793.                                             raise
  794.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  795.                                 try:
  796.                                     result = self.wrappedOperation( *cArguments )
  797.                                 except ctypes.ArgumentError, err:
  798.                                     err.args = err.args + (cArguments,)
  799.                                     raise err
  800.                                 except error.GLError, err:
  801.                                     err.cArgs = cArgs 
  802.                                     err.pyArgs = pyArgs
  803.                                     raise err
  804.                                 # handle storage of persistent argument values...
  805.                                 storeValues(
  806.                                     result,
  807.                                     self,
  808.                                     pyArgs,
  809.                                     cArgs,
  810.                                 )
  811.                                 return returnValues(
  812.                                     result,
  813.                                     self,
  814.                                     pyArgs,
  815.                                     cArgs,
  816.                                 )
  817.                             return wrapperCall
  818.                         else:
  819.                             def wrapperCall( self, *args ):
  820.                                 """Wrapper with all save returnValues"""
  821.                                 pyArgs = args 
  822.                                 cArgs = []
  823.                                 for (index,converter) in enumerate( cConverters ):
  824.                                     # move enumerate out...
  825.                                     if not callable(converter):
  826.                                         cArgs.append( converter )
  827.                                     else:
  828.                                         try:
  829.                                             cArgs.append(
  830.                                                 converter( pyArgs, index, self )
  831.                                             )
  832.                                         except Exception, err:
  833.                                             if hasattr( err, 'args' ):
  834.                                                 err.args += (
  835.                                                     """Failure in cConverter %r"""%(converter),
  836.                                                     pyArgs, index, self,
  837.                                                 )
  838.                                             raise
  839.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  840.                                 try:
  841.                                     result = self.wrappedOperation( *cArguments )
  842.                                 except ctypes.ArgumentError, err:
  843.                                     err.args = err.args + (cArguments,)
  844.                                     raise err
  845.                                 except error.GLError, err:
  846.                                     err.cArgs = cArgs 
  847.                                     err.pyArgs = pyArgs
  848.                                     raise err
  849.                                 # handle storage of persistent argument values...
  850.                                 storeValues(
  851.                                     result,
  852.                                     self,
  853.                                     pyArgs,
  854.                                     cArgs,
  855.                                 )
  856.                                 return result 
  857.                             return wrapperCall
  858.                     else: # null storeValues
  859.                         if returnValues:
  860.                             def wrapperCall( self, *args ):
  861.                                 """Wrapper with all save storeValues"""
  862.                                 pyArgs = args 
  863.                                 cArgs = []
  864.                                 for (index,converter) in enumerate( cConverters ):
  865.                                     # move enumerate out...
  866.                                     if not callable(converter):
  867.                                         cArgs.append( converter )
  868.                                     else:
  869.                                         try:
  870.                                             cArgs.append(
  871.                                                 converter( pyArgs, index, self )
  872.                                             )
  873.                                         except Exception, err:
  874.                                             if hasattr( err, 'args' ):
  875.                                                 err.args += (
  876.                                                     """Failure in cConverter %r"""%(converter),
  877.                                                     pyArgs, index, self,
  878.                                                 )
  879.                                             raise
  880.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  881.                                 try:
  882.                                     result = self.wrappedOperation( *cArguments )
  883.                                 except ctypes.ArgumentError, err:
  884.                                     err.args = err.args + (cArguments,)
  885.                                     raise err
  886.                                 except error.GLError, err:
  887.                                     err.cArgs = cArgs 
  888.                                     err.pyArgs = pyArgs
  889.                                     raise err
  890.                                 return returnValues(
  891.                                     result,
  892.                                     self,
  893.                                     pyArgs,
  894.                                     cArgs,
  895.                                 )
  896.                             return wrapperCall
  897.                         else:
  898.                             def wrapperCall( self, *args ):
  899.                                 """Wrapper with all save returnValues and storeValues"""
  900.                                 pyArgs = args 
  901.                                 cArgs = []
  902.                                 for (index,converter) in enumerate( cConverters ):
  903.                                     # move enumerate out...
  904.                                     if not callable(converter):
  905.                                         cArgs.append( converter )
  906.                                     else:
  907.                                         try:
  908.                                             cArgs.append(
  909.                                                 converter( pyArgs, index, self )
  910.                                             )
  911.                                         except Exception, err:
  912.                                             if hasattr( err, 'args' ):
  913.                                                 err.args += (
  914.                                                     """Failure in cConverter %r"""%(converter),
  915.                                                     pyArgs, index, self,
  916.                                                 )
  917.                                             raise
  918.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  919.                                 try:
  920.                                     result = self.wrappedOperation( *cArguments )
  921.                                 except ctypes.ArgumentError, err:
  922.                                     err.args = err.args + (cArguments,)
  923.                                     raise err
  924.                                 except error.GLError, err:
  925.                                     err.cArgs = cArgs 
  926.                                     err.pyArgs = pyArgs
  927.                                     raise err
  928.                                 return result 
  929.                             return wrapperCall
  930.                 else:
  931.                     # null cResolvers
  932.                     if storeValues:
  933.                         if returnValues:
  934.                             def wrapperCall( self, *args ):
  935.                                 """Wrapper with all possible operations"""
  936.                                 pyArgs = args 
  937.                                 cArgs = []
  938.                                 for (index,converter) in enumerate( cConverters ):
  939.                                     # move enumerate out...
  940.                                     if not callable(converter):
  941.                                         cArgs.append( converter )
  942.                                     else:
  943.                                         try:
  944.                                             cArgs.append(
  945.                                                 converter( pyArgs, index, self )
  946.                                             )
  947.                                         except Exception, err:
  948.                                             if hasattr( err, 'args' ):
  949.                                                 err.args += (
  950.                                                     """Failure in cConverter %r"""%(converter),
  951.                                                     pyArgs, index, self,
  952.                                                 )
  953.                                             raise
  954.                                 cArguments = cArgs
  955.                                 try:
  956.                                     result = self.wrappedOperation( *cArguments )
  957.                                 except ctypes.ArgumentError, err:
  958.                                     err.args = err.args + (cArguments,)
  959.                                     raise err
  960.                                 except error.GLError, err:
  961.                                     err.cArgs = cArgs 
  962.                                     err.pyArgs = pyArgs
  963.                                     raise err
  964.                                 # handle storage of persistent argument values...
  965.                                 storeValues(
  966.                                     result,
  967.                                     self,
  968.                                     pyArgs,
  969.                                     cArgs,
  970.                                 )
  971.                                 return returnValues(
  972.                                     result,
  973.                                     self,
  974.                                     pyArgs,
  975.                                     cArgs,
  976.                                 )
  977.                             return wrapperCall
  978.                         else:
  979.                             def wrapperCall( self, *args ):
  980.                                 """Wrapper with all save returnValues"""
  981.                                 pyArgs = args 
  982.                                 cArgs = []
  983.                                 for (index,converter) in enumerate( cConverters ):
  984.                                     # move enumerate out...
  985.                                     if not callable(converter):
  986.                                         cArgs.append( converter )
  987.                                     else:
  988.                                         try:
  989.                                             cArgs.append(
  990.                                                 converter( pyArgs, index, self )
  991.                                             )
  992.                                         except Exception, err:
  993.                                             if hasattr( err, 'args' ):
  994.                                                 err.args += (
  995.                                                     """Failure in cConverter %r"""%(converter),
  996.                                                     pyArgs, index, self,
  997.                                                 )
  998.                                             raise
  999.                                 cArguments = cArgs
  1000.                                 try:
  1001.                                     result = self.wrappedOperation( *cArguments )
  1002.                                 except ctypes.ArgumentError, err:
  1003.                                     err.args = err.args + (cArguments,)
  1004.                                     raise err
  1005.                                 except error.GLError, err:
  1006.                                     err.cArgs = cArgs 
  1007.                                     err.pyArgs = pyArgs
  1008.                                     raise err
  1009.                                 # handle storage of persistent argument values...
  1010.                                 storeValues(
  1011.                                     result,
  1012.                                     self,
  1013.                                     pyArgs,
  1014.                                     cArgs,
  1015.                                 )
  1016.                                 return result 
  1017.                             return wrapperCall
  1018.                     else: # null storeValues
  1019.                         if returnValues:
  1020.                             def wrapperCall( self, *args ):
  1021.                                 """Wrapper with all save storeValues"""
  1022.                                 pyArgs = args 
  1023.                                 cArgs = []
  1024.                                 for (index,converter) in enumerate( cConverters ):
  1025.                                     # move enumerate out...
  1026.                                     if not callable(converter):
  1027.                                         cArgs.append( converter )
  1028.                                     else:
  1029.                                         try:
  1030.                                             cArgs.append(
  1031.                                                 converter( pyArgs, index, self )
  1032.                                             )
  1033.                                         except Exception, err:
  1034.                                             if hasattr( err, 'args' ):
  1035.                                                 err.args += (
  1036.                                                     """Failure in cConverter %r"""%(converter),
  1037.                                                     pyArgs, index, self,
  1038.                                                 )
  1039.                                             raise
  1040.                                 cArguments = cArgs
  1041.                                 try:
  1042.                                     result = self.wrappedOperation( *cArguments )
  1043.                                 except ctypes.ArgumentError, err:
  1044.                                     err.args = err.args + (cArguments,)
  1045.                                     raise err
  1046.                                 except error.GLError, err:
  1047.                                     err.cArgs = cArgs 
  1048.                                     err.pyArgs = pyArgs
  1049.                                     raise err
  1050.                                 return returnValues(
  1051.                                     result,
  1052.                                     self,
  1053.                                     pyArgs,
  1054.                                     cArgs,
  1055.                                 )
  1056.                             return wrapperCall
  1057.                         else:
  1058.                             def wrapperCall( self, *args ):
  1059.                                 """Wrapper with all save returnValues and storeValues"""
  1060.                                 pyArgs = args 
  1061.                                 cArgs = []
  1062.                                 for (index,converter) in enumerate( cConverters ):
  1063.                                     # move enumerate out...
  1064.                                     if not callable(converter):
  1065.                                         cArgs.append( converter )
  1066.                                     else:
  1067.                                         try:
  1068.                                             cArgs.append(
  1069.                                                 converter( pyArgs, index, self )
  1070.                                             )
  1071.                                         except Exception, err:
  1072.                                             if hasattr( err, 'args' ):
  1073.                                                 err.args += (
  1074.                                                     """Failure in cConverter %r"""%(converter),
  1075.                                                     pyArgs, index, self,
  1076.                                                 )
  1077.                                             raise
  1078.                                 cArguments = cArgs
  1079.                                 try:
  1080.                                     result = self.wrappedOperation( *cArguments )
  1081.                                 except ctypes.ArgumentError, err:
  1082.                                     err.args = err.args + (cArguments,)
  1083.                                     raise err
  1084.                                 except error.GLError, err:
  1085.                                     err.cArgs = cArgs 
  1086.                                     err.pyArgs = pyArgs
  1087.                                     raise err
  1088.                                 return result 
  1089.                             return wrapperCall
  1090.             else:
  1091.                 # null cConverters
  1092.                 if cResolvers:
  1093.                     if storeValues:
  1094.                         if returnValues:
  1095.                             def wrapperCall( self, *args ):
  1096.                                 """Wrapper with all possible operations"""
  1097.                                 cArgs = args
  1098.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  1099.                                 try:
  1100.                                     result = self.wrappedOperation( *cArguments )
  1101.                                 except ctypes.ArgumentError, err:
  1102.                                     err.args = err.args + (cArguments,)
  1103.                                     raise err
  1104.                                 except error.GLError, err:
  1105.                                     err.cArgs = cArgs 
  1106.                                     err.pyArgs = args
  1107.                                     raise err
  1108.                                 # handle storage of persistent argument values...
  1109.                                 storeValues(
  1110.                                     result,
  1111.                                     self,
  1112.                                     args,
  1113.                                     cArgs,
  1114.                                 )
  1115.                                 return returnValues(
  1116.                                     result,
  1117.                                     self,
  1118.                                     args,
  1119.                                     cArgs,
  1120.                                 )
  1121.                             return wrapperCall
  1122.                         else:
  1123.                             def wrapperCall( self, *args ):
  1124.                                 """Wrapper with all save returnValues"""
  1125.                                 cArgs = args
  1126.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  1127.                                 try:
  1128.                                     result = self.wrappedOperation( *cArguments )
  1129.                                 except ctypes.ArgumentError, err:
  1130.                                     err.args = err.args + (cArguments,)
  1131.                                     raise err
  1132.                                 except error.GLError, err:
  1133.                                     err.cArgs = cArgs 
  1134.                                     err.pyArgs = args
  1135.                                     raise err
  1136.                                 # handle storage of persistent argument values...
  1137.                                 storeValues(
  1138.                                     result,
  1139.                                     self,
  1140.                                     args,
  1141.                                     cArgs,
  1142.                                 )
  1143.                                 return result 
  1144.                             return wrapperCall
  1145.                     else: # null storeValues
  1146.                         if returnValues:
  1147.                             def wrapperCall( self, *args ):
  1148.                                 """Wrapper with all save storeValues"""
  1149.                                 cArgs = args
  1150.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  1151.                                 try:
  1152.                                     result = self.wrappedOperation( *cArguments )
  1153.                                 except ctypes.ArgumentError, err:
  1154.                                     err.args = err.args + (cArguments,)
  1155.                                     raise err
  1156.                                 except error.GLError, err:
  1157.                                     err.cArgs = cArgs 
  1158.                                     err.pyArgs = args
  1159.                                     raise err
  1160.                                 return returnValues(
  1161.                                     result,
  1162.                                     self,
  1163.                                     args,
  1164.                                     cArgs,
  1165.                                 )
  1166.                             return wrapperCall
  1167.                         else:
  1168.                             def wrapperCall( self, *args ):
  1169.                                 """Wrapper with all save returnValues and storeValues"""
  1170.                                 cArgs = args
  1171.                                 cArguments = tuple(calculate_cArguments( cArgs ))
  1172.                                 try:
  1173.                                     result = self.wrappedOperation( *cArguments )
  1174.                                 except ctypes.ArgumentError, err:
  1175.                                     err.args = err.args + (cArguments,)
  1176.                                     raise err
  1177.                                 except error.GLError, err:
  1178.                                     err.cArgs = cArgs 
  1179.                                     err.pyArgs = args
  1180.                                     raise err
  1181.                                 return result 
  1182.                             return wrapperCall
  1183.                 else:
  1184.                     # null cResolvers
  1185.                     if storeValues:
  1186.                         if returnValues:
  1187.                             def wrapperCall( self, *args ):
  1188.                                 """Wrapper with all possible operations"""
  1189.                                 cArguments = args
  1190.                                 try:
  1191.                                     result = self.wrappedOperation( *cArguments )
  1192.                                 except ctypes.ArgumentError, err:
  1193.                                     err.args = err.args + (cArguments,)
  1194.                                     raise err
  1195.                                 except error.GLError, err:
  1196.                                     err.cArgs = cArgs 
  1197.                                     err.pyArgs = args
  1198.                                     raise err
  1199.                                 # handle storage of persistent argument values...
  1200.                                 storeValues(
  1201.                                     result,
  1202.                                     self,
  1203.                                     args,
  1204.                                     cArgs,
  1205.                                 )
  1206.                                 return returnValues(
  1207.                                     result,
  1208.                                     self,
  1209.                                     args,
  1210.                                     cArgs,
  1211.                                 )
  1212.                             return wrapperCall
  1213.                         else:
  1214.                             def wrapperCall( self, *args ):
  1215.                                 """Wrapper with all save returnValues"""
  1216.                                 cArguments = args
  1217.                                 try:
  1218.                                     result = self.wrappedOperation( *cArguments )
  1219.                                 except ctypes.ArgumentError, err:
  1220.                                     err.args = err.args + (cArguments,)
  1221.                                     raise err
  1222.                                 except error.GLError, err:
  1223.                                     err.cArgs = cArgs 
  1224.                                     err.pyArgs = args
  1225.                                     raise err
  1226.                                 # handle storage of persistent argument values...
  1227.                                 storeValues(
  1228.                                     result,
  1229.                                     self,
  1230.                                     args,
  1231.                                     cArgs,
  1232.                                 )
  1233.                                 return result 
  1234.                             return wrapperCall
  1235.                     else: # null storeValues
  1236.                         if returnValues:
  1237.                             def wrapperCall( self, *args ):
  1238.                                 """Wrapper with all save storeValues"""
  1239.                                 cArguments = args
  1240.                                 try:
  1241.                                     result = self.wrappedOperation( *cArguments )
  1242.                                 except ctypes.ArgumentError, err:
  1243.                                     err.args = err.args + (cArguments,)
  1244.                                     raise err
  1245.                                 except error.GLError, err:
  1246.                                     err.cArgs = cArgs 
  1247.                                     err.pyArgs = args
  1248.                                     raise err
  1249.                                 return returnValues(
  1250.                                     result,
  1251.                                     self,
  1252.                                     args,
  1253.                                     cArgs,
  1254.                                 )
  1255.                             return wrapperCall
  1256.                         else:
  1257.                             def wrapperCall( self, *args ):
  1258.                                 """Wrapper with all save returnValues and storeValues"""
  1259.                                 cArguments = args
  1260.                                 try:
  1261.                                     result = self.wrappedOperation( *cArguments )
  1262.                                 except ctypes.ArgumentError, err:
  1263.                                     err.args = err.args + (cArguments,)
  1264.                                     raise err
  1265.                                 except error.GLError, err:
  1266.                                     err.cArgs = cArgs 
  1267.                                     err.pyArgs = args
  1268.                                     raise err
  1269.                                 return result 
  1270.                             return wrapperCall
  1271.     def __call__( self, *args, **named ):
  1272.         """Finalise the wrapper before calling it"""
  1273.         return self.finalise()( *args, **named )
  1274.  
  1275.     def _unspecialised__call__( self, *args ):
  1276.         """Expand arguments, call the function, store values and check errors"""
  1277.         pyConverters = getattr( self, 'pyConverters', None )
  1278.         if pyConverters:
  1279.             if len(pyConverters) != len(args):
  1280.                 raise ValueError(
  1281.                     """%s requires %r arguments (%s), received %s: %r"""%(
  1282.                         self.wrappedOperation.__name__,
  1283.                         len(pyConverters),
  1284.                         ", ".join( self.pyConverterNames ),
  1285.                         len(args),
  1286.                         args
  1287.                     )
  1288.                 )
  1289.             pyArgs = []
  1290.             for (converter,arg) in zip(pyConverters,args):
  1291.                 if converter is None:
  1292.                     pyArgs.append( arg )
  1293.                 else:
  1294.                     pyArgs.append( converter(arg, self, args) )
  1295.         else:
  1296.             pyArgs = args 
  1297.         cConverters = getattr( self, 'cConverters', None )
  1298.         if cConverters:
  1299.             cArgs = []
  1300.             for (index,converter) in enumerate( cConverters ):
  1301.                 if not callable(converter):
  1302.                     cArgs.append( converter )
  1303.                 else:
  1304.                     try:
  1305.                         cArgs.append(
  1306.                             converter( pyArgs, index, self )
  1307.                         )
  1308.                     except Exception, err:
  1309.                         if hasattr( err, 'args' ):
  1310.                             err.args += (
  1311.                                 """Failure in cConverter %r"""%(converter),
  1312.                                 pyArgs, index, self,
  1313.                             )
  1314.                         raise
  1315.         else:
  1316.             cArgs = pyArgs
  1317.         cResolvers = getattr( self, 'cResolvers', None )
  1318.         if cResolvers:
  1319.             cArguments = []
  1320.             for (converter, value) in zip( cResolvers, cArgs ):
  1321.                 if converter is None:
  1322.                     cArguments.append( value )
  1323.                 else:
  1324.                     cArguments.append( converter( value ) )
  1325.         else:
  1326.             cArguments = cArgs
  1327.         try:
  1328.             result = self.wrappedOperation( *cArguments )
  1329.         except ctypes.ArgumentError, err:
  1330.             err.args = err.args + (cArguments,)
  1331.             raise err
  1332.         except error.GLError, err:
  1333.             err.cArgs = cArgs 
  1334.             err.pyArgs = pyArgs
  1335.             raise err
  1336.         storeValues = getattr( self, 'storeValues', None )
  1337.         if storeValues is not None:
  1338.             # handle storage of persistent argument values...
  1339.             storeValues(
  1340.                 result,
  1341.                 self,
  1342.                 pyArgs,
  1343.                 cArgs,
  1344.             )
  1345.         returnValues = getattr( self, 'returnValues', None )
  1346.         if returnValues is not None:
  1347.             return returnValues(
  1348.                 result,
  1349.                 self,
  1350.                 pyArgs,
  1351.                 cArgs,
  1352.             )
  1353.         else:
  1354.             return result
  1355.  
  1356. def wrapper( wrappedOperation ):
  1357.     """Create a Wrapper sub-class instance for the given wrappedOperation
  1358.     
  1359.     The purpose of this function is to create a subclass of Wrapper which
  1360.     has the __doc__ and __name__ of the wrappedOperation so that the instance of
  1361.     the wrapper will show up as <functionname instance @ address> by default,
  1362.     and will have the docstring available naturally in pydoc and the like.
  1363.     """
  1364.     if isinstance( wrappedOperation, Wrapper ):
  1365.         return wrappedOperation
  1366.     dict = {
  1367.         '__doc__': wrappedOperation.__doc__,
  1368.         '__slots__': ('wrappedOperation', ),
  1369.     }
  1370.     cls = type( wrappedOperation.__name__, (Wrapper,), dict )
  1371.     instance = cls(wrappedOperation)
  1372.     return instance
  1373.