# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.39
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_GLUtils', [dirname(__file__)])
        except ImportError:
            import _GLUtils
            return _GLUtils
        if fp is not None:
            try:
                _mod = imp.load_module('_GLUtils', fp, pathname, description)
            finally:
                fp.close()
                return _mod
    _GLUtils = swig_import_helper()
    del swig_import_helper
else:
    import _GLUtils
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


import Utils
import MathLib
class GLUtils(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUtils, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUtils, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _GLUtils.new_GLUtils()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLUtils
    __del__ = lambda self : None;
    __swig_getmethods__["gprintf"] = lambda x: _GLUtils.GLUtils_gprintf
    if _newclass:gprintf = staticmethod(_GLUtils.GLUtils_gprintf)
    __swig_getmethods__["drawWireFrameBox"] = lambda x: _GLUtils.GLUtils_drawWireFrameBox
    if _newclass:drawWireFrameBox = staticmethod(_GLUtils.GLUtils_drawWireFrameBox)
    __swig_getmethods__["drawSphere"] = lambda x: _GLUtils.GLUtils_drawSphere
    if _newclass:drawSphere = staticmethod(_GLUtils.GLUtils_drawSphere)
    __swig_getmethods__["drawAxes"] = lambda x: _GLUtils.GLUtils_drawAxes
    if _newclass:drawAxes = staticmethod(_GLUtils.GLUtils_drawAxes)
    __swig_getmethods__["drawCapsule"] = lambda x: _GLUtils.GLUtils_drawCapsule
    if _newclass:drawCapsule = staticmethod(_GLUtils.GLUtils_drawCapsule)
    __swig_getmethods__["drawDisk"] = lambda x: _GLUtils.GLUtils_drawDisk
    if _newclass:drawDisk = staticmethod(_GLUtils.GLUtils_drawDisk)
    __swig_getmethods__["drawCylinder"] = lambda x: _GLUtils.GLUtils_drawCylinder
    if _newclass:drawCylinder = staticmethod(_GLUtils.GLUtils_drawCylinder)
    __swig_getmethods__["drawCone"] = lambda x: _GLUtils.GLUtils_drawCone
    if _newclass:drawCone = staticmethod(_GLUtils.GLUtils_drawCone)
    __swig_getmethods__["drawArrow"] = lambda x: _GLUtils.GLUtils_drawArrow
    if _newclass:drawArrow = staticmethod(_GLUtils.GLUtils_drawArrow)
    __swig_getmethods__["saveScreenShot"] = lambda x: _GLUtils.GLUtils_saveScreenShot
    if _newclass:saveScreenShot = staticmethod(_GLUtils.GLUtils_saveScreenShot)
    __swig_getmethods__["drawCheckerboard"] = lambda x: _GLUtils.GLUtils_drawCheckerboard
    if _newclass:drawCheckerboard = staticmethod(_GLUtils.GLUtils_drawCheckerboard)
    __swig_getmethods__["drawBox"] = lambda x: _GLUtils.GLUtils_drawBox
    if _newclass:drawBox = staticmethod(_GLUtils.GLUtils_drawBox)
    __swig_getmethods__["drawGrid"] = lambda x: _GLUtils.GLUtils_drawGrid
    if _newclass:drawGrid = staticmethod(_GLUtils.GLUtils_drawGrid)
    __swig_getmethods__["printOglError"] = lambda x: _GLUtils.GLUtils_printOglError
    if _newclass:printOglError = staticmethod(_GLUtils.GLUtils_printOglError)
    __swig_getmethods__["drawGround"] = lambda x: _GLUtils.GLUtils_drawGround
    if _newclass:drawGround = staticmethod(_GLUtils.GLUtils_drawGround)
GLUtils_swigregister = _GLUtils.GLUtils_swigregister
GLUtils_swigregister(GLUtils)

def GLUtils_gprintf(*args):
  return _GLUtils.GLUtils_gprintf(*args)
GLUtils_gprintf = _GLUtils.GLUtils_gprintf

def GLUtils_drawWireFrameBox(*args):
  return _GLUtils.GLUtils_drawWireFrameBox(*args)
GLUtils_drawWireFrameBox = _GLUtils.GLUtils_drawWireFrameBox

def GLUtils_drawSphere(*args):
  return _GLUtils.GLUtils_drawSphere(*args)
GLUtils_drawSphere = _GLUtils.GLUtils_drawSphere

def GLUtils_drawAxes(*args):
  return _GLUtils.GLUtils_drawAxes(*args)
GLUtils_drawAxes = _GLUtils.GLUtils_drawAxes

def GLUtils_drawCapsule(*args):
  return _GLUtils.GLUtils_drawCapsule(*args)
GLUtils_drawCapsule = _GLUtils.GLUtils_drawCapsule

def GLUtils_drawDisk(*args):
  return _GLUtils.GLUtils_drawDisk(*args)
GLUtils_drawDisk = _GLUtils.GLUtils_drawDisk

def GLUtils_drawCylinder(*args):
  return _GLUtils.GLUtils_drawCylinder(*args)
GLUtils_drawCylinder = _GLUtils.GLUtils_drawCylinder

def GLUtils_drawCone(*args):
  return _GLUtils.GLUtils_drawCone(*args)
GLUtils_drawCone = _GLUtils.GLUtils_drawCone

def GLUtils_drawArrow(*args):
  return _GLUtils.GLUtils_drawArrow(*args)
GLUtils_drawArrow = _GLUtils.GLUtils_drawArrow

def GLUtils_saveScreenShot(*args):
  return _GLUtils.GLUtils_saveScreenShot(*args)
GLUtils_saveScreenShot = _GLUtils.GLUtils_saveScreenShot

def GLUtils_drawCheckerboard(*args):
  return _GLUtils.GLUtils_drawCheckerboard(*args)
GLUtils_drawCheckerboard = _GLUtils.GLUtils_drawCheckerboard

def GLUtils_drawBox(*args):
  return _GLUtils.GLUtils_drawBox(*args)
GLUtils_drawBox = _GLUtils.GLUtils_drawBox

def GLUtils_drawGrid(*args):
  return _GLUtils.GLUtils_drawGrid(*args)
GLUtils_drawGrid = _GLUtils.GLUtils_drawGrid

def GLUtils_printOglError(*args):
  return _GLUtils.GLUtils_printOglError(*args)
GLUtils_printOglError = _GLUtils.GLUtils_printOglError

def GLUtils_drawGround(*args):
  return _GLUtils.GLUtils_drawGround(*args)
GLUtils_drawGround = _GLUtils.GLUtils_drawGround

class GLCamera(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLCamera, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLCamera, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _GLUtils.new_GLCamera()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLCamera
    __del__ = lambda self : None;
    def applyCameraTransformations(self): return _GLUtils.GLCamera_applyCameraTransformations(self)
    def translateTarget(self, *args): return _GLUtils.GLCamera_translateTarget(self, *args)
    def setTarget(self, *args): return _GLUtils.GLCamera_setTarget(self, *args)
    def modifyRotations(self, *args): return _GLUtils.GLCamera_modifyRotations(self, *args)
    def translateCamDistance(self, *args): return _GLUtils.GLCamera_translateCamDistance(self, *args)
    def getRotations(self): return _GLUtils.GLCamera_getRotations(self)
    def getCamDistance(self): return _GLUtils.GLCamera_getCamDistance(self)
    def getTarget(self): return _GLUtils.GLCamera_getTarget(self)
    def getWorldToCam(self): return _GLUtils.GLCamera_getWorldToCam(self)
    def setAutoOrbit(self, *args): return _GLUtils.GLCamera_setAutoOrbit(self, *args)
    def doesAutoOrbit(self): return _GLUtils.GLCamera_doesAutoOrbit(self)
GLCamera_swigregister = _GLUtils.GLCamera_swigregister
GLCamera_swigregister(GLCamera)

class GLTexture(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLTexture, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLTexture, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _GLUtils.new_GLTexture(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLTexture
    __del__ = lambda self : None;
    def activate(self): return _GLUtils.GLTexture_activate(self)
GLTexture_swigregister = _GLUtils.GLTexture_swigregister
GLTexture_swigregister(GLTexture)

class VertexInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VertexInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VertexInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["n1Index"] = _GLUtils.VertexInfo_n1Index_set
    __swig_getmethods__["n1Index"] = _GLUtils.VertexInfo_n1Index_get
    if _newclass:n1Index = _swig_property(_GLUtils.VertexInfo_n1Index_get, _GLUtils.VertexInfo_n1Index_set)
    __swig_setmethods__["n2Index"] = _GLUtils.VertexInfo_n2Index_set
    __swig_getmethods__["n2Index"] = _GLUtils.VertexInfo_n2Index_get
    if _newclass:n2Index = _swig_property(_GLUtils.VertexInfo_n2Index_get, _GLUtils.VertexInfo_n2Index_set)
    def __init__(self, *args): 
        this = _GLUtils.new_VertexInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_VertexInfo
    __del__ = lambda self : None;
VertexInfo_swigregister = _GLUtils.VertexInfo_swigregister
VertexInfo_swigregister(VertexInfo)

class SharedVertexInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedVertexInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedVertexInfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
SharedVertexInfo_swigregister = _GLUtils.SharedVertexInfo_swigregister
SharedVertexInfo_swigregister(SharedVertexInfo)

class GLIndexedPoly(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLIndexedPoly, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLIndexedPoly, name)
    __repr__ = _swig_repr
    __swig_setmethods__["indexes"] = _GLUtils.GLIndexedPoly_indexes_set
    __swig_getmethods__["indexes"] = _GLUtils.GLIndexedPoly_indexes_get
    if _newclass:indexes = _swig_property(_GLUtils.GLIndexedPoly_indexes_get, _GLUtils.GLIndexedPoly_indexes_set)
    def clear(self): return _GLUtils.GLIndexedPoly_clear(self)
    def addVertexIndex(self, *args): return _GLUtils.GLIndexedPoly_addVertexIndex(self, *args)
    def __init__(self): 
        this = _GLUtils.new_GLIndexedPoly()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLIndexedPoly
    __del__ = lambda self : None;
GLIndexedPoly_swigregister = _GLUtils.GLIndexedPoly_swigregister
GLIndexedPoly_swigregister(GLIndexedPoly)

class GLPolyIndexList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLPolyIndexList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLPolyIndexList, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _GLUtils.new_GLPolyIndexList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLPolyIndexList
    __del__ = lambda self : None;
    def addPoly(self, *args): return _GLUtils.GLPolyIndexList_addPoly(self, *args)
GLPolyIndexList_swigregister = _GLUtils.GLPolyIndexList_swigregister
GLPolyIndexList_swigregister(GLPolyIndexList)

class GLPolyCategory(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLPolyCategory, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLPolyCategory, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
GLPolyCategory_swigregister = _GLUtils.GLPolyCategory_swigregister
GLPolyCategory_swigregister(GLPolyCategory)

class GLMesh(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLMesh, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLMesh, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _GLUtils.new_GLMesh()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLMesh
    __del__ = lambda self : None;
    def setOriginalFilename(self, *args): return _GLUtils.GLMesh_setOriginalFilename(self, *args)
    def getOriginalFilename(self): return _GLUtils.GLMesh_getOriginalFilename(self)
    def addVertex(self, *args): return _GLUtils.GLMesh_addVertex(self, *args)
    def setVertexCoordinates(self, *args): return _GLUtils.GLMesh_setVertexCoordinates(self, *args)
    def setVertexTexCoordinates(self, *args): return _GLUtils.GLMesh_setVertexTexCoordinates(self, *args)
    def offset(self, *args): return _GLUtils.GLMesh_offset(self, *args)
    def scale(self, *args): return _GLUtils.GLMesh_scale(self, *args)
    def computeNormals(self, modifier = 1): return _GLUtils.GLMesh_computeNormals(self, modifier)
    def addPoly(self, *args): return _GLUtils.GLMesh_addPoly(self, *args)
    def drawMesh(self, useColours = True): return _GLUtils.GLMesh_drawMesh(self, useColours)
    def drawNormals(self): return _GLUtils.GLMesh_drawNormals(self)
    def renderToObjFile(self, *args): return _GLUtils.GLMesh_renderToObjFile(self, *args)
    def getPolyCount(self): return _GLUtils.GLMesh_getPolyCount(self)
    def getVertexCount(self): return _GLUtils.GLMesh_getVertexCount(self)
    def getVertexArray(self): return _GLUtils.GLMesh_getVertexArray(self)
    def dontUseTextureMapping(self): return _GLUtils.GLMesh_dontUseTextureMapping(self)
    def doUseTextureMapping(self): return _GLUtils.GLMesh_doUseTextureMapping(self)
    def setColour(self, *args): return _GLUtils.GLMesh_setColour(self, *args)
    def getColourR(self): return _GLUtils.GLMesh_getColourR(self)
    def getColourG(self): return _GLUtils.GLMesh_getColourG(self)
    def getColourB(self): return _GLUtils.GLMesh_getColourB(self)
    def getColourA(self): return _GLUtils.GLMesh_getColourA(self)
GLMesh_swigregister = _GLUtils.GLMesh_swigregister
GLMesh_swigregister(GLMesh)

GLUI_VISIBLE = _GLUtils.GLUI_VISIBLE
GLUI_HAS_CONTENT = _GLUtils.GLUI_HAS_CONTENT
GLUI_EXPAND = _GLUtils.GLUI_EXPAND
GLUI_VERTICAL = _GLUtils.GLUI_VERTICAL
GLUI_HORIZONTAL = _GLUtils.GLUI_HORIZONTAL
class GLUISize(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUISize, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUISize, name)
    __repr__ = _swig_repr
    __swig_setmethods__["width"] = _GLUtils.GLUISize_width_set
    __swig_getmethods__["width"] = _GLUtils.GLUISize_width_get
    if _newclass:width = _swig_property(_GLUtils.GLUISize_width_get, _GLUtils.GLUISize_width_set)
    __swig_setmethods__["height"] = _GLUtils.GLUISize_height_set
    __swig_getmethods__["height"] = _GLUtils.GLUISize_height_get
    if _newclass:height = _swig_property(_GLUtils.GLUISize_height_get, _GLUtils.GLUISize_height_set)
    def __init__(self, *args): 
        this = _GLUtils.new_GLUISize(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args): return _GLUtils.GLUISize_set(self, *args)
    def get(self, *args): return _GLUtils.GLUISize_get(self, *args)
    def setOrientation(self, *args): return _GLUtils.GLUISize_setOrientation(self, *args)
    __swig_destroy__ = _GLUtils.delete_GLUISize
    __del__ = lambda self : None;
GLUISize_swigregister = _GLUtils.GLUISize_swigregister
GLUISize_swigregister(GLUISize)

class GLUIPos(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUIPos, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUIPos, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _GLUtils.GLUIPos_x_set
    __swig_getmethods__["x"] = _GLUtils.GLUIPos_x_get
    if _newclass:x = _swig_property(_GLUtils.GLUIPos_x_get, _GLUtils.GLUIPos_x_set)
    __swig_setmethods__["y"] = _GLUtils.GLUIPos_y_set
    __swig_getmethods__["y"] = _GLUtils.GLUIPos_y_get
    if _newclass:y = _swig_property(_GLUtils.GLUIPos_y_get, _GLUtils.GLUIPos_y_set)
    def __init__(self, *args): 
        this = _GLUtils.new_GLUIPos(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args): return _GLUtils.GLUIPos_set(self, *args)
    def get(self, *args): return _GLUtils.GLUIPos_get(self, *args)
    def setOrientation(self, *args): return _GLUtils.GLUIPos_setOrientation(self, *args)
    __swig_destroy__ = _GLUtils.delete_GLUIPos
    __del__ = lambda self : None;
GLUIPos_swigregister = _GLUtils.GLUIPos_swigregister
GLUIPos_swigregister(GLUIPos)

class GLUIRect(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUIRect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUIRect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _GLUtils.GLUIRect_x_set
    __swig_getmethods__["x"] = _GLUtils.GLUIRect_x_get
    if _newclass:x = _swig_property(_GLUtils.GLUIRect_x_get, _GLUtils.GLUIRect_x_set)
    __swig_setmethods__["y"] = _GLUtils.GLUIRect_y_set
    __swig_getmethods__["y"] = _GLUtils.GLUIRect_y_get
    if _newclass:y = _swig_property(_GLUtils.GLUIRect_y_get, _GLUtils.GLUIRect_y_set)
    __swig_setmethods__["width"] = _GLUtils.GLUIRect_width_set
    __swig_getmethods__["width"] = _GLUtils.GLUIRect_width_get
    if _newclass:width = _swig_property(_GLUtils.GLUIRect_width_get, _GLUtils.GLUIRect_width_set)
    __swig_setmethods__["height"] = _GLUtils.GLUIRect_height_set
    __swig_getmethods__["height"] = _GLUtils.GLUIRect_height_get
    if _newclass:height = _swig_property(_GLUtils.GLUIRect_height_get, _GLUtils.GLUIRect_height_set)
    def __init__(self, *args): 
        this = _GLUtils.new_GLUIRect(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args): return _GLUtils.GLUIRect_set(self, *args)
    def pointInside(self, *args): return _GLUtils.GLUIRect_pointInside(self, *args)
    def getSize(self, *args): return _GLUtils.GLUIRect_getSize(self, *args)
    __swig_destroy__ = _GLUtils.delete_GLUIRect
    __del__ = lambda self : None;
GLUIRect_swigregister = _GLUtils.GLUIRect_swigregister
GLUIRect_swigregister(GLUIRect)

class GLUIColor(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUIColor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUIColor, name)
    __repr__ = _swig_repr
    __swig_setmethods__["r"] = _GLUtils.GLUIColor_r_set
    __swig_getmethods__["r"] = _GLUtils.GLUIColor_r_get
    if _newclass:r = _swig_property(_GLUtils.GLUIColor_r_get, _GLUtils.GLUIColor_r_set)
    __swig_setmethods__["g"] = _GLUtils.GLUIColor_g_set
    __swig_getmethods__["g"] = _GLUtils.GLUIColor_g_get
    if _newclass:g = _swig_property(_GLUtils.GLUIColor_g_get, _GLUtils.GLUIColor_g_set)
    __swig_setmethods__["b"] = _GLUtils.GLUIColor_b_set
    __swig_getmethods__["b"] = _GLUtils.GLUIColor_b_get
    if _newclass:b = _swig_property(_GLUtils.GLUIColor_b_get, _GLUtils.GLUIColor_b_set)
    __swig_setmethods__["a"] = _GLUtils.GLUIColor_a_set
    __swig_getmethods__["a"] = _GLUtils.GLUIColor_a_get
    if _newclass:a = _swig_property(_GLUtils.GLUIColor_a_get, _GLUtils.GLUIColor_a_set)
    def __init__(self, *args): 
        this = _GLUtils.new_GLUIColor(*args)
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args): return _GLUtils.GLUIColor_set(self, *args)
    def activate(self): return _GLUtils.GLUIColor_activate(self)
    __swig_destroy__ = _GLUtils.delete_GLUIColor
    __del__ = lambda self : None;
GLUIColor_swigregister = _GLUtils.GLUIColor_swigregister
GLUIColor_swigregister(GLUIColor)

class GLUIMouseEvent(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUIMouseEvent, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUIMouseEvent, name)
    __repr__ = _swig_repr
    __swig_setmethods__["altDown"] = _GLUtils.GLUIMouseEvent_altDown_set
    __swig_getmethods__["altDown"] = _GLUtils.GLUIMouseEvent_altDown_get
    if _newclass:altDown = _swig_property(_GLUtils.GLUIMouseEvent_altDown_get, _GLUtils.GLUIMouseEvent_altDown_set)
    __swig_setmethods__["controlDown"] = _GLUtils.GLUIMouseEvent_controlDown_set
    __swig_getmethods__["controlDown"] = _GLUtils.GLUIMouseEvent_controlDown_get
    if _newclass:controlDown = _swig_property(_GLUtils.GLUIMouseEvent_controlDown_get, _GLUtils.GLUIMouseEvent_controlDown_set)
    __swig_setmethods__["leftDown"] = _GLUtils.GLUIMouseEvent_leftDown_set
    __swig_getmethods__["leftDown"] = _GLUtils.GLUIMouseEvent_leftDown_get
    if _newclass:leftDown = _swig_property(_GLUtils.GLUIMouseEvent_leftDown_get, _GLUtils.GLUIMouseEvent_leftDown_set)
    __swig_setmethods__["middleDown"] = _GLUtils.GLUIMouseEvent_middleDown_set
    __swig_getmethods__["middleDown"] = _GLUtils.GLUIMouseEvent_middleDown_get
    if _newclass:middleDown = _swig_property(_GLUtils.GLUIMouseEvent_middleDown_get, _GLUtils.GLUIMouseEvent_middleDown_set)
    __swig_setmethods__["rightDown"] = _GLUtils.GLUIMouseEvent_rightDown_set
    __swig_getmethods__["rightDown"] = _GLUtils.GLUIMouseEvent_rightDown_get
    if _newclass:rightDown = _swig_property(_GLUtils.GLUIMouseEvent_rightDown_get, _GLUtils.GLUIMouseEvent_rightDown_set)
    __swig_setmethods__["metaDown"] = _GLUtils.GLUIMouseEvent_metaDown_set
    __swig_getmethods__["metaDown"] = _GLUtils.GLUIMouseEvent_metaDown_get
    if _newclass:metaDown = _swig_property(_GLUtils.GLUIMouseEvent_metaDown_get, _GLUtils.GLUIMouseEvent_metaDown_set)
    __swig_setmethods__["shiftDown"] = _GLUtils.GLUIMouseEvent_shiftDown_set
    __swig_getmethods__["shiftDown"] = _GLUtils.GLUIMouseEvent_shiftDown_get
    if _newclass:shiftDown = _swig_property(_GLUtils.GLUIMouseEvent_shiftDown_get, _GLUtils.GLUIMouseEvent_shiftDown_set)
    __swig_setmethods__["x"] = _GLUtils.GLUIMouseEvent_x_set
    __swig_getmethods__["x"] = _GLUtils.GLUIMouseEvent_x_get
    if _newclass:x = _swig_property(_GLUtils.GLUIMouseEvent_x_get, _GLUtils.GLUIMouseEvent_x_set)
    __swig_setmethods__["y"] = _GLUtils.GLUIMouseEvent_y_set
    __swig_getmethods__["y"] = _GLUtils.GLUIMouseEvent_y_get
    if _newclass:y = _swig_property(_GLUtils.GLUIMouseEvent_y_get, _GLUtils.GLUIMouseEvent_y_set)
    __swig_setmethods__["wheelRotation"] = _GLUtils.GLUIMouseEvent_wheelRotation_set
    __swig_getmethods__["wheelRotation"] = _GLUtils.GLUIMouseEvent_wheelRotation_get
    if _newclass:wheelRotation = _swig_property(_GLUtils.GLUIMouseEvent_wheelRotation_get, _GLUtils.GLUIMouseEvent_wheelRotation_set)
    __swig_setmethods__["wheelDelta"] = _GLUtils.GLUIMouseEvent_wheelDelta_set
    __swig_getmethods__["wheelDelta"] = _GLUtils.GLUIMouseEvent_wheelDelta_get
    if _newclass:wheelDelta = _swig_property(_GLUtils.GLUIMouseEvent_wheelDelta_get, _GLUtils.GLUIMouseEvent_wheelDelta_set)
    __swig_setmethods__["linesPerAction"] = _GLUtils.GLUIMouseEvent_linesPerAction_set
    __swig_getmethods__["linesPerAction"] = _GLUtils.GLUIMouseEvent_linesPerAction_get
    if _newclass:linesPerAction = _swig_property(_GLUtils.GLUIMouseEvent_linesPerAction_get, _GLUtils.GLUIMouseEvent_linesPerAction_set)
    __swig_setmethods__["dragging"] = _GLUtils.GLUIMouseEvent_dragging_set
    __swig_getmethods__["dragging"] = _GLUtils.GLUIMouseEvent_dragging_get
    if _newclass:dragging = _swig_property(_GLUtils.GLUIMouseEvent_dragging_get, _GLUtils.GLUIMouseEvent_dragging_set)
    __swig_setmethods__["moving"] = _GLUtils.GLUIMouseEvent_moving_set
    __swig_getmethods__["moving"] = _GLUtils.GLUIMouseEvent_moving_get
    if _newclass:moving = _swig_property(_GLUtils.GLUIMouseEvent_moving_get, _GLUtils.GLUIMouseEvent_moving_set)
    __swig_setmethods__["skip"] = _GLUtils.GLUIMouseEvent_skip_set
    __swig_getmethods__["skip"] = _GLUtils.GLUIMouseEvent_skip_get
    if _newclass:skip = _swig_property(_GLUtils.GLUIMouseEvent_skip_get, _GLUtils.GLUIMouseEvent_skip_set)
    def __init__(self): 
        this = _GLUtils.new_GLUIMouseEvent()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLUIMouseEvent
    __del__ = lambda self : None;
GLUIMouseEvent_swigregister = _GLUtils.GLUIMouseEvent_swigregister
GLUIMouseEvent_swigregister(GLUIMouseEvent)

class GLUIWindow(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUIWindow, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUIWindow, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        if self.__class__ == GLUIWindow:
            _self = None
        else:
            _self = self
        this = _GLUtils.new_GLUIWindow(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLUIWindow
    __del__ = lambda self : None;
    def setSizer(self, *args): return _GLUtils.GLUIWindow_setSizer(self, *args)
    def getSizer(self): return _GLUtils.GLUIWindow_getSizer(self)
    def getParent(self): return _GLUtils.GLUIWindow_getParent(self)
    def refresh(self): return _GLUtils.GLUIWindow_refresh(self)
    def setPosition(self, *args): return _GLUtils.GLUIWindow_setPosition(self, *args)
    def setSize(self, *args): return _GLUtils.GLUIWindow_setSize(self, *args)
    def setDimension(self, *args): return _GLUtils.GLUIWindow_setDimension(self, *args)
    def getPosition(self): return _GLUtils.GLUIWindow_getPosition(self)
    def getSize(self): return _GLUtils.GLUIWindow_getSize(self)
    def setMinSize(self, *args): return _GLUtils.GLUIWindow_setMinSize(self, *args)
    def getMinSize(self): return _GLUtils.GLUIWindow_getMinSize(self)
    def layout(self): return _GLUtils.GLUIWindow_layout(self)
    def isVisible(self): return _GLUtils.GLUIWindow_isVisible(self)
    def setVisible(self, visible = True): return _GLUtils.GLUIWindow_setVisible(self, visible)
    def pointInside(self, *args): return _GLUtils.GLUIWindow_pointInside(self, *args)
    def captureMouse(self, window = None): return _GLUtils.GLUIWindow_captureMouse(self, window)
    def releaseMouse(self, window = None): return _GLUtils.GLUIWindow_releaseMouse(self, window)
    def hasCapture(self, window = None): return _GLUtils.GLUIWindow_hasCapture(self, window)
    def onLeftDown(self, *args): return _GLUtils.GLUIWindow_onLeftDown(self, *args)
    def onLeftUp(self, *args): return _GLUtils.GLUIWindow_onLeftUp(self, *args)
    def onLeftDClick(self, *args): return _GLUtils.GLUIWindow_onLeftDClick(self, *args)
    def onMiddleDown(self, *args): return _GLUtils.GLUIWindow_onMiddleDown(self, *args)
    def onMiddleUp(self, *args): return _GLUtils.GLUIWindow_onMiddleUp(self, *args)
    def onMiddleDClick(self, *args): return _GLUtils.GLUIWindow_onMiddleDClick(self, *args)
    def onRightDown(self, *args): return _GLUtils.GLUIWindow_onRightDown(self, *args)
    def onRightUp(self, *args): return _GLUtils.GLUIWindow_onRightUp(self, *args)
    def onRightDClick(self, *args): return _GLUtils.GLUIWindow_onRightDClick(self, *args)
    def onMotion(self, *args): return _GLUtils.GLUIWindow_onMotion(self, *args)
    def onMouseWheel(self, *args): return _GLUtils.GLUIWindow_onMouseWheel(self, *args)
    def draw(self): return _GLUtils.GLUIWindow_draw(self)
    def __disown__(self):
        self.this.disown()
        _GLUtils.disown_GLUIWindow(self)
        return weakref_proxy(self)
GLUIWindow_swigregister = _GLUtils.GLUIWindow_swigregister
GLUIWindow_swigregister(GLUIWindow)

class GLUIContainer(GLUIWindow):
    __swig_setmethods__ = {}
    for _s in [GLUIWindow]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUIContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [GLUIWindow]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GLUIContainer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        if self.__class__ == GLUIContainer:
            _self = None
        else:
            _self = self
        this = _GLUtils.new_GLUIContainer(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLUIContainer
    __del__ = lambda self : None;
    def refresh(self): return _GLUtils.GLUIContainer_refresh(self)
    def detachAllChildren(self): return _GLUtils.GLUIContainer_detachAllChildren(self)
    def detachChild(self, *args): return _GLUtils.GLUIContainer_detachChild(self, *args)
    def __disown__(self):
        self.this.disown()
        _GLUtils.disown_GLUIContainer(self)
        return weakref_proxy(self)
GLUIContainer_swigregister = _GLUtils.GLUIContainer_swigregister
GLUIContainer_swigregister(GLUIContainer)

class GLUITopLevelWindow(GLUIContainer):
    __swig_setmethods__ = {}
    for _s in [GLUIContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUITopLevelWindow, name, value)
    __swig_getmethods__ = {}
    for _s in [GLUIContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GLUITopLevelWindow, name)
    __repr__ = _swig_repr
    def __init__(self, width = 0, height = 0): 
        if self.__class__ == GLUITopLevelWindow:
            _self = None
        else:
            _self = self
        this = _GLUtils.new_GLUITopLevelWindow(_self, width, height)
        try: self.this.append(this)
        except: self.this = this
    def captureMouse(self, window = None): return _GLUtils.GLUITopLevelWindow_captureMouse(self, window)
    def releaseMouse(self, window = None): return _GLUtils.GLUITopLevelWindow_releaseMouse(self, window)
    def mouseIsCaptured(self): return _GLUtils.GLUITopLevelWindow_mouseIsCaptured(self)
    def hasCapture(self, window = None): return _GLUtils.GLUITopLevelWindow_hasCapture(self, window)
    def startMouseCapture(self): return _GLUtils.GLUITopLevelWindow_startMouseCapture(self)
    def stopMouseCapture(self): return _GLUtils.GLUITopLevelWindow_stopMouseCapture(self)
    __swig_destroy__ = _GLUtils.delete_GLUITopLevelWindow
    __del__ = lambda self : None;
    def __disown__(self):
        self.this.disown()
        _GLUtils.disown_GLUITopLevelWindow(self)
        return weakref_proxy(self)
GLUITopLevelWindow_swigregister = _GLUtils.GLUITopLevelWindow_swigregister
GLUITopLevelWindow_swigregister(GLUITopLevelWindow)

class GLUICurveEditor(GLUIWindow):
    __swig_setmethods__ = {}
    for _s in [GLUIWindow]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUICurveEditor, name, value)
    __swig_getmethods__ = {}
    for _s in [GLUIWindow]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GLUICurveEditor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _GLUtils.new_GLUICurveEditor(*args)
        try: self.this.append(this)
        except: self.this = this
    def setTitle(self, *args): return _GLUtils.GLUICurveEditor_setTitle(self, *args)
    def setTrajectory(self, *args): return _GLUtils.GLUICurveEditor_setTrajectory(self, *args)
    def getTrajectory(self): return _GLUtils.GLUICurveEditor_getTrajectory(self)
    def setCurrTime(self, *args): return _GLUtils.GLUICurveEditor_setCurrTime(self, *args)
    def getCurrTime(self): return _GLUtils.GLUICurveEditor_getCurrTime(self)
    def draw(self): return _GLUtils.GLUICurveEditor_draw(self)
    def onLeftDown(self, *args): return _GLUtils.GLUICurveEditor_onLeftDown(self, *args)
    def onRightDown(self, *args): return _GLUtils.GLUICurveEditor_onRightDown(self, *args)
    def onLeftUp(self, *args): return _GLUtils.GLUICurveEditor_onLeftUp(self, *args)
    def onRightUp(self, *args): return _GLUtils.GLUICurveEditor_onRightUp(self, *args)
    def onMotion(self, *args): return _GLUtils.GLUICurveEditor_onMotion(self, *args)
    __swig_destroy__ = _GLUtils.delete_GLUICurveEditor
    __del__ = lambda self : None;
GLUICurveEditor_swigregister = _GLUtils.GLUICurveEditor_swigregister
GLUICurveEditor_swigregister(GLUICurveEditor)

class GLUICheckBox(GLUIWindow):
    __swig_setmethods__ = {}
    for _s in [GLUIWindow]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUICheckBox, name, value)
    __swig_getmethods__ = {}
    for _s in [GLUIWindow]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GLUICheckBox, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _GLUtils.new_GLUICheckBox(*args)
        try: self.this.append(this)
        except: self.this = this
    def draw(self): return _GLUtils.GLUICheckBox_draw(self)
    def onLeftDown(self, *args): return _GLUtils.GLUICheckBox_onLeftDown(self, *args)
    def setChecked(self, *args): return _GLUtils.GLUICheckBox_setChecked(self, *args)
    def isChecked(self): return _GLUtils.GLUICheckBox_isChecked(self)
    def setCheckBoxCallback(self, *args): return _GLUtils.GLUICheckBox_setCheckBoxCallback(self, *args)
    __swig_destroy__ = _GLUtils.delete_GLUICheckBox
    __del__ = lambda self : None;
GLUICheckBox_swigregister = _GLUtils.GLUICheckBox_swigregister
GLUICheckBox_swigregister(GLUICheckBox)

class GLUISizedWindow(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUISizedWindow, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUISizedWindow, name)
    __repr__ = _swig_repr
    __swig_setmethods__["window"] = _GLUtils.GLUISizedWindow_window_set
    __swig_getmethods__["window"] = _GLUtils.GLUISizedWindow_window_get
    if _newclass:window = _swig_property(_GLUtils.GLUISizedWindow_window_get, _GLUtils.GLUISizedWindow_window_set)
    __swig_setmethods__["sizer"] = _GLUtils.GLUISizedWindow_sizer_set
    __swig_getmethods__["sizer"] = _GLUtils.GLUISizedWindow_sizer_get
    if _newclass:sizer = _swig_property(_GLUtils.GLUISizedWindow_sizer_get, _GLUtils.GLUISizedWindow_sizer_set)
    __swig_setmethods__["size"] = _GLUtils.GLUISizedWindow_size_set
    __swig_getmethods__["size"] = _GLUtils.GLUISizedWindow_size_get
    if _newclass:size = _swig_property(_GLUtils.GLUISizedWindow_size_get, _GLUtils.GLUISizedWindow_size_set)
    __swig_setmethods__["proportion"] = _GLUtils.GLUISizedWindow_proportion_set
    __swig_getmethods__["proportion"] = _GLUtils.GLUISizedWindow_proportion_get
    if _newclass:proportion = _swig_property(_GLUtils.GLUISizedWindow_proportion_get, _GLUtils.GLUISizedWindow_proportion_set)
    __swig_setmethods__["flag"] = _GLUtils.GLUISizedWindow_flag_set
    __swig_getmethods__["flag"] = _GLUtils.GLUISizedWindow_flag_get
    if _newclass:flag = _swig_property(_GLUtils.GLUISizedWindow_flag_get, _GLUtils.GLUISizedWindow_flag_set)
    def __init__(self, *args): 
        this = _GLUtils.new_GLUISizedWindow(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLUISizedWindow
    __del__ = lambda self : None;
GLUISizedWindow_swigregister = _GLUtils.GLUISizedWindow_swigregister
GLUISizedWindow_swigregister(GLUISizedWindow)

class GLUISizer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUISizer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUISizer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _GLUtils.delete_GLUISizer
    __del__ = lambda self : None;
    def add(self, *args): return _GLUtils.GLUISizer_add(self, *args)
    def addSizer(self, *args): return _GLUtils.GLUISizer_addSizer(self, *args)
    def addSpacer(self, *args): return _GLUtils.GLUISizer_addSpacer(self, *args)
    def addStretchSpacer(self, *args): return _GLUtils.GLUISizer_addStretchSpacer(self, *args)
    def insert(self, *args): return _GLUtils.GLUISizer_insert(self, *args)
    def insertSizer(self, *args): return _GLUtils.GLUISizer_insertSizer(self, *args)
    def insertSpacer(self, *args): return _GLUtils.GLUISizer_insertSpacer(self, *args)
    def insertStretchSpacer(self, *args): return _GLUtils.GLUISizer_insertStretchSpacer(self, *args)
    def detach(self, *args): return _GLUtils.GLUISizer_detach(self, *args)
    def detachSizer(self, *args): return _GLUtils.GLUISizer_detachSizer(self, *args)
    def setDimension(self, *args): return _GLUtils.GLUISizer_setDimension(self, *args)
    def calcMinSize(self, totalProportionOut = None, leftOverSpaceOut = None): return _GLUtils.GLUISizer_calcMinSize(self, totalProportionOut, leftOverSpaceOut)
    def layout(self): return _GLUtils.GLUISizer_layout(self)
GLUISizer_swigregister = _GLUtils.GLUISizer_swigregister
GLUISizer_swigregister(GLUISizer)

class GLUIBoxSizer(GLUISizer):
    __swig_setmethods__ = {}
    for _s in [GLUISizer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUIBoxSizer, name, value)
    __swig_getmethods__ = {}
    for _s in [GLUISizer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GLUIBoxSizer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _GLUtils.new_GLUIBoxSizer(*args)
        try: self.this.append(this)
        except: self.this = this
    def calcMinSize(self, totalProportionOut = None, leftOverSpaceOut = None): return _GLUtils.GLUIBoxSizer_calcMinSize(self, totalProportionOut, leftOverSpaceOut)
    def layout(self): return _GLUtils.GLUIBoxSizer_layout(self)
    __swig_destroy__ = _GLUtils.delete_GLUIBoxSizer
    __del__ = lambda self : None;
GLUIBoxSizer_swigregister = _GLUtils.GLUIBoxSizer_swigregister
GLUIBoxSizer_swigregister(GLUIBoxSizer)

class GLUICallback(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLUICallback, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLUICallback, name)
    __repr__ = _swig_repr
    def __init__(self): 
        if self.__class__ == GLUICallback:
            _self = None
        else:
            _self = self
        this = _GLUtils.new_GLUICallback(_self, )
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _GLUtils.delete_GLUICallback
    __del__ = lambda self : None;
    def execute(self): return _GLUtils.GLUICallback_execute(self)
    def __disown__(self):
        self.this.disown()
        _GLUtils.disown_GLUICallback(self)
        return weakref_proxy(self)
GLUICallback_swigregister = _GLUtils.GLUICallback_swigregister
GLUICallback_swigregister(GLUICallback)



