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