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