Source code for OpenGL.constant
"""Implementation of OpenGL constant objects"""
import sys
from OpenGL._bytes import bytes,unicode,as_8_bit, long, integer_types, maxsize
from OpenGL import _configflags
class Constant( object ):
"""OpenGL constant that displays itself as a name rather than a value
The purpose of this class is to make debugging OpenGL code easier,
as you recieve messages that say what value you passed in in a
human-readable form, rather than as a bald number that requires
lookup and disambiguation in the header file.
"""
def __new__( cls, name, value=None ):
"""Initialise the constant with the given name and value"""
if not isinstance( value, Constant ):
if isinstance( value, float ) and cls is not FloatConstant:
return FloatConstant( name, value )
elif isinstance( value, int ) and cls is not IntConstant:
return IntConstant( name, value )
elif isinstance( value, long ) and cls is not LongConstant:
return LongConstant( name, value )
elif isinstance( value, (bytes,unicode) ) and cls is not StringConstant:
return StringConstant( name, as_8_bit(value) )
if isinstance( value, integer_types ):
if value > maxsize: # TODO: I'm guessing this should really by sizeof GLint, not
value = - (value & maxsize)
base = super(Constant,cls).__new__( cls, value )
base.name = name
if _configflags.MODULE_ANNOTATIONS:
frame = sys._getframe().f_back
if frame and frame.f_back and '__name__' in frame.f_back.f_globals:
base.__module__ = frame.f_back.f_globals['__name__']
return base
def __repr__( self ):
"""Return the name, rather than the bald value"""
return self.name
def __getnewargs__( self ):
"""Produce the new arguments for recreating the instance"""
return (self.name,) + super( Constant, self ).__getnewargs__()
class NumericConstant( Constant ):
"""Base class for numeric-value constants"""
def __str__( self ):
"""Return the value as a human-friendly string"""
return '%s (%s)'%(self.name,super(Constant,self).__str__())
def __getstate__(self):
"""Retrieve state for pickle and the like"""
return self.name
def __setstate__( self, state ):
self.name = state
class IntConstant( NumericConstant, int ):
"""Integer constant"""
if int is not long:
class LongConstant( NumericConstant, long ):
"""Long integer constant"""
else:
LongConstant = IntConstant
class FloatConstant( NumericConstant, float ):
"""Float constant"""
class StringConstant( Constant, bytes ):
"""String constants"""
def __repr__( self ):
"""Return the value as a human-friendly string"""
return '%s (%s)'%(self.name,super(Constant,self).__str__())
if __name__ == "__main__":
x = IntConstant( 'testint', 3 )
y = FloatConstant( 'testfloat', 3.0 )
z = StringConstant( 'teststr', 'some testing string' )
import pickle
for val in x,y,z:
restored = pickle.loads( pickle.dumps( val ))
assert restored == val, (str(restored),str(val))
assert restored.name == val.name, (restored.name,val.name)