Viewing file: formathandler.py (3.95 KB) -rw-r--r-- Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
"""Base class for the various Python data-format storage type APIs
Data-type handlers are specified using OpenGL.plugins module """ import ctypes from OpenGL import plugins
class FormatHandler( object ): """Abstract class describing the handler interface Each data-type handler is responsible for providing a number of methods which allow it to manipulate (and create) instances of the data-type it represents. """ LAZY_TYPE_REGISTRY = {} # more registrations HANDLER_REGISTRY = {} baseType = None typeConstant = None HANDLED_TYPES = () preferredOutput = None isOutput = False GENERIC_OUTPUT_PREFERENCES = ['numpy','numeric','ctypesarrays'] ALL_OUTPUT_HANDLERS = [] def loadAll( cls ): """Load all setuptools-registered FormatHandler classes register a new datatype with code similar to this in your package's setup.py for setuptools: entry_points = { 'OpenGL.arrays.formathandler':[ 'numpy = OpenGL.arrays.numpymodule.NumpyHandler', ], } """ for entrypoint in plugins.FormatHandler.all(): cls.loadPlugin( entrypoint ) @classmethod def loadPlugin( cls, entrypoint ): """Load a single entry-point via plugins module""" if not entrypoint.loaded: from OpenGL.arrays.arraydatatype import ArrayDatatype try: plugin_class = entrypoint.load() except ImportError, err: from OpenGL import logs,WARN_ON_FORMAT_UNAVAILABLE log = logs.getLog( 'OpenGL.formathandler' ) if WARN_ON_FORMAT_UNAVAILABLE: logFunc = log.warn else: logFunc = log.info logFunc( 'Unable to load registered array format handler %s:\n%s', entrypoint.name, log.getException( err ) ) else: handler = plugin_class() handler.register( handler.HANDLED_TYPES ) ArrayDatatype.getRegistry()[ entrypoint.name ] = handler entrypoint.loaded = True @classmethod def typeLookup( cls, type ): """Lookup handler by data-type""" registry = ArrayDatatype.getRegistry() try: return registry[ type ] except KeyError, err: key = '%s.%s'%(type.__module__,type.__name__) plugin = cls.LAZY_TYPE_REGISTRY.get( key ) if plugin: cls.loadPlugin( plugin ) return registry[ type ] raise KeyError( """Unable to find data-format handler for %s"""%( type,)) loadAll = classmethod( loadAll )
def register( self, types=None ): """Register this class as handler for given set of types""" from OpenGL.arrays.arraydatatype import ArrayDatatype ArrayDatatype.getRegistry().register( self, types ) def registerReturn( self ): """Register this handler as the default return-type handler""" from OpenGL.arrays.arraydatatype import ArrayDatatype ArrayDatatype.getRegistry().registerReturn( self )
def from_param( self, value, typeCode=None ): """Convert to a ctypes pointer value""" def dataPointer( self, value ): """return long for pointer value""" def asArray( self, value, typeCode=None ): """Given a value, convert to array representation""" def arrayToGLType( self, value ): """Given a value, guess OpenGL type of the corresponding pointer""" def arraySize( self, value, typeCode = None ): """Given a data-value, calculate dimensions for the array""" def unitSize( self, value, typeCode=None ): """Determine unit size of an array (if possible)""" if self.baseType is not None: return def dimensions( self, value, typeCode=None ): """Determine dimensions of the passed array value (if possible)"""
|