# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _amanith
import new
new_instancemethod = new.instancemethod
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__ == 'PySwigObject':
            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,)

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


class PySwigIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PySwigIterator, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_PySwigIterator
    __del__ = lambda self : None;
    def value(*args): return _amanith.PySwigIterator_value(*args)
    def incr(*args): return _amanith.PySwigIterator_incr(*args)
    def decr(*args): return _amanith.PySwigIterator_decr(*args)
    def distance(*args): return _amanith.PySwigIterator_distance(*args)
    def equal(*args): return _amanith.PySwigIterator_equal(*args)
    def copy(*args): return _amanith.PySwigIterator_copy(*args)
    def next(*args): return _amanith.PySwigIterator_next(*args)
    def previous(*args): return _amanith.PySwigIterator_previous(*args)
    def advance(*args): return _amanith.PySwigIterator_advance(*args)
    def __eq__(*args): return _amanith.PySwigIterator___eq__(*args)
    def __ne__(*args): return _amanith.PySwigIterator___ne__(*args)
    def __iadd__(*args): return _amanith.PySwigIterator___iadd__(*args)
    def __isub__(*args): return _amanith.PySwigIterator___isub__(*args)
    def __add__(*args): return _amanith.PySwigIterator___add__(*args)
    def __sub__(*args): return _amanith.PySwigIterator___sub__(*args)
    def __iter__(self): return self
PySwigIterator_swigregister = _amanith.PySwigIterator_swigregister
PySwigIterator_swigregister(PySwigIterator)

class CoordVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoordVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CoordVector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.CoordVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.CoordVector___nonzero__(*args)
    def __len__(*args): return _amanith.CoordVector___len__(*args)
    def pop(*args): return _amanith.CoordVector_pop(*args)
    def __getslice__(*args): return _amanith.CoordVector___getslice__(*args)
    def __setslice__(*args): return _amanith.CoordVector___setslice__(*args)
    def __delslice__(*args): return _amanith.CoordVector___delslice__(*args)
    def __delitem__(*args): return _amanith.CoordVector___delitem__(*args)
    def __getitem__(*args): return _amanith.CoordVector___getitem__(*args)
    def __setitem__(*args): return _amanith.CoordVector___setitem__(*args)
    def append(*args): return _amanith.CoordVector_append(*args)
    def empty(*args): return _amanith.CoordVector_empty(*args)
    def size(*args): return _amanith.CoordVector_size(*args)
    def clear(*args): return _amanith.CoordVector_clear(*args)
    def swap(*args): return _amanith.CoordVector_swap(*args)
    def get_allocator(*args): return _amanith.CoordVector_get_allocator(*args)
    def begin(*args): return _amanith.CoordVector_begin(*args)
    def end(*args): return _amanith.CoordVector_end(*args)
    def rbegin(*args): return _amanith.CoordVector_rbegin(*args)
    def rend(*args): return _amanith.CoordVector_rend(*args)
    def pop_back(*args): return _amanith.CoordVector_pop_back(*args)
    def erase(*args): return _amanith.CoordVector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_CoordVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.CoordVector_push_back(*args)
    def front(*args): return _amanith.CoordVector_front(*args)
    def back(*args): return _amanith.CoordVector_back(*args)
    def assign(*args): return _amanith.CoordVector_assign(*args)
    def resize(*args): return _amanith.CoordVector_resize(*args)
    def insert(*args): return _amanith.CoordVector_insert(*args)
    def reserve(*args): return _amanith.CoordVector_reserve(*args)
    def capacity(*args): return _amanith.CoordVector_capacity(*args)
    __swig_destroy__ = _amanith.delete_CoordVector
    __del__ = lambda self : None;
CoordVector_swigregister = _amanith.CoordVector_swigregister
CoordVector_swigregister(CoordVector)

class GPoint2Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPoint2Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPoint2Vector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GPoint2Vector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GPoint2Vector___nonzero__(*args)
    def __len__(*args): return _amanith.GPoint2Vector___len__(*args)
    def pop(*args): return _amanith.GPoint2Vector_pop(*args)
    def __getslice__(*args): return _amanith.GPoint2Vector___getslice__(*args)
    def __setslice__(*args): return _amanith.GPoint2Vector___setslice__(*args)
    def __delslice__(*args): return _amanith.GPoint2Vector___delslice__(*args)
    def __delitem__(*args): return _amanith.GPoint2Vector___delitem__(*args)
    def __getitem__(*args): return _amanith.GPoint2Vector___getitem__(*args)
    def __setitem__(*args): return _amanith.GPoint2Vector___setitem__(*args)
    def append(*args): return _amanith.GPoint2Vector_append(*args)
    def empty(*args): return _amanith.GPoint2Vector_empty(*args)
    def size(*args): return _amanith.GPoint2Vector_size(*args)
    def clear(*args): return _amanith.GPoint2Vector_clear(*args)
    def swap(*args): return _amanith.GPoint2Vector_swap(*args)
    def get_allocator(*args): return _amanith.GPoint2Vector_get_allocator(*args)
    def begin(*args): return _amanith.GPoint2Vector_begin(*args)
    def end(*args): return _amanith.GPoint2Vector_end(*args)
    def rbegin(*args): return _amanith.GPoint2Vector_rbegin(*args)
    def rend(*args): return _amanith.GPoint2Vector_rend(*args)
    def pop_back(*args): return _amanith.GPoint2Vector_pop_back(*args)
    def erase(*args): return _amanith.GPoint2Vector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPoint2Vector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GPoint2Vector_push_back(*args)
    def front(*args): return _amanith.GPoint2Vector_front(*args)
    def back(*args): return _amanith.GPoint2Vector_back(*args)
    def assign(*args): return _amanith.GPoint2Vector_assign(*args)
    def resize(*args): return _amanith.GPoint2Vector_resize(*args)
    def insert(*args): return _amanith.GPoint2Vector_insert(*args)
    def reserve(*args): return _amanith.GPoint2Vector_reserve(*args)
    def capacity(*args): return _amanith.GPoint2Vector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GPoint2Vector
    __del__ = lambda self : None;
GPoint2Vector_swigregister = _amanith.GPoint2Vector_swigregister
GPoint2Vector_swigregister(GPoint2Vector)

class GPoint3Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPoint3Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPoint3Vector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GPoint3Vector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GPoint3Vector___nonzero__(*args)
    def __len__(*args): return _amanith.GPoint3Vector___len__(*args)
    def pop(*args): return _amanith.GPoint3Vector_pop(*args)
    def __getslice__(*args): return _amanith.GPoint3Vector___getslice__(*args)
    def __setslice__(*args): return _amanith.GPoint3Vector___setslice__(*args)
    def __delslice__(*args): return _amanith.GPoint3Vector___delslice__(*args)
    def __delitem__(*args): return _amanith.GPoint3Vector___delitem__(*args)
    def __getitem__(*args): return _amanith.GPoint3Vector___getitem__(*args)
    def __setitem__(*args): return _amanith.GPoint3Vector___setitem__(*args)
    def append(*args): return _amanith.GPoint3Vector_append(*args)
    def empty(*args): return _amanith.GPoint3Vector_empty(*args)
    def size(*args): return _amanith.GPoint3Vector_size(*args)
    def clear(*args): return _amanith.GPoint3Vector_clear(*args)
    def swap(*args): return _amanith.GPoint3Vector_swap(*args)
    def get_allocator(*args): return _amanith.GPoint3Vector_get_allocator(*args)
    def begin(*args): return _amanith.GPoint3Vector_begin(*args)
    def end(*args): return _amanith.GPoint3Vector_end(*args)
    def rbegin(*args): return _amanith.GPoint3Vector_rbegin(*args)
    def rend(*args): return _amanith.GPoint3Vector_rend(*args)
    def pop_back(*args): return _amanith.GPoint3Vector_pop_back(*args)
    def erase(*args): return _amanith.GPoint3Vector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPoint3Vector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GPoint3Vector_push_back(*args)
    def front(*args): return _amanith.GPoint3Vector_front(*args)
    def back(*args): return _amanith.GPoint3Vector_back(*args)
    def assign(*args): return _amanith.GPoint3Vector_assign(*args)
    def resize(*args): return _amanith.GPoint3Vector_resize(*args)
    def insert(*args): return _amanith.GPoint3Vector_insert(*args)
    def reserve(*args): return _amanith.GPoint3Vector_reserve(*args)
    def capacity(*args): return _amanith.GPoint3Vector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GPoint3Vector
    __del__ = lambda self : None;
GPoint3Vector_swigregister = _amanith.GPoint3Vector_swigregister
GPoint3Vector_swigregister(GPoint3Vector)

class GPoint4Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPoint4Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPoint4Vector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GPoint4Vector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GPoint4Vector___nonzero__(*args)
    def __len__(*args): return _amanith.GPoint4Vector___len__(*args)
    def pop(*args): return _amanith.GPoint4Vector_pop(*args)
    def __getslice__(*args): return _amanith.GPoint4Vector___getslice__(*args)
    def __setslice__(*args): return _amanith.GPoint4Vector___setslice__(*args)
    def __delslice__(*args): return _amanith.GPoint4Vector___delslice__(*args)
    def __delitem__(*args): return _amanith.GPoint4Vector___delitem__(*args)
    def __getitem__(*args): return _amanith.GPoint4Vector___getitem__(*args)
    def __setitem__(*args): return _amanith.GPoint4Vector___setitem__(*args)
    def append(*args): return _amanith.GPoint4Vector_append(*args)
    def empty(*args): return _amanith.GPoint4Vector_empty(*args)
    def size(*args): return _amanith.GPoint4Vector_size(*args)
    def clear(*args): return _amanith.GPoint4Vector_clear(*args)
    def swap(*args): return _amanith.GPoint4Vector_swap(*args)
    def get_allocator(*args): return _amanith.GPoint4Vector_get_allocator(*args)
    def begin(*args): return _amanith.GPoint4Vector_begin(*args)
    def end(*args): return _amanith.GPoint4Vector_end(*args)
    def rbegin(*args): return _amanith.GPoint4Vector_rbegin(*args)
    def rend(*args): return _amanith.GPoint4Vector_rend(*args)
    def pop_back(*args): return _amanith.GPoint4Vector_pop_back(*args)
    def erase(*args): return _amanith.GPoint4Vector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPoint4Vector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GPoint4Vector_push_back(*args)
    def front(*args): return _amanith.GPoint4Vector_front(*args)
    def back(*args): return _amanith.GPoint4Vector_back(*args)
    def assign(*args): return _amanith.GPoint4Vector_assign(*args)
    def resize(*args): return _amanith.GPoint4Vector_resize(*args)
    def insert(*args): return _amanith.GPoint4Vector_insert(*args)
    def reserve(*args): return _amanith.GPoint4Vector_reserve(*args)
    def capacity(*args): return _amanith.GPoint4Vector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GPoint4Vector
    __del__ = lambda self : None;
GPoint4Vector_swigregister = _amanith.GPoint4Vector_swigregister
GPoint4Vector_swigregister(GPoint4Vector)

class GKeyValueVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKeyValueVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GKeyValueVector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GKeyValueVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GKeyValueVector___nonzero__(*args)
    def __len__(*args): return _amanith.GKeyValueVector___len__(*args)
    def pop(*args): return _amanith.GKeyValueVector_pop(*args)
    def __getslice__(*args): return _amanith.GKeyValueVector___getslice__(*args)
    def __setslice__(*args): return _amanith.GKeyValueVector___setslice__(*args)
    def __delslice__(*args): return _amanith.GKeyValueVector___delslice__(*args)
    def __delitem__(*args): return _amanith.GKeyValueVector___delitem__(*args)
    def __getitem__(*args): return _amanith.GKeyValueVector___getitem__(*args)
    def __setitem__(*args): return _amanith.GKeyValueVector___setitem__(*args)
    def append(*args): return _amanith.GKeyValueVector_append(*args)
    def empty(*args): return _amanith.GKeyValueVector_empty(*args)
    def size(*args): return _amanith.GKeyValueVector_size(*args)
    def clear(*args): return _amanith.GKeyValueVector_clear(*args)
    def swap(*args): return _amanith.GKeyValueVector_swap(*args)
    def get_allocator(*args): return _amanith.GKeyValueVector_get_allocator(*args)
    def begin(*args): return _amanith.GKeyValueVector_begin(*args)
    def end(*args): return _amanith.GKeyValueVector_end(*args)
    def rbegin(*args): return _amanith.GKeyValueVector_rbegin(*args)
    def rend(*args): return _amanith.GKeyValueVector_rend(*args)
    def pop_back(*args): return _amanith.GKeyValueVector_pop_back(*args)
    def erase(*args): return _amanith.GKeyValueVector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GKeyValueVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GKeyValueVector_push_back(*args)
    def front(*args): return _amanith.GKeyValueVector_front(*args)
    def back(*args): return _amanith.GKeyValueVector_back(*args)
    def assign(*args): return _amanith.GKeyValueVector_assign(*args)
    def resize(*args): return _amanith.GKeyValueVector_resize(*args)
    def insert(*args): return _amanith.GKeyValueVector_insert(*args)
    def reserve(*args): return _amanith.GKeyValueVector_reserve(*args)
    def capacity(*args): return _amanith.GKeyValueVector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GKeyValueVector
    __del__ = lambda self : None;
GKeyValueVector_swigregister = _amanith.GKeyValueVector_swigregister
GKeyValueVector_swigregister(GKeyValueVector)

class GImpExpFeatureVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GImpExpFeatureVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GImpExpFeatureVector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GImpExpFeatureVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GImpExpFeatureVector___nonzero__(*args)
    def __len__(*args): return _amanith.GImpExpFeatureVector___len__(*args)
    def pop(*args): return _amanith.GImpExpFeatureVector_pop(*args)
    def __getslice__(*args): return _amanith.GImpExpFeatureVector___getslice__(*args)
    def __setslice__(*args): return _amanith.GImpExpFeatureVector___setslice__(*args)
    def __delslice__(*args): return _amanith.GImpExpFeatureVector___delslice__(*args)
    def __delitem__(*args): return _amanith.GImpExpFeatureVector___delitem__(*args)
    def __getitem__(*args): return _amanith.GImpExpFeatureVector___getitem__(*args)
    def __setitem__(*args): return _amanith.GImpExpFeatureVector___setitem__(*args)
    def append(*args): return _amanith.GImpExpFeatureVector_append(*args)
    def empty(*args): return _amanith.GImpExpFeatureVector_empty(*args)
    def size(*args): return _amanith.GImpExpFeatureVector_size(*args)
    def clear(*args): return _amanith.GImpExpFeatureVector_clear(*args)
    def swap(*args): return _amanith.GImpExpFeatureVector_swap(*args)
    def get_allocator(*args): return _amanith.GImpExpFeatureVector_get_allocator(*args)
    def begin(*args): return _amanith.GImpExpFeatureVector_begin(*args)
    def end(*args): return _amanith.GImpExpFeatureVector_end(*args)
    def rbegin(*args): return _amanith.GImpExpFeatureVector_rbegin(*args)
    def rend(*args): return _amanith.GImpExpFeatureVector_rend(*args)
    def pop_back(*args): return _amanith.GImpExpFeatureVector_pop_back(*args)
    def erase(*args): return _amanith.GImpExpFeatureVector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GImpExpFeatureVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GImpExpFeatureVector_push_back(*args)
    def front(*args): return _amanith.GImpExpFeatureVector_front(*args)
    def back(*args): return _amanith.GImpExpFeatureVector_back(*args)
    def assign(*args): return _amanith.GImpExpFeatureVector_assign(*args)
    def resize(*args): return _amanith.GImpExpFeatureVector_resize(*args)
    def insert(*args): return _amanith.GImpExpFeatureVector_insert(*args)
    def reserve(*args): return _amanith.GImpExpFeatureVector_reserve(*args)
    def capacity(*args): return _amanith.GImpExpFeatureVector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GImpExpFeatureVector
    __del__ = lambda self : None;
GImpExpFeatureVector_swigregister = _amanith.GImpExpFeatureVector_swigregister
GImpExpFeatureVector_swigregister(GImpExpFeatureVector)

class GPropertyVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPropertyVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPropertyVector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GPropertyVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GPropertyVector___nonzero__(*args)
    def __len__(*args): return _amanith.GPropertyVector___len__(*args)
    def pop(*args): return _amanith.GPropertyVector_pop(*args)
    def __getslice__(*args): return _amanith.GPropertyVector___getslice__(*args)
    def __setslice__(*args): return _amanith.GPropertyVector___setslice__(*args)
    def __delslice__(*args): return _amanith.GPropertyVector___delslice__(*args)
    def __delitem__(*args): return _amanith.GPropertyVector___delitem__(*args)
    def __getitem__(*args): return _amanith.GPropertyVector___getitem__(*args)
    def __setitem__(*args): return _amanith.GPropertyVector___setitem__(*args)
    def append(*args): return _amanith.GPropertyVector_append(*args)
    def empty(*args): return _amanith.GPropertyVector_empty(*args)
    def size(*args): return _amanith.GPropertyVector_size(*args)
    def clear(*args): return _amanith.GPropertyVector_clear(*args)
    def swap(*args): return _amanith.GPropertyVector_swap(*args)
    def get_allocator(*args): return _amanith.GPropertyVector_get_allocator(*args)
    def begin(*args): return _amanith.GPropertyVector_begin(*args)
    def end(*args): return _amanith.GPropertyVector_end(*args)
    def rbegin(*args): return _amanith.GPropertyVector_rbegin(*args)
    def rend(*args): return _amanith.GPropertyVector_rend(*args)
    def pop_back(*args): return _amanith.GPropertyVector_pop_back(*args)
    def erase(*args): return _amanith.GPropertyVector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPropertyVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GPropertyVector_push_back(*args)
    def front(*args): return _amanith.GPropertyVector_front(*args)
    def back(*args): return _amanith.GPropertyVector_back(*args)
    def assign(*args): return _amanith.GPropertyVector_assign(*args)
    def resize(*args): return _amanith.GPropertyVector_resize(*args)
    def insert(*args): return _amanith.GPropertyVector_insert(*args)
    def reserve(*args): return _amanith.GPropertyVector_reserve(*args)
    def capacity(*args): return _amanith.GPropertyVector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GPropertyVector
    __del__ = lambda self : None;
GPropertyVector_swigregister = _amanith.GPropertyVector_swigregister
GPropertyVector_swigregister(GPropertyVector)

class GProxyStateVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GProxyStateVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GProxyStateVector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GProxyStateVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GProxyStateVector___nonzero__(*args)
    def __len__(*args): return _amanith.GProxyStateVector___len__(*args)
    def pop(*args): return _amanith.GProxyStateVector_pop(*args)
    def __getslice__(*args): return _amanith.GProxyStateVector___getslice__(*args)
    def __setslice__(*args): return _amanith.GProxyStateVector___setslice__(*args)
    def __delslice__(*args): return _amanith.GProxyStateVector___delslice__(*args)
    def __delitem__(*args): return _amanith.GProxyStateVector___delitem__(*args)
    def __getitem__(*args): return _amanith.GProxyStateVector___getitem__(*args)
    def __setitem__(*args): return _amanith.GProxyStateVector___setitem__(*args)
    def append(*args): return _amanith.GProxyStateVector_append(*args)
    def empty(*args): return _amanith.GProxyStateVector_empty(*args)
    def size(*args): return _amanith.GProxyStateVector_size(*args)
    def clear(*args): return _amanith.GProxyStateVector_clear(*args)
    def swap(*args): return _amanith.GProxyStateVector_swap(*args)
    def get_allocator(*args): return _amanith.GProxyStateVector_get_allocator(*args)
    def begin(*args): return _amanith.GProxyStateVector_begin(*args)
    def end(*args): return _amanith.GProxyStateVector_end(*args)
    def rbegin(*args): return _amanith.GProxyStateVector_rbegin(*args)
    def rend(*args): return _amanith.GProxyStateVector_rend(*args)
    def pop_back(*args): return _amanith.GProxyStateVector_pop_back(*args)
    def erase(*args): return _amanith.GProxyStateVector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GProxyStateVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GProxyStateVector_push_back(*args)
    def front(*args): return _amanith.GProxyStateVector_front(*args)
    def back(*args): return _amanith.GProxyStateVector_back(*args)
    def assign(*args): return _amanith.GProxyStateVector_assign(*args)
    def resize(*args): return _amanith.GProxyStateVector_resize(*args)
    def insert(*args): return _amanith.GProxyStateVector_insert(*args)
    def reserve(*args): return _amanith.GProxyStateVector_reserve(*args)
    def capacity(*args): return _amanith.GProxyStateVector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GProxyStateVector
    __del__ = lambda self : None;
GProxyStateVector_swigregister = _amanith.GProxyStateVector_swigregister
GProxyStateVector_swigregister(GProxyStateVector)

class GRealVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GRealVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GRealVector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GRealVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GRealVector___nonzero__(*args)
    def __len__(*args): return _amanith.GRealVector___len__(*args)
    def pop(*args): return _amanith.GRealVector_pop(*args)
    def __getslice__(*args): return _amanith.GRealVector___getslice__(*args)
    def __setslice__(*args): return _amanith.GRealVector___setslice__(*args)
    def __delslice__(*args): return _amanith.GRealVector___delslice__(*args)
    def __delitem__(*args): return _amanith.GRealVector___delitem__(*args)
    def __getitem__(*args): return _amanith.GRealVector___getitem__(*args)
    def __setitem__(*args): return _amanith.GRealVector___setitem__(*args)
    def append(*args): return _amanith.GRealVector_append(*args)
    def empty(*args): return _amanith.GRealVector_empty(*args)
    def size(*args): return _amanith.GRealVector_size(*args)
    def clear(*args): return _amanith.GRealVector_clear(*args)
    def swap(*args): return _amanith.GRealVector_swap(*args)
    def get_allocator(*args): return _amanith.GRealVector_get_allocator(*args)
    def begin(*args): return _amanith.GRealVector_begin(*args)
    def end(*args): return _amanith.GRealVector_end(*args)
    def rbegin(*args): return _amanith.GRealVector_rbegin(*args)
    def rend(*args): return _amanith.GRealVector_rend(*args)
    def pop_back(*args): return _amanith.GRealVector_pop_back(*args)
    def erase(*args): return _amanith.GRealVector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GRealVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GRealVector_push_back(*args)
    def front(*args): return _amanith.GRealVector_front(*args)
    def back(*args): return _amanith.GRealVector_back(*args)
    def assign(*args): return _amanith.GRealVector_assign(*args)
    def resize(*args): return _amanith.GRealVector_resize(*args)
    def insert(*args): return _amanith.GRealVector_insert(*args)
    def reserve(*args): return _amanith.GRealVector_reserve(*args)
    def capacity(*args): return _amanith.GRealVector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GRealVector
    __del__ = lambda self : None;
GRealVector_swigregister = _amanith.GRealVector_swigregister
GRealVector_swigregister(GRealVector)

class GHermiteKey1DVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteKey1DVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteKey1DVector, name)
    __repr__ = _swig_repr
    def iterator(*args): return _amanith.GHermiteKey1DVector_iterator(*args)
    def __iter__(self): return self.iterator()
    def __nonzero__(*args): return _amanith.GHermiteKey1DVector___nonzero__(*args)
    def __len__(*args): return _amanith.GHermiteKey1DVector___len__(*args)
    def pop(*args): return _amanith.GHermiteKey1DVector_pop(*args)
    def __getslice__(*args): return _amanith.GHermiteKey1DVector___getslice__(*args)
    def __setslice__(*args): return _amanith.GHermiteKey1DVector___setslice__(*args)
    def __delslice__(*args): return _amanith.GHermiteKey1DVector___delslice__(*args)
    def __delitem__(*args): return _amanith.GHermiteKey1DVector___delitem__(*args)
    def __getitem__(*args): return _amanith.GHermiteKey1DVector___getitem__(*args)
    def __setitem__(*args): return _amanith.GHermiteKey1DVector___setitem__(*args)
    def append(*args): return _amanith.GHermiteKey1DVector_append(*args)
    def empty(*args): return _amanith.GHermiteKey1DVector_empty(*args)
    def size(*args): return _amanith.GHermiteKey1DVector_size(*args)
    def clear(*args): return _amanith.GHermiteKey1DVector_clear(*args)
    def swap(*args): return _amanith.GHermiteKey1DVector_swap(*args)
    def get_allocator(*args): return _amanith.GHermiteKey1DVector_get_allocator(*args)
    def begin(*args): return _amanith.GHermiteKey1DVector_begin(*args)
    def end(*args): return _amanith.GHermiteKey1DVector_end(*args)
    def rbegin(*args): return _amanith.GHermiteKey1DVector_rbegin(*args)
    def rend(*args): return _amanith.GHermiteKey1DVector_rend(*args)
    def pop_back(*args): return _amanith.GHermiteKey1DVector_pop_back(*args)
    def erase(*args): return _amanith.GHermiteKey1DVector_erase(*args)
    def __init__(self, *args): 
        this = _amanith.new_GHermiteKey1DVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(*args): return _amanith.GHermiteKey1DVector_push_back(*args)
    def front(*args): return _amanith.GHermiteKey1DVector_front(*args)
    def back(*args): return _amanith.GHermiteKey1DVector_back(*args)
    def assign(*args): return _amanith.GHermiteKey1DVector_assign(*args)
    def resize(*args): return _amanith.GHermiteKey1DVector_resize(*args)
    def insert(*args): return _amanith.GHermiteKey1DVector_insert(*args)
    def reserve(*args): return _amanith.GHermiteKey1DVector_reserve(*args)
    def capacity(*args): return _amanith.GHermiteKey1DVector_capacity(*args)
    __swig_destroy__ = _amanith.delete_GHermiteKey1DVector
    __del__ = lambda self : None;
GHermiteKey1DVector_swigregister = _amanith.GHermiteKey1DVector_swigregister
GHermiteKey1DVector_swigregister(GHermiteKey1DVector)

G_AMANITH_VERSION = _amanith.G_AMANITH_VERSION
G_VERSION_STR = _amanith.G_VERSION_STR
G_LANG_EN = _amanith.G_LANG_EN
G_LANG_IT = _amanith.G_LANG_IT
G_LANG_DE = _amanith.G_LANG_DE
G_LANG_FR = _amanith.G_LANG_FR
G_LANG_ES = _amanith.G_LANG_ES
G_LANG_CN = _amanith.G_LANG_CN
G_LANG_JP = _amanith.G_LANG_JP
G_LANG_RU = _amanith.G_LANG_RU
G_LANG_FI = _amanith.G_LANG_FI
G_USED_LANG = _amanith.G_USED_LANG
G_X = _amanith.G_X
G_Y = _amanith.G_Y
G_Z = _amanith.G_Z
G_W = _amanith.G_W
G_XYX = _amanith.G_XYX
G_XYZ = _amanith.G_XYZ
G_XZX = _amanith.G_XZX
G_XZY = _amanith.G_XZY
G_YXY = _amanith.G_YXY
G_YXZ = _amanith.G_YXZ
G_YZX = _amanith.G_YZX
G_YZY = _amanith.G_YZY
G_ZXY = _amanith.G_ZXY
G_ZXZ = _amanith.G_ZXZ
G_ZYX = _amanith.G_ZYX
G_ZYZ = _amanith.G_ZYZ
G_DEGREE_UNIT = _amanith.G_DEGREE_UNIT
G_GRAD_UNIT = _amanith.G_GRAD_UNIT
G_MIL_UNIT = _amanith.G_MIL_UNIT
G_MINUTE_UNIT = _amanith.G_MINUTE_UNIT
G_OCTANT_UNIT = _amanith.G_OCTANT_UNIT
G_QUADRANT_UNIT = _amanith.G_QUADRANT_UNIT
G_RADIAN_UNIT = _amanith.G_RADIAN_UNIT
G_SECOND_UNIT = _amanith.G_SECOND_UNIT
G_SEXTANT_UNIT = _amanith.G_SEXTANT_UNIT
G_SIGN_UNIT = _amanith.G_SIGN_UNIT
G_CIRCLE_UNIT = _amanith.G_CIRCLE_UNIT
G_TURN_UNIT = _amanith.G_TURN_UNIT
G_REVOLUTION_UNIT = _amanith.G_REVOLUTION_UNIT
G_RIGHTANGLE_UNIT = _amanith.G_RIGHTANGLE_UNIT
G_NO_SORT = _amanith.G_NO_SORT
G_ASCENDING_SORT = _amanith.G_ASCENDING_SORT
G_DESCENDING_SORT = _amanith.G_DESCENDING_SORT
G_ONSURFACE = _amanith.G_ONSURFACE
G_INSIDE = _amanith.G_INSIDE
G_OUTSIDE = _amanith.G_OUTSIDE
G_LEFTSIDE = _amanith.G_LEFTSIDE
G_RIGHTSIDE = _amanith.G_RIGHTSIDE
G_TOPSIDE = _amanith.G_TOPSIDE
G_BOTTOMSIDE = _amanith.G_BOTTOMSIDE
G_FRONTSIDE = _amanith.G_FRONTSIDE
G_BACKSIDE = _amanith.G_BACKSIDE
G_MAX_INT8 = _amanith.G_MAX_INT8
G_MIN_INT8 = _amanith.G_MIN_INT8
G_MAX_INT16 = _amanith.G_MAX_INT16
G_MIN_INT16 = _amanith.G_MIN_INT16
G_MAX_INT32 = _amanith.G_MAX_INT32
G_MIN_INT32 = _amanith.G_MIN_INT32
G_MAX_LONG = _amanith.G_MAX_LONG
G_MIN_LONG = _amanith.G_MIN_LONG
G_MAX_UINT8 = _amanith.G_MAX_UINT8
G_MAX_UINT16 = _amanith.G_MAX_UINT16
G_MAX_FLOAT = _amanith.G_MAX_FLOAT
G_MIN_FLOAT = _amanith.G_MIN_FLOAT
G_MAX_DOUBLE = _amanith.G_MAX_DOUBLE
G_MIN_DOUBLE = _amanith.G_MIN_DOUBLE
G_BIG_ENDIAN = _amanith.G_BIG_ENDIAN
G_LITTLE_ENDIAN = _amanith.G_LITTLE_ENDIAN
class GSystemInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GSystemInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GSystemInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["WordSize"] = _amanith.GSystemInfo_WordSize_set
    __swig_getmethods__["WordSize"] = _amanith.GSystemInfo_WordSize_get
    if _newclass:WordSize = property(_amanith.GSystemInfo_WordSize_get, _amanith.GSystemInfo_WordSize_set)
    __swig_setmethods__["EndianType"] = _amanith.GSystemInfo_EndianType_set
    __swig_getmethods__["EndianType"] = _amanith.GSystemInfo_EndianType_get
    if _newclass:EndianType = property(_amanith.GSystemInfo_EndianType_get, _amanith.GSystemInfo_EndianType_set)
    __swig_setmethods__["TrailerPathDelimiter"] = _amanith.GSystemInfo_TrailerPathDelimiter_set
    __swig_getmethods__["TrailerPathDelimiter"] = _amanith.GSystemInfo_TrailerPathDelimiter_get
    if _newclass:TrailerPathDelimiter = property(_amanith.GSystemInfo_TrailerPathDelimiter_get, _amanith.GSystemInfo_TrailerPathDelimiter_set)
    __swig_setmethods__["DynamicLibExtension"] = _amanith.GSystemInfo_DynamicLibExtension_set
    __swig_getmethods__["DynamicLibExtension"] = _amanith.GSystemInfo_DynamicLibExtension_get
    if _newclass:DynamicLibExtension = property(_amanith.GSystemInfo_DynamicLibExtension_get, _amanith.GSystemInfo_DynamicLibExtension_set)
    __swig_setmethods__["OSMinorVersion"] = _amanith.GSystemInfo_OSMinorVersion_set
    __swig_getmethods__["OSMinorVersion"] = _amanith.GSystemInfo_OSMinorVersion_get
    if _newclass:OSMinorVersion = property(_amanith.GSystemInfo_OSMinorVersion_get, _amanith.GSystemInfo_OSMinorVersion_set)
    __swig_setmethods__["OSMajorVersion"] = _amanith.GSystemInfo_OSMajorVersion_set
    __swig_getmethods__["OSMajorVersion"] = _amanith.GSystemInfo_OSMajorVersion_get
    if _newclass:OSMajorVersion = property(_amanith.GSystemInfo_OSMajorVersion_get, _amanith.GSystemInfo_OSMajorVersion_set)
    __swig_setmethods__["OSBuildNumber"] = _amanith.GSystemInfo_OSBuildNumber_set
    __swig_getmethods__["OSBuildNumber"] = _amanith.GSystemInfo_OSBuildNumber_get
    if _newclass:OSBuildNumber = property(_amanith.GSystemInfo_OSBuildNumber_get, _amanith.GSystemInfo_OSBuildNumber_set)
    def __init__(self, *args): 
        this = _amanith.new_GSystemInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GSystemInfo
    __del__ = lambda self : None;
GSystemInfo_swigregister = _amanith.GSystemInfo_swigregister
GSystemInfo_swigregister(GSystemInfo)
cvar = _amanith.cvar
G_EPSILON = cvar.G_EPSILON
G_MAX_REAL = cvar.G_MAX_REAL
G_MIN_REAL = cvar.G_MIN_REAL

class StrUtils(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StrUtils, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StrUtils, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Lower"] = lambda x: _amanith.StrUtils_Lower
    if _newclass:Lower = staticmethod(_amanith.StrUtils_Lower)
    __swig_getmethods__["Upper"] = lambda x: _amanith.StrUtils_Upper
    if _newclass:Upper = staticmethod(_amanith.StrUtils_Upper)
    __swig_getmethods__["Right"] = lambda x: _amanith.StrUtils_Right
    if _newclass:Right = staticmethod(_amanith.StrUtils_Right)
    __swig_getmethods__["Left"] = lambda x: _amanith.StrUtils_Left
    if _newclass:Left = staticmethod(_amanith.StrUtils_Left)
    __swig_getmethods__["Replace"] = lambda x: _amanith.StrUtils_Replace
    if _newclass:Replace = staticmethod(_amanith.StrUtils_Replace)
    __swig_getmethods__["Find"] = lambda x: _amanith.StrUtils_Find
    if _newclass:Find = staticmethod(_amanith.StrUtils_Find)
    __swig_getmethods__["ExtractFilePath"] = lambda x: _amanith.StrUtils_ExtractFilePath
    if _newclass:ExtractFilePath = staticmethod(_amanith.StrUtils_ExtractFilePath)
    __swig_getmethods__["ExtractFileName"] = lambda x: _amanith.StrUtils_ExtractFileName
    if _newclass:ExtractFileName = staticmethod(_amanith.StrUtils_ExtractFileName)
    __swig_getmethods__["ExtractFileExt"] = lambda x: _amanith.StrUtils_ExtractFileExt
    if _newclass:ExtractFileExt = staticmethod(_amanith.StrUtils_ExtractFileExt)
    __swig_getmethods__["OSFixPath"] = lambda x: _amanith.StrUtils_OSFixPath
    if _newclass:OSFixPath = staticmethod(_amanith.StrUtils_OSFixPath)
    __swig_getmethods__["SameText"] = lambda x: _amanith.StrUtils_SameText
    if _newclass:SameText = staticmethod(_amanith.StrUtils_SameText)
    __swig_getmethods__["Purge"] = lambda x: _amanith.StrUtils_Purge
    if _newclass:Purge = staticmethod(_amanith.StrUtils_Purge)
    __swig_getmethods__["ToString"] = lambda x: _amanith.StrUtils_ToString
    if _newclass:ToString = staticmethod(_amanith.StrUtils_ToString)
    __swig_getmethods__["ToAscii"] = lambda x: _amanith.StrUtils_ToAscii
    if _newclass:ToAscii = staticmethod(_amanith.StrUtils_ToAscii)
    __swig_getmethods__["ToInt"] = lambda x: _amanith.StrUtils_ToInt
    if _newclass:ToInt = staticmethod(_amanith.StrUtils_ToInt)
    __swig_getmethods__["ToLong"] = lambda x: _amanith.StrUtils_ToLong
    if _newclass:ToLong = staticmethod(_amanith.StrUtils_ToLong)
    __swig_getmethods__["ToDouble"] = lambda x: _amanith.StrUtils_ToDouble
    if _newclass:ToDouble = staticmethod(_amanith.StrUtils_ToDouble)
    __swig_getmethods__["ToHex"] = lambda x: _amanith.StrUtils_ToHex
    if _newclass:ToHex = staticmethod(_amanith.StrUtils_ToHex)
    __swig_getmethods__["Split"] = lambda x: _amanith.StrUtils_Split
    if _newclass:Split = staticmethod(_amanith.StrUtils_Split)
    __swig_getmethods__["Merge"] = lambda x: _amanith.StrUtils_Merge
    if _newclass:Merge = staticmethod(_amanith.StrUtils_Merge)
    __swig_getmethods__["FromString"] = lambda x: _amanith.StrUtils_FromString
    if _newclass:FromString = staticmethod(_amanith.StrUtils_FromString)
    def __init__(self, *args): 
        this = _amanith.new_StrUtils(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_StrUtils
    __del__ = lambda self : None;
StrUtils_swigregister = _amanith.StrUtils_swigregister
StrUtils_swigregister(StrUtils)
G_NULL_POINT2 = cvar.G_NULL_POINT2
G_NULL_POINT3 = cvar.G_NULL_POINT3
G_NULL_POINT4 = cvar.G_NULL_POINT4
G_MATRIX_IDENTITY22 = cvar.G_MATRIX_IDENTITY22
G_MATRIX_IDENTITY33 = cvar.G_MATRIX_IDENTITY33
G_MATRIX_IDENTITY44 = cvar.G_MATRIX_IDENTITY44
StrUtils_Lower = _amanith.StrUtils_Lower
StrUtils_Upper = _amanith.StrUtils_Upper
StrUtils_Right = _amanith.StrUtils_Right
StrUtils_Left = _amanith.StrUtils_Left
StrUtils_Replace = _amanith.StrUtils_Replace
StrUtils_Find = _amanith.StrUtils_Find
StrUtils_ExtractFilePath = _amanith.StrUtils_ExtractFilePath
StrUtils_ExtractFileName = _amanith.StrUtils_ExtractFileName
StrUtils_ExtractFileExt = _amanith.StrUtils_ExtractFileExt
StrUtils_OSFixPath = _amanith.StrUtils_OSFixPath
StrUtils_SameText = _amanith.StrUtils_SameText
StrUtils_Purge = _amanith.StrUtils_Purge
StrUtils_ToString = _amanith.StrUtils_ToString
StrUtils_ToAscii = _amanith.StrUtils_ToAscii
StrUtils_ToInt = _amanith.StrUtils_ToInt
StrUtils_ToLong = _amanith.StrUtils_ToLong
StrUtils_ToDouble = _amanith.StrUtils_ToDouble
StrUtils_ToHex = _amanith.StrUtils_ToHex
StrUtils_Split = _amanith.StrUtils_Split
StrUtils_Merge = _amanith.StrUtils_Merge
StrUtils_FromString = _amanith.StrUtils_FromString

class FileUtils(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileUtils, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FileUtils, name)
    __repr__ = _swig_repr
    __swig_getmethods__["ReadFile"] = lambda x: _amanith.FileUtils_ReadFile
    if _newclass:ReadFile = staticmethod(_amanith.FileUtils_ReadFile)
    __swig_getmethods__["WriteFile"] = lambda x: _amanith.FileUtils_WriteFile
    if _newclass:WriteFile = staticmethod(_amanith.FileUtils_WriteFile)
    __swig_getmethods__["ScanPath"] = lambda x: _amanith.FileUtils_ScanPath
    if _newclass:ScanPath = staticmethod(_amanith.FileUtils_ScanPath)
    __swig_getmethods__["FileExists"] = lambda x: _amanith.FileUtils_FileExists
    if _newclass:FileExists = staticmethod(_amanith.FileUtils_FileExists)
    def __init__(self, *args): 
        this = _amanith.new_FileUtils(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_FileUtils
    __del__ = lambda self : None;
FileUtils_swigregister = _amanith.FileUtils_swigregister
FileUtils_swigregister(FileUtils)
FileUtils_ReadFile = _amanith.FileUtils_ReadFile
FileUtils_WriteFile = _amanith.FileUtils_WriteFile
FileUtils_ScanPath = _amanith.FileUtils_ScanPath
FileUtils_FileExists = _amanith.FileUtils_FileExists

class GClassID(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GClassID, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GClassID, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GClassID(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GClassID
    __del__ = lambda self : None;
    def CopyFrom(*args): return _amanith.GClassID_CopyFrom(*args)
    def IDName(*args): return _amanith.GClassID_IDName(*args)
    def __eq__(*args): return _amanith.GClassID___eq__(*args)
    def __ne__(*args): return _amanith.GClassID___ne__(*args)
GClassID_swigregister = _amanith.GClassID_swigregister
GClassID_swigregister(GClassID)

class GElement(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GElement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GElement, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GElement(*args)
        try: self.this.append(this)
        except: self.this = this
        if len(args) and isinstance(args[0], GElement): self.thisown = 0

    __swig_destroy__ = _amanith.delete_GElement
    __del__ = lambda self : None;
    def IsOfType(*args): return _amanith.GElement_IsOfType(*args)
    def As(*args): return _amanith.GElement_As(*args)
    def IsTypeOfType(*args): return _amanith.GElement_IsTypeOfType(*args)
    def CopyFrom(*args): return _amanith.GElement_CopyFrom(*args)
    def CopyTo(*args): return _amanith.GElement_CopyTo(*args)
    def Owner(*args): return _amanith.GElement_Owner(*args)
    def ClassID(*args): return _amanith.GElement_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GElement_DerivedClassID(*args)
    def IsRootClass(*args): return _amanith.GElement_IsRootClass(*args)
GElement_swigregister = _amanith.GElement_swigregister
GElement_swigregister(GElement)
G_FOREVER_TIMEINTERVAL = cvar.G_FOREVER_TIMEINTERVAL
G_NEVER_TIMEINTERVAL = cvar.G_NEVER_TIMEINTERVAL
G_ELEMENT_CLASSID = cvar.G_ELEMENT_CLASSID

class GElementProxy(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GElementProxy, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GElementProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GElementProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GElementProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GElementProxy_DerivedClassID(*args)
    def IsRootClass(*args): return _amanith.GElementProxy_IsRootClass(*args)
    def Version(*args): return _amanith.GElementProxy_Version(*args)
    __swig_destroy__ = _amanith.delete_GElementProxy
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _amanith.new_GElementProxy(*args)
        try: self.this.append(this)
        except: self.this = this
GElementProxy_swigregister = _amanith.GElementProxy_swigregister
GElementProxy_swigregister(GElementProxy)

G_UNDEFINED_KEY = _amanith.G_UNDEFINED_KEY
G_BOOL_KEY = _amanith.G_BOOL_KEY
G_INT_KEY = _amanith.G_INT_KEY
G_REAL_KEY = _amanith.G_REAL_KEY
G_VECTOR2_KEY = _amanith.G_VECTOR2_KEY
G_VECTOR3_KEY = _amanith.G_VECTOR3_KEY
G_VECTOR4_KEY = _amanith.G_VECTOR4_KEY
class GKeyValue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKeyValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GKeyValue, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GKeyValue(*args)
        try: self.this.append(this)
        except: self.this = this
    def SetValue(*args): return _amanith.GKeyValue_SetValue(*args)
    def KeyType(*args): return _amanith.GKeyValue_KeyType(*args)
    def SetKeyType(*args): return _amanith.GKeyValue_SetKeyType(*args)
    def TimePosition(*args): return _amanith.GKeyValue_TimePosition(*args)
    def SetTimePosition(*args): return _amanith.GKeyValue_SetTimePosition(*args)
    def BoolValue(*args): return _amanith.GKeyValue_BoolValue(*args)
    def IntValue(*args): return _amanith.GKeyValue_IntValue(*args)
    def RealValue(*args): return _amanith.GKeyValue_RealValue(*args)
    __swig_destroy__ = _amanith.delete_GKeyValue
    __del__ = lambda self : None;
GKeyValue_swigregister = _amanith.GKeyValue_swigregister
GKeyValue_swigregister(GKeyValue)
G_ELEMENT_PROXY = cvar.G_ELEMENT_PROXY

class GAnimElement(GElement):
    __swig_setmethods__ = {}
    for _s in [GElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAnimElement, name, value)
    __swig_getmethods__ = {}
    for _s in [GElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GAnimElement, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GAnimElement(*args)
        try: self.this.append(this)
        except: self.this = this
        if len(args) and isinstance(args[0], GElement): self.thisown = 0

    __swig_destroy__ = _amanith.delete_GAnimElement
    __del__ = lambda self : None;
    def AddProperty(*args): return _amanith.GAnimElement_AddProperty(*args)
    def Property(*args): return _amanith.GAnimElement_Property(*args)
    def RemoveProperty(*args): return _amanith.GAnimElement_RemoveProperty(*args)
    def RemoveProperties(*args): return _amanith.GAnimElement_RemoveProperties(*args)
    def RenameProperty(*args): return _amanith.GAnimElement_RenameProperty(*args)
    def Properties(*args): return _amanith.GAnimElement_Properties(*args)
    def PropertiesCount(*args): return _amanith.GAnimElement_PropertiesCount(*args)
    def ClassID(*args): return _amanith.GAnimElement_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GAnimElement_DerivedClassID(*args)
GAnimElement_swigregister = _amanith.GAnimElement_swigregister
GAnimElement_swigregister(GAnimElement)
G_ANIMELEMENT_CLASSID = cvar.G_ANIMELEMENT_CLASSID

class GAnimElementProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAnimElementProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GAnimElementProxy, name)
    __repr__ = _swig_repr
    def ClassID(*args): return _amanith.GAnimElementProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GAnimElementProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GAnimElementProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GAnimElementProxy
    __del__ = lambda self : None;
GAnimElementProxy_swigregister = _amanith.GAnimElementProxy_swigregister
GAnimElementProxy_swigregister(GAnimElementProxy)

G_CONSTANT_OOR = _amanith.G_CONSTANT_OOR
G_LOOP_OOR = _amanith.G_LOOP_OOR
G_PINGPONG_OOR = _amanith.G_PINGPONG_OOR
G_ABSOLUTE_VALUE = _amanith.G_ABSOLUTE_VALUE
G_RELATIVE_VALUE = _amanith.G_RELATIVE_VALUE
class GProperty(GAnimElement):
    __swig_setmethods__ = {}
    for _s in [GAnimElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GProperty, name, value)
    __swig_getmethods__ = {}
    for _s in [GAnimElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GProperty, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GProperty(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GProperty
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GProperty_Clear(*args)
    def Name(*args): return _amanith.GProperty_Name(*args)
    def UpperName(*args): return _amanith.GProperty_UpperName(*args)
    def DefaultValue(*args): return _amanith.GProperty_DefaultValue(*args)
    def SetDefaultValue(*args): return _amanith.GProperty_SetDefaultValue(*args)
    def IsKeyBased(*args): return _amanith.GProperty_IsKeyBased(*args)
    def KeysCount(*args): return _amanith.GProperty_KeysCount(*args)
    def Key(*args): return _amanith.GProperty_Key(*args)
    def SetKey(*args): return _amanith.GProperty_SetKey(*args)
    def AddKey(*args): return _amanith.GProperty_AddKey(*args)
    def MoveKey(*args): return _amanith.GProperty_MoveKey(*args)
    def RemoveKey(*args): return _amanith.GProperty_RemoveKey(*args)
    def SetKeys(*args): return _amanith.GProperty_SetKeys(*args)
    def RemoveKeys(*args): return _amanith.GProperty_RemoveKeys(*args)
    def Value(*args): return _amanith.GProperty_Value(*args)
    def SetValue(*args): return _amanith.GProperty_SetValue(*args)
    def EaseProperty(*args): return _amanith.GProperty_EaseProperty(*args)
    def SetEaseProperty(*args): return _amanith.GProperty_SetEaseProperty(*args)
    def RemoveEaseProperty(*args): return _amanith.GProperty_RemoveEaseProperty(*args)
    def ApplyEase(*args): return _amanith.GProperty_ApplyEase(*args)
    def SetApplyEasy(*args): return _amanith.GProperty_SetApplyEasy(*args)
    def OORBefore(*args): return _amanith.GProperty_OORBefore(*args)
    def SetOORBefore(*args): return _amanith.GProperty_SetOORBefore(*args)
    def OORAfter(*args): return _amanith.GProperty_OORAfter(*args)
    def SetOORAfter(*args): return _amanith.GProperty_SetOORAfter(*args)
    def OORTime(*args): return _amanith.GProperty_OORTime(*args)
    def HandledType(*args): return _amanith.GProperty_HandledType(*args)
    def ClassID(*args): return _amanith.GProperty_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GProperty_DerivedClassID(*args)
GProperty_swigregister = _amanith.GProperty_swigregister
GProperty_swigregister(GProperty)
G_ANIMELEMENT_PROXY = cvar.G_ANIMELEMENT_PROXY
G_PROPERTY_CLASSID = cvar.G_PROPERTY_CLASSID

class GPropertyProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPropertyProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPropertyProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GPropertyProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GPropertyProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPropertyProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPropertyProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPropertyProxy
    __del__ = lambda self : None;
GPropertyProxy_swigregister = _amanith.GPropertyProxy_swigregister
GPropertyProxy_swigregister(GPropertyProxy)

G_NO_ERROR = _amanith.G_NO_ERROR
G_UNKNOWN_ERROR = _amanith.G_UNKNOWN_ERROR
G_FILE_NOT_FOUND = _amanith.G_FILE_NOT_FOUND
G_FILE_ALREADY_EXISTS = _amanith.G_FILE_ALREADY_EXISTS
G_INVALID_FORMAT = _amanith.G_INVALID_FORMAT
G_PERMISSION_DENIED = _amanith.G_PERMISSION_DENIED
G_INVALID_PARAMETER = _amanith.G_INVALID_PARAMETER
G_INVALID_NODE = _amanith.G_INVALID_NODE
G_UNSUPPORTED_CLASSID = _amanith.G_UNSUPPORTED_CLASSID
G_OUT_OF_RANGE = _amanith.G_OUT_OF_RANGE
G_READ_ERROR = _amanith.G_READ_ERROR
G_WRITE_ERROR = _amanith.G_WRITE_ERROR
G_MEMORY_ERROR = _amanith.G_MEMORY_ERROR
G_MISSING_KERNEL = _amanith.G_MISSING_KERNEL
G_MISSED_FEATURE = _amanith.G_MISSED_FEATURE
G_ENTRY_ALREADY_EXISTS = _amanith.G_ENTRY_ALREADY_EXISTS
G_INVALID_OPERATION = _amanith.G_INVALID_OPERATION
G_PLUGIN_NOTLOADED = _amanith.G_PLUGIN_NOTLOADED
G_PLUGIN_NOTPRESENT = _amanith.G_PLUGIN_NOTPRESENT
G_PLUGIN_SYMBOL_UNRESOLVED = _amanith.G_PLUGIN_SYMBOL_UNRESOLVED
G_PLUGIN_ALREADYLOADED = _amanith.G_PLUGIN_ALREADYLOADED
G_PLUGIN_ISTANCED = _amanith.G_PLUGIN_ISTANCED
G_DRAWBOARD_INVALID_CACHEBANK = _amanith.G_DRAWBOARD_INVALID_CACHEBANK
G_DRAWBOARD_CACHE_NOT_WRITTEN = _amanith.G_DRAWBOARD_CACHE_NOT_WRITTEN
G_SMTP_UNEXPECTEDANSWER = _amanith.G_SMTP_UNEXPECTEDANSWER
G_SMTP_SERVICECLOSED = _amanith.G_SMTP_SERVICECLOSED
G_SMTP_NOTIMPLEMENTED = _amanith.G_SMTP_NOTIMPLEMENTED
G_SMTP_MIMENOTSUPPORTED = _amanith.G_SMTP_MIMENOTSUPPORTED
G_SMTP_SERVERCANTEXECUTE = _amanith.G_SMTP_SERVERCANTEXECUTE
G_SMTP_CANTCONNECT = _amanith.G_SMTP_CANTCONNECT
G_SMTP_DATAERROR = _amanith.G_SMTP_DATAERROR
G_SMTP_SYNTAXERROR = _amanith.G_SMTP_SYNTAXERROR
G_SMTP_STORAGEEXCEDED = _amanith.G_SMTP_STORAGEEXCEDED
G_SMTP_UNKNOWNUSER = _amanith.G_SMTP_UNKNOWNUSER
G_SMTP_FORWARDED = _amanith.G_SMTP_FORWARDED
G_HTTP_BAD_URL = _amanith.G_HTTP_BAD_URL
G_HTTP_TCP_FAILED = _amanith.G_HTTP_TCP_FAILED
G_HTTP_HOST_UNKNOWN = _amanith.G_HTTP_HOST_UNKNOWN
G_HTTP_TCP_CONNECT = _amanith.G_HTTP_TCP_CONNECT
G_HTTP_FILE_ERROR = _amanith.G_HTTP_FILE_ERROR
G_HTTP_INSMEMORY = _amanith.G_HTTP_INSMEMORY
G_HTTP_BAD_PARAM = _amanith.G_HTTP_BAD_PARAM
G_HTTP_OVERFLOW = _amanith.G_HTTP_OVERFLOW
G_HTTP_CANCELLED = _amanith.G_HTTP_CANCELLED
G_HTTP_NO_CONTENT = _amanith.G_HTTP_NO_CONTENT
G_HTTP_MOVED = _amanith.G_HTTP_MOVED
G_HTTP_BAD_REQUEST = _amanith.G_HTTP_BAD_REQUEST
G_HTTP_FORBIDDEN = _amanith.G_HTTP_FORBIDDEN
G_HTTP_NOT_FOUND = _amanith.G_HTTP_NOT_FOUND
G_HTTP_PROTOCOL_ERROR = _amanith.G_HTTP_PROTOCOL_ERROR
G_HTTP_UNDEFINED = _amanith.G_HTTP_UNDEFINED
G_HTTP_TIMEOUT = _amanith.G_HTTP_TIMEOUT
class ErrorUtils(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ErrorUtils, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ErrorUtils, name)
    __repr__ = _swig_repr
    __swig_getmethods__["ErrToString"] = lambda x: _amanith.ErrorUtils_ErrToString
    if _newclass:ErrToString = staticmethod(_amanith.ErrorUtils_ErrToString)
    def __init__(self, *args): 
        this = _amanith.new_ErrorUtils(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_ErrorUtils
    __del__ = lambda self : None;
ErrorUtils_swigregister = _amanith.ErrorUtils_swigregister
ErrorUtils_swigregister(ErrorUtils)
G_PROPERTY_PROXY = cvar.G_PROPERTY_PROXY
ErrorUtils_ErrToString = _amanith.ErrorUtils_ErrToString

G_IMPEXP_READ = _amanith.G_IMPEXP_READ
G_IMPEXP_WRITE = _amanith.G_IMPEXP_WRITE
G_IMPEXP_READWRITE = _amanith.G_IMPEXP_READWRITE
class GImpExpFeature(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GImpExpFeature, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GImpExpFeature, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GImpExpFeature(*args)
        try: self.this.append(this)
        except: self.this = this
    def ClassID(*args): return _amanith.GImpExpFeature_ClassID(*args)
    def FormatName(*args): return _amanith.GImpExpFeature_FormatName(*args)
    def ReadWriteOp(*args): return _amanith.GImpExpFeature_ReadWriteOp(*args)
    def Version(*args): return _amanith.GImpExpFeature_Version(*args)
    def FormatSupported(*args): return _amanith.GImpExpFeature_FormatSupported(*args)
    def FileExtensionSupported(*args): return _amanith.GImpExpFeature_FileExtensionSupported(*args)
    def FileExtensionsCount(*args): return _amanith.GImpExpFeature_FileExtensionsCount(*args)
    def FileExtension(*args): return _amanith.GImpExpFeature_FileExtension(*args)
    __swig_destroy__ = _amanith.delete_GImpExpFeature
    __del__ = lambda self : None;
GImpExpFeature_swigregister = _amanith.GImpExpFeature_swigregister
GImpExpFeature_swigregister(GImpExpFeature)

class GImpExp(GElement):
    __swig_setmethods__ = {}
    for _s in [GElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GImpExp, name, value)
    __swig_getmethods__ = {}
    for _s in [GElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GImpExp, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GImpExp
    __del__ = lambda self : None;
    def Read(*args): return _amanith.GImpExp_Read(*args)
    def Write(*args): return _amanith.GImpExp_Write(*args)
    def Features(*args): return _amanith.GImpExp_Features(*args)
    def FormatSupported(*args): return _amanith.GImpExp_FormatSupported(*args)
    def FileExtensionSupported(*args): return _amanith.GImpExp_FileExtensionSupported(*args)
    def ClassID(*args): return _amanith.GImpExp_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GImpExp_DerivedClassID(*args)
GImpExp_swigregister = _amanith.GImpExp_swigregister
GImpExp_swigregister(GImpExp)
G_IMPEXP_CLASSID = cvar.G_IMPEXP_CLASSID

class GImpExpProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GImpExpProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GImpExpProxy, name)
    __repr__ = _swig_repr
    def ClassID(*args): return _amanith.GImpExpProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GImpExpProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GImpExpProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GImpExpProxy
    __del__ = lambda self : None;
GImpExpProxy_swigregister = _amanith.GImpExpProxy_swigregister
GImpExpProxy_swigregister(GImpExpProxy)

class GProxyState(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GProxyState, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GProxyState, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GProxyState(*args)
        try: self.this.append(this)
        except: self.this = this
    def Proxy(*args): return _amanith.GProxyState_Proxy(*args)
    def External(*args): return _amanith.GProxyState_External(*args)
    __swig_destroy__ = _amanith.delete_GProxyState
    __del__ = lambda self : None;
GProxyState_swigregister = _amanith.GProxyState_swigregister
GProxyState_swigregister(GProxyState)
G_IMPEXP_PROXY = cvar.G_IMPEXP_PROXY

class GKernel(GElement):
    __swig_setmethods__ = {}
    for _s in [GElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKernel, name, value)
    __swig_getmethods__ = {}
    for _s in [GElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GKernel, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GKernel(*args)
        try: self.this.append(this)
        except: self.this = this
        if len(args) and isinstance(args[0], GElement): self.thisown = 0

    __swig_destroy__ = _amanith.delete_GKernel
    __del__ = lambda self : None;
    def ClassIDFromClassName(*args): return _amanith.GKernel_ClassIDFromClassName(*args)
    def Copy(*args): return _amanith.GKernel_Copy(*args)
    def CreateNew(*args): return _amanith.GKernel_CreateNew(*args)
    def IsTypeOfType(*args): return _amanith.GKernel_IsTypeOfType(*args)
    def IsSupported(*args): return _amanith.GKernel_IsSupported(*args)
    def LoadPlugin(*args): return _amanith.GKernel_LoadPlugin(*args)
    def LoadPlugins(*args): return _amanith.GKernel_LoadPlugins(*args)
    def UnLoadPlugin(*args): return _amanith.GKernel_UnLoadPlugin(*args)
    def Load(*args): return _amanith.GKernel_Load(*args)
    def Save(*args): return _amanith.GKernel_Save(*args)
    def ImpExpFeatures(*args): return _amanith.GKernel_ImpExpFeatures(*args)
    def ProxiesCount(*args): return _amanith.GKernel_ProxiesCount(*args)
    def Proxy(*args): return _amanith.GKernel_Proxy(*args)
    def Proxies(*args): return _amanith.GKernel_Proxies(*args)
    def RootClassProxies(*args): return _amanith.GKernel_RootClassProxies(*args)
    def ChildClassProxies(*args): return _amanith.GKernel_ChildClassProxies(*args)
    def DerivedClassID(*args): return _amanith.GKernel_DerivedClassID(*args)
    def ClassID(*args): return _amanith.GKernel_ClassID(*args)
GKernel_swigregister = _amanith.GKernel_swigregister
GKernel_swigregister(GKernel)
G_KERNEL_CLASSID = cvar.G_KERNEL_CLASSID

class GKernelProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKernelProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GKernelProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GKernelProxy_CreateNew(*args)
    def DerivedClassID(*args): return _amanith.GKernelProxy_DerivedClassID(*args)
    def ClassID(*args): return _amanith.GKernelProxy_ClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GKernelProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GKernelProxy
    __del__ = lambda self : None;
GKernelProxy_swigregister = _amanith.GKernelProxy_swigregister
GKernelProxy_swigregister(GKernelProxy)

G_2PI = _amanith.G_2PI
G_PI = _amanith.G_PI
G_PI_OVER2 = _amanith.G_PI_OVER2
G_PI_OVER4 = _amanith.G_PI_OVER4
G_SQRTHALF = _amanith.G_SQRTHALF
G_EXP1 = _amanith.G_EXP1
G_ONE_OVER_PI = _amanith.G_ONE_OVER_PI
G_ONE_OVER_2PI = _amanith.G_ONE_OVER_2PI
LogStar = _amanith.LogStar
Log2Star = _amanith.Log2Star
Log10Star = _amanith.Log10Star
GCD = _amanith.GCD
MCM = _amanith.MCM
UnitRandomf = _amanith.UnitRandomf
UnitRandom = _amanith.UnitRandom
FloorDiv = _amanith.FloorDiv
class GMultiProperty1D(GProperty):
    __swig_setmethods__ = {}
    for _s in [GProperty]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMultiProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GProperty]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GMultiProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GMultiProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GMultiProperty1D
    __del__ = lambda self : None;
    def SubPropertiesType(*args): return _amanith.GMultiProperty1D_SubPropertiesType(*args)
    def ClassID(*args): return _amanith.GMultiProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GMultiProperty1D_DerivedClassID(*args)
GMultiProperty1D_swigregister = _amanith.GMultiProperty1D_swigregister
GMultiProperty1D_swigregister(GMultiProperty1D)
G_KERNEL_PROXY = cvar.G_KERNEL_PROXY
Abs = _amanith.Abs
Ceil = _amanith.Ceil
Floor = _amanith.Floor
Acos = _amanith.Acos
Asin = _amanith.Asin
Atan = _amanith.Atan
Atan2 = _amanith.Atan2
Cos = _amanith.Cos
Exp = _amanith.Exp
Log = _amanith.Log
Log2 = _amanith.Log2
Log10 = _amanith.Log10
Pow = _amanith.Pow
Sin = _amanith.Sin
Tan = _amanith.Tan
Sqrt = _amanith.Sqrt
BesselJ0 = _amanith.BesselJ0
BesselJ1 = _amanith.BesselJ1
BesselJN = _amanith.BesselJN
BesselY0 = _amanith.BesselY0
BesselY1 = _amanith.BesselY1
BesselYN = _amanith.BesselYN
BesselI0 = _amanith.BesselI0
BesslI1 = _amanith.BesslI1
Hypot = _amanith.Hypot
SeedRandom = _amanith.SeedRandom
RangeRandom = _amanith.RangeRandom
Deg2Rad = _amanith.Deg2Rad
Rad2Deg = _amanith.Rad2Deg
AngleConversion = _amanith.AngleConversion
G_MULTIPROPERTY1D_CLASSID = cvar.G_MULTIPROPERTY1D_CLASSID

class GMultiProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMultiProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GMultiProperty1DProxy, name)
    __repr__ = _swig_repr
    def ClassID(*args): return _amanith.GMultiProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GMultiProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GMultiProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GMultiProperty1DProxy
    __del__ = lambda self : None;
GMultiProperty1DProxy_swigregister = _amanith.GMultiProperty1DProxy_swigregister
GMultiProperty1DProxy_swigregister(GMultiProperty1DProxy)

class GTwoHermiteProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTwoHermiteProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GTwoHermiteProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GTwoHermiteProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTwoHermiteProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GTwoHermiteProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GTwoHermiteProperty1D_DerivedClassID(*args)
GTwoHermiteProperty1D_swigregister = _amanith.GTwoHermiteProperty1D_swigregister
GTwoHermiteProperty1D_swigregister(GTwoHermiteProperty1D)
G_MULTIPROPERTY1D_PROXY = cvar.G_MULTIPROPERTY1D_PROXY
G_TWOHERMITEPROPERTY1D_CLASSID = cvar.G_TWOHERMITEPROPERTY1D_CLASSID

class GTwoHermiteProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTwoHermiteProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GTwoHermiteProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GTwoHermiteProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GTwoHermiteProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GTwoHermiteProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GTwoHermiteProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTwoHermiteProperty1DProxy
    __del__ = lambda self : None;
GTwoHermiteProperty1DProxy_swigregister = _amanith.GTwoHermiteProperty1DProxy_swigregister
GTwoHermiteProperty1DProxy_swigregister(GTwoHermiteProperty1DProxy)

class GThreeHermiteProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GThreeHermiteProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GThreeHermiteProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GThreeHermiteProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GThreeHermiteProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GThreeHermiteProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GThreeHermiteProperty1D_DerivedClassID(*args)
GThreeHermiteProperty1D_swigregister = _amanith.GThreeHermiteProperty1D_swigregister
GThreeHermiteProperty1D_swigregister(GThreeHermiteProperty1D)
G_TWOHERMITEPROPERTY1D_PROXY = cvar.G_TWOHERMITEPROPERTY1D_PROXY
G_THREEHERMITEPROPERTY1D_CLASSID = cvar.G_THREEHERMITEPROPERTY1D_CLASSID

class GThreeHermiteProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GThreeHermiteProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GThreeHermiteProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GThreeHermiteProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GThreeHermiteProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GThreeHermiteProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GThreeHermiteProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GThreeHermiteProperty1DProxy
    __del__ = lambda self : None;
GThreeHermiteProperty1DProxy_swigregister = _amanith.GThreeHermiteProperty1DProxy_swigregister
GThreeHermiteProperty1DProxy_swigregister(GThreeHermiteProperty1DProxy)

class GFourHermiteProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFourHermiteProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFourHermiteProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GFourHermiteProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFourHermiteProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GFourHermiteProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFourHermiteProperty1D_DerivedClassID(*args)
GFourHermiteProperty1D_swigregister = _amanith.GFourHermiteProperty1D_swigregister
GFourHermiteProperty1D_swigregister(GFourHermiteProperty1D)
G_THREEHERMITEPROPERTY1D_PROXY = cvar.G_THREEHERMITEPROPERTY1D_PROXY
G_FOURHERMITEPROPERTY1D_CLASSID = cvar.G_FOURHERMITEPROPERTY1D_CLASSID

class GFourHermiteProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFourHermiteProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFourHermiteProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GFourHermiteProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GFourHermiteProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFourHermiteProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GFourHermiteProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFourHermiteProperty1DProxy
    __del__ = lambda self : None;
GFourHermiteProperty1DProxy_swigregister = _amanith.GFourHermiteProperty1DProxy_swigregister
GFourHermiteProperty1DProxy_swigregister(GFourHermiteProperty1DProxy)

class GTwoLinearProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTwoLinearProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GTwoLinearProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GTwoLinearProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTwoLinearProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GTwoLinearProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GTwoLinearProperty1D_DerivedClassID(*args)
GTwoLinearProperty1D_swigregister = _amanith.GTwoLinearProperty1D_swigregister
GTwoLinearProperty1D_swigregister(GTwoLinearProperty1D)
G_FOURHERMITEPROPERTY1D_PROXY = cvar.G_FOURHERMITEPROPERTY1D_PROXY
G_TWOLINEARPROPERTY1D_CLASSID = cvar.G_TWOLINEARPROPERTY1D_CLASSID

class GTwoLinearProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTwoLinearProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GTwoLinearProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GTwoLinearProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GTwoLinearProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GTwoLinearProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GTwoLinearProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTwoLinearProperty1DProxy
    __del__ = lambda self : None;
GTwoLinearProperty1DProxy_swigregister = _amanith.GTwoLinearProperty1DProxy_swigregister
GTwoLinearProperty1DProxy_swigregister(GTwoLinearProperty1DProxy)

class GThreeLinearProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GThreeLinearProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GThreeLinearProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GThreeLinearProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GThreeLinearProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GThreeLinearProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GThreeLinearProperty1D_DerivedClassID(*args)
GThreeLinearProperty1D_swigregister = _amanith.GThreeLinearProperty1D_swigregister
GThreeLinearProperty1D_swigregister(GThreeLinearProperty1D)
G_TWOLINEARPROPERTY1D_PROXY = cvar.G_TWOLINEARPROPERTY1D_PROXY
G_THREELINEARPROPERTY1D_CLASSID = cvar.G_THREELINEARPROPERTY1D_CLASSID

class GThreeLinearProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GThreeLinearProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GThreeLinearProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GThreeLinearProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GThreeLinearProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GThreeLinearProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GThreeLinearProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GThreeLinearProperty1DProxy
    __del__ = lambda self : None;
GThreeLinearProperty1DProxy_swigregister = _amanith.GThreeLinearProperty1DProxy_swigregister
GThreeLinearProperty1DProxy_swigregister(GThreeLinearProperty1DProxy)

class GFourLinearProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFourLinearProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFourLinearProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GFourLinearProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFourLinearProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GFourLinearProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFourLinearProperty1D_DerivedClassID(*args)
GFourLinearProperty1D_swigregister = _amanith.GFourLinearProperty1D_swigregister
GFourLinearProperty1D_swigregister(GFourLinearProperty1D)
G_THREELINEARPROPERTY1D_PROXY = cvar.G_THREELINEARPROPERTY1D_PROXY
G_FOURLINEARPROPERTY1D_CLASSID = cvar.G_FOURLINEARPROPERTY1D_CLASSID

class GFourLinearProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFourLinearProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFourLinearProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GFourLinearProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GFourLinearProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFourLinearProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GFourLinearProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFourLinearProperty1DProxy
    __del__ = lambda self : None;
GFourLinearProperty1DProxy_swigregister = _amanith.GFourLinearProperty1DProxy_swigregister
GFourLinearProperty1DProxy_swigregister(GFourLinearProperty1DProxy)

class GTwoConstantProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTwoConstantProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GTwoConstantProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GTwoConstantProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTwoConstantProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GTwoConstantProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GTwoConstantProperty1D_DerivedClassID(*args)
GTwoConstantProperty1D_swigregister = _amanith.GTwoConstantProperty1D_swigregister
GTwoConstantProperty1D_swigregister(GTwoConstantProperty1D)
G_FOURLINEARPROPERTY1D_PROXY = cvar.G_FOURLINEARPROPERTY1D_PROXY
G_TWOCONSTANTPROPERTY1D_CLASSID = cvar.G_TWOCONSTANTPROPERTY1D_CLASSID

class GTwoConstantProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTwoConstantProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GTwoConstantProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GTwoConstantProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GTwoConstantProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GTwoConstantProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GTwoConstantProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTwoConstantProperty1DProxy
    __del__ = lambda self : None;
GTwoConstantProperty1DProxy_swigregister = _amanith.GTwoConstantProperty1DProxy_swigregister
GTwoConstantProperty1DProxy_swigregister(GTwoConstantProperty1DProxy)

class GThreeConstantProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GThreeConstantProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GThreeConstantProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GThreeConstantProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GThreeConstantProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GThreeConstantProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GThreeConstantProperty1D_DerivedClassID(*args)
GThreeConstantProperty1D_swigregister = _amanith.GThreeConstantProperty1D_swigregister
GThreeConstantProperty1D_swigregister(GThreeConstantProperty1D)
G_TWOCONSTANTPROPERTY1D_PROXY = cvar.G_TWOCONSTANTPROPERTY1D_PROXY
G_THREECONSTANTPROPERTY1D_CLASSID = cvar.G_THREECONSTANTPROPERTY1D_CLASSID

class GThreeConstantProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GThreeConstantProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GThreeConstantProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GThreeConstantProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GThreeConstantProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GThreeConstantProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GThreeConstantProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GThreeConstantProperty1DProxy
    __del__ = lambda self : None;
GThreeConstantProperty1DProxy_swigregister = _amanith.GThreeConstantProperty1DProxy_swigregister
GThreeConstantProperty1DProxy_swigregister(GThreeConstantProperty1DProxy)

class GFourConstantProperty1D(GMultiProperty1D):
    __swig_setmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFourConstantProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiProperty1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFourConstantProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GFourConstantProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFourConstantProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GFourConstantProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFourConstantProperty1D_DerivedClassID(*args)
GFourConstantProperty1D_swigregister = _amanith.GFourConstantProperty1D_swigregister
GFourConstantProperty1D_swigregister(GFourConstantProperty1D)
G_THREECONSTANTPROPERTY1D_PROXY = cvar.G_THREECONSTANTPROPERTY1D_PROXY
G_FOURCONSTANTPROPERTY1D_CLASSID = cvar.G_FOURCONSTANTPROPERTY1D_CLASSID

class GFourConstantProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFourConstantProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFourConstantProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GFourConstantProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GFourConstantProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFourConstantProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GFourConstantProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFourConstantProperty1DProxy
    __del__ = lambda self : None;
GFourConstantProperty1DProxy_swigregister = _amanith.GFourConstantProperty1DProxy_swigregister
GFourConstantProperty1DProxy_swigregister(GFourConstantProperty1DProxy)

class GOpenglExt(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GOpenglExt, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GOpenglExt, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GOpenglExt(*args)
        try: self.this.append(this)
        except: self.this = this
    def IsFunctionSupported(*args): return _amanith.GOpenglExt_IsFunctionSupported(*args)
    def IsGLVersionSupported(*args): return _amanith.GOpenglExt_IsGLVersionSupported(*args)
    def IsGLExtensionSupported(*args): return _amanith.GOpenglExt_IsGLExtensionSupported(*args)
    def IsMultitextureSupported(*args): return _amanith.GOpenglExt_IsMultitextureSupported(*args)
    def IsCubemapSupported(*args): return _amanith.GOpenglExt_IsCubemapSupported(*args)
    def IsRectTextureSupported(*args): return _amanith.GOpenglExt_IsRectTextureSupported(*args)
    def IsMirroredRepeatSupported(*args): return _amanith.GOpenglExt_IsMirroredRepeatSupported(*args)
    def IsArbShadersSupported(*args): return _amanith.GOpenglExt_IsArbShadersSupported(*args)
    def IsArbProgramsSupported(*args): return _amanith.GOpenglExt_IsArbProgramsSupported(*args)
    def IsOcclusionQuerySupported(*args): return _amanith.GOpenglExt_IsOcclusionQuerySupported(*args)
    def IsFBOSupported(*args): return _amanith.GOpenglExt_IsFBOSupported(*args)
    __swig_getmethods__["TextureUnitsCount"] = lambda x: _amanith.GOpenglExt_TextureUnitsCount
    if _newclass:TextureUnitsCount = staticmethod(_amanith.GOpenglExt_TextureUnitsCount)
    __swig_getmethods__["MaxConvolutionWidth"] = lambda x: _amanith.GOpenglExt_MaxConvolutionWidth
    if _newclass:MaxConvolutionWidth = staticmethod(_amanith.GOpenglExt_MaxConvolutionWidth)
    __swig_getmethods__["MaxConvolutionHeight"] = lambda x: _amanith.GOpenglExt_MaxConvolutionHeight
    if _newclass:MaxConvolutionHeight = staticmethod(_amanith.GOpenglExt_MaxConvolutionHeight)
    __swig_getmethods__["MaxTextureSize"] = lambda x: _amanith.GOpenglExt_MaxTextureSize
    if _newclass:MaxTextureSize = staticmethod(_amanith.GOpenglExt_MaxTextureSize)
    __swig_getmethods__["MaxRenderBufferSize"] = lambda x: _amanith.GOpenglExt_MaxRenderBufferSize
    if _newclass:MaxRenderBufferSize = staticmethod(_amanith.GOpenglExt_MaxRenderBufferSize)
    __swig_getmethods__["RedBits"] = lambda x: _amanith.GOpenglExt_RedBits
    if _newclass:RedBits = staticmethod(_amanith.GOpenglExt_RedBits)
    __swig_getmethods__["GreenBits"] = lambda x: _amanith.GOpenglExt_GreenBits
    if _newclass:GreenBits = staticmethod(_amanith.GOpenglExt_GreenBits)
    __swig_getmethods__["BlueBits"] = lambda x: _amanith.GOpenglExt_BlueBits
    if _newclass:BlueBits = staticmethod(_amanith.GOpenglExt_BlueBits)
    __swig_getmethods__["AlphaBits"] = lambda x: _amanith.GOpenglExt_AlphaBits
    if _newclass:AlphaBits = staticmethod(_amanith.GOpenglExt_AlphaBits)
    __swig_getmethods__["DepthBits"] = lambda x: _amanith.GOpenglExt_DepthBits
    if _newclass:DepthBits = staticmethod(_amanith.GOpenglExt_DepthBits)
    __swig_getmethods__["StencilBits"] = lambda x: _amanith.GOpenglExt_StencilBits
    if _newclass:StencilBits = staticmethod(_amanith.GOpenglExt_StencilBits)
    __swig_getmethods__["MultiSamples"] = lambda x: _amanith.GOpenglExt_MultiSamples
    if _newclass:MultiSamples = staticmethod(_amanith.GOpenglExt_MultiSamples)
    __swig_getmethods__["FBOMaxColorAttachments"] = lambda x: _amanith.GOpenglExt_FBOMaxColorAttachments
    if _newclass:FBOMaxColorAttachments = staticmethod(_amanith.GOpenglExt_FBOMaxColorAttachments)
    def SupportedFunctions(*args): return _amanith.GOpenglExt_SupportedFunctions(*args)
    def PrintInfoLog(*args): return _amanith.GOpenglExt_PrintInfoLog(*args)
    __swig_getmethods__["PrintOglError"] = lambda x: _amanith.GOpenglExt_PrintOglError
    if _newclass:PrintOglError = staticmethod(_amanith.GOpenglExt_PrintOglError)
    __swig_getmethods__["PowerOfTwo"] = lambda x: _amanith.GOpenglExt_PowerOfTwo
    if _newclass:PowerOfTwo = staticmethod(_amanith.GOpenglExt_PowerOfTwo)
    __swig_destroy__ = _amanith.delete_GOpenglExt
    __del__ = lambda self : None;
GOpenglExt_swigregister = _amanith.GOpenglExt_swigregister
GOpenglExt_swigregister(GOpenglExt)
G_FOURCONSTANTPROPERTY1D_PROXY = cvar.G_FOURCONSTANTPROPERTY1D_PROXY
GOpenglExt_TextureUnitsCount = _amanith.GOpenglExt_TextureUnitsCount
GOpenglExt_MaxConvolutionWidth = _amanith.GOpenglExt_MaxConvolutionWidth
GOpenglExt_MaxConvolutionHeight = _amanith.GOpenglExt_MaxConvolutionHeight
GOpenglExt_MaxTextureSize = _amanith.GOpenglExt_MaxTextureSize
GOpenglExt_MaxRenderBufferSize = _amanith.GOpenglExt_MaxRenderBufferSize
GOpenglExt_RedBits = _amanith.GOpenglExt_RedBits
GOpenglExt_GreenBits = _amanith.GOpenglExt_GreenBits
GOpenglExt_BlueBits = _amanith.GOpenglExt_BlueBits
GOpenglExt_AlphaBits = _amanith.GOpenglExt_AlphaBits
GOpenglExt_DepthBits = _amanith.GOpenglExt_DepthBits
GOpenglExt_StencilBits = _amanith.GOpenglExt_StencilBits
GOpenglExt_MultiSamples = _amanith.GOpenglExt_MultiSamples
GOpenglExt_FBOMaxColorAttachments = _amanith.GOpenglExt_FBOMaxColorAttachments
GOpenglExt_PrintOglError = _amanith.GOpenglExt_PrintOglError
GOpenglExt_PowerOfTwo = _amanith.GOpenglExt_PowerOfTwo

class GPlugLoader(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPlugLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPlugLoader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPlugLoader(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPlugLoader
    __del__ = lambda self : None;
    def LoadPlug(*args): return _amanith.GPlugLoader_LoadPlug(*args)
    def UnloadPlug(*args): return _amanith.GPlugLoader_UnloadPlug(*args)
    def IsPlugLoaded(*args): return _amanith.GPlugLoader_IsPlugLoaded(*args)
    def PlugName(*args): return _amanith.GPlugLoader_PlugName(*args)
    def PlugHandle(*args): return _amanith.GPlugLoader_PlugHandle(*args)
    def ResolveSymbol(*args): return _amanith.GPlugLoader_ResolveSymbol(*args)
    def UnloadOnDestroy(*args): return _amanith.GPlugLoader_UnloadOnDestroy(*args)
    def SetUnloadOnDestroy(*args): return _amanith.GPlugLoader_SetUnloadOnDestroy(*args)
GPlugLoader_swigregister = _amanith.GPlugLoader_swigregister
GPlugLoader_swigregister(GPlugLoader)

class GHermiteProperty1D(GProperty):
    __swig_setmethods__ = {}
    for _s in [GProperty]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GProperty]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GHermiteProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteProperty1D
    __del__ = lambda self : None;
    def RecalcSmoothTangents(*args): return _amanith.GHermiteProperty1D_RecalcSmoothTangents(*args)
    def HermiteKey(*args): return _amanith.GHermiteProperty1D_HermiteKey(*args)
    def SetHermiteKey(*args): return _amanith.GHermiteProperty1D_SetHermiteKey(*args)
    def SetHermiteKeys(*args): return _amanith.GHermiteProperty1D_SetHermiteKeys(*args)
    def ClassID(*args): return _amanith.GHermiteProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GHermiteProperty1D_DerivedClassID(*args)
    def HandledType(*args): return _amanith.GHermiteProperty1D_HandledType(*args)
GHermiteProperty1D_swigregister = _amanith.GHermiteProperty1D_swigregister
GHermiteProperty1D_swigregister(GHermiteProperty1D)
G_HERMITEPROPERTY1D_CLASSID = cvar.G_HERMITEPROPERTY1D_CLASSID

class GHermiteProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GHermiteProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GHermiteProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GHermiteProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GHermiteProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteProperty1DProxy
    __del__ = lambda self : None;
GHermiteProperty1DProxy_swigregister = _amanith.GHermiteProperty1DProxy_swigregister
GHermiteProperty1DProxy_swigregister(GHermiteProperty1DProxy)

class GLinearProperty1D(GProperty):
    __swig_setmethods__ = {}
    for _s in [GProperty]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLinearProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GProperty]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GLinearProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GLinearProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GLinearProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GLinearProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GLinearProperty1D_DerivedClassID(*args)
    def HandledType(*args): return _amanith.GLinearProperty1D_HandledType(*args)
GLinearProperty1D_swigregister = _amanith.GLinearProperty1D_swigregister
GLinearProperty1D_swigregister(GLinearProperty1D)
G_HERMITEPROPERTY1D_PROXY = cvar.G_HERMITEPROPERTY1D_PROXY
G_LINEARPROPERTY1D_CLASSID = cvar.G_LINEARPROPERTY1D_CLASSID

class GLinearProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLinearProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GLinearProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GLinearProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GLinearProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GLinearProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GLinearProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GLinearProperty1DProxy
    __del__ = lambda self : None;
GLinearProperty1DProxy_swigregister = _amanith.GLinearProperty1DProxy_swigregister
GLinearProperty1DProxy_swigregister(GLinearProperty1DProxy)

class GConstantProperty1D(GProperty):
    __swig_setmethods__ = {}
    for _s in [GProperty]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GConstantProperty1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GProperty]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GConstantProperty1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GConstantProperty1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GConstantProperty1D
    __del__ = lambda self : None;
    def ClassID(*args): return _amanith.GConstantProperty1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GConstantProperty1D_DerivedClassID(*args)
    def HandledType(*args): return _amanith.GConstantProperty1D_HandledType(*args)
GConstantProperty1D_swigregister = _amanith.GConstantProperty1D_swigregister
GConstantProperty1D_swigregister(GConstantProperty1D)
G_LINEARPROPERTY1D_PROXY = cvar.G_LINEARPROPERTY1D_PROXY
G_CONSTANTPROPERTY1D_CLASSID = cvar.G_CONSTANTPROPERTY1D_CLASSID

class GConstantProperty1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GConstantProperty1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GConstantProperty1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GConstantProperty1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GConstantProperty1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GConstantProperty1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GConstantProperty1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GConstantProperty1DProxy
    __del__ = lambda self : None;
GConstantProperty1DProxy_swigregister = _amanith.GConstantProperty1DProxy_swigregister
GConstantProperty1DProxy_swigregister(GConstantProperty1DProxy)

class GAffineParts(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAffineParts, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GAffineParts, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GAffineParts(*args)
        try: self.this.append(this)
        except: self.this = this
    def Translation(*args): return _amanith.GAffineParts_Translation(*args)
    def MainRotation(*args): return _amanith.GAffineParts_MainRotation(*args)
    def StretchRotation(*args): return _amanith.GAffineParts_StretchRotation(*args)
    def StretchFactors(*args): return _amanith.GAffineParts_StretchFactors(*args)
    def DeterminantSign(*args): return _amanith.GAffineParts_DeterminantSign(*args)
    __swig_destroy__ = _amanith.delete_GAffineParts
    __del__ = lambda self : None;
GAffineParts_swigregister = _amanith.GAffineParts_swigregister
GAffineParts_swigregister(GAffineParts)
G_CONSTANTPROPERTY1D_PROXY = cvar.G_CONSTANTPROPERTY1D_PROXY

NO_SOLUTIONS = _amanith.NO_SOLUTIONS
MULTIPLE_SOLUTIONS = _amanith.MULTIPLE_SOLUTIONS
SINGLE_SOLUTION = _amanith.SINGLE_SOLUTION
INFINITE_SOLUTIONS = _amanith.INFINITE_SOLUTIONS
COINCIDENT_SHAPES = _amanith.COINCIDENT_SHAPES
INCLUDED_SHAPE = _amanith.INCLUDED_SHAPE
TANGENT_SHAPES = _amanith.TANGENT_SHAPES
class GEigen(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GEigen, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GEigen, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GEigen(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GEigen
    __del__ = lambda self : None;
GEigen_swigregister = _amanith.GEigen_swigregister
GEigen_swigregister(GEigen)

class GMitchellDataFloat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMitchellDataFloat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMitchellDataFloat, name)
    __repr__ = _swig_repr
    __swig_setmethods__["p0"] = _amanith.GMitchellDataFloat_p0_set
    __swig_getmethods__["p0"] = _amanith.GMitchellDataFloat_p0_get
    if _newclass:p0 = property(_amanith.GMitchellDataFloat_p0_get, _amanith.GMitchellDataFloat_p0_set)
    __swig_setmethods__["p2"] = _amanith.GMitchellDataFloat_p2_set
    __swig_getmethods__["p2"] = _amanith.GMitchellDataFloat_p2_get
    if _newclass:p2 = property(_amanith.GMitchellDataFloat_p2_get, _amanith.GMitchellDataFloat_p2_set)
    __swig_setmethods__["p3"] = _amanith.GMitchellDataFloat_p3_set
    __swig_getmethods__["p3"] = _amanith.GMitchellDataFloat_p3_get
    if _newclass:p3 = property(_amanith.GMitchellDataFloat_p3_get, _amanith.GMitchellDataFloat_p3_set)
    __swig_setmethods__["q0"] = _amanith.GMitchellDataFloat_q0_set
    __swig_getmethods__["q0"] = _amanith.GMitchellDataFloat_q0_get
    if _newclass:q0 = property(_amanith.GMitchellDataFloat_q0_get, _amanith.GMitchellDataFloat_q0_set)
    __swig_setmethods__["q1"] = _amanith.GMitchellDataFloat_q1_set
    __swig_getmethods__["q1"] = _amanith.GMitchellDataFloat_q1_get
    if _newclass:q1 = property(_amanith.GMitchellDataFloat_q1_get, _amanith.GMitchellDataFloat_q1_set)
    __swig_setmethods__["q2"] = _amanith.GMitchellDataFloat_q2_set
    __swig_getmethods__["q2"] = _amanith.GMitchellDataFloat_q2_get
    if _newclass:q2 = property(_amanith.GMitchellDataFloat_q2_get, _amanith.GMitchellDataFloat_q2_set)
    __swig_setmethods__["q3"] = _amanith.GMitchellDataFloat_q3_set
    __swig_getmethods__["q3"] = _amanith.GMitchellDataFloat_q3_get
    if _newclass:q3 = property(_amanith.GMitchellDataFloat_q3_get, _amanith.GMitchellDataFloat_q3_set)
    def __init__(self, *args): 
        this = _amanith.new_GMitchellDataFloat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GMitchellDataFloat
    __del__ = lambda self : None;
GMitchellDataFloat_swigregister = _amanith.GMitchellDataFloat_swigregister
GMitchellDataFloat_swigregister(GMitchellDataFloat)

class GMitchellDataDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMitchellDataDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMitchellDataDouble, name)
    __repr__ = _swig_repr
    __swig_setmethods__["p0"] = _amanith.GMitchellDataDouble_p0_set
    __swig_getmethods__["p0"] = _amanith.GMitchellDataDouble_p0_get
    if _newclass:p0 = property(_amanith.GMitchellDataDouble_p0_get, _amanith.GMitchellDataDouble_p0_set)
    __swig_setmethods__["p2"] = _amanith.GMitchellDataDouble_p2_set
    __swig_getmethods__["p2"] = _amanith.GMitchellDataDouble_p2_get
    if _newclass:p2 = property(_amanith.GMitchellDataDouble_p2_get, _amanith.GMitchellDataDouble_p2_set)
    __swig_setmethods__["p3"] = _amanith.GMitchellDataDouble_p3_set
    __swig_getmethods__["p3"] = _amanith.GMitchellDataDouble_p3_get
    if _newclass:p3 = property(_amanith.GMitchellDataDouble_p3_get, _amanith.GMitchellDataDouble_p3_set)
    __swig_setmethods__["q0"] = _amanith.GMitchellDataDouble_q0_set
    __swig_getmethods__["q0"] = _amanith.GMitchellDataDouble_q0_get
    if _newclass:q0 = property(_amanith.GMitchellDataDouble_q0_get, _amanith.GMitchellDataDouble_q0_set)
    __swig_setmethods__["q1"] = _amanith.GMitchellDataDouble_q1_set
    __swig_getmethods__["q1"] = _amanith.GMitchellDataDouble_q1_get
    if _newclass:q1 = property(_amanith.GMitchellDataDouble_q1_get, _amanith.GMitchellDataDouble_q1_set)
    __swig_setmethods__["q2"] = _amanith.GMitchellDataDouble_q2_set
    __swig_getmethods__["q2"] = _amanith.GMitchellDataDouble_q2_get
    if _newclass:q2 = property(_amanith.GMitchellDataDouble_q2_get, _amanith.GMitchellDataDouble_q2_set)
    __swig_setmethods__["q3"] = _amanith.GMitchellDataDouble_q3_set
    __swig_getmethods__["q3"] = _amanith.GMitchellDataDouble_q3_get
    if _newclass:q3 = property(_amanith.GMitchellDataDouble_q3_get, _amanith.GMitchellDataDouble_q3_set)
    def __init__(self, *args): 
        this = _amanith.new_GMitchellDataDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GMitchellDataDouble
    __del__ = lambda self : None;
GMitchellDataDouble_swigregister = _amanith.GMitchellDataDouble_swigregister
GMitchellDataDouble_swigregister(GMitchellDataDouble)

class GKaiserDataFloat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKaiserDataFloat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GKaiserDataFloat, name)
    __repr__ = _swig_repr
    __swig_setmethods__["a"] = _amanith.GKaiserDataFloat_a_set
    __swig_getmethods__["a"] = _amanith.GKaiserDataFloat_a_get
    if _newclass:a = property(_amanith.GKaiserDataFloat_a_get, _amanith.GKaiserDataFloat_a_set)
    __swig_setmethods__["i0a"] = _amanith.GKaiserDataFloat_i0a_set
    __swig_getmethods__["i0a"] = _amanith.GKaiserDataFloat_i0a_get
    if _newclass:i0a = property(_amanith.GKaiserDataFloat_i0a_get, _amanith.GKaiserDataFloat_i0a_set)
    def __init__(self, *args): 
        this = _amanith.new_GKaiserDataFloat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GKaiserDataFloat
    __del__ = lambda self : None;
GKaiserDataFloat_swigregister = _amanith.GKaiserDataFloat_swigregister
GKaiserDataFloat_swigregister(GKaiserDataFloat)

class GKaiserDataDouble(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKaiserDataDouble, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GKaiserDataDouble, name)
    __repr__ = _swig_repr
    __swig_setmethods__["a"] = _amanith.GKaiserDataDouble_a_set
    __swig_getmethods__["a"] = _amanith.GKaiserDataDouble_a_get
    if _newclass:a = property(_amanith.GKaiserDataDouble_a_get, _amanith.GKaiserDataDouble_a_set)
    __swig_setmethods__["i0a"] = _amanith.GKaiserDataDouble_i0a_set
    __swig_getmethods__["i0a"] = _amanith.GKaiserDataDouble_i0a_get
    if _newclass:i0a = property(_amanith.GKaiserDataDouble_i0a_get, _amanith.GKaiserDataDouble_i0a_set)
    def __init__(self, *args): 
        this = _amanith.new_GKaiserDataDouble(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GKaiserDataDouble
    __del__ = lambda self : None;
GKaiserDataDouble_swigregister = _amanith.GKaiserDataDouble_swigregister
GKaiserDataDouble_swigregister(GKaiserDataDouble)

class GIntegration(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GIntegration, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GIntegration, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Romberg"] = lambda x: _amanith.GIntegration_Romberg
    if _newclass:Romberg = staticmethod(_amanith.GIntegration_Romberg)
    def __init__(self, *args): 
        this = _amanith.new_GIntegration(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GIntegration
    __del__ = lambda self : None;
GIntegration_swigregister = _amanith.GIntegration_swigregister
GIntegration_swigregister(GIntegration)
BoxFilter = _amanith.BoxFilter
TriangleFilter = _amanith.TriangleFilter
QuadraticFilter = _amanith.QuadraticFilter
CubicFilter = _amanith.CubicFilter
CatmullRomFilter = _amanith.CatmullRomFilter
GaussianFilter = _amanith.GaussianFilter
SincFilter = _amanith.SincFilter
BesselFilter = _amanith.BesselFilter
BellFilter = _amanith.BellFilter
MitchellFilter = _amanith.MitchellFilter
MitchellFilterInit = _amanith.MitchellFilterInit
HanningFilter = _amanith.HanningFilter
HammingFilter = _amanith.HammingFilter
BlackmanFilter = _amanith.BlackmanFilter
KaiserFilter = _amanith.KaiserFilter
KaiserFilterInit = _amanith.KaiserFilterInit
NormalFilter = _amanith.NormalFilter
GIntegration_Romberg = _amanith.GIntegration_Romberg

G_FIRST_ORDER_DERIVATIVE = _amanith.G_FIRST_ORDER_DERIVATIVE
G_SECOND_ORDER_DERIVATIVE = _amanith.G_SECOND_ORDER_DERIVATIVE
class GCurve1D(GElement):
    __swig_setmethods__ = {}
    for _s in [GElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GCurve1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GCurve1D, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GCurve1D
    __del__ = lambda self : None;
    def DomainStart(*args): return _amanith.GCurve1D_DomainStart(*args)
    def DomainEnd(*args): return _amanith.GCurve1D_DomainEnd(*args)
    def Domain(*args): return _amanith.GCurve1D_Domain(*args)
    def SetDomain(*args): return _amanith.GCurve1D_SetDomain(*args)
    def PointsCount(*args): return _amanith.GCurve1D_PointsCount(*args)
    def Clear(*args): return _amanith.GCurve1D_Clear(*args)
    def Point(*args): return _amanith.GCurve1D_Point(*args)
    def SetPoint(*args): return _amanith.GCurve1D_SetPoint(*args)
    def Evaluate(*args): return _amanith.GCurve1D_Evaluate(*args)
    def Derivative(*args): return _amanith.GCurve1D_Derivative(*args)
    def GlobalParameter(*args): return _amanith.GCurve1D_GlobalParameter(*args)
    def Length(*args): return _amanith.GCurve1D_Length(*args)
    def TotalLength(*args): return _amanith.GCurve1D_TotalLength(*args)
    def Cut(*args): return _amanith.GCurve1D_Cut(*args)
    def CutByLength(*args): return _amanith.GCurve1D_CutByLength(*args)
    def Tangent(*args): return _amanith.GCurve1D_Tangent(*args)
    def Speed(*args): return _amanith.GCurve1D_Speed(*args)
    def StartPoint(*args): return _amanith.GCurve1D_StartPoint(*args)
    def EndPoint(*args): return _amanith.GCurve1D_EndPoint(*args)
    def SetStartPoint(*args): return _amanith.GCurve1D_SetStartPoint(*args)
    def SetEndPoint(*args): return _amanith.GCurve1D_SetEndPoint(*args)
    def Translate(*args): return _amanith.GCurve1D_Translate(*args)
    def Scale(*args): return _amanith.GCurve1D_Scale(*args)
    def ClassID(*args): return _amanith.GCurve1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GCurve1D_DerivedClassID(*args)
GCurve1D_swigregister = _amanith.GCurve1D_swigregister
GCurve1D_swigregister(GCurve1D)
G_CURVE1D_CLASSID = cvar.G_CURVE1D_CLASSID

class GCurve1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GCurve1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GCurve1DProxy, name)
    __repr__ = _swig_repr
    def ClassID(*args): return _amanith.GCurve1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GCurve1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GCurve1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GCurve1DProxy
    __del__ = lambda self : None;
GCurve1DProxy_swigregister = _amanith.GCurve1DProxy_swigregister
GCurve1DProxy_swigregister(GCurve1DProxy)

class GMultiCurve1D(GCurve1D):
    __swig_setmethods__ = {}
    for _s in [GCurve1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMultiCurve1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GCurve1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GMultiCurve1D, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GMultiCurve1D
    __del__ = lambda self : None;
    def PointParameter(*args): return _amanith.GMultiCurve1D_PointParameter(*args)
    def SetPointParameter(*args): return _amanith.GMultiCurve1D_SetPointParameter(*args)
    def AddPoint(*args): return _amanith.GMultiCurve1D_AddPoint(*args)
    def RemovePoint(*args): return _amanith.GMultiCurve1D_RemovePoint(*args)
    def DerivativeLR(*args): return _amanith.GMultiCurve1D_DerivativeLR(*args)
    def TangentLR(*args): return _amanith.GMultiCurve1D_TangentLR(*args)
    def SpeedLR(*args): return _amanith.GMultiCurve1D_SpeedLR(*args)
    def ClassID(*args): return _amanith.GMultiCurve1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GMultiCurve1D_DerivedClassID(*args)
GMultiCurve1D_swigregister = _amanith.GMultiCurve1D_swigregister
GMultiCurve1D_swigregister(GMultiCurve1D)
G_CURVE1D_PROXY = cvar.G_CURVE1D_PROXY
G_MULTICURVE1D_CLASSID = cvar.G_MULTICURVE1D_CLASSID

class GMultiCurve1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMultiCurve1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GMultiCurve1DProxy, name)
    __repr__ = _swig_repr
    def ClassID(*args): return _amanith.GMultiCurve1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GMultiCurve1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GMultiCurve1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GMultiCurve1DProxy
    __del__ = lambda self : None;
GMultiCurve1DProxy_swigregister = _amanith.GMultiCurve1DProxy_swigregister
GMultiCurve1DProxy_swigregister(GMultiCurve1DProxy)

class GKnotMultiplicity(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKnotMultiplicity, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GKnotMultiplicity, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Value"] = _amanith.GKnotMultiplicity_Value_set
    __swig_getmethods__["Value"] = _amanith.GKnotMultiplicity_Value_get
    if _newclass:Value = property(_amanith.GKnotMultiplicity_Value_get, _amanith.GKnotMultiplicity_Value_set)
    __swig_setmethods__["Multiplicity"] = _amanith.GKnotMultiplicity_Multiplicity_set
    __swig_getmethods__["Multiplicity"] = _amanith.GKnotMultiplicity_Multiplicity_get
    if _newclass:Multiplicity = property(_amanith.GKnotMultiplicity_Multiplicity_get, _amanith.GKnotMultiplicity_Multiplicity_set)
    def __init__(self, *args): 
        this = _amanith.new_GKnotMultiplicity(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GKnotMultiplicity
    __del__ = lambda self : None;
GKnotMultiplicity_swigregister = _amanith.GKnotMultiplicity_swigregister
GKnotMultiplicity_swigregister(GKnotMultiplicity)
G_MULTICURVE1D_PROXY = cvar.G_MULTICURVE1D_PROXY
G_BSPLINECURVE1D_CLASSID = cvar.G_BSPLINECURVE1D_CLASSID

class GBSplineCurve1D(GCurve1D):
    __swig_setmethods__ = {}
    for _s in [GCurve1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GBSplineCurve1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GCurve1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GBSplineCurve1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GBSplineCurve1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GBSplineCurve1D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GBSplineCurve1D_Clear(*args)
    def PointsCount(*args): return _amanith.GBSplineCurve1D_PointsCount(*args)
    def Degree(*args): return _amanith.GBSplineCurve1D_Degree(*args)
    def Point(*args): return _amanith.GBSplineCurve1D_Point(*args)
    def Points(*args): return _amanith.GBSplineCurve1D_Points(*args)
    def Knots(*args): return _amanith.GBSplineCurve1D_Knots(*args)
    def Multiplicity(*args): return _amanith.GBSplineCurve1D_Multiplicity(*args)
    def FindSpan(*args): return _amanith.GBSplineCurve1D_FindSpan(*args)
    def FindSpanMult(*args): return _amanith.GBSplineCurve1D_FindSpanMult(*args)
    def Multiplicities(*args): return _amanith.GBSplineCurve1D_Multiplicities(*args)
    def SetPoint(*args): return _amanith.GBSplineCurve1D_SetPoint(*args)
    def SetPoints(*args): return _amanith.GBSplineCurve1D_SetPoints(*args)
    def SetDomain(*args): return _amanith.GBSplineCurve1D_SetDomain(*args)
    def KnotsCount(*args): return _amanith.GBSplineCurve1D_KnotsCount(*args)
    def HigherDegree(*args): return _amanith.GBSplineCurve1D_HigherDegree(*args)
    def LowerDegree(*args): return _amanith.GBSplineCurve1D_LowerDegree(*args)
    def InsertKnot(*args): return _amanith.GBSplineCurve1D_InsertKnot(*args)
    def EvaluateBasisFunc(*args): return _amanith.GBSplineCurve1D_EvaluateBasisFunc(*args)
    def Evaluate(*args): return _amanith.GBSplineCurve1D_Evaluate(*args)
    def Derivative(*args): return _amanith.GBSplineCurve1D_Derivative(*args)
    def GlobalNaturalFit(*args): return _amanith.GBSplineCurve1D_GlobalNaturalFit(*args)
    def GlobalFit(*args): return _amanith.GBSplineCurve1D_GlobalFit(*args)
    def ClassID(*args): return _amanith.GBSplineCurve1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GBSplineCurve1D_DerivedClassID(*args)
GBSplineCurve1D_swigregister = _amanith.GBSplineCurve1D_swigregister
GBSplineCurve1D_swigregister(GBSplineCurve1D)

class GBSplineCurve1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GBSplineCurve1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GBSplineCurve1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GBSplineCurve1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GBSplineCurve1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GBSplineCurve1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GBSplineCurve1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GBSplineCurve1DProxy
    __del__ = lambda self : None;
GBSplineCurve1DProxy_swigregister = _amanith.GBSplineCurve1DProxy_swigregister
GBSplineCurve1DProxy_swigregister(GBSplineCurve1DProxy)

class GHermiteKey1D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteKey1D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteKey1D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Parameter"] = _amanith.GHermiteKey1D_Parameter_set
    __swig_getmethods__["Parameter"] = _amanith.GHermiteKey1D_Parameter_get
    if _newclass:Parameter = property(_amanith.GHermiteKey1D_Parameter_get, _amanith.GHermiteKey1D_Parameter_set)
    __swig_setmethods__["Value"] = _amanith.GHermiteKey1D_Value_set
    __swig_getmethods__["Value"] = _amanith.GHermiteKey1D_Value_get
    if _newclass:Value = property(_amanith.GHermiteKey1D_Value_get, _amanith.GHermiteKey1D_Value_set)
    __swig_setmethods__["InTangent"] = _amanith.GHermiteKey1D_InTangent_set
    __swig_getmethods__["InTangent"] = _amanith.GHermiteKey1D_InTangent_get
    if _newclass:InTangent = property(_amanith.GHermiteKey1D_InTangent_get, _amanith.GHermiteKey1D_InTangent_set)
    __swig_setmethods__["OutTangent"] = _amanith.GHermiteKey1D_OutTangent_set
    __swig_getmethods__["OutTangent"] = _amanith.GHermiteKey1D_OutTangent_get
    if _newclass:OutTangent = property(_amanith.GHermiteKey1D_OutTangent_get, _amanith.GHermiteKey1D_OutTangent_set)
    def __init__(self, *args): 
        this = _amanith.new_GHermiteKey1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteKey1D
    __del__ = lambda self : None;
GHermiteKey1D_swigregister = _amanith.GHermiteKey1D_swigregister
GHermiteKey1D_swigregister(GHermiteKey1D)
G_BSPLINECURVE1D_PROXY = cvar.G_BSPLINECURVE1D_PROXY
G_HERMITECURVE1D_CLASSID = cvar.G_HERMITECURVE1D_CLASSID

class GHermiteCurve1D(GMultiCurve1D):
    __swig_setmethods__ = {}
    for _s in [GMultiCurve1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteCurve1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiCurve1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteCurve1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GHermiteCurve1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteCurve1D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GHermiteCurve1D_Clear(*args)
    def PointsCount(*args): return _amanith.GHermiteCurve1D_PointsCount(*args)
    def ParamToKeyIndex(*args): return _amanith.GHermiteCurve1D_ParamToKeyIndex(*args)
    def Point(*args): return _amanith.GHermiteCurve1D_Point(*args)
    def SetPoint(*args): return _amanith.GHermiteCurve1D_SetPoint(*args)
    def SetPoints(*args): return _amanith.GHermiteCurve1D_SetPoints(*args)
    def Key(*args): return _amanith.GHermiteCurve1D_Key(*args)
    def Keys(*args): return _amanith.GHermiteCurve1D_Keys(*args)
    def SetKeys(*args): return _amanith.GHermiteCurve1D_SetKeys(*args)
    def SetKey(*args): return _amanith.GHermiteCurve1D_SetKey(*args)
    def RecalcSmoothTangents(*args): return _amanith.GHermiteCurve1D_RecalcSmoothTangents(*args)
    def SetDomain(*args): return _amanith.GHermiteCurve1D_SetDomain(*args)
    def Length(*args): return _amanith.GHermiteCurve1D_Length(*args)
    def Evaluate(*args): return _amanith.GHermiteCurve1D_Evaluate(*args)
    def Derivative(*args): return _amanith.GHermiteCurve1D_Derivative(*args)
    def DerivativeLR(*args): return _amanith.GHermiteCurve1D_DerivativeLR(*args)
    def SegmentToBezier(*args): return _amanith.GHermiteCurve1D_SegmentToBezier(*args)
    def Scale(*args): return _amanith.GHermiteCurve1D_Scale(*args)
    def ClassID(*args): return _amanith.GHermiteCurve1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GHermiteCurve1D_DerivedClassID(*args)
GHermiteCurve1D_swigregister = _amanith.GHermiteCurve1D_swigregister
GHermiteCurve1D_swigregister(GHermiteCurve1D)

class GHermiteCurve1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteCurve1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteCurve1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GHermiteCurve1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GHermiteCurve1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GHermiteCurve1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GHermiteCurve1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteCurve1DProxy
    __del__ = lambda self : None;
GHermiteCurve1DProxy_swigregister = _amanith.GHermiteCurve1DProxy_swigregister
GHermiteCurve1DProxy_swigregister(GHermiteCurve1DProxy)

class GPolyLineKey1D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPolyLineKey1D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPolyLineKey1D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Parameter"] = _amanith.GPolyLineKey1D_Parameter_set
    __swig_getmethods__["Parameter"] = _amanith.GPolyLineKey1D_Parameter_get
    if _newclass:Parameter = property(_amanith.GPolyLineKey1D_Parameter_get, _amanith.GPolyLineKey1D_Parameter_set)
    __swig_setmethods__["Value"] = _amanith.GPolyLineKey1D_Value_set
    __swig_getmethods__["Value"] = _amanith.GPolyLineKey1D_Value_get
    if _newclass:Value = property(_amanith.GPolyLineKey1D_Value_get, _amanith.GPolyLineKey1D_Value_set)
    def __init__(self, *args): 
        this = _amanith.new_GPolyLineKey1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPolyLineKey1D
    __del__ = lambda self : None;
GPolyLineKey1D_swigregister = _amanith.GPolyLineKey1D_swigregister
GPolyLineKey1D_swigregister(GPolyLineKey1D)
G_HERMITECURVE1D_PROXY = cvar.G_HERMITECURVE1D_PROXY
G_POLYLINECURVE1D_CLASSID = cvar.G_POLYLINECURVE1D_CLASSID

class GPolyLineCurve1D(GMultiCurve1D):
    __swig_setmethods__ = {}
    for _s in [GMultiCurve1D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPolyLineCurve1D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiCurve1D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPolyLineCurve1D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPolyLineCurve1D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPolyLineCurve1D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GPolyLineCurve1D_Clear(*args)
    def PointsCount(*args): return _amanith.GPolyLineCurve1D_PointsCount(*args)
    def ParamToKeyIndex(*args): return _amanith.GPolyLineCurve1D_ParamToKeyIndex(*args)
    def Point(*args): return _amanith.GPolyLineCurve1D_Point(*args)
    def SetPoint(*args): return _amanith.GPolyLineCurve1D_SetPoint(*args)
    def SetPoints(*args): return _amanith.GPolyLineCurve1D_SetPoints(*args)
    def Key(*args): return _amanith.GPolyLineCurve1D_Key(*args)
    def Keys(*args): return _amanith.GPolyLineCurve1D_Keys(*args)
    def SetKeys(*args): return _amanith.GPolyLineCurve1D_SetKeys(*args)
    def SetKey(*args): return _amanith.GPolyLineCurve1D_SetKey(*args)
    def SetDomain(*args): return _amanith.GPolyLineCurve1D_SetDomain(*args)
    def Length(*args): return _amanith.GPolyLineCurve1D_Length(*args)
    def Evaluate(*args): return _amanith.GPolyLineCurve1D_Evaluate(*args)
    def Derivative(*args): return _amanith.GPolyLineCurve1D_Derivative(*args)
    def DerivativeLR(*args): return _amanith.GPolyLineCurve1D_DerivativeLR(*args)
    def ClassID(*args): return _amanith.GPolyLineCurve1D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPolyLineCurve1D_DerivedClassID(*args)
GPolyLineCurve1D_swigregister = _amanith.GPolyLineCurve1D_swigregister
GPolyLineCurve1D_swigregister(GPolyLineCurve1D)

class GPolyLineCurve1DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPolyLineCurve1DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPolyLineCurve1DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GPolyLineCurve1DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GPolyLineCurve1DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPolyLineCurve1DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPolyLineCurve1DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPolyLineCurve1DProxy
    __del__ = lambda self : None;
GPolyLineCurve1DProxy_swigregister = _amanith.GPolyLineCurve1DProxy_swigregister
GPolyLineCurve1DProxy_swigregister(GPolyLineCurve1DProxy)

class GCurve2D(GElement):
    __swig_setmethods__ = {}
    for _s in [GElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GCurve2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GCurve2D, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GCurve2D
    __del__ = lambda self : None;
    def DomainStart(*args): return _amanith.GCurve2D_DomainStart(*args)
    def DomainEnd(*args): return _amanith.GCurve2D_DomainEnd(*args)
    def Domain(*args): return _amanith.GCurve2D_Domain(*args)
    def SetDomain(*args): return _amanith.GCurve2D_SetDomain(*args)
    def PointsCount(*args): return _amanith.GCurve2D_PointsCount(*args)
    def Clear(*args): return _amanith.GCurve2D_Clear(*args)
    def Point(*args): return _amanith.GCurve2D_Point(*args)
    def SetPoint(*args): return _amanith.GCurve2D_SetPoint(*args)
    def IntersectRay(*args): return _amanith.GCurve2D_IntersectRay(*args)
    def Flatten(*args): return _amanith.GCurve2D_Flatten(*args)
    def Evaluate(*args): return _amanith.GCurve2D_Evaluate(*args)
    def Derivative(*args): return _amanith.GCurve2D_Derivative(*args)
    def GlobalParameter(*args): return _amanith.GCurve2D_GlobalParameter(*args)
    def Length(*args): return _amanith.GCurve2D_Length(*args)
    def TotalLength(*args): return _amanith.GCurve2D_TotalLength(*args)
    def Cut(*args): return _amanith.GCurve2D_Cut(*args)
    def CutByLength(*args): return _amanith.GCurve2D_CutByLength(*args)
    def Tangent(*args): return _amanith.GCurve2D_Tangent(*args)
    def Normal(*args): return _amanith.GCurve2D_Normal(*args)
    def Curvature(*args): return _amanith.GCurve2D_Curvature(*args)
    def Speed(*args): return _amanith.GCurve2D_Speed(*args)
    def Variation(*args): return _amanith.GCurve2D_Variation(*args)
    def StartPoint(*args): return _amanith.GCurve2D_StartPoint(*args)
    def EndPoint(*args): return _amanith.GCurve2D_EndPoint(*args)
    def SetStartPoint(*args): return _amanith.GCurve2D_SetStartPoint(*args)
    def SetEndPoint(*args): return _amanith.GCurve2D_SetEndPoint(*args)
    def Translate(*args): return _amanith.GCurve2D_Translate(*args)
    def Rotate(*args): return _amanith.GCurve2D_Rotate(*args)
    def Scale(*args): return _amanith.GCurve2D_Scale(*args)
    def XForm(*args): return _amanith.GCurve2D_XForm(*args)
    def ClassID(*args): return _amanith.GCurve2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GCurve2D_DerivedClassID(*args)
GCurve2D_swigregister = _amanith.GCurve2D_swigregister
GCurve2D_swigregister(GCurve2D)
G_POLYLINECURVE1D_PROXY = cvar.G_POLYLINECURVE1D_PROXY
G_CURVE2D_CLASSID = cvar.G_CURVE2D_CLASSID

class GCurve2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GCurve2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GCurve2DProxy, name)
    __repr__ = _swig_repr
    def ClassID(*args): return _amanith.GCurve2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GCurve2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GCurve2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GCurve2DProxy
    __del__ = lambda self : None;
GCurve2DProxy_swigregister = _amanith.GCurve2DProxy_swigregister
GCurve2DProxy_swigregister(GCurve2DProxy)

class GMultiCurve2D(GCurve2D):
    __swig_setmethods__ = {}
    for _s in [GCurve2D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMultiCurve2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GCurve2D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GMultiCurve2D, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GMultiCurve2D
    __del__ = lambda self : None;
    def PointParameter(*args): return _amanith.GMultiCurve2D_PointParameter(*args)
    def SetPointParameter(*args): return _amanith.GMultiCurve2D_SetPointParameter(*args)
    def AddPoint(*args): return _amanith.GMultiCurve2D_AddPoint(*args)
    def RemovePoint(*args): return _amanith.GMultiCurve2D_RemovePoint(*args)
    def DerivativeLR(*args): return _amanith.GMultiCurve2D_DerivativeLR(*args)
    def TangentLR(*args): return _amanith.GMultiCurve2D_TangentLR(*args)
    def NormalLR(*args): return _amanith.GMultiCurve2D_NormalLR(*args)
    def CurvatureLR(*args): return _amanith.GMultiCurve2D_CurvatureLR(*args)
    def SpeedLR(*args): return _amanith.GMultiCurve2D_SpeedLR(*args)
    def ClassID(*args): return _amanith.GMultiCurve2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GMultiCurve2D_DerivedClassID(*args)
GMultiCurve2D_swigregister = _amanith.GMultiCurve2D_swigregister
GMultiCurve2D_swigregister(GMultiCurve2D)
G_CURVE2D_PROXY = cvar.G_CURVE2D_PROXY
G_MULTICURVE2D_CLASSID = cvar.G_MULTICURVE2D_CLASSID

class GMultiCurve2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMultiCurve2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GMultiCurve2DProxy, name)
    __repr__ = _swig_repr
    def ClassID(*args): return _amanith.GMultiCurve2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GMultiCurve2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GMultiCurve2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GMultiCurve2DProxy
    __del__ = lambda self : None;
GMultiCurve2DProxy_swigregister = _amanith.GMultiCurve2DProxy_swigregister
GMultiCurve2DProxy_swigregister(GMultiCurve2DProxy)

G_LOCAL_SPACE = _amanith.G_LOCAL_SPACE
G_WORLD_SPACE = _amanith.G_WORLD_SPACE
class GAnimTRSNode2D(GAnimElement):
    __swig_setmethods__ = {}
    for _s in [GAnimElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAnimTRSNode2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GAnimElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GAnimTRSNode2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GAnimTRSNode2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GAnimTRSNode2D
    __del__ = lambda self : None;
    def CustomData(*args): return _amanith.GAnimTRSNode2D_CustomData(*args)
    def SetCustomData(*args): return _amanith.GAnimTRSNode2D_SetCustomData(*args)
    def Father(*args): return _amanith.GAnimTRSNode2D_Father(*args)
    def SetFather(*args): return _amanith.GAnimTRSNode2D_SetFather(*args)
    def IsRoot(*args): return _amanith.GAnimTRSNode2D_IsRoot(*args)
    def IsLeaf(*args): return _amanith.GAnimTRSNode2D_IsLeaf(*args)
    def ChildrenCounts(*args): return _amanith.GAnimTRSNode2D_ChildrenCounts(*args)
    def Child(*args): return _amanith.GAnimTRSNode2D_Child(*args)
    def PivotMatrix(*args): return _amanith.GAnimTRSNode2D_PivotMatrix(*args)
    def InversePivotMatrix(*args): return _amanith.GAnimTRSNode2D_InversePivotMatrix(*args)
    def Matrix(*args): return _amanith.GAnimTRSNode2D_Matrix(*args)
    def InverseMatrix(*args): return _amanith.GAnimTRSNode2D_InverseMatrix(*args)
    def Position(*args): return _amanith.GAnimTRSNode2D_Position(*args)
    def SetPosition(*args): return _amanith.GAnimTRSNode2D_SetPosition(*args)
    def Rotation(*args): return _amanith.GAnimTRSNode2D_Rotation(*args)
    def SetRotation(*args): return _amanith.GAnimTRSNode2D_SetRotation(*args)
    def Scale(*args): return _amanith.GAnimTRSNode2D_Scale(*args)
    def SetScale(*args): return _amanith.GAnimTRSNode2D_SetScale(*args)
    def PivotPosition(*args): return _amanith.GAnimTRSNode2D_PivotPosition(*args)
    def SetPivotPosition(*args): return _amanith.GAnimTRSNode2D_SetPivotPosition(*args)
    def PivotRotation(*args): return _amanith.GAnimTRSNode2D_PivotRotation(*args)
    def SetPivotRotation(*args): return _amanith.GAnimTRSNode2D_SetPivotRotation(*args)
    def PivotScale(*args): return _amanith.GAnimTRSNode2D_PivotScale(*args)
    def SetPivotScale(*args): return _amanith.GAnimTRSNode2D_SetPivotScale(*args)
    def ClassID(*args): return _amanith.GAnimTRSNode2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GAnimTRSNode2D_DerivedClassID(*args)
GAnimTRSNode2D_swigregister = _amanith.GAnimTRSNode2D_swigregister
GAnimTRSNode2D_swigregister(GAnimTRSNode2D)
G_MULTICURVE2D_PROXY = cvar.G_MULTICURVE2D_PROXY
G_ANIMTRSNODE2D_CLASSID = cvar.G_ANIMTRSNODE2D_CLASSID

class GAnimTRSNode2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAnimTRSNode2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GAnimTRSNode2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GAnimTRSNode2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GAnimTRSNode2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GAnimTRSNode2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GAnimTRSNode2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GAnimTRSNode2DProxy
    __del__ = lambda self : None;
GAnimTRSNode2DProxy_swigregister = _amanith.GAnimTRSNode2DProxy_swigregister
GAnimTRSNode2DProxy_swigregister(GAnimTRSNode2DProxy)

class GBezierCurve2D(GCurve2D):
    __swig_setmethods__ = {}
    for _s in [GCurve2D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GBezierCurve2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GCurve2D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GBezierCurve2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GBezierCurve2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GBezierCurve2D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GBezierCurve2D_Clear(*args)
    def PointsCount(*args): return _amanith.GBezierCurve2D_PointsCount(*args)
    def Degree(*args): return _amanith.GBezierCurve2D_Degree(*args)
    def Points(*args): return _amanith.GBezierCurve2D_Points(*args)
    def Point(*args): return _amanith.GBezierCurve2D_Point(*args)
    def SetPoint(*args): return _amanith.GBezierCurve2D_SetPoint(*args)
    def SetPoints(*args): return _amanith.GBezierCurve2D_SetPoints(*args)
    def SetDomain(*args): return _amanith.GBezierCurve2D_SetDomain(*args)
    def HigherDegree(*args): return _amanith.GBezierCurve2D_HigherDegree(*args)
    def LowerDegree(*args): return _amanith.GBezierCurve2D_LowerDegree(*args)
    def IntersectRay(*args): return _amanith.GBezierCurve2D_IntersectRay(*args)
    def CrossingCount(*args): return _amanith.GBezierCurve2D_CrossingCount(*args)
    def ControlPolygonLength(*args): return _amanith.GBezierCurve2D_ControlPolygonLength(*args)
    def Flatten(*args): return _amanith.GBezierCurve2D_Flatten(*args)
    def Variation(*args): return _amanith.GBezierCurve2D_Variation(*args)
    def Evaluate(*args): return _amanith.GBezierCurve2D_Evaluate(*args)
    def Derivative(*args): return _amanith.GBezierCurve2D_Derivative(*args)
    def ConvertToHermite(*args): return _amanith.GBezierCurve2D_ConvertToHermite(*args)
    def ClassID(*args): return _amanith.GBezierCurve2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GBezierCurve2D_DerivedClassID(*args)
GBezierCurve2D_swigregister = _amanith.GBezierCurve2D_swigregister
GBezierCurve2D_swigregister(GBezierCurve2D)
G_ANIMTRSNODE2D_PROXY = cvar.G_ANIMTRSNODE2D_PROXY
G_BEZIERCURVE2D_CLASSID = cvar.G_BEZIERCURVE2D_CLASSID

class GBezierCurve2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GBezierCurve2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GBezierCurve2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GBezierCurve2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GBezierCurve2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GBezierCurve2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GBezierCurve2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GBezierCurve2DProxy
    __del__ = lambda self : None;
GBezierCurve2DProxy_swigregister = _amanith.GBezierCurve2DProxy_swigregister
GBezierCurve2DProxy_swigregister(GBezierCurve2DProxy)

class GBSplineCurve2D(GCurve2D):
    __swig_setmethods__ = {}
    for _s in [GCurve2D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GBSplineCurve2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GCurve2D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GBSplineCurve2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GBSplineCurve2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GBSplineCurve2D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GBSplineCurve2D_Clear(*args)
    def PointsCount(*args): return _amanith.GBSplineCurve2D_PointsCount(*args)
    def Degree(*args): return _amanith.GBSplineCurve2D_Degree(*args)
    def Point(*args): return _amanith.GBSplineCurve2D_Point(*args)
    def Points(*args): return _amanith.GBSplineCurve2D_Points(*args)
    def Knots(*args): return _amanith.GBSplineCurve2D_Knots(*args)
    def Multiplicity(*args): return _amanith.GBSplineCurve2D_Multiplicity(*args)
    def FindSpan(*args): return _amanith.GBSplineCurve2D_FindSpan(*args)
    def FindSpanMult(*args): return _amanith.GBSplineCurve2D_FindSpanMult(*args)
    def Multiplicities(*args): return _amanith.GBSplineCurve2D_Multiplicities(*args)
    def SetPoint(*args): return _amanith.GBSplineCurve2D_SetPoint(*args)
    def SetPoints(*args): return _amanith.GBSplineCurve2D_SetPoints(*args)
    def SetDomain(*args): return _amanith.GBSplineCurve2D_SetDomain(*args)
    def KnotsCount(*args): return _amanith.GBSplineCurve2D_KnotsCount(*args)
    def ControlPolygonLength(*args): return _amanith.GBSplineCurve2D_ControlPolygonLength(*args)
    def HigherDegree(*args): return _amanith.GBSplineCurve2D_HigherDegree(*args)
    def LowerDegree(*args): return _amanith.GBSplineCurve2D_LowerDegree(*args)
    def CrossingCount(*args): return _amanith.GBSplineCurve2D_CrossingCount(*args)
    def IntersectRay(*args): return _amanith.GBSplineCurve2D_IntersectRay(*args)
    def InsertKnot(*args): return _amanith.GBSplineCurve2D_InsertKnot(*args)
    def Flatten(*args): return _amanith.GBSplineCurve2D_Flatten(*args)
    def Variation(*args): return _amanith.GBSplineCurve2D_Variation(*args)
    def EvaluateBasisFunc(*args): return _amanith.GBSplineCurve2D_EvaluateBasisFunc(*args)
    def Evaluate(*args): return _amanith.GBSplineCurve2D_Evaluate(*args)
    def Derivative(*args): return _amanith.GBSplineCurve2D_Derivative(*args)
    def GlobalNaturalFit(*args): return _amanith.GBSplineCurve2D_GlobalNaturalFit(*args)
    def GlobalFit(*args): return _amanith.GBSplineCurve2D_GlobalFit(*args)
    def ClassID(*args): return _amanith.GBSplineCurve2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GBSplineCurve2D_DerivedClassID(*args)
GBSplineCurve2D_swigregister = _amanith.GBSplineCurve2D_swigregister
GBSplineCurve2D_swigregister(GBSplineCurve2D)
G_BEZIERCURVE2D_PROXY = cvar.G_BEZIERCURVE2D_PROXY
G_BSPLINECURVE2D_CLASSID = cvar.G_BSPLINECURVE2D_CLASSID

class GBSplineCurve2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GBSplineCurve2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GBSplineCurve2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GBSplineCurve2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GBSplineCurve2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GBSplineCurve2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GBSplineCurve2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GBSplineCurve2DProxy
    __del__ = lambda self : None;
GBSplineCurve2DProxy_swigregister = _amanith.GBSplineCurve2DProxy_swigregister
GBSplineCurve2DProxy_swigregister(GBSplineCurve2DProxy)

class GEllipseCurve2D(GCurve2D):
    __swig_setmethods__ = {}
    for _s in [GCurve2D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GEllipseCurve2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GCurve2D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GEllipseCurve2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GEllipseCurve2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GEllipseCurve2D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GEllipseCurve2D_Clear(*args)
    def PointsCount(*args): return _amanith.GEllipseCurve2D_PointsCount(*args)
    def Point(*args): return _amanith.GEllipseCurve2D_Point(*args)
    def SetPoint(*args): return _amanith.GEllipseCurve2D_SetPoint(*args)
    def SetEllipse(*args): return _amanith.GEllipseCurve2D_SetEllipse(*args)
    def Center(*args): return _amanith.GEllipseCurve2D_Center(*args)
    def SetCenter(*args): return _amanith.GEllipseCurve2D_SetCenter(*args)
    def XSemiAxisLength(*args): return _amanith.GEllipseCurve2D_XSemiAxisLength(*args)
    def SetXSemiAxisLength(*args): return _amanith.GEllipseCurve2D_SetXSemiAxisLength(*args)
    def YSemiAxisLength(*args): return _amanith.GEllipseCurve2D_YSemiAxisLength(*args)
    def SetYSemiAxisLength(*args): return _amanith.GEllipseCurve2D_SetYSemiAxisLength(*args)
    def OffsetRotation(*args): return _amanith.GEllipseCurve2D_OffsetRotation(*args)
    def SetOffsetRotation(*args): return _amanith.GEllipseCurve2D_SetOffsetRotation(*args)
    def StartAngle(*args): return _amanith.GEllipseCurve2D_StartAngle(*args)
    def EndAngle(*args): return _amanith.GEllipseCurve2D_EndAngle(*args)
    def SetAngleDomain(*args): return _amanith.GEllipseCurve2D_SetAngleDomain(*args)
    def IntersectRay(*args): return _amanith.GEllipseCurve2D_IntersectRay(*args)
    def Flatten(*args): return _amanith.GEllipseCurve2D_Flatten(*args)
    def LargeArc(*args): return _amanith.GEllipseCurve2D_LargeArc(*args)
    def Variation(*args): return _amanith.GEllipseCurve2D_Variation(*args)
    def Evaluate(*args): return _amanith.GEllipseCurve2D_Evaluate(*args)
    def Derivative(*args): return _amanith.GEllipseCurve2D_Derivative(*args)
    def Translate(*args): return _amanith.GEllipseCurve2D_Translate(*args)
    def Rotate(*args): return _amanith.GEllipseCurve2D_Rotate(*args)
    def Scale(*args): return _amanith.GEllipseCurve2D_Scale(*args)
    def XForm(*args): return _amanith.GEllipseCurve2D_XForm(*args)
    def ClassID(*args): return _amanith.GEllipseCurve2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GEllipseCurve2D_DerivedClassID(*args)
GEllipseCurve2D_swigregister = _amanith.GEllipseCurve2D_swigregister
GEllipseCurve2D_swigregister(GEllipseCurve2D)
G_BSPLINECURVE2D_PROXY = cvar.G_BSPLINECURVE2D_PROXY
G_ELLIPSECURVE2D_CLASSID = cvar.G_ELLIPSECURVE2D_CLASSID

class GEllipseCurve2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GEllipseCurve2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GEllipseCurve2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GEllipseCurve2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GEllipseCurve2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GEllipseCurve2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GEllipseCurve2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GEllipseCurve2DProxy
    __del__ = lambda self : None;
GEllipseCurve2DProxy_swigregister = _amanith.GEllipseCurve2DProxy_swigregister
GEllipseCurve2DProxy_swigregister(GEllipseCurve2DProxy)

class GHermiteKey2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteKey2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteKey2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Parameter"] = _amanith.GHermiteKey2D_Parameter_set
    __swig_getmethods__["Parameter"] = _amanith.GHermiteKey2D_Parameter_get
    if _newclass:Parameter = property(_amanith.GHermiteKey2D_Parameter_get, _amanith.GHermiteKey2D_Parameter_set)
    __swig_setmethods__["Value"] = _amanith.GHermiteKey2D_Value_set
    __swig_getmethods__["Value"] = _amanith.GHermiteKey2D_Value_get
    if _newclass:Value = property(_amanith.GHermiteKey2D_Value_get, _amanith.GHermiteKey2D_Value_set)
    __swig_setmethods__["InTangent"] = _amanith.GHermiteKey2D_InTangent_set
    __swig_getmethods__["InTangent"] = _amanith.GHermiteKey2D_InTangent_get
    if _newclass:InTangent = property(_amanith.GHermiteKey2D_InTangent_get, _amanith.GHermiteKey2D_InTangent_set)
    __swig_setmethods__["OutTangent"] = _amanith.GHermiteKey2D_OutTangent_set
    __swig_getmethods__["OutTangent"] = _amanith.GHermiteKey2D_OutTangent_get
    if _newclass:OutTangent = property(_amanith.GHermiteKey2D_OutTangent_get, _amanith.GHermiteKey2D_OutTangent_set)
    def __init__(self, *args): 
        this = _amanith.new_GHermiteKey2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteKey2D
    __del__ = lambda self : None;
GHermiteKey2D_swigregister = _amanith.GHermiteKey2D_swigregister
GHermiteKey2D_swigregister(GHermiteKey2D)
G_ELLIPSECURVE2D_PROXY = cvar.G_ELLIPSECURVE2D_PROXY
G_HERMITECURVE2D_CLASSID = cvar.G_HERMITECURVE2D_CLASSID

class GHermiteCurve2D(GMultiCurve2D):
    __swig_setmethods__ = {}
    for _s in [GMultiCurve2D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteCurve2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiCurve2D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteCurve2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GHermiteCurve2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteCurve2D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GHermiteCurve2D_Clear(*args)
    def PointsCount(*args): return _amanith.GHermiteCurve2D_PointsCount(*args)
    def ParamToKeyIndex(*args): return _amanith.GHermiteCurve2D_ParamToKeyIndex(*args)
    def Point(*args): return _amanith.GHermiteCurve2D_Point(*args)
    def SetPoint(*args): return _amanith.GHermiteCurve2D_SetPoint(*args)
    def SetPoints(*args): return _amanith.GHermiteCurve2D_SetPoints(*args)
    def Key(*args): return _amanith.GHermiteCurve2D_Key(*args)
    def Keys(*args): return _amanith.GHermiteCurve2D_Keys(*args)
    def SetKeys(*args): return _amanith.GHermiteCurve2D_SetKeys(*args)
    def SetKey(*args): return _amanith.GHermiteCurve2D_SetKey(*args)
    def RecalcSmoothTangents(*args): return _amanith.GHermiteCurve2D_RecalcSmoothTangents(*args)
    def SetDomain(*args): return _amanith.GHermiteCurve2D_SetDomain(*args)
    def IntersectRay(*args): return _amanith.GHermiteCurve2D_IntersectRay(*args)
    def Length(*args): return _amanith.GHermiteCurve2D_Length(*args)
    def Evaluate(*args): return _amanith.GHermiteCurve2D_Evaluate(*args)
    def Derivative(*args): return _amanith.GHermiteCurve2D_Derivative(*args)
    def DerivativeLR(*args): return _amanith.GHermiteCurve2D_DerivativeLR(*args)
    def SegmentToBezier(*args): return _amanith.GHermiteCurve2D_SegmentToBezier(*args)
    def Flatten(*args): return _amanith.GHermiteCurve2D_Flatten(*args)
    def Variation(*args): return _amanith.GHermiteCurve2D_Variation(*args)
    def XForm(*args): return _amanith.GHermiteCurve2D_XForm(*args)
    def ClassID(*args): return _amanith.GHermiteCurve2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GHermiteCurve2D_DerivedClassID(*args)
GHermiteCurve2D_swigregister = _amanith.GHermiteCurve2D_swigregister
GHermiteCurve2D_swigregister(GHermiteCurve2D)

class GHermiteCurve2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GHermiteCurve2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GHermiteCurve2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GHermiteCurve2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GHermiteCurve2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GHermiteCurve2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GHermiteCurve2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GHermiteCurve2DProxy
    __del__ = lambda self : None;
GHermiteCurve2DProxy_swigregister = _amanith.GHermiteCurve2DProxy_swigregister
GHermiteCurve2DProxy_swigregister(GHermiteCurve2DProxy)

class GFontCharContour2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFontCharContour2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GFontCharContour2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GFontCharContour2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFontCharContour2D
    __del__ = lambda self : None;
    def IsHole(*args): return _amanith.GFontCharContour2D_IsHole(*args)
    def BoundBox(*args): return _amanith.GFontCharContour2D_BoundBox(*args)
    def Points(*args): return _amanith.GFontCharContour2D_Points(*args)
    def PointsFlags(*args): return _amanith.GFontCharContour2D_PointsFlags(*args)
    def PointsCount(*args): return _amanith.GFontCharContour2D_PointsCount(*args)
    def DrawContour(*args): return _amanith.GFontCharContour2D_DrawContour(*args)
    def DecomposeBezier(*args): return _amanith.GFontCharContour2D_DecomposeBezier(*args)
    def ConvertToPath(*args): return _amanith.GFontCharContour2D_ConvertToPath(*args)
    def PickPointOnCurve(*args): return _amanith.GFontCharContour2D_PickPointOnCurve(*args)
    def IntersectionsCount(*args): return _amanith.GFontCharContour2D_IntersectionsCount(*args)
GFontCharContour2D_swigregister = _amanith.GFontCharContour2D_swigregister
GFontCharContour2D_swigregister(GFontCharContour2D)
G_HERMITECURVE2D_PROXY = cvar.G_HERMITECURVE2D_PROXY

class GSubChar2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GSubChar2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GSubChar2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["GlyphIndex"] = _amanith.GSubChar2D_GlyphIndex_set
    __swig_getmethods__["GlyphIndex"] = _amanith.GSubChar2D_GlyphIndex_get
    if _newclass:GlyphIndex = property(_amanith.GSubChar2D_GlyphIndex_get, _amanith.GSubChar2D_GlyphIndex_set)
    __swig_setmethods__["Flags"] = _amanith.GSubChar2D_Flags_set
    __swig_getmethods__["Flags"] = _amanith.GSubChar2D_Flags_get
    if _newclass:Flags = property(_amanith.GSubChar2D_Flags_get, _amanith.GSubChar2D_Flags_set)
    __swig_setmethods__["Transformation"] = _amanith.GSubChar2D_Transformation_set
    __swig_getmethods__["Transformation"] = _amanith.GSubChar2D_Transformation_get
    if _newclass:Transformation = property(_amanith.GSubChar2D_Transformation_get, _amanith.GSubChar2D_Transformation_set)
    def __init__(self, *args): 
        this = _amanith.new_GSubChar2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GSubChar2D
    __del__ = lambda self : None;
GSubChar2D_swigregister = _amanith.GSubChar2D_swigregister
GSubChar2D_swigregister(GSubChar2D)

class GGlyphMetrics(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GGlyphMetrics, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GGlyphMetrics, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Width"] = _amanith.GGlyphMetrics_Width_set
    __swig_getmethods__["Width"] = _amanith.GGlyphMetrics_Width_get
    if _newclass:Width = property(_amanith.GGlyphMetrics_Width_get, _amanith.GGlyphMetrics_Width_set)
    __swig_setmethods__["Height"] = _amanith.GGlyphMetrics_Height_set
    __swig_getmethods__["Height"] = _amanith.GGlyphMetrics_Height_get
    if _newclass:Height = property(_amanith.GGlyphMetrics_Height_get, _amanith.GGlyphMetrics_Height_set)
    __swig_setmethods__["HoriBearingX"] = _amanith.GGlyphMetrics_HoriBearingX_set
    __swig_getmethods__["HoriBearingX"] = _amanith.GGlyphMetrics_HoriBearingX_get
    if _newclass:HoriBearingX = property(_amanith.GGlyphMetrics_HoriBearingX_get, _amanith.GGlyphMetrics_HoriBearingX_set)
    __swig_setmethods__["HoriBearingY"] = _amanith.GGlyphMetrics_HoriBearingY_set
    __swig_getmethods__["HoriBearingY"] = _amanith.GGlyphMetrics_HoriBearingY_get
    if _newclass:HoriBearingY = property(_amanith.GGlyphMetrics_HoriBearingY_get, _amanith.GGlyphMetrics_HoriBearingY_set)
    __swig_setmethods__["HoriAdvance"] = _amanith.GGlyphMetrics_HoriAdvance_set
    __swig_getmethods__["HoriAdvance"] = _amanith.GGlyphMetrics_HoriAdvance_get
    if _newclass:HoriAdvance = property(_amanith.GGlyphMetrics_HoriAdvance_get, _amanith.GGlyphMetrics_HoriAdvance_set)
    __swig_setmethods__["VertBearingX"] = _amanith.GGlyphMetrics_VertBearingX_set
    __swig_getmethods__["VertBearingX"] = _amanith.GGlyphMetrics_VertBearingX_get
    if _newclass:VertBearingX = property(_amanith.GGlyphMetrics_VertBearingX_get, _amanith.GGlyphMetrics_VertBearingX_set)
    __swig_setmethods__["VertBearingY"] = _amanith.GGlyphMetrics_VertBearingY_set
    __swig_getmethods__["VertBearingY"] = _amanith.GGlyphMetrics_VertBearingY_get
    if _newclass:VertBearingY = property(_amanith.GGlyphMetrics_VertBearingY_get, _amanith.GGlyphMetrics_VertBearingY_set)
    __swig_setmethods__["VertAdvance"] = _amanith.GGlyphMetrics_VertAdvance_set
    __swig_getmethods__["VertAdvance"] = _amanith.GGlyphMetrics_VertAdvance_get
    if _newclass:VertAdvance = property(_amanith.GGlyphMetrics_VertAdvance_get, _amanith.GGlyphMetrics_VertAdvance_set)
    def __init__(self, *args): 
        this = _amanith.new_GGlyphMetrics(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GGlyphMetrics
    __del__ = lambda self : None;
GGlyphMetrics_swigregister = _amanith.GGlyphMetrics_swigregister
GGlyphMetrics_swigregister(GGlyphMetrics)

class GFontChar2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFontChar2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GFontChar2D, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    def ContoursCount(*args): return _amanith.GFontChar2D_ContoursCount(*args)
    def Contour(*args): return _amanith.GFontChar2D_Contour(*args)
    def SubCharsCount(*args): return _amanith.GFontChar2D_SubCharsCount(*args)
    def SubChar(*args): return _amanith.GFontChar2D_SubChar(*args)
    def ConvertToPaths(*args): return _amanith.GFontChar2D_ConvertToPaths(*args)
    def LinearHoriAdvance(*args): return _amanith.GFontChar2D_LinearHoriAdvance(*args)
    def SetLinearHoriAdvance(*args): return _amanith.GFontChar2D_SetLinearHoriAdvance(*args)
    def LinearVertAdvance(*args): return _amanith.GFontChar2D_LinearVertAdvance(*args)
    def SetLinearVertAdvance(*args): return _amanith.GFontChar2D_SetLinearVertAdvance(*args)
    def Advance(*args): return _amanith.GFontChar2D_Advance(*args)
    def SetAdvance(*args): return _amanith.GFontChar2D_SetAdvance(*args)
    def LSBDelta(*args): return _amanith.GFontChar2D_LSBDelta(*args)
    def SetLSBDelta(*args): return _amanith.GFontChar2D_SetLSBDelta(*args)
    def RSBDelta(*args): return _amanith.GFontChar2D_RSBDelta(*args)
    def SetRSBDelta(*args): return _amanith.GFontChar2D_SetRSBDelta(*args)
    def GlyphMetrics(*args): return _amanith.GFontChar2D_GlyphMetrics(*args)
    def SetMetrics(*args): return _amanith.GFontChar2D_SetMetrics(*args)
    def EvenOddFill(*args): return _amanith.GFontChar2D_EvenOddFill(*args)
    def SetEvenOddFill(*args): return _amanith.GFontChar2D_SetEvenOddFill(*args)
    def IsComposite(*args): return _amanith.GFontChar2D_IsComposite(*args)
GFontChar2D_swigregister = _amanith.GFontChar2D_swigregister
GFontChar2D_swigregister(GFontChar2D)

class GEncodedChar(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GEncodedChar, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GEncodedChar, name)
    __repr__ = _swig_repr
    __swig_setmethods__["CharCode"] = _amanith.GEncodedChar_CharCode_set
    __swig_getmethods__["CharCode"] = _amanith.GEncodedChar_CharCode_get
    if _newclass:CharCode = property(_amanith.GEncodedChar_CharCode_get, _amanith.GEncodedChar_CharCode_set)
    __swig_setmethods__["GlyphIndex"] = _amanith.GEncodedChar_GlyphIndex_set
    __swig_getmethods__["GlyphIndex"] = _amanith.GEncodedChar_GlyphIndex_get
    if _newclass:GlyphIndex = property(_amanith.GEncodedChar_GlyphIndex_get, _amanith.GEncodedChar_GlyphIndex_set)
    def __init__(self, *args): 
        this = _amanith.new_GEncodedChar(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GEncodedChar
    __del__ = lambda self : None;
GEncodedChar_swigregister = _amanith.GEncodedChar_swigregister
GEncodedChar_swigregister(GEncodedChar)
G_FONT2D_CLASSID = cvar.G_FONT2D_CLASSID

G_ENCODING_NONE = _amanith.G_ENCODING_NONE
G_ENCODING_MS_SYMBOL = _amanith.G_ENCODING_MS_SYMBOL
G_ENCODING_UNICODE = _amanith.G_ENCODING_UNICODE
G_ENCODING_SJIS = _amanith.G_ENCODING_SJIS
G_ENCODING_GB2312 = _amanith.G_ENCODING_GB2312
G_ENCODING_BIG5 = _amanith.G_ENCODING_BIG5
G_ENCODING_WANSUNG = _amanith.G_ENCODING_WANSUNG
G_ENCODING_JOHAB = _amanith.G_ENCODING_JOHAB
G_ENCODING_ADOBE_STANDARD = _amanith.G_ENCODING_ADOBE_STANDARD
G_ENCODING_ADOBE_EXPERT = _amanith.G_ENCODING_ADOBE_EXPERT
G_ENCODING_ADOBE_CUSTOM = _amanith.G_ENCODING_ADOBE_CUSTOM
G_ENCODING_ADOBE_LATIN_1 = _amanith.G_ENCODING_ADOBE_LATIN_1
G_ENCODING_OLD_LATIN_2 = _amanith.G_ENCODING_OLD_LATIN_2
G_ENCODING_APPLE_ROMAN = _amanith.G_ENCODING_APPLE_ROMAN
class GCharMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GCharMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GCharMap, name)
    __repr__ = _swig_repr
    __swig_setmethods__["CharMap"] = _amanith.GCharMap_CharMap_set
    __swig_getmethods__["CharMap"] = _amanith.GCharMap_CharMap_get
    if _newclass:CharMap = property(_amanith.GCharMap_CharMap_get, _amanith.GCharMap_CharMap_set)
    __swig_setmethods__["PlatformID"] = _amanith.GCharMap_PlatformID_set
    __swig_getmethods__["PlatformID"] = _amanith.GCharMap_PlatformID_get
    if _newclass:PlatformID = property(_amanith.GCharMap_PlatformID_get, _amanith.GCharMap_PlatformID_set)
    __swig_setmethods__["EncodingID"] = _amanith.GCharMap_EncodingID_set
    __swig_getmethods__["EncodingID"] = _amanith.GCharMap_EncodingID_get
    if _newclass:EncodingID = property(_amanith.GCharMap_EncodingID_get, _amanith.GCharMap_EncodingID_set)
    __swig_setmethods__["Encoding"] = _amanith.GCharMap_Encoding_set
    __swig_getmethods__["Encoding"] = _amanith.GCharMap_Encoding_get
    if _newclass:Encoding = property(_amanith.GCharMap_Encoding_get, _amanith.GCharMap_Encoding_set)
    def __init__(self, *args): 
        this = _amanith.new_GCharMap(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GCharMap
    __del__ = lambda self : None;
GCharMap_swigregister = _amanith.GCharMap_swigregister
GCharMap_swigregister(GCharMap)

class GKerningEntry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GKerningEntry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GKerningEntry, name)
    __repr__ = _swig_repr
    __swig_setmethods__["GlyphIndexLeft"] = _amanith.GKerningEntry_GlyphIndexLeft_set
    __swig_getmethods__["GlyphIndexLeft"] = _amanith.GKerningEntry_GlyphIndexLeft_get
    if _newclass:GlyphIndexLeft = property(_amanith.GKerningEntry_GlyphIndexLeft_get, _amanith.GKerningEntry_GlyphIndexLeft_set)
    __swig_setmethods__["GlyphIndexRight"] = _amanith.GKerningEntry_GlyphIndexRight_set
    __swig_getmethods__["GlyphIndexRight"] = _amanith.GKerningEntry_GlyphIndexRight_get
    if _newclass:GlyphIndexRight = property(_amanith.GKerningEntry_GlyphIndexRight_get, _amanith.GKerningEntry_GlyphIndexRight_set)
    __swig_setmethods__["Kerning"] = _amanith.GKerningEntry_Kerning_set
    __swig_getmethods__["Kerning"] = _amanith.GKerningEntry_Kerning_get
    if _newclass:Kerning = property(_amanith.GKerningEntry_Kerning_get, _amanith.GKerningEntry_Kerning_set)
    def __init__(self, *args): 
        this = _amanith.new_GKerningEntry(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GKerningEntry
    __del__ = lambda self : None;
GKerningEntry_swigregister = _amanith.GKerningEntry_swigregister
GKerningEntry_swigregister(GKerningEntry)

class GFont2D(GElement):
    __swig_setmethods__ = {}
    for _s in [GElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFont2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFont2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GFont2D(*args)
        try: self.this.append(this)
        except: self.this = this
        if len(args) and isinstance(args[0], GElement): self.thisown = 0

    __swig_destroy__ = _amanith.delete_GFont2D
    __del__ = lambda self : None;
    def Load(*args): return _amanith.GFont2D_Load(*args)
    def CharsCount(*args): return _amanith.GFont2D_CharsCount(*args)
    def AddChar(*args): return _amanith.GFont2D_AddChar(*args)
    def RemoveChar(*args): return _amanith.GFont2D_RemoveChar(*args)
    def Clear(*args): return _amanith.GFont2D_Clear(*args)
    def CharByIndex(*args): return _amanith.GFont2D_CharByIndex(*args)
    def CharByCode(*args): return _amanith.GFont2D_CharByCode(*args)
    def CharMapsCount(*args): return _amanith.GFont2D_CharMapsCount(*args)
    def AddCharMap(*args): return _amanith.GFont2D_AddCharMap(*args)
    def RemoveCharMap(*args): return _amanith.GFont2D_RemoveCharMap(*args)
    def RemoveCharsMaps(*args): return _amanith.GFont2D_RemoveCharsMaps(*args)
    def CharIndexByCharCode(*args): return _amanith.GFont2D_CharIndexByCharCode(*args)
    def FamilyName(*args): return _amanith.GFont2D_FamilyName(*args)
    def SetFamilyName(*args): return _amanith.GFont2D_SetFamilyName(*args)
    def StyleName(*args): return _amanith.GFont2D_StyleName(*args)
    def SetStyleName(*args): return _amanith.GFont2D_SetStyleName(*args)
    def IsItalic(*args): return _amanith.GFont2D_IsItalic(*args)
    def SetItalic(*args): return _amanith.GFont2D_SetItalic(*args)
    def IsBold(*args): return _amanith.GFont2D_IsBold(*args)
    def SetBold(*args): return _amanith.GFont2D_SetBold(*args)
    def HasKerningInfos(*args): return _amanith.GFont2D_HasKerningInfos(*args)
    def SetKerning(*args): return _amanith.GFont2D_SetKerning(*args)
    def KerningByIndex(*args): return _amanith.GFont2D_KerningByIndex(*args)
    def KerningByCharCode(*args): return _amanith.GFont2D_KerningByCharCode(*args)
    def UnitsPerEM(*args): return _amanith.GFont2D_UnitsPerEM(*args)
    def SetUnitsPerEM(*args): return _amanith.GFont2D_SetUnitsPerEM(*args)
    def Ascender(*args): return _amanith.GFont2D_Ascender(*args)
    def SetAscender(*args): return _amanith.GFont2D_SetAscender(*args)
    def Descender(*args): return _amanith.GFont2D_Descender(*args)
    def SetDescender(*args): return _amanith.GFont2D_SetDescender(*args)
    def ExternalLeading(*args): return _amanith.GFont2D_ExternalLeading(*args)
    def SetExternalLeading(*args): return _amanith.GFont2D_SetExternalLeading(*args)
    def Height(*args): return _amanith.GFont2D_Height(*args)
    def MaxAdvanceWidth(*args): return _amanith.GFont2D_MaxAdvanceWidth(*args)
    def SetMaxAdvanceWidth(*args): return _amanith.GFont2D_SetMaxAdvanceWidth(*args)
    def MaxAdvanceHeight(*args): return _amanith.GFont2D_MaxAdvanceHeight(*args)
    def SetMaxAdvanceHeight(*args): return _amanith.GFont2D_SetMaxAdvanceHeight(*args)
    def UnderlinePosition(*args): return _amanith.GFont2D_UnderlinePosition(*args)
    def SetUnderlinePosition(*args): return _amanith.GFont2D_SetUnderlinePosition(*args)
    def UnderlineThickness(*args): return _amanith.GFont2D_UnderlineThickness(*args)
    def SetUnderlineThickness(*args): return _amanith.GFont2D_SetUnderlineThickness(*args)
    def ClassID(*args): return _amanith.GFont2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFont2D_DerivedClassID(*args)
GFont2D_swigregister = _amanith.GFont2D_swigregister
GFont2D_swigregister(GFont2D)

class GFont2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GFont2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GFont2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GFont2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GFont2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GFont2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GFont2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GFont2DProxy
    __del__ = lambda self : None;
GFont2DProxy_swigregister = _amanith.GFont2DProxy_swigregister
GFont2DProxy_swigregister(GFont2DProxy)

class GPath2D(GMultiCurve2D):
    __swig_setmethods__ = {}
    for _s in [GMultiCurve2D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPath2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiCurve2D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPath2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPath2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPath2D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GPath2D_Clear(*args)
    def SetDomain(*args): return _amanith.GPath2D_SetDomain(*args)
    def IntersectRay(*args): return _amanith.GPath2D_IntersectRay(*args)
    def Flatten(*args): return _amanith.GPath2D_Flatten(*args)
    def Variation(*args): return _amanith.GPath2D_Variation(*args)
    def Evaluate(*args): return _amanith.GPath2D_Evaluate(*args)
    def Derivative(*args): return _amanith.GPath2D_Derivative(*args)
    def DerivativeLR(*args): return _amanith.GPath2D_DerivativeLR(*args)
    def Length(*args): return _amanith.GPath2D_Length(*args)
    def ParamToSegmentIndex(*args): return _amanith.GPath2D_ParamToSegmentIndex(*args)
    def PointsCount(*args): return _amanith.GPath2D_PointsCount(*args)
    def SetPoint(*args): return _amanith.GPath2D_SetPoint(*args)
    def Point(*args): return _amanith.GPath2D_Point(*args)
    def AppendCurve(*args): return _amanith.GPath2D_AppendCurve(*args)
    def SegmentsCount(*args): return _amanith.GPath2D_SegmentsCount(*args)
    def SegmentType(*args): return _amanith.GPath2D_SegmentType(*args)
    def Segment(*args): return _amanith.GPath2D_Segment(*args)
    def SetSegment(*args): return _amanith.GPath2D_SetSegment(*args)
    def RemoveSegment(*args): return _amanith.GPath2D_RemoveSegment(*args)
    def GlobalParameter(*args): return _amanith.GPath2D_GlobalParameter(*args)
    def TwoWaysCut(*args): return _amanith.GPath2D_TwoWaysCut(*args)
    def IsClosed(*args): return _amanith.GPath2D_IsClosed(*args)
    def IsOpen(*args): return _amanith.GPath2D_IsOpen(*args)
    def ClosePath(*args): return _amanith.GPath2D_ClosePath(*args)
    def OpenPath(*args): return _amanith.GPath2D_OpenPath(*args)
    def XForm(*args): return _amanith.GPath2D_XForm(*args)
    def ClassID(*args): return _amanith.GPath2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPath2D_DerivedClassID(*args)
GPath2D_swigregister = _amanith.GPath2D_swigregister
GPath2D_swigregister(GPath2D)
G_FONT2D_PROXY = cvar.G_FONT2D_PROXY
G_PATH2D_CLASSID = cvar.G_PATH2D_CLASSID

class GPath2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPath2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPath2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GPath2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GPath2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPath2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPath2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPath2DProxy
    __del__ = lambda self : None;
GPath2DProxy_swigregister = _amanith.GPath2DProxy_swigregister
GPath2DProxy_swigregister(GPath2DProxy)

G_GRAYSCALE = _amanith.G_GRAYSCALE
G_RGB_PALETTE = _amanith.G_RGB_PALETTE
G_R8G8B8 = _amanith.G_R8G8B8
G_A8R8G8B8 = _amanith.G_A8R8G8B8
G_A1R5G5B5 = _amanith.G_A1R5G5B5
G_R5G6B5 = _amanith.G_R5G6B5
G_RESIZE_BOX = _amanith.G_RESIZE_BOX
G_RESIZE_TRIANGLE = _amanith.G_RESIZE_TRIANGLE
G_RESIZE_QUADRATIC = _amanith.G_RESIZE_QUADRATIC
G_RESIZE_CUBIC = _amanith.G_RESIZE_CUBIC
G_RESIZE_CATMULLROM = _amanith.G_RESIZE_CATMULLROM
G_RESIZE_GAUSSIAN = _amanith.G_RESIZE_GAUSSIAN
G_RESIZE_SINC = _amanith.G_RESIZE_SINC
G_RESIZE_BESSEL = _amanith.G_RESIZE_BESSEL
G_RESIZE_BELL = _amanith.G_RESIZE_BELL
G_RESIZE_HANNING = _amanith.G_RESIZE_HANNING
G_RESIZE_HAMMING = _amanith.G_RESIZE_HAMMING
G_RESIZE_BLACKMAN = _amanith.G_RESIZE_BLACKMAN
G_RESIZE_NORMAL = _amanith.G_RESIZE_NORMAL
class GPixelMap(GElement):
    __swig_setmethods__ = {}
    for _s in [GElement]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPixelMap, name, value)
    __swig_getmethods__ = {}
    for _s in [GElement]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPixelMap, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPixelMap(*args)
        try: self.this.append(this)
        except: self.this = this
        if len(args) and isinstance(args[0], GElement): self.thisown = 0

    __swig_destroy__ = _amanith.delete_GPixelMap
    __del__ = lambda self : None;
    def Width(*args): return _amanith.GPixelMap_Width(*args)
    def Height(*args): return _amanith.GPixelMap_Height(*args)
    def PixelFormat(*args): return _amanith.GPixelMap_PixelFormat(*args)
    def PixelsCount(*args): return _amanith.GPixelMap_PixelsCount(*args)
    def PaletteEntriesCount(*args): return _amanith.GPixelMap_PaletteEntriesCount(*args)
    def BitsPerPixel(*args): return _amanith.GPixelMap_BitsPerPixel(*args)
    def BytesPerPixel(*args): return _amanith.GPixelMap_BytesPerPixel(*args)
    def BytesPerLine(*args): return _amanith.GPixelMap_BytesPerLine(*args)
    def Size(*args): return _amanith.GPixelMap_Size(*args)
    def PaletteSize(*args): return _amanith.GPixelMap_PaletteSize(*args)
    def HasAlphaChannel(*args): return _amanith.GPixelMap_HasAlphaChannel(*args)
    def IsPaletted(*args): return _amanith.GPixelMap_IsPaletted(*args)
    def IsGrayScale(*args): return _amanith.GPixelMap_IsGrayScale(*args)
    def IsHighColor(*args): return _amanith.GPixelMap_IsHighColor(*args)
    def IsTrueColor(*args): return _amanith.GPixelMap_IsTrueColor(*args)
    def Clear(*args): return _amanith.GPixelMap_Clear(*args)
    def Pixel(*args): return _amanith.GPixelMap_Pixel(*args)
    def SetPixel(*args): return _amanith.GPixelMap_SetPixel(*args)
    def ReverseChannels(*args): return _amanith.GPixelMap_ReverseChannels(*args)
    def Flip(*args): return _amanith.GPixelMap_Flip(*args)
    def Negative(*args): return _amanith.GPixelMap_Negative(*args)
    def Resize(*args): return _amanith.GPixelMap_Resize(*args)
    def ResizeCanvas(*args): return _amanith.GPixelMap_ResizeCanvas(*args)
    def ResizeCanvasMirror(*args): return _amanith.GPixelMap_ResizeCanvasMirror(*args)
    def Create(*args): return _amanith.GPixelMap_Create(*args)
    def EdgePreservingSmooth(*args): return _amanith.GPixelMap_EdgePreservingSmooth(*args)
    def TraceContours(*args): return _amanith.GPixelMap_TraceContours(*args)
    def EdgeEnhance(*args): return _amanith.GPixelMap_EdgeEnhance(*args)
    def SetPixelFormat(*args): return _amanith.GPixelMap_SetPixelFormat(*args)
    def Reset(*args): return _amanith.GPixelMap_Reset(*args)
    def SplitChannels(*args): return _amanith.GPixelMap_SplitChannels(*args)
    def MergeChannels(*args): return _amanith.GPixelMap_MergeChannels(*args)
    def Pixels(*args): return _amanith.GPixelMap_Pixels(*args)
    def Palette(*args): return _amanith.GPixelMap_Palette(*args)
    def Load(*args): return _amanith.GPixelMap_Load(*args)
    def Save(*args): return _amanith.GPixelMap_Save(*args)
    __swig_getmethods__["RGBToGray"] = lambda x: _amanith.GPixelMap_RGBToGray
    if _newclass:RGBToGray = staticmethod(_amanith.GPixelMap_RGBToGray)
    __swig_getmethods__["RGBToCMY"] = lambda x: _amanith.GPixelMap_RGBToCMY
    if _newclass:RGBToCMY = staticmethod(_amanith.GPixelMap_RGBToCMY)
    __swig_getmethods__["CMYToRGB"] = lambda x: _amanith.GPixelMap_CMYToRGB
    if _newclass:CMYToRGB = staticmethod(_amanith.GPixelMap_CMYToRGB)
    __swig_getmethods__["CMYToKCMY"] = lambda x: _amanith.GPixelMap_CMYToKCMY
    if _newclass:CMYToKCMY = staticmethod(_amanith.GPixelMap_CMYToKCMY)
    __swig_getmethods__["KCMYToCMY"] = lambda x: _amanith.GPixelMap_KCMYToCMY
    if _newclass:KCMYToCMY = staticmethod(_amanith.GPixelMap_KCMYToCMY)
    __swig_getmethods__["RGBToKCMY"] = lambda x: _amanith.GPixelMap_RGBToKCMY
    if _newclass:RGBToKCMY = staticmethod(_amanith.GPixelMap_RGBToKCMY)
    __swig_getmethods__["KCMYToRGB"] = lambda x: _amanith.GPixelMap_KCMYToRGB
    if _newclass:KCMYToRGB = staticmethod(_amanith.GPixelMap_KCMYToRGB)
    __swig_getmethods__["RGBToHSV"] = lambda x: _amanith.GPixelMap_RGBToHSV
    if _newclass:RGBToHSV = staticmethod(_amanith.GPixelMap_RGBToHSV)
    __swig_getmethods__["HSVToRGB"] = lambda x: _amanith.GPixelMap_HSVToRGB
    if _newclass:HSVToRGB = staticmethod(_amanith.GPixelMap_HSVToRGB)
    __swig_getmethods__["RGBToHSL"] = lambda x: _amanith.GPixelMap_RGBToHSL
    if _newclass:RGBToHSL = staticmethod(_amanith.GPixelMap_RGBToHSL)
    __swig_getmethods__["HSLToRGB"] = lambda x: _amanith.GPixelMap_HSLToRGB
    if _newclass:HSLToRGB = staticmethod(_amanith.GPixelMap_HSLToRGB)
    __swig_getmethods__["HueDistance"] = lambda x: _amanith.GPixelMap_HueDistance
    if _newclass:HueDistance = staticmethod(_amanith.GPixelMap_HueDistance)
    def ClassID(*args): return _amanith.GPixelMap_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPixelMap_DerivedClassID(*args)
GPixelMap_swigregister = _amanith.GPixelMap_swigregister
GPixelMap_swigregister(GPixelMap)
G_PATH2D_PROXY = cvar.G_PATH2D_PROXY
G_PIXELMAP_CLASSID = cvar.G_PIXELMAP_CLASSID
GPixelMap_RGBToGray = _amanith.GPixelMap_RGBToGray
GPixelMap_RGBToCMY = _amanith.GPixelMap_RGBToCMY
GPixelMap_CMYToRGB = _amanith.GPixelMap_CMYToRGB
GPixelMap_CMYToKCMY = _amanith.GPixelMap_CMYToKCMY
GPixelMap_KCMYToCMY = _amanith.GPixelMap_KCMYToCMY
GPixelMap_RGBToKCMY = _amanith.GPixelMap_RGBToKCMY
GPixelMap_KCMYToRGB = _amanith.GPixelMap_KCMYToRGB
GPixelMap_RGBToHSV = _amanith.GPixelMap_RGBToHSV
GPixelMap_HSVToRGB = _amanith.GPixelMap_HSVToRGB
GPixelMap_RGBToHSL = _amanith.GPixelMap_RGBToHSL
GPixelMap_HSLToRGB = _amanith.GPixelMap_HSLToRGB
GPixelMap_HueDistance = _amanith.GPixelMap_HueDistance

class GPixelMapProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPixelMapProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPixelMapProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GPixelMapProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GPixelMapProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPixelMapProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPixelMapProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPixelMapProxy
    __del__ = lambda self : None;
GPixelMapProxy_swigregister = _amanith.GPixelMapProxy_swigregister
GPixelMapProxy_swigregister(GPixelMapProxy)

class GPolyLineKey2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPolyLineKey2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPolyLineKey2D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Parameter"] = _amanith.GPolyLineKey2D_Parameter_set
    __swig_getmethods__["Parameter"] = _amanith.GPolyLineKey2D_Parameter_get
    if _newclass:Parameter = property(_amanith.GPolyLineKey2D_Parameter_get, _amanith.GPolyLineKey2D_Parameter_set)
    __swig_setmethods__["Value"] = _amanith.GPolyLineKey2D_Value_set
    __swig_getmethods__["Value"] = _amanith.GPolyLineKey2D_Value_get
    if _newclass:Value = property(_amanith.GPolyLineKey2D_Value_get, _amanith.GPolyLineKey2D_Value_set)
    def __init__(self, *args): 
        this = _amanith.new_GPolyLineKey2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPolyLineKey2D
    __del__ = lambda self : None;
GPolyLineKey2D_swigregister = _amanith.GPolyLineKey2D_swigregister
GPolyLineKey2D_swigregister(GPolyLineKey2D)
G_PIXELMAP_PROXY = cvar.G_PIXELMAP_PROXY
G_POLYLINECURVE2D_CLASSID = cvar.G_POLYLINECURVE2D_CLASSID

class GPolyLineCurve2D(GMultiCurve2D):
    __swig_setmethods__ = {}
    for _s in [GMultiCurve2D]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPolyLineCurve2D, name, value)
    __swig_getmethods__ = {}
    for _s in [GMultiCurve2D]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPolyLineCurve2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPolyLineCurve2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPolyLineCurve2D
    __del__ = lambda self : None;
    def Clear(*args): return _amanith.GPolyLineCurve2D_Clear(*args)
    def PointsCount(*args): return _amanith.GPolyLineCurve2D_PointsCount(*args)
    def ParamToKeyIndex(*args): return _amanith.GPolyLineCurve2D_ParamToKeyIndex(*args)
    def Point(*args): return _amanith.GPolyLineCurve2D_Point(*args)
    def SetPoint(*args): return _amanith.GPolyLineCurve2D_SetPoint(*args)
    def SetPoints(*args): return _amanith.GPolyLineCurve2D_SetPoints(*args)
    def Key(*args): return _amanith.GPolyLineCurve2D_Key(*args)
    def Keys(*args): return _amanith.GPolyLineCurve2D_Keys(*args)
    def SetKeys(*args): return _amanith.GPolyLineCurve2D_SetKeys(*args)
    def SetKey(*args): return _amanith.GPolyLineCurve2D_SetKey(*args)
    def SetDomain(*args): return _amanith.GPolyLineCurve2D_SetDomain(*args)
    def IntersectRay(*args): return _amanith.GPolyLineCurve2D_IntersectRay(*args)
    def Variation(*args): return _amanith.GPolyLineCurve2D_Variation(*args)
    def Flatten(*args): return _amanith.GPolyLineCurve2D_Flatten(*args)
    def Length(*args): return _amanith.GPolyLineCurve2D_Length(*args)
    def Evaluate(*args): return _amanith.GPolyLineCurve2D_Evaluate(*args)
    def Derivative(*args): return _amanith.GPolyLineCurve2D_Derivative(*args)
    def DerivativeLR(*args): return _amanith.GPolyLineCurve2D_DerivativeLR(*args)
    def ClassID(*args): return _amanith.GPolyLineCurve2D_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPolyLineCurve2D_DerivedClassID(*args)
GPolyLineCurve2D_swigregister = _amanith.GPolyLineCurve2D_swigregister
GPolyLineCurve2D_swigregister(GPolyLineCurve2D)

class GPolyLineCurve2DProxy(GElementProxy):
    __swig_setmethods__ = {}
    for _s in [GElementProxy]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPolyLineCurve2DProxy, name, value)
    __swig_getmethods__ = {}
    for _s in [GElementProxy]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPolyLineCurve2DProxy, name)
    __repr__ = _swig_repr
    def CreateNew(*args): return _amanith.GPolyLineCurve2DProxy_CreateNew(*args)
    def ClassID(*args): return _amanith.GPolyLineCurve2DProxy_ClassID(*args)
    def DerivedClassID(*args): return _amanith.GPolyLineCurve2DProxy_DerivedClassID(*args)
    def __init__(self, *args): 
        this = _amanith.new_GPolyLineCurve2DProxy(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPolyLineCurve2DProxy
    __del__ = lambda self : None;
GPolyLineCurve2DProxy_swigregister = _amanith.GPolyLineCurve2DProxy_swigregister
GPolyLineCurve2DProxy_swigregister(GPolyLineCurve2DProxy)

G_ODD_EVEN_RULE = _amanith.G_ODD_EVEN_RULE
G_EVEN_ODD_RULE = _amanith.G_EVEN_ODD_RULE
G_NON_ZERO_RULE = _amanith.G_NON_ZERO_RULE
G_ANY_RULE = _amanith.G_ANY_RULE
class GTesselator2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTesselator2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GTesselator2D, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GTesselator2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTesselator2D
    __del__ = lambda self : None;
    def Tesselate(*args): return _amanith.GTesselator2D_Tesselate(*args)
GTesselator2D_swigregister = _amanith.GTesselator2D_swigregister
GTesselator2D_swigregister(GTesselator2D)
G_POLYLINECURVE2D_PROXY = cvar.G_POLYLINECURVE2D_PROXY

class ThreePoints(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreePoints, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreePoints, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Points"] = _amanith.ThreePoints_Points_set
    __swig_getmethods__["Points"] = _amanith.ThreePoints_Points_get
    if _newclass:Points = property(_amanith.ThreePoints_Points_get, _amanith.ThreePoints_Points_set)
    def __init__(self, *args): 
        this = _amanith.new_ThreePoints(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_ThreePoints
    __del__ = lambda self : None;
ThreePoints_swigregister = _amanith.ThreePoints_swigregister
ThreePoints_swigregister(ThreePoints)

class GTracedContour(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTracedContour, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GTracedContour, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GTracedContour(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTracedContour
    __del__ = lambda self : None;
    def DrawContour(*args): return _amanith.GTracedContour_DrawContour(*args)
    def ConvertToPath(*args): return _amanith.GTracedContour_ConvertToPath(*args)
GTracedContour_swigregister = _amanith.GTracedContour_swigregister
GTracedContour_swigregister(GTracedContour)

G_CONNECT_BLACK = _amanith.G_CONNECT_BLACK
G_CONNECT_WHITE = _amanith.G_CONNECT_WHITE
G_CONNECT_DOMINANT = _amanith.G_CONNECT_DOMINANT
G_CONNECT_NOT_DOMINANT = _amanith.G_CONNECT_NOT_DOMINANT
class GTracer2D(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GTracer2D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GTracer2D, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Trace"] = lambda x: _amanith.GTracer2D_Trace
    if _newclass:Trace = staticmethod(_amanith.GTracer2D_Trace)
    def __init__(self, *args): 
        this = _amanith.new_GTracer2D(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GTracer2D
    __del__ = lambda self : None;
GTracer2D_swigregister = _amanith.GTracer2D_swigregister
GTracer2D_swigregister(GTracer2D)
GTracer2D_Trace = _amanith.GTracer2D_Trace

G_BUTT_CAP = _amanith.G_BUTT_CAP
G_ROUND_CAP = _amanith.G_ROUND_CAP
G_SQUARE_CAP = _amanith.G_SQUARE_CAP
G_MITER_JOIN = _amanith.G_MITER_JOIN
G_ROUND_JOIN = _amanith.G_ROUND_JOIN
G_BEVEL_JOIN = _amanith.G_BEVEL_JOIN
G_SOLID_STROKE = _amanith.G_SOLID_STROKE
G_DASHED_STROKE = _amanith.G_DASHED_STROKE
G_ODD_EVEN_FILLRULE = _amanith.G_ODD_EVEN_FILLRULE
G_EVEN_ODD_FILLRULE = _amanith.G_EVEN_ODD_FILLRULE
G_NON_ZERO_FILLRULE = _amanith.G_NON_ZERO_FILLRULE
G_ANY_FILLRULE = _amanith.G_ANY_FILLRULE
G_COLOR_PAINT_TYPE = _amanith.G_COLOR_PAINT_TYPE
G_GRADIENT_PAINT_TYPE = _amanith.G_GRADIENT_PAINT_TYPE
G_PATTERN_PAINT_TYPE = _amanith.G_PATTERN_PAINT_TYPE
G_LINEAR_GRADIENT = _amanith.G_LINEAR_GRADIENT
G_RADIAL_GRADIENT = _amanith.G_RADIAL_GRADIENT
G_CONICAL_GRADIENT = _amanith.G_CONICAL_GRADIENT
G_PAD_COLOR_RAMP_SPREAD = _amanith.G_PAD_COLOR_RAMP_SPREAD
G_REPEAT_COLOR_RAMP_SPREAD = _amanith.G_REPEAT_COLOR_RAMP_SPREAD
G_REFLECT_COLOR_RAMP_SPREAD = _amanith.G_REFLECT_COLOR_RAMP_SPREAD
G_CONSTANT_COLOR_INTERPOLATION = _amanith.G_CONSTANT_COLOR_INTERPOLATION
G_LINEAR_COLOR_INTERPOLATION = _amanith.G_LINEAR_COLOR_INTERPOLATION
G_HERMITE_COLOR_INTERPOLATION = _amanith.G_HERMITE_COLOR_INTERPOLATION
G_PAD_TILE = _amanith.G_PAD_TILE
G_REPEAT_TILE = _amanith.G_REPEAT_TILE
G_REFLECT_TILE = _amanith.G_REFLECT_TILE
G_LOW_IMAGE_QUALITY = _amanith.G_LOW_IMAGE_QUALITY
G_NORMAL_IMAGE_QUALITY = _amanith.G_NORMAL_IMAGE_QUALITY
G_HIGH_IMAGE_QUALITY = _amanith.G_HIGH_IMAGE_QUALITY
class GGradientDesc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GGradientDesc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GGradientDesc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GGradientDesc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GGradientDesc
    __del__ = lambda self : None;
    def Type(*args): return _amanith.GGradientDesc_Type(*args)
    def SetType(*args): return _amanith.GGradientDesc_SetType(*args)
    def StartPoint(*args): return _amanith.GGradientDesc_StartPoint(*args)
    def SetStartPoint(*args): return _amanith.GGradientDesc_SetStartPoint(*args)
    def AuxPoint(*args): return _amanith.GGradientDesc_AuxPoint(*args)
    def SetAuxPoint(*args): return _amanith.GGradientDesc_SetAuxPoint(*args)
    def Radius(*args): return _amanith.GGradientDesc_Radius(*args)
    def SetRadius(*args): return _amanith.GGradientDesc_SetRadius(*args)
    def ColorKeys(*args): return _amanith.GGradientDesc_ColorKeys(*args)
    def SetColorKeys(*args): return _amanith.GGradientDesc_SetColorKeys(*args)
    def ColorInterpolation(*args): return _amanith.GGradientDesc_ColorInterpolation(*args)
    def SetColorInterpolation(*args): return _amanith.GGradientDesc_SetColorInterpolation(*args)
    def SpreadMode(*args): return _amanith.GGradientDesc_SpreadMode(*args)
    def SetSpreadMode(*args): return _amanith.GGradientDesc_SetSpreadMode(*args)
    def Matrix(*args): return _amanith.GGradientDesc_Matrix(*args)
    def InverseMatrix(*args): return _amanith.GGradientDesc_InverseMatrix(*args)
    def SetMatrix(*args): return _amanith.GGradientDesc_SetMatrix(*args)
    def TypeModified(*args): return _amanith.GGradientDesc_TypeModified(*args)
    def StartPointModified(*args): return _amanith.GGradientDesc_StartPointModified(*args)
    def AuxPointModified(*args): return _amanith.GGradientDesc_AuxPointModified(*args)
    def ColorKeysModified(*args): return _amanith.GGradientDesc_ColorKeysModified(*args)
    def ColorInterpolationModified(*args): return _amanith.GGradientDesc_ColorInterpolationModified(*args)
    def SpreadModeModified(*args): return _amanith.GGradientDesc_SpreadModeModified(*args)
    def MatrixModified(*args): return _amanith.GGradientDesc_MatrixModified(*args)
    def Modified(*args): return _amanith.GGradientDesc_Modified(*args)
GGradientDesc_swigregister = _amanith.GGradientDesc_swigregister
GGradientDesc_swigregister(GGradientDesc)

class GPatternDesc(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPatternDesc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GPatternDesc, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GPatternDesc
    __del__ = lambda self : None;
    def LogicalWindow(*args): return _amanith.GPatternDesc_LogicalWindow(*args)
    def SetLogicalWindow(*args): return _amanith.GPatternDesc_SetLogicalWindow(*args)
    def TilingMode(*args): return _amanith.GPatternDesc_TilingMode(*args)
    def SetTilingMode(*args): return _amanith.GPatternDesc_SetTilingMode(*args)
    def Matrix(*args): return _amanith.GPatternDesc_Matrix(*args)
    def InverseMatrix(*args): return _amanith.GPatternDesc_InverseMatrix(*args)
    def SetMatrix(*args): return _amanith.GPatternDesc_SetMatrix(*args)
    def SetImage(*args): return _amanith.GPatternDesc_SetImage(*args)
    def TilingModeModified(*args): return _amanith.GPatternDesc_TilingModeModified(*args)
    def MatrixModified(*args): return _amanith.GPatternDesc_MatrixModified(*args)
    def LogicalWindowModified(*args): return _amanith.GPatternDesc_LogicalWindowModified(*args)
    def Modified(*args): return _amanith.GPatternDesc_Modified(*args)
GPatternDesc_swigregister = _amanith.GPatternDesc_swigregister
GPatternDesc_swigregister(GPatternDesc)

G_CLEAR_OP = _amanith.G_CLEAR_OP
G_SRC_OP = _amanith.G_SRC_OP
G_DST_OP = _amanith.G_DST_OP
G_SRC_OVER_OP = _amanith.G_SRC_OVER_OP
G_DST_OVER_OP = _amanith.G_DST_OVER_OP
G_SRC_IN_OP = _amanith.G_SRC_IN_OP
G_DST_IN_OP = _amanith.G_DST_IN_OP
G_SRC_OUT_OP = _amanith.G_SRC_OUT_OP
G_DST_OUT_OP = _amanith.G_DST_OUT_OP
G_SRC_ATOP_OP = _amanith.G_SRC_ATOP_OP
G_DST_ATOP_OP = _amanith.G_DST_ATOP_OP
G_XOR_OP = _amanith.G_XOR_OP
G_PLUS_OP = _amanith.G_PLUS_OP
G_MULTIPLY_OP = _amanith.G_MULTIPLY_OP
G_SCREEN_OP = _amanith.G_SCREEN_OP
G_OVERLAY_OP = _amanith.G_OVERLAY_OP
G_DARKEN_OP = _amanith.G_DARKEN_OP
G_LIGHTEN_OP = _amanith.G_LIGHTEN_OP
G_COLOR_DODGE_OP = _amanith.G_COLOR_DODGE_OP
G_COLOR_BURN_OP = _amanith.G_COLOR_BURN_OP
G_HARD_LIGHT_OP = _amanith.G_HARD_LIGHT_OP
G_SOFT_LIGHT_OP = _amanith.G_SOFT_LIGHT_OP
G_DIFFERENCE_OP = _amanith.G_DIFFERENCE_OP
G_EXCLUSION_OP = _amanith.G_EXCLUSION_OP
class GDrawStyle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GDrawStyle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GDrawStyle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GDrawStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GDrawStyle
    __del__ = lambda self : None;
    def StrokeWidth(*args): return _amanith.GDrawStyle_StrokeWidth(*args)
    def SetStrokeWidth(*args): return _amanith.GDrawStyle_SetStrokeWidth(*args)
    def StrokeThickness(*args): return _amanith.GDrawStyle_StrokeThickness(*args)
    def StrokeMiterLimit(*args): return _amanith.GDrawStyle_StrokeMiterLimit(*args)
    def SetStrokeMiterLimit(*args): return _amanith.GDrawStyle_SetStrokeMiterLimit(*args)
    def StrokeStartCapStyle(*args): return _amanith.GDrawStyle_StrokeStartCapStyle(*args)
    def SetStrokeStartCapStyle(*args): return _amanith.GDrawStyle_SetStrokeStartCapStyle(*args)
    def StrokeEndCapStyle(*args): return _amanith.GDrawStyle_StrokeEndCapStyle(*args)
    def SetStrokeEndCapStyle(*args): return _amanith.GDrawStyle_SetStrokeEndCapStyle(*args)
    def StrokeJoinStyle(*args): return _amanith.GDrawStyle_StrokeJoinStyle(*args)
    def SetStrokeJoinStyle(*args): return _amanith.GDrawStyle_SetStrokeJoinStyle(*args)
    def StrokePaintType(*args): return _amanith.GDrawStyle_StrokePaintType(*args)
    def SetStrokePaintType(*args): return _amanith.GDrawStyle_SetStrokePaintType(*args)
    def StrokeColor(*args): return _amanith.GDrawStyle_StrokeColor(*args)
    def SetStrokeColor(*args): return _amanith.GDrawStyle_SetStrokeColor(*args)
    def StrokeGradient(*args): return _amanith.GDrawStyle_StrokeGradient(*args)
    def SetStrokeGradient(*args): return _amanith.GDrawStyle_SetStrokeGradient(*args)
    def StrokePattern(*args): return _amanith.GDrawStyle_StrokePattern(*args)
    def SetStrokePattern(*args): return _amanith.GDrawStyle_SetStrokePattern(*args)
    def StrokeStyle(*args): return _amanith.GDrawStyle_StrokeStyle(*args)
    def SetStrokeStyle(*args): return _amanith.GDrawStyle_SetStrokeStyle(*args)
    def StrokeDashPattern(*args): return _amanith.GDrawStyle_StrokeDashPattern(*args)
    def SetStrokeDashPattern(*args): return _amanith.GDrawStyle_SetStrokeDashPattern(*args)
    def StrokeDashPhase(*args): return _amanith.GDrawStyle_StrokeDashPhase(*args)
    def SetStrokeDashPhase(*args): return _amanith.GDrawStyle_SetStrokeDashPhase(*args)
    def StrokeEnabled(*args): return _amanith.GDrawStyle_StrokeEnabled(*args)
    def StrokeCompOp(*args): return _amanith.GDrawStyle_StrokeCompOp(*args)
    def SetStrokeCompOp(*args): return _amanith.GDrawStyle_SetStrokeCompOp(*args)
    def SetStrokeEnabled(*args): return _amanith.GDrawStyle_SetStrokeEnabled(*args)
    def FillRule(*args): return _amanith.GDrawStyle_FillRule(*args)
    def SetFillRule(*args): return _amanith.GDrawStyle_SetFillRule(*args)
    def FillPaintType(*args): return _amanith.GDrawStyle_FillPaintType(*args)
    def SetFillPaintType(*args): return _amanith.GDrawStyle_SetFillPaintType(*args)
    def FillColor(*args): return _amanith.GDrawStyle_FillColor(*args)
    def SetFillColor(*args): return _amanith.GDrawStyle_SetFillColor(*args)
    def FillGradient(*args): return _amanith.GDrawStyle_FillGradient(*args)
    def SetFillGradient(*args): return _amanith.GDrawStyle_SetFillGradient(*args)
    def FillPattern(*args): return _amanith.GDrawStyle_FillPattern(*args)
    def SetFillPattern(*args): return _amanith.GDrawStyle_SetFillPattern(*args)
    def FillCompOp(*args): return _amanith.GDrawStyle_FillCompOp(*args)
    def SetFillCompOp(*args): return _amanith.GDrawStyle_SetFillCompOp(*args)
    def FillEnabled(*args): return _amanith.GDrawStyle_FillEnabled(*args)
    def SetFillEnabled(*args): return _amanith.GDrawStyle_SetFillEnabled(*args)
    def ModelView(*args): return _amanith.GDrawStyle_ModelView(*args)
    def InverseModelView(*args): return _amanith.GDrawStyle_InverseModelView(*args)
    def SetModelView(*args): return _amanith.GDrawStyle_SetModelView(*args)
    def StrokeOffsettedDashPattern(*args): return _amanith.GDrawStyle_StrokeOffsettedDashPattern(*args)
    def StrokeOffsettedDashPatternEmpty(*args): return _amanith.GDrawStyle_StrokeOffsettedDashPatternEmpty(*args)
    def StrokeDashPatternSum(*args): return _amanith.GDrawStyle_StrokeDashPatternSum(*args)
    def StrokeWidthModified(*args): return _amanith.GDrawStyle_StrokeWidthModified(*args)
    def StrokeMiterLimitModified(*args): return _amanith.GDrawStyle_StrokeMiterLimitModified(*args)
    def StrokeStartCapStyleModified(*args): return _amanith.GDrawStyle_StrokeStartCapStyleModified(*args)
    def StrokeEndCapStyleModified(*args): return _amanith.GDrawStyle_StrokeEndCapStyleModified(*args)
    def StrokeJoinStyleModified(*args): return _amanith.GDrawStyle_StrokeJoinStyleModified(*args)
    def StrokePaintTypeModified(*args): return _amanith.GDrawStyle_StrokePaintTypeModified(*args)
    def StrokeStyleModified(*args): return _amanith.GDrawStyle_StrokeStyleModified(*args)
    def StrokeColorModified(*args): return _amanith.GDrawStyle_StrokeColorModified(*args)
    def StrokeGradientModified(*args): return _amanith.GDrawStyle_StrokeGradientModified(*args)
    def StrokePatternModified(*args): return _amanith.GDrawStyle_StrokePatternModified(*args)
    def StrokeDashPatternModified(*args): return _amanith.GDrawStyle_StrokeDashPatternModified(*args)
    def StrokeDashPhaseModified(*args): return _amanith.GDrawStyle_StrokeDashPhaseModified(*args)
    def StrokeCompOpModified(*args): return _amanith.GDrawStyle_StrokeCompOpModified(*args)
    def StrokeEnabledModified(*args): return _amanith.GDrawStyle_StrokeEnabledModified(*args)
    def FillRuleModified(*args): return _amanith.GDrawStyle_FillRuleModified(*args)
    def FillPaintTypeModified(*args): return _amanith.GDrawStyle_FillPaintTypeModified(*args)
    def FillColorModified(*args): return _amanith.GDrawStyle_FillColorModified(*args)
    def FillGradientModified(*args): return _amanith.GDrawStyle_FillGradientModified(*args)
    def FillPatternModified(*args): return _amanith.GDrawStyle_FillPatternModified(*args)
    def FillCompOpModified(*args): return _amanith.GDrawStyle_FillCompOpModified(*args)
    def FillEnabledModified(*args): return _amanith.GDrawStyle_FillEnabledModified(*args)
    def ModelViewModified(*args): return _amanith.GDrawStyle_ModelViewModified(*args)
    def Modified(*args): return _amanith.GDrawStyle_Modified(*args)
GDrawStyle_swigregister = _amanith.GDrawStyle_swigregister
GDrawStyle_swigregister(GDrawStyle)

G_LOW_RENDERING_QUALITY = _amanith.G_LOW_RENDERING_QUALITY
G_NORMAL_RENDERING_QUALITY = _amanith.G_NORMAL_RENDERING_QUALITY
G_HIGH_RENDERING_QUALITY = _amanith.G_HIGH_RENDERING_QUALITY
G_COLOR_MODE = _amanith.G_COLOR_MODE
G_CLIP_MODE = _amanith.G_CLIP_MODE
G_COLOR_AND_CACHE_MODE = _amanith.G_COLOR_AND_CACHE_MODE
G_CLIP_AND_CACHE_MODE = _amanith.G_CLIP_AND_CACHE_MODE
G_CACHE_MODE = _amanith.G_CACHE_MODE
G_REPLACE_CLIP = _amanith.G_REPLACE_CLIP
G_INTERSECTION_CLIP = _amanith.G_INTERSECTION_CLIP
class GRenderingContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GRenderingContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GRenderingContext, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_setmethods__["gDrawStyle"] = _amanith.GRenderingContext_gDrawStyle_set
    __swig_getmethods__["gDrawStyle"] = _amanith.GRenderingContext_gDrawStyle_get
    if _newclass:gDrawStyle = property(_amanith.GRenderingContext_gDrawStyle_get, _amanith.GRenderingContext_gDrawStyle_set)
    __swig_setmethods__["gRenderingQuality"] = _amanith.GRenderingContext_gRenderingQuality_set
    __swig_getmethods__["gRenderingQuality"] = _amanith.GRenderingContext_gRenderingQuality_get
    if _newclass:gRenderingQuality = property(_amanith.GRenderingContext_gRenderingQuality_get, _amanith.GRenderingContext_gRenderingQuality_set)
    __swig_setmethods__["gGroupOpacity"] = _amanith.GRenderingContext_gGroupOpacity_set
    __swig_getmethods__["gGroupOpacity"] = _amanith.GRenderingContext_gGroupOpacity_get
    if _newclass:gGroupOpacity = property(_amanith.GRenderingContext_gGroupOpacity_get, _amanith.GRenderingContext_gGroupOpacity_set)
    __swig_setmethods__["gGroupCompOp"] = _amanith.GRenderingContext_gGroupCompOp_set
    __swig_getmethods__["gGroupCompOp"] = _amanith.GRenderingContext_gGroupCompOp_get
    if _newclass:gGroupCompOp = property(_amanith.GRenderingContext_gGroupCompOp_get, _amanith.GRenderingContext_gGroupCompOp_set)
    __swig_setmethods__["gTargetMode"] = _amanith.GRenderingContext_gTargetMode_set
    __swig_getmethods__["gTargetMode"] = _amanith.GRenderingContext_gTargetMode_get
    if _newclass:gTargetMode = property(_amanith.GRenderingContext_gTargetMode_get, _amanith.GRenderingContext_gTargetMode_set)
    __swig_setmethods__["gClipEnabled"] = _amanith.GRenderingContext_gClipEnabled_set
    __swig_getmethods__["gClipEnabled"] = _amanith.GRenderingContext_gClipEnabled_get
    if _newclass:gClipEnabled = property(_amanith.GRenderingContext_gClipEnabled_get, _amanith.GRenderingContext_gClipEnabled_set)
    __swig_setmethods__["gClipOperation"] = _amanith.GRenderingContext_gClipOperation_set
    __swig_getmethods__["gClipOperation"] = _amanith.GRenderingContext_gClipOperation_get
    if _newclass:gClipOperation = property(_amanith.GRenderingContext_gClipOperation_get, _amanith.GRenderingContext_gClipOperation_set)
    __swig_destroy__ = _amanith.delete_GRenderingContext
    __del__ = lambda self : None;
GRenderingContext_swigregister = _amanith.GRenderingContext_swigregister
GRenderingContext_swigregister(GRenderingContext)

class GCacheBank(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GCacheBank, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GCacheBank, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GCacheBank
    __del__ = lambda self : None;
    def SlotsCount(*args): return _amanith.GCacheBank_SlotsCount(*args)
    def Invalidate(*args): return _amanith.GCacheBank_Invalidate(*args)
GCacheBank_swigregister = _amanith.GCacheBank_swigregister
GCacheBank_swigregister(GCacheBank)

class GDrawBoard(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GDrawBoard, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GDrawBoard, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GDrawBoard
    __del__ = lambda self : None;
    def MaxDashCount(*args): return _amanith.GDrawBoard_MaxDashCount(*args)
    def MaxColorKeys(*args): return _amanith.GDrawBoard_MaxColorKeys(*args)
    def MaxImageWidth(*args): return _amanith.GDrawBoard_MaxImageWidth(*args)
    def MaxImageHeight(*args): return _amanith.GDrawBoard_MaxImageHeight(*args)
    def MaxImageBytes(*args): return _amanith.GDrawBoard_MaxImageBytes(*args)
    def CreateLinearGradient(*args): return _amanith.GDrawBoard_CreateLinearGradient(*args)
    def CreateRadialGradient(*args): return _amanith.GDrawBoard_CreateRadialGradient(*args)
    def CreateConicalGradient(*args): return _amanith.GDrawBoard_CreateConicalGradient(*args)
    def CreatePattern(*args): return _amanith.GDrawBoard_CreatePattern(*args)
    def CreateCacheBank(*args): return _amanith.GDrawBoard_CreateCacheBank(*args)
    def CacheBank(*args): return _amanith.GDrawBoard_CacheBank(*args)
    def SetCacheBank(*args): return _amanith.GDrawBoard_SetCacheBank(*args)
    def GroupOpacity(*args): return _amanith.GDrawBoard_GroupOpacity(*args)
    def SetGroupOpacity(*args): return _amanith.GDrawBoard_SetGroupOpacity(*args)
    def GroupCompOp(*args): return _amanith.GDrawBoard_GroupCompOp(*args)
    def SetGroupCompOp(*args): return _amanith.GDrawBoard_SetGroupCompOp(*args)
    def RenderingQuality(*args): return _amanith.GDrawBoard_RenderingQuality(*args)
    def SetRenderingQuality(*args): return _amanith.GDrawBoard_SetRenderingQuality(*args)
    def TargetMode(*args): return _amanith.GDrawBoard_TargetMode(*args)
    def SetTargetMode(*args): return _amanith.GDrawBoard_SetTargetMode(*args)
    def ClipOperation(*args): return _amanith.GDrawBoard_ClipOperation(*args)
    def SetClipOperation(*args): return _amanith.GDrawBoard_SetClipOperation(*args)
    def ClipEnabled(*args): return _amanith.GDrawBoard_ClipEnabled(*args)
    def SetClipEnabled(*args): return _amanith.GDrawBoard_SetClipEnabled(*args)
    def PopClipMask(*args): return _amanith.GDrawBoard_PopClipMask(*args)
    def ModelViewMatrix(*args): return _amanith.GDrawBoard_ModelViewMatrix(*args)
    def SetModelViewMatrix(*args): return _amanith.GDrawBoard_SetModelViewMatrix(*args)
    def StrokeStartCapStyle(*args): return _amanith.GDrawBoard_StrokeStartCapStyle(*args)
    def SetStrokeStartCapStyle(*args): return _amanith.GDrawBoard_SetStrokeStartCapStyle(*args)
    def StrokeEndCapStyle(*args): return _amanith.GDrawBoard_StrokeEndCapStyle(*args)
    def SetStrokeEndCapStyle(*args): return _amanith.GDrawBoard_SetStrokeEndCapStyle(*args)
    def StrokeJoinStyle(*args): return _amanith.GDrawBoard_StrokeJoinStyle(*args)
    def SetStrokeJoinStyle(*args): return _amanith.GDrawBoard_SetStrokeJoinStyle(*args)
    def StrokeWidth(*args): return _amanith.GDrawBoard_StrokeWidth(*args)
    def SetStrokeWidth(*args): return _amanith.GDrawBoard_SetStrokeWidth(*args)
    def StrokeMiterLimit(*args): return _amanith.GDrawBoard_StrokeMiterLimit(*args)
    def SetStrokeMiterLimit(*args): return _amanith.GDrawBoard_SetStrokeMiterLimit(*args)
    def StrokeStyle(*args): return _amanith.GDrawBoard_StrokeStyle(*args)
    def SetStrokeStyle(*args): return _amanith.GDrawBoard_SetStrokeStyle(*args)
    def StrokeDashPattern(*args): return _amanith.GDrawBoard_StrokeDashPattern(*args)
    def SetStrokeDashPattern(*args): return _amanith.GDrawBoard_SetStrokeDashPattern(*args)
    def StrokeDashPhase(*args): return _amanith.GDrawBoard_StrokeDashPhase(*args)
    def SetStrokeDashPhase(*args): return _amanith.GDrawBoard_SetStrokeDashPhase(*args)
    def StrokePaintType(*args): return _amanith.GDrawBoard_StrokePaintType(*args)
    def SetStrokePaintType(*args): return _amanith.GDrawBoard_SetStrokePaintType(*args)
    def StrokeColor(*args): return _amanith.GDrawBoard_StrokeColor(*args)
    def SetStrokeColor(*args): return _amanith.GDrawBoard_SetStrokeColor(*args)
    def SetStrokeOpacity(*args): return _amanith.GDrawBoard_SetStrokeOpacity(*args)
    def StrokeGradient(*args): return _amanith.GDrawBoard_StrokeGradient(*args)
    def SetStrokeGradient(*args): return _amanith.GDrawBoard_SetStrokeGradient(*args)
    def StrokePattern(*args): return _amanith.GDrawBoard_StrokePattern(*args)
    def SetStrokePattern(*args): return _amanith.GDrawBoard_SetStrokePattern(*args)
    def StrokeCompOp(*args): return _amanith.GDrawBoard_StrokeCompOp(*args)
    def SetStrokeCompOp(*args): return _amanith.GDrawBoard_SetStrokeCompOp(*args)
    def StrokeEnabled(*args): return _amanith.GDrawBoard_StrokeEnabled(*args)
    def SetStrokeEnabled(*args): return _amanith.GDrawBoard_SetStrokeEnabled(*args)
    def FillRule(*args): return _amanith.GDrawBoard_FillRule(*args)
    def SetFillRule(*args): return _amanith.GDrawBoard_SetFillRule(*args)
    def FillPaintType(*args): return _amanith.GDrawBoard_FillPaintType(*args)
    def SetFillPaintType(*args): return _amanith.GDrawBoard_SetFillPaintType(*args)
    def FillColor(*args): return _amanith.GDrawBoard_FillColor(*args)
    def SetFillColor(*args): return _amanith.GDrawBoard_SetFillColor(*args)
    def SetFillOpacity(*args): return _amanith.GDrawBoard_SetFillOpacity(*args)
    def FillGradient(*args): return _amanith.GDrawBoard_FillGradient(*args)
    def SetFillGradient(*args): return _amanith.GDrawBoard_SetFillGradient(*args)
    def FillPattern(*args): return _amanith.GDrawBoard_FillPattern(*args)
    def SetFillPattern(*args): return _amanith.GDrawBoard_SetFillPattern(*args)
    def FillCompOp(*args): return _amanith.GDrawBoard_FillCompOp(*args)
    def SetFillCompOp(*args): return _amanith.GDrawBoard_SetFillCompOp(*args)
    def FillEnabled(*args): return _amanith.GDrawBoard_FillEnabled(*args)
    def SetFillEnabled(*args): return _amanith.GDrawBoard_SetFillEnabled(*args)
    def DrawLine(*args): return _amanith.GDrawBoard_DrawLine(*args)
    def DrawBezier(*args): return _amanith.GDrawBoard_DrawBezier(*args)
    def DrawEllipseArc(*args): return _amanith.GDrawBoard_DrawEllipseArc(*args)
    def DrawPolygon(*args): return _amanith.GDrawBoard_DrawPolygon(*args)
    def DrawRectangle(*args): return _amanith.GDrawBoard_DrawRectangle(*args)
    def DrawRoundRectangle(*args): return _amanith.GDrawBoard_DrawRoundRectangle(*args)
    def DrawEllipse(*args): return _amanith.GDrawBoard_DrawEllipse(*args)
    def DrawCircle(*args): return _amanith.GDrawBoard_DrawCircle(*args)
    def DrawPath(*args): return _amanith.GDrawBoard_DrawPath(*args)
    def DrawPaths(*args): return _amanith.GDrawBoard_DrawPaths(*args)
    def BeginPaths(*args): return _amanith.GDrawBoard_BeginPaths(*args)
    def MoveTo(*args): return _amanith.GDrawBoard_MoveTo(*args)
    def LineTo(*args): return _amanith.GDrawBoard_LineTo(*args)
    def HorizontalLineTo(*args): return _amanith.GDrawBoard_HorizontalLineTo(*args)
    def VerticalLineTo(*args): return _amanith.GDrawBoard_VerticalLineTo(*args)
    def CurveTo(*args): return _amanith.GDrawBoard_CurveTo(*args)
    def SmoothCurveTo(*args): return _amanith.GDrawBoard_SmoothCurveTo(*args)
    def EllipticalArcTo(*args): return _amanith.GDrawBoard_EllipticalArcTo(*args)
    def ClosePath(*args): return _amanith.GDrawBoard_ClosePath(*args)
    def EndPaths(*args): return _amanith.GDrawBoard_EndPaths(*args)
    def DrawCacheSlots(*args): return _amanith.GDrawBoard_DrawCacheSlots(*args)
    def DrawCacheBank(*args): return _amanith.GDrawBoard_DrawCacheBank(*args)
    def DrawCacheSlot(*args): return _amanith.GDrawBoard_DrawCacheSlot(*args)
    def Clear(*args): return _amanith.GDrawBoard_Clear(*args)
    def Flush(*args): return _amanith.GDrawBoard_Flush(*args)
    def Finish(*args): return _amanith.GDrawBoard_Finish(*args)
    def GroupBegin(*args): return _amanith.GDrawBoard_GroupBegin(*args)
    def GroupEnd(*args): return _amanith.GDrawBoard_GroupEnd(*args)
    def Viewport(*args): return _amanith.GDrawBoard_Viewport(*args)
    def SetViewport(*args): return _amanith.GDrawBoard_SetViewport(*args)
    def Projection(*args): return _amanith.GDrawBoard_Projection(*args)
    def SetProjection(*args): return _amanith.GDrawBoard_SetProjection(*args)
    def LogicalToPhysicalInt(*args): return _amanith.GDrawBoard_LogicalToPhysicalInt(*args)
    def LogicalToPhysicalReal(*args): return _amanith.GDrawBoard_LogicalToPhysicalReal(*args)
    def PhysicalToLogical(*args): return _amanith.GDrawBoard_PhysicalToLogical(*args)
    def ScreenShot(*args): return _amanith.GDrawBoard_ScreenShot(*args)
    def PhysicalToLogicalMatrix(*args): return _amanith.GDrawBoard_PhysicalToLogicalMatrix(*args)
    def LogicalToPhysicalMatrix(*args): return _amanith.GDrawBoard_LogicalToPhysicalMatrix(*args)
    def InsideGroup(*args): return _amanith.GDrawBoard_InsideGroup(*args)
GDrawBoard_swigregister = _amanith.GDrawBoard_swigregister
GDrawBoard_swigregister(GDrawBoard)

class GOpenGLGradientDesc(GGradientDesc):
    __swig_setmethods__ = {}
    for _s in [GGradientDesc]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GOpenGLGradientDesc, name, value)
    __swig_getmethods__ = {}
    for _s in [GGradientDesc]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GOpenGLGradientDesc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GOpenGLGradientDesc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GOpenGLGradientDesc
    __del__ = lambda self : None;
    def SetColorKeys(*args): return _amanith.GOpenGLGradientDesc_SetColorKeys(*args)
    def GradientTexture(*args): return _amanith.GOpenGLGradientDesc_GradientTexture(*args)
GOpenGLGradientDesc_swigregister = _amanith.GOpenGLGradientDesc_swigregister
GOpenGLGradientDesc_swigregister(GOpenGLGradientDesc)

class GOpenGLPatternDesc(GPatternDesc):
    __swig_setmethods__ = {}
    for _s in [GPatternDesc]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GOpenGLPatternDesc, name, value)
    __swig_getmethods__ = {}
    for _s in [GPatternDesc]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GOpenGLPatternDesc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GOpenGLPatternDesc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GOpenGLPatternDesc
    __del__ = lambda self : None;
    def SetImage(*args): return _amanith.GOpenGLPatternDesc_SetImage(*args)
    def PatternTexture(*args): return _amanith.GOpenGLPatternDesc_PatternTexture(*args)
GOpenGLPatternDesc_swigregister = _amanith.GOpenGLPatternDesc_swigregister
GOpenGLPatternDesc_swigregister(GOpenGLPatternDesc)

class GOpenGLDrawStyle(GDrawStyle):
    __swig_setmethods__ = {}
    for _s in [GDrawStyle]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GOpenGLDrawStyle, name, value)
    __swig_getmethods__ = {}
    for _s in [GDrawStyle]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GOpenGLDrawStyle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GOpenGLDrawStyle(*args)
        try: self.this.append(this)
        except: self.this = this
    def SetStrokeColor(*args): return _amanith.GOpenGLDrawStyle_SetStrokeColor(*args)
    def SetFillColor(*args): return _amanith.GOpenGLDrawStyle_SetFillColor(*args)
    def SetStrokeMiterLimit(*args): return _amanith.GOpenGLDrawStyle_SetStrokeMiterLimit(*args)
    def SetStrokeWidth(*args): return _amanith.GOpenGLDrawStyle_SetStrokeWidth(*args)
    def StrokeMiterLimitMulThickness(*args): return _amanith.GOpenGLDrawStyle_StrokeMiterLimitMulThickness(*args)
    __swig_destroy__ = _amanith.delete_GOpenGLDrawStyle
    __del__ = lambda self : None;
GOpenGLDrawStyle_swigregister = _amanith.GOpenGLDrawStyle_swigregister
GOpenGLDrawStyle_swigregister(GOpenGLDrawStyle)

class GOpenGLCacheSlot(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GOpenGLCacheSlot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GOpenGLCacheSlot, name)
    __repr__ = _swig_repr
    __swig_setmethods__["FillDisplayList"] = _amanith.GOpenGLCacheSlot_FillDisplayList_set
    __swig_getmethods__["FillDisplayList"] = _amanith.GOpenGLCacheSlot_FillDisplayList_get
    if _newclass:FillDisplayList = property(_amanith.GOpenGLCacheSlot_FillDisplayList_get, _amanith.GOpenGLCacheSlot_FillDisplayList_set)
    __swig_setmethods__["StrokeDisplayList"] = _amanith.GOpenGLCacheSlot_StrokeDisplayList_set
    __swig_getmethods__["StrokeDisplayList"] = _amanith.GOpenGLCacheSlot_StrokeDisplayList_get
    if _newclass:StrokeDisplayList = property(_amanith.GOpenGLCacheSlot_StrokeDisplayList_get, _amanith.GOpenGLCacheSlot_StrokeDisplayList_set)
    __swig_setmethods__["Box"] = _amanith.GOpenGLCacheSlot_Box_set
    __swig_getmethods__["Box"] = _amanith.GOpenGLCacheSlot_Box_get
    if _newclass:Box = property(_amanith.GOpenGLCacheSlot_Box_get, _amanith.GOpenGLCacheSlot_Box_set)
    def __init__(self, *args): 
        this = _amanith.new_GOpenGLCacheSlot(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GOpenGLCacheSlot
    __del__ = lambda self : None;
GOpenGLCacheSlot_swigregister = _amanith.GOpenGLCacheSlot_swigregister
GOpenGLCacheSlot_swigregister(GOpenGLCacheSlot)

class GOpenGLCacheBank(GCacheBank):
    __swig_setmethods__ = {}
    for _s in [GCacheBank]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GOpenGLCacheBank, name, value)
    __swig_getmethods__ = {}
    for _s in [GCacheBank]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GOpenGLCacheBank, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GOpenGLCacheBank(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GOpenGLCacheBank
    __del__ = lambda self : None;
    def SlotsCount(*args): return _amanith.GOpenGLCacheBank_SlotsCount(*args)
    def Invalidate(*args): return _amanith.GOpenGLCacheBank_Invalidate(*args)
GOpenGLCacheBank_swigregister = _amanith.GOpenGLCacheBank_swigregister
GOpenGLCacheBank_swigregister(GOpenGLCacheBank)

class GLGrabbedRect(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GLGrabbedRect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GLGrabbedRect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["Width"] = _amanith.GLGrabbedRect_Width_set
    __swig_getmethods__["Width"] = _amanith.GLGrabbedRect_Width_get
    if _newclass:Width = property(_amanith.GLGrabbedRect_Width_get, _amanith.GLGrabbedRect_Width_set)
    __swig_setmethods__["Height"] = _amanith.GLGrabbedRect_Height_set
    __swig_getmethods__["Height"] = _amanith.GLGrabbedRect_Height_get
    if _newclass:Height = property(_amanith.GLGrabbedRect_Height_get, _amanith.GLGrabbedRect_Height_set)
    __swig_setmethods__["TexWidth"] = _amanith.GLGrabbedRect_TexWidth_set
    __swig_getmethods__["TexWidth"] = _amanith.GLGrabbedRect_TexWidth_get
    if _newclass:TexWidth = property(_amanith.GLGrabbedRect_TexWidth_get, _amanith.GLGrabbedRect_TexWidth_set)
    __swig_setmethods__["TexHeight"] = _amanith.GLGrabbedRect_TexHeight_set
    __swig_getmethods__["TexHeight"] = _amanith.GLGrabbedRect_TexHeight_get
    if _newclass:TexHeight = property(_amanith.GLGrabbedRect_TexHeight_get, _amanith.GLGrabbedRect_TexHeight_set)
    __swig_setmethods__["Target"] = _amanith.GLGrabbedRect_Target_set
    __swig_getmethods__["Target"] = _amanith.GLGrabbedRect_Target_get
    if _newclass:Target = property(_amanith.GLGrabbedRect_Target_get, _amanith.GLGrabbedRect_Target_set)
    __swig_setmethods__["Format"] = _amanith.GLGrabbedRect_Format_set
    __swig_getmethods__["Format"] = _amanith.GLGrabbedRect_Format_get
    if _newclass:Format = property(_amanith.GLGrabbedRect_Format_get, _amanith.GLGrabbedRect_Format_set)
    __swig_setmethods__["TexName"] = _amanith.GLGrabbedRect_TexName_set
    __swig_getmethods__["TexName"] = _amanith.GLGrabbedRect_TexName_get
    if _newclass:TexName = property(_amanith.GLGrabbedRect_TexName_get, _amanith.GLGrabbedRect_TexName_set)
    __swig_setmethods__["IsEmpty"] = _amanith.GLGrabbedRect_IsEmpty_set
    __swig_getmethods__["IsEmpty"] = _amanith.GLGrabbedRect_IsEmpty_get
    if _newclass:IsEmpty = property(_amanith.GLGrabbedRect_IsEmpty_get, _amanith.GLGrabbedRect_IsEmpty_set)
    __swig_setmethods__["gExpandedLogicBox"] = _amanith.GLGrabbedRect_gExpandedLogicBox_set
    __swig_getmethods__["gExpandedLogicBox"] = _amanith.GLGrabbedRect_gExpandedLogicBox_get
    if _newclass:gExpandedLogicBox = property(_amanith.GLGrabbedRect_gExpandedLogicBox_get, _amanith.GLGrabbedRect_gExpandedLogicBox_set)
    __swig_setmethods__["gNotExpandedLogicBox"] = _amanith.GLGrabbedRect_gNotExpandedLogicBox_set
    __swig_getmethods__["gNotExpandedLogicBox"] = _amanith.GLGrabbedRect_gNotExpandedLogicBox_get
    if _newclass:gNotExpandedLogicBox = property(_amanith.GLGrabbedRect_gNotExpandedLogicBox_get, _amanith.GLGrabbedRect_gNotExpandedLogicBox_set)
    def __init__(self, *args): 
        this = _amanith.new_GLGrabbedRect(*args)
        try: self.this.append(this)
        except: self.this = this
    def Valid(*args): return _amanith.GLGrabbedRect_Valid(*args)
    def SetValid(*args): return _amanith.GLGrabbedRect_SetValid(*args)
    __swig_destroy__ = _amanith.delete_GLGrabbedRect
    __del__ = lambda self : None;
GLGrabbedRect_swigregister = _amanith.GLGrabbedRect_swigregister
GLGrabbedRect_swigregister(GLGrabbedRect)

class GOpenGLBoard(GDrawBoard):
    __swig_setmethods__ = {}
    for _s in [GDrawBoard]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GOpenGLBoard, name, value)
    __swig_getmethods__ = {}
    for _s in [GDrawBoard]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GOpenGLBoard, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GOpenGLBoard(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GOpenGLBoard
    __del__ = lambda self : None;
    def MaxDashCount(*args): return _amanith.GOpenGLBoard_MaxDashCount(*args)
    def MaxColorKeys(*args): return _amanith.GOpenGLBoard_MaxColorKeys(*args)
    def MaxImageWidth(*args): return _amanith.GOpenGLBoard_MaxImageWidth(*args)
    def MaxImageHeight(*args): return _amanith.GOpenGLBoard_MaxImageHeight(*args)
    def MaxImageBytes(*args): return _amanith.GOpenGLBoard_MaxImageBytes(*args)
    def SetShadersEnabled(*args): return _amanith.GOpenGLBoard_SetShadersEnabled(*args)
    def SetRectTextureEnabled(*args): return _amanith.GOpenGLBoard_SetRectTextureEnabled(*args)
    def SetCustomRenderingQuality(*args): return _amanith.GOpenGLBoard_SetCustomRenderingQuality(*args)
    def CreateLinearGradient(*args): return _amanith.GOpenGLBoard_CreateLinearGradient(*args)
    def CreateRadialGradient(*args): return _amanith.GOpenGLBoard_CreateRadialGradient(*args)
    def CreateConicalGradient(*args): return _amanith.GOpenGLBoard_CreateConicalGradient(*args)
    def CreatePattern(*args): return _amanith.GOpenGLBoard_CreatePattern(*args)
    def CreateCacheBank(*args): return _amanith.GOpenGLBoard_CreateCacheBank(*args)
    def CacheBank(*args): return _amanith.GOpenGLBoard_CacheBank(*args)
    def SetCacheBank(*args): return _amanith.GOpenGLBoard_SetCacheBank(*args)
    def ColorFromString(*args): return _amanith.GOpenGLBoard_ColorFromString(*args)
    def BeginPaths(*args): return _amanith.GOpenGLBoard_BeginPaths(*args)
    def MoveTo(*args): return _amanith.GOpenGLBoard_MoveTo(*args)
    def LineTo(*args): return _amanith.GOpenGLBoard_LineTo(*args)
    def HorizontalLineTo(*args): return _amanith.GOpenGLBoard_HorizontalLineTo(*args)
    def VerticalLineTo(*args): return _amanith.GOpenGLBoard_VerticalLineTo(*args)
    def CurveTo(*args): return _amanith.GOpenGLBoard_CurveTo(*args)
    def SmoothCurveTo(*args): return _amanith.GOpenGLBoard_SmoothCurveTo(*args)
    def EllipticalArcTo(*args): return _amanith.GOpenGLBoard_EllipticalArcTo(*args)
    def ClosePath(*args): return _amanith.GOpenGLBoard_ClosePath(*args)
    def EndPaths(*args): return _amanith.GOpenGLBoard_EndPaths(*args)
GOpenGLBoard_swigregister = _amanith.GOpenGLBoard_swigregister
GOpenGLBoard_swigregister(GOpenGLBoard)

class GAVLNode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAVLNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GAVLNode, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GAVLNode(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GAVLNode
    __del__ = lambda self : None;
    def LeftChild(*args): return _amanith.GAVLNode_LeftChild(*args)
    def RightChild(*args): return _amanith.GAVLNode_RightChild(*args)
    def Father(*args): return _amanith.GAVLNode_Father(*args)
    def CustomData(*args): return _amanith.GAVLNode_CustomData(*args)
    def BalanceFactor(*args): return _amanith.GAVLNode_BalanceFactor(*args)
GAVLNode_swigregister = _amanith.GAVLNode_swigregister
GAVLNode_swigregister(GAVLNode)

class GAVLTree(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAVLTree, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GAVLTree, name)
    def __init__(self): raise AttributeError, "No constructor defined"
    __repr__ = _swig_repr
    __swig_destroy__ = _amanith.delete_GAVLTree
    __del__ = lambda self : None;
    def Root(*args): return _amanith.GAVLTree_Root(*args)
    def NodesCount(*args): return _amanith.GAVLTree_NodesCount(*args)
    def Min(*args): return _amanith.GAVLTree_Min(*args)
    def Max(*args): return _amanith.GAVLTree_Max(*args)
    def Next(*args): return _amanith.GAVLTree_Next(*args)
    def Prev(*args): return _amanith.GAVLTree_Prev(*args)
    def Insert(*args): return _amanith.GAVLTree_Insert(*args)
    def Delete(*args): return _amanith.GAVLTree_Delete(*args)
    def DeleteNode(*args): return _amanith.GAVLTree_DeleteNode(*args)
    def Find(*args): return _amanith.GAVLTree_Find(*args)
    def FindPrev(*args): return _amanith.GAVLTree_FindPrev(*args)
    def FindNext(*args): return _amanith.GAVLTree_FindNext(*args)
    def Compare(*args): return _amanith.GAVLTree_Compare(*args)
GAVLTree_swigregister = _amanith.GAVLTree_swigregister
GAVLTree_swigregister(GAVLTree)

class GSVGPathTokenizer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GSVGPathTokenizer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GSVGPathTokenizer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GSVGPathTokenizer(*args)
        try: self.this.append(this)
        except: self.this = this
    def NextTkn(*args): return _amanith.GSVGPathTokenizer_NextTkn(*args)
    def NextTknAsReal(*args): return _amanith.GSVGPathTokenizer_NextTknAsReal(*args)
    def NextTknAsBool(*args): return _amanith.GSVGPathTokenizer_NextTknAsBool(*args)
    def LastCmd(*args): return _amanith.GSVGPathTokenizer_LastCmd(*args)
    def LastNum(*args): return _amanith.GSVGPathTokenizer_LastNum(*args)
    def LastFlg(*args): return _amanith.GSVGPathTokenizer_LastFlg(*args)
    __swig_destroy__ = _amanith.delete_GSVGPathTokenizer
    __del__ = lambda self : None;
GSVGPathTokenizer_swigregister = _amanith.GSVGPathTokenizer_swigregister
GSVGPathTokenizer_swigregister(GSVGPathTokenizer)

class GVectorBase2(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GVectorBase2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GVectorBase2, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GVectorBase2(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GVectorBase2_Set(*args)
    def Data(*args): return _amanith.GVectorBase2_Data(*args)
    def Swap(*args): return _amanith.GVectorBase2_Swap(*args)
    def Fill(*args): return _amanith.GVectorBase2_Fill(*args)
    def __eq__(*args): return _amanith.GVectorBase2___eq__(*args)
    def __ne__(*args): return _amanith.GVectorBase2___ne__(*args)
    __swig_destroy__ = _amanith.delete_GVectorBase2
    __del__ = lambda self : None;
GVectorBase2_swigregister = _amanith.GVectorBase2_swigregister
GVectorBase2_swigregister(GVectorBase2)

class GVectorBase3(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GVectorBase3, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GVectorBase3, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GVectorBase3(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GVectorBase3_Set(*args)
    def Data(*args): return _amanith.GVectorBase3_Data(*args)
    def Swap(*args): return _amanith.GVectorBase3_Swap(*args)
    def Fill(*args): return _amanith.GVectorBase3_Fill(*args)
    def __eq__(*args): return _amanith.GVectorBase3___eq__(*args)
    def __ne__(*args): return _amanith.GVectorBase3___ne__(*args)
    __swig_destroy__ = _amanith.delete_GVectorBase3
    __del__ = lambda self : None;
GVectorBase3_swigregister = _amanith.GVectorBase3_swigregister
GVectorBase3_swigregister(GVectorBase3)

class GVectorBase4(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GVectorBase4, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GVectorBase4, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GVectorBase4(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GVectorBase4_Set(*args)
    def Data(*args): return _amanith.GVectorBase4_Data(*args)
    def Swap(*args): return _amanith.GVectorBase4_Swap(*args)
    def Fill(*args): return _amanith.GVectorBase4_Fill(*args)
    def __eq__(*args): return _amanith.GVectorBase4___eq__(*args)
    def __ne__(*args): return _amanith.GVectorBase4___ne__(*args)
    __swig_destroy__ = _amanith.delete_GVectorBase4
    __del__ = lambda self : None;
GVectorBase4_swigregister = _amanith.GVectorBase4_swigregister
GVectorBase4_swigregister(GVectorBase4)

class GVector2(GVectorBase2):
    __swig_setmethods__ = {}
    for _s in [GVectorBase2]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GVector2, name, value)
    __swig_getmethods__ = {}
    for _s in [GVectorBase2]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GVector2, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GVector2(*args)
        try: self.this.append(this)
        except: self.this = this
    def LengthSquared(*args): return _amanith.GVector2_LengthSquared(*args)
    def Length(*args): return _amanith.GVector2_Length(*args)
    def Normalize(*args): return _amanith.GVector2_Normalize(*args)
    def IsNormalized(*args): return _amanith.GVector2_IsNormalized(*args)
    def __getitem__(*args): return _amanith.GVector2___getitem__(*args)
    def __setitem__(*args): return _amanith.GVector2___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GVector2
    __del__ = lambda self : None;
GVector2_swigregister = _amanith.GVector2_swigregister
GVector2_swigregister(GVector2)

class GVector3(GVectorBase3):
    __swig_setmethods__ = {}
    for _s in [GVectorBase3]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GVector3, name, value)
    __swig_getmethods__ = {}
    for _s in [GVectorBase3]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GVector3, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GVector3(*args)
        try: self.this.append(this)
        except: self.this = this
    def LengthSquared(*args): return _amanith.GVector3_LengthSquared(*args)
    def Length(*args): return _amanith.GVector3_Length(*args)
    def Normalize(*args): return _amanith.GVector3_Normalize(*args)
    def IsNormalized(*args): return _amanith.GVector3_IsNormalized(*args)
    def __getitem__(*args): return _amanith.GVector3___getitem__(*args)
    def __setitem__(*args): return _amanith.GVector3___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GVector3
    __del__ = lambda self : None;
GVector3_swigregister = _amanith.GVector3_swigregister
GVector3_swigregister(GVector3)

class GVector4(GVectorBase4):
    __swig_setmethods__ = {}
    for _s in [GVectorBase4]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GVector4, name, value)
    __swig_getmethods__ = {}
    for _s in [GVectorBase4]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GVector4, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GVector4(*args)
        try: self.this.append(this)
        except: self.this = this
    def LengthSquared(*args): return _amanith.GVector4_LengthSquared(*args)
    def Length(*args): return _amanith.GVector4_Length(*args)
    def Normalize(*args): return _amanith.GVector4_Normalize(*args)
    def IsNormalized(*args): return _amanith.GVector4_IsNormalized(*args)
    def __getitem__(*args): return _amanith.GVector4___getitem__(*args)
    def __setitem__(*args): return _amanith.GVector4___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GVector4
    __del__ = lambda self : None;
GVector4_swigregister = _amanith.GVector4_swigregister
GVector4_swigregister(GVector4)

class GPoint2(GVectorBase2):
    __swig_setmethods__ = {}
    for _s in [GVectorBase2]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPoint2, name, value)
    __swig_getmethods__ = {}
    for _s in [GVectorBase2]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPoint2, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPoint2(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPoint2
    __del__ = lambda self : None;
GPoint2_swigregister = _amanith.GPoint2_swigregister
GPoint2_swigregister(GPoint2)

class GPoint3(GVectorBase3):
    __swig_setmethods__ = {}
    for _s in [GVectorBase3]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPoint3, name, value)
    __swig_getmethods__ = {}
    for _s in [GVectorBase3]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPoint3, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPoint3(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPoint3
    __del__ = lambda self : None;
GPoint3_swigregister = _amanith.GPoint3_swigregister
GPoint3_swigregister(GPoint3)

class GPoint4(GVectorBase4):
    __swig_setmethods__ = {}
    for _s in [GVectorBase4]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GPoint4, name, value)
    __swig_getmethods__ = {}
    for _s in [GVectorBase4]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GPoint4, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GPoint4(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _amanith.delete_GPoint4
    __del__ = lambda self : None;
GPoint4_swigregister = _amanith.GPoint4_swigregister
GPoint4_swigregister(GPoint4)

class GAxisAngle(GVectorBase4):
    __swig_setmethods__ = {}
    for _s in [GVectorBase4]: __swig_setmethods__.update(_s.__swig_setmethods__)
    __setattr__ = lambda self, name, value: _swig_setattr(self, GAxisAngle, name, value)
    __swig_getmethods__ = {}
    for _s in [GVectorBase4]: __swig_getmethods__.update(_s.__swig_getmethods__)
    __getattr__ = lambda self, name: _swig_getattr(self, GAxisAngle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GAxisAngle(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GAxisAngle_Set(*args)
    def SetAxis(*args): return _amanith.GAxisAngle_SetAxis(*args)
    def SetAngle(*args): return _amanith.GAxisAngle_SetAngle(*args)
    def Axis(*args): return _amanith.GAxisAngle_Axis(*args)
    def Angle(*args): return _amanith.GAxisAngle_Angle(*args)
    __swig_destroy__ = _amanith.delete_GAxisAngle
    __del__ = lambda self : None;
GAxisAngle_swigregister = _amanith.GAxisAngle_swigregister
GAxisAngle_swigregister(GAxisAngle)

class GQuaternion(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GQuaternion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GQuaternion, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GQuaternion(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GQuaternion_Set(*args)
    def Get(*args): return _amanith.GQuaternion_Get(*args)
    def Data(*args): return _amanith.GQuaternion_Data(*args)
    def Swap(*args): return _amanith.GQuaternion_Swap(*args)
    def __eq__(*args): return _amanith.GQuaternion___eq__(*args)
    def __ne__(*args): return _amanith.GQuaternion___ne__(*args)
    def __neg__(*args): return _amanith.GQuaternion___neg__(*args)
    def __iadd__(*args): return _amanith.GQuaternion___iadd__(*args)
    def __add__(*args): return _amanith.GQuaternion___add__(*args)
    def __isub__(*args): return _amanith.GQuaternion___isub__(*args)
    def __sub__(*args): return _amanith.GQuaternion___sub__(*args)
    def __mul__(*args): return _amanith.GQuaternion___mul__(*args)
    def __imul__(*args): return _amanith.GQuaternion___imul__(*args)
    def __div__(*args): return _amanith.GQuaternion___div__(*args)
    def __idiv__(*args): return _amanith.GQuaternion___idiv__(*args)
    def LengthSquared(*args): return _amanith.GQuaternion_LengthSquared(*args)
    def Length(*args): return _amanith.GQuaternion_Length(*args)
    def Normalize(*args): return _amanith.GQuaternion_Normalize(*args)
    def IsNormalized(*args): return _amanith.GQuaternion_IsNormalized(*args)
    def Conj(*args): return _amanith.GQuaternion_Conj(*args)
    def Invert(*args): return _amanith.GQuaternion_Invert(*args)
    def Exp(*args): return _amanith.GQuaternion_Exp(*args)
    def Log(*args): return _amanith.GQuaternion_Log(*args)
    def __getitem__(*args): return _amanith.GQuaternion___getitem__(*args)
    def __setitem__(*args): return _amanith.GQuaternion___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GQuaternion
    __del__ = lambda self : None;
GQuaternion_swigregister = _amanith.GQuaternion_swigregister
GQuaternion_swigregister(GQuaternion)

class GMatrix22(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMatrix22, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMatrix22, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GMatrix22(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GMatrix22_Set(*args)
    def SetTranspose(*args): return _amanith.GMatrix22_SetTranspose(*args)
    def __call__(*args): return _amanith.GMatrix22___call__(*args)
    def Data(*args): return _amanith.GMatrix22_Data(*args)
    def SwapRow(*args): return _amanith.GMatrix22_SwapRow(*args)
    def SwapColumn(*args): return _amanith.GMatrix22_SwapColumn(*args)
    def Norm1(*args): return _amanith.GMatrix22_Norm1(*args)
    def NormInf(*args): return _amanith.GMatrix22_NormInf(*args)
    def NormFrobenius(*args): return _amanith.GMatrix22_NormFrobenius(*args)
    def __eq__(*args): return _amanith.GMatrix22___eq__(*args)
    def __ne__(*args): return _amanith.GMatrix22___ne__(*args)
    def __getitem__(*args): return _amanith.GMatrix22___getitem__(*args)
    def __setitem__(*args): return _amanith.GMatrix22___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GMatrix22
    __del__ = lambda self : None;
GMatrix22_swigregister = _amanith.GMatrix22_swigregister
GMatrix22_swigregister(GMatrix22)

class GMatrix23(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMatrix23, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMatrix23, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GMatrix23(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GMatrix23_Set(*args)
    def SetTranspose(*args): return _amanith.GMatrix23_SetTranspose(*args)
    def __call__(*args): return _amanith.GMatrix23___call__(*args)
    def Data(*args): return _amanith.GMatrix23_Data(*args)
    def SwapRow(*args): return _amanith.GMatrix23_SwapRow(*args)
    def SwapColumn(*args): return _amanith.GMatrix23_SwapColumn(*args)
    def Norm1(*args): return _amanith.GMatrix23_Norm1(*args)
    def NormInf(*args): return _amanith.GMatrix23_NormInf(*args)
    def NormFrobenius(*args): return _amanith.GMatrix23_NormFrobenius(*args)
    def __eq__(*args): return _amanith.GMatrix23___eq__(*args)
    def __ne__(*args): return _amanith.GMatrix23___ne__(*args)
    def __getitem__(*args): return _amanith.GMatrix23___getitem__(*args)
    def __setitem__(*args): return _amanith.GMatrix23___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GMatrix23
    __del__ = lambda self : None;
GMatrix23_swigregister = _amanith.GMatrix23_swigregister
GMatrix23_swigregister(GMatrix23)

class GMatrix33(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMatrix33, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMatrix33, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GMatrix33(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GMatrix33_Set(*args)
    def SetTranspose(*args): return _amanith.GMatrix33_SetTranspose(*args)
    def __call__(*args): return _amanith.GMatrix33___call__(*args)
    def Data(*args): return _amanith.GMatrix33_Data(*args)
    def SwapRow(*args): return _amanith.GMatrix33_SwapRow(*args)
    def SwapColumn(*args): return _amanith.GMatrix33_SwapColumn(*args)
    def Norm1(*args): return _amanith.GMatrix33_Norm1(*args)
    def NormInf(*args): return _amanith.GMatrix33_NormInf(*args)
    def NormFrobenius(*args): return _amanith.GMatrix33_NormFrobenius(*args)
    def __eq__(*args): return _amanith.GMatrix33___eq__(*args)
    def __ne__(*args): return _amanith.GMatrix33___ne__(*args)
    def __getitem__(*args): return _amanith.GMatrix33___getitem__(*args)
    def __setitem__(*args): return _amanith.GMatrix33___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GMatrix33
    __del__ = lambda self : None;
GMatrix33_swigregister = _amanith.GMatrix33_swigregister
GMatrix33_swigregister(GMatrix33)

class GMatrix34(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMatrix34, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMatrix34, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GMatrix34(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GMatrix34_Set(*args)
    def SetTranspose(*args): return _amanith.GMatrix34_SetTranspose(*args)
    def __call__(*args): return _amanith.GMatrix34___call__(*args)
    def Data(*args): return _amanith.GMatrix34_Data(*args)
    def SwapRow(*args): return _amanith.GMatrix34_SwapRow(*args)
    def SwapColumn(*args): return _amanith.GMatrix34_SwapColumn(*args)
    def Norm1(*args): return _amanith.GMatrix34_Norm1(*args)
    def NormInf(*args): return _amanith.GMatrix34_NormInf(*args)
    def NormFrobenius(*args): return _amanith.GMatrix34_NormFrobenius(*args)
    def __eq__(*args): return _amanith.GMatrix34___eq__(*args)
    def __ne__(*args): return _amanith.GMatrix34___ne__(*args)
    def __getitem__(*args): return _amanith.GMatrix34___getitem__(*args)
    def __setitem__(*args): return _amanith.GMatrix34___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GMatrix34
    __del__ = lambda self : None;
GMatrix34_swigregister = _amanith.GMatrix34_swigregister
GMatrix34_swigregister(GMatrix34)

class GMatrix43(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMatrix43, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMatrix43, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GMatrix43(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GMatrix43_Set(*args)
    def SetTranspose(*args): return _amanith.GMatrix43_SetTranspose(*args)
    def __call__(*args): return _amanith.GMatrix43___call__(*args)
    def Data(*args): return _amanith.GMatrix43_Data(*args)
    def SwapRow(*args): return _amanith.GMatrix43_SwapRow(*args)
    def SwapColumn(*args): return _amanith.GMatrix43_SwapColumn(*args)
    def Norm1(*args): return _amanith.GMatrix43_Norm1(*args)
    def NormInf(*args): return _amanith.GMatrix43_NormInf(*args)
    def NormFrobenius(*args): return _amanith.GMatrix43_NormFrobenius(*args)
    def __eq__(*args): return _amanith.GMatrix43___eq__(*args)
    def __ne__(*args): return _amanith.GMatrix43___ne__(*args)
    def __getitem__(*args): return _amanith.GMatrix43___getitem__(*args)
    def __setitem__(*args): return _amanith.GMatrix43___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GMatrix43
    __del__ = lambda self : None;
GMatrix43_swigregister = _amanith.GMatrix43_swigregister
GMatrix43_swigregister(GMatrix43)

class GMatrix44(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GMatrix44, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GMatrix44, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _amanith.new_GMatrix44(*args)
        try: self.this.append(this)
        except: self.this = this
    def Set(*args): return _amanith.GMatrix44_Set(*args)
    def SetTranspose(*args): return _amanith.GMatrix44_SetTranspose(*args)
    def __call__(*args): return _amanith.GMatrix44___call__(*args)
    def Data(*args): return _amanith.GMatrix44_Data(*args)
    def SwapRow(*args): return _amanith.GMatrix44_SwapRow(*args)
    def SwapColumn(*args): return _amanith.GMatrix44_SwapColumn(*args)
    def Norm1(*args): return _amanith.GMatrix44_Norm1(*args)
    def NormInf(*args): return _amanith.GMatrix44_NormInf(*args)
    def NormFrobenius(*args): return _amanith.GMatrix44_NormFrobenius(*args)
    def __eq__(*args): return _amanith.GMatrix44___eq__(*args)
    def __ne__(*args): return _amanith.GMatrix44___ne__(*args)
    def __getitem__(*args): return _amanith.GMatrix44___getitem__(*args)
    def __setitem__(*args): return _amanith.GMatrix44___setitem__(*args)
    __swig_destroy__ = _amanith.delete_GMatrix44
    __del__ = lambda self : None;
GMatrix44_swigregister = _amanith.GMatrix44_swigregister
GMatrix44_swigregister(GMatrix44)



