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

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

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

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

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

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


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


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _fife.SwigPyIterator_value(self)
    def incr(self, n = 1): return _fife.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _fife.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _fife.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _fife.SwigPyIterator_equal(self, *args)
    def copy(self): return _fife.SwigPyIterator_copy(self)
    def next(self): return _fife.SwigPyIterator_next(self)
    def __next__(self): return _fife.SwigPyIterator___next__(self)
    def previous(self): return _fife.SwigPyIterator_previous(self)
    def advance(self, *args): return _fife.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _fife.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _fife.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _fife.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _fife.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _fife.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _fife.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _fife.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class StringVector(_object):
    """Proxy of C++ std::vector<(std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.StringVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.StringVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.StringVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.StringVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.StringVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> StringVector"""
        return _fife.StringVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, StringVector v)"""
        return _fife.StringVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.StringVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> StringVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, StringVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.StringVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.StringVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.StringVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.StringVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.StringVector_clear(self)

    def swap(self, *args):
        """swap(self, StringVector v)"""
        return _fife.StringVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.StringVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.StringVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.StringVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.StringVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.StringVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.StringVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.StringVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> StringVector
        __init__(self, StringVector arg0) -> StringVector
        __init__(self, size_type size) -> StringVector
        __init__(self, size_type size, value_type value) -> StringVector
        """
        this = _fife.new_StringVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.StringVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.StringVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.StringVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.StringVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.StringVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.StringVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.StringVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.StringVector_capacity(self)

    __swig_destroy__ = _fife.delete_StringVector
    __del__ = lambda self : None;
StringVector_swigregister = _fife.StringVector_swigregister
StringVector_swigregister(StringVector)

class UintVector(_object):
    """Proxy of C++ std::vector<(uint32_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UintVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UintVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.UintVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.UintVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.UintVector___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(unsigned int)>::size_type"""
        return _fife.UintVector___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(unsigned int)>::value_type"""
        return _fife.UintVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, std::vector<(unsigned int)>::difference_type i, std::vector<(unsigned int)>::difference_type j) -> UintVector"""
        return _fife.UintVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(unsigned int)>::difference_type i, std::vector<(unsigned int)>::difference_type j, 
            UintVector v)
        """
        return _fife.UintVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, std::vector<(unsigned int)>::difference_type i, std::vector<(unsigned int)>::difference_type j)"""
        return _fife.UintVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(unsigned int)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.UintVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> UintVector
        __getitem__(self, std::vector<(unsigned int)>::difference_type i) -> std::vector<(unsigned int)>::value_type
        """
        return _fife.UintVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, UintVector v)
        __setitem__(self, std::vector<(unsigned int)>::difference_type i, std::vector<(unsigned int)>::value_type x)
        """
        return _fife.UintVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(unsigned int)>::value_type x)"""
        return _fife.UintVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.UintVector_empty(self)

    def size(self):
        """size(self) -> std::vector<(unsigned int)>::size_type"""
        return _fife.UintVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.UintVector_clear(self)

    def swap(self, *args):
        """swap(self, UintVector v)"""
        return _fife.UintVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(unsigned int)>::allocator_type"""
        return _fife.UintVector_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(unsigned int)>::const_iterator"""
        return _fife.UintVector_begin(self)

    def end(self):
        """end(self) -> std::vector<(unsigned int)>::const_iterator"""
        return _fife.UintVector_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(unsigned int)>::const_reverse_iterator"""
        return _fife.UintVector_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(unsigned int)>::const_reverse_iterator"""
        return _fife.UintVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.UintVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(unsigned int)>::iterator pos) -> std::vector<(unsigned int)>::iterator
        erase(self, std::vector<(unsigned int)>::iterator first, std::vector<(unsigned int)>::iterator last) -> std::vector<(unsigned int)>::iterator
        """
        return _fife.UintVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> UintVector
        __init__(self, UintVector arg0) -> UintVector
        __init__(self, std::vector<(unsigned int)>::size_type size) -> UintVector
        __init__(self, std::vector<(unsigned int)>::size_type size, std::vector<(unsigned int)>::value_type value) -> UintVector
        """
        this = _fife.new_UintVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(unsigned int)>::value_type x)"""
        return _fife.UintVector_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(unsigned int)>::value_type"""
        return _fife.UintVector_front(self)

    def back(self):
        """back(self) -> std::vector<(unsigned int)>::value_type"""
        return _fife.UintVector_back(self)

    def assign(self, *args):
        """assign(self, std::vector<(unsigned int)>::size_type n, std::vector<(unsigned int)>::value_type x)"""
        return _fife.UintVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(unsigned int)>::size_type new_size)
        resize(self, std::vector<(unsigned int)>::size_type new_size, std::vector<(unsigned int)>::value_type x)
        """
        return _fife.UintVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(unsigned int)>::iterator pos, std::vector<(unsigned int)>::value_type x) -> std::vector<(unsigned int)>::iterator
        insert(self, std::vector<(unsigned int)>::iterator pos, std::vector<(unsigned int)>::size_type n, 
            std::vector<(unsigned int)>::value_type x)
        """
        return _fife.UintVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(unsigned int)>::size_type n)"""
        return _fife.UintVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(unsigned int)>::size_type"""
        return _fife.UintVector_capacity(self)

    __swig_destroy__ = _fife.delete_UintVector
    __del__ = lambda self : None;
UintVector_swigregister = _fife.UintVector_swigregister
UintVector_swigregister(UintVector)

class IntVector(_object):
    """Proxy of C++ std::vector<(int32_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IntVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IntVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.IntVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.IntVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.IntVector___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(int)>::size_type"""
        return _fife.IntVector___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(int)>::value_type"""
        return _fife.IntVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, std::vector<(int)>::difference_type i, std::vector<(int)>::difference_type j) -> IntVector"""
        return _fife.IntVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(int)>::difference_type i, std::vector<(int)>::difference_type j, 
            IntVector v)
        """
        return _fife.IntVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, std::vector<(int)>::difference_type i, std::vector<(int)>::difference_type j)"""
        return _fife.IntVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(int)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.IntVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> IntVector
        __getitem__(self, std::vector<(int)>::difference_type i) -> std::vector<(int)>::value_type
        """
        return _fife.IntVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, IntVector v)
        __setitem__(self, std::vector<(int)>::difference_type i, std::vector<(int)>::value_type x)
        """
        return _fife.IntVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(int)>::value_type x)"""
        return _fife.IntVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.IntVector_empty(self)

    def size(self):
        """size(self) -> std::vector<(int)>::size_type"""
        return _fife.IntVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.IntVector_clear(self)

    def swap(self, *args):
        """swap(self, IntVector v)"""
        return _fife.IntVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(int)>::allocator_type"""
        return _fife.IntVector_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(int)>::const_iterator"""
        return _fife.IntVector_begin(self)

    def end(self):
        """end(self) -> std::vector<(int)>::const_iterator"""
        return _fife.IntVector_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(int)>::const_reverse_iterator"""
        return _fife.IntVector_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(int)>::const_reverse_iterator"""
        return _fife.IntVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.IntVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(int)>::iterator pos) -> std::vector<(int)>::iterator
        erase(self, std::vector<(int)>::iterator first, std::vector<(int)>::iterator last) -> std::vector<(int)>::iterator
        """
        return _fife.IntVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> IntVector
        __init__(self, IntVector arg0) -> IntVector
        __init__(self, std::vector<(int)>::size_type size) -> IntVector
        __init__(self, std::vector<(int)>::size_type size, std::vector<(int)>::value_type value) -> IntVector
        """
        this = _fife.new_IntVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(int)>::value_type x)"""
        return _fife.IntVector_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(int)>::value_type"""
        return _fife.IntVector_front(self)

    def back(self):
        """back(self) -> std::vector<(int)>::value_type"""
        return _fife.IntVector_back(self)

    def assign(self, *args):
        """assign(self, std::vector<(int)>::size_type n, std::vector<(int)>::value_type x)"""
        return _fife.IntVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(int)>::size_type new_size)
        resize(self, std::vector<(int)>::size_type new_size, std::vector<(int)>::value_type x)
        """
        return _fife.IntVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(int)>::iterator pos, std::vector<(int)>::value_type x) -> std::vector<(int)>::iterator
        insert(self, std::vector<(int)>::iterator pos, std::vector<(int)>::size_type n, 
            std::vector<(int)>::value_type x)
        """
        return _fife.IntVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(int)>::size_type n)"""
        return _fife.IntVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(int)>::size_type"""
        return _fife.IntVector_capacity(self)

    __swig_destroy__ = _fife.delete_IntVector
    __del__ = lambda self : None;
IntVector_swigregister = _fife.IntVector_swigregister
IntVector_swigregister(IntVector)

class FloatVector(_object):
    """Proxy of C++ std::vector<(float)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.FloatVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.FloatVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.FloatVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.FloatVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.FloatVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> FloatVector"""
        return _fife.FloatVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, FloatVector v)"""
        return _fife.FloatVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.FloatVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.FloatVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> FloatVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.FloatVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, FloatVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.FloatVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.FloatVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.FloatVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.FloatVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.FloatVector_clear(self)

    def swap(self, *args):
        """swap(self, FloatVector v)"""
        return _fife.FloatVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.FloatVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.FloatVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.FloatVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.FloatVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.FloatVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.FloatVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.FloatVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> FloatVector
        __init__(self, FloatVector arg0) -> FloatVector
        __init__(self, size_type size) -> FloatVector
        __init__(self, size_type size, value_type value) -> FloatVector
        """
        this = _fife.new_FloatVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.FloatVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.FloatVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.FloatVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.FloatVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.FloatVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.FloatVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.FloatVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.FloatVector_capacity(self)

    __swig_destroy__ = _fife.delete_FloatVector
    __del__ = lambda self : None;
FloatVector_swigregister = _fife.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

class DoubleVector(_object):
    """Proxy of C++ std::vector<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.DoubleVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.DoubleVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.DoubleVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.DoubleVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.DoubleVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> DoubleVector"""
        return _fife.DoubleVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, DoubleVector v)"""
        return _fife.DoubleVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.DoubleVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.DoubleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> DoubleVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.DoubleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, DoubleVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.DoubleVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.DoubleVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.DoubleVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.DoubleVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.DoubleVector_clear(self)

    def swap(self, *args):
        """swap(self, DoubleVector v)"""
        return _fife.DoubleVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.DoubleVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.DoubleVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.DoubleVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.DoubleVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.DoubleVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.DoubleVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.DoubleVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> DoubleVector
        __init__(self, DoubleVector arg0) -> DoubleVector
        __init__(self, size_type size) -> DoubleVector
        __init__(self, size_type size, value_type value) -> DoubleVector
        """
        this = _fife.new_DoubleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.DoubleVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.DoubleVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.DoubleVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.DoubleVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.DoubleVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.DoubleVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.DoubleVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.DoubleVector_capacity(self)

    __swig_destroy__ = _fife.delete_DoubleVector
    __del__ = lambda self : None;
DoubleVector_swigregister = _fife.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class BoolVector(_object):
    """Proxy of C++ std::vector<(bool)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BoolVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BoolVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.BoolVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.BoolVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.BoolVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.BoolVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.BoolVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> BoolVector"""
        return _fife.BoolVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, BoolVector v)"""
        return _fife.BoolVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.BoolVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.BoolVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> BoolVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.BoolVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, BoolVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.BoolVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.BoolVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.BoolVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.BoolVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.BoolVector_clear(self)

    def swap(self, *args):
        """swap(self, BoolVector v)"""
        return _fife.BoolVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.BoolVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.BoolVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.BoolVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.BoolVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.BoolVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.BoolVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.BoolVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> BoolVector
        __init__(self, BoolVector arg0) -> BoolVector
        __init__(self, size_type size) -> BoolVector
        __init__(self, size_type size, value_type value) -> BoolVector
        """
        this = _fife.new_BoolVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.BoolVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.BoolVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.BoolVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.BoolVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.BoolVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.BoolVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.BoolVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.BoolVector_capacity(self)

    __swig_destroy__ = _fife.delete_BoolVector
    __del__ = lambda self : None;
BoolVector_swigregister = _fife.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

class Uint16Uint16Pair(_object):
    """Proxy of C++ std::pair<(uint16_t,uint16_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Uint16Uint16Pair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Uint16Uint16Pair, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Uint16Uint16Pair
        __init__(self, unsigned short first, unsigned short second) -> Uint16Uint16Pair
        __init__(self, Uint16Uint16Pair p) -> Uint16Uint16Pair
        """
        this = _fife.new_Uint16Uint16Pair(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["first"] = _fife.Uint16Uint16Pair_first_set
    __swig_getmethods__["first"] = _fife.Uint16Uint16Pair_first_get
    if _newclass:first = _swig_property(_fife.Uint16Uint16Pair_first_get, _fife.Uint16Uint16Pair_first_set)
    __swig_setmethods__["second"] = _fife.Uint16Uint16Pair_second_set
    __swig_getmethods__["second"] = _fife.Uint16Uint16Pair_second_get
    if _newclass:second = _swig_property(_fife.Uint16Uint16Pair_second_get, _fife.Uint16Uint16Pair_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _fife.delete_Uint16Uint16Pair
    __del__ = lambda self : None;
Uint16Uint16Pair_swigregister = _fife.Uint16Uint16Pair_swigregister
Uint16Uint16Pair_swigregister(Uint16Uint16Pair)

class Uint16Uint16PairVector(_object):
    """Proxy of C++ std::vector<(std::pair<(uint16_t,uint16_t)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Uint16Uint16PairVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Uint16Uint16PairVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.Uint16Uint16PairVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.Uint16Uint16PairVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.Uint16Uint16PairVector___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type"""
        return _fife.Uint16Uint16PairVector___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type"""
        return _fife.Uint16Uint16PairVector_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type j) -> Uint16Uint16PairVector
        """
        return _fife.Uint16Uint16PairVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type j, 
            Uint16Uint16PairVector v)
        """
        return _fife.Uint16Uint16PairVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type j)
        """
        return _fife.Uint16Uint16PairVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.Uint16Uint16PairVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> Uint16Uint16PairVector
        __getitem__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type
        """
        return _fife.Uint16Uint16PairVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, Uint16Uint16PairVector v)
        __setitem__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::difference_type i, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)
        """
        return _fife.Uint16Uint16PairVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)"""
        return _fife.Uint16Uint16PairVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.Uint16Uint16PairVector_empty(self)

    def size(self):
        """size(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type"""
        return _fife.Uint16Uint16PairVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.Uint16Uint16PairVector_clear(self)

    def swap(self, *args):
        """swap(self, Uint16Uint16PairVector v)"""
        return _fife.Uint16Uint16PairVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::allocator_type"""
        return _fife.Uint16Uint16PairVector_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_iterator"""
        return _fife.Uint16Uint16PairVector_begin(self)

    def end(self):
        """end(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_iterator"""
        return _fife.Uint16Uint16PairVector_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_reverse_iterator"""
        return _fife.Uint16Uint16PairVector_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::const_reverse_iterator"""
        return _fife.Uint16Uint16PairVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.Uint16Uint16PairVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator pos) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator
        erase(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator first, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator last) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator
        """
        return _fife.Uint16Uint16PairVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> Uint16Uint16PairVector
        __init__(self, Uint16Uint16PairVector arg0) -> Uint16Uint16PairVector
        __init__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type size) -> Uint16Uint16PairVector
        __init__(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type size, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type value) -> Uint16Uint16PairVector
        """
        this = _fife.new_Uint16Uint16PairVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)"""
        return _fife.Uint16Uint16PairVector_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type"""
        return _fife.Uint16Uint16PairVector_front(self)

    def back(self):
        """back(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type"""
        return _fife.Uint16Uint16PairVector_back(self)

    def assign(self, *args):
        """
        assign(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type n, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)
        """
        return _fife.Uint16Uint16PairVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type new_size)
        resize(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type new_size, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)
        """
        return _fife.Uint16Uint16PairVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator pos, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator
        insert(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::iterator pos, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type n, 
            std::vector<(std::pair<(unsigned short,unsigned short)>)>::value_type x)
        """
        return _fife.Uint16Uint16PairVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type n)"""
        return _fife.Uint16Uint16PairVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(std::pair<(unsigned short,unsigned short)>)>::size_type"""
        return _fife.Uint16Uint16PairVector_capacity(self)

    __swig_destroy__ = _fife.delete_Uint16Uint16PairVector
    __del__ = lambda self : None;
Uint16Uint16PairVector_swigregister = _fife.Uint16Uint16PairVector_swigregister
Uint16Uint16PairVector_swigregister(Uint16Uint16PairVector)

class IResourceLoader(_object):
    """Proxy of C++ FIFE::IResourceLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IResourceLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IResourceLoader, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IResourceLoader
    __del__ = lambda self : None;
    def load(self, *args):
        """load(self, IResource resource)"""
        return _fife.IResourceLoader_load(self, *args)

IResourceLoader_swigregister = _fife.IResourceLoader_swigregister
IResourceLoader_swigregister(IResourceLoader)

class IResource(_object):
    """Proxy of C++ FIFE::IResource class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IResource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IResource, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    RES_NOT_LOADED = _fife.IResource_RES_NOT_LOADED
    RES_LOADED = _fife.IResource_RES_LOADED
    __swig_destroy__ = _fife.delete_IResource
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.IResource_getName(self)

    def getHandle(self):
        """getHandle(self) -> ResourceHandle"""
        return _fife.IResource_getHandle(self)

    def getState(self):
        """getState(self) -> ResourceState"""
        return _fife.IResource_getState(self)

    def setState(self, *args):
        """setState(self, ResourceState state)"""
        return _fife.IResource_setState(self, *args)

    def getSize(self):
        """getSize(self) -> size_t"""
        return _fife.IResource_getSize(self)

    def load(self):
        """load(self)"""
        return _fife.IResource_load(self)

    def free(self):
        """free(self)"""
        return _fife.IResource_free(self)

IResource_swigregister = _fife.IResource_swigregister
IResource_swigregister(IResource)

class SharedResourcePointer(_object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::IResource)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedResourcePointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedResourcePointer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SharedResourcePointer
        __init__(self, SharedResourcePointer rhs) -> SharedResourcePointer
        """
        this = _fife.new_SharedResourcePointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SharedResourcePointer
    __del__ = lambda self : None;
    def __ref__(self):
        """__ref__(self) -> IResource"""
        return _fife.SharedResourcePointer___ref__(self)

    def __deref__(self):
        """__deref__(self) -> IResource"""
        return _fife.SharedResourcePointer___deref__(self)

    def get(self):
        """get(self) -> IResource"""
        return _fife.SharedResourcePointer_get(self)

    def reset(self, ptr = None):
        """
        reset(self, IResource ptr = None)
        reset(self)
        """
        return _fife.SharedResourcePointer_reset(self, ptr)

    def useCount(self):
        """useCount(self) -> uint32_t"""
        return _fife.SharedResourcePointer_useCount(self)

    def useCountPtr(self):
        """useCountPtr(self) -> uint32_t"""
        return _fife.SharedResourcePointer_useCountPtr(self)

    def unique(self):
        """unique(self) -> bool"""
        return _fife.SharedResourcePointer_unique(self)

    def __nonzero__(self):
        return _fife.SharedResourcePointer___nonzero__(self)
    __bool__ = __nonzero__


    def getName(self):
        """getName(self) -> string"""
        return _fife.SharedResourcePointer_getName(self)

    def getHandle(self):
        """getHandle(self) -> ResourceHandle"""
        return _fife.SharedResourcePointer_getHandle(self)

    def getState(self):
        """getState(self) -> ResourceState"""
        return _fife.SharedResourcePointer_getState(self)

    def setState(self, *args):
        """setState(self, ResourceState state)"""
        return _fife.SharedResourcePointer_setState(self, *args)

    def getSize(self):
        """getSize(self) -> size_t"""
        return _fife.SharedResourcePointer_getSize(self)

    def load(self):
        """load(self)"""
        return _fife.SharedResourcePointer_load(self)

    def free(self):
        """free(self)"""
        return _fife.SharedResourcePointer_free(self)

SharedResourcePointer_swigregister = _fife.SharedResourcePointer_swigregister
SharedResourcePointer_swigregister(SharedResourcePointer)

class IResourceManager(_object):
    """Proxy of C++ FIFE::IResourceManager class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IResourceManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IResourceManager, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getMemoryUsed(self):
        """getMemoryUsed(self) -> size_t"""
        return _fife.IResourceManager_getMemoryUsed(self)

    def getTotalResourcesCreated(self):
        """getTotalResourcesCreated(self) -> size_t"""
        return _fife.IResourceManager_getTotalResourcesCreated(self)

    def getTotalResourcesLoaded(self):
        """getTotalResourcesLoaded(self) -> size_t"""
        return _fife.IResourceManager_getTotalResourcesLoaded(self)

    def getTotalResources(self):
        """getTotalResources(self) -> size_t"""
        return _fife.IResourceManager_getTotalResources(self)

    __swig_destroy__ = _fife.delete_IResourceManager
    __del__ = lambda self : None;
IResourceManager_swigregister = _fife.IResourceManager_swigregister
IResourceManager_swigregister(IResourceManager)

class SoundClip(IResource):
    """Proxy of C++ FIFE::SoundClip class"""
    __swig_setmethods__ = {}
    for _s in [IResource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SoundClip, name, value)
    __swig_getmethods__ = {}
    for _s in [IResource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SoundClip, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SoundClip
    __del__ = lambda self : None;
    def isStream(self):
        """isStream(self) -> bool"""
        return _fife.SoundClip_isStream(self)

SoundClip_swigregister = _fife.SoundClip_swigregister
SoundClip_swigregister(SoundClip)

class SharedSoundClipPointer(_object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::SoundClip)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedSoundClipPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedSoundClipPointer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SharedSoundClipPointer
        __init__(self, SharedSoundClipPointer rhs) -> SharedSoundClipPointer
        """
        this = _fife.new_SharedSoundClipPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SharedSoundClipPointer
    __del__ = lambda self : None;
    def __ref__(self):
        """__ref__(self) -> SoundClip"""
        return _fife.SharedSoundClipPointer___ref__(self)

    def __deref__(self):
        """__deref__(self) -> SoundClip"""
        return _fife.SharedSoundClipPointer___deref__(self)

    def get(self):
        """get(self) -> SoundClip"""
        return _fife.SharedSoundClipPointer_get(self)

    def reset(self, ptr = None):
        """
        reset(self, SoundClip ptr = None)
        reset(self)
        """
        return _fife.SharedSoundClipPointer_reset(self, ptr)

    def useCount(self):
        """useCount(self) -> uint32_t"""
        return _fife.SharedSoundClipPointer_useCount(self)

    def useCountPtr(self):
        """useCountPtr(self) -> uint32_t"""
        return _fife.SharedSoundClipPointer_useCountPtr(self)

    def unique(self):
        """unique(self) -> bool"""
        return _fife.SharedSoundClipPointer_unique(self)

    def __nonzero__(self):
        return _fife.SharedSoundClipPointer___nonzero__(self)
    __bool__ = __nonzero__


    def isStream(self):
        """isStream(self) -> bool"""
        return _fife.SharedSoundClipPointer_isStream(self)

    def getName(self):
        """getName(self) -> string"""
        return _fife.SharedSoundClipPointer_getName(self)

    def getHandle(self):
        """getHandle(self) -> ResourceHandle"""
        return _fife.SharedSoundClipPointer_getHandle(self)

    def getState(self):
        """getState(self) -> ResourceState"""
        return _fife.SharedSoundClipPointer_getState(self)

    def setState(self, *args):
        """setState(self, ResourceState state)"""
        return _fife.SharedSoundClipPointer_setState(self, *args)

    def getSize(self):
        """getSize(self) -> size_t"""
        return _fife.SharedSoundClipPointer_getSize(self)

    def load(self):
        """load(self)"""
        return _fife.SharedSoundClipPointer_load(self)

    def free(self):
        """free(self)"""
        return _fife.SharedSoundClipPointer_free(self)

SharedSoundClipPointer_swigregister = _fife.SharedSoundClipPointer_swigregister
SharedSoundClipPointer_swigregister(SharedSoundClipPointer)

class SoundClipManager(IResourceManager):
    """Proxy of C++ FIFE::SoundClipManager class"""
    __swig_setmethods__ = {}
    for _s in [IResourceManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SoundClipManager, name, value)
    __swig_getmethods__ = {}
    for _s in [IResourceManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SoundClipManager, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SoundClipManager
    __del__ = lambda self : None;
    def getMemoryUsed(self):
        """getMemoryUsed(self) -> size_t"""
        return _fife.SoundClipManager_getMemoryUsed(self)

    def getTotalResourcesCreated(self):
        """getTotalResourcesCreated(self) -> size_t"""
        return _fife.SoundClipManager_getTotalResourcesCreated(self)

    def getTotalResourcesLoaded(self):
        """getTotalResourcesLoaded(self) -> size_t"""
        return _fife.SoundClipManager_getTotalResourcesLoaded(self)

    def getTotalResources(self):
        """getTotalResources(self) -> size_t"""
        return _fife.SoundClipManager_getTotalResources(self)

    def create(self, *args):
        """
        create(self, string name, IResourceLoader loader = None) -> SoundClipPtr
        create(self, string name) -> SoundClipPtr
        """
        return _fife.SoundClipManager_create(self, *args)

    def load(self, *args):
        """
        load(self, string name, IResourceLoader loader = None) -> SoundClipPtr
        load(self, string name) -> SoundClipPtr
        """
        return _fife.SoundClipManager_load(self, *args)

    def add(self, *args):
        """add(self, SoundClip res) -> SoundClipPtr"""
        return _fife.SoundClipManager_add(self, *args)

    def exists(self, *args):
        """
        exists(self, string name) -> bool
        exists(self, ResourceHandle handle) -> bool
        """
        return _fife.SoundClipManager_exists(self, *args)

    def reload(self, *args):
        """
        reload(self, string name)
        reload(self, ResourceHandle handle)
        """
        return _fife.SoundClipManager_reload(self, *args)

    def reloadAll(self):
        """reloadAll(self)"""
        return _fife.SoundClipManager_reloadAll(self)

    def loadUnreferenced(self):
        """loadUnreferenced(self)"""
        return _fife.SoundClipManager_loadUnreferenced(self)

    def free(self, *args):
        """
        free(self, string name)
        free(self, ResourceHandle handle)
        """
        return _fife.SoundClipManager_free(self, *args)

    def freeAll(self):
        """freeAll(self)"""
        return _fife.SoundClipManager_freeAll(self)

    def freeUnreferenced(self):
        """freeUnreferenced(self)"""
        return _fife.SoundClipManager_freeUnreferenced(self)

    def remove(self, *args):
        """
        remove(self, SoundClipPtr resource)
        remove(self, string name)
        remove(self, ResourceHandle handle)
        """
        return _fife.SoundClipManager_remove(self, *args)

    def removeAll(self):
        """removeAll(self)"""
        return _fife.SoundClipManager_removeAll(self)

    def removeUnreferenced(self):
        """removeUnreferenced(self)"""
        return _fife.SoundClipManager_removeUnreferenced(self)

    def get(self, *args):
        """
        get(self, string name) -> SoundClipPtr
        get(self, ResourceHandle handle) -> SoundClipPtr
        """
        return _fife.SoundClipManager_get(self, *args)

    def getResourceHandle(self, *args):
        """getResourceHandle(self, string name) -> ResourceHandle"""
        return _fife.SoundClipManager_getResourceHandle(self, *args)

    def __init__(self): 
        """__init__(self) -> SoundClipManager"""
        this = _fife.new_SoundClipManager()
        try: self.this.append(this)
        except: self.this = this
SoundClipManager_swigregister = _fife.SoundClipManager_swigregister
SoundClipManager_swigregister(SoundClipManager)

SD_SAMPLE_POS = _fife.SD_SAMPLE_POS
SD_TIME_POS = _fife.SD_TIME_POS
SD_BYTE_POS = _fife.SD_BYTE_POS
class SoundEmitter(_object):
    """Proxy of C++ FIFE::SoundEmitter class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SoundEmitter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SoundEmitter, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, SoundManager manager, uint32_t uid) -> SoundEmitter"""
        this = _fife.new_SoundEmitter(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SoundEmitter
    __del__ = lambda self : None;
    def getId(self):
        """getId(self) -> uint32_t"""
        return _fife.SoundEmitter_getId(self)

    def setSoundClip(self, *args):
        """setSoundClip(self, SoundClipPtr soundclip)"""
        return _fife.SoundEmitter_setSoundClip(self, *args)

    def getSoundClip(self):
        """getSoundClip(self) -> SoundClipPtr"""
        return _fife.SoundEmitter_getSoundClip(self)

    def reset(self, defaultall = False):
        """
        reset(self, bool defaultall = False)
        reset(self)
        """
        return _fife.SoundEmitter_reset(self, defaultall)

    def release(self):
        """release(self)"""
        return _fife.SoundEmitter_release(self)

    def play(self):
        """play(self)"""
        return _fife.SoundEmitter_play(self)

    def pause(self):
        """pause(self)"""
        return _fife.SoundEmitter_pause(self)

    def stop(self):
        """stop(self)"""
        return _fife.SoundEmitter_stop(self)

    def setLooping(self, *args):
        """setLooping(self, bool loop)"""
        return _fife.SoundEmitter_setLooping(self, *args)

    def setRolloff(self, *args):
        """setRolloff(self, float rolloff)"""
        return _fife.SoundEmitter_setRolloff(self, *args)

    def setPositioning(self, *args):
        """setPositioning(self, bool relative)"""
        return _fife.SoundEmitter_setPositioning(self, *args)

    def setPosition(self, *args):
        """setPosition(self, float x, float y, float z)"""
        return _fife.SoundEmitter_setPosition(self, *args)

    def setVelocity(self, *args):
        """setVelocity(self, float x, float y, float z)"""
        return _fife.SoundEmitter_setVelocity(self, *args)

    def setGain(self, *args):
        """setGain(self, float gain)"""
        return _fife.SoundEmitter_setGain(self, *args)

    def getGain(self):
        """getGain(self) -> float"""
        return _fife.SoundEmitter_getGain(self)

    def isStereo(self):
        """isStereo(self) -> bool"""
        return _fife.SoundEmitter_isStereo(self)

    def getBitResolution(self):
        """getBitResolution(self) -> int16_t"""
        return _fife.SoundEmitter_getBitResolution(self)

    def getSampleRate(self):
        """getSampleRate(self) -> uint64_t"""
        return _fife.SoundEmitter_getSampleRate(self)

    def getDecodedLength(self):
        """getDecodedLength(self) -> uint64_t"""
        return _fife.SoundEmitter_getDecodedLength(self)

    def getDuration(self):
        """getDuration(self) -> uint64_t"""
        return _fife.SoundEmitter_getDuration(self)

    def setCursor(self, *args):
        """setCursor(self, SoundPositionType type, float value)"""
        return _fife.SoundEmitter_setCursor(self, *args)

    def getCursor(self, *args):
        """getCursor(self, SoundPositionType type) -> float"""
        return _fife.SoundEmitter_getCursor(self, *args)

SoundEmitter_swigregister = _fife.SoundEmitter_swigregister
SoundEmitter_swigregister(SoundEmitter)

class SoundManager(_object):
    """Proxy of C++ FIFE::SoundManager class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SoundManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SoundManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SoundManager"""
        this = _fife.new_SoundManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SoundManager
    __del__ = lambda self : None;
    def init(self):
        """init(self)"""
        return _fife.SoundManager_init(self)

    def createEmitter(self):
        """createEmitter(self) -> SoundEmitter"""
        return _fife.SoundManager_createEmitter(self)

    def getEmitter(self, *args):
        """getEmitter(self, uint32_t emitterid) -> SoundEmitter"""
        return _fife.SoundManager_getEmitter(self, *args)

    def releaseEmitter(self, *args):
        """releaseEmitter(self, uint32_t emitterid)"""
        return _fife.SoundManager_releaseEmitter(self, *args)

    def getContext(self):
        """getContext(self) -> ALCcontext"""
        return _fife.SoundManager_getContext(self)

    def setVolume(self, *args):
        """setVolume(self, float vol)"""
        return _fife.SoundManager_setVolume(self, *args)

    def getVolume(self):
        """getVolume(self) -> float"""
        return _fife.SoundManager_getVolume(self)

    def mute(self):
        """mute(self)"""
        return _fife.SoundManager_mute(self)

    def unmute(self):
        """unmute(self)"""
        return _fife.SoundManager_unmute(self)

    def setListenerPosition(self, *args):
        """setListenerPosition(self, float x, float y, float z)"""
        return _fife.SoundManager_setListenerPosition(self, *args)

    def setListenerOrientation(self, *args):
        """setListenerOrientation(self, float x, float y, float z)"""
        return _fife.SoundManager_setListenerOrientation(self, *args)

SoundManager_swigregister = _fife.SoundManager_swigregister
SoundManager_swigregister(SoundManager)

class EngineSettings(_object):
    """Proxy of C++ FIFE::EngineSettings class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EngineSettings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EngineSettings, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_EngineSettings
    __del__ = lambda self : None;
    def setBitsPerPixel(self, *args):
        """setBitsPerPixel(self, uint8_t bitsperpixel)"""
        return _fife.EngineSettings_setBitsPerPixel(self, *args)

    def getBitsPerPixel(self):
        """getBitsPerPixel(self) -> uint8_t"""
        return _fife.EngineSettings_getBitsPerPixel(self)

    def getPossibleBitsPerPixel(self):
        """getPossibleBitsPerPixel(self) -> vectoru"""
        return _fife.EngineSettings_getPossibleBitsPerPixel(self)

    def setFullScreen(self, *args):
        """setFullScreen(self, bool fullscreen)"""
        return _fife.EngineSettings_setFullScreen(self, *args)

    def isFullScreen(self):
        """isFullScreen(self) -> bool"""
        return _fife.EngineSettings_isFullScreen(self)

    def setInitialVolume(self, *args):
        """setInitialVolume(self, float volume)"""
        return _fife.EngineSettings_setInitialVolume(self, *args)

    def getInitialVolume(self):
        """getInitialVolume(self) -> float"""
        return _fife.EngineSettings_getInitialVolume(self)

    def getMaxVolume(self):
        """getMaxVolume(self) -> float"""
        return _fife.EngineSettings_getMaxVolume(self)

    def setRenderBackend(self, *args):
        """setRenderBackend(self, string renderbackend)"""
        return _fife.EngineSettings_setRenderBackend(self, *args)

    def getRenderBackend(self):
        """getRenderBackend(self) -> string"""
        return _fife.EngineSettings_getRenderBackend(self)

    def getPossibleRenderBackends(self):
        """getPossibleRenderBackends(self) -> StringVector"""
        return _fife.EngineSettings_getPossibleRenderBackends(self)

    def setSDLRemoveFakeAlpha(self, *args):
        """setSDLRemoveFakeAlpha(self, bool sdlremovefakealpha)"""
        return _fife.EngineSettings_setSDLRemoveFakeAlpha(self, *args)

    def isSDLRemoveFakeAlpha(self):
        """isSDLRemoveFakeAlpha(self) -> bool"""
        return _fife.EngineSettings_isSDLRemoveFakeAlpha(self)

    def setGLCompressImages(self, *args):
        """setGLCompressImages(self, bool oglcompressimages)"""
        return _fife.EngineSettings_setGLCompressImages(self, *args)

    def isGLCompressImages(self):
        """isGLCompressImages(self) -> bool"""
        return _fife.EngineSettings_isGLCompressImages(self)

    def setGLUseFramebuffer(self, *args):
        """setGLUseFramebuffer(self, bool ogluseframebuffer)"""
        return _fife.EngineSettings_setGLUseFramebuffer(self, *args)

    def isGLUseFramebuffer(self):
        """isGLUseFramebuffer(self) -> bool"""
        return _fife.EngineSettings_isGLUseFramebuffer(self)

    def setGLUseNPOT(self, *args):
        """setGLUseNPOT(self, bool oglusenpot)"""
        return _fife.EngineSettings_setGLUseNPOT(self, *args)

    def isGLUseNPOT(self):
        """isGLUseNPOT(self) -> bool"""
        return _fife.EngineSettings_isGLUseNPOT(self)

    def setScreenWidth(self, *args):
        """setScreenWidth(self, uint16_t screenwidth)"""
        return _fife.EngineSettings_setScreenWidth(self, *args)

    def getScreenWidth(self):
        """getScreenWidth(self) -> uint16_t"""
        return _fife.EngineSettings_getScreenWidth(self)

    def setScreenHeight(self, *args):
        """setScreenHeight(self, uint16_t screenheight)"""
        return _fife.EngineSettings_setScreenHeight(self, *args)

    def getScreenHeight(self):
        """getScreenHeight(self) -> uint16_t"""
        return _fife.EngineSettings_getScreenHeight(self)

    def setDefaultFontPath(self, *args):
        """setDefaultFontPath(self, string defaultfontpath)"""
        return _fife.EngineSettings_setDefaultFontPath(self, *args)

    def getDefaultFontPath(self):
        """getDefaultFontPath(self) -> string"""
        return _fife.EngineSettings_getDefaultFontPath(self)

    def setDefaultFontSize(self, *args):
        """setDefaultFontSize(self, uint16_t defaultfontsize)"""
        return _fife.EngineSettings_setDefaultFontSize(self, *args)

    def getDefaultFontSize(self):
        """getDefaultFontSize(self) -> uint16_t"""
        return _fife.EngineSettings_getDefaultFontSize(self)

    def setDefaultFontGlyphs(self, *args):
        """setDefaultFontGlyphs(self, string defaultfontglyphs)"""
        return _fife.EngineSettings_setDefaultFontGlyphs(self, *args)

    def getDefaultFontGlyphs(self):
        """getDefaultFontGlyphs(self) -> string"""
        return _fife.EngineSettings_getDefaultFontGlyphs(self)

    def setWindowTitle(self, *args):
        """setWindowTitle(self, string title)"""
        return _fife.EngineSettings_setWindowTitle(self, *args)

    def getWindowTitle(self):
        """getWindowTitle(self) -> string"""
        return _fife.EngineSettings_getWindowTitle(self)

    def setWindowIcon(self, *args):
        """setWindowIcon(self, string icon)"""
        return _fife.EngineSettings_setWindowIcon(self, *args)

    def getWindowIcon(self):
        """getWindowIcon(self) -> string"""
        return _fife.EngineSettings_getWindowIcon(self)

    def setColorKeyEnabled(self, *args):
        """setColorKeyEnabled(self, bool colorkeyenable)"""
        return _fife.EngineSettings_setColorKeyEnabled(self, *args)

    def isColorKeyEnabled(self):
        """isColorKeyEnabled(self) -> bool"""
        return _fife.EngineSettings_isColorKeyEnabled(self)

    def setColorKey(self, *args):
        """setColorKey(self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.EngineSettings_setColorKey(self, *args)

    def getColorKey(self):
        """getColorKey(self) -> SDL_Color"""
        return _fife.EngineSettings_getColorKey(self)

    def setVideoDriver(self, *args):
        """setVideoDriver(self, string driver)"""
        return _fife.EngineSettings_setVideoDriver(self, *args)

    def getVideoDriver(self):
        """getVideoDriver(self) -> string"""
        return _fife.EngineSettings_getVideoDriver(self)

    def setLightingModel(self, *args):
        """setLightingModel(self, uint32_t lighting)"""
        return _fife.EngineSettings_setLightingModel(self, *args)

    def getLightingModel(self):
        """getLightingModel(self) -> uint32_t"""
        return _fife.EngineSettings_getLightingModel(self)

    def setFrameLimitEnabled(self, *args):
        """setFrameLimitEnabled(self, bool limited)"""
        return _fife.EngineSettings_setFrameLimitEnabled(self, *args)

    def isFrameLimitEnabled(self):
        """isFrameLimitEnabled(self) -> bool"""
        return _fife.EngineSettings_isFrameLimitEnabled(self)

    def setFrameLimit(self, *args):
        """setFrameLimit(self, uint16_t framelimit)"""
        return _fife.EngineSettings_setFrameLimit(self, *args)

    def getFrameLimit(self):
        """getFrameLimit(self) -> uint16_t"""
        return _fife.EngineSettings_getFrameLimit(self)

    def setMouseSensitivity(self, *args):
        """setMouseSensitivity(self, float sens)"""
        return _fife.EngineSettings_setMouseSensitivity(self, *args)

    def getMouseSensitivity(self):
        """getMouseSensitivity(self) -> float"""
        return _fife.EngineSettings_getMouseSensitivity(self)

    def setMouseAccelerationEnabled(self, *args):
        """setMouseAccelerationEnabled(self, bool acceleration)"""
        return _fife.EngineSettings_setMouseAccelerationEnabled(self, *args)

    def isMouseAccelerationEnabled(self):
        """isMouseAccelerationEnabled(self) -> bool"""
        return _fife.EngineSettings_isMouseAccelerationEnabled(self)

EngineSettings_swigregister = _fife.EngineSettings_swigregister
EngineSettings_swigregister(EngineSettings)

class IEngineChangeListener(_object):
    """Proxy of C++ FIFE::IEngineChangeListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IEngineChangeListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IEngineChangeListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IEngineChangeListener
    __del__ = lambda self : None;
    def onScreenModeChanged(self, *args):
        """onScreenModeChanged(self, ScreenMode newmode)"""
        return _fife.IEngineChangeListener_onScreenModeChanged(self, *args)

    def __init__(self): 
        """__init__(self) -> IEngineChangeListener"""
        if self.__class__ == IEngineChangeListener:
            _self = None
        else:
            _self = self
        this = _fife.new_IEngineChangeListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEngineChangeListener(self)
        return weakref_proxy(self)
IEngineChangeListener_swigregister = _fife.IEngineChangeListener_swigregister
IEngineChangeListener_swigregister(IEngineChangeListener)

class Engine(_object):
    """Proxy of C++ FIFE::Engine class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Engine, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Engine, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Engine"""
        this = _fife.new_Engine()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Engine
    __del__ = lambda self : None;
    def initializePumping(self):
        """initializePumping(self)"""
        return _fife.Engine_initializePumping(self)

    def finalizePumping(self):
        """finalizePumping(self)"""
        return _fife.Engine_finalizePumping(self)

    def pump(self):
        """pump(self)"""
        return _fife.Engine_pump(self)

    def getSettings(self):
        """getSettings(self) -> EngineSettings"""
        return _fife.Engine_getSettings(self)

    def getDeviceCaps(self):
        """getDeviceCaps(self) -> DeviceCaps"""
        return _fife.Engine_getDeviceCaps(self)

    def changeScreenMode(self, *args):
        """changeScreenMode(self, ScreenMode mode)"""
        return _fife.Engine_changeScreenMode(self, *args)

    def init(self):
        """init(self)"""
        return _fife.Engine_init(self)

    def destroy(self):
        """destroy(self)"""
        return _fife.Engine_destroy(self)

    def getSoundManager(self):
        """getSoundManager(self) -> SoundManager"""
        return _fife.Engine_getSoundManager(self)

    def getEventManager(self):
        """getEventManager(self) -> EventManager"""
        return _fife.Engine_getEventManager(self)

    def getTimeManager(self):
        """getTimeManager(self) -> TimeManager"""
        return _fife.Engine_getTimeManager(self)

    def setGuiManager(self, *args):
        """setGuiManager(self, IGUIManager guimanager)"""
        return _fife.Engine_setGuiManager(self, *args)

    def getGuiManager(self):
        """getGuiManager(self) -> IGUIManager"""
        return _fife.Engine_getGuiManager(self)

    def getImageManager(self):
        """getImageManager(self) -> ImageManager"""
        return _fife.Engine_getImageManager(self)

    def getSoundClipManager(self):
        """getSoundClipManager(self) -> SoundClipManager"""
        return _fife.Engine_getSoundClipManager(self)

    def getRenderBackend(self):
        """getRenderBackend(self) -> RenderBackend"""
        return _fife.Engine_getRenderBackend(self)

    def getModel(self):
        """getModel(self) -> Model"""
        return _fife.Engine_getModel(self)

    def getLogManager(self):
        """getLogManager(self) -> LogManager"""
        return _fife.Engine_getLogManager(self)

    def getVFS(self):
        """getVFS(self) -> VFS"""
        return _fife.Engine_getVFS(self)

    def getCursor(self):
        """getCursor(self) -> Cursor"""
        return _fife.Engine_getCursor(self)

    def getOffRenderer(self):
        """getOffRenderer(self) -> OffRenderer"""
        return _fife.Engine_getOffRenderer(self)

    def getTargetRenderer(self):
        """getTargetRenderer(self) -> TargetRenderer"""
        return _fife.Engine_getTargetRenderer(self)

    def addChangeListener(self, *args):
        """addChangeListener(self, IEngineChangeListener listener)"""
        return _fife.Engine_addChangeListener(self, *args)

    def removeChangeListener(self, *args):
        """removeChangeListener(self, IEngineChangeListener listener)"""
        return _fife.Engine_removeChangeListener(self, *args)

Engine_swigregister = _fife.Engine_swigregister
Engine_swigregister(Engine)

class Key(_object):
    """Proxy of C++ FIFE::Key class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Key, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Key, name)
    __repr__ = _swig_repr
    INVALID_KEY = _fife.Key_INVALID_KEY
    BACKSPACE = _fife.Key_BACKSPACE
    TAB = _fife.Key_TAB
    CLEAR = _fife.Key_CLEAR
    ENTER = _fife.Key_ENTER
    PAUSE = _fife.Key_PAUSE
    ESCAPE = _fife.Key_ESCAPE
    SPACE = _fife.Key_SPACE
    EXCLAIM = _fife.Key_EXCLAIM
    QUOTEDBL = _fife.Key_QUOTEDBL
    HASH = _fife.Key_HASH
    DOLLAR = _fife.Key_DOLLAR
    AMPERSAND = _fife.Key_AMPERSAND
    QUOTE = _fife.Key_QUOTE
    LEFTPAREN = _fife.Key_LEFTPAREN
    RIGHTPAREN = _fife.Key_RIGHTPAREN
    ASTERISK = _fife.Key_ASTERISK
    PLUS = _fife.Key_PLUS
    COMMA = _fife.Key_COMMA
    MINUS = _fife.Key_MINUS
    PERIOD = _fife.Key_PERIOD
    SLASH = _fife.Key_SLASH
    NUM_0 = _fife.Key_NUM_0
    NUM_1 = _fife.Key_NUM_1
    NUM_2 = _fife.Key_NUM_2
    NUM_3 = _fife.Key_NUM_3
    NUM_4 = _fife.Key_NUM_4
    NUM_5 = _fife.Key_NUM_5
    NUM_6 = _fife.Key_NUM_6
    NUM_7 = _fife.Key_NUM_7
    NUM_8 = _fife.Key_NUM_8
    NUM_9 = _fife.Key_NUM_9
    COLON = _fife.Key_COLON
    SEMICOLON = _fife.Key_SEMICOLON
    LESS = _fife.Key_LESS
    EQUALS = _fife.Key_EQUALS
    GREATER = _fife.Key_GREATER
    QUESTION = _fife.Key_QUESTION
    AT = _fife.Key_AT
    LEFTBRACKET = _fife.Key_LEFTBRACKET
    BACKSLASH = _fife.Key_BACKSLASH
    RIGHTBRACKET = _fife.Key_RIGHTBRACKET
    CARET = _fife.Key_CARET
    UNDERSCORE = _fife.Key_UNDERSCORE
    BACKQUOTE = _fife.Key_BACKQUOTE
    A = _fife.Key_A
    B = _fife.Key_B
    C = _fife.Key_C
    D = _fife.Key_D
    E = _fife.Key_E
    F = _fife.Key_F
    G = _fife.Key_G
    H = _fife.Key_H
    I = _fife.Key_I
    J = _fife.Key_J
    K = _fife.Key_K
    L = _fife.Key_L
    M = _fife.Key_M
    N = _fife.Key_N
    O = _fife.Key_O
    P = _fife.Key_P
    Q = _fife.Key_Q
    R = _fife.Key_R
    S = _fife.Key_S
    T = _fife.Key_T
    U = _fife.Key_U
    V = _fife.Key_V
    W = _fife.Key_W
    X = _fife.Key_X
    Y = _fife.Key_Y
    Z = _fife.Key_Z
    DELETE = _fife.Key_DELETE
    WORLD_0 = _fife.Key_WORLD_0
    WORLD_1 = _fife.Key_WORLD_1
    WORLD_2 = _fife.Key_WORLD_2
    WORLD_3 = _fife.Key_WORLD_3
    WORLD_4 = _fife.Key_WORLD_4
    WORLD_5 = _fife.Key_WORLD_5
    WORLD_6 = _fife.Key_WORLD_6
    WORLD_7 = _fife.Key_WORLD_7
    WORLD_8 = _fife.Key_WORLD_8
    WORLD_9 = _fife.Key_WORLD_9
    WORLD_10 = _fife.Key_WORLD_10
    WORLD_11 = _fife.Key_WORLD_11
    WORLD_12 = _fife.Key_WORLD_12
    WORLD_13 = _fife.Key_WORLD_13
    WORLD_14 = _fife.Key_WORLD_14
    WORLD_15 = _fife.Key_WORLD_15
    WORLD_16 = _fife.Key_WORLD_16
    WORLD_17 = _fife.Key_WORLD_17
    WORLD_18 = _fife.Key_WORLD_18
    WORLD_19 = _fife.Key_WORLD_19
    WORLD_20 = _fife.Key_WORLD_20
    WORLD_21 = _fife.Key_WORLD_21
    WORLD_22 = _fife.Key_WORLD_22
    WORLD_23 = _fife.Key_WORLD_23
    WORLD_24 = _fife.Key_WORLD_24
    WORLD_25 = _fife.Key_WORLD_25
    WORLD_26 = _fife.Key_WORLD_26
    WORLD_27 = _fife.Key_WORLD_27
    WORLD_28 = _fife.Key_WORLD_28
    WORLD_29 = _fife.Key_WORLD_29
    WORLD_30 = _fife.Key_WORLD_30
    WORLD_31 = _fife.Key_WORLD_31
    WORLD_32 = _fife.Key_WORLD_32
    WORLD_33 = _fife.Key_WORLD_33
    WORLD_34 = _fife.Key_WORLD_34
    WORLD_35 = _fife.Key_WORLD_35
    WORLD_36 = _fife.Key_WORLD_36
    WORLD_37 = _fife.Key_WORLD_37
    WORLD_38 = _fife.Key_WORLD_38
    WORLD_39 = _fife.Key_WORLD_39
    WORLD_40 = _fife.Key_WORLD_40
    WORLD_41 = _fife.Key_WORLD_41
    WORLD_42 = _fife.Key_WORLD_42
    WORLD_43 = _fife.Key_WORLD_43
    WORLD_44 = _fife.Key_WORLD_44
    WORLD_45 = _fife.Key_WORLD_45
    WORLD_46 = _fife.Key_WORLD_46
    WORLD_47 = _fife.Key_WORLD_47
    WORLD_48 = _fife.Key_WORLD_48
    WORLD_49 = _fife.Key_WORLD_49
    WORLD_50 = _fife.Key_WORLD_50
    WORLD_51 = _fife.Key_WORLD_51
    WORLD_52 = _fife.Key_WORLD_52
    WORLD_53 = _fife.Key_WORLD_53
    WORLD_54 = _fife.Key_WORLD_54
    WORLD_55 = _fife.Key_WORLD_55
    WORLD_56 = _fife.Key_WORLD_56
    WORLD_57 = _fife.Key_WORLD_57
    WORLD_58 = _fife.Key_WORLD_58
    WORLD_59 = _fife.Key_WORLD_59
    WORLD_60 = _fife.Key_WORLD_60
    WORLD_61 = _fife.Key_WORLD_61
    WORLD_62 = _fife.Key_WORLD_62
    WORLD_63 = _fife.Key_WORLD_63
    WORLD_64 = _fife.Key_WORLD_64
    WORLD_65 = _fife.Key_WORLD_65
    WORLD_66 = _fife.Key_WORLD_66
    WORLD_67 = _fife.Key_WORLD_67
    WORLD_68 = _fife.Key_WORLD_68
    WORLD_69 = _fife.Key_WORLD_69
    WORLD_70 = _fife.Key_WORLD_70
    WORLD_71 = _fife.Key_WORLD_71
    WORLD_72 = _fife.Key_WORLD_72
    WORLD_73 = _fife.Key_WORLD_73
    WORLD_74 = _fife.Key_WORLD_74
    WORLD_75 = _fife.Key_WORLD_75
    WORLD_76 = _fife.Key_WORLD_76
    WORLD_77 = _fife.Key_WORLD_77
    WORLD_78 = _fife.Key_WORLD_78
    WORLD_79 = _fife.Key_WORLD_79
    WORLD_80 = _fife.Key_WORLD_80
    WORLD_81 = _fife.Key_WORLD_81
    WORLD_82 = _fife.Key_WORLD_82
    WORLD_83 = _fife.Key_WORLD_83
    WORLD_84 = _fife.Key_WORLD_84
    WORLD_85 = _fife.Key_WORLD_85
    WORLD_86 = _fife.Key_WORLD_86
    WORLD_87 = _fife.Key_WORLD_87
    WORLD_88 = _fife.Key_WORLD_88
    WORLD_89 = _fife.Key_WORLD_89
    WORLD_90 = _fife.Key_WORLD_90
    WORLD_91 = _fife.Key_WORLD_91
    WORLD_92 = _fife.Key_WORLD_92
    WORLD_93 = _fife.Key_WORLD_93
    WORLD_94 = _fife.Key_WORLD_94
    WORLD_95 = _fife.Key_WORLD_95
    KP0 = _fife.Key_KP0
    KP1 = _fife.Key_KP1
    KP2 = _fife.Key_KP2
    KP3 = _fife.Key_KP3
    KP4 = _fife.Key_KP4
    KP5 = _fife.Key_KP5
    KP6 = _fife.Key_KP6
    KP7 = _fife.Key_KP7
    KP8 = _fife.Key_KP8
    KP9 = _fife.Key_KP9
    KP_PERIOD = _fife.Key_KP_PERIOD
    KP_DIVIDE = _fife.Key_KP_DIVIDE
    KP_MULTIPLY = _fife.Key_KP_MULTIPLY
    KP_MINUS = _fife.Key_KP_MINUS
    KP_PLUS = _fife.Key_KP_PLUS
    KP_ENTER = _fife.Key_KP_ENTER
    KP_EQUALS = _fife.Key_KP_EQUALS
    UP = _fife.Key_UP
    DOWN = _fife.Key_DOWN
    RIGHT = _fife.Key_RIGHT
    LEFT = _fife.Key_LEFT
    INSERT = _fife.Key_INSERT
    HOME = _fife.Key_HOME
    END = _fife.Key_END
    PAGE_UP = _fife.Key_PAGE_UP
    PAGE_DOWN = _fife.Key_PAGE_DOWN
    F1 = _fife.Key_F1
    F2 = _fife.Key_F2
    F3 = _fife.Key_F3
    F4 = _fife.Key_F4
    F5 = _fife.Key_F5
    F6 = _fife.Key_F6
    F7 = _fife.Key_F7
    F8 = _fife.Key_F8
    F9 = _fife.Key_F9
    F10 = _fife.Key_F10
    F11 = _fife.Key_F11
    F12 = _fife.Key_F12
    F13 = _fife.Key_F13
    F14 = _fife.Key_F14
    F15 = _fife.Key_F15
    NUM_LOCK = _fife.Key_NUM_LOCK
    CAPS_LOCK = _fife.Key_CAPS_LOCK
    SCROLL_LOCK = _fife.Key_SCROLL_LOCK
    RIGHT_SHIFT = _fife.Key_RIGHT_SHIFT
    LEFT_SHIFT = _fife.Key_LEFT_SHIFT
    RIGHT_CONTROL = _fife.Key_RIGHT_CONTROL
    LEFT_CONTROL = _fife.Key_LEFT_CONTROL
    RIGHT_ALT = _fife.Key_RIGHT_ALT
    LEFT_ALT = _fife.Key_LEFT_ALT
    RIGHT_META = _fife.Key_RIGHT_META
    LEFT_META = _fife.Key_LEFT_META
    RIGHT_SUPER = _fife.Key_RIGHT_SUPER
    LEFT_SUPER = _fife.Key_LEFT_SUPER
    ALT_GR = _fife.Key_ALT_GR
    COMPOSE = _fife.Key_COMPOSE
    HELP = _fife.Key_HELP
    PRINT_SCREEN = _fife.Key_PRINT_SCREEN
    SYSREQ = _fife.Key_SYSREQ
    BREAK = _fife.Key_BREAK
    MENU = _fife.Key_MENU
    POWER = _fife.Key_POWER
    EURO = _fife.Key_EURO
    UNDO = _fife.Key_UNDO
    def __init__(self, *args): 
        """
        __init__(self, KeyType key = INVALID_KEY, uint32_t codepoint = 0) -> Key
        __init__(self, KeyType key = INVALID_KEY) -> Key
        __init__(self) -> Key
        """
        this = _fife.new_Key(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Key
    __del__ = lambda self : None;
    def isPrintable(self):
        """isPrintable(self) -> bool"""
        return _fife.Key_isPrintable(self)

    def isFunctionKey(self):
        """isFunctionKey(self) -> bool"""
        return _fife.Key_isFunctionKey(self)

    def getValue(self):
        """getValue(self) -> KeyType"""
        return _fife.Key_getValue(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _fife.Key_getAsString(self)

Key_swigregister = _fife.Key_swigregister
Key_swigregister(Key)

ES_ENGINE = _fife.ES_ENGINE
ES_GUICHAN_WIDGET = _fife.ES_GUICHAN_WIDGET
CMD_UNKNOWN = _fife.CMD_UNKNOWN
CMD_QUIT_GAME = _fife.CMD_QUIT_GAME
CMD_MOUSE_FOCUS_GAINED = _fife.CMD_MOUSE_FOCUS_GAINED
CMD_MOUSE_FOCUS_LOST = _fife.CMD_MOUSE_FOCUS_LOST
CMD_INPUT_FOCUS_GAINED = _fife.CMD_INPUT_FOCUS_GAINED
CMD_INPUT_FOCUS_LOST = _fife.CMD_INPUT_FOCUS_LOST
CMD_APP_RESTORED = _fife.CMD_APP_RESTORED
CMD_APP_ICONIFIED = _fife.CMD_APP_ICONIFIED
class IEventSource(_object):
    """Proxy of C++ FIFE::IEventSource class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IEventSource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IEventSource, name)
    __repr__ = _swig_repr
    def getEventSourceType(self):
        """getEventSourceType(self) -> EventSourceType"""
        return _fife.IEventSource_getEventSourceType(self)

    __swig_destroy__ = _fife.delete_IEventSource
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> IEventSource"""
        if self.__class__ == IEventSource:
            _self = None
        else:
            _self = self
        this = _fife.new_IEventSource(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEventSource(self)
        return weakref_proxy(self)
IEventSource_swigregister = _fife.IEventSource_swigregister
IEventSource_swigregister(IEventSource)

class Event(_object):
    """Proxy of C++ FIFE::Event class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Event, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Event, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def consume(self):
        """consume(self)"""
        return _fife.Event_consume(self)

    def isConsumed(self):
        """isConsumed(self) -> bool"""
        return _fife.Event_isConsumed(self)

    def getSource(self):
        """getSource(self) -> IEventSource"""
        return _fife.Event_getSource(self)

    def getTimeStamp(self):
        """getTimeStamp(self) -> int32_t"""
        return _fife.Event_getTimeStamp(self)

    def getDebugString(self):
        """getDebugString(self) -> string"""
        return _fife.Event_getDebugString(self)

    def getName(self):
        """getName(self) -> string"""
        return _fife.Event_getName(self)

    __swig_destroy__ = _fife.delete_Event
    __del__ = lambda self : None;
Event_swigregister = _fife.Event_swigregister
Event_swigregister(Event)

class InputEvent(Event):
    """Proxy of C++ FIFE::InputEvent class"""
    __swig_setmethods__ = {}
    for _s in [Event]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputEvent, name, value)
    __swig_getmethods__ = {}
    for _s in [Event]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputEvent, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def isConsumedByWidgets(self):
        """isConsumedByWidgets(self) -> bool"""
        return _fife.InputEvent_isConsumedByWidgets(self)

    def isAltPressed(self):
        """isAltPressed(self) -> bool"""
        return _fife.InputEvent_isAltPressed(self)

    def isControlPressed(self):
        """isControlPressed(self) -> bool"""
        return _fife.InputEvent_isControlPressed(self)

    def isMetaPressed(self):
        """isMetaPressed(self) -> bool"""
        return _fife.InputEvent_isMetaPressed(self)

    def isShiftPressed(self):
        """isShiftPressed(self) -> bool"""
        return _fife.InputEvent_isShiftPressed(self)

    __swig_destroy__ = _fife.delete_InputEvent
    __del__ = lambda self : None;
InputEvent_swigregister = _fife.InputEvent_swigregister
InputEvent_swigregister(InputEvent)

class Command(Event):
    """Proxy of C++ FIFE::Command class"""
    __swig_setmethods__ = {}
    for _s in [Event]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Command, name, value)
    __swig_getmethods__ = {}
    for _s in [Event]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Command, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Command"""
        this = _fife.new_Command()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Command
    __del__ = lambda self : None;
    def getCommandType(self):
        """getCommandType(self) -> CommandType"""
        return _fife.Command_getCommandType(self)

    def setCommandType(self, *args):
        """setCommandType(self, CommandType type)"""
        return _fife.Command_setCommandType(self, *args)

    def getCode(self):
        """getCode(self) -> int32_t"""
        return _fife.Command_getCode(self)

    def setCode(self, *args):
        """setCode(self, int32_t code)"""
        return _fife.Command_setCode(self, *args)

    def setSource(self, *args):
        """setSource(self, IEventSource source)"""
        return _fife.Command_setSource(self, *args)

    def setTimeStamp(self, *args):
        """setTimeStamp(self, int32_t timestamp)"""
        return _fife.Command_setTimeStamp(self, *args)

Command_swigregister = _fife.Command_swigregister
Command_swigregister(Command)

class ICommandListener(_object):
    """Proxy of C++ FIFE::ICommandListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ICommandListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ICommandListener, name)
    __repr__ = _swig_repr
    def onCommand(self, *args):
        """onCommand(self, Command command)"""
        return _fife.ICommandListener_onCommand(self, *args)

    __swig_destroy__ = _fife.delete_ICommandListener
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> ICommandListener"""
        if self.__class__ == ICommandListener:
            _self = None
        else:
            _self = self
        this = _fife.new_ICommandListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ICommandListener(self)
        return weakref_proxy(self)
ICommandListener_swigregister = _fife.ICommandListener_swigregister
ICommandListener_swigregister(ICommandListener)

class KeyEvent(InputEvent):
    """Proxy of C++ FIFE::KeyEvent class"""
    __swig_setmethods__ = {}
    for _s in [InputEvent]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, KeyEvent, name, value)
    __swig_getmethods__ = {}
    for _s in [InputEvent]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, KeyEvent, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    UNKNOWN = _fife.KeyEvent_UNKNOWN
    PRESSED = _fife.KeyEvent_PRESSED
    RELEASED = _fife.KeyEvent_RELEASED
    def getType(self):
        """getType(self) -> KeyEventType"""
        return _fife.KeyEvent_getType(self)

    def isNumericPad(self):
        """isNumericPad(self) -> bool"""
        return _fife.KeyEvent_isNumericPad(self)

    def getKey(self):
        """getKey(self) -> Key"""
        return _fife.KeyEvent_getKey(self)

    __swig_destroy__ = _fife.delete_KeyEvent
    __del__ = lambda self : None;
KeyEvent_swigregister = _fife.KeyEvent_swigregister
KeyEvent_swigregister(KeyEvent)

class IKeyListener(_object):
    """Proxy of C++ FIFE::IKeyListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IKeyListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IKeyListener, name)
    __repr__ = _swig_repr
    def keyPressed(self, *args):
        """keyPressed(self, KeyEvent evt)"""
        return _fife.IKeyListener_keyPressed(self, *args)

    def keyReleased(self, *args):
        """keyReleased(self, KeyEvent evt)"""
        return _fife.IKeyListener_keyReleased(self, *args)

    __swig_destroy__ = _fife.delete_IKeyListener
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> IKeyListener"""
        if self.__class__ == IKeyListener:
            _self = None
        else:
            _self = self
        this = _fife.new_IKeyListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyListener(self)
        return weakref_proxy(self)
IKeyListener_swigregister = _fife.IKeyListener_swigregister
IKeyListener_swigregister(IKeyListener)

class ISdlEventListener(_object):
    """Proxy of C++ FIFE::ISdlEventListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ISdlEventListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ISdlEventListener, name)
    __repr__ = _swig_repr
    def onSdlEvent(self, *args):
        """onSdlEvent(self, SDL_Event evt) -> bool"""
        return _fife.ISdlEventListener_onSdlEvent(self, *args)

    __swig_destroy__ = _fife.delete_ISdlEventListener
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> ISdlEventListener"""
        if self.__class__ == ISdlEventListener:
            _self = None
        else:
            _self = self
        this = _fife.new_ISdlEventListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ISdlEventListener(self)
        return weakref_proxy(self)
ISdlEventListener_swigregister = _fife.ISdlEventListener_swigregister
ISdlEventListener_swigregister(ISdlEventListener)

class MouseEvent(InputEvent):
    """Proxy of C++ FIFE::MouseEvent class"""
    __swig_setmethods__ = {}
    for _s in [InputEvent]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MouseEvent, name, value)
    __swig_getmethods__ = {}
    for _s in [InputEvent]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MouseEvent, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    UNKNOWN_EVENT = _fife.MouseEvent_UNKNOWN_EVENT
    MOVED = _fife.MouseEvent_MOVED
    PRESSED = _fife.MouseEvent_PRESSED
    RELEASED = _fife.MouseEvent_RELEASED
    WHEEL_MOVED_DOWN = _fife.MouseEvent_WHEEL_MOVED_DOWN
    WHEEL_MOVED_UP = _fife.MouseEvent_WHEEL_MOVED_UP
    CLICKED = _fife.MouseEvent_CLICKED
    ENTERED = _fife.MouseEvent_ENTERED
    EXITED = _fife.MouseEvent_EXITED
    DRAGGED = _fife.MouseEvent_DRAGGED
    EMPTY = _fife.MouseEvent_EMPTY
    LEFT = _fife.MouseEvent_LEFT
    RIGHT = _fife.MouseEvent_RIGHT
    MIDDLE = _fife.MouseEvent_MIDDLE
    UNKNOWN_BUTTON = _fife.MouseEvent_UNKNOWN_BUTTON
    def getX(self):
        """getX(self) -> int32_t"""
        return _fife.MouseEvent_getX(self)

    def getY(self):
        """getY(self) -> int32_t"""
        return _fife.MouseEvent_getY(self)

    def getType(self):
        """getType(self) -> MouseEventType"""
        return _fife.MouseEvent_getType(self)

    def getButton(self):
        """getButton(self) -> MouseButtonType"""
        return _fife.MouseEvent_getButton(self)

    __swig_destroy__ = _fife.delete_MouseEvent
    __del__ = lambda self : None;
MouseEvent_swigregister = _fife.MouseEvent_swigregister
MouseEvent_swigregister(MouseEvent)

class IMouseListener(_object):
    """Proxy of C++ FIFE::IMouseListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMouseListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMouseListener, name)
    __repr__ = _swig_repr
    def mouseEntered(self, *args):
        """mouseEntered(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseEntered(self, *args)

    def mouseExited(self, *args):
        """mouseExited(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseExited(self, *args)

    def mousePressed(self, *args):
        """mousePressed(self, MouseEvent evt)"""
        return _fife.IMouseListener_mousePressed(self, *args)

    def mouseReleased(self, *args):
        """mouseReleased(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseReleased(self, *args)

    def mouseClicked(self, *args):
        """mouseClicked(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseClicked(self, *args)

    def mouseWheelMovedUp(self, *args):
        """mouseWheelMovedUp(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseWheelMovedUp(self, *args)

    def mouseWheelMovedDown(self, *args):
        """mouseWheelMovedDown(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseWheelMovedDown(self, *args)

    def mouseMoved(self, *args):
        """mouseMoved(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseMoved(self, *args)

    def mouseDragged(self, *args):
        """mouseDragged(self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseDragged(self, *args)

    __swig_destroy__ = _fife.delete_IMouseListener
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> IMouseListener"""
        if self.__class__ == IMouseListener:
            _self = None
        else:
            _self = self
        this = _fife.new_IMouseListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMouseListener(self)
        return weakref_proxy(self)
IMouseListener_swigregister = _fife.IMouseListener_swigregister
IMouseListener_swigregister(IMouseListener)

class IKeyFilter(_object):
    """Proxy of C++ FIFE::IKeyFilter class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IKeyFilter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IKeyFilter, name)
    __repr__ = _swig_repr
    def isFiltered(self, *args):
        """isFiltered(self, KeyEvent evt) -> bool"""
        return _fife.IKeyFilter_isFiltered(self, *args)

    __swig_destroy__ = _fife.delete_IKeyFilter
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> IKeyFilter"""
        if self.__class__ == IKeyFilter:
            _self = None
        else:
            _self = self
        this = _fife.new_IKeyFilter(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyFilter(self)
        return weakref_proxy(self)
IKeyFilter_swigregister = _fife.IKeyFilter_swigregister
IKeyFilter_swigregister(IKeyFilter)

class EventManager(_object):
    """Proxy of C++ FIFE::EventManager class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, EventManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> EventManager"""
        this = _fife.new_EventManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_EventManager
    __del__ = lambda self : None;
    def addCommandListener(self, *args):
        """addCommandListener(self, ICommandListener listener)"""
        return _fife.EventManager_addCommandListener(self, *args)

    def addCommandListenerFront(self, *args):
        """addCommandListenerFront(self, ICommandListener listener)"""
        return _fife.EventManager_addCommandListenerFront(self, *args)

    def removeCommandListener(self, *args):
        """removeCommandListener(self, ICommandListener listener)"""
        return _fife.EventManager_removeCommandListener(self, *args)

    def addKeyListener(self, *args):
        """addKeyListener(self, IKeyListener listener)"""
        return _fife.EventManager_addKeyListener(self, *args)

    def addKeyListenerFront(self, *args):
        """addKeyListenerFront(self, IKeyListener listener)"""
        return _fife.EventManager_addKeyListenerFront(self, *args)

    def removeKeyListener(self, *args):
        """removeKeyListener(self, IKeyListener listener)"""
        return _fife.EventManager_removeKeyListener(self, *args)

    def addMouseListener(self, *args):
        """addMouseListener(self, IMouseListener listener)"""
        return _fife.EventManager_addMouseListener(self, *args)

    def addMouseListenerFront(self, *args):
        """addMouseListenerFront(self, IMouseListener listener)"""
        return _fife.EventManager_addMouseListenerFront(self, *args)

    def removeMouseListener(self, *args):
        """removeMouseListener(self, IMouseListener listener)"""
        return _fife.EventManager_removeMouseListener(self, *args)

    def addSdlEventListener(self, *args):
        """addSdlEventListener(self, ISdlEventListener listener)"""
        return _fife.EventManager_addSdlEventListener(self, *args)

    def addSdlEventListenerFront(self, *args):
        """addSdlEventListenerFront(self, ISdlEventListener listener)"""
        return _fife.EventManager_addSdlEventListenerFront(self, *args)

    def removeSdlEventListener(self, *args):
        """removeSdlEventListener(self, ISdlEventListener listener)"""
        return _fife.EventManager_removeSdlEventListener(self, *args)

    def getEventSourceType(self):
        """getEventSourceType(self) -> EventSourceType"""
        return _fife.EventManager_getEventSourceType(self)

    def dispatchCommand(self, *args):
        """dispatchCommand(self, Command command)"""
        return _fife.EventManager_dispatchCommand(self, *args)

    def setKeyFilter(self, *args):
        """setKeyFilter(self, IKeyFilter keyFilter)"""
        return _fife.EventManager_setKeyFilter(self, *args)

    def setMouseSensitivity(self, *args):
        """setMouseSensitivity(self, float sensitivity)"""
        return _fife.EventManager_setMouseSensitivity(self, *args)

    def getMouseSensitivity(self):
        """getMouseSensitivity(self) -> float"""
        return _fife.EventManager_getMouseSensitivity(self)

    def setMouseAccelerationEnabled(self, *args):
        """setMouseAccelerationEnabled(self, bool acceleration)"""
        return _fife.EventManager_setMouseAccelerationEnabled(self, *args)

    def isMouseAccelerationEnabled(self):
        """isMouseAccelerationEnabled(self) -> bool"""
        return _fife.EventManager_isMouseAccelerationEnabled(self)

EventManager_swigregister = _fife.EventManager_swigregister
EventManager_swigregister(EventManager)

class IFont(_object):
    """Proxy of C++ FIFE::IFont class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IFont, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IFont, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IFont
    __del__ = lambda self : None;
    def setRowSpacing(self, *args):
        """setRowSpacing(self, int32_t spacing)"""
        return _fife.IFont_setRowSpacing(self, *args)

    def getRowSpacing(self):
        """getRowSpacing(self) -> int32_t"""
        return _fife.IFont_getRowSpacing(self)

    def setGlyphSpacing(self, *args):
        """setGlyphSpacing(self, int32_t spacing)"""
        return _fife.IFont_setGlyphSpacing(self, *args)

    def getGlyphSpacing(self):
        """getGlyphSpacing(self) -> int32_t"""
        return _fife.IFont_getGlyphSpacing(self)

    def setAntiAlias(self, *args):
        """setAntiAlias(self, bool antiAlias)"""
        return _fife.IFont_setAntiAlias(self, *args)

    def isAntiAlias(self):
        """isAntiAlias(self) -> bool"""
        return _fife.IFont_isAntiAlias(self)

    def setColor(self, *args):
        """
        setColor(self, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
        setColor(self, uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.IFont_setColor(self, *args)

    def getColor(self):
        """getColor(self) -> SDL_Color"""
        return _fife.IFont_getColor(self)

    def getWidth(self, *args):
        """getWidth(self, string text) -> int32_t"""
        return _fife.IFont_getWidth(self, *args)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.IFont_getHeight(self)

IFont_swigregister = _fife.IFont_swigregister
IFont_swigregister(IFont)

class FontBase(IFont):
    """Proxy of C++ FIFE::FontBase class"""
    __swig_setmethods__ = {}
    for _s in [IFont]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FontBase, name, value)
    __swig_getmethods__ = {}
    for _s in [IFont]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FontBase, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_FontBase
    __del__ = lambda self : None;
FontBase_swigregister = _fife.FontBase_swigregister
FontBase_swigregister(FontBase)

class TTFont(FontBase):
    """Proxy of C++ FIFE::TrueTypeFont class"""
    __swig_setmethods__ = {}
    for _s in [FontBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TTFont, name, value)
    __swig_getmethods__ = {}
    for _s in [FontBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TTFont, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string filename, int32_t size) -> TTFont"""
        this = _fife.new_TTFont(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_TTFont
    __del__ = lambda self : None;
    def setColor(self, *args):
        """
        setColor(self, Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255)
        setColor(self, Uint8 r, Uint8 g, Uint8 b)
        """
        return _fife.TTFont_setColor(self, *args)

    def getWidth(self, *args):
        """getWidth(self, string text) -> int32_t"""
        return _fife.TTFont_getWidth(self, *args)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.TTFont_getHeight(self)

TTFont_swigregister = _fife.TTFont_swigregister
TTFont_swigregister(TTFont)

class SubImageFont(FontBase):
    """Proxy of C++ FIFE::SubImageFont class"""
    __swig_setmethods__ = {}
    for _s in [FontBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SubImageFont, name, value)
    __swig_getmethods__ = {}
    for _s in [FontBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SubImageFont, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string filename, string glyphs) -> SubImageFont"""
        this = _fife.new_SubImageFont(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SubImageFont
    __del__ = lambda self : None;
    def setColor(self, *args):
        """
        setColor(self, Uint8 r, Uint8 g, Uint8 b, Uint8 a = 255)
        setColor(self, Uint8 r, Uint8 g, Uint8 b)
        """
        return _fife.SubImageFont_setColor(self, *args)

    def getWidth(self, *args):
        """getWidth(self, string text) -> int32_t"""
        return _fife.SubImageFont_getWidth(self, *args)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.SubImageFont_getHeight(self)

SubImageFont_swigregister = _fife.SubImageFont_swigregister
SubImageFont_swigregister(SubImageFont)

class Font(_object):
    """Proxy of C++ gcn::Font class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Font, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Font, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Font
    __del__ = lambda self : None;
    def getWidth(self, *args):
        """getWidth(self, string text) -> int32_t"""
        return _fife.Font_getWidth(self, *args)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.Font_getHeight(self)

Font_swigregister = _fife.Font_swigregister
Font_swigregister(Font)

class GuiFont(Font,IFont):
    """Proxy of C++ FIFE::GuiFont class"""
    __swig_setmethods__ = {}
    for _s in [Font,IFont]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GuiFont, name, value)
    __swig_getmethods__ = {}
    for _s in [Font,IFont]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GuiFont, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, IFont font) -> GuiFont"""
        this = _fife.new_GuiFont(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GuiFont
    __del__ = lambda self : None;
    def getStringIndexAt(self, *args):
        """getStringIndexAt(self, string text, int32_t x) -> int32_t"""
        return _fife.GuiFont_getStringIndexAt(self, *args)

    def drawString(self, *args):
        """drawString(self, Graphics graphics, string text, int32_t x, int32_t y)"""
        return _fife.GuiFont_drawString(self, *args)

    def setRowSpacing(self, *args):
        """setRowSpacing(self, int32_t spacing)"""
        return _fife.GuiFont_setRowSpacing(self, *args)

    def getRowSpacing(self):
        """getRowSpacing(self) -> int32_t"""
        return _fife.GuiFont_getRowSpacing(self)

    def setGlyphSpacing(self, *args):
        """setGlyphSpacing(self, int32_t spacing)"""
        return _fife.GuiFont_setGlyphSpacing(self, *args)

    def getGlyphSpacing(self):
        """getGlyphSpacing(self) -> int32_t"""
        return _fife.GuiFont_getGlyphSpacing(self)

    def setAntiAlias(self, *args):
        """setAntiAlias(self, bool antiAlias)"""
        return _fife.GuiFont_setAntiAlias(self, *args)

    def isAntiAlias(self):
        """isAntiAlias(self) -> bool"""
        return _fife.GuiFont_isAntiAlias(self)

    def getAsImage(self, *args):
        """getAsImage(self, string text) -> Image"""
        return _fife.GuiFont_getAsImage(self, *args)

    def setColor(self, *args):
        """
        setColor(self, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
        setColor(self, uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.GuiFont_setColor(self, *args)

    def getColor(self):
        """getColor(self) -> SDL_Color"""
        return _fife.GuiFont_getColor(self)

    def getWidth(self, *args):
        """getWidth(self, string text) -> int32_t"""
        return _fife.GuiFont_getWidth(self, *args)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.GuiFont_getHeight(self)

GuiFont_swigregister = _fife.GuiFont_swigregister
GuiFont_swigregister(GuiFont)

class GcnImage(_object):
    """Proxy of C++ gcn::Image class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GcnImage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GcnImage, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_GcnImage
    __del__ = lambda self : None;
    def load(*args):
        """
        load(string filename, bool convertToDisplayFormat = True) -> GcnImage
        load(string filename) -> GcnImage
        """
        return _fife.GcnImage_load(*args)

    if _newclass:load = staticmethod(load)
    __swig_getmethods__["load"] = lambda x: load
    def getWidth(self):
        """getWidth(self) -> int32_t"""
        return _fife.GcnImage_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.GcnImage_getHeight(self)

GcnImage_swigregister = _fife.GcnImage_swigregister
GcnImage_swigregister(GcnImage)

def GcnImage_load(*args):
  """
    load(string filename, bool convertToDisplayFormat = True) -> GcnImage
    GcnImage_load(string filename) -> GcnImage
    """
  return _fife.GcnImage_load(*args)

class GuiImage(GcnImage):
    """Proxy of C++ FIFE::GuiImage class"""
    __swig_setmethods__ = {}
    for _s in [GcnImage]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GuiImage, name, value)
    __swig_getmethods__ = {}
    for _s in [GcnImage]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GuiImage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> GuiImage
        __init__(self, ImagePtr Image) -> GuiImage
        """
        this = _fife.new_GuiImage(*args)
        try: self.this.append(this)
        except: self.this = this
    def getWidth(self):
        """getWidth(self) -> int32_t"""
        return _fife.GuiImage_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.GuiImage_getHeight(self)

    __swig_destroy__ = _fife.delete_GuiImage
    __del__ = lambda self : None;
GuiImage_swigregister = _fife.GuiImage_swigregister
GuiImage_swigregister(GuiImage)

class ConsoleExecuter(_object):
    """Proxy of C++ FIFE::ConsoleExecuter class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConsoleExecuter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConsoleExecuter, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ConsoleExecuter
    __del__ = lambda self : None;
    def onToolsClick(self):
        """onToolsClick(self)"""
        return _fife.ConsoleExecuter_onToolsClick(self)

    def onConsoleCommand(self, *args):
        """onConsoleCommand(self, string command) -> string"""
        return _fife.ConsoleExecuter_onConsoleCommand(self, *args)

    def __init__(self): 
        """__init__(self) -> ConsoleExecuter"""
        if self.__class__ == ConsoleExecuter:
            _self = None
        else:
            _self = self
        this = _fife.new_ConsoleExecuter(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ConsoleExecuter(self)
        return weakref_proxy(self)
ConsoleExecuter_swigregister = _fife.ConsoleExecuter_swigregister
ConsoleExecuter_swigregister(ConsoleExecuter)

class Console(_object):
    """Proxy of C++ FIFE::Console class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Console, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Console, name)
    __repr__ = _swig_repr
    def show(self):
        """show(self)"""
        return _fife.Console_show(self)

    def hide(self):
        """hide(self)"""
        return _fife.Console_hide(self)

    def clear(self):
        """clear(self)"""
        return _fife.Console_clear(self)

    def toggleShowHide(self):
        """toggleShowHide(self)"""
        return _fife.Console_toggleShowHide(self)

    def println(self, *args):
        """println(self, string s)"""
        return _fife.Console_println(self, *args)

    def setConsoleExecuter(self, *args):
        """setConsoleExecuter(self, ConsoleExecuter consoleexec)"""
        return _fife.Console_setConsoleExecuter(self, *args)

    def removeConsoleExecuter(self):
        """removeConsoleExecuter(self)"""
        return _fife.Console_removeConsoleExecuter(self)

    def __init__(self): 
        """__init__(self) -> Console"""
        this = _fife.new_Console()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Console
    __del__ = lambda self : None;
Console_swigregister = _fife.Console_swigregister
Console_swigregister(Console)

class MouseListener(_object):
    """Proxy of C++ gcn::MouseListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MouseListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MouseListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_MouseListener
    __del__ = lambda self : None;
    def mouseEntered(self, *args):
        """mouseEntered(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseEntered(self, *args)

    def mouseExited(self, *args):
        """mouseExited(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseExited(self, *args)

    def mousePressed(self, *args):
        """mousePressed(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mousePressed(self, *args)

    def mouseReleased(self, *args):
        """mouseReleased(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseReleased(self, *args)

    def mouseClicked(self, *args):
        """mouseClicked(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseClicked(self, *args)

    def mouseWheelMovedUp(self, *args):
        """mouseWheelMovedUp(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseWheelMovedUp(self, *args)

    def mouseWheelMovedDown(self, *args):
        """mouseWheelMovedDown(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseWheelMovedDown(self, *args)

    def mouseMoved(self, *args):
        """mouseMoved(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseMoved(self, *args)

    def mouseDragged(self, *args):
        """mouseDragged(self, gcn::MouseEvent mouseEvent)"""
        return _fife.MouseListener_mouseDragged(self, *args)

    def __init__(self): 
        """__init__(self) -> MouseListener"""
        if self.__class__ == MouseListener:
            _self = None
        else:
            _self = self
        this = _fife.new_MouseListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_MouseListener(self)
        return weakref_proxy(self)
MouseListener_swigregister = _fife.MouseListener_swigregister
MouseListener_swigregister(MouseListener)

class KeyListener(_object):
    """Proxy of C++ gcn::KeyListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, KeyListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, KeyListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_KeyListener
    __del__ = lambda self : None;
    def keyPressed(self, *args):
        """keyPressed(self, gcn::KeyEvent keyEvent)"""
        return _fife.KeyListener_keyPressed(self, *args)

    def keyReleased(self, *args):
        """keyReleased(self, gcn::KeyEvent keyEvent)"""
        return _fife.KeyListener_keyReleased(self, *args)

    def __init__(self): 
        """__init__(self) -> KeyListener"""
        if self.__class__ == KeyListener:
            _self = None
        else:
            _self = self
        this = _fife.new_KeyListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_KeyListener(self)
        return weakref_proxy(self)
KeyListener_swigregister = _fife.KeyListener_swigregister
KeyListener_swigregister(KeyListener)

class ActionListener(_object):
    """Proxy of C++ gcn::ActionListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ActionListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ActionListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ActionListener
    __del__ = lambda self : None;
    def action(self, *args):
        """action(self, gcn::ActionEvent actionEvent)"""
        return _fife.ActionListener_action(self, *args)

    def __init__(self): 
        """__init__(self) -> ActionListener"""
        if self.__class__ == ActionListener:
            _self = None
        else:
            _self = self
        this = _fife.new_ActionListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ActionListener(self)
        return weakref_proxy(self)
ActionListener_swigregister = _fife.ActionListener_swigregister
ActionListener_swigregister(ActionListener)

class IGUIManager(ISdlEventListener):
    """Proxy of C++ FIFE::IGUIManager class"""
    __swig_setmethods__ = {}
    for _s in [ISdlEventListener]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IGUIManager, name, value)
    __swig_getmethods__ = {}
    for _s in [ISdlEventListener]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IGUIManager, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IGUIManager
    __del__ = lambda self : None;
    def turn(self):
        """turn(self)"""
        return _fife.IGUIManager_turn(self)

    def resizeTopContainer(self, *args):
        """resizeTopContainer(self, uint32_t x, uint32_t y, uint32_t width, uint32_t height)"""
        return _fife.IGUIManager_resizeTopContainer(self, *args)

IGUIManager_swigregister = _fife.IGUIManager_swigregister
IGUIManager_swigregister(IGUIManager)

class GUIChanManager(IGUIManager):
    """Proxy of C++ FIFE::GUIChanManager class"""
    __swig_setmethods__ = {}
    for _s in [IGUIManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GUIChanManager, name, value)
    __swig_getmethods__ = {}
    for _s in [IGUIManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GUIChanManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> GUIChanManager"""
        this = _fife.new_GUIChanManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GUIChanManager
    __del__ = lambda self : None;
    def init(self, *args):
        """init(self, string backend, int32_t screenWidth, int32_t screenHeight)"""
        return _fife.GUIChanManager_init(self, *args)

    def getConsole(self):
        """getConsole(self) -> Console"""
        return _fife.GUIChanManager_getConsole(self)

    def add(self, *args):
        """add(self, Widget widget)"""
        return _fife.GUIChanManager_add(self, *args)

    def remove(self, *args):
        """remove(self, Widget widget)"""
        return _fife.GUIChanManager_remove(self, *args)

    def createFont(self, *args):
        """createFont(self, string path, uint32_t size, string glyphs) -> GuiFont"""
        return _fife.GUIChanManager_createFont(self, *args)

    def releaseFont(self, *args):
        """releaseFont(self, GuiFont font)"""
        return _fife.GUIChanManager_releaseFont(self, *args)

    def setDefaultFont(self, *args):
        """setDefaultFont(self, string path, uint32_t size, string glyphs) -> GuiFont"""
        return _fife.GUIChanManager_setDefaultFont(self, *args)

    def getDefaultFont(self):
        """getDefaultFont(self) -> GuiFont"""
        return _fife.GUIChanManager_getDefaultFont(self)

    def translateKeyEvent(self, *args):
        """translateKeyEvent(self, gcn::KeyEvent evt) -> KeyEvent"""
        return _fife.GUIChanManager_translateKeyEvent(self, *args)

    def translateMouseEvent(self, *args):
        """translateMouseEvent(self, gcn::MouseEvent evt) -> MouseEvent"""
        return _fife.GUIChanManager_translateMouseEvent(self, *args)

GUIChanManager_swigregister = _fife.GUIChanManager_swigregister
GUIChanManager_swigregister(GUIChanManager)

class Graphics(_object):
    """Proxy of C++ gcn::Graphics class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Graphics, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Graphics, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    LEFT = _fife.Graphics_LEFT
    CENTER = _fife.Graphics_CENTER
    RIGHT = _fife.Graphics_RIGHT
    __swig_destroy__ = _fife.delete_Graphics
    __del__ = lambda self : None;
Graphics_swigregister = _fife.Graphics_swigregister
Graphics_swigregister(Graphics)

class Color(_object):
    """Proxy of C++ gcn::Color class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Color, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Color, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Color
        __init__(self, int32_t color) -> Color
        __init__(self, int32_t r, int32_t g, int32_t b, int32_t a = 255) -> Color
        __init__(self, int32_t r, int32_t g, int32_t b) -> Color
        """
        this = _fife.new_Color(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, Color color) -> Color"""
        return _fife.Color___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, Color color) -> Color"""
        return _fife.Color___sub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, float value) -> Color"""
        return _fife.Color___mul__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Color color) -> bool"""
        return _fife.Color___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, Color color) -> bool"""
        return _fife.Color___ne__(self, *args)

    __swig_setmethods__["r"] = _fife.Color_r_set
    __swig_getmethods__["r"] = _fife.Color_r_get
    if _newclass:r = _swig_property(_fife.Color_r_get, _fife.Color_r_set)
    __swig_setmethods__["g"] = _fife.Color_g_set
    __swig_getmethods__["g"] = _fife.Color_g_get
    if _newclass:g = _swig_property(_fife.Color_g_get, _fife.Color_g_set)
    __swig_setmethods__["b"] = _fife.Color_b_set
    __swig_getmethods__["b"] = _fife.Color_b_get
    if _newclass:b = _swig_property(_fife.Color_b_get, _fife.Color_b_set)
    __swig_setmethods__["a"] = _fife.Color_a_set
    __swig_getmethods__["a"] = _fife.Color_a_get
    if _newclass:a = _swig_property(_fife.Color_a_get, _fife.Color_a_set)
    __swig_destroy__ = _fife.delete_Color
    __del__ = lambda self : None;
Color_swigregister = _fife.Color_swigregister
Color_swigregister(Color)

class Widget(_object):
    """Proxy of C++ gcn::Widget class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Widget, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Widget, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def setWidth(self, *args):
        """setWidth(self, int32_t width)"""
        return _fife.Widget_setWidth(self, *args)

    def getWidth(self):
        """getWidth(self) -> int32_t"""
        return _fife.Widget_getWidth(self)

    def setHeight(self, *args):
        """setHeight(self, int32_t height)"""
        return _fife.Widget_setHeight(self, *args)

    def getHeight(self):
        """getHeight(self) -> int32_t"""
        return _fife.Widget_getHeight(self)

    def setSize(self, *args):
        """setSize(self, int32_t width, int32_t height)"""
        return _fife.Widget_setSize(self, *args)

    def setX(self, *args):
        """setX(self, int32_t x)"""
        return _fife.Widget_setX(self, *args)

    def getX(self):
        """getX(self) -> int32_t"""
        return _fife.Widget_getX(self)

    def setY(self, *args):
        """setY(self, int32_t y)"""
        return _fife.Widget_setY(self, *args)

    def getY(self):
        """getY(self) -> int32_t"""
        return _fife.Widget_getY(self)

    def setPosition(self, *args):
        """setPosition(self, int32_t x, int32_t y)"""
        return _fife.Widget_setPosition(self, *args)

    def setFrameSize(self, *args):
        """setFrameSize(self, uint32_t frameSize)"""
        return _fife.Widget_setFrameSize(self, *args)

    def getFrameSize(self):
        """getFrameSize(self) -> uint32_t"""
        return _fife.Widget_getFrameSize(self)

    def setFocusable(self, *args):
        """setFocusable(self, bool focusable)"""
        return _fife.Widget_setFocusable(self, *args)

    def isFocusable(self):
        """isFocusable(self) -> bool"""
        return _fife.Widget_isFocusable(self)

    def isFocused(self):
        """isFocused(self) -> bool"""
        return _fife.Widget_isFocused(self)

    def setEnabled(self, *args):
        """setEnabled(self, bool enabled)"""
        return _fife.Widget_setEnabled(self, *args)

    def isEnabled(self):
        """isEnabled(self) -> bool"""
        return _fife.Widget_isEnabled(self)

    def setVisible(self, *args):
        """setVisible(self, bool visible)"""
        return _fife.Widget_setVisible(self, *args)

    def isVisible(self):
        """isVisible(self) -> bool"""
        return _fife.Widget_isVisible(self)

    def setBaseColor(self, *args):
        """setBaseColor(self, Color color)"""
        return _fife.Widget_setBaseColor(self, *args)

    def getBaseColor(self):
        """getBaseColor(self) -> Color"""
        return _fife.Widget_getBaseColor(self)

    def setForegroundColor(self, *args):
        """setForegroundColor(self, Color color)"""
        return _fife.Widget_setForegroundColor(self, *args)

    def getForegroundColor(self):
        """getForegroundColor(self) -> Color"""
        return _fife.Widget_getForegroundColor(self)

    def setBackgroundColor(self, *args):
        """setBackgroundColor(self, Color color)"""
        return _fife.Widget_setBackgroundColor(self, *args)

    def getBackgroundColor(self):
        """getBackgroundColor(self) -> Color"""
        return _fife.Widget_getBackgroundColor(self)

    def setSelectionColor(self, *args):
        """setSelectionColor(self, Color color)"""
        return _fife.Widget_setSelectionColor(self, *args)

    def getSelectionColor(self):
        """getSelectionColor(self) -> Color"""
        return _fife.Widget_getSelectionColor(self)

    def requestFocus(self):
        """requestFocus(self)"""
        return _fife.Widget_requestFocus(self)

    def requestMoveToTop(self):
        """requestMoveToTop(self)"""
        return _fife.Widget_requestMoveToTop(self)

    def requestMoveToBottom(self):
        """requestMoveToBottom(self)"""
        return _fife.Widget_requestMoveToBottom(self)

    def setActionEventId(self, *args):
        """setActionEventId(self, string actionEventId)"""
        return _fife.Widget_setActionEventId(self, *args)

    def getActionEventId(self):
        """getActionEventId(self) -> string"""
        return _fife.Widget_getActionEventId(self)

    def getAbsolutePosition(self, *args):
        """getAbsolutePosition(self, int32_t x, int32_t y)"""
        return _fife.Widget_getAbsolutePosition(self, *args)

    def getFont(self):
        """getFont(self) -> Font"""
        return _fife.Widget_getFont(self)

    def setGlobalFont(*args):
        """setGlobalFont(Font font)"""
        return _fife.Widget_setGlobalFont(*args)

    if _newclass:setGlobalFont = staticmethod(setGlobalFont)
    __swig_getmethods__["setGlobalFont"] = lambda x: setGlobalFont
    def setFont(self, *args):
        """setFont(self, Font font)"""
        return _fife.Widget_setFont(self, *args)

    def isTabInEnabled(self):
        """isTabInEnabled(self) -> bool"""
        return _fife.Widget_isTabInEnabled(self)

    def setTabInEnabled(self, *args):
        """setTabInEnabled(self, bool enabled)"""
        return _fife.Widget_setTabInEnabled(self, *args)

    def isTabOutEnabled(self):
        """isTabOutEnabled(self) -> bool"""
        return _fife.Widget_isTabOutEnabled(self)

    def setTabOutEnabled(self, *args):
        """setTabOutEnabled(self, bool enabled)"""
        return _fife.Widget_setTabOutEnabled(self, *args)

    def requestModalFocus(self):
        """requestModalFocus(self)"""
        return _fife.Widget_requestModalFocus(self)

    def requestModalMouseInputFocus(self):
        """requestModalMouseInputFocus(self)"""
        return _fife.Widget_requestModalMouseInputFocus(self)

    def releaseModalFocus(self):
        """releaseModalFocus(self)"""
        return _fife.Widget_releaseModalFocus(self)

    def releaseModalMouseInputFocus(self):
        """releaseModalMouseInputFocus(self)"""
        return _fife.Widget_releaseModalMouseInputFocus(self)

    def isModalFocused(self):
        """isModalFocused(self) -> bool"""
        return _fife.Widget_isModalFocused(self)

    def isModalMouseInputFocused(self):
        """isModalMouseInputFocused(self) -> bool"""
        return _fife.Widget_isModalMouseInputFocused(self)

    def getWidgetAt(self, *args):
        """getWidgetAt(self, int32_t x, int32_t y) -> Widget"""
        return _fife.Widget_getWidgetAt(self, *args)

    def moveToTop(self, *args):
        """moveToTop(self, Widget widget)"""
        return _fife.Widget_moveToTop(self, *args)

    def moveToBottom(self, *args):
        """moveToBottom(self, Widget widget)"""
        return _fife.Widget_moveToBottom(self, *args)

    def focusNext(self):
        """focusNext(self)"""
        return _fife.Widget_focusNext(self)

    def focusPrevious(self):
        """focusPrevious(self)"""
        return _fife.Widget_focusPrevious(self)

    def addActionListener(self, *args):
        """addActionListener(self, ActionListener actionListener)"""
        return _fife.Widget_addActionListener(self, *args)

    def removeActionListener(self, *args):
        """removeActionListener(self, ActionListener actionListener)"""
        return _fife.Widget_removeActionListener(self, *args)

    def addMouseListener(self, *args):
        """addMouseListener(self, MouseListener actionListener)"""
        return _fife.Widget_addMouseListener(self, *args)

    def removeMouseListener(self, *args):
        """removeMouseListener(self, MouseListener actionListener)"""
        return _fife.Widget_removeMouseListener(self, *args)

    def addKeyListener(self, *args):
        """addKeyListener(self, KeyListener actionListener)"""
        return _fife.Widget_addKeyListener(self, *args)

    def removeKeyListener(self, *args):
        """removeKeyListener(self, KeyListener actionListener)"""
        return _fife.Widget_removeKeyListener(self, *args)

    def draw(self, *args):
        """draw(self, Graphics graphics)"""
        return _fife.Widget_draw(self, *args)

    __swig_destroy__ = _fife.delete_Widget
    __del__ = lambda self : None;
Widget_swigregister = _fife.Widget_swigregister
Widget_swigregister(Widget)

def Widget_setGlobalFont(*args):
  """Widget_setGlobalFont(Font font)"""
  return _fife.Widget_setGlobalFont(*args)

class Container(Widget):
    """Proxy of C++ gcn::Container class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Container, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Container, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Container"""
        this = _fife.new_Container()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Container
    __del__ = lambda self : None;
    def setOpaque(self, *args):
        """setOpaque(self, bool opaque)"""
        return _fife.Container_setOpaque(self, *args)

    def isOpaque(self):
        """isOpaque(self) -> bool"""
        return _fife.Container_isOpaque(self)

    def add(self, *args):
        """
        add(self, Widget widget)
        add(self, Widget widget, int32_t x, int32_t y)
        """
        return _fife.Container_add(self, *args)

    def remove(self, *args):
        """remove(self, Widget widget)"""
        return _fife.Container_remove(self, *args)

    def clear(self):
        """clear(self)"""
        return _fife.Container_clear(self)

Container_swigregister = _fife.Container_swigregister
Container_swigregister(Container)

class CheckBox(Widget):
    """Proxy of C++ gcn::CheckBox class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CheckBox, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CheckBox, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> CheckBox"""
        this = _fife.new_CheckBox()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_CheckBox
    __del__ = lambda self : None;
    def isSelected(self):
        """isSelected(self) -> bool"""
        return _fife.CheckBox_isSelected(self)

    def setSelected(self, *args):
        """setSelected(self, bool marked)"""
        return _fife.CheckBox_setSelected(self, *args)

    def getCaption(self):
        """getCaption(self) -> string"""
        return _fife.CheckBox_getCaption(self)

    def setCaption(self, *args):
        """setCaption(self, string caption)"""
        return _fife.CheckBox_setCaption(self, *args)

    def adjustSize(self):
        """adjustSize(self)"""
        return _fife.CheckBox_adjustSize(self)

CheckBox_swigregister = _fife.CheckBox_swigregister
CheckBox_swigregister(CheckBox)

class TextField(Widget):
    """Proxy of C++ gcn::UTF8TextField class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextField, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TextField, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        UTF8TextField() -> TextField
        __init__(self, string text) -> TextField
        """
        this = _fife.new_TextField(*args)
        try: self.this.append(this)
        except: self.this = this
    def setText(self, *args):
        """setText(self, string text)"""
        return _fife.TextField_setText(self, *args)

    def getText(self):
        """getText(self) -> string"""
        return _fife.TextField_getText(self)

    def adjustSize(self):
        """adjustSize(self)"""
        return _fife.TextField_adjustSize(self)

    def adjustHeight(self):
        """adjustHeight(self)"""
        return _fife.TextField_adjustHeight(self)

    def setCaretPosition(self, *args):
        """setCaretPosition(self, uint32_t position)"""
        return _fife.TextField_setCaretPosition(self, *args)

    def getCaretPosition(self):
        """getCaretPosition(self) -> uint32_t"""
        return _fife.TextField_getCaretPosition(self)

    __swig_destroy__ = _fife.delete_TextField
    __del__ = lambda self : None;
TextField_swigregister = _fife.TextField_swigregister
TextField_swigregister(TextField)

class Button(Widget):
    """Proxy of C++ gcn::Button class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Button, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Button, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Button
        __init__(self, string caption) -> Button
        """
        this = _fife.new_Button(*args)
        try: self.this.append(this)
        except: self.this = this
    def setCaption(self, *args):
        """setCaption(self, string caption)"""
        return _fife.Button_setCaption(self, *args)

    def getCaption(self):
        """getCaption(self) -> string"""
        return _fife.Button_getCaption(self)

    def setAlignment(self, *args):
        """setAlignment(self, Alignment alignment)"""
        return _fife.Button_setAlignment(self, *args)

    def getAlignment(self):
        """getAlignment(self) -> Alignment"""
        return _fife.Button_getAlignment(self)

    def adjustSize(self):
        """adjustSize(self)"""
        return _fife.Button_adjustSize(self)

    __swig_destroy__ = _fife.delete_Button
    __del__ = lambda self : None;
Button_swigregister = _fife.Button_swigregister
Button_swigregister(Button)

class TwoButton(Widget):
    """Proxy of C++ gcn::TwoButton class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TwoButton, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TwoButton, name)
    __repr__ = _swig_repr
    def __init__(self, up_image = None, down_image = None, hover_image = None, 
    caption = ""): 
        """
        __init__(self, GcnImage up_image = None, GcnImage down_image = None, 
            GcnImage hover_image = None, char caption = "") -> TwoButton
        __init__(self, GcnImage up_image = None, GcnImage down_image = None, 
            GcnImage hover_image = None) -> TwoButton
        __init__(self, GcnImage up_image = None, GcnImage down_image = None) -> TwoButton
        __init__(self, GcnImage up_image = None) -> TwoButton
        __init__(self) -> TwoButton
        """
        this = _fife.new_TwoButton(up_image, down_image, hover_image, caption)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_TwoButton
    __del__ = lambda self : None;
    def setCaption(self, *args):
        """setCaption(self, string caption)"""
        return _fife.TwoButton_setCaption(self, *args)

    def getCaption(self):
        """getCaption(self) -> string"""
        return _fife.TwoButton_getCaption(self)

    def setAlignment(self, *args):
        """setAlignment(self, Alignment alignment)"""
        return _fife.TwoButton_setAlignment(self, *args)

    def getAlignment(self):
        """getAlignment(self) -> Alignment"""
        return _fife.TwoButton_getAlignment(self)

    def setUpImage(self, *args):
        """setUpImage(self, GcnImage image)"""
        return _fife.TwoButton_setUpImage(self, *args)

    def setDownImage(self, *args):
        """setDownImage(self, GcnImage image)"""
        return _fife.TwoButton_setDownImage(self, *args)

    def setHoverImage(self, *args):
        """setHoverImage(self, GcnImage image)"""
        return _fife.TwoButton_setHoverImage(self, *args)

    def setDownOffset(self, *args):
        """setDownOffset(self, int32_t x, int32_t y)"""
        return _fife.TwoButton_setDownOffset(self, *args)

    def getDownXOffset(self):
        """getDownXOffset(self) -> int32_t"""
        return _fife.TwoButton_getDownXOffset(self)

    def getDownYOffset(self):
        """getDownYOffset(self) -> int32_t"""
        return _fife.TwoButton_getDownYOffset(self)

TwoButton_swigregister = _fife.TwoButton_swigregister
TwoButton_swigregister(TwoButton)

class ToggleButton(Widget):
    """Proxy of C++ gcn::ToggleButton class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ToggleButton, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ToggleButton, name)
    __repr__ = _swig_repr
    def __init__(self, up_image = None, down_image = None, hover_image = None, 
    caption = "", group = ""): 
        """
        __init__(self, GcnImage up_image = None, GcnImage down_image = None, 
            GcnImage hover_image = None, char caption = "", 
            char group = "") -> ToggleButton
        __init__(self, GcnImage up_image = None, GcnImage down_image = None, 
            GcnImage hover_image = None, char caption = "") -> ToggleButton
        __init__(self, GcnImage up_image = None, GcnImage down_image = None, 
            GcnImage hover_image = None) -> ToggleButton
        __init__(self, GcnImage up_image = None, GcnImage down_image = None) -> ToggleButton
        __init__(self, GcnImage up_image = None) -> ToggleButton
        __init__(self) -> ToggleButton
        """
        this = _fife.new_ToggleButton(up_image, down_image, hover_image, caption, group)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_ToggleButton
    __del__ = lambda self : None;
    def setCaption(self, *args):
        """setCaption(self, string caption)"""
        return _fife.ToggleButton_setCaption(self, *args)

    def getCaption(self):
        """getCaption(self) -> string"""
        return _fife.ToggleButton_getCaption(self)

    def setAlignment(self, *args):
        """setAlignment(self, Alignment alignment)"""
        return _fife.ToggleButton_setAlignment(self, *args)

    def getAlignment(self):
        """getAlignment(self) -> Alignment"""
        return _fife.ToggleButton_getAlignment(self)

    def setSpacing(self, *args):
        """setSpacing(self, uint32_t spacing)"""
        return _fife.ToggleButton_setSpacing(self, *args)

    def getSpacing(self):
        """getSpacing(self) -> uint32_t"""
        return _fife.ToggleButton_getSpacing(self)

    def setUpImage(self, *args):
        """setUpImage(self, GcnImage image)"""
        return _fife.ToggleButton_setUpImage(self, *args)

    def setDownImage(self, *args):
        """setDownImage(self, GcnImage image)"""
        return _fife.ToggleButton_setDownImage(self, *args)

    def setHoverImage(self, *args):
        """setHoverImage(self, GcnImage image)"""
        return _fife.ToggleButton_setHoverImage(self, *args)

    def setDownOffset(self, *args):
        """setDownOffset(self, int32_t x, int32_t y)"""
        return _fife.ToggleButton_setDownOffset(self, *args)

    def getDownXOffset(self):
        """getDownXOffset(self) -> int32_t"""
        return _fife.ToggleButton_getDownXOffset(self)

    def getDownYOffset(self):
        """getDownYOffset(self) -> int32_t"""
        return _fife.ToggleButton_getDownYOffset(self)

    def isToggled(self):
        """isToggled(self) -> bool"""
        return _fife.ToggleButton_isToggled(self)

    def setToggled(self, *args):
        """setToggled(self, bool toggled)"""
        return _fife.ToggleButton_setToggled(self, *args)

    def setGroup(self, *args):
        """setGroup(self, string group)"""
        return _fife.ToggleButton_setGroup(self, *args)

    def getGroup(self):
        """getGroup(self) -> string"""
        return _fife.ToggleButton_getGroup(self)

ToggleButton_swigregister = _fife.ToggleButton_swigregister
ToggleButton_swigregister(ToggleButton)

class ScrollArea(Widget):
    """Proxy of C++ gcn::ScrollArea class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScrollArea, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScrollArea, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ScrollArea
        __init__(self, Widget content) -> ScrollArea
        __init__(self, Widget content, ScrollPolicy hPolicy, ScrollPolicy vPolicy) -> ScrollArea
        """
        this = _fife.new_ScrollArea(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_ScrollArea
    __del__ = lambda self : None;
    def setContent(self, *args):
        """setContent(self, Widget widget)"""
        return _fife.ScrollArea_setContent(self, *args)

    def getContent(self):
        """getContent(self) -> Widget"""
        return _fife.ScrollArea_getContent(self)

    def setHorizontalScrollPolicy(self, *args):
        """setHorizontalScrollPolicy(self, ScrollPolicy hPolicy)"""
        return _fife.ScrollArea_setHorizontalScrollPolicy(self, *args)

    def getHorizontalScrollPolicy(self):
        """getHorizontalScrollPolicy(self) -> ScrollPolicy"""
        return _fife.ScrollArea_getHorizontalScrollPolicy(self)

    def setVerticalScrollPolicy(self, *args):
        """setVerticalScrollPolicy(self, ScrollPolicy vPolicy)"""
        return _fife.ScrollArea_setVerticalScrollPolicy(self, *args)

    def getVerticalScrollPolicy(self):
        """getVerticalScrollPolicy(self) -> ScrollPolicy"""
        return _fife.ScrollArea_getVerticalScrollPolicy(self)

    def setScrollPolicy(self, *args):
        """setScrollPolicy(self, ScrollPolicy hPolicy, ScrollPolicy vPolicy)"""
        return _fife.ScrollArea_setScrollPolicy(self, *args)

    def setVerticalScrollAmount(self, *args):
        """setVerticalScrollAmount(self, int32_t vScroll)"""
        return _fife.ScrollArea_setVerticalScrollAmount(self, *args)

    def getVerticalScrollAmount(self):
        """getVerticalScrollAmount(self) -> int32_t"""
        return _fife.ScrollArea_getVerticalScrollAmount(self)

    def setHorizontalScrollAmount(self, *args):
        """setHorizontalScrollAmount(self, int32_t hScroll)"""
        return _fife.ScrollArea_setHorizontalScrollAmount(self, *args)

    def getHorizontalScrollAmount(self):
        """getHorizontalScrollAmount(self) -> int32_t"""
        return _fife.ScrollArea_getHorizontalScrollAmount(self)

    def setScrollAmount(self, *args):
        """setScrollAmount(self, int32_t hScroll, int32_t vScroll)"""
        return _fife.ScrollArea_setScrollAmount(self, *args)

    def getHorizontalMaxScroll(self):
        """getHorizontalMaxScroll(self) -> int32_t"""
        return _fife.ScrollArea_getHorizontalMaxScroll(self)

    def getVerticalMaxScroll(self):
        """getVerticalMaxScroll(self) -> int32_t"""
        return _fife.ScrollArea_getVerticalMaxScroll(self)

    def setScrollbarWidth(self, *args):
        """setScrollbarWidth(self, int32_t width)"""
        return _fife.ScrollArea_setScrollbarWidth(self, *args)

    def getScrollbarWidth(self):
        """getScrollbarWidth(self) -> int32_t"""
        return _fife.ScrollArea_getScrollbarWidth(self)

    def setLeftButtonScrollAmount(self, *args):
        """setLeftButtonScrollAmount(self, int32_t amount)"""
        return _fife.ScrollArea_setLeftButtonScrollAmount(self, *args)

    def setRightButtonScrollAmount(self, *args):
        """setRightButtonScrollAmount(self, int32_t amount)"""
        return _fife.ScrollArea_setRightButtonScrollAmount(self, *args)

    def setUpButtonScrollAmount(self, *args):
        """setUpButtonScrollAmount(self, int32_t amount)"""
        return _fife.ScrollArea_setUpButtonScrollAmount(self, *args)

    def setDownButtonScrollAmount(self, *args):
        """setDownButtonScrollAmount(self, int32_t amount)"""
        return _fife.ScrollArea_setDownButtonScrollAmount(self, *args)

    def getLeftButtonScrollAmount(self):
        """getLeftButtonScrollAmount(self) -> int32_t"""
        return _fife.ScrollArea_getLeftButtonScrollAmount(self)

    def getRightButtonScrollAmount(self):
        """getRightButtonScrollAmount(self) -> int32_t"""
        return _fife.ScrollArea_getRightButtonScrollAmount(self)

    def getUpButtonScrollAmount(self):
        """getUpButtonScrollAmount(self) -> int32_t"""
        return _fife.ScrollArea_getUpButtonScrollAmount(self)

    def getDownButtonScrollAmount(self):
        """getDownButtonScrollAmount(self) -> int32_t"""
        return _fife.ScrollArea_getDownButtonScrollAmount(self)

    SHOW_ALWAYS = _fife.ScrollArea_SHOW_ALWAYS
    SHOW_NEVER = _fife.ScrollArea_SHOW_NEVER
    SHOW_AUTO = _fife.ScrollArea_SHOW_AUTO
ScrollArea_swigregister = _fife.ScrollArea_swigregister
ScrollArea_swigregister(ScrollArea)

class TextBox(Widget):
    """Proxy of C++ gcn::UTF8TextBox class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TextBox, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TextBox, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        UTF8TextBox() -> TextBox
        __init__(self, string text) -> TextBox
        """
        this = _fife.new_TextBox(*args)
        try: self.this.append(this)
        except: self.this = this
    def setText(self, *args):
        """setText(self, string text)"""
        return _fife.TextBox_setText(self, *args)

    def getText(self):
        """getText(self) -> string"""
        return _fife.TextBox_getText(self)

    def getTextRow(self, *args):
        """getTextRow(self, int32_t row) -> string"""
        return _fife.TextBox_getTextRow(self, *args)

    def setTextRow(self, *args):
        """setTextRow(self, int32_t row, string text)"""
        return _fife.TextBox_setTextRow(self, *args)

    def getNumberOfRows(self):
        """getNumberOfRows(self) -> uint32_t"""
        return _fife.TextBox_getNumberOfRows(self)

    def getCaretPosition(self):
        """getCaretPosition(self) -> uint32_t"""
        return _fife.TextBox_getCaretPosition(self)

    def setCaretPosition(self, *args):
        """setCaretPosition(self, uint32_t position)"""
        return _fife.TextBox_setCaretPosition(self, *args)

    def getCaretRow(self):
        """getCaretRow(self) -> uint32_t"""
        return _fife.TextBox_getCaretRow(self)

    def setCaretRow(self, *args):
        """setCaretRow(self, int32_t row)"""
        return _fife.TextBox_setCaretRow(self, *args)

    def getCaretColumn(self):
        """getCaretColumn(self) -> uint32_t"""
        return _fife.TextBox_getCaretColumn(self)

    def setCaretColumn(self, *args):
        """setCaretColumn(self, int32_t column)"""
        return _fife.TextBox_setCaretColumn(self, *args)

    def setCaretRowColumn(self, *args):
        """setCaretRowColumn(self, int32_t row, int32_t column)"""
        return _fife.TextBox_setCaretRowColumn(self, *args)

    def scrollToCaret(self):
        """scrollToCaret(self)"""
        return _fife.TextBox_scrollToCaret(self)

    def isEditable(self):
        """isEditable(self) -> bool"""
        return _fife.TextBox_isEditable(self)

    def setEditable(self, *args):
        """setEditable(self, bool editable)"""
        return _fife.TextBox_setEditable(self, *args)

    def addRow(self, *args):
        """addRow(self, string row)"""
        return _fife.TextBox_addRow(self, *args)

    def isOpaque(self):
        """isOpaque(self) -> bool"""
        return _fife.TextBox_isOpaque(self)

    def setOpaque(self, *args):
        """setOpaque(self, bool opaque)"""
        return _fife.TextBox_setOpaque(self, *args)

    __swig_destroy__ = _fife.delete_TextBox
    __del__ = lambda self : None;
TextBox_swigregister = _fife.TextBox_swigregister
TextBox_swigregister(TextBox)

class ListModel(_object):
    """Proxy of C++ gcn::ListModel class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListModel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ListModel, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ListModel
    __del__ = lambda self : None;
    def getNumberOfElements(self):
        """getNumberOfElements(self) -> int32_t"""
        return _fife.ListModel_getNumberOfElements(self)

    def getElementAt(self, *args):
        """getElementAt(self, int32_t i) -> string"""
        return _fife.ListModel_getElementAt(self, *args)

    def __init__(self): 
        """__init__(self) -> ListModel"""
        if self.__class__ == ListModel:
            _self = None
        else:
            _self = self
        this = _fife.new_ListModel(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ListModel(self)
        return weakref_proxy(self)
ListModel_swigregister = _fife.ListModel_swigregister
ListModel_swigregister(ListModel)

class ListBox(Widget):
    """Proxy of C++ gcn::ListBox class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ListBox, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ListBox, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> ListBox
        __init__(self, ListModel listModel) -> ListBox
        """
        this = _fife.new_ListBox(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_ListBox
    __del__ = lambda self : None;
    def getSelected(self):
        """getSelected(self) -> int32_t"""
        return _fife.ListBox_getSelected(self)

    def setSelected(self, *args):
        """setSelected(self, int32_t selected)"""
        return _fife.ListBox_setSelected(self, *args)

    def setListModel(self, *args):
        """setListModel(self, ListModel listModel)"""
        return _fife.ListBox_setListModel(self, *args)

    def getListModel(self):
        """getListModel(self) -> ListModel"""
        return _fife.ListBox_getListModel(self)

    def adjustSize(self):
        """adjustSize(self)"""
        return _fife.ListBox_adjustSize(self)

    def isWrappingEnabled(self):
        """isWrappingEnabled(self) -> bool"""
        return _fife.ListBox_isWrappingEnabled(self)

    def setWrappingEnabled(self, *args):
        """setWrappingEnabled(self, bool wrapping)"""
        return _fife.ListBox_setWrappingEnabled(self, *args)

ListBox_swigregister = _fife.ListBox_swigregister
ListBox_swigregister(ListBox)

class DropDown(Widget):
    """Proxy of C++ gcn::DropDown class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DropDown, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DropDown, name)
    __repr__ = _swig_repr
    def __init__(self, listModel = None, scrollArea = None, listBox = None): 
        """
        __init__(self, ListModel listModel = None, ScrollArea scrollArea = None, 
            ListBox listBox = None) -> DropDown
        __init__(self, ListModel listModel = None, ScrollArea scrollArea = None) -> DropDown
        __init__(self, ListModel listModel = None) -> DropDown
        __init__(self) -> DropDown
        """
        this = _fife.new_DropDown(listModel, scrollArea, listBox)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_DropDown
    __del__ = lambda self : None;
    def getSelected(self):
        """getSelected(self) -> int32_t"""
        return _fife.DropDown_getSelected(self)

    def setSelected(self, *args):
        """setSelected(self, int32_t selected)"""
        return _fife.DropDown_setSelected(self, *args)

    def setListModel(self, *args):
        """setListModel(self, ListModel listModel)"""
        return _fife.DropDown_setListModel(self, *args)

    def getListModel(self):
        """getListModel(self) -> ListModel"""
        return _fife.DropDown_getListModel(self)

    def adjustHeight(self):
        """adjustHeight(self)"""
        return _fife.DropDown_adjustHeight(self)

    def setBaseColor(self, *args):
        """setBaseColor(self, Color color)"""
        return _fife.DropDown_setBaseColor(self, *args)

    def getBaseColor(self):
        """getBaseColor(self) -> Color"""
        return _fife.DropDown_getBaseColor(self)

    def setForegroundColor(self, *args):
        """setForegroundColor(self, Color color)"""
        return _fife.DropDown_setForegroundColor(self, *args)

    def getForegroundColor(self):
        """getForegroundColor(self) -> Color"""
        return _fife.DropDown_getForegroundColor(self)

    def setBackgroundColor(self, *args):
        """setBackgroundColor(self, Color color)"""
        return _fife.DropDown_setBackgroundColor(self, *args)

    def getBackgroundColor(self):
        """getBackgroundColor(self) -> Color"""
        return _fife.DropDown_getBackgroundColor(self)

    def setSelectionColor(self, *args):
        """setSelectionColor(self, Color color)"""
        return _fife.DropDown_setSelectionColor(self, *args)

    def getSelectionColor(self):
        """getSelectionColor(self) -> Color"""
        return _fife.DropDown_getSelectionColor(self)

DropDown_swigregister = _fife.DropDown_swigregister
DropDown_swigregister(DropDown)

class RadioButton(Widget):
    """Proxy of C++ gcn::RadioButton class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RadioButton, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RadioButton, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> RadioButton
        __init__(self, string caption, string group, bool marked = False) -> RadioButton
        __init__(self, string caption, string group) -> RadioButton
        """
        this = _fife.new_RadioButton(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_RadioButton
    __del__ = lambda self : None;
    def isSelected(self):
        """isSelected(self) -> bool"""
        return _fife.RadioButton_isSelected(self)

    def setSelected(self, *args):
        """setSelected(self, bool marked)"""
        return _fife.RadioButton_setSelected(self, *args)

    def getCaption(self):
        """getCaption(self) -> string"""
        return _fife.RadioButton_getCaption(self)

    def setCaption(self, *args):
        """setCaption(self, string caption)"""
        return _fife.RadioButton_setCaption(self, *args)

    def setGroup(self, *args):
        """setGroup(self, string group)"""
        return _fife.RadioButton_setGroup(self, *args)

    def getGroup(self):
        """getGroup(self) -> string"""
        return _fife.RadioButton_getGroup(self)

    def adjustSize(self):
        """adjustSize(self)"""
        return _fife.RadioButton_adjustSize(self)

RadioButton_swigregister = _fife.RadioButton_swigregister
RadioButton_swigregister(RadioButton)

class Slider(Widget):
    """Proxy of C++ gcn::Slider class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Slider, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Slider, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, double scaleEnd = 1.0) -> Slider
        __init__(self) -> Slider
        __init__(self, double scaleStart, double scaleEnd) -> Slider
        """
        this = _fife.new_Slider(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Slider
    __del__ = lambda self : None;
    def setScale(self, *args):
        """setScale(self, double scaleStart, double scaleEnd)"""
        return _fife.Slider_setScale(self, *args)

    def getScaleStart(self):
        """getScaleStart(self) -> double"""
        return _fife.Slider_getScaleStart(self)

    def setScaleStart(self, *args):
        """setScaleStart(self, double scaleStart)"""
        return _fife.Slider_setScaleStart(self, *args)

    def getScaleEnd(self):
        """getScaleEnd(self) -> double"""
        return _fife.Slider_getScaleEnd(self)

    def setScaleEnd(self, *args):
        """setScaleEnd(self, double scaleEnd)"""
        return _fife.Slider_setScaleEnd(self, *args)

    def getValue(self):
        """getValue(self) -> double"""
        return _fife.Slider_getValue(self)

    def setValue(self, *args):
        """setValue(self, double value)"""
        return _fife.Slider_setValue(self, *args)

    def setMarkerLength(self, *args):
        """setMarkerLength(self, int32_t length)"""
        return _fife.Slider_setMarkerLength(self, *args)

    def getMarkerLength(self):
        """getMarkerLength(self) -> int32_t"""
        return _fife.Slider_getMarkerLength(self)

    def setOrientation(self, *args):
        """setOrientation(self, Orientation orientation)"""
        return _fife.Slider_setOrientation(self, *args)

    def getOrientation(self):
        """getOrientation(self) -> Orientation"""
        return _fife.Slider_getOrientation(self)

    def setStepLength(self, *args):
        """setStepLength(self, double length)"""
        return _fife.Slider_setStepLength(self, *args)

    def getStepLength(self):
        """getStepLength(self) -> double"""
        return _fife.Slider_getStepLength(self)

    HORIZONTAL = _fife.Slider_HORIZONTAL
    VERTICAL = _fife.Slider_VERTICAL
Slider_swigregister = _fife.Slider_swigregister
Slider_swigregister(Slider)

class Window(Container):
    """Proxy of C++ gcn::Window class"""
    __swig_setmethods__ = {}
    for _s in [Container]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Window, name, value)
    __swig_getmethods__ = {}
    for _s in [Container]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Window, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Window
        __init__(self, string caption) -> Window
        """
        this = _fife.new_Window(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Window
    __del__ = lambda self : None;
    def setCaption(self, *args):
        """setCaption(self, string caption)"""
        return _fife.Window_setCaption(self, *args)

    def getCaption(self):
        """getCaption(self) -> string"""
        return _fife.Window_getCaption(self)

    def setAlignment(self, *args):
        """setAlignment(self, Alignment alignment)"""
        return _fife.Window_setAlignment(self, *args)

    def getAlignment(self):
        """getAlignment(self) -> Alignment"""
        return _fife.Window_getAlignment(self)

    def setPadding(self, *args):
        """setPadding(self, uint32_t padding)"""
        return _fife.Window_setPadding(self, *args)

    def getPadding(self):
        """getPadding(self) -> uint32_t"""
        return _fife.Window_getPadding(self)

    def setTitleBarHeight(self, *args):
        """setTitleBarHeight(self, uint32_t height)"""
        return _fife.Window_setTitleBarHeight(self, *args)

    def getTitleBarHeight(self):
        """getTitleBarHeight(self) -> uint32_t"""
        return _fife.Window_getTitleBarHeight(self)

    def setMovable(self, *args):
        """setMovable(self, bool movable)"""
        return _fife.Window_setMovable(self, *args)

    def isMovable(self):
        """isMovable(self) -> bool"""
        return _fife.Window_isMovable(self)

    def setOpaque(self, *args):
        """setOpaque(self, bool opaque)"""
        return _fife.Window_setOpaque(self, *args)

    def isOpaque(self):
        """isOpaque(self) -> bool"""
        return _fife.Window_isOpaque(self)

    def resizeToContent(self):
        """resizeToContent(self)"""
        return _fife.Window_resizeToContent(self)

Window_swigregister = _fife.Window_swigregister
Window_swigregister(Window)

class Label(Widget):
    """Proxy of C++ gcn::ClickLabel class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Label, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Label, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        ClickLabel() -> Label
        __init__(self, string caption) -> Label
        """
        this = _fife.new_Label(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Label
    __del__ = lambda self : None;
    def setCaption(self, *args):
        """setCaption(self, string caption)"""
        return _fife.Label_setCaption(self, *args)

    def getCaption(self):
        """getCaption(self) -> string"""
        return _fife.Label_getCaption(self)

    def isTextWrapping(self):
        """isTextWrapping(self) -> bool"""
        return _fife.Label_isTextWrapping(self)

    def setTextWrapping(self, *args):
        """setTextWrapping(self, bool arg0)"""
        return _fife.Label_setTextWrapping(self, *args)

    def setWidth(self, *args):
        """setWidth(self, int32_t width)"""
        return _fife.Label_setWidth(self, *args)

    def adjustSize(self):
        """adjustSize(self)"""
        return _fife.Label_adjustSize(self)

Label_swigregister = _fife.Label_swigregister
Label_swigregister(Label)

class Icon(Widget):
    """Proxy of C++ gcn::Icon2 class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Icon, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Icon, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, GcnImage image) -> Icon"""
        this = _fife.new_Icon(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Icon
    __del__ = lambda self : None;
    def setImage(self, *args):
        """setImage(self, GcnImage image)"""
        return _fife.Icon_setImage(self, *args)

Icon_swigregister = _fife.Icon_swigregister
Icon_swigregister(Icon)

class PercentageBar(Widget):
    """Proxy of C++ gcn::PercentageBar class"""
    __swig_setmethods__ = {}
    for _s in [Widget]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PercentageBar, name, value)
    __swig_getmethods__ = {}
    for _s in [Widget]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PercentageBar, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> PercentageBar"""
        this = _fife.new_PercentageBar()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_PercentageBar
    __del__ = lambda self : None;
    def setForegroundImage(self, *args):
        """setForegroundImage(self, GcnImage image)"""
        return _fife.PercentageBar_setForegroundImage(self, *args)

    def setOrientation(self, *args):
        """setOrientation(self, Orientation orientation)"""
        return _fife.PercentageBar_setOrientation(self, *args)

    def getOrientation(self):
        """getOrientation(self) -> Orientation"""
        return _fife.PercentageBar_getOrientation(self)

    def getValue(self):
        """getValue(self) -> int32_t"""
        return _fife.PercentageBar_getValue(self)

    def setValue(self, *args):
        """setValue(self, int32_t value)"""
        return _fife.PercentageBar_setValue(self, *args)

    HORIZONTAL = _fife.PercentageBar_HORIZONTAL
    VERTICAL = _fife.PercentageBar_VERTICAL
PercentageBar_swigregister = _fife.PercentageBar_swigregister
PercentageBar_swigregister(PercentageBar)

class Exception(_object):
    """Proxy of C++ FIFE::Exception class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Exception, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Exception, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> Exception"""
        this = _fife.new_Exception(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Exception
    __del__ = lambda self : None;
    def what(self):
        """what(self) -> char"""
        return _fife.Exception_what(self)

    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.Exception_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.Exception_getDescription(self)

Exception_swigregister = _fife.Exception_swigregister
Exception_swigregister(Exception)

class SDLException(Exception):
    """Proxy of C++ FIFE::SDLException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SDLException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SDLException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> SDLException"""
        this = _fife.new_SDLException(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.SDLException_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.SDLException_getDescription(self)

    __swig_destroy__ = _fife.delete_SDLException
    __del__ = lambda self : None;
SDLException_swigregister = _fife.SDLException_swigregister
SDLException_swigregister(SDLException)

class NotFound(Exception):
    """Proxy of C++ FIFE::NotFound class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotFound, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotFound, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> NotFound"""
        this = _fife.new_NotFound(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.NotFound_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.NotFound_getDescription(self)

    __swig_destroy__ = _fife.delete_NotFound
    __del__ = lambda self : None;
NotFound_swigregister = _fife.NotFound_swigregister
NotFound_swigregister(NotFound)

class NotSet(Exception):
    """Proxy of C++ FIFE::NotSet class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotSet, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotSet, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> NotSet"""
        this = _fife.new_NotSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.NotSet_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.NotSet_getDescription(self)

    __swig_destroy__ = _fife.delete_NotSet
    __del__ = lambda self : None;
NotSet_swigregister = _fife.NotSet_swigregister
NotSet_swigregister(NotSet)

class IndexOverflow(Exception):
    """Proxy of C++ FIFE::IndexOverflow class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexOverflow, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexOverflow, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> IndexOverflow"""
        this = _fife.new_IndexOverflow(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.IndexOverflow_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.IndexOverflow_getDescription(self)

    __swig_destroy__ = _fife.delete_IndexOverflow
    __del__ = lambda self : None;
IndexOverflow_swigregister = _fife.IndexOverflow_swigregister
IndexOverflow_swigregister(IndexOverflow)

class InvalidFormat(Exception):
    """Proxy of C++ FIFE::InvalidFormat class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidFormat, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidFormat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> InvalidFormat"""
        this = _fife.new_InvalidFormat(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.InvalidFormat_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.InvalidFormat_getDescription(self)

    __swig_destroy__ = _fife.delete_InvalidFormat
    __del__ = lambda self : None;
InvalidFormat_swigregister = _fife.InvalidFormat_swigregister
InvalidFormat_swigregister(InvalidFormat)

class CannotOpenFile(Exception):
    """Proxy of C++ FIFE::CannotOpenFile class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CannotOpenFile, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CannotOpenFile, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> CannotOpenFile"""
        this = _fife.new_CannotOpenFile(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.CannotOpenFile_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.CannotOpenFile_getDescription(self)

    __swig_destroy__ = _fife.delete_CannotOpenFile
    __del__ = lambda self : None;
CannotOpenFile_swigregister = _fife.CannotOpenFile_swigregister
CannotOpenFile_swigregister(CannotOpenFile)

class InvalidConversion(Exception):
    """Proxy of C++ FIFE::InvalidConversion class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidConversion, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidConversion, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> InvalidConversion"""
        this = _fife.new_InvalidConversion(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.InvalidConversion_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.InvalidConversion_getDescription(self)

    __swig_destroy__ = _fife.delete_InvalidConversion
    __del__ = lambda self : None;
InvalidConversion_swigregister = _fife.InvalidConversion_swigregister
InvalidConversion_swigregister(InvalidConversion)

class NotSupported(Exception):
    """Proxy of C++ FIFE::NotSupported class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotSupported, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotSupported, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> NotSupported"""
        this = _fife.new_NotSupported(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.NotSupported_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.NotSupported_getDescription(self)

    __swig_destroy__ = _fife.delete_NotSupported
    __del__ = lambda self : None;
NotSupported_swigregister = _fife.NotSupported_swigregister
NotSupported_swigregister(NotSupported)

class NameClash(Exception):
    """Proxy of C++ FIFE::NameClash class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NameClash, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NameClash, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> NameClash"""
        this = _fife.new_NameClash(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.NameClash_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.NameClash_getDescription(self)

    __swig_destroy__ = _fife.delete_NameClash
    __del__ = lambda self : None;
NameClash_swigregister = _fife.NameClash_swigregister
NameClash_swigregister(NameClash)

class Duplicate(Exception):
    """Proxy of C++ FIFE::Duplicate class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Duplicate, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Duplicate, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> Duplicate"""
        this = _fife.new_Duplicate(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.Duplicate_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.Duplicate_getDescription(self)

    __swig_destroy__ = _fife.delete_Duplicate
    __del__ = lambda self : None;
Duplicate_swigregister = _fife.Duplicate_swigregister
Duplicate_swigregister(Duplicate)

class ScriptException(Exception):
    """Proxy of C++ FIFE::ScriptException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScriptException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScriptException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> ScriptException"""
        this = _fife.new_ScriptException(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.ScriptException_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.ScriptException_getDescription(self)

    __swig_destroy__ = _fife.delete_ScriptException
    __del__ = lambda self : None;
ScriptException_swigregister = _fife.ScriptException_swigregister
ScriptException_swigregister(ScriptException)

class EventException(Exception):
    """Proxy of C++ FIFE::EventException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EventException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> EventException"""
        this = _fife.new_EventException(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.EventException_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.EventException_getDescription(self)

    __swig_destroy__ = _fife.delete_EventException
    __del__ = lambda self : None;
EventException_swigregister = _fife.EventException_swigregister
EventException_swigregister(EventException)

class GuiException(Exception):
    """Proxy of C++ FIFE::GuiException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GuiException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GuiException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> GuiException"""
        this = _fife.new_GuiException(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.GuiException_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.GuiException_getDescription(self)

    __swig_destroy__ = _fife.delete_GuiException
    __del__ = lambda self : None;
GuiException_swigregister = _fife.GuiException_swigregister
GuiException_swigregister(GuiException)

class InconsistencyDetected(Exception):
    """Proxy of C++ FIFE::InconsistencyDetected class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InconsistencyDetected, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InconsistencyDetected, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> InconsistencyDetected"""
        this = _fife.new_InconsistencyDetected(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.InconsistencyDetected_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.InconsistencyDetected_getDescription(self)

    __swig_destroy__ = _fife.delete_InconsistencyDetected
    __del__ = lambda self : None;
InconsistencyDetected_swigregister = _fife.InconsistencyDetected_swigregister
InconsistencyDetected_swigregister(InconsistencyDetected)

class OutOfMemory(Exception):
    """Proxy of C++ FIFE::OutOfMemory class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutOfMemory, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutOfMemory, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string msg) -> OutOfMemory"""
        this = _fife.new_OutOfMemory(*args)
        try: self.this.append(this)
        except: self.this = this
    def getTypeStr(self):
        """getTypeStr(self) -> string"""
        return _fife.OutOfMemory_getTypeStr(self)

    def getDescription(self):
        """getDescription(self) -> string"""
        return _fife.OutOfMemory_getDescription(self)

    __swig_destroy__ = _fife.delete_OutOfMemory
    __del__ = lambda self : None;
OutOfMemory_swigregister = _fife.OutOfMemory_swigregister
OutOfMemory_swigregister(OutOfMemory)

class FifeClass(_object):
    """Proxy of C++ FIFE::FifeClass class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FifeClass, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FifeClass, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_FifeClass
    __del__ = lambda self : None;
    def getFifeId(self):
        """getFifeId(self) -> fifeid_t"""
        return _fife.FifeClass_getFifeId(self)

    def __init__(self): 
        """__init__(self) -> FifeClass"""
        this = _fife.new_FifeClass()
        try: self.this.append(this)
        except: self.this = this
FifeClass_swigregister = _fife.FifeClass_swigregister
FifeClass_swigregister(FifeClass)

class Point(_object):
    """Proxy of C++ FIFE::PointType2D<(int32_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Point, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Point, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.Point_x_set
    __swig_getmethods__["x"] = _fife.Point_x_get
    if _newclass:x = _swig_property(_fife.Point_x_get, _fife.Point_x_set)
    __swig_setmethods__["y"] = _fife.Point_y_set
    __swig_getmethods__["y"] = _fife.Point_y_get
    if _newclass:y = _swig_property(_fife.Point_y_get, _fife.Point_y_set)
    def __init__(self, *args): 
        """
        __init__(self, int _x = 0, int _y = 0) -> Point
        __init__(self, int _x = 0) -> Point
        __init__(self) -> Point
        __init__(self, Point rhs) -> Point
        """
        this = _fife.new_Point(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, Point p) -> Point"""
        return _fife.Point___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, Point p) -> Point"""
        return _fife.Point___sub__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, Point p) -> Point"""
        return _fife.Point___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, Point p) -> Point"""
        return _fife.Point___isub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, int i) -> Point"""
        return _fife.Point___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, int i) -> Point"""
        return _fife.Point___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Point p) -> bool"""
        return _fife.Point___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, Point p) -> bool"""
        return _fife.Point___ne__(self, *args)

    def length(self):
        """length(self) -> int"""
        return _fife.Point_length(self)

    def normalize(self):
        """normalize(self)"""
        return _fife.Point_normalize(self)

    def rotate(self, *args):
        """
        rotate(self, int angle)
        rotate(self, Point origin, int angle)
        """
        return _fife.Point_rotate(self, *args)

    def set(self, *args):
        """set(self, int _x, int _y)"""
        return _fife.Point_set(self, *args)

    def getX(self):
        """getX(self) -> int32_t"""
        return _fife.Point_getX(self)

    def getY(self):
        """getY(self) -> int32_t"""
        return _fife.Point_getY(self)

    def setX(self, *args):
        """setX(self, int32_t _x)"""
        return _fife.Point_setX(self, *args)

    def setY(self, *args):
        """setY(self, int32_t _y)"""
        return _fife.Point_setY(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _fife.Point___str__(self)

    __swig_destroy__ = _fife.delete_Point
    __del__ = lambda self : None;
Point_swigregister = _fife.Point_swigregister
Point_swigregister(Point)

class DoublePoint(_object):
    """Proxy of C++ FIFE::PointType2D<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoublePoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoublePoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.DoublePoint_x_set
    __swig_getmethods__["x"] = _fife.DoublePoint_x_get
    if _newclass:x = _swig_property(_fife.DoublePoint_x_get, _fife.DoublePoint_x_set)
    __swig_setmethods__["y"] = _fife.DoublePoint_y_set
    __swig_getmethods__["y"] = _fife.DoublePoint_y_get
    if _newclass:y = _swig_property(_fife.DoublePoint_y_get, _fife.DoublePoint_y_set)
    def __init__(self, *args): 
        """
        __init__(self, double _x = 0, double _y = 0) -> DoublePoint
        __init__(self, double _x = 0) -> DoublePoint
        __init__(self) -> DoublePoint
        __init__(self, DoublePoint rhs) -> DoublePoint
        """
        this = _fife.new_DoublePoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___sub__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___isub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, double i) -> DoublePoint"""
        return _fife.DoublePoint___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double i) -> DoublePoint"""
        return _fife.DoublePoint___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, DoublePoint p) -> bool"""
        return _fife.DoublePoint___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, DoublePoint p) -> bool"""
        return _fife.DoublePoint___ne__(self, *args)

    def length(self):
        """length(self) -> double"""
        return _fife.DoublePoint_length(self)

    def normalize(self):
        """normalize(self)"""
        return _fife.DoublePoint_normalize(self)

    def rotate(self, *args):
        """
        rotate(self, double angle)
        rotate(self, DoublePoint origin, double angle)
        """
        return _fife.DoublePoint_rotate(self, *args)

    def set(self, *args):
        """set(self, double _x, double _y)"""
        return _fife.DoublePoint_set(self, *args)

    def getX(self):
        """getX(self) -> double"""
        return _fife.DoublePoint_getX(self)

    def getY(self):
        """getY(self) -> double"""
        return _fife.DoublePoint_getY(self)

    def setX(self, *args):
        """setX(self, double _x)"""
        return _fife.DoublePoint_setX(self, *args)

    def setY(self, *args):
        """setY(self, double _y)"""
        return _fife.DoublePoint_setY(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _fife.DoublePoint___str__(self)

    __swig_destroy__ = _fife.delete_DoublePoint
    __del__ = lambda self : None;
DoublePoint_swigregister = _fife.DoublePoint_swigregister
DoublePoint_swigregister(DoublePoint)

class Point3D(_object):
    """Proxy of C++ FIFE::PointType3D<(int32_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Point3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Point3D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.Point3D_x_set
    __swig_getmethods__["x"] = _fife.Point3D_x_get
    if _newclass:x = _swig_property(_fife.Point3D_x_get, _fife.Point3D_x_set)
    __swig_setmethods__["y"] = _fife.Point3D_y_set
    __swig_getmethods__["y"] = _fife.Point3D_y_get
    if _newclass:y = _swig_property(_fife.Point3D_y_get, _fife.Point3D_y_set)
    __swig_setmethods__["z"] = _fife.Point3D_z_set
    __swig_getmethods__["z"] = _fife.Point3D_z_get
    if _newclass:z = _swig_property(_fife.Point3D_z_get, _fife.Point3D_z_set)
    def __init__(self, *args): 
        """
        __init__(self, int _x = 0, int _y = 0, int _z = 0) -> Point3D
        __init__(self, int _x = 0, int _y = 0) -> Point3D
        __init__(self, int _x = 0) -> Point3D
        __init__(self) -> Point3D
        __init__(self, Point3D rhs) -> Point3D
        """
        this = _fife.new_Point3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, Point3D p) -> Point3D"""
        return _fife.Point3D___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, Point3D p) -> Point3D"""
        return _fife.Point3D___sub__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, Point3D p) -> Point3D"""
        return _fife.Point3D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, Point3D p) -> Point3D"""
        return _fife.Point3D___isub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, int i) -> Point3D"""
        return _fife.Point3D___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, int i) -> Point3D"""
        return _fife.Point3D___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Point3D p) -> bool"""
        return _fife.Point3D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, Point3D p) -> bool"""
        return _fife.Point3D___ne__(self, *args)

    def length(self):
        """length(self) -> int"""
        return _fife.Point3D_length(self)

    def normalize(self):
        """normalize(self)"""
        return _fife.Point3D_normalize(self)

    def set(self, *args):
        """set(self, int _x, int _y, int _z)"""
        return _fife.Point3D_set(self, *args)

    __swig_destroy__ = _fife.delete_Point3D
    __del__ = lambda self : None;
Point3D_swigregister = _fife.Point3D_swigregister
Point3D_swigregister(Point3D)

class DoublePoint3D(_object):
    """Proxy of C++ FIFE::PointType3D<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoublePoint3D, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoublePoint3D, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.DoublePoint3D_x_set
    __swig_getmethods__["x"] = _fife.DoublePoint3D_x_get
    if _newclass:x = _swig_property(_fife.DoublePoint3D_x_get, _fife.DoublePoint3D_x_set)
    __swig_setmethods__["y"] = _fife.DoublePoint3D_y_set
    __swig_getmethods__["y"] = _fife.DoublePoint3D_y_get
    if _newclass:y = _swig_property(_fife.DoublePoint3D_y_get, _fife.DoublePoint3D_y_set)
    __swig_setmethods__["z"] = _fife.DoublePoint3D_z_set
    __swig_getmethods__["z"] = _fife.DoublePoint3D_z_get
    if _newclass:z = _swig_property(_fife.DoublePoint3D_z_get, _fife.DoublePoint3D_z_set)
    def __init__(self, *args): 
        """
        __init__(self, double _x = 0, double _y = 0, double _z = 0) -> DoublePoint3D
        __init__(self, double _x = 0, double _y = 0) -> DoublePoint3D
        __init__(self, double _x = 0) -> DoublePoint3D
        __init__(self) -> DoublePoint3D
        __init__(self, DoublePoint3D rhs) -> DoublePoint3D
        """
        this = _fife.new_DoublePoint3D(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___sub__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___isub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, double i) -> DoublePoint3D"""
        return _fife.DoublePoint3D___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double i) -> DoublePoint3D"""
        return _fife.DoublePoint3D___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, DoublePoint3D p) -> bool"""
        return _fife.DoublePoint3D___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, DoublePoint3D p) -> bool"""
        return _fife.DoublePoint3D___ne__(self, *args)

    def length(self):
        """length(self) -> double"""
        return _fife.DoublePoint3D_length(self)

    def normalize(self):
        """normalize(self)"""
        return _fife.DoublePoint3D_normalize(self)

    def set(self, *args):
        """set(self, double _x, double _y, double _z)"""
        return _fife.DoublePoint3D_set(self, *args)

    __swig_destroy__ = _fife.delete_DoublePoint3D
    __del__ = lambda self : None;
DoublePoint3D_swigregister = _fife.DoublePoint3D_swigregister
DoublePoint3D_swigregister(DoublePoint3D)

class Rect(_object):
    """Proxy of C++ FIFE::RectType<(int32_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.Rect_x_set
    __swig_getmethods__["x"] = _fife.Rect_x_get
    if _newclass:x = _swig_property(_fife.Rect_x_get, _fife.Rect_x_set)
    __swig_setmethods__["y"] = _fife.Rect_y_set
    __swig_getmethods__["y"] = _fife.Rect_y_get
    if _newclass:y = _swig_property(_fife.Rect_y_get, _fife.Rect_y_set)
    __swig_setmethods__["w"] = _fife.Rect_w_set
    __swig_getmethods__["w"] = _fife.Rect_w_get
    if _newclass:w = _swig_property(_fife.Rect_w_get, _fife.Rect_w_set)
    __swig_setmethods__["h"] = _fife.Rect_h_set
    __swig_getmethods__["h"] = _fife.Rect_h_get
    if _newclass:h = _swig_property(_fife.Rect_h_get, _fife.Rect_h_set)
    def __init__(self, x = 0, y = 0, width = 0, height = 0): 
        """
        __init__(self, int x = 0, int y = 0, int width = 0, int height = 0) -> Rect
        __init__(self, int x = 0, int y = 0, int width = 0) -> Rect
        __init__(self, int x = 0, int y = 0) -> Rect
        __init__(self, int x = 0) -> Rect
        __init__(self) -> Rect
        """
        this = _fife.new_Rect(x, y, width, height)
        try: self.this.append(this)
        except: self.this = this
    def right(self):
        """right(self) -> int"""
        return _fife.Rect_right(self)

    def bottom(self):
        """bottom(self) -> int"""
        return _fife.Rect_bottom(self)

    def __eq__(self, *args):
        """__eq__(self, Rect rect) -> bool"""
        return _fife.Rect___eq__(self, *args)

    def contains(self, *args):
        """contains(self, Point point) -> bool"""
        return _fife.Rect_contains(self, *args)

    def intersects(self, *args):
        """intersects(self, Rect rect) -> bool"""
        return _fife.Rect_intersects(self, *args)

    def intersectInplace(self, *args):
        """intersectInplace(self, Rect rect) -> bool"""
        return _fife.Rect_intersectInplace(self, *args)

    def getX(self):
        """getX(self) -> int32_t"""
        return _fife.Rect_getX(self)

    def getY(self):
        """getY(self) -> int32_t"""
        return _fife.Rect_getY(self)

    def setX(self, *args):
        """setX(self, int32_t _x)"""
        return _fife.Rect_setX(self, *args)

    def setY(self, *args):
        """setY(self, int32_t _y)"""
        return _fife.Rect_setY(self, *args)

    def getW(self):
        """getW(self) -> int32_t"""
        return _fife.Rect_getW(self)

    def getH(self):
        """getH(self) -> int32_t"""
        return _fife.Rect_getH(self)

    def setW(self, *args):
        """setW(self, int32_t _w)"""
        return _fife.Rect_setW(self, *args)

    def setH(self, *args):
        """setH(self, int32_t _h)"""
        return _fife.Rect_setH(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _fife.Rect___str__(self)

    __swig_destroy__ = _fife.delete_Rect
    __del__ = lambda self : None;
Rect_swigregister = _fife.Rect_swigregister
Rect_swigregister(Rect)

class FloatRect(_object):
    """Proxy of C++ FIFE::RectType<(float)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatRect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatRect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.FloatRect_x_set
    __swig_getmethods__["x"] = _fife.FloatRect_x_get
    if _newclass:x = _swig_property(_fife.FloatRect_x_get, _fife.FloatRect_x_set)
    __swig_setmethods__["y"] = _fife.FloatRect_y_set
    __swig_getmethods__["y"] = _fife.FloatRect_y_get
    if _newclass:y = _swig_property(_fife.FloatRect_y_get, _fife.FloatRect_y_set)
    __swig_setmethods__["w"] = _fife.FloatRect_w_set
    __swig_getmethods__["w"] = _fife.FloatRect_w_get
    if _newclass:w = _swig_property(_fife.FloatRect_w_get, _fife.FloatRect_w_set)
    __swig_setmethods__["h"] = _fife.FloatRect_h_set
    __swig_getmethods__["h"] = _fife.FloatRect_h_get
    if _newclass:h = _swig_property(_fife.FloatRect_h_get, _fife.FloatRect_h_set)
    def __init__(self, x = 0, y = 0, width = 0, height = 0): 
        """
        __init__(self, float x = 0, float y = 0, float width = 0, float height = 0) -> FloatRect
        __init__(self, float x = 0, float y = 0, float width = 0) -> FloatRect
        __init__(self, float x = 0, float y = 0) -> FloatRect
        __init__(self, float x = 0) -> FloatRect
        __init__(self) -> FloatRect
        """
        this = _fife.new_FloatRect(x, y, width, height)
        try: self.this.append(this)
        except: self.this = this
    def right(self):
        """right(self) -> float"""
        return _fife.FloatRect_right(self)

    def bottom(self):
        """bottom(self) -> float"""
        return _fife.FloatRect_bottom(self)

    def __eq__(self, *args):
        """__eq__(self, FloatRect rect) -> bool"""
        return _fife.FloatRect___eq__(self, *args)

    def contains(self, *args):
        """contains(self, FIFE::PointType2D<(float)> point) -> bool"""
        return _fife.FloatRect_contains(self, *args)

    def intersects(self, *args):
        """intersects(self, FloatRect rect) -> bool"""
        return _fife.FloatRect_intersects(self, *args)

    def intersectInplace(self, *args):
        """intersectInplace(self, FloatRect rect) -> bool"""
        return _fife.FloatRect_intersectInplace(self, *args)

    def getX(self):
        """getX(self) -> float"""
        return _fife.FloatRect_getX(self)

    def getY(self):
        """getY(self) -> float"""
        return _fife.FloatRect_getY(self)

    def setX(self, *args):
        """setX(self, float _x)"""
        return _fife.FloatRect_setX(self, *args)

    def setY(self, *args):
        """setY(self, float _y)"""
        return _fife.FloatRect_setY(self, *args)

    def getW(self):
        """getW(self) -> float"""
        return _fife.FloatRect_getW(self)

    def getH(self):
        """getH(self) -> float"""
        return _fife.FloatRect_getH(self)

    def setW(self, *args):
        """setW(self, float _w)"""
        return _fife.FloatRect_setW(self, *args)

    def setH(self, *args):
        """setH(self, float _h)"""
        return _fife.FloatRect_setH(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _fife.FloatRect___str__(self)

    __swig_destroy__ = _fife.delete_FloatRect
    __del__ = lambda self : None;
FloatRect_swigregister = _fife.FloatRect_swigregister
FloatRect_swigregister(FloatRect)

class DoubleRect(_object):
    """Proxy of C++ FIFE::RectType<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DoubleRect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DoubleRect, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.DoubleRect_x_set
    __swig_getmethods__["x"] = _fife.DoubleRect_x_get
    if _newclass:x = _swig_property(_fife.DoubleRect_x_get, _fife.DoubleRect_x_set)
    __swig_setmethods__["y"] = _fife.DoubleRect_y_set
    __swig_getmethods__["y"] = _fife.DoubleRect_y_get
    if _newclass:y = _swig_property(_fife.DoubleRect_y_get, _fife.DoubleRect_y_set)
    __swig_setmethods__["w"] = _fife.DoubleRect_w_set
    __swig_getmethods__["w"] = _fife.DoubleRect_w_get
    if _newclass:w = _swig_property(_fife.DoubleRect_w_get, _fife.DoubleRect_w_set)
    __swig_setmethods__["h"] = _fife.DoubleRect_h_set
    __swig_getmethods__["h"] = _fife.DoubleRect_h_get
    if _newclass:h = _swig_property(_fife.DoubleRect_h_get, _fife.DoubleRect_h_set)
    def __init__(self, x = 0, y = 0, width = 0, height = 0): 
        """
        __init__(self, double x = 0, double y = 0, double width = 0, double height = 0) -> DoubleRect
        __init__(self, double x = 0, double y = 0, double width = 0) -> DoubleRect
        __init__(self, double x = 0, double y = 0) -> DoubleRect
        __init__(self, double x = 0) -> DoubleRect
        __init__(self) -> DoubleRect
        """
        this = _fife.new_DoubleRect(x, y, width, height)
        try: self.this.append(this)
        except: self.this = this
    def right(self):
        """right(self) -> double"""
        return _fife.DoubleRect_right(self)

    def bottom(self):
        """bottom(self) -> double"""
        return _fife.DoubleRect_bottom(self)

    def __eq__(self, *args):
        """__eq__(self, DoubleRect rect) -> bool"""
        return _fife.DoubleRect___eq__(self, *args)

    def contains(self, *args):
        """contains(self, DoublePoint point) -> bool"""
        return _fife.DoubleRect_contains(self, *args)

    def intersects(self, *args):
        """intersects(self, DoubleRect rect) -> bool"""
        return _fife.DoubleRect_intersects(self, *args)

    def intersectInplace(self, *args):
        """intersectInplace(self, DoubleRect rect) -> bool"""
        return _fife.DoubleRect_intersectInplace(self, *args)

    def getX(self):
        """getX(self) -> double"""
        return _fife.DoubleRect_getX(self)

    def getY(self):
        """getY(self) -> double"""
        return _fife.DoubleRect_getY(self)

    def setX(self, *args):
        """setX(self, double _x)"""
        return _fife.DoubleRect_setX(self, *args)

    def setY(self, *args):
        """setY(self, double _y)"""
        return _fife.DoubleRect_setY(self, *args)

    def getW(self):
        """getW(self) -> double"""
        return _fife.DoubleRect_getW(self)

    def getH(self):
        """getH(self) -> double"""
        return _fife.DoubleRect_getH(self)

    def setW(self, *args):
        """setW(self, double _w)"""
        return _fife.DoubleRect_setW(self, *args)

    def setH(self, *args):
        """setH(self, double _h)"""
        return _fife.DoubleRect_setH(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _fife.DoubleRect___str__(self)

    __swig_destroy__ = _fife.delete_DoubleRect
    __del__ = lambda self : None;
DoubleRect_swigregister = _fife.DoubleRect_swigregister
DoubleRect_swigregister(DoubleRect)

class ScreenModeVector(_object):
    """Proxy of C++ std::vector<(FIFE::ScreenMode)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenModeVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenModeVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.ScreenModeVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.ScreenModeVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.ScreenModeVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.ScreenModeVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.ScreenModeVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> ScreenModeVector"""
        return _fife.ScreenModeVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, ScreenModeVector v)"""
        return _fife.ScreenModeVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.ScreenModeVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.ScreenModeVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> ScreenModeVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.ScreenModeVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, ScreenModeVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.ScreenModeVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.ScreenModeVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.ScreenModeVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.ScreenModeVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.ScreenModeVector_clear(self)

    def swap(self, *args):
        """swap(self, ScreenModeVector v)"""
        return _fife.ScreenModeVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.ScreenModeVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.ScreenModeVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.ScreenModeVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.ScreenModeVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.ScreenModeVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.ScreenModeVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.ScreenModeVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> ScreenModeVector
        __init__(self, ScreenModeVector arg0) -> ScreenModeVector
        __init__(self, size_type size) -> ScreenModeVector
        __init__(self, size_type size, value_type value) -> ScreenModeVector
        """
        this = _fife.new_ScreenModeVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.ScreenModeVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.ScreenModeVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.ScreenModeVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.ScreenModeVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.ScreenModeVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.ScreenModeVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.ScreenModeVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.ScreenModeVector_capacity(self)

    __swig_destroy__ = _fife.delete_ScreenModeVector
    __del__ = lambda self : None;
ScreenModeVector_swigregister = _fife.ScreenModeVector_swigregister
ScreenModeVector_swigregister(ScreenModeVector)

class Image(IResource):
    """Proxy of C++ FIFE::Image class"""
    __swig_setmethods__ = {}
    for _s in [IResource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Image, name, value)
    __swig_getmethods__ = {}
    for _s in [IResource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Image, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Image
    __del__ = lambda self : None;
    def getSurface(self):
        """getSurface(self) -> SDL_Surface"""
        return _fife.Image_getSurface(self)

    def getWidth(self):
        """getWidth(self) -> uint32_t"""
        return _fife.Image_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> uint32_t"""
        return _fife.Image_getHeight(self)

    def getArea(self):
        """getArea(self) -> Rect"""
        return _fife.Image_getArea(self)

    def setXShift(self, *args):
        """setXShift(self, int32_t xshift)"""
        return _fife.Image_setXShift(self, *args)

    def getXShift(self):
        """getXShift(self) -> int32_t"""
        return _fife.Image_getXShift(self)

    def setYShift(self, *args):
        """setYShift(self, int32_t yshift)"""
        return _fife.Image_setYShift(self, *args)

    def getYShift(self):
        """getYShift(self) -> int32_t"""
        return _fife.Image_getYShift(self)

    def getPixelRGBA(self, *args):
        """getPixelRGBA(self, int32_t x, int32_t y)"""
        return _fife.Image_getPixelRGBA(self, *args)

    def saveImage(self, *args):
        """saveImage(self, string filename)"""
        return _fife.Image_saveImage(self, *args)

    def useSharedImage(self, *args):
        """useSharedImage(self, ImagePtr shared, Rect region)"""
        return _fife.Image_useSharedImage(self, *args)

    def forceLoadInternal(self):
        """forceLoadInternal(self)"""
        return _fife.Image_forceLoadInternal(self)

    def isSharedImage(self):
        """isSharedImage(self) -> bool"""
        return _fife.Image_isSharedImage(self)

    def getSubImageRect(self):
        """getSubImageRect(self) -> Rect"""
        return _fife.Image_getSubImageRect(self)

    def copySubimage(self, *args):
        """copySubimage(self, uint32_t xoffset, uint32_t yoffset, ImagePtr img)"""
        return _fife.Image_copySubimage(self, *args)

Image_swigregister = _fife.Image_swigregister
Image_swigregister(Image)

class SharedImagePointer(_object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::Image)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedImagePointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedImagePointer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SharedImagePointer
        __init__(self, SharedImagePointer rhs) -> SharedImagePointer
        """
        this = _fife.new_SharedImagePointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SharedImagePointer
    __del__ = lambda self : None;
    def __ref__(self):
        """__ref__(self) -> Image"""
        return _fife.SharedImagePointer___ref__(self)

    def __deref__(self):
        """__deref__(self) -> Image"""
        return _fife.SharedImagePointer___deref__(self)

    def get(self):
        """get(self) -> Image"""
        return _fife.SharedImagePointer_get(self)

    def reset(self, ptr = None):
        """
        reset(self, Image ptr = None)
        reset(self)
        """
        return _fife.SharedImagePointer_reset(self, ptr)

    def useCount(self):
        """useCount(self) -> uint32_t"""
        return _fife.SharedImagePointer_useCount(self)

    def useCountPtr(self):
        """useCountPtr(self) -> uint32_t"""
        return _fife.SharedImagePointer_useCountPtr(self)

    def unique(self):
        """unique(self) -> bool"""
        return _fife.SharedImagePointer_unique(self)

    def __nonzero__(self):
        return _fife.SharedImagePointer___nonzero__(self)
    __bool__ = __nonzero__


    def getSurface(self):
        """getSurface(self) -> SDL_Surface"""
        return _fife.SharedImagePointer_getSurface(self)

    def getWidth(self):
        """getWidth(self) -> uint32_t"""
        return _fife.SharedImagePointer_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> uint32_t"""
        return _fife.SharedImagePointer_getHeight(self)

    def getArea(self):
        """getArea(self) -> Rect"""
        return _fife.SharedImagePointer_getArea(self)

    def setXShift(self, *args):
        """setXShift(self, int32_t xshift)"""
        return _fife.SharedImagePointer_setXShift(self, *args)

    def getXShift(self):
        """getXShift(self) -> int32_t"""
        return _fife.SharedImagePointer_getXShift(self)

    def setYShift(self, *args):
        """setYShift(self, int32_t yshift)"""
        return _fife.SharedImagePointer_setYShift(self, *args)

    def getYShift(self):
        """getYShift(self) -> int32_t"""
        return _fife.SharedImagePointer_getYShift(self)

    def getPixelRGBA(self, *args):
        """getPixelRGBA(self, int32_t x, int32_t y)"""
        return _fife.SharedImagePointer_getPixelRGBA(self, *args)

    def saveImage(self, *args):
        """saveImage(self, string filename)"""
        return _fife.SharedImagePointer_saveImage(self, *args)

    def useSharedImage(self, *args):
        """useSharedImage(self, ImagePtr shared, Rect region)"""
        return _fife.SharedImagePointer_useSharedImage(self, *args)

    def forceLoadInternal(self):
        """forceLoadInternal(self)"""
        return _fife.SharedImagePointer_forceLoadInternal(self)

    def isSharedImage(self):
        """isSharedImage(self) -> bool"""
        return _fife.SharedImagePointer_isSharedImage(self)

    def getSubImageRect(self):
        """getSubImageRect(self) -> Rect"""
        return _fife.SharedImagePointer_getSubImageRect(self)

    def copySubimage(self, *args):
        """copySubimage(self, uint32_t xoffset, uint32_t yoffset, ImagePtr img)"""
        return _fife.SharedImagePointer_copySubimage(self, *args)

    def getName(self):
        """getName(self) -> string"""
        return _fife.SharedImagePointer_getName(self)

    def getHandle(self):
        """getHandle(self) -> ResourceHandle"""
        return _fife.SharedImagePointer_getHandle(self)

    def getState(self):
        """getState(self) -> ResourceState"""
        return _fife.SharedImagePointer_getState(self)

    def setState(self, *args):
        """setState(self, ResourceState state)"""
        return _fife.SharedImagePointer_setState(self, *args)

    def getSize(self):
        """getSize(self) -> size_t"""
        return _fife.SharedImagePointer_getSize(self)

    def load(self):
        """load(self)"""
        return _fife.SharedImagePointer_load(self)

    def free(self):
        """free(self)"""
        return _fife.SharedImagePointer_free(self)

SharedImagePointer_swigregister = _fife.SharedImagePointer_swigregister
SharedImagePointer_swigregister(SharedImagePointer)

class ImageManager(IResourceManager):
    """Proxy of C++ FIFE::ImageManager class"""
    __swig_setmethods__ = {}
    for _s in [IResourceManager]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ImageManager, name, value)
    __swig_getmethods__ = {}
    for _s in [IResourceManager]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ImageManager, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ImageManager
    __del__ = lambda self : None;
    def getMemoryUsed(self):
        """getMemoryUsed(self) -> size_t"""
        return _fife.ImageManager_getMemoryUsed(self)

    def getTotalResourcesCreated(self):
        """getTotalResourcesCreated(self) -> size_t"""
        return _fife.ImageManager_getTotalResourcesCreated(self)

    def getTotalResourcesLoaded(self):
        """getTotalResourcesLoaded(self) -> size_t"""
        return _fife.ImageManager_getTotalResourcesLoaded(self)

    def getTotalResources(self):
        """getTotalResources(self) -> size_t"""
        return _fife.ImageManager_getTotalResources(self)

    def create(self, *args):
        """
        create(self, string name, IResourceLoader loader = None) -> ImagePtr
        create(self, string name) -> ImagePtr
        """
        return _fife.ImageManager_create(self, *args)

    def load(self, *args):
        """
        load(self, string name, IResourceLoader loader = None) -> ImagePtr
        load(self, string name) -> ImagePtr
        """
        return _fife.ImageManager_load(self, *args)

    def loadBlank(self, *args):
        """loadBlank(self, uint32_t width, uint32_t height) -> ImagePtr"""
        return _fife.ImageManager_loadBlank(self, *args)

    def add(self, *args):
        """add(self, Image res) -> ImagePtr"""
        return _fife.ImageManager_add(self, *args)

    def exists(self, *args):
        """
        exists(self, string name) -> bool
        exists(self, ResourceHandle handle) -> bool
        """
        return _fife.ImageManager_exists(self, *args)

    def reload(self, *args):
        """
        reload(self, string name)
        reload(self, ResourceHandle handle)
        """
        return _fife.ImageManager_reload(self, *args)

    def reloadAll(self):
        """reloadAll(self)"""
        return _fife.ImageManager_reloadAll(self)

    def loadUnreferenced(self):
        """loadUnreferenced(self)"""
        return _fife.ImageManager_loadUnreferenced(self)

    def free(self, *args):
        """
        free(self, string name)
        free(self, ResourceHandle handle)
        """
        return _fife.ImageManager_free(self, *args)

    def freeAll(self):
        """freeAll(self)"""
        return _fife.ImageManager_freeAll(self)

    def freeUnreferenced(self):
        """freeUnreferenced(self)"""
        return _fife.ImageManager_freeUnreferenced(self)

    def remove(self, *args):
        """
        remove(self, ImagePtr resource)
        remove(self, string name)
        remove(self, ResourceHandle handle)
        """
        return _fife.ImageManager_remove(self, *args)

    def removeAll(self):
        """removeAll(self)"""
        return _fife.ImageManager_removeAll(self)

    def removeUnreferenced(self):
        """removeUnreferenced(self)"""
        return _fife.ImageManager_removeUnreferenced(self)

    def get(self, *args):
        """
        get(self, string name) -> ImagePtr
        get(self, ResourceHandle handle) -> ImagePtr
        """
        return _fife.ImageManager_get(self, *args)

    def getResourceHandle(self, *args):
        """getResourceHandle(self, string name) -> ResourceHandle"""
        return _fife.ImageManager_getResourceHandle(self, *args)

    def invalidate(self, *args):
        """
        invalidate(self, string name)
        invalidate(self, ResourceHandle handle)
        """
        return _fife.ImageManager_invalidate(self, *args)

    def invalidateAll(self):
        """invalidateAll(self)"""
        return _fife.ImageManager_invalidateAll(self)

    def __init__(self): 
        """__init__(self) -> ImageManager"""
        this = _fife.new_ImageManager()
        try: self.this.append(this)
        except: self.this = this
ImageManager_swigregister = _fife.ImageManager_swigregister
ImageManager_swigregister(ImageManager)

class Animation(FifeClass):
    """Proxy of C++ FIFE::Animation class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Animation, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Animation, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Animation"""
        this = _fife.new_Animation()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Animation
    __del__ = lambda self : None;
    def addFrame(self, *args):
        """addFrame(self, ImagePtr image, uint32_t duration)"""
        return _fife.Animation_addFrame(self, *args)

    def getFrameIndex(self, *args):
        """getFrameIndex(self, uint32_t timestamp) -> int32_t"""
        return _fife.Animation_getFrameIndex(self, *args)

    def getFrame(self, *args):
        """getFrame(self, int32_t index) -> ImagePtr"""
        return _fife.Animation_getFrame(self, *args)

    def getFrameByTimestamp(self, *args):
        """getFrameByTimestamp(self, uint32_t timestamp) -> ImagePtr"""
        return _fife.Animation_getFrameByTimestamp(self, *args)

    def getFrameDuration(self, *args):
        """getFrameDuration(self, int32_t index) -> int32_t"""
        return _fife.Animation_getFrameDuration(self, *args)

    def getFrameCount(self):
        """getFrameCount(self) -> uint32_t"""
        return _fife.Animation_getFrameCount(self)

    def setActionFrame(self, *args):
        """setActionFrame(self, int32_t num)"""
        return _fife.Animation_setActionFrame(self, *args)

    def getActionFrame(self):
        """getActionFrame(self) -> int32_t"""
        return _fife.Animation_getActionFrame(self)

    def setDirection(self, *args):
        """setDirection(self, uint32_t direction)"""
        return _fife.Animation_setDirection(self, *args)

    def getDirection(self):
        """getDirection(self) -> uint32_t"""
        return _fife.Animation_getDirection(self)

    def getDuration(self):
        """getDuration(self) -> int32_t"""
        return _fife.Animation_getDuration(self)

    def createAnimation():
        """createAnimation() -> SharedAnimationPointer"""
        return _fife.Animation_createAnimation()

    if _newclass:createAnimation = staticmethod(createAnimation)
    __swig_getmethods__["createAnimation"] = lambda x: createAnimation
Animation_swigregister = _fife.Animation_swigregister
Animation_swigregister(Animation)

def Animation_createAnimation():
  """Animation_createAnimation() -> SharedAnimationPointer"""
  return _fife.Animation_createAnimation()

class SharedAnimationPointer(_object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::Animation)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedAnimationPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedAnimationPointer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SharedAnimationPointer
        __init__(self, SharedAnimationPointer rhs) -> SharedAnimationPointer
        """
        this = _fife.new_SharedAnimationPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SharedAnimationPointer
    __del__ = lambda self : None;
    def __ref__(self):
        """__ref__(self) -> Animation"""
        return _fife.SharedAnimationPointer___ref__(self)

    def __deref__(self):
        """__deref__(self) -> Animation"""
        return _fife.SharedAnimationPointer___deref__(self)

    def get(self):
        """get(self) -> Animation"""
        return _fife.SharedAnimationPointer_get(self)

    def reset(self, ptr = None):
        """
        reset(self, Animation ptr = None)
        reset(self)
        """
        return _fife.SharedAnimationPointer_reset(self, ptr)

    def useCount(self):
        """useCount(self) -> uint32_t"""
        return _fife.SharedAnimationPointer_useCount(self)

    def useCountPtr(self):
        """useCountPtr(self) -> uint32_t"""
        return _fife.SharedAnimationPointer_useCountPtr(self)

    def unique(self):
        """unique(self) -> bool"""
        return _fife.SharedAnimationPointer_unique(self)

    def __nonzero__(self):
        return _fife.SharedAnimationPointer___nonzero__(self)
    __bool__ = __nonzero__


    def addFrame(self, *args):
        """addFrame(self, ImagePtr image, uint32_t duration)"""
        return _fife.SharedAnimationPointer_addFrame(self, *args)

    def getFrameIndex(self, *args):
        """getFrameIndex(self, uint32_t timestamp) -> int32_t"""
        return _fife.SharedAnimationPointer_getFrameIndex(self, *args)

    def getFrame(self, *args):
        """getFrame(self, int32_t index) -> ImagePtr"""
        return _fife.SharedAnimationPointer_getFrame(self, *args)

    def getFrameByTimestamp(self, *args):
        """getFrameByTimestamp(self, uint32_t timestamp) -> ImagePtr"""
        return _fife.SharedAnimationPointer_getFrameByTimestamp(self, *args)

    def getFrameDuration(self, *args):
        """getFrameDuration(self, int32_t index) -> int32_t"""
        return _fife.SharedAnimationPointer_getFrameDuration(self, *args)

    def getFrameCount(self):
        """getFrameCount(self) -> uint32_t"""
        return _fife.SharedAnimationPointer_getFrameCount(self)

    def setActionFrame(self, *args):
        """setActionFrame(self, int32_t num)"""
        return _fife.SharedAnimationPointer_setActionFrame(self, *args)

    def getActionFrame(self):
        """getActionFrame(self) -> int32_t"""
        return _fife.SharedAnimationPointer_getActionFrame(self)

    def setDirection(self, *args):
        """setDirection(self, uint32_t direction)"""
        return _fife.SharedAnimationPointer_setDirection(self, *args)

    def getDirection(self):
        """getDirection(self) -> uint32_t"""
        return _fife.SharedAnimationPointer_getDirection(self)

    def getDuration(self):
        """getDuration(self) -> int32_t"""
        return _fife.SharedAnimationPointer_getDuration(self)

    def createAnimation(self):
        """createAnimation(self) -> SharedAnimationPointer"""
        return _fife.SharedAnimationPointer_createAnimation(self)

    def getFifeId(self):
        """getFifeId(self) -> fifeid_t"""
        return _fife.SharedAnimationPointer_getFifeId(self)

SharedAnimationPointer_swigregister = _fife.SharedAnimationPointer_swigregister
SharedAnimationPointer_swigregister(SharedAnimationPointer)

class RenderBackend(_object):
    """Proxy of C++ FIFE::RenderBackend class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderBackend, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RenderBackend, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RenderBackend
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.RenderBackend_getName(self)

    def captureScreen(self, *args):
        """
        captureScreen(self, string filename)
        captureScreen(self, string filename, uint32_t width, uint32_t height)
        """
        return _fife.RenderBackend_captureScreen(self, *args)

    def getCurrentScreenMode(self):
        """getCurrentScreenMode(self) -> ScreenMode"""
        return _fife.RenderBackend_getCurrentScreenMode(self)

    def getWidth(self):
        """getWidth(self) -> uint32_t"""
        return _fife.RenderBackend_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> uint32_t"""
        return _fife.RenderBackend_getHeight(self)

    def getScreenWidth(self):
        """getScreenWidth(self) -> uint32_t"""
        return _fife.RenderBackend_getScreenWidth(self)

    def getScreenHeight(self):
        """getScreenHeight(self) -> uint32_t"""
        return _fife.RenderBackend_getScreenHeight(self)

    def getArea(self):
        """getArea(self) -> Rect"""
        return _fife.RenderBackend_getArea(self)

    def getClipArea(self):
        """getClipArea(self) -> Rect"""
        return _fife.RenderBackend_getClipArea(self)

    def setAlphaOptimizerEnabled(self, *args):
        """setAlphaOptimizerEnabled(self, bool enabled)"""
        return _fife.RenderBackend_setAlphaOptimizerEnabled(self, *args)

    def isAlphaOptimizerEnabled(self):
        """isAlphaOptimizerEnabled(self) -> bool"""
        return _fife.RenderBackend_isAlphaOptimizerEnabled(self)

    def setImageCompressingEnabled(self, *args):
        """setImageCompressingEnabled(self, bool enabled)"""
        return _fife.RenderBackend_setImageCompressingEnabled(self, *args)

    def isImageCompressingEnabled(self):
        """isImageCompressingEnabled(self) -> bool"""
        return _fife.RenderBackend_isImageCompressingEnabled(self)

    def setFramebufferEnabled(self, *args):
        """setFramebufferEnabled(self, bool enabled)"""
        return _fife.RenderBackend_setFramebufferEnabled(self, *args)

    def isFramebufferEnabled(self):
        """isFramebufferEnabled(self) -> bool"""
        return _fife.RenderBackend_isFramebufferEnabled(self)

    def setNPOTEnabled(self, *args):
        """setNPOTEnabled(self, bool enabled)"""
        return _fife.RenderBackend_setNPOTEnabled(self, *args)

    def isNPOTEnabled(self):
        """isNPOTEnabled(self) -> bool"""
        return _fife.RenderBackend_isNPOTEnabled(self)

    def setColorKeyEnabled(self, *args):
        """setColorKeyEnabled(self, bool colorkeyenable)"""
        return _fife.RenderBackend_setColorKeyEnabled(self, *args)

    def isColorKeyEnabled(self):
        """isColorKeyEnabled(self) -> bool"""
        return _fife.RenderBackend_isColorKeyEnabled(self)

    def setColorKey(self, *args):
        """setColorKey(self, SDL_Color colorkey)"""
        return _fife.RenderBackend_setColorKey(self, *args)

    def getColorKey(self):
        """getColorKey(self) -> SDL_Color"""
        return _fife.RenderBackend_getColorKey(self)

    def getPixelFormat(self):
        """getPixelFormat(self) -> SDL_PixelFormat"""
        return _fife.RenderBackend_getPixelFormat(self)

    def setBackgroundColor(self, *args):
        """setBackgroundColor(self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.RenderBackend_setBackgroundColor(self, *args)

    def resetBackgroundColor(self):
        """resetBackgroundColor(self)"""
        return _fife.RenderBackend_resetBackgroundColor(self)

    def setFrameLimitEnabled(self, *args):
        """setFrameLimitEnabled(self, bool limited)"""
        return _fife.RenderBackend_setFrameLimitEnabled(self, *args)

    def isFrameLimitEnabled(self):
        """isFrameLimitEnabled(self) -> bool"""
        return _fife.RenderBackend_isFrameLimitEnabled(self)

    def setFrameLimit(self, *args):
        """setFrameLimit(self, uint16_t framelimit)"""
        return _fife.RenderBackend_setFrameLimit(self, *args)

    def getFrameLimit(self):
        """getFrameLimit(self) -> uint16_t"""
        return _fife.RenderBackend_getFrameLimit(self)

RenderBackend_swigregister = _fife.RenderBackend_swigregister
RenderBackend_swigregister(RenderBackend)

CURSOR_NONE = _fife.CURSOR_NONE
CURSOR_NATIVE = _fife.CURSOR_NATIVE
CURSOR_IMAGE = _fife.CURSOR_IMAGE
CURSOR_ANIMATION = _fife.CURSOR_ANIMATION
NC_ARROW = _fife.NC_ARROW
NC_IBEAM = _fife.NC_IBEAM
NC_WAIT = _fife.NC_WAIT
NC_CROSS = _fife.NC_CROSS
NC_UPARROW = _fife.NC_UPARROW
NC_RESIZENW = _fife.NC_RESIZENW
NC_RESIZESE = _fife.NC_RESIZESE
NC_RESIZESW = _fife.NC_RESIZESW
NC_RESIZENE = _fife.NC_RESIZENE
NC_RESIZEE = _fife.NC_RESIZEE
NC_RESIZEW = _fife.NC_RESIZEW
NC_RESIZEN = _fife.NC_RESIZEN
NC_RESIZES = _fife.NC_RESIZES
NC_RESIZEALL = _fife.NC_RESIZEALL
NC_NO = _fife.NC_NO
NC_HAND = _fife.NC_HAND
NC_APPSTARTING = _fife.NC_APPSTARTING
NC_HELP = _fife.NC_HELP
class Cursor(_object):
    """Proxy of C++ FIFE::Cursor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cursor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Cursor, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Cursor
    __del__ = lambda self : None;
    def draw(self):
        """draw(self)"""
        return _fife.Cursor_draw(self)

    def set(self, *args):
        """
        set(self, uint32_t cursor_id = 0)
        set(self)
        set(self, AnimationPtr anim)
        set(self, ImagePtr image)
        """
        return _fife.Cursor_set(self, *args)

    def setDrag(self, *args):
        """
        setDrag(self, AnimationPtr anim, int32_t drag_offset_x = 0, int32_t drag_offset_y = 0)
        setDrag(self, AnimationPtr anim, int32_t drag_offset_x = 0)
        setDrag(self, AnimationPtr anim)
        setDrag(self, ImagePtr image, int32_t drag_offset_x = 0, int32_t drag_offset_y = 0)
        setDrag(self, ImagePtr image, int32_t drag_offset_x = 0)
        setDrag(self, ImagePtr image)
        """
        return _fife.Cursor_setDrag(self, *args)

    def resetDrag(self):
        """resetDrag(self)"""
        return _fife.Cursor_resetDrag(self)

    def getType(self):
        """getType(self) -> MouseCursorType"""
        return _fife.Cursor_getType(self)

    def getId(self):
        """getId(self) -> uint32_t"""
        return _fife.Cursor_getId(self)

    def getImage(self):
        """getImage(self) -> ImagePtr"""
        return _fife.Cursor_getImage(self)

    def getAnimation(self):
        """getAnimation(self) -> AnimationPtr"""
        return _fife.Cursor_getAnimation(self)

    def getDragType(self):
        """getDragType(self) -> MouseCursorType"""
        return _fife.Cursor_getDragType(self)

    def getDragImage(self):
        """getDragImage(self) -> ImagePtr"""
        return _fife.Cursor_getDragImage(self)

    def getDragAnimation(self):
        """getDragAnimation(self) -> AnimationPtr"""
        return _fife.Cursor_getDragAnimation(self)

    def getX(self):
        """getX(self) -> uint32_t"""
        return _fife.Cursor_getX(self)

    def getY(self):
        """getY(self) -> uint32_t"""
        return _fife.Cursor_getY(self)

    def setPosition(self, *args):
        """setPosition(self, uint32_t x, uint32_t y)"""
        return _fife.Cursor_setPosition(self, *args)

    def getPosition(self):
        """getPosition(self)"""
        return _fife.Cursor_getPosition(self)

Cursor_swigregister = _fife.Cursor_swigregister
Cursor_swigregister(Cursor)

class ScreenMode(_object):
    """Proxy of C++ FIFE::ScreenMode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenMode, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ScreenMode
    __del__ = lambda self : None;
    def getWidth(self):
        """getWidth(self) -> uint16_t"""
        return _fife.ScreenMode_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> uint16_t"""
        return _fife.ScreenMode_getHeight(self)

    def getBPP(self):
        """getBPP(self) -> uint16_t"""
        return _fife.ScreenMode_getBPP(self)

    def getSDLFlags(self):
        """getSDLFlags(self) -> uint32_t"""
        return _fife.ScreenMode_getSDLFlags(self)

    def isFullScreen(self):
        """isFullScreen(self) -> bool"""
        return _fife.ScreenMode_isFullScreen(self)

    def isOpenGL(self):
        """isOpenGL(self) -> bool"""
        return _fife.ScreenMode_isOpenGL(self)

    def isSDL(self):
        """isSDL(self) -> bool"""
        return _fife.ScreenMode_isSDL(self)

    def isSDLHardwareSurface(self):
        """isSDLHardwareSurface(self) -> bool"""
        return _fife.ScreenMode_isSDLHardwareSurface(self)

    def __init__(self): 
        """__init__(self) -> ScreenMode"""
        this = _fife.new_ScreenMode()
        try: self.this.append(this)
        except: self.this = this
ScreenMode_swigregister = _fife.ScreenMode_swigregister
ScreenMode_swigregister(ScreenMode)
cvar = _fife.cvar
ScreenMode.HW_WINDOWED_OPENGL = _fife.cvar.ScreenMode_HW_WINDOWED_OPENGL
ScreenMode.HW_FULLSCREEN_OPENGL = _fife.cvar.ScreenMode_HW_FULLSCREEN_OPENGL
ScreenMode.WINDOWED_SDL = _fife.cvar.ScreenMode_WINDOWED_SDL
ScreenMode.WINDOWED_SDL_DB_HW = _fife.cvar.ScreenMode_WINDOWED_SDL_DB_HW
ScreenMode.FULLSCREEN_SDL = _fife.cvar.ScreenMode_FULLSCREEN_SDL
ScreenMode.FULLSCREEN_SDL_DB_HW = _fife.cvar.ScreenMode_FULLSCREEN_SDL_DB_HW

class DeviceCaps(_object):
    """Proxy of C++ FIFE::DeviceCaps class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DeviceCaps, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DeviceCaps, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> DeviceCaps"""
        this = _fife.new_DeviceCaps()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_DeviceCaps
    __del__ = lambda self : None;
    def fillDeviceCaps(self):
        """fillDeviceCaps(self)"""
        return _fife.DeviceCaps_fillDeviceCaps(self)

    def getSupportedScreenModes(self):
        """getSupportedScreenModes(self) -> ScreenModeVector"""
        return _fife.DeviceCaps_getSupportedScreenModes(self)

    def getNearestScreenMode(self, *args):
        """
        getNearestScreenMode(self, uint16_t width, uint16_t height, uint16_t bpp, string renderer, 
            bool fs) -> ScreenMode
        """
        return _fife.DeviceCaps_getNearestScreenMode(self, *args)

    def getDriverName(self):
        """getDriverName(self) -> string"""
        return _fife.DeviceCaps_getDriverName(self)

    def getAvailableDrivers(self):
        """getAvailableDrivers(self) -> StringVector"""
        return _fife.DeviceCaps_getAvailableDrivers(self)

    def isHwSurfaceAvail(self):
        """isHwSurfaceAvail(self) -> bool"""
        return _fife.DeviceCaps_isHwSurfaceAvail(self)

    def isWindowManagerAvail(self):
        """isWindowManagerAvail(self) -> bool"""
        return _fife.DeviceCaps_isWindowManagerAvail(self)

    def isHwBlitAccel(self):
        """isHwBlitAccel(self) -> bool"""
        return _fife.DeviceCaps_isHwBlitAccel(self)

    def isHwColorkeyBlitAccel(self):
        """isHwColorkeyBlitAccel(self) -> bool"""
        return _fife.DeviceCaps_isHwColorkeyBlitAccel(self)

    def isHwAlphaBlitAccel(self):
        """isHwAlphaBlitAccel(self) -> bool"""
        return _fife.DeviceCaps_isHwAlphaBlitAccel(self)

    def isSwToHwBlitAccel(self):
        """isSwToHwBlitAccel(self) -> bool"""
        return _fife.DeviceCaps_isSwToHwBlitAccel(self)

    def isSwToHwColorkeyBlitAccel(self):
        """isSwToHwColorkeyBlitAccel(self) -> bool"""
        return _fife.DeviceCaps_isSwToHwColorkeyBlitAccel(self)

    def isSwToHwAlphaBlitAccel(self):
        """isSwToHwAlphaBlitAccel(self) -> bool"""
        return _fife.DeviceCaps_isSwToHwAlphaBlitAccel(self)

    def isBlitFillAccel(self):
        """isBlitFillAccel(self) -> bool"""
        return _fife.DeviceCaps_isBlitFillAccel(self)

    def getVideoMemory(self):
        """getVideoMemory(self) -> uint32_t"""
        return _fife.DeviceCaps_getVideoMemory(self)

    def getDesktopWidth(self):
        """getDesktopWidth(self) -> int32_t"""
        return _fife.DeviceCaps_getDesktopWidth(self)

    def getDesktopHeight(self):
        """getDesktopHeight(self) -> int32_t"""
        return _fife.DeviceCaps_getDesktopHeight(self)

DeviceCaps_swigregister = _fife.DeviceCaps_swigregister
DeviceCaps_swigregister(DeviceCaps)

class AtlasBlock(_object):
    """Proxy of C++ FIFE::AtlasBlock class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtlasBlock, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtlasBlock, name)
    __repr__ = _swig_repr
    __swig_setmethods__["page"] = _fife.AtlasBlock_page_set
    __swig_getmethods__["page"] = _fife.AtlasBlock_page_get
    if _newclass:page = _swig_property(_fife.AtlasBlock_page_get, _fife.AtlasBlock_page_set)
    __swig_setmethods__["left"] = _fife.AtlasBlock_left_set
    __swig_getmethods__["left"] = _fife.AtlasBlock_left_get
    if _newclass:left = _swig_property(_fife.AtlasBlock_left_get, _fife.AtlasBlock_left_set)
    __swig_setmethods__["right"] = _fife.AtlasBlock_right_set
    __swig_getmethods__["right"] = _fife.AtlasBlock_right_get
    if _newclass:right = _swig_property(_fife.AtlasBlock_right_get, _fife.AtlasBlock_right_set)
    __swig_setmethods__["top"] = _fife.AtlasBlock_top_set
    __swig_getmethods__["top"] = _fife.AtlasBlock_top_get
    if _newclass:top = _swig_property(_fife.AtlasBlock_top_get, _fife.AtlasBlock_top_set)
    __swig_setmethods__["bottom"] = _fife.AtlasBlock_bottom_set
    __swig_getmethods__["bottom"] = _fife.AtlasBlock_bottom_get
    if _newclass:bottom = _swig_property(_fife.AtlasBlock_bottom_get, _fife.AtlasBlock_bottom_set)
    def __init__(self, *args): 
        """
        __init__(self, Rect rect, uint32_t page) -> AtlasBlock
        __init__(self) -> AtlasBlock
        """
        this = _fife.new_AtlasBlock(*args)
        try: self.this.append(this)
        except: self.this = this
    def setTrivial(self):
        """setTrivial(self)"""
        return _fife.AtlasBlock_setTrivial(self)

    def isTrivial(self):
        """isTrivial(self) -> bool"""
        return _fife.AtlasBlock_isTrivial(self)

    def getWidth(self):
        """getWidth(self) -> uint32_t"""
        return _fife.AtlasBlock_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> uint32_t"""
        return _fife.AtlasBlock_getHeight(self)

    def intersects(self, *args):
        """intersects(self, AtlasBlock rect) -> AtlasBlock"""
        return _fife.AtlasBlock_intersects(self, *args)

    def merge(self, *args):
        """merge(self, AtlasBlock rect)"""
        return _fife.AtlasBlock_merge(self, *args)

    __swig_destroy__ = _fife.delete_AtlasBlock
    __del__ = lambda self : None;
AtlasBlock_swigregister = _fife.AtlasBlock_swigregister
AtlasBlock_swigregister(AtlasBlock)

class AtlasBook(_object):
    """Proxy of C++ FIFE::AtlasBook class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtlasBook, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtlasBook, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, uint32_t pageWidth, uint32_t pageHeight, uint32_t pixelSize = 4) -> AtlasBook
        __init__(self, uint32_t pageWidth, uint32_t pageHeight) -> AtlasBook
        """
        this = _fife.new_AtlasBook(*args)
        try: self.this.append(this)
        except: self.this = this
    def getBlock(self, *args):
        """getBlock(self, uint32_t width, uint32_t height) -> AtlasBlock"""
        return _fife.AtlasBook_getBlock(self, *args)

    def shrink(self, *args):
        """shrink(self, bool pot)"""
        return _fife.AtlasBook_shrink(self, *args)

    def getPageWidth(self, *args):
        """getPageWidth(self, uint32_t index) -> uint32_t"""
        return _fife.AtlasBook_getPageWidth(self, *args)

    def getPageHeight(self, *args):
        """getPageHeight(self, uint32_t index) -> uint32_t"""
        return _fife.AtlasBook_getPageHeight(self, *args)

    __swig_destroy__ = _fife.delete_AtlasBook
    __del__ = lambda self : None;
AtlasBook_swigregister = _fife.AtlasBook_swigregister
AtlasBook_swigregister(AtlasBook)

class IAnimationLoader(_object):
    """Proxy of C++ FIFE::IAnimationLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IAnimationLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IAnimationLoader, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAnimationLoader
    __del__ = lambda self : None;
    def isLoadable(self, *args):
        """isLoadable(self, string filename) -> bool"""
        return _fife.IAnimationLoader_isLoadable(self, *args)

    def load(self, *args):
        """load(self, string filename) -> AnimationPtr"""
        return _fife.IAnimationLoader_load(self, *args)

    def __init__(self): 
        """__init__(self) -> IAnimationLoader"""
        if self.__class__ == IAnimationLoader:
            _self = None
        else:
            _self = self
        this = _fife.new_IAnimationLoader(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationLoader(self)
        return weakref_proxy(self)
IAnimationLoader_swigregister = _fife.IAnimationLoader_swigregister
IAnimationLoader_swigregister(IAnimationLoader)

class IAtlasLoader(_object):
    """Proxy of C++ FIFE::IAtlasLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IAtlasLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IAtlasLoader, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAtlasLoader
    __del__ = lambda self : None;
    def isLoadable(self, *args):
        """isLoadable(self, string filename) -> bool"""
        return _fife.IAtlasLoader_isLoadable(self, *args)

    def load(self, *args):
        """load(self, string filename) -> AtlasPtr"""
        return _fife.IAtlasLoader_load(self, *args)

    def __init__(self): 
        """__init__(self) -> IAtlasLoader"""
        if self.__class__ == IAtlasLoader:
            _self = None
        else:
            _self = self
        this = _fife.new_IAtlasLoader(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasLoader(self)
        return weakref_proxy(self)
IAtlasLoader_swigregister = _fife.IAtlasLoader_swigregister
IAtlasLoader_swigregister(IAtlasLoader)

class AtlasData(_object):
    """Proxy of C++ FIFE::AtlasData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtlasData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AtlasData, name)
    __repr__ = _swig_repr
    __swig_setmethods__["rect"] = _fife.AtlasData_rect_set
    __swig_getmethods__["rect"] = _fife.AtlasData_rect_get
    if _newclass:rect = _swig_property(_fife.AtlasData_rect_get, _fife.AtlasData_rect_set)
    __swig_setmethods__["image"] = _fife.AtlasData_image_set
    __swig_getmethods__["image"] = _fife.AtlasData_image_get
    if _newclass:image = _swig_property(_fife.AtlasData_image_get, _fife.AtlasData_image_set)
    def __init__(self): 
        """__init__(self) -> AtlasData"""
        this = _fife.new_AtlasData()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_AtlasData
    __del__ = lambda self : None;
AtlasData_swigregister = _fife.AtlasData_swigregister
AtlasData_swigregister(AtlasData)

class Atlas(_object):
    """Proxy of C++ FIFE::Atlas class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Atlas, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Atlas, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string name) -> Atlas"""
        this = _fife.new_Atlas(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Atlas
    __del__ = lambda self : None;
    def getImageCount(self):
        """getImageCount(self) -> size_t"""
        return _fife.Atlas_getImageCount(self)

    def getPackedImage(self):
        """getPackedImage(self) -> ImagePtr"""
        return _fife.Atlas_getPackedImage(self)

    def getImage(self, *args):
        """
        getImage(self, string id) -> ImagePtr
        getImage(self, uint32_t index) -> ImagePtr
        """
        return _fife.Atlas_getImage(self, *args)

    def addImage(self, *args):
        """addImage(self, string imagename, AtlasData data) -> bool"""
        return _fife.Atlas_addImage(self, *args)

    def setPackedImage(self, *args):
        """setPackedImage(self, ImagePtr image)"""
        return _fife.Atlas_setPackedImage(self, *args)

    def getName(self):
        """getName(self) -> string"""
        return _fife.Atlas_getName(self)

Atlas_swigregister = _fife.Atlas_swigregister
Atlas_swigregister(Atlas)

class AtlasLoader(IAtlasLoader):
    """Proxy of C++ FIFE::AtlasLoader class"""
    __swig_setmethods__ = {}
    for _s in [IAtlasLoader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtlasLoader, name, value)
    __swig_getmethods__ = {}
    for _s in [IAtlasLoader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AtlasLoader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Model model, VFS vfs, ImageManager imageManager) -> AtlasLoader"""
        this = _fife.new_AtlasLoader(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_AtlasLoader
    __del__ = lambda self : None;
    def isLoadable(self, *args):
        """isLoadable(self, string filename) -> bool"""
        return _fife.AtlasLoader_isLoadable(self, *args)

    def load(self, *args):
        """load(self, string filename) -> AtlasPtr"""
        return _fife.AtlasLoader_load(self, *args)

AtlasLoader_swigregister = _fife.AtlasLoader_swigregister
AtlasLoader_swigregister(AtlasLoader)


def createDefaultAtlasLoader(*args):
  """createDefaultAtlasLoader(Model model, VFS vfs, ImageManager imageManager) -> AtlasLoader"""
  return _fife.createDefaultAtlasLoader(*args)
class IMapLoader(_object):
    """Proxy of C++ FIFE::IMapLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMapLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMapLoader, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IMapLoader
    __del__ = lambda self : None;
    def setObjectLoader(self, *args):
        """setObjectLoader(self, ObjectLoaderPtr objectLoader)"""
        return _fife.IMapLoader_setObjectLoader(self, *args)

    def setAnimationLoader(self, *args):
        """setAnimationLoader(self, AnimationLoaderPtr animationLoader)"""
        return _fife.IMapLoader_setAnimationLoader(self, *args)

    def setAtlasLoader(self, *args):
        """setAtlasLoader(self, AtlasLoaderPtr atlasLoader)"""
        return _fife.IMapLoader_setAtlasLoader(self, *args)

    def isLoadable(self, *args):
        """isLoadable(self, string filename) -> bool"""
        return _fife.IMapLoader_isLoadable(self, *args)

    def load(self, *args):
        """load(self, string filename) -> Map"""
        return _fife.IMapLoader_load(self, *args)

    def __init__(self): 
        """__init__(self) -> IMapLoader"""
        if self.__class__ == IMapLoader:
            _self = None
        else:
            _self = self
        this = _fife.new_IMapLoader(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapLoader(self)
        return weakref_proxy(self)
IMapLoader_swigregister = _fife.IMapLoader_swigregister
IMapLoader_swigregister(IMapLoader)

class IObjectLoader(_object):
    """Proxy of C++ FIFE::IObjectLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IObjectLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IObjectLoader, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IObjectLoader
    __del__ = lambda self : None;
    def setAnimationLoader(self, *args):
        """setAnimationLoader(self, AnimationLoaderPtr animationLoader)"""
        return _fife.IObjectLoader_setAnimationLoader(self, *args)

    def isLoadable(self, *args):
        """isLoadable(self, string filename) -> bool"""
        return _fife.IObjectLoader_isLoadable(self, *args)

    def load(self, *args):
        """load(self, string filename)"""
        return _fife.IObjectLoader_load(self, *args)

    def __init__(self): 
        """__init__(self) -> IObjectLoader"""
        if self.__class__ == IObjectLoader:
            _self = None
        else:
            _self = self
        this = _fife.new_IObjectLoader(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectLoader(self)
        return weakref_proxy(self)
IObjectLoader_swigregister = _fife.IObjectLoader_swigregister
IObjectLoader_swigregister(IObjectLoader)

class ObjectLoader(IObjectLoader):
    """Proxy of C++ FIFE::ObjectLoader class"""
    __swig_setmethods__ = {}
    for _s in [IObjectLoader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjectLoader, name, value)
    __swig_getmethods__ = {}
    for _s in [IObjectLoader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ObjectLoader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Model model, VFS vfs, ImageManager imageManager, AnimationLoaderPtr animationLoader = FIFE::AnimationLoaderPtr()) -> ObjectLoader
        __init__(self, Model model, VFS vfs, ImageManager imageManager) -> ObjectLoader
        """
        this = _fife.new_ObjectLoader(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_ObjectLoader
    __del__ = lambda self : None;
    def setAnimationLoader(self, *args):
        """setAnimationLoader(self, AnimationLoaderPtr animationLoader)"""
        return _fife.ObjectLoader_setAnimationLoader(self, *args)

    def isLoadable(self, *args):
        """isLoadable(self, string filename) -> bool"""
        return _fife.ObjectLoader_isLoadable(self, *args)

    def load(self, *args):
        """load(self, string filename)"""
        return _fife.ObjectLoader_load(self, *args)

ObjectLoader_swigregister = _fife.ObjectLoader_swigregister
ObjectLoader_swigregister(ObjectLoader)

class MapLoader(IMapLoader):
    """Proxy of C++ FIFE::MapLoader class"""
    __swig_setmethods__ = {}
    for _s in [IMapLoader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapLoader, name, value)
    __swig_getmethods__ = {}
    for _s in [IMapLoader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapLoader, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Model model, VFS vfs, ImageManager imageManager, RenderBackend renderBackend) -> MapLoader"""
        this = _fife.new_MapLoader(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_MapLoader
    __del__ = lambda self : None;
    def setObjectLoader(self, *args):
        """setObjectLoader(self, ObjectLoaderPtr objectLoader)"""
        return _fife.MapLoader_setObjectLoader(self, *args)

    def setAnimationLoader(self, *args):
        """setAnimationLoader(self, AnimationLoaderPtr animationLoader)"""
        return _fife.MapLoader_setAnimationLoader(self, *args)

    def setAtlasLoader(self, *args):
        """setAtlasLoader(self, AtlasLoaderPtr atlasLoader)"""
        return _fife.MapLoader_setAtlasLoader(self, *args)

    def isLoadable(self, *args):
        """isLoadable(self, string filename) -> bool"""
        return _fife.MapLoader_isLoadable(self, *args)

    def load(self, *args):
        """load(self, string filename) -> Map"""
        return _fife.MapLoader_load(self, *args)

    def loadImportFile(self, *args):
        """
        loadImportFile(self, string file, string directory = "")
        loadImportFile(self, string file)
        """
        return _fife.MapLoader_loadImportFile(self, *args)

    def loadImportDirectory(self, *args):
        """loadImportDirectory(self, string directory)"""
        return _fife.MapLoader_loadImportDirectory(self, *args)

    def addPercentDoneListener(self, *args):
        """addPercentDoneListener(self, PercentDoneListener listener)"""
        return _fife.MapLoader_addPercentDoneListener(self, *args)

    def getLoaderName(self):
        """getLoaderName(self) -> string"""
        return _fife.MapLoader_getLoaderName(self)

MapLoader_swigregister = _fife.MapLoader_swigregister
MapLoader_swigregister(MapLoader)


def createDefaultMapLoader(*args):
  """createDefaultMapLoader(Model model, VFS vfs, ImageManager imageManager, RenderBackend renderBackend) -> MapLoader"""
  return _fife.createDefaultMapLoader(*args)
class PercentDoneListener(_object):
    """Proxy of C++ FIFE::PercentDoneListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PercentDoneListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PercentDoneListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_PercentDoneListener
    __del__ = lambda self : None;
    def OnEvent(self, *args):
        """OnEvent(self, unsigned int percentDone)"""
        return _fife.PercentDoneListener_OnEvent(self, *args)

    def __init__(self): 
        """__init__(self) -> PercentDoneListener"""
        if self.__class__ == PercentDoneListener:
            _self = None
        else:
            _self = self
        this = _fife.new_PercentDoneListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_PercentDoneListener(self)
        return weakref_proxy(self)
PercentDoneListener_swigregister = _fife.PercentDoneListener_swigregister
PercentDoneListener_swigregister(PercentDoneListener)

class IVisual(_object):
    """Proxy of C++ FIFE::IVisual class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IVisual, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IVisual, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IVisual
    __del__ = lambda self : None;
IVisual_swigregister = _fife.IVisual_swigregister
IVisual_swigregister(IVisual)

class Action(FifeClass):
    """Proxy of C++ FIFE::Action class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Action, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Action, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string identifier) -> Action"""
        this = _fife.new_Action(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Action
    __del__ = lambda self : None;
    def getId(self):
        """getId(self) -> string"""
        return _fife.Action_getId(self)

    def adoptVisual(self, *args):
        """adoptVisual(self, IVisual visual)"""
        return _fife.Action_adoptVisual(self, *args)

    def setDuration(self, *args):
        """setDuration(self, uint32_t duration)"""
        return _fife.Action_setDuration(self, *args)

    def getDuration(self):
        """getDuration(self) -> uint32_t"""
        return _fife.Action_getDuration(self)

    def get2dGfxVisual(self):
        """get2dGfxVisual(self) -> ActionVisual"""
        return _fife.Action_get2dGfxVisual(self)

Action_swigregister = _fife.Action_swigregister
Action_swigregister(Action)

class ModelCoordinate(_object):
    """Proxy of C++ FIFE::PointType3D<(int32_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModelCoordinate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ModelCoordinate, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.ModelCoordinate_x_set
    __swig_getmethods__["x"] = _fife.ModelCoordinate_x_get
    if _newclass:x = _swig_property(_fife.ModelCoordinate_x_get, _fife.ModelCoordinate_x_set)
    __swig_setmethods__["y"] = _fife.ModelCoordinate_y_set
    __swig_getmethods__["y"] = _fife.ModelCoordinate_y_get
    if _newclass:y = _swig_property(_fife.ModelCoordinate_y_get, _fife.ModelCoordinate_y_set)
    __swig_setmethods__["z"] = _fife.ModelCoordinate_z_set
    __swig_getmethods__["z"] = _fife.ModelCoordinate_z_get
    if _newclass:z = _swig_property(_fife.ModelCoordinate_z_get, _fife.ModelCoordinate_z_set)
    def __init__(self, *args): 
        """
        __init__(self, int _x = 0, int _y = 0, int _z = 0) -> ModelCoordinate
        __init__(self, int _x = 0, int _y = 0) -> ModelCoordinate
        __init__(self, int _x = 0) -> ModelCoordinate
        __init__(self) -> ModelCoordinate
        __init__(self, Point3D rhs) -> ModelCoordinate
        """
        this = _fife.new_ModelCoordinate(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___sub__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___isub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, int i) -> Point3D"""
        return _fife.ModelCoordinate___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, int i) -> Point3D"""
        return _fife.ModelCoordinate___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Point3D p) -> bool"""
        return _fife.ModelCoordinate___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, Point3D p) -> bool"""
        return _fife.ModelCoordinate___ne__(self, *args)

    def length(self):
        """length(self) -> int"""
        return _fife.ModelCoordinate_length(self)

    def normalize(self):
        """normalize(self)"""
        return _fife.ModelCoordinate_normalize(self)

    def set(self, *args):
        """set(self, int _x, int _y, int _z)"""
        return _fife.ModelCoordinate_set(self, *args)

    __swig_destroy__ = _fife.delete_ModelCoordinate
    __del__ = lambda self : None;
ModelCoordinate_swigregister = _fife.ModelCoordinate_swigregister
ModelCoordinate_swigregister(ModelCoordinate)

class ExactModelCoordinate(_object):
    """Proxy of C++ FIFE::PointType3D<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExactModelCoordinate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExactModelCoordinate, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.ExactModelCoordinate_x_set
    __swig_getmethods__["x"] = _fife.ExactModelCoordinate_x_get
    if _newclass:x = _swig_property(_fife.ExactModelCoordinate_x_get, _fife.ExactModelCoordinate_x_set)
    __swig_setmethods__["y"] = _fife.ExactModelCoordinate_y_set
    __swig_getmethods__["y"] = _fife.ExactModelCoordinate_y_get
    if _newclass:y = _swig_property(_fife.ExactModelCoordinate_y_get, _fife.ExactModelCoordinate_y_set)
    __swig_setmethods__["z"] = _fife.ExactModelCoordinate_z_set
    __swig_getmethods__["z"] = _fife.ExactModelCoordinate_z_get
    if _newclass:z = _swig_property(_fife.ExactModelCoordinate_z_get, _fife.ExactModelCoordinate_z_set)
    def __init__(self, *args): 
        """
        __init__(self, double _x = 0, double _y = 0, double _z = 0) -> ExactModelCoordinate
        __init__(self, double _x = 0, double _y = 0) -> ExactModelCoordinate
        __init__(self, double _x = 0) -> ExactModelCoordinate
        __init__(self) -> ExactModelCoordinate
        __init__(self, DoublePoint3D rhs) -> ExactModelCoordinate
        """
        this = _fife.new_ExactModelCoordinate(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___sub__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___isub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, double i) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, double i) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, DoublePoint3D p) -> bool"""
        return _fife.ExactModelCoordinate___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, DoublePoint3D p) -> bool"""
        return _fife.ExactModelCoordinate___ne__(self, *args)

    def length(self):
        """length(self) -> double"""
        return _fife.ExactModelCoordinate_length(self)

    def normalize(self):
        """normalize(self)"""
        return _fife.ExactModelCoordinate_normalize(self)

    def set(self, *args):
        """set(self, double _x, double _y, double _z)"""
        return _fife.ExactModelCoordinate_set(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _fife.ExactModelCoordinate___str__(self)

    __swig_destroy__ = _fife.delete_ExactModelCoordinate
    __del__ = lambda self : None;
ExactModelCoordinate_swigregister = _fife.ExactModelCoordinate_swigregister
ExactModelCoordinate_swigregister(ExactModelCoordinate)

class ModelCoordinateVector(_object):
    """Proxy of C++ std::vector<(FIFE::ModelCoordinate)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ModelCoordinateVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ModelCoordinateVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.ModelCoordinateVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.ModelCoordinateVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.ModelCoordinateVector___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(FIFE::PointType3D<(int)>)>::size_type"""
        return _fife.ModelCoordinateVector___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(FIFE::PointType3D<(int)>)>::value_type"""
        return _fife.ModelCoordinateVector_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(self, std::vector<(FIFE::PointType3D<(int)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(int)>)>::difference_type j) -> ModelCoordinateVector
        """
        return _fife.ModelCoordinateVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(FIFE::PointType3D<(int)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(int)>)>::difference_type j, 
            ModelCoordinateVector v)
        """
        return _fife.ModelCoordinateVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(self, std::vector<(FIFE::PointType3D<(int)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(int)>)>::difference_type j)
        """
        return _fife.ModelCoordinateVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(FIFE::PointType3D<(int)>)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.ModelCoordinateVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> ModelCoordinateVector
        __getitem__(self, std::vector<(FIFE::PointType3D<(int)>)>::difference_type i) -> std::vector<(FIFE::PointType3D<(int)>)>::value_type
        """
        return _fife.ModelCoordinateVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, ModelCoordinateVector v)
        __setitem__(self, std::vector<(FIFE::PointType3D<(int)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(int)>)>::value_type x)
        """
        return _fife.ModelCoordinateVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(FIFE::PointType3D<(int)>)>::value_type x)"""
        return _fife.ModelCoordinateVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.ModelCoordinateVector_empty(self)

    def size(self):
        """size(self) -> std::vector<(FIFE::PointType3D<(int)>)>::size_type"""
        return _fife.ModelCoordinateVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.ModelCoordinateVector_clear(self)

    def swap(self, *args):
        """swap(self, ModelCoordinateVector v)"""
        return _fife.ModelCoordinateVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(FIFE::PointType3D<(int)>)>::allocator_type"""
        return _fife.ModelCoordinateVector_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(FIFE::PointType3D<(int)>)>::const_iterator"""
        return _fife.ModelCoordinateVector_begin(self)

    def end(self):
        """end(self) -> std::vector<(FIFE::PointType3D<(int)>)>::const_iterator"""
        return _fife.ModelCoordinateVector_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(FIFE::PointType3D<(int)>)>::const_reverse_iterator"""
        return _fife.ModelCoordinateVector_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(FIFE::PointType3D<(int)>)>::const_reverse_iterator"""
        return _fife.ModelCoordinateVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.ModelCoordinateVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(FIFE::PointType3D<(int)>)>::iterator pos) -> std::vector<(FIFE::PointType3D<(int)>)>::iterator
        erase(self, std::vector<(FIFE::PointType3D<(int)>)>::iterator first, 
            std::vector<(FIFE::PointType3D<(int)>)>::iterator last) -> std::vector<(FIFE::PointType3D<(int)>)>::iterator
        """
        return _fife.ModelCoordinateVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> ModelCoordinateVector
        __init__(self, ModelCoordinateVector arg0) -> ModelCoordinateVector
        __init__(self, std::vector<(FIFE::PointType3D<(int)>)>::size_type size) -> ModelCoordinateVector
        __init__(self, std::vector<(FIFE::PointType3D<(int)>)>::size_type size, 
            std::vector<(FIFE::PointType3D<(int)>)>::value_type value) -> ModelCoordinateVector
        """
        this = _fife.new_ModelCoordinateVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(FIFE::PointType3D<(int)>)>::value_type x)"""
        return _fife.ModelCoordinateVector_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(FIFE::PointType3D<(int)>)>::value_type"""
        return _fife.ModelCoordinateVector_front(self)

    def back(self):
        """back(self) -> std::vector<(FIFE::PointType3D<(int)>)>::value_type"""
        return _fife.ModelCoordinateVector_back(self)

    def assign(self, *args):
        """
        assign(self, std::vector<(FIFE::PointType3D<(int)>)>::size_type n, 
            std::vector<(FIFE::PointType3D<(int)>)>::value_type x)
        """
        return _fife.ModelCoordinateVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(FIFE::PointType3D<(int)>)>::size_type new_size)
        resize(self, std::vector<(FIFE::PointType3D<(int)>)>::size_type new_size, 
            std::vector<(FIFE::PointType3D<(int)>)>::value_type x)
        """
        return _fife.ModelCoordinateVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(FIFE::PointType3D<(int)>)>::iterator pos, 
            std::vector<(FIFE::PointType3D<(int)>)>::value_type x) -> std::vector<(FIFE::PointType3D<(int)>)>::iterator
        insert(self, std::vector<(FIFE::PointType3D<(int)>)>::iterator pos, 
            std::vector<(FIFE::PointType3D<(int)>)>::size_type n, 
            std::vector<(FIFE::PointType3D<(int)>)>::value_type x)
        """
        return _fife.ModelCoordinateVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(FIFE::PointType3D<(int)>)>::size_type n)"""
        return _fife.ModelCoordinateVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(FIFE::PointType3D<(int)>)>::size_type"""
        return _fife.ModelCoordinateVector_capacity(self)

    __swig_destroy__ = _fife.delete_ModelCoordinateVector
    __del__ = lambda self : None;
ModelCoordinateVector_swigregister = _fife.ModelCoordinateVector_swigregister
ModelCoordinateVector_swigregister(ModelCoordinateVector)

class ExactModelCoordinateVector(_object):
    """Proxy of C++ std::vector<(FIFE::ExactModelCoordinate)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExactModelCoordinateVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ExactModelCoordinateVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.ExactModelCoordinateVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.ExactModelCoordinateVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.ExactModelCoordinateVector___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(FIFE::PointType3D<(double)>)>::size_type"""
        return _fife.ExactModelCoordinateVector___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(FIFE::PointType3D<(double)>)>::value_type"""
        return _fife.ExactModelCoordinateVector_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(self, std::vector<(FIFE::PointType3D<(double)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(double)>)>::difference_type j) -> ExactModelCoordinateVector
        """
        return _fife.ExactModelCoordinateVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(FIFE::PointType3D<(double)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(double)>)>::difference_type j, 
            ExactModelCoordinateVector v)
        """
        return _fife.ExactModelCoordinateVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(self, std::vector<(FIFE::PointType3D<(double)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(double)>)>::difference_type j)
        """
        return _fife.ExactModelCoordinateVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(FIFE::PointType3D<(double)>)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.ExactModelCoordinateVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> ExactModelCoordinateVector
        __getitem__(self, std::vector<(FIFE::PointType3D<(double)>)>::difference_type i) -> std::vector<(FIFE::PointType3D<(double)>)>::value_type
        """
        return _fife.ExactModelCoordinateVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, ExactModelCoordinateVector v)
        __setitem__(self, std::vector<(FIFE::PointType3D<(double)>)>::difference_type i, 
            std::vector<(FIFE::PointType3D<(double)>)>::value_type x)
        """
        return _fife.ExactModelCoordinateVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(FIFE::PointType3D<(double)>)>::value_type x)"""
        return _fife.ExactModelCoordinateVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.ExactModelCoordinateVector_empty(self)

    def size(self):
        """size(self) -> std::vector<(FIFE::PointType3D<(double)>)>::size_type"""
        return _fife.ExactModelCoordinateVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.ExactModelCoordinateVector_clear(self)

    def swap(self, *args):
        """swap(self, ExactModelCoordinateVector v)"""
        return _fife.ExactModelCoordinateVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(FIFE::PointType3D<(double)>)>::allocator_type"""
        return _fife.ExactModelCoordinateVector_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(FIFE::PointType3D<(double)>)>::const_iterator"""
        return _fife.ExactModelCoordinateVector_begin(self)

    def end(self):
        """end(self) -> std::vector<(FIFE::PointType3D<(double)>)>::const_iterator"""
        return _fife.ExactModelCoordinateVector_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(FIFE::PointType3D<(double)>)>::const_reverse_iterator"""
        return _fife.ExactModelCoordinateVector_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(FIFE::PointType3D<(double)>)>::const_reverse_iterator"""
        return _fife.ExactModelCoordinateVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.ExactModelCoordinateVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(FIFE::PointType3D<(double)>)>::iterator pos) -> std::vector<(FIFE::PointType3D<(double)>)>::iterator
        erase(self, std::vector<(FIFE::PointType3D<(double)>)>::iterator first, 
            std::vector<(FIFE::PointType3D<(double)>)>::iterator last) -> std::vector<(FIFE::PointType3D<(double)>)>::iterator
        """
        return _fife.ExactModelCoordinateVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> ExactModelCoordinateVector
        __init__(self, ExactModelCoordinateVector arg0) -> ExactModelCoordinateVector
        __init__(self, std::vector<(FIFE::PointType3D<(double)>)>::size_type size) -> ExactModelCoordinateVector
        __init__(self, std::vector<(FIFE::PointType3D<(double)>)>::size_type size, 
            std::vector<(FIFE::PointType3D<(double)>)>::value_type value) -> ExactModelCoordinateVector
        """
        this = _fife.new_ExactModelCoordinateVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(FIFE::PointType3D<(double)>)>::value_type x)"""
        return _fife.ExactModelCoordinateVector_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(FIFE::PointType3D<(double)>)>::value_type"""
        return _fife.ExactModelCoordinateVector_front(self)

    def back(self):
        """back(self) -> std::vector<(FIFE::PointType3D<(double)>)>::value_type"""
        return _fife.ExactModelCoordinateVector_back(self)

    def assign(self, *args):
        """
        assign(self, std::vector<(FIFE::PointType3D<(double)>)>::size_type n, 
            std::vector<(FIFE::PointType3D<(double)>)>::value_type x)
        """
        return _fife.ExactModelCoordinateVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(FIFE::PointType3D<(double)>)>::size_type new_size)
        resize(self, std::vector<(FIFE::PointType3D<(double)>)>::size_type new_size, 
            std::vector<(FIFE::PointType3D<(double)>)>::value_type x)
        """
        return _fife.ExactModelCoordinateVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(FIFE::PointType3D<(double)>)>::iterator pos, 
            std::vector<(FIFE::PointType3D<(double)>)>::value_type x) -> std::vector<(FIFE::PointType3D<(double)>)>::iterator
        insert(self, std::vector<(FIFE::PointType3D<(double)>)>::iterator pos, 
            std::vector<(FIFE::PointType3D<(double)>)>::size_type n, 
            std::vector<(FIFE::PointType3D<(double)>)>::value_type x)
        """
        return _fife.ExactModelCoordinateVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(FIFE::PointType3D<(double)>)>::size_type n)"""
        return _fife.ExactModelCoordinateVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(FIFE::PointType3D<(double)>)>::size_type"""
        return _fife.ExactModelCoordinateVector_capacity(self)

    __swig_destroy__ = _fife.delete_ExactModelCoordinateVector
    __del__ = lambda self : None;
ExactModelCoordinateVector_swigregister = _fife.ExactModelCoordinateVector_swigregister
ExactModelCoordinateVector_swigregister(ExactModelCoordinateVector)

class CellGrid(_object):
    """Proxy of C++ FIFE::CellGrid class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CellGrid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CellGrid, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellGrid
    __del__ = lambda self : None;
    def getAccessibleCoordinates(self, *args):
        """getAccessibleCoordinates(self, ModelCoordinate curpos, ModelCoordinateVector coordinates)"""
        return _fife.CellGrid_getAccessibleCoordinates(self, *args)

    def getType(self):
        """getType(self) -> string"""
        return _fife.CellGrid_getType(self)

    def getName(self):
        """getName(self) -> string"""
        return _fife.CellGrid_getName(self)

    def isAccessible(self, *args):
        """isAccessible(self, ModelCoordinate curpos, ModelCoordinate target) -> bool"""
        return _fife.CellGrid_isAccessible(self, *args)

    def getAdjacentCost(self, *args):
        """getAdjacentCost(self, ModelCoordinate curpos, ModelCoordinate target) -> double"""
        return _fife.CellGrid_getAdjacentCost(self, *args)

    def getHeuristicCost(self, *args):
        """getHeuristicCost(self, ModelCoordinate curpos, ModelCoordinate target) -> double"""
        return _fife.CellGrid_getHeuristicCost(self, *args)

    def getCellSideCount(self):
        """getCellSideCount(self) -> uint32_t"""
        return _fife.CellGrid_getCellSideCount(self)

    def toMapCoordinates(self, *args):
        """
        toMapCoordinates(self, ModelCoordinate layer_coords) -> ExactModelCoordinate
        toMapCoordinates(self, ExactModelCoordinate layer_coords) -> ExactModelCoordinate
        """
        return _fife.CellGrid_toMapCoordinates(self, *args)

    def toLayerCoordinates(self, *args):
        """toLayerCoordinates(self, ExactModelCoordinate map_coord) -> ModelCoordinate"""
        return _fife.CellGrid_toLayerCoordinates(self, *args)

    def toExactLayerCoordinates(self, *args):
        """toExactLayerCoordinates(self, ExactModelCoordinate map_coord) -> ExactModelCoordinate"""
        return _fife.CellGrid_toExactLayerCoordinates(self, *args)

    def getVertices(self, *args):
        """getVertices(self, ModelCoordinate cell)"""
        return _fife.CellGrid_getVertices(self, *args)

    def setXShift(self, *args):
        """setXShift(self, double xshift)"""
        return _fife.CellGrid_setXShift(self, *args)

    def getXShift(self):
        """getXShift(self) -> double"""
        return _fife.CellGrid_getXShift(self)

    def setYShift(self, *args):
        """setYShift(self, double yshift)"""
        return _fife.CellGrid_setYShift(self, *args)

    def getYShift(self):
        """getYShift(self) -> double"""
        return _fife.CellGrid_getYShift(self)

    def setZShift(self, *args):
        """setZShift(self, double zshift)"""
        return _fife.CellGrid_setZShift(self, *args)

    def getZShift(self):
        """getZShift(self) -> double"""
        return _fife.CellGrid_getZShift(self)

    def setXScale(self, *args):
        """setXScale(self, double scale)"""
        return _fife.CellGrid_setXScale(self, *args)

    def setYScale(self, *args):
        """setYScale(self, double scale)"""
        return _fife.CellGrid_setYScale(self, *args)

    def setZScale(self, *args):
        """setZScale(self, double scale)"""
        return _fife.CellGrid_setZScale(self, *args)

    def getXScale(self):
        """getXScale(self) -> double"""
        return _fife.CellGrid_getXScale(self)

    def getYScale(self):
        """getYScale(self) -> double"""
        return _fife.CellGrid_getYScale(self)

    def getZScale(self):
        """getZScale(self) -> double"""
        return _fife.CellGrid_getZScale(self)

    def setRotation(self, *args):
        """setRotation(self, double rotation)"""
        return _fife.CellGrid_setRotation(self, *args)

    def getRotation(self):
        """getRotation(self) -> double"""
        return _fife.CellGrid_getRotation(self)

CellGrid_swigregister = _fife.CellGrid_swigregister
CellGrid_swigregister(CellGrid)

class HexGrid(CellGrid):
    """Proxy of C++ FIFE::HexGrid class"""
    __swig_setmethods__ = {}
    for _s in [CellGrid]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HexGrid, name, value)
    __swig_getmethods__ = {}
    for _s in [CellGrid]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HexGrid, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_HexGrid
    __del__ = lambda self : None;
    def isAccessible(self, *args):
        """isAccessible(self, ModelCoordinate curpos, ModelCoordinate target) -> bool"""
        return _fife.HexGrid_isAccessible(self, *args)

    def getType(self):
        """getType(self) -> string"""
        return _fife.HexGrid_getType(self)

    def getName(self):
        """getName(self) -> string"""
        return _fife.HexGrid_getName(self)

    def getAdjacentCost(self, *args):
        """getAdjacentCost(self, ModelCoordinate curpos, ModelCoordinate target) -> double"""
        return _fife.HexGrid_getAdjacentCost(self, *args)

    def getCellSideCount(self):
        """getCellSideCount(self) -> uint32_t"""
        return _fife.HexGrid_getCellSideCount(self)

    def toMapCoordinates(self, *args):
        """toMapCoordinates(self, ExactModelCoordinate layer_coords) -> ExactModelCoordinate"""
        return _fife.HexGrid_toMapCoordinates(self, *args)

    def toLayerCoordinates(self, *args):
        """toLayerCoordinates(self, ExactModelCoordinate map_coord) -> ModelCoordinate"""
        return _fife.HexGrid_toLayerCoordinates(self, *args)

    def toExactLayerCoordinates(self, *args):
        """toExactLayerCoordinates(self, ExactModelCoordinate map_coord) -> ExactModelCoordinate"""
        return _fife.HexGrid_toExactLayerCoordinates(self, *args)

    def getVertices(self, *args):
        """getVertices(self, ModelCoordinate cell)"""
        return _fife.HexGrid_getVertices(self, *args)

HexGrid_swigregister = _fife.HexGrid_swigregister
HexGrid_swigregister(HexGrid)

class SquareGrid(CellGrid):
    """Proxy of C++ FIFE::SquareGrid class"""
    __swig_setmethods__ = {}
    for _s in [CellGrid]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SquareGrid, name, value)
    __swig_getmethods__ = {}
    for _s in [CellGrid]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SquareGrid, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SquareGrid
    __del__ = lambda self : None;
    def getType(self):
        """getType(self) -> string"""
        return _fife.SquareGrid_getType(self)

    def getName(self):
        """getName(self) -> string"""
        return _fife.SquareGrid_getName(self)

    def isAccessible(self, *args):
        """isAccessible(self, ModelCoordinate curpos, ModelCoordinate target) -> bool"""
        return _fife.SquareGrid_isAccessible(self, *args)

    def getAdjacentCost(self, *args):
        """getAdjacentCost(self, ModelCoordinate curpos, ModelCoordinate target) -> double"""
        return _fife.SquareGrid_getAdjacentCost(self, *args)

    def getCellSideCount(self):
        """getCellSideCount(self) -> uint32_t"""
        return _fife.SquareGrid_getCellSideCount(self)

    def toMapCoordinates(self, *args):
        """toMapCoordinates(self, ExactModelCoordinate layer_coords) -> ExactModelCoordinate"""
        return _fife.SquareGrid_toMapCoordinates(self, *args)

    def toLayerCoordinates(self, *args):
        """toLayerCoordinates(self, ExactModelCoordinate map_coord) -> ModelCoordinate"""
        return _fife.SquareGrid_toLayerCoordinates(self, *args)

    def toExactLayerCoordinates(self, *args):
        """toExactLayerCoordinates(self, ExactModelCoordinate map_coord) -> ExactModelCoordinate"""
        return _fife.SquareGrid_toExactLayerCoordinates(self, *args)

    def getVertices(self, *args):
        """getVertices(self, ModelCoordinate cell)"""
        return _fife.SquareGrid_getVertices(self, *args)

SquareGrid_swigregister = _fife.SquareGrid_swigregister
SquareGrid_swigregister(SquareGrid)

class Location(_object):
    """Proxy of C++ FIFE::Location class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Location, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Location, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> Location
        __init__(self, Location loc) -> Location
        __init__(self, Layer layer) -> Location
        """
        this = _fife.new_Location(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Location
    __del__ = lambda self : None;
    def reset(self):
        """reset(self)"""
        return _fife.Location_reset(self)

    def __eq__(self, *args):
        """__eq__(self, Location loc) -> bool"""
        return _fife.Location___eq__(self, *args)

    def getMap(self):
        """getMap(self) -> Map"""
        return _fife.Location_getMap(self)

    def setLayer(self, *args):
        """setLayer(self, Layer layer)"""
        return _fife.Location_setLayer(self, *args)

    def getLayer(self):
        """getLayer(self) -> Layer"""
        return _fife.Location_getLayer(self)

    def setExactLayerCoordinates(self, *args):
        """setExactLayerCoordinates(self, ExactModelCoordinate coordinates)"""
        return _fife.Location_setExactLayerCoordinates(self, *args)

    def setLayerCoordinates(self, *args):
        """setLayerCoordinates(self, ModelCoordinate coordinates)"""
        return _fife.Location_setLayerCoordinates(self, *args)

    def setMapCoordinates(self, *args):
        """setMapCoordinates(self, ExactModelCoordinate coordinates)"""
        return _fife.Location_setMapCoordinates(self, *args)

    def getExactLayerCoordinatesRef(self):
        """getExactLayerCoordinatesRef(self) -> ExactModelCoordinate"""
        return _fife.Location_getExactLayerCoordinatesRef(self)

    def getExactLayerCoordinates(self, *args):
        """
        getExactLayerCoordinates(self) -> ExactModelCoordinate
        getExactLayerCoordinates(self, Layer layer) -> ExactModelCoordinate
        """
        return _fife.Location_getExactLayerCoordinates(self, *args)

    def getLayerCoordinates(self, *args):
        """
        getLayerCoordinates(self) -> ModelCoordinate
        getLayerCoordinates(self, Layer layer) -> ModelCoordinate
        """
        return _fife.Location_getLayerCoordinates(self, *args)

    def getMapCoordinates(self):
        """getMapCoordinates(self) -> ExactModelCoordinate"""
        return _fife.Location_getMapCoordinates(self)

    def isValid(self):
        """isValid(self) -> bool"""
        return _fife.Location_isValid(self)

    def getCellOffsetDistance(self):
        """getCellOffsetDistance(self) -> double"""
        return _fife.Location_getCellOffsetDistance(self)

    def getMapDistanceTo(self, *args):
        """getMapDistanceTo(self, Location location) -> double"""
        return _fife.Location_getMapDistanceTo(self, *args)

    def getLayerDistanceTo(self, *args):
        """getLayerDistanceTo(self, Location location) -> double"""
        return _fife.Location_getLayerDistanceTo(self, *args)

Location_swigregister = _fife.Location_swigregister
Location_swigregister(Location)


def __lshift__(*args):
  """__lshift__(std::ostream os, Location l) -> std::ostream"""
  return _fife.__lshift__(*args)
class InstanceActionListener(_object):
    """Proxy of C++ FIFE::InstanceActionListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceActionListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceActionListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_InstanceActionListener
    __del__ = lambda self : None;
    def onInstanceActionFinished(self, *args):
        """onInstanceActionFinished(self, Instance instance, Action action)"""
        return _fife.InstanceActionListener_onInstanceActionFinished(self, *args)

    def onInstanceActionFrame(self, *args):
        """onInstanceActionFrame(self, Instance instance, Action action, int32_t frame)"""
        return _fife.InstanceActionListener_onInstanceActionFrame(self, *args)

    def __init__(self): 
        """__init__(self) -> InstanceActionListener"""
        if self.__class__ == InstanceActionListener:
            _self = None
        else:
            _self = self
        this = _fife.new_InstanceActionListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceActionListener(self)
        return weakref_proxy(self)
InstanceActionListener_swigregister = _fife.InstanceActionListener_swigregister
InstanceActionListener_swigregister(InstanceActionListener)

ICHANGE_NO_CHANGES = _fife.ICHANGE_NO_CHANGES
ICHANGE_LOC = _fife.ICHANGE_LOC
ICHANGE_ROTATION = _fife.ICHANGE_ROTATION
ICHANGE_SPEED = _fife.ICHANGE_SPEED
ICHANGE_ACTION = _fife.ICHANGE_ACTION
ICHANGE_TIME_MULTIPLIER = _fife.ICHANGE_TIME_MULTIPLIER
ICHANGE_SAYTEXT = _fife.ICHANGE_SAYTEXT
ICHANGE_BLOCK = _fife.ICHANGE_BLOCK
ICHANGE_CELL = _fife.ICHANGE_CELL
ICHANGE_TRANSPARENCY = _fife.ICHANGE_TRANSPARENCY
ICHANGE_VISIBLE = _fife.ICHANGE_VISIBLE
ICHANGE_STACKPOS = _fife.ICHANGE_STACKPOS
class InstanceChangeListener(_object):
    """Proxy of C++ FIFE::InstanceChangeListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceChangeListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceChangeListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_InstanceChangeListener
    __del__ = lambda self : None;
    def onInstanceChanged(self, *args):
        """onInstanceChanged(self, Instance instance, InstanceChangeInfo info)"""
        return _fife.InstanceChangeListener_onInstanceChanged(self, *args)

    def __init__(self): 
        """__init__(self) -> InstanceChangeListener"""
        if self.__class__ == InstanceChangeListener:
            _self = None
        else:
            _self = self
        this = _fife.new_InstanceChangeListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceChangeListener(self)
        return weakref_proxy(self)
InstanceChangeListener_swigregister = _fife.InstanceChangeListener_swigregister
InstanceChangeListener_swigregister(InstanceChangeListener)

ITYPE_NO_SHAPE = _fife.ITYPE_NO_SHAPE
ITYPE_QUAD_SHAPE = _fife.ITYPE_QUAD_SHAPE
ITYPE_CIRCLE_SHAPE = _fife.ITYPE_CIRCLE_SHAPE
class Instance(FifeClass):
    """Proxy of C++ FIFE::Instance class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Instance, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Instance, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Object object, Location location, string identifier = "") -> Instance
        __init__(self, Object object, Location location) -> Instance
        """
        this = _fife.new_Instance(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Instance
    __del__ = lambda self : None;
    def getId(self):
        """getId(self) -> string"""
        return _fife.Instance_getId(self)

    def setId(self, identifier = ""):
        """
        setId(self, string identifier = "")
        setId(self)
        """
        return _fife.Instance_setId(self, identifier)

    def getObject(self):
        """getObject(self) -> Object"""
        return _fife.Instance_getObject(self)

    def setLocation(self, *args):
        """setLocation(self, Location loc)"""
        return _fife.Instance_setLocation(self, *args)

    def getLocation(self):
        """getLocation(self) -> Location"""
        return _fife.Instance_getLocation(self)

    def getLocationRef(self):
        """getLocationRef(self) -> Location"""
        return _fife.Instance_getLocationRef(self)

    def getTargetLocation(self):
        """getTargetLocation(self) -> Location"""
        return _fife.Instance_getTargetLocation(self)

    def setRotation(self, *args):
        """setRotation(self, int32_t arg0)"""
        return _fife.Instance_setRotation(self, *args)

    def getRotation(self):
        """getRotation(self) -> int32_t"""
        return _fife.Instance_getRotation(self)

    def getOldRotation(self):
        """getOldRotation(self) -> int32_t"""
        return _fife.Instance_getOldRotation(self)

    def setBlocking(self, *args):
        """setBlocking(self, bool blocking)"""
        return _fife.Instance_setBlocking(self, *args)

    def isBlocking(self):
        """isBlocking(self) -> bool"""
        return _fife.Instance_isBlocking(self)

    def setOverrideBlocking(self, *args):
        """setOverrideBlocking(self, bool overblock)"""
        return _fife.Instance_setOverrideBlocking(self, *args)

    def isOverrideBlocking(self):
        """isOverrideBlocking(self) -> bool"""
        return _fife.Instance_isOverrideBlocking(self)

    def addActionListener(self, *args):
        """addActionListener(self, InstanceActionListener listener)"""
        return _fife.Instance_addActionListener(self, *args)

    def removeActionListener(self, *args):
        """removeActionListener(self, InstanceActionListener listener)"""
        return _fife.Instance_removeActionListener(self, *args)

    def addChangeListener(self, *args):
        """addChangeListener(self, InstanceChangeListener listener)"""
        return _fife.Instance_addChangeListener(self, *args)

    def removeChangeListener(self, *args):
        """removeChangeListener(self, InstanceChangeListener listener)"""
        return _fife.Instance_removeChangeListener(self, *args)

    def getCurrentAction(self):
        """getCurrentAction(self) -> Action"""
        return _fife.Instance_getCurrentAction(self)

    def getMovementSpeed(self):
        """getMovementSpeed(self) -> double"""
        return _fife.Instance_getMovementSpeed(self)

    def setFacingLocation(self, *args):
        """setFacingLocation(self, Location loc)"""
        return _fife.Instance_setFacingLocation(self, *args)

    def getFacingLocation(self):
        """getFacingLocation(self) -> Location"""
        return _fife.Instance_getFacingLocation(self)

    def getActionRuntime(self):
        """getActionRuntime(self) -> uint32_t"""
        return _fife.Instance_getActionRuntime(self)

    def setActionRuntime(self, *args):
        """setActionRuntime(self, uint32_t time_offset)"""
        return _fife.Instance_setActionRuntime(self, *args)

    def move(self, *args):
        """
        move(self, string actionName, Location target, double speed, string costId = "")
        move(self, string actionName, Location target, double speed)
        """
        return _fife.Instance_move(self, *args)

    def act(self, *args):
        """
        act(self, string actionName, Location direction, bool repeating = False)
        act(self, string actionName, Location direction)
        act(self, string actionName, int32_t rotation, bool repeating = False)
        act(self, string actionName, int32_t rotation)
        act(self, string actionName, bool repeating = False)
        act(self, string actionName)
        """
        return _fife.Instance_act(self, *args)

    def follow(self, *args):
        """
        follow(self, string actionName, Instance leader, double speed)
        follow(self, string actionName, Route route, double speed)
        """
        return _fife.Instance_follow(self, *args)

    def cancelMovement(self, length = 1):
        """
        cancelMovement(self, uint32_t length = 1)
        cancelMovement(self)
        """
        return _fife.Instance_cancelMovement(self, length)

    def say(self, *args):
        """
        say(self, string text, uint32_t duration = 0)
        say(self, string text)
        """
        return _fife.Instance_say(self, *args)

    def setTimeMultiplier(self, *args):
        """setTimeMultiplier(self, float multip)"""
        return _fife.Instance_setTimeMultiplier(self, *args)

    def getTimeMultiplier(self):
        """getTimeMultiplier(self) -> float"""
        return _fife.Instance_getTimeMultiplier(self)

    def getRuntime(self):
        """getRuntime(self) -> uint32_t"""
        return _fife.Instance_getRuntime(self)

    def refresh(self):
        """refresh(self)"""
        return _fife.Instance_refresh(self)

    def getChangeInfo(self):
        """getChangeInfo(self) -> InstanceChangeInfo"""
        return _fife.Instance_getChangeInfo(self)

    def setVisual(self, *args):
        """setVisual(self, IVisual visual)"""
        return _fife.Instance_setVisual(self, *args)

    def getRoute(self):
        """getRoute(self) -> Route"""
        return _fife.Instance_getRoute(self)

    def setVisitor(self, *args):
        """setVisitor(self, bool visit)"""
        return _fife.Instance_setVisitor(self, *args)

    def isVisitor(self):
        """isVisitor(self) -> bool"""
        return _fife.Instance_isVisitor(self)

    def setVisitorShape(self, *args):
        """setVisitorShape(self, VisitorShapeInfo info)"""
        return _fife.Instance_setVisitorShape(self, *args)

    def getVisitorShape(self):
        """getVisitorShape(self) -> VisitorShapeInfo"""
        return _fife.Instance_getVisitorShape(self)

    def setVisitorRadius(self, *args):
        """setVisitorRadius(self, uint16_t radius)"""
        return _fife.Instance_setVisitorRadius(self, *args)

    def getVisitorRadius(self):
        """getVisitorRadius(self) -> uint16_t"""
        return _fife.Instance_getVisitorRadius(self)

    def setCellStackPosition(self, *args):
        """setCellStackPosition(self, uint8_t stack)"""
        return _fife.Instance_setCellStackPosition(self, *args)

    def getCellStackPosition(self):
        """getCellStackPosition(self) -> uint8_t"""
        return _fife.Instance_getCellStackPosition(self)

    def isSpecialCost(self):
        """isSpecialCost(self) -> bool"""
        return _fife.Instance_isSpecialCost(self)

    def setCost(self, *args):
        """setCost(self, string id, double cost)"""
        return _fife.Instance_setCost(self, *args)

    def resetCost(self):
        """resetCost(self)"""
        return _fife.Instance_resetCost(self)

    def getCost(self):
        """getCost(self) -> double"""
        return _fife.Instance_getCost(self)

    def getCostId(self):
        """getCostId(self) -> string"""
        return _fife.Instance_getCostId(self)

    def isMultiCell(self):
        """isMultiCell(self) -> bool"""
        return _fife.Instance_isMultiCell(self)

    def get2dGfxVisual(self):
        """get2dGfxVisual(self) -> InstanceVisual"""
        return _fife.Instance_get2dGfxVisual(self)

Instance_swigregister = _fife.Instance_swigregister
Instance_swigregister(Instance)

class InstanceVector(_object):
    """Proxy of C++ std::vector<(p.FIFE::Instance)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.InstanceVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.InstanceVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.InstanceVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.InstanceVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.InstanceVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> InstanceVector"""
        return _fife.InstanceVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, InstanceVector v)"""
        return _fife.InstanceVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.InstanceVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.InstanceVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> InstanceVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.InstanceVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, InstanceVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.InstanceVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.InstanceVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.InstanceVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.InstanceVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.InstanceVector_clear(self)

    def swap(self, *args):
        """swap(self, InstanceVector v)"""
        return _fife.InstanceVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.InstanceVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.InstanceVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.InstanceVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.InstanceVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.InstanceVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.InstanceVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.InstanceVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> InstanceVector
        __init__(self, InstanceVector arg0) -> InstanceVector
        __init__(self, size_type size) -> InstanceVector
        __init__(self, size_type size, value_type value) -> InstanceVector
        """
        this = _fife.new_InstanceVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.InstanceVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.InstanceVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.InstanceVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.InstanceVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.InstanceVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.InstanceVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.InstanceVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.InstanceVector_capacity(self)

    __swig_destroy__ = _fife.delete_InstanceVector
    __del__ = lambda self : None;
InstanceVector_swigregister = _fife.InstanceVector_swigregister
InstanceVector_swigregister(InstanceVector)

class InstanceList(_object):
    """Proxy of C++ std::list<(p.FIFE::Instance)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceList, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.InstanceList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.InstanceList___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.InstanceList___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.InstanceList___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.InstanceList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> InstanceList"""
        return _fife.InstanceList___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, InstanceList v)"""
        return _fife.InstanceList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.InstanceList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.InstanceList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> InstanceList
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.InstanceList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, InstanceList v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.InstanceList___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.InstanceList_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.InstanceList_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.InstanceList_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.InstanceList_clear(self)

    def swap(self, *args):
        """swap(self, InstanceList v)"""
        return _fife.InstanceList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.InstanceList_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.InstanceList_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.InstanceList_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.InstanceList_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.InstanceList_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.InstanceList_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.InstanceList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> InstanceList
        __init__(self, InstanceList arg0) -> InstanceList
        __init__(self, size_type size) -> InstanceList
        __init__(self, size_type size, value_type value) -> InstanceList
        """
        this = _fife.new_InstanceList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.InstanceList_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.InstanceList_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.InstanceList_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.InstanceList_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.InstanceList_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.InstanceList_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _fife.InstanceList_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _fife.InstanceList_push_front(self, *args)

    def remove(self, *args):
        """remove(self, value_type x)"""
        return _fife.InstanceList_remove(self, *args)

    def unique(self):
        """unique(self)"""
        return _fife.InstanceList_unique(self)

    def reverse(self):
        """reverse(self)"""
        return _fife.InstanceList_reverse(self)

    def sort(self):
        """sort(self)"""
        return _fife.InstanceList_sort(self)

    def merge(self, *args):
        """merge(self, InstanceList x)"""
        return _fife.InstanceList_merge(self, *args)

    __swig_destroy__ = _fife.delete_InstanceList
    __del__ = lambda self : None;
InstanceList_swigregister = _fife.InstanceList_swigregister
InstanceList_swigregister(InstanceList)

ROUTE_CREATED = _fife.ROUTE_CREATED
ROUTE_SEARCHING = _fife.ROUTE_SEARCHING
ROUTE_SEARCHED = _fife.ROUTE_SEARCHED
ROUTE_SOLVED = _fife.ROUTE_SOLVED
ROUTE_FAILED = _fife.ROUTE_FAILED
class Route(FifeClass):
    """Proxy of C++ FIFE::Route class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Route, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Route, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Location start, Location end) -> Route"""
        this = _fife.new_Route(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Route
    __del__ = lambda self : None;
    def setRouteStatus(self, *args):
        """setRouteStatus(self, RouteStatusInfo status)"""
        return _fife.Route_setRouteStatus(self, *args)

    def getRouteStatus(self):
        """getRouteStatus(self) -> RouteStatusInfo"""
        return _fife.Route_getRouteStatus(self)

    def setStartNode(self, *args):
        """setStartNode(self, Location node)"""
        return _fife.Route_setStartNode(self, *args)

    def getStartNode(self):
        """getStartNode(self) -> Location"""
        return _fife.Route_getStartNode(self)

    def setEndNode(self, *args):
        """setEndNode(self, Location node)"""
        return _fife.Route_setEndNode(self, *args)

    def getEndNode(self):
        """getEndNode(self) -> Location"""
        return _fife.Route_getEndNode(self)

    def getCurrentNode(self):
        """getCurrentNode(self) -> Location"""
        return _fife.Route_getCurrentNode(self)

    def getPreviousNode(self):
        """getPreviousNode(self) -> Location"""
        return _fife.Route_getPreviousNode(self)

    def getNextNode(self):
        """getNextNode(self) -> Location"""
        return _fife.Route_getNextNode(self)

    def walkToNextNode(self, step = 1):
        """
        walkToNextNode(self, int32_t step = 1) -> bool
        walkToNextNode(self) -> bool
        """
        return _fife.Route_walkToNextNode(self, step)

    def reachedEnd(self):
        """reachedEnd(self) -> bool"""
        return _fife.Route_reachedEnd(self)

    def setPath(self, *args):
        """setPath(self, Path path)"""
        return _fife.Route_setPath(self, *args)

    def getPath(self):
        """getPath(self) -> Path"""
        return _fife.Route_getPath(self)

    def cutPath(self, length = 1):
        """
        cutPath(self, uint32_t length = 1)
        cutPath(self)
        """
        return _fife.Route_cutPath(self, length)

    def setReplanned(self, *args):
        """setReplanned(self, bool replanned)"""
        return _fife.Route_setReplanned(self, *args)

    def isReplanned(self):
        """isReplanned(self) -> bool"""
        return _fife.Route_isReplanned(self)

    def getPathLength(self):
        """getPathLength(self) -> uint32_t"""
        return _fife.Route_getPathLength(self)

    def getWalkedLength(self):
        """getWalkedLength(self) -> uint32_t"""
        return _fife.Route_getWalkedLength(self)

    def setSessionId(self, *args):
        """setSessionId(self, int32_t id)"""
        return _fife.Route_setSessionId(self, *args)

    def getSessionId(self):
        """getSessionId(self) -> int32_t"""
        return _fife.Route_getSessionId(self)

    def setRotation(self, *args):
        """setRotation(self, int32_t rotation)"""
        return _fife.Route_setRotation(self, *args)

    def getRotation(self):
        """getRotation(self) -> int32_t"""
        return _fife.Route_getRotation(self)

    def setCostId(self, *args):
        """setCostId(self, string cost)"""
        return _fife.Route_setCostId(self, *args)

    def getCostId(self):
        """getCostId(self) -> string"""
        return _fife.Route_getCostId(self)

    def isMultiCell(self):
        """isMultiCell(self) -> bool"""
        return _fife.Route_isMultiCell(self)

    def setOccupiedArea(self, *args):
        """setOccupiedArea(self, ModelCoordinateVector area)"""
        return _fife.Route_setOccupiedArea(self, *args)

    def getOccupiedArea(self):
        """getOccupiedArea(self) -> ModelCoordinateVector"""
        return _fife.Route_getOccupiedArea(self)

    def getOccupiedCells(self, *args):
        """getOccupiedCells(self, int32_t rotation) -> ModelCoordinateVector"""
        return _fife.Route_getOccupiedCells(self, *args)

    def getZStepRange(self):
        """getZStepRange(self) -> int32_t"""
        return _fife.Route_getZStepRange(self)

    def isAreaLimited(self):
        """isAreaLimited(self) -> bool"""
        return _fife.Route_isAreaLimited(self)

    def getLimitedAreas(self):
        """getLimitedAreas(self) -> StringList"""
        return _fife.Route_getLimitedAreas(self)

    def setObject(self, *args):
        """setObject(self, Object obj)"""
        return _fife.Route_setObject(self, *args)

    def getObject(self):
        """getObject(self) -> Object"""
        return _fife.Route_getObject(self)

Route_swigregister = _fife.Route_swigregister
Route_swigregister(Route)

HIGH_PRIORITY = _fife.HIGH_PRIORITY
MEDIUM_PRIORITY = _fife.MEDIUM_PRIORITY
LOW_PRIORITY = _fife.LOW_PRIORITY
class IPather(_object):
    """Proxy of C++ FIFE::IPather class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IPather, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IPather, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IPather
    __del__ = lambda self : None;
    def createRoute(self, *args):
        """
        createRoute(self, Location start, Location end, bool immediate = False, 
            string cost_id = "") -> Route
        createRoute(self, Location start, Location end, bool immediate = False) -> Route
        createRoute(self, Location start, Location end) -> Route
        """
        return _fife.IPather_createRoute(self, *args)

    def solveRoute(self, *args):
        """
        solveRoute(self, Route route, int32_t priority = MEDIUM_PRIORITY, bool immediate = False) -> bool
        solveRoute(self, Route route, int32_t priority = MEDIUM_PRIORITY) -> bool
        solveRoute(self, Route route) -> bool
        """
        return _fife.IPather_solveRoute(self, *args)

    def followRoute(self, *args):
        """followRoute(self, Location current, Route route, double speed, Location nextLocation) -> bool"""
        return _fife.IPather_followRoute(self, *args)

    def update(self):
        """update(self)"""
        return _fife.IPather_update(self)

    def cancelSession(self, *args):
        """cancelSession(self, int32_t sessionId) -> bool"""
        return _fife.IPather_cancelSession(self, *args)

    def setMaxTicks(self, *args):
        """setMaxTicks(self, int32_t ticks)"""
        return _fife.IPather_setMaxTicks(self, *args)

    def getMaxTicks(self):
        """getMaxTicks(self) -> int32_t"""
        return _fife.IPather_getMaxTicks(self)

    def getName(self):
        """getName(self) -> string"""
        return _fife.IPather_getName(self)

    def __init__(self): 
        """__init__(self) -> IPather"""
        if self.__class__ == IPather:
            _self = None
        else:
            _self = self
        this = _fife.new_IPather(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IPather(self)
        return weakref_proxy(self)
IPather_swigregister = _fife.IPather_swigregister
IPather_swigregister(IPather)

class Object(_object):
    """Proxy of C++ FIFE::Object class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Object, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Object, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string identifier, string name_space, Object inherited = None) -> Object
        __init__(self, string identifier, string name_space) -> Object
        """
        this = _fife.new_Object(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Object
    __del__ = lambda self : None;
    def getId(self):
        """getId(self) -> string"""
        return _fife.Object_getId(self)

    def getNamespace(self):
        """getNamespace(self) -> string"""
        return _fife.Object_getNamespace(self)

    def setId(self, *args):
        """setId(self, string id)"""
        return _fife.Object_setId(self, *args)

    def createAction(self, *args):
        """
        createAction(self, string identifier, bool is_default = False) -> Action
        createAction(self, string identifier) -> Action
        """
        return _fife.Object_createAction(self, *args)

    def getAction(self, *args):
        """getAction(self, string identifier) -> Action"""
        return _fife.Object_getAction(self, *args)

    def getActionIds(self):
        """getActionIds(self) -> StringList"""
        return _fife.Object_getActionIds(self)

    def setDefaultAction(self, *args):
        """setDefaultAction(self, string identifier)"""
        return _fife.Object_setDefaultAction(self, *args)

    def getDefaultAction(self):
        """getDefaultAction(self) -> Action"""
        return _fife.Object_getDefaultAction(self)

    def setPather(self, *args):
        """setPather(self, IPather pather)"""
        return _fife.Object_setPather(self, *args)

    def getPather(self):
        """getPather(self) -> IPather"""
        return _fife.Object_getPather(self)

    def getInherited(self):
        """getInherited(self) -> Object"""
        return _fife.Object_getInherited(self)

    def adoptVisual(self, *args):
        """adoptVisual(self, IVisual visual)"""
        return _fife.Object_adoptVisual(self, *args)

    def setBlocking(self, *args):
        """setBlocking(self, bool blocking)"""
        return _fife.Object_setBlocking(self, *args)

    def isBlocking(self):
        """isBlocking(self) -> bool"""
        return _fife.Object_isBlocking(self)

    def setStatic(self, *args):
        """setStatic(self, bool stat)"""
        return _fife.Object_setStatic(self, *args)

    def isStatic(self):
        """isStatic(self) -> bool"""
        return _fife.Object_isStatic(self)

    def setFilename(self, *args):
        """setFilename(self, string file)"""
        return _fife.Object_setFilename(self, *args)

    def getFilename(self):
        """getFilename(self) -> string"""
        return _fife.Object_getFilename(self)

    def setCellStackPosition(self, *args):
        """setCellStackPosition(self, uint8_t position)"""
        return _fife.Object_setCellStackPosition(self, *args)

    def getCellStackPosition(self):
        """getCellStackPosition(self) -> uint8_t"""
        return _fife.Object_getCellStackPosition(self)

    def isSpecialCost(self):
        """isSpecialCost(self) -> bool"""
        return _fife.Object_isSpecialCost(self)

    def setCostId(self, *args):
        """setCostId(self, string cost)"""
        return _fife.Object_setCostId(self, *args)

    def getCostId(self):
        """getCostId(self) -> string"""
        return _fife.Object_getCostId(self)

    def setCost(self, *args):
        """setCost(self, double cost)"""
        return _fife.Object_setCost(self, *args)

    def getCost(self):
        """getCost(self) -> double"""
        return _fife.Object_getCost(self)

    def isMultiObject(self):
        """isMultiObject(self) -> bool"""
        return _fife.Object_isMultiObject(self)

    def addMultiPartId(self, *args):
        """addMultiPartId(self, string partId)"""
        return _fife.Object_addMultiPartId(self, *args)

    def getMultiPartIds(self):
        """getMultiPartIds(self) -> StringList"""
        return _fife.Object_getMultiPartIds(self)

    def removeMultiPartId(self, *args):
        """removeMultiPartId(self, string partId)"""
        return _fife.Object_removeMultiPartId(self, *args)

    def removeAllMultiPartIds(self):
        """removeAllMultiPartIds(self)"""
        return _fife.Object_removeAllMultiPartIds(self)

    def isMultiPart(self):
        """isMultiPart(self) -> bool"""
        return _fife.Object_isMultiPart(self)

    def setMultiPart(self, *args):
        """setMultiPart(self, bool part)"""
        return _fife.Object_setMultiPart(self, *args)

    def addMultiPart(self, *args):
        """addMultiPart(self, Object obj)"""
        return _fife.Object_addMultiPart(self, *args)

    def getMultiParts(self):
        """getMultiParts(self) -> std::set<(p.FIFE::Object,std::less<(p.FIFE::Object)>,std::allocator<(p.FIFE::Object)>)>"""
        return _fife.Object_getMultiParts(self)

    def removeMultiPart(self, *args):
        """removeMultiPart(self, Object obj)"""
        return _fife.Object_removeMultiPart(self, *args)

    def removeMultiParts(self):
        """removeMultiParts(self)"""
        return _fife.Object_removeMultiParts(self)

    def addMultiPartCoordinate(self, *args):
        """addMultiPartCoordinate(self, int32_t rotation, ModelCoordinate coord)"""
        return _fife.Object_addMultiPartCoordinate(self, *args)

    def getMultiPartCoordinates(self, *args):
        """
        getMultiPartCoordinates(self) -> std::multimap<(int32_t,FIFE::ModelCoordinate)>
        getMultiPartCoordinates(self, int32_t rotation) -> ModelCoordinateVector
        """
        return _fife.Object_getMultiPartCoordinates(self, *args)

    def getMultiObjectCoordinates(self, *args):
        """getMultiObjectCoordinates(self, int32_t rotation) -> ModelCoordinateVector"""
        return _fife.Object_getMultiObjectCoordinates(self, *args)

    def setRotationAnchor(self, *args):
        """setRotationAnchor(self, ExactModelCoordinate anchor)"""
        return _fife.Object_setRotationAnchor(self, *args)

    def getRotationAnchor(self):
        """getRotationAnchor(self) -> ExactModelCoordinate"""
        return _fife.Object_getRotationAnchor(self)

    def setRestrictedRotation(self, *args):
        """setRestrictedRotation(self, bool restrict)"""
        return _fife.Object_setRestrictedRotation(self, *args)

    def isRestrictedRotation(self):
        """isRestrictedRotation(self) -> bool"""
        return _fife.Object_isRestrictedRotation(self)

    def getRestrictedRotation(self, *args):
        """getRestrictedRotation(self, int32_t rotation) -> int32_t"""
        return _fife.Object_getRestrictedRotation(self, *args)

    def setZStepRange(self, *args):
        """setZStepRange(self, int32_t zRange)"""
        return _fife.Object_setZStepRange(self, *args)

    def getZStepRange(self):
        """getZStepRange(self) -> int32_t"""
        return _fife.Object_getZStepRange(self)

    def setArea(self, *args):
        """setArea(self, string id)"""
        return _fife.Object_setArea(self, *args)

    def getArea(self):
        """getArea(self) -> string"""
        return _fife.Object_getArea(self)

    def addWalkableArea(self, *args):
        """addWalkableArea(self, string id)"""
        return _fife.Object_addWalkableArea(self, *args)

    def removeWalkableArea(self, *args):
        """removeWalkableArea(self, string id)"""
        return _fife.Object_removeWalkableArea(self, *args)

    def getWalkableAreas(self):
        """getWalkableAreas(self) -> StringList"""
        return _fife.Object_getWalkableAreas(self)

    def __eq__(self, *args):
        """__eq__(self, Object obj) -> bool"""
        return _fife.Object___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, Object obj) -> bool"""
        return _fife.Object___ne__(self, *args)

    def get2dGfxVisual(self):
        """get2dGfxVisual(self) -> ObjectVisual"""
        return _fife.Object_get2dGfxVisual(self)

Object_swigregister = _fife.Object_swigregister
Object_swigregister(Object)

class TimeProvider(_object):
    """Proxy of C++ FIFE::TimeProvider class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeProvider, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimeProvider, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, TimeProvider master) -> TimeProvider"""
        this = _fife.new_TimeProvider(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_TimeProvider
    __del__ = lambda self : None;
    def setMultiplier(self, *args):
        """setMultiplier(self, float multiplier)"""
        return _fife.TimeProvider_setMultiplier(self, *args)

    def getMultiplier(self):
        """getMultiplier(self) -> float"""
        return _fife.TimeProvider_getMultiplier(self)

    def getTotalMultiplier(self):
        """getTotalMultiplier(self) -> float"""
        return _fife.TimeProvider_getTotalMultiplier(self)

    def getGameTime(self):
        """getGameTime(self) -> uint32_t"""
        return _fife.TimeProvider_getGameTime(self)

TimeProvider_swigregister = _fife.TimeProvider_swigregister
TimeProvider_swigregister(TimeProvider)

class StringList(_object):
    """Proxy of C++ std::list<(std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringList, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.StringList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.StringList___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.StringList___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.StringList___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.StringList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> StringList"""
        return _fife.StringList___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, StringList v)"""
        return _fife.StringList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.StringList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.StringList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> StringList
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.StringList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, StringList v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.StringList___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.StringList_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.StringList_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.StringList_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.StringList_clear(self)

    def swap(self, *args):
        """swap(self, StringList v)"""
        return _fife.StringList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.StringList_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.StringList_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.StringList_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.StringList_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.StringList_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.StringList_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.StringList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> StringList
        __init__(self, StringList arg0) -> StringList
        __init__(self, size_type size) -> StringList
        __init__(self, size_type size, value_type value) -> StringList
        """
        this = _fife.new_StringList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.StringList_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.StringList_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.StringList_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.StringList_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.StringList_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.StringList_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _fife.StringList_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _fife.StringList_push_front(self, *args)

    def reverse(self):
        """reverse(self)"""
        return _fife.StringList_reverse(self)

    __swig_destroy__ = _fife.delete_StringList
    __del__ = lambda self : None;
StringList_swigregister = _fife.StringList_swigregister
StringList_swigregister(StringList)

class ObjectList(_object):
    """Proxy of C++ std::list<(p.FIFE::Object)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjectList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ObjectList, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.ObjectList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.ObjectList___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.ObjectList___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.ObjectList___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.ObjectList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> ObjectList"""
        return _fife.ObjectList___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, ObjectList v)"""
        return _fife.ObjectList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.ObjectList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.ObjectList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> ObjectList
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.ObjectList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, ObjectList v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.ObjectList___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.ObjectList_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.ObjectList_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.ObjectList_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.ObjectList_clear(self)

    def swap(self, *args):
        """swap(self, ObjectList v)"""
        return _fife.ObjectList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.ObjectList_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.ObjectList_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.ObjectList_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.ObjectList_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.ObjectList_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.ObjectList_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.ObjectList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> ObjectList
        __init__(self, ObjectList arg0) -> ObjectList
        __init__(self, size_type size) -> ObjectList
        __init__(self, size_type size, value_type value) -> ObjectList
        """
        this = _fife.new_ObjectList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.ObjectList_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.ObjectList_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.ObjectList_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.ObjectList_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.ObjectList_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.ObjectList_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _fife.ObjectList_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _fife.ObjectList_push_front(self, *args)

    def remove(self, *args):
        """remove(self, value_type x)"""
        return _fife.ObjectList_remove(self, *args)

    def unique(self):
        """unique(self)"""
        return _fife.ObjectList_unique(self)

    def reverse(self):
        """reverse(self)"""
        return _fife.ObjectList_reverse(self)

    def sort(self):
        """sort(self)"""
        return _fife.ObjectList_sort(self)

    def merge(self, *args):
        """merge(self, ObjectList x)"""
        return _fife.ObjectList_merge(self, *args)

    __swig_destroy__ = _fife.delete_ObjectList
    __del__ = lambda self : None;
ObjectList_swigregister = _fife.ObjectList_swigregister
ObjectList_swigregister(ObjectList)

class MapList(_object):
    """Proxy of C++ std::list<(p.FIFE::Map)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapList, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.MapList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.MapList___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.MapList___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.MapList___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.MapList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> MapList"""
        return _fife.MapList___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, MapList v)"""
        return _fife.MapList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.MapList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.MapList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> MapList
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.MapList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, MapList v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.MapList___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.MapList_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.MapList_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.MapList_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.MapList_clear(self)

    def swap(self, *args):
        """swap(self, MapList v)"""
        return _fife.MapList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.MapList_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.MapList_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.MapList_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.MapList_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.MapList_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.MapList_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.MapList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> MapList
        __init__(self, MapList arg0) -> MapList
        __init__(self, size_type size) -> MapList
        __init__(self, size_type size, value_type value) -> MapList
        """
        this = _fife.new_MapList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.MapList_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.MapList_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.MapList_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.MapList_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.MapList_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.MapList_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _fife.MapList_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _fife.MapList_push_front(self, *args)

    def remove(self, *args):
        """remove(self, value_type x)"""
        return _fife.MapList_remove(self, *args)

    def unique(self):
        """unique(self)"""
        return _fife.MapList_unique(self)

    def reverse(self):
        """reverse(self)"""
        return _fife.MapList_reverse(self)

    def sort(self):
        """sort(self)"""
        return _fife.MapList_sort(self)

    def merge(self, *args):
        """merge(self, MapList x)"""
        return _fife.MapList_merge(self, *args)

    __swig_destroy__ = _fife.delete_MapList
    __del__ = lambda self : None;
MapList_swigregister = _fife.MapList_swigregister
MapList_swigregister(MapList)

class Model(FifeClass):
    """Proxy of C++ FIFE::Model class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Model, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Model, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, RenderBackend renderbackend, std::vector<(p.FIFE::RendererBase,std::allocator<(p.FIFE::RendererBase)>)> renderers) -> Model"""
        this = _fife.new_Model(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Model
    __del__ = lambda self : None;
    def createMap(self, *args):
        """createMap(self, string identifier) -> Map"""
        return _fife.Model_createMap(self, *args)

    def deleteMap(self, *args):
        """deleteMap(self, Map arg0)"""
        return _fife.Model_deleteMap(self, *args)

    def getMaps(self):
        """getMaps(self) -> MapList"""
        return _fife.Model_getMaps(self)

    def getMap(self, *args):
        """getMap(self, string id) -> Map"""
        return _fife.Model_getMap(self, *args)

    def getNamespaces(self):
        """getNamespaces(self) -> StringList"""
        return _fife.Model_getNamespaces(self)

    def createObject(self, *args):
        """
        createObject(self, string identifier, string name_space, Object parent = None) -> Object
        createObject(self, string identifier, string name_space) -> Object
        """
        return _fife.Model_createObject(self, *args)

    def deleteObject(self, *args):
        """deleteObject(self, Object arg0) -> bool"""
        return _fife.Model_deleteObject(self, *args)

    def deleteObjects(self):
        """deleteObjects(self) -> bool"""
        return _fife.Model_deleteObjects(self)

    def getObject(self, *args):
        """getObject(self, string id, string name_space) -> Object"""
        return _fife.Model_getObject(self, *args)

    def getObjects(self, *args):
        """getObjects(self, string name_space) -> ObjectList"""
        return _fife.Model_getObjects(self, *args)

    def getMapCount(self):
        """getMapCount(self) -> uint32_t"""
        return _fife.Model_getMapCount(self)

    def deleteMaps(self):
        """deleteMaps(self)"""
        return _fife.Model_deleteMaps(self)

    def adoptPather(self, *args):
        """adoptPather(self, IPather pather)"""
        return _fife.Model_adoptPather(self, *args)

    def getPather(self, *args):
        """getPather(self, string pathername) -> IPather"""
        return _fife.Model_getPather(self, *args)

    def getCellGrid(self, *args):
        """getCellGrid(self, string gridtype) -> CellGrid"""
        return _fife.Model_getCellGrid(self, *args)

    def setTimeMultiplier(self, *args):
        """setTimeMultiplier(self, float multip)"""
        return _fife.Model_setTimeMultiplier(self, *args)

    def getTimeMultiplier(self):
        """getTimeMultiplier(self) -> double"""
        return _fife.Model_getTimeMultiplier(self)

Model_swigregister = _fife.Model_swigregister
Model_swigregister(Model)

CTYPE_NO_BLOCKER = _fife.CTYPE_NO_BLOCKER
CTYPE_STATIC_BLOCKER = _fife.CTYPE_STATIC_BLOCKER
CTYPE_DYNAMIC_BLOCKER = _fife.CTYPE_DYNAMIC_BLOCKER
CTYPE_CELL_NO_BLOCKER = _fife.CTYPE_CELL_NO_BLOCKER
CTYPE_CELL_BLOCKER = _fife.CTYPE_CELL_BLOCKER
CELLV_CONCEALED = _fife.CELLV_CONCEALED
CELLV_REVEALED = _fife.CELLV_REVEALED
CELLV_MASKED = _fife.CELLV_MASKED
class CellChangeListener(_object):
    """Proxy of C++ FIFE::CellChangeListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CellChangeListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CellChangeListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellChangeListener
    __del__ = lambda self : None;
    def onInstanceEnteredCell(self, *args):
        """onInstanceEnteredCell(self, Cell cell, Instance instance)"""
        return _fife.CellChangeListener_onInstanceEnteredCell(self, *args)

    def onInstanceExitedCell(self, *args):
        """onInstanceExitedCell(self, Cell cell, Instance instance)"""
        return _fife.CellChangeListener_onInstanceExitedCell(self, *args)

    def onBlockingChangedCell(self, *args):
        """onBlockingChangedCell(self, Cell cell, CellTypeInfo type, bool blocks)"""
        return _fife.CellChangeListener_onBlockingChangedCell(self, *args)

    def __init__(self): 
        """__init__(self) -> CellChangeListener"""
        if self.__class__ == CellChangeListener:
            _self = None
        else:
            _self = self
        this = _fife.new_CellChangeListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_CellChangeListener(self)
        return weakref_proxy(self)
CellChangeListener_swigregister = _fife.CellChangeListener_swigregister
CellChangeListener_swigregister(CellChangeListener)

class Cell(FifeClass):
    """Proxy of C++ FIFE::Cell class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Cell, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Cell, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, int32_t coordint, ModelCoordinate coordinate, Layer layer) -> Cell"""
        this = _fife.new_Cell(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Cell
    __del__ = lambda self : None;
    def addInstances(self, *args):
        """addInstances(self, InstanceList instances)"""
        return _fife.Cell_addInstances(self, *args)

    def addInstance(self, *args):
        """addInstance(self, Instance instance)"""
        return _fife.Cell_addInstance(self, *args)

    def changeInstance(self, *args):
        """changeInstance(self, Instance instance)"""
        return _fife.Cell_changeInstance(self, *args)

    def removeInstance(self, *args):
        """removeInstance(self, Instance instance)"""
        return _fife.Cell_removeInstance(self, *args)

    def isNeighbor(self, *args):
        """isNeighbor(self, Cell cell) -> bool"""
        return _fife.Cell_isNeighbor(self, *args)

    def getNeighbors(self):
        """getNeighbors(self) -> CellVector"""
        return _fife.Cell_getNeighbors(self)

    def updateCellInfo(self):
        """updateCellInfo(self)"""
        return _fife.Cell_updateCellInfo(self)

    def getCellId(self):
        """getCellId(self) -> int32_t"""
        return _fife.Cell_getCellId(self)

    def getLayerCoordinates(self):
        """getLayerCoordinates(self) -> ModelCoordinate"""
        return _fife.Cell_getLayerCoordinates(self)

    def defaultCost(self):
        """defaultCost(self) -> bool"""
        return _fife.Cell_defaultCost(self)

    def setCostMultiplier(self, *args):
        """setCostMultiplier(self, double multi)"""
        return _fife.Cell_setCostMultiplier(self, *args)

    def getCostMultiplier(self):
        """getCostMultiplier(self) -> double"""
        return _fife.Cell_getCostMultiplier(self)

    def resetCostMultiplier(self):
        """resetCostMultiplier(self)"""
        return _fife.Cell_resetCostMultiplier(self)

    def defaultSpeed(self):
        """defaultSpeed(self) -> bool"""
        return _fife.Cell_defaultSpeed(self)

    def setSpeedMultiplier(self, *args):
        """setSpeedMultiplier(self, double multi)"""
        return _fife.Cell_setSpeedMultiplier(self, *args)

    def getSpeedMultiplier(self):
        """getSpeedMultiplier(self) -> double"""
        return _fife.Cell_getSpeedMultiplier(self)

    def resetSpeedMultiplier(self):
        """resetSpeedMultiplier(self)"""
        return _fife.Cell_resetSpeedMultiplier(self)

    def getInstances(self):
        """getInstances(self) -> InstanceSet"""
        return _fife.Cell_getInstances(self)

    def setCellType(self, *args):
        """setCellType(self, CellTypeInfo type)"""
        return _fife.Cell_setCellType(self, *args)

    def getCellType(self):
        """getCellType(self) -> CellTypeInfo"""
        return _fife.Cell_getCellType(self)

    def setFoWType(self, *args):
        """setFoWType(self, CellVisualEffect type)"""
        return _fife.Cell_setFoWType(self, *args)

    def getFoWType(self):
        """getFoWType(self) -> CellVisualEffect"""
        return _fife.Cell_getFoWType(self)

    def getLayer(self):
        """getLayer(self) -> Layer"""
        return _fife.Cell_getLayer(self)

    def createTransition(self, *args):
        """createTransition(self, Layer layer, ModelCoordinate mc)"""
        return _fife.Cell_createTransition(self, *args)

    def deleteTransition(self):
        """deleteTransition(self)"""
        return _fife.Cell_deleteTransition(self)

Cell_swigregister = _fife.Cell_swigregister
Cell_swigregister(Cell)

class InstanceSet(_object):
    """Proxy of C++ std::set<(p.FIFE::Instance)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceSet, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.InstanceSet_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.InstanceSet___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.InstanceSet___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.InstanceSet___len__(self)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.InstanceSet_append(self, *args)

    def __contains__(self, *args):
        """__contains__(self, value_type x) -> bool"""
        return _fife.InstanceSet___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _fife.InstanceSet___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(p.FIFE::Instance)> arg0) -> InstanceSet
        __init__(self) -> InstanceSet
        __init__(self, InstanceSet arg0) -> InstanceSet
        """
        this = _fife.new_InstanceSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _fife.InstanceSet_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.InstanceSet_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.InstanceSet_clear(self)

    def swap(self, *args):
        """swap(self, InstanceSet v)"""
        return _fife.InstanceSet_swap(self, *args)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _fife.InstanceSet_count(self, *args)

    def begin(self):
        """begin(self) -> iterator"""
        return _fife.InstanceSet_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _fife.InstanceSet_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _fife.InstanceSet_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _fife.InstanceSet_rend(self)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator pos)
        erase(self, iterator first, iterator last)
        """
        return _fife.InstanceSet_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _fife.InstanceSet_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _fife.InstanceSet_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _fife.InstanceSet_upper_bound(self, *args)

    def equal_range(self, *args):
        """equal_range(self, key_type x) -> std::pair<(std::set<(p.FIFE::Instance)>::iterator,std::set<(p.FIFE::Instance)>::iterator)>"""
        return _fife.InstanceSet_equal_range(self, *args)

    def insert(self, *args):
        """insert(self, value_type __x) -> std::pair<(std::set<(p.FIFE::Instance)>::iterator,bool)>"""
        return _fife.InstanceSet_insert(self, *args)

    __swig_destroy__ = _fife.delete_InstanceSet
    __del__ = lambda self : None;
InstanceSet_swigregister = _fife.InstanceSet_swigregister
InstanceSet_swigregister(InstanceSet)

class CellSet(_object):
    """Proxy of C++ std::set<(p.FIFE::Cell)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CellSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CellSet, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.CellSet_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.CellSet___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.CellSet___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.CellSet___len__(self)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.CellSet_append(self, *args)

    def __contains__(self, *args):
        """__contains__(self, value_type x) -> bool"""
        return _fife.CellSet___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _fife.CellSet___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(p.FIFE::Cell)> arg0) -> CellSet
        __init__(self) -> CellSet
        __init__(self, CellSet arg0) -> CellSet
        """
        this = _fife.new_CellSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _fife.CellSet_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.CellSet_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.CellSet_clear(self)

    def swap(self, *args):
        """swap(self, CellSet v)"""
        return _fife.CellSet_swap(self, *args)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _fife.CellSet_count(self, *args)

    def begin(self):
        """begin(self) -> iterator"""
        return _fife.CellSet_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _fife.CellSet_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _fife.CellSet_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _fife.CellSet_rend(self)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator pos)
        erase(self, iterator first, iterator last)
        """
        return _fife.CellSet_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _fife.CellSet_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _fife.CellSet_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _fife.CellSet_upper_bound(self, *args)

    def equal_range(self, *args):
        """equal_range(self, key_type x) -> std::pair<(std::set<(p.FIFE::Cell)>::iterator,std::set<(p.FIFE::Cell)>::iterator)>"""
        return _fife.CellSet_equal_range(self, *args)

    def insert(self, *args):
        """insert(self, value_type __x) -> std::pair<(std::set<(p.FIFE::Cell)>::iterator,bool)>"""
        return _fife.CellSet_insert(self, *args)

    __swig_destroy__ = _fife.delete_CellSet
    __del__ = lambda self : None;
CellSet_swigregister = _fife.CellSet_swigregister
CellSet_swigregister(CellSet)

class CellVector(_object):
    """Proxy of C++ std::vector<(p.FIFE::Cell)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CellVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CellVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.CellVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.CellVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.CellVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.CellVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.CellVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> CellVector"""
        return _fife.CellVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, CellVector v)"""
        return _fife.CellVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.CellVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.CellVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> CellVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.CellVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, CellVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.CellVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.CellVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.CellVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.CellVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.CellVector_clear(self)

    def swap(self, *args):
        """swap(self, CellVector v)"""
        return _fife.CellVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.CellVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.CellVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.CellVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.CellVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.CellVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.CellVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.CellVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> CellVector
        __init__(self, CellVector arg0) -> CellVector
        __init__(self, size_type size) -> CellVector
        __init__(self, size_type size, value_type value) -> CellVector
        """
        this = _fife.new_CellVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.CellVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.CellVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.CellVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.CellVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.CellVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.CellVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.CellVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.CellVector_capacity(self)

    __swig_destroy__ = _fife.delete_CellVector
    __del__ = lambda self : None;
CellVector_swigregister = _fife.CellVector_swigregister
CellVector_swigregister(CellVector)

class CellCache(FifeClass):
    """Proxy of C++ FIFE::CellCache class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CellCache, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CellCache, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Layer layer) -> CellCache"""
        this = _fife.new_CellCache(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_CellCache
    __del__ = lambda self : None;
    def createCells(self):
        """createCells(self)"""
        return _fife.CellCache_createCells(self)

    def forceUpdate(self):
        """forceUpdate(self)"""
        return _fife.CellCache_forceUpdate(self)

    def addCell(self, *args):
        """addCell(self, Cell cell)"""
        return _fife.CellCache_addCell(self, *args)

    def createCell(self, *args):
        """createCell(self, ModelCoordinate mc) -> Cell"""
        return _fife.CellCache_createCell(self, *args)

    def getCell(self, *args):
        """getCell(self, ModelCoordinate mc) -> Cell"""
        return _fife.CellCache_getCell(self, *args)

    def addInteractOnRuntime(self, *args):
        """addInteractOnRuntime(self, Layer interact)"""
        return _fife.CellCache_addInteractOnRuntime(self, *args)

    def removeInteractOnRuntime(self, *args):
        """removeInteractOnRuntime(self, Layer interact)"""
        return _fife.CellCache_removeInteractOnRuntime(self, *args)

    def getSize(self):
        """getSize(self) -> Rect"""
        return _fife.CellCache_getSize(self)

    def setSize(self, *args):
        """setSize(self, Rect rec)"""
        return _fife.CellCache_setSize(self, *args)

    def getWidth(self):
        """getWidth(self) -> uint32_t"""
        return _fife.CellCache_getWidth(self)

    def getHeight(self):
        """getHeight(self) -> uint32_t"""
        return _fife.CellCache_getHeight(self)

    def getMaxIndex(self):
        """getMaxIndex(self) -> int32_t"""
        return _fife.CellCache_getMaxIndex(self)

    def setMaxNeighborZ(self, *args):
        """setMaxNeighborZ(self, int32_t z)"""
        return _fife.CellCache_setMaxNeighborZ(self, *args)

    def getMaxNeighborZ(self):
        """getMaxNeighborZ(self) -> int32_t"""
        return _fife.CellCache_getMaxNeighborZ(self)

    def isInCellCache(self, *args):
        """isInCellCache(self, Location location) -> bool"""
        return _fife.CellCache_isInCellCache(self, *args)

    def getCellsInLine(self, *args):
        """
        getCellsInLine(self, ModelCoordinate pt1, ModelCoordinate pt2, bool blocker = False) -> CellVector
        getCellsInLine(self, ModelCoordinate pt1, ModelCoordinate pt2) -> CellVector
        """
        return _fife.CellCache_getCellsInLine(self, *args)

    def getCellsInRect(self, *args):
        """getCellsInRect(self, Rect rec) -> CellVector"""
        return _fife.CellCache_getCellsInRect(self, *args)

    def getCellsInCircle(self, *args):
        """getCellsInCircle(self, ModelCoordinate center, uint16_t radius) -> CellVector"""
        return _fife.CellCache_getCellsInCircle(self, *args)

    def registerCost(self, *args):
        """registerCost(self, string costId, double cost)"""
        return _fife.CellCache_registerCost(self, *args)

    def unregisterCost(self, *args):
        """unregisterCost(self, string costId)"""
        return _fife.CellCache_unregisterCost(self, *args)

    def getCost(self, *args):
        """getCost(self, string costId) -> double"""
        return _fife.CellCache_getCost(self, *args)

    def existsCost(self, *args):
        """existsCost(self, string costId) -> bool"""
        return _fife.CellCache_existsCost(self, *args)

    def getCosts(self):
        """getCosts(self) -> StringList"""
        return _fife.CellCache_getCosts(self)

    def unregisterAllCosts(self):
        """unregisterAllCosts(self)"""
        return _fife.CellCache_unregisterAllCosts(self)

    def addCellToCost(self, *args):
        """addCellToCost(self, string costId, Cell cell)"""
        return _fife.CellCache_addCellToCost(self, *args)

    def addCellsToCost(self, *args):
        """addCellsToCost(self, string costId, CellVector cells)"""
        return _fife.CellCache_addCellsToCost(self, *args)

    def removeCellFromCost(self, *args):
        """
        removeCellFromCost(self, Cell cell)
        removeCellFromCost(self, string costId, Cell cell)
        """
        return _fife.CellCache_removeCellFromCost(self, *args)

    def removeCellsFromCost(self, *args):
        """removeCellsFromCost(self, string costId, CellVector cells)"""
        return _fife.CellCache_removeCellsFromCost(self, *args)

    def getCostCells(self, *args):
        """getCostCells(self, string costId) -> CellVector"""
        return _fife.CellCache_getCostCells(self, *args)

    def getCellCosts(self, *args):
        """getCellCosts(self, Cell cell) -> StringVector"""
        return _fife.CellCache_getCellCosts(self, *args)

    def existsCostForCell(self, *args):
        """existsCostForCell(self, string costId, Cell cell) -> bool"""
        return _fife.CellCache_existsCostForCell(self, *args)

    def setDefaultCostMultiplier(self, *args):
        """setDefaultCostMultiplier(self, double multi)"""
        return _fife.CellCache_setDefaultCostMultiplier(self, *args)

    def getDefaultCostMultiplier(self):
        """getDefaultCostMultiplier(self) -> double"""
        return _fife.CellCache_getDefaultCostMultiplier(self)

    def setDefaultSpeedMultiplier(self, *args):
        """setDefaultSpeedMultiplier(self, double multi)"""
        return _fife.CellCache_setDefaultSpeedMultiplier(self, *args)

    def getDefaultSpeedMultiplier(self):
        """getDefaultSpeedMultiplier(self) -> double"""
        return _fife.CellCache_getDefaultSpeedMultiplier(self)

    def addCellToArea(self, *args):
        """addCellToArea(self, string id, Cell cell)"""
        return _fife.CellCache_addCellToArea(self, *args)

    def addCellsToArea(self, *args):
        """addCellsToArea(self, string id, CellVector cells)"""
        return _fife.CellCache_addCellsToArea(self, *args)

    def removeCellFromArea(self, *args):
        """removeCellFromArea(self, string id, Cell cell)"""
        return _fife.CellCache_removeCellFromArea(self, *args)

    def removeCellsFromArea(self, *args):
        """removeCellsFromArea(self, string id, CellVector cells)"""
        return _fife.CellCache_removeCellsFromArea(self, *args)

    def removeArea(self, *args):
        """removeArea(self, string id)"""
        return _fife.CellCache_removeArea(self, *args)

    def existsArea(self, *args):
        """existsArea(self, string id) -> bool"""
        return _fife.CellCache_existsArea(self, *args)

    def getAreas(self):
        """getAreas(self) -> StringVector"""
        return _fife.CellCache_getAreas(self)

    def getCellAreas(self, *args):
        """getCellAreas(self, Cell cell) -> StringVector"""
        return _fife.CellCache_getCellAreas(self, *args)

    def getAreaCells(self, *args):
        """getAreaCells(self, string id) -> CellVector"""
        return _fife.CellCache_getAreaCells(self, *args)

    def isCellInArea(self, *args):
        """isCellInArea(self, string id, Cell cell) -> bool"""
        return _fife.CellCache_isCellInArea(self, *args)

    def setStaticSize(self, *args):
        """setStaticSize(self, bool staticSize)"""
        return _fife.CellCache_setStaticSize(self, *args)

    def isStaticSize(self):
        """isStaticSize(self) -> bool"""
        return _fife.CellCache_isStaticSize(self)

CellCache_swigregister = _fife.CellCache_swigregister
CellCache_swigregister(CellCache)

CELL_EDGES_ONLY = _fife.CELL_EDGES_ONLY
CELL_EDGES_AND_DIAGONALS = _fife.CELL_EDGES_AND_DIAGONALS
SORTING_CAMERA = _fife.SORTING_CAMERA
SORTING_LOCATION = _fife.SORTING_LOCATION
SORTING_CAMERA_AND_LOCATION = _fife.SORTING_CAMERA_AND_LOCATION
class LayerChangeListener(_object):
    """Proxy of C++ FIFE::LayerChangeListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayerChangeListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LayerChangeListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LayerChangeListener
    __del__ = lambda self : None;
    def onLayerChanged(self, *args):
        """onLayerChanged(self, Layer layer, InstanceVector changedInstances)"""
        return _fife.LayerChangeListener_onLayerChanged(self, *args)

    def onInstanceCreate(self, *args):
        """onInstanceCreate(self, Layer layer, Instance instance)"""
        return _fife.LayerChangeListener_onInstanceCreate(self, *args)

    def onInstanceDelete(self, *args):
        """onInstanceDelete(self, Layer layer, Instance instance)"""
        return _fife.LayerChangeListener_onInstanceDelete(self, *args)

    def __init__(self): 
        """__init__(self) -> LayerChangeListener"""
        if self.__class__ == LayerChangeListener:
            _self = None
        else:
            _self = self
        this = _fife.new_LayerChangeListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_LayerChangeListener(self)
        return weakref_proxy(self)
LayerChangeListener_swigregister = _fife.LayerChangeListener_swigregister
LayerChangeListener_swigregister(LayerChangeListener)

class Layer(FifeClass):
    """Proxy of C++ FIFE::Layer class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Layer, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Layer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string identifier, Map map, CellGrid geometry) -> Layer"""
        this = _fife.new_Layer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Layer
    __del__ = lambda self : None;
    def getId(self):
        """getId(self) -> string"""
        return _fife.Layer_getId(self)

    def setId(self, *args):
        """setId(self, string id)"""
        return _fife.Layer_setId(self, *args)

    def getCellGrid(self):
        """getCellGrid(self) -> CellGrid"""
        return _fife.Layer_getCellGrid(self)

    def setCellGrid(self, *args):
        """setCellGrid(self, CellGrid grid)"""
        return _fife.Layer_setCellGrid(self, *args)

    def getMap(self):
        """getMap(self) -> Map"""
        return _fife.Layer_getMap(self)

    def hasInstances(self):
        """hasInstances(self) -> bool"""
        return _fife.Layer_hasInstances(self)

    def createInstance(self, *args):
        """
        createInstance(self, Object object, ModelCoordinate p, string id = "") -> Instance
        createInstance(self, Object object, ModelCoordinate p) -> Instance
        createInstance(self, Object object, ExactModelCoordinate p, string id = "") -> Instance
        createInstance(self, Object object, ExactModelCoordinate p) -> Instance
        """
        return _fife.Layer_createInstance(self, *args)

    def addInstance(self, *args):
        """addInstance(self, Instance instance, ExactModelCoordinate p) -> bool"""
        return _fife.Layer_addInstance(self, *args)

    def deleteInstance(self, *args):
        """deleteInstance(self, Instance object)"""
        return _fife.Layer_deleteInstance(self, *args)

    def getInstances(self, *args):
        """
        getInstances(self) -> InstanceVector
        getInstances(self, string identifier) -> InstanceVector
        """
        return _fife.Layer_getInstances(self, *args)

    def getInstancesAt(self, *args):
        """
        getInstancesAt(self, Location loc, bool use_exactcoordinates = False) -> InstanceVector
        getInstancesAt(self, Location loc) -> InstanceVector
        """
        return _fife.Layer_getInstancesAt(self, *args)

    def getInstancesIn(self, *args):
        """getInstancesIn(self, Rect rec) -> InstanceList"""
        return _fife.Layer_getInstancesIn(self, *args)

    def getInstance(self, *args):
        """getInstance(self, string id) -> Instance"""
        return _fife.Layer_getInstance(self, *args)

    def setInstancesVisible(self, *args):
        """setInstancesVisible(self, bool vis)"""
        return _fife.Layer_setInstancesVisible(self, *args)

    def setLayerTransparency(self, *args):
        """setLayerTransparency(self, uint8_t transparency)"""
        return _fife.Layer_setLayerTransparency(self, *args)

    def getLayerTransparency(self):
        """getLayerTransparency(self) -> uint8_t"""
        return _fife.Layer_getLayerTransparency(self)

    def getMinMaxCoordinates(self, *args):
        """
        getMinMaxCoordinates(self, ModelCoordinate min, ModelCoordinate max, Layer layer = None)
        getMinMaxCoordinates(self, ModelCoordinate min, ModelCoordinate max)
        """
        return _fife.Layer_getMinMaxCoordinates(self, *args)

    def cellContainsBlockingInstance(self, *args):
        """cellContainsBlockingInstance(self, ModelCoordinate cellCoordinate) -> bool"""
        return _fife.Layer_cellContainsBlockingInstance(self, *args)

    def getBlockingInstances(self, *args):
        """getBlockingInstances(self, ModelCoordinate cellCoordinate) -> InstanceVector"""
        return _fife.Layer_getBlockingInstances(self, *args)

    def toggleInstancesVisible(self):
        """toggleInstancesVisible(self)"""
        return _fife.Layer_toggleInstancesVisible(self)

    def areInstancesVisible(self):
        """areInstancesVisible(self) -> bool"""
        return _fife.Layer_areInstancesVisible(self)

    def setPathingStrategy(self, *args):
        """setPathingStrategy(self, PathingStrategy strategy)"""
        return _fife.Layer_setPathingStrategy(self, *args)

    def getPathingStrategy(self):
        """getPathingStrategy(self) -> PathingStrategy"""
        return _fife.Layer_getPathingStrategy(self)

    def setSortingStrategy(self, *args):
        """setSortingStrategy(self, SortingStrategy strategy)"""
        return _fife.Layer_setSortingStrategy(self, *args)

    def getSortingStrategy(self):
        """getSortingStrategy(self) -> SortingStrategy"""
        return _fife.Layer_getSortingStrategy(self)

    def setWalkable(self, *args):
        """setWalkable(self, bool walkable)"""
        return _fife.Layer_setWalkable(self, *args)

    def isWalkable(self):
        """isWalkable(self) -> bool"""
        return _fife.Layer_isWalkable(self)

    def setInteract(self, *args):
        """setInteract(self, bool interact, string id)"""
        return _fife.Layer_setInteract(self, *args)

    def isInteract(self):
        """isInteract(self) -> bool"""
        return _fife.Layer_isInteract(self)

    def getWalkableId(self):
        """getWalkableId(self) -> string"""
        return _fife.Layer_getWalkableId(self)

    def addInteractLayer(self, *args):
        """addInteractLayer(self, Layer layer)"""
        return _fife.Layer_addInteractLayer(self, *args)

    def getInteractLayers(self):
        """getInteractLayers(self) -> LayerVector"""
        return _fife.Layer_getInteractLayers(self)

    def removeInteractLayer(self, *args):
        """removeInteractLayer(self, Layer layer)"""
        return _fife.Layer_removeInteractLayer(self, *args)

    def createCellCache(self):
        """createCellCache(self)"""
        return _fife.Layer_createCellCache(self)

    def getCellCache(self):
        """getCellCache(self) -> CellCache"""
        return _fife.Layer_getCellCache(self)

    def destroyCellCache(self):
        """destroyCellCache(self)"""
        return _fife.Layer_destroyCellCache(self)

    def addChangeListener(self, *args):
        """addChangeListener(self, LayerChangeListener listener)"""
        return _fife.Layer_addChangeListener(self, *args)

    def removeChangeListener(self, *args):
        """removeChangeListener(self, LayerChangeListener listener)"""
        return _fife.Layer_removeChangeListener(self, *args)

    def isChanged(self):
        """isChanged(self) -> bool"""
        return _fife.Layer_isChanged(self)

    def getChangedInstances(self):
        """getChangedInstances(self) -> InstanceVector"""
        return _fife.Layer_getChangedInstances(self)

    def setStatic(self, *args):
        """setStatic(self, bool stati)"""
        return _fife.Layer_setStatic(self, *args)

    def isStatic(self):
        """isStatic(self) -> bool"""
        return _fife.Layer_isStatic(self)

Layer_swigregister = _fife.Layer_swigregister
Layer_swigregister(Layer)

class LayerList(_object):
    """Proxy of C++ std::list<(p.FIFE::Layer)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayerList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LayerList, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.LayerList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.LayerList___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.LayerList___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.LayerList___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.LayerList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> LayerList"""
        return _fife.LayerList___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, LayerList v)"""
        return _fife.LayerList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.LayerList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.LayerList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> LayerList
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.LayerList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, LayerList v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.LayerList___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.LayerList_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.LayerList_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.LayerList_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.LayerList_clear(self)

    def swap(self, *args):
        """swap(self, LayerList v)"""
        return _fife.LayerList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.LayerList_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.LayerList_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.LayerList_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.LayerList_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.LayerList_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.LayerList_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.LayerList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> LayerList
        __init__(self, LayerList arg0) -> LayerList
        __init__(self, size_type size) -> LayerList
        __init__(self, size_type size, value_type value) -> LayerList
        """
        this = _fife.new_LayerList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.LayerList_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.LayerList_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.LayerList_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.LayerList_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.LayerList_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.LayerList_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _fife.LayerList_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _fife.LayerList_push_front(self, *args)

    def remove(self, *args):
        """remove(self, value_type x)"""
        return _fife.LayerList_remove(self, *args)

    def unique(self):
        """unique(self)"""
        return _fife.LayerList_unique(self)

    def reverse(self):
        """reverse(self)"""
        return _fife.LayerList_reverse(self)

    def sort(self):
        """sort(self)"""
        return _fife.LayerList_sort(self)

    def merge(self, *args):
        """merge(self, LayerList x)"""
        return _fife.LayerList_merge(self, *args)

    __swig_destroy__ = _fife.delete_LayerList
    __del__ = lambda self : None;
LayerList_swigregister = _fife.LayerList_swigregister
LayerList_swigregister(LayerList)

class LayerVector(_object):
    """Proxy of C++ std::vector<(p.FIFE::Layer)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LayerVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LayerVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.LayerVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.LayerVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.LayerVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.LayerVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.LayerVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> LayerVector"""
        return _fife.LayerVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, LayerVector v)"""
        return _fife.LayerVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.LayerVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.LayerVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> LayerVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.LayerVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, LayerVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.LayerVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.LayerVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.LayerVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.LayerVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.LayerVector_clear(self)

    def swap(self, *args):
        """swap(self, LayerVector v)"""
        return _fife.LayerVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.LayerVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.LayerVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.LayerVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.LayerVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.LayerVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.LayerVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.LayerVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> LayerVector
        __init__(self, LayerVector arg0) -> LayerVector
        __init__(self, size_type size) -> LayerVector
        __init__(self, size_type size, value_type value) -> LayerVector
        """
        this = _fife.new_LayerVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.LayerVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.LayerVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.LayerVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.LayerVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.LayerVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.LayerVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.LayerVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.LayerVector_capacity(self)

    __swig_destroy__ = _fife.delete_LayerVector
    __del__ = lambda self : None;
LayerVector_swigregister = _fife.LayerVector_swigregister
LayerVector_swigregister(LayerVector)

class CameraVector(_object):
    """Proxy of C++ std::vector<(p.FIFE::Camera)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CameraVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CameraVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.CameraVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.CameraVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.CameraVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.CameraVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.CameraVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> CameraVector"""
        return _fife.CameraVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, CameraVector v)"""
        return _fife.CameraVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.CameraVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.CameraVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> CameraVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.CameraVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, CameraVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.CameraVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.CameraVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.CameraVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.CameraVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.CameraVector_clear(self)

    def swap(self, *args):
        """swap(self, CameraVector v)"""
        return _fife.CameraVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.CameraVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.CameraVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.CameraVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.CameraVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.CameraVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.CameraVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.CameraVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> CameraVector
        __init__(self, CameraVector arg0) -> CameraVector
        __init__(self, size_type size) -> CameraVector
        __init__(self, size_type size, value_type value) -> CameraVector
        """
        this = _fife.new_CameraVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.CameraVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.CameraVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.CameraVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.CameraVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.CameraVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.CameraVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.CameraVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.CameraVector_capacity(self)

    __swig_destroy__ = _fife.delete_CameraVector
    __del__ = lambda self : None;
CameraVector_swigregister = _fife.CameraVector_swigregister
CameraVector_swigregister(CameraVector)

class MapChangeListener(_object):
    """Proxy of C++ FIFE::MapChangeListener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapChangeListener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MapChangeListener, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_MapChangeListener
    __del__ = lambda self : None;
    def onMapChanged(self, *args):
        """onMapChanged(self, Map map, LayerVector changedLayers)"""
        return _fife.MapChangeListener_onMapChanged(self, *args)

    def onLayerCreate(self, *args):
        """onLayerCreate(self, Map map, Layer layer)"""
        return _fife.MapChangeListener_onLayerCreate(self, *args)

    def onLayerDelete(self, *args):
        """onLayerDelete(self, Map map, Layer layer)"""
        return _fife.MapChangeListener_onLayerDelete(self, *args)

    def __init__(self): 
        """__init__(self) -> MapChangeListener"""
        if self.__class__ == MapChangeListener:
            _self = None
        else:
            _self = self
        this = _fife.new_MapChangeListener(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_MapChangeListener(self)
        return weakref_proxy(self)
MapChangeListener_swigregister = _fife.MapChangeListener_swigregister
MapChangeListener_swigregister(MapChangeListener)

class Map(FifeClass):
    """Proxy of C++ FIFE::Map class"""
    __swig_setmethods__ = {}
    for _s in [FifeClass]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Map, name, value)
    __swig_getmethods__ = {}
    for _s in [FifeClass]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Map, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string identifier, RenderBackend renderbackend, std::vector<(p.FIFE::RendererBase,std::allocator<(p.FIFE::RendererBase)>)> renderers, 
            TimeProvider tp_master = None) -> Map
        __init__(self, string identifier, RenderBackend renderbackend, std::vector<(p.FIFE::RendererBase,std::allocator<(p.FIFE::RendererBase)>)> renderers) -> Map
        """
        this = _fife.new_Map(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Map
    __del__ = lambda self : None;
    def getId(self):
        """getId(self) -> string"""
        return _fife.Map_getId(self)

    def setId(self, *args):
        """setId(self, string id)"""
        return _fife.Map_setId(self, *args)

    def createLayer(self, *args):
        """createLayer(self, string identifier, CellGrid grid) -> Layer"""
        return _fife.Map_createLayer(self, *args)

    def deleteLayer(self, *args):
        """deleteLayer(self, Layer index)"""
        return _fife.Map_deleteLayer(self, *args)

    def getLayers(self):
        """getLayers(self) -> LayerList"""
        return _fife.Map_getLayers(self)

    def getLayer(self, *args):
        """getLayer(self, string id) -> Layer"""
        return _fife.Map_getLayer(self, *args)

    def getLayerCount(self):
        """getLayerCount(self) -> uint32_t"""
        return _fife.Map_getLayerCount(self)

    def deleteLayers(self):
        """deleteLayers(self)"""
        return _fife.Map_deleteLayers(self)

    def getMinMaxCoordinates(self, *args):
        """getMinMaxCoordinates(self, ExactModelCoordinate min, ExactModelCoordinate max)"""
        return _fife.Map_getMinMaxCoordinates(self, *args)

    def setTimeMultiplier(self, *args):
        """setTimeMultiplier(self, float multip)"""
        return _fife.Map_setTimeMultiplier(self, *args)

    def getTimeMultiplier(self):
        """getTimeMultiplier(self) -> double"""
        return _fife.Map_getTimeMultiplier(self)

    def addChangeListener(self, *args):
        """addChangeListener(self, MapChangeListener listener)"""
        return _fife.Map_addChangeListener(self, *args)

    def removeChangeListener(self, *args):
        """removeChangeListener(self, MapChangeListener listener)"""
        return _fife.Map_removeChangeListener(self, *args)

    def isChanged(self):
        """isChanged(self) -> bool"""
        return _fife.Map_isChanged(self)

    def getChangedLayers(self):
        """getChangedLayers(self) -> LayerVector"""
        return _fife.Map_getChangedLayers(self)

    def addCamera(self, *args):
        """addCamera(self, string id, Layer layer, Rect viewport) -> Camera"""
        return _fife.Map_addCamera(self, *args)

    def removeCamera(self, *args):
        """removeCamera(self, string id)"""
        return _fife.Map_removeCamera(self, *args)

    def getCamera(self, *args):
        """getCamera(self, string id) -> Camera"""
        return _fife.Map_getCamera(self, *args)

    def getCameras(self):
        """getCameras(self) -> CameraVector"""
        return _fife.Map_getCameras(self)

    def setFilename(self, *args):
        """setFilename(self, string file)"""
        return _fife.Map_setFilename(self, *args)

    def getFilename(self):
        """getFilename(self) -> string"""
        return _fife.Map_getFilename(self)

    def initializeCellCaches(self):
        """initializeCellCaches(self)"""
        return _fife.Map_initializeCellCaches(self)

    def finalizeCellCaches(self):
        """finalizeCellCaches(self)"""
        return _fife.Map_finalizeCellCaches(self)

Map_swigregister = _fife.Map_swigregister
Map_swigregister(Map)

class RendererNode(_object):
    """Proxy of C++ FIFE::RendererNode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RendererNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RendererNode, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Instance attached_instance, Location relative_location, 
            Layer relative_layer, Point relative_point = FIFE::Point(0,0)) -> RendererNode
        __init__(self, Instance attached_instance, Location relative_location, 
            Layer relative_layer) -> RendererNode
        __init__(self, Instance attached_instance, Location relative_location, 
            Point relative_point = FIFE::Point(0,0)) -> RendererNode
        __init__(self, Instance attached_instance, Location relative_location) -> RendererNode
        __init__(self, Instance attached_instance, Layer relative_layer, Point relative_point = FIFE::Point(0,0)) -> RendererNode
        __init__(self, Instance attached_instance, Layer relative_layer) -> RendererNode
        __init__(self, Instance attached_instance, Point relative_point = FIFE::Point(0,0)) -> RendererNode
        __init__(self, Instance attached_instance) -> RendererNode
        __init__(self, Location attached_location, Layer relative_layer, Point relative_point = FIFE::Point(0,0)) -> RendererNode
        __init__(self, Location attached_location, Layer relative_layer) -> RendererNode
        __init__(self, Location attached_location, Point relative_point = FIFE::Point(0,0)) -> RendererNode
        __init__(self, Location attached_location) -> RendererNode
        __init__(self, Layer attached_layer, Point relative_point = FIFE::Point(0,0)) -> RendererNode
        __init__(self, Layer attached_layer) -> RendererNode
        __init__(self, Point attached_point) -> RendererNode
        __init__(self, RendererNode old) -> RendererNode
        """
        this = _fife.new_RendererNode(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_RendererNode
    __del__ = lambda self : None;
    def setAttached(self, *args):
        """
        setAttached(self, Instance attached_instance, Location relative_location, 
            Point relative_point)
        setAttached(self, Instance attached_instance, Location relative_location)
        setAttached(self, Instance attached_instance, Point relative_point)
        setAttached(self, Instance attached_instance)
        setAttached(self, Location attached_location, Point relative_point)
        setAttached(self, Location attached_location)
        setAttached(self, Layer attached_layer)
        setAttached(self, Point attached_point)
        """
        return _fife.RendererNode_setAttached(self, *args)

    def setRelative(self, *args):
        """
        setRelative(self, Location relative_location)
        setRelative(self, Location relative_location, Point relative_point)
        setRelative(self, Point relative_point)
        """
        return _fife.RendererNode_setRelative(self, *args)

    def getAttachedInstance(self):
        """getAttachedInstance(self) -> Instance"""
        return _fife.RendererNode_getAttachedInstance(self)

    def getAttachedLocation(self):
        """getAttachedLocation(self) -> Location"""
        return _fife.RendererNode_getAttachedLocation(self)

    def getAttachedLayer(self):
        """getAttachedLayer(self) -> Layer"""
        return _fife.RendererNode_getAttachedLayer(self)

    def getAttachedPoint(self):
        """getAttachedPoint(self) -> Point"""
        return _fife.RendererNode_getAttachedPoint(self)

    def getOffsetLocation(self):
        """getOffsetLocation(self) -> Location"""
        return _fife.RendererNode_getOffsetLocation(self)

    def getOffsetPoint(self):
        """getOffsetPoint(self) -> Point"""
        return _fife.RendererNode_getOffsetPoint(self)

    def getInstance(self):
        """getInstance(self) -> Instance"""
        return _fife.RendererNode_getInstance(self)

    def getLocation(self):
        """getLocation(self) -> Location"""
        return _fife.RendererNode_getLocation(self)

    def getLocationRef(self):
        """getLocationRef(self) -> Location"""
        return _fife.RendererNode_getLocationRef(self)

    def getLayer(self):
        """getLayer(self) -> Layer"""
        return _fife.RendererNode_getLayer(self)

    def getPoint(self):
        """getPoint(self) -> Point"""
        return _fife.RendererNode_getPoint(self)

    def getPointRef(self):
        """getPointRef(self) -> Point"""
        return _fife.RendererNode_getPointRef(self)

    def getCalculatedPoint(self, *args):
        """getCalculatedPoint(self, Camera cam, Layer layer, bool zoomed) -> Point"""
        return _fife.RendererNode_getCalculatedPoint(self, *args)

RendererNode_swigregister = _fife.RendererNode_swigregister
RendererNode_swigregister(RendererNode)

class LocationList(_object):
    """Proxy of C++ std::list<(FIFE::Location)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LocationList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LocationList, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.LocationList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.LocationList___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.LocationList___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.LocationList___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.LocationList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> LocationList"""
        return _fife.LocationList___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, LocationList v)"""
        return _fife.LocationList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.LocationList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.LocationList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> LocationList
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.LocationList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, LocationList v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.LocationList___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.LocationList_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.LocationList_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.LocationList_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.LocationList_clear(self)

    def swap(self, *args):
        """swap(self, LocationList v)"""
        return _fife.LocationList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.LocationList_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.LocationList_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.LocationList_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.LocationList_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.LocationList_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.LocationList_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.LocationList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> LocationList
        __init__(self, LocationList arg0) -> LocationList
        __init__(self, size_type size) -> LocationList
        __init__(self, size_type size, value_type value) -> LocationList
        """
        this = _fife.new_LocationList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.LocationList_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.LocationList_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.LocationList_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.LocationList_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.LocationList_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.LocationList_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _fife.LocationList_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _fife.LocationList_push_front(self, *args)

    def reverse(self):
        """reverse(self)"""
        return _fife.LocationList_reverse(self)

    __swig_destroy__ = _fife.delete_LocationList
    __del__ = lambda self : None;
LocationList_swigregister = _fife.LocationList_swigregister
LocationList_swigregister(LocationList)

class RoutePather(IPather):
    """Proxy of C++ FIFE::RoutePather class"""
    __swig_setmethods__ = {}
    for _s in [IPather]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RoutePather, name, value)
    __swig_getmethods__ = {}
    for _s in [IPather]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RoutePather, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> RoutePather"""
        this = _fife.new_RoutePather()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_RoutePather
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.RoutePather_getName(self)

RoutePather_swigregister = _fife.RoutePather_swigregister
RoutePather_swigregister(RoutePather)

class IAnimationSaver(_object):
    """Proxy of C++ FIFE::IAnimationSaver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IAnimationSaver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IAnimationSaver, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAnimationSaver
    __del__ = lambda self : None;
    def save(self, *args):
        """save(self, string filename)"""
        return _fife.IAnimationSaver_save(self, *args)

    def __init__(self): 
        """__init__(self) -> IAnimationSaver"""
        if self.__class__ == IAnimationSaver:
            _self = None
        else:
            _self = self
        this = _fife.new_IAnimationSaver(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationSaver(self)
        return weakref_proxy(self)
IAnimationSaver_swigregister = _fife.IAnimationSaver_swigregister
IAnimationSaver_swigregister(IAnimationSaver)

class IAtlasSaver(_object):
    """Proxy of C++ FIFE::IAtlasSaver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IAtlasSaver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IAtlasSaver, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAtlasSaver
    __del__ = lambda self : None;
    def save(self, *args):
        """save(self, string filename)"""
        return _fife.IAtlasSaver_save(self, *args)

    def __init__(self): 
        """__init__(self) -> IAtlasSaver"""
        if self.__class__ == IAtlasSaver:
            _self = None
        else:
            _self = self
        this = _fife.new_IAtlasSaver(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasSaver(self)
        return weakref_proxy(self)
IAtlasSaver_swigregister = _fife.IAtlasSaver_swigregister
IAtlasSaver_swigregister(IAtlasSaver)

class IMapSaver(_object):
    """Proxy of C++ FIFE::IMapSaver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMapSaver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IMapSaver, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IMapSaver
    __del__ = lambda self : None;
    def setObjectSaver(self, *args):
        """setObjectSaver(self, ObjectSaverPtr objectSaver)"""
        return _fife.IMapSaver_setObjectSaver(self, *args)

    def setAnimationSaver(self, *args):
        """setAnimationSaver(self, AnimationSaverPtr animationSaver)"""
        return _fife.IMapSaver_setAnimationSaver(self, *args)

    def setAtlasSaver(self, *args):
        """setAtlasSaver(self, AtlasSaverPtr atlasSaver)"""
        return _fife.IMapSaver_setAtlasSaver(self, *args)

    def save(self, *args):
        """save(self, Map map, string filename, StringVector importFiles)"""
        return _fife.IMapSaver_save(self, *args)

    def __init__(self): 
        """__init__(self) -> IMapSaver"""
        if self.__class__ == IMapSaver:
            _self = None
        else:
            _self = self
        this = _fife.new_IMapSaver(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapSaver(self)
        return weakref_proxy(self)
IMapSaver_swigregister = _fife.IMapSaver_swigregister
IMapSaver_swigregister(IMapSaver)

class IObjectSaver(_object):
    """Proxy of C++ FIFE::IObjectSaver class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IObjectSaver, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IObjectSaver, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IObjectSaver
    __del__ = lambda self : None;
    def setAnimationSaver(self, *args):
        """setAnimationSaver(self, AnimationSaverPtr animationSaver)"""
        return _fife.IObjectSaver_setAnimationSaver(self, *args)

    def save(self, *args):
        """save(self, string filename)"""
        return _fife.IObjectSaver_save(self, *args)

    def __init__(self): 
        """__init__(self) -> IObjectSaver"""
        if self.__class__ == IObjectSaver:
            _self = None
        else:
            _self = self
        this = _fife.new_IObjectSaver(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectSaver(self)
        return weakref_proxy(self)
IObjectSaver_swigregister = _fife.IObjectSaver_swigregister
IObjectSaver_swigregister(IObjectSaver)

class MapSaver(IMapSaver):
    """Proxy of C++ FIFE::MapSaver class"""
    __swig_setmethods__ = {}
    for _s in [IMapSaver]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MapSaver, name, value)
    __swig_getmethods__ = {}
    for _s in [IMapSaver]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MapSaver, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> MapSaver"""
        this = _fife.new_MapSaver()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_MapSaver
    __del__ = lambda self : None;
    def setObjectSaver(self, *args):
        """setObjectSaver(self, ObjectSaverPtr objectSaver)"""
        return _fife.MapSaver_setObjectSaver(self, *args)

    def setAnimationSaver(self, *args):
        """setAnimationSaver(self, AnimationSaverPtr animationSaver)"""
        return _fife.MapSaver_setAnimationSaver(self, *args)

    def setAtlasSaver(self, *args):
        """setAtlasSaver(self, AtlasSaverPtr atlasSaver)"""
        return _fife.MapSaver_setAtlasSaver(self, *args)

    def save(self, *args):
        """save(self, Map map, string filename, StringVector importFiles)"""
        return _fife.MapSaver_save(self, *args)

MapSaver_swigregister = _fife.MapSaver_swigregister
MapSaver_swigregister(MapSaver)

LM_CORE = _fife.LM_CORE
LM_AUDIO = _fife.LM_AUDIO
LM_CONTROLLER = _fife.LM_CONTROLLER
LM_EVTCHANNEL = _fife.LM_EVTCHANNEL
LM_GUI = _fife.LM_GUI
LM_CONSOLE = _fife.LM_CONSOLE
LM_LOADERS = _fife.LM_LOADERS
LM_NATIVE_LOADERS = _fife.LM_NATIVE_LOADERS
LM_FO_LOADERS = _fife.LM_FO_LOADERS
LM_SAVERS = _fife.LM_SAVERS
LM_NATIVE_SAVERS = _fife.LM_NATIVE_SAVERS
LM_MODEL = _fife.LM_MODEL
LM_STRUCTURES = _fife.LM_STRUCTURES
LM_INSTANCE = _fife.LM_INSTANCE
LM_LOCATION = _fife.LM_LOCATION
LM_METAMODEL = _fife.LM_METAMODEL
LM_CELLGRID = _fife.LM_CELLGRID
LM_SQUAREGRID = _fife.LM_SQUAREGRID
LM_HEXGRID = _fife.LM_HEXGRID
LM_PATHFINDER = _fife.LM_PATHFINDER
LM_UTIL = _fife.LM_UTIL
LM_RESMGR = _fife.LM_RESMGR
LM_VFS = _fife.LM_VFS
LM_VIDEO = _fife.LM_VIDEO
LM_VIEW = _fife.LM_VIEW
LM_CAMERA = _fife.LM_CAMERA
LM_VIEWVIEW = _fife.LM_VIEWVIEW
LM_XML = _fife.LM_XML
LM_EXCEPTION = _fife.LM_EXCEPTION
LM_SCRIPT = _fife.LM_SCRIPT
LM_MODULE_MAX = _fife.LM_MODULE_MAX
class moduleVector(_object):
    """Proxy of C++ std::vector<(logmodule_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, moduleVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, moduleVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.moduleVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.moduleVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.moduleVector___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(enum logmodule_t)>::size_type"""
        return _fife.moduleVector___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(enum logmodule_t)>::value_type"""
        return _fife.moduleVector_pop(self)

    def __getslice__(self, *args):
        """
        __getslice__(self, std::vector<(enum logmodule_t)>::difference_type i, 
            std::vector<(enum logmodule_t)>::difference_type j) -> moduleVector
        """
        return _fife.moduleVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(enum logmodule_t)>::difference_type i, 
            std::vector<(enum logmodule_t)>::difference_type j, 
            moduleVector v)
        """
        return _fife.moduleVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """
        __delslice__(self, std::vector<(enum logmodule_t)>::difference_type i, 
            std::vector<(enum logmodule_t)>::difference_type j)
        """
        return _fife.moduleVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(enum logmodule_t)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.moduleVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> moduleVector
        __getitem__(self, std::vector<(enum logmodule_t)>::difference_type i) -> std::vector<(enum logmodule_t)>::value_type
        """
        return _fife.moduleVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, moduleVector v)
        __setitem__(self, std::vector<(enum logmodule_t)>::difference_type i, 
            std::vector<(enum logmodule_t)>::value_type x)
        """
        return _fife.moduleVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(enum logmodule_t)>::value_type x)"""
        return _fife.moduleVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.moduleVector_empty(self)

    def size(self):
        """size(self) -> std::vector<(enum logmodule_t)>::size_type"""
        return _fife.moduleVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.moduleVector_clear(self)

    def swap(self, *args):
        """swap(self, moduleVector v)"""
        return _fife.moduleVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(enum logmodule_t)>::allocator_type"""
        return _fife.moduleVector_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(enum logmodule_t)>::const_iterator"""
        return _fife.moduleVector_begin(self)

    def end(self):
        """end(self) -> std::vector<(enum logmodule_t)>::const_iterator"""
        return _fife.moduleVector_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(enum logmodule_t)>::const_reverse_iterator"""
        return _fife.moduleVector_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(enum logmodule_t)>::const_reverse_iterator"""
        return _fife.moduleVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.moduleVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(enum logmodule_t)>::iterator pos) -> std::vector<(enum logmodule_t)>::iterator
        erase(self, std::vector<(enum logmodule_t)>::iterator first, std::vector<(enum logmodule_t)>::iterator last) -> std::vector<(enum logmodule_t)>::iterator
        """
        return _fife.moduleVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> moduleVector
        __init__(self, moduleVector arg0) -> moduleVector
        __init__(self, std::vector<(enum logmodule_t)>::size_type size) -> moduleVector
        __init__(self, std::vector<(enum logmodule_t)>::size_type size, std::vector<(enum logmodule_t)>::value_type value) -> moduleVector
        """
        this = _fife.new_moduleVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(enum logmodule_t)>::value_type x)"""
        return _fife.moduleVector_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(enum logmodule_t)>::value_type"""
        return _fife.moduleVector_front(self)

    def back(self):
        """back(self) -> std::vector<(enum logmodule_t)>::value_type"""
        return _fife.moduleVector_back(self)

    def assign(self, *args):
        """assign(self, std::vector<(enum logmodule_t)>::size_type n, std::vector<(enum logmodule_t)>::value_type x)"""
        return _fife.moduleVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(enum logmodule_t)>::size_type new_size)
        resize(self, std::vector<(enum logmodule_t)>::size_type new_size, 
            std::vector<(enum logmodule_t)>::value_type x)
        """
        return _fife.moduleVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(enum logmodule_t)>::iterator pos, std::vector<(enum logmodule_t)>::value_type x) -> std::vector<(enum logmodule_t)>::iterator
        insert(self, std::vector<(enum logmodule_t)>::iterator pos, std::vector<(enum logmodule_t)>::size_type n, 
            std::vector<(enum logmodule_t)>::value_type x)
        """
        return _fife.moduleVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(enum logmodule_t)>::size_type n)"""
        return _fife.moduleVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(enum logmodule_t)>::size_type"""
        return _fife.moduleVector_capacity(self)

    __swig_destroy__ = _fife.delete_moduleVector
    __del__ = lambda self : None;
moduleVector_swigregister = _fife.moduleVector_swigregister
moduleVector_swigregister(moduleVector)

class LogManager(_object):
    """Proxy of C++ FIFE::LogManager class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogManager, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    LEVEL_DEBUG = _fife.LogManager_LEVEL_DEBUG
    LEVEL_LOG = _fife.LogManager_LEVEL_LOG
    LEVEL_WARN = _fife.LogManager_LEVEL_WARN
    LEVEL_ERROR = _fife.LogManager_LEVEL_ERROR
    __swig_destroy__ = _fife.delete_LogManager
    __del__ = lambda self : None;
    def log(self, *args):
        """log(self, LogLevel level, logmodule_t module, string msg)"""
        return _fife.LogManager_log(self, *args)

    def setLevelFilter(self, *args):
        """setLevelFilter(self, LogLevel level)"""
        return _fife.LogManager_setLevelFilter(self, *args)

    def getLevelFilter(self):
        """getLevelFilter(self) -> LogLevel"""
        return _fife.LogManager_getLevelFilter(self)

    def addVisibleModule(self, *args):
        """addVisibleModule(self, logmodule_t module)"""
        return _fife.LogManager_addVisibleModule(self, *args)

    def removeVisibleModule(self, *args):
        """removeVisibleModule(self, logmodule_t module)"""
        return _fife.LogManager_removeVisibleModule(self, *args)

    def clearVisibleModules(self):
        """clearVisibleModules(self)"""
        return _fife.LogManager_clearVisibleModules(self)

    def isVisible(self, *args):
        """isVisible(self, logmodule_t module) -> bool"""
        return _fife.LogManager_isVisible(self, *args)

    def setLogToPrompt(self, *args):
        """setLogToPrompt(self, bool logtoprompt)"""
        return _fife.LogManager_setLogToPrompt(self, *args)

    def isLogToPrompt(self):
        """isLogToPrompt(self) -> bool"""
        return _fife.LogManager_isLogToPrompt(self)

    def setLogToFile(self, *args):
        """setLogToFile(self, bool logtofile)"""
        return _fife.LogManager_setLogToFile(self, *args)

    def isLogToFile(self):
        """isLogToFile(self) -> bool"""
        return _fife.LogManager_isLogToFile(self)

    def getModuleName(self, *args):
        """getModuleName(self, logmodule_t module) -> string"""
        return _fife.LogManager_getModuleName(self, *args)

LogManager_swigregister = _fife.LogManager_swigregister
LogManager_swigregister(LogManager)

class Logger(_object):
    """Proxy of C++ FIFE::Logger class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Logger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Logger, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, logmodule_t module) -> Logger"""
        this = _fife.new_Logger(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Logger
    __del__ = lambda self : None;
    def log(self, *args):
        """log(self, LogLevel level, string msg)"""
        return _fife.Logger_log(self, *args)

Logger_swigregister = _fife.Logger_swigregister
Logger_swigregister(Logger)

class Mathf(_object):
    """Proxy of C++ FIFE::Math<(float)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mathf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Mathf, name)
    __repr__ = _swig_repr
    def epsilon():
        """epsilon() -> num_type"""
        return _fife.Mathf_epsilon()

    if _newclass:epsilon = staticmethod(epsilon)
    __swig_getmethods__["epsilon"] = lambda x: epsilon
    def zeroTolerance():
        """zeroTolerance() -> num_type"""
        return _fife.Mathf_zeroTolerance()

    if _newclass:zeroTolerance = staticmethod(zeroTolerance)
    __swig_getmethods__["zeroTolerance"] = lambda x: zeroTolerance
    def max():
        """max() -> num_type"""
        return _fife.Mathf_max()

    if _newclass:max = staticmethod(max)
    __swig_getmethods__["max"] = lambda x: max
    def pi():
        """pi() -> num_type"""
        return _fife.Mathf_pi()

    if _newclass:pi = staticmethod(pi)
    __swig_getmethods__["pi"] = lambda x: pi
    def twoPi():
        """twoPi() -> num_type"""
        return _fife.Mathf_twoPi()

    if _newclass:twoPi = staticmethod(twoPi)
    __swig_getmethods__["twoPi"] = lambda x: twoPi
    def halfPi():
        """halfPi() -> num_type"""
        return _fife.Mathf_halfPi()

    if _newclass:halfPi = staticmethod(halfPi)
    __swig_getmethods__["halfPi"] = lambda x: halfPi
    def inversePi():
        """inversePi() -> num_type"""
        return _fife.Mathf_inversePi()

    if _newclass:inversePi = staticmethod(inversePi)
    __swig_getmethods__["inversePi"] = lambda x: inversePi
    def inverseTwoPi():
        """inverseTwoPi() -> num_type"""
        return _fife.Mathf_inverseTwoPi()

    if _newclass:inverseTwoPi = staticmethod(inverseTwoPi)
    __swig_getmethods__["inverseTwoPi"] = lambda x: inverseTwoPi
    def degToRad():
        """degToRad() -> num_type"""
        return _fife.Mathf_degToRad()

    if _newclass:degToRad = staticmethod(degToRad)
    __swig_getmethods__["degToRad"] = lambda x: degToRad
    def radToDeg():
        """radToDeg() -> num_type"""
        return _fife.Mathf_radToDeg()

    if _newclass:radToDeg = staticmethod(radToDeg)
    __swig_getmethods__["radToDeg"] = lambda x: radToDeg
    def log2():
        """log2() -> num_type"""
        return _fife.Mathf_log2()

    if _newclass:log2 = staticmethod(log2)
    __swig_getmethods__["log2"] = lambda x: log2
    def log10():
        """log10() -> num_type"""
        return _fife.Mathf_log10()

    if _newclass:log10 = staticmethod(log10)
    __swig_getmethods__["log10"] = lambda x: log10
    def invLog2():
        """invLog2() -> num_type"""
        return _fife.Mathf_invLog2()

    if _newclass:invLog2 = staticmethod(invLog2)
    __swig_getmethods__["invLog2"] = lambda x: invLog2
    def invLog10():
        """invLog10() -> num_type"""
        return _fife.Mathf_invLog10()

    if _newclass:invLog10 = staticmethod(invLog10)
    __swig_getmethods__["invLog10"] = lambda x: invLog10
    def ACos(*args):
        """ACos(float _val) -> float"""
        return _fife.Mathf_ACos(*args)

    if _newclass:ACos = staticmethod(ACos)
    __swig_getmethods__["ACos"] = lambda x: ACos
    def ASin(*args):
        """ASin(float _val) -> float"""
        return _fife.Mathf_ASin(*args)

    if _newclass:ASin = staticmethod(ASin)
    __swig_getmethods__["ASin"] = lambda x: ASin
    def ATan(*args):
        """ATan(float _val) -> float"""
        return _fife.Mathf_ATan(*args)

    if _newclass:ATan = staticmethod(ATan)
    __swig_getmethods__["ATan"] = lambda x: ATan
    def ATan2(*args):
        """ATan2(float _x, float _y) -> float"""
        return _fife.Mathf_ATan2(*args)

    if _newclass:ATan2 = staticmethod(ATan2)
    __swig_getmethods__["ATan2"] = lambda x: ATan2
    def Ceil(*args):
        """Ceil(float _val) -> float"""
        return _fife.Mathf_Ceil(*args)

    if _newclass:Ceil = staticmethod(Ceil)
    __swig_getmethods__["Ceil"] = lambda x: Ceil
    def Cos(*args):
        """Cos(float _val) -> float"""
        return _fife.Mathf_Cos(*args)

    if _newclass:Cos = staticmethod(Cos)
    __swig_getmethods__["Cos"] = lambda x: Cos
    def Exp(*args):
        """Exp(float _val) -> float"""
        return _fife.Mathf_Exp(*args)

    if _newclass:Exp = staticmethod(Exp)
    __swig_getmethods__["Exp"] = lambda x: Exp
    def FAbs(*args):
        """FAbs(float _val) -> float"""
        return _fife.Mathf_FAbs(*args)

    if _newclass:FAbs = staticmethod(FAbs)
    __swig_getmethods__["FAbs"] = lambda x: FAbs
    def Floor(*args):
        """Floor(float _val) -> float"""
        return _fife.Mathf_Floor(*args)

    if _newclass:Floor = staticmethod(Floor)
    __swig_getmethods__["Floor"] = lambda x: Floor
    def FMod(*args):
        """FMod(float _x, float _y) -> float"""
        return _fife.Mathf_FMod(*args)

    if _newclass:FMod = staticmethod(FMod)
    __swig_getmethods__["FMod"] = lambda x: FMod
    def InvSqrt(*args):
        """InvSqrt(float _val) -> float"""
        return _fife.Mathf_InvSqrt(*args)

    if _newclass:InvSqrt = staticmethod(InvSqrt)
    __swig_getmethods__["InvSqrt"] = lambda x: InvSqrt
    def Log(*args):
        """Log(float _val) -> float"""
        return _fife.Mathf_Log(*args)

    if _newclass:Log = staticmethod(Log)
    __swig_getmethods__["Log"] = lambda x: Log
    def Log2(*args):
        """Log2(float _val) -> float"""
        return _fife.Mathf_Log2(*args)

    if _newclass:Log2 = staticmethod(Log2)
    __swig_getmethods__["Log2"] = lambda x: Log2
    def Log10(*args):
        """Log10(float _val) -> float"""
        return _fife.Mathf_Log10(*args)

    if _newclass:Log10 = staticmethod(Log10)
    __swig_getmethods__["Log10"] = lambda x: Log10
    def Pow(*args):
        """Pow(float _base, float _exponent) -> float"""
        return _fife.Mathf_Pow(*args)

    if _newclass:Pow = staticmethod(Pow)
    __swig_getmethods__["Pow"] = lambda x: Pow
    def Sin(*args):
        """Sin(float _val) -> float"""
        return _fife.Mathf_Sin(*args)

    if _newclass:Sin = staticmethod(Sin)
    __swig_getmethods__["Sin"] = lambda x: Sin
    def Sqr(*args):
        """Sqr(float _val) -> float"""
        return _fife.Mathf_Sqr(*args)

    if _newclass:Sqr = staticmethod(Sqr)
    __swig_getmethods__["Sqr"] = lambda x: Sqr
    def Sqrt(*args):
        """Sqrt(float _val) -> float"""
        return _fife.Mathf_Sqrt(*args)

    if _newclass:Sqrt = staticmethod(Sqrt)
    __swig_getmethods__["Sqrt"] = lambda x: Sqrt
    def Tan(*args):
        """Tan(float _val) -> float"""
        return _fife.Mathf_Tan(*args)

    if _newclass:Tan = staticmethod(Tan)
    __swig_getmethods__["Tan"] = lambda x: Tan
    def __init__(self): 
        """__init__(self) -> Mathf"""
        this = _fife.new_Mathf()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Mathf
    __del__ = lambda self : None;
Mathf_swigregister = _fife.Mathf_swigregister
Mathf_swigregister(Mathf)

def getAngleBetween(*args):
  """
    getAngleBetween(Location loc1, Location loc2) -> int32_t
    getAngleBetween(ExactModelCoordinate emc1, ExactModelCoordinate emc2) -> int32_t
    """
  return _fife.getAngleBetween(*args)

def getFacing(*args):
  """
    getFacing(Location loc, int32_t angle) -> Location
    getFacing(ExactModelCoordinate emc, int32_t angle) -> ExactModelCoordinate
    """
  return _fife.getFacing(*args)

def Mathf_epsilon():
  """Mathf_epsilon() -> num_type"""
  return _fife.Mathf_epsilon()

def Mathf_zeroTolerance():
  """Mathf_zeroTolerance() -> num_type"""
  return _fife.Mathf_zeroTolerance()

def Mathf_max():
  """Mathf_max() -> num_type"""
  return _fife.Mathf_max()

def Mathf_pi():
  """Mathf_pi() -> num_type"""
  return _fife.Mathf_pi()

def Mathf_twoPi():
  """Mathf_twoPi() -> num_type"""
  return _fife.Mathf_twoPi()

def Mathf_halfPi():
  """Mathf_halfPi() -> num_type"""
  return _fife.Mathf_halfPi()

def Mathf_inversePi():
  """Mathf_inversePi() -> num_type"""
  return _fife.Mathf_inversePi()

def Mathf_inverseTwoPi():
  """Mathf_inverseTwoPi() -> num_type"""
  return _fife.Mathf_inverseTwoPi()

def Mathf_degToRad():
  """Mathf_degToRad() -> num_type"""
  return _fife.Mathf_degToRad()

def Mathf_radToDeg():
  """Mathf_radToDeg() -> num_type"""
  return _fife.Mathf_radToDeg()

def Mathf_log2():
  """Mathf_log2() -> num_type"""
  return _fife.Mathf_log2()

def Mathf_log10():
  """Mathf_log10() -> num_type"""
  return _fife.Mathf_log10()

def Mathf_invLog2():
  """Mathf_invLog2() -> num_type"""
  return _fife.Mathf_invLog2()

def Mathf_invLog10():
  """Mathf_invLog10() -> num_type"""
  return _fife.Mathf_invLog10()

def Mathf_ACos(*args):
  """Mathf_ACos(float _val) -> float"""
  return _fife.Mathf_ACos(*args)

def Mathf_ASin(*args):
  """Mathf_ASin(float _val) -> float"""
  return _fife.Mathf_ASin(*args)

def Mathf_ATan(*args):
  """Mathf_ATan(float _val) -> float"""
  return _fife.Mathf_ATan(*args)

def Mathf_ATan2(*args):
  """Mathf_ATan2(float _x, float _y) -> float"""
  return _fife.Mathf_ATan2(*args)

def Mathf_Ceil(*args):
  """Mathf_Ceil(float _val) -> float"""
  return _fife.Mathf_Ceil(*args)

def Mathf_Cos(*args):
  """Mathf_Cos(float _val) -> float"""
  return _fife.Mathf_Cos(*args)

def Mathf_Exp(*args):
  """Mathf_Exp(float _val) -> float"""
  return _fife.Mathf_Exp(*args)

def Mathf_FAbs(*args):
  """Mathf_FAbs(float _val) -> float"""
  return _fife.Mathf_FAbs(*args)

def Mathf_Floor(*args):
  """Mathf_Floor(float _val) -> float"""
  return _fife.Mathf_Floor(*args)

def Mathf_FMod(*args):
  """Mathf_FMod(float _x, float _y) -> float"""
  return _fife.Mathf_FMod(*args)

def Mathf_InvSqrt(*args):
  """Mathf_InvSqrt(float _val) -> float"""
  return _fife.Mathf_InvSqrt(*args)

def Mathf_Log(*args):
  """Mathf_Log(float _val) -> float"""
  return _fife.Mathf_Log(*args)

def Mathf_Log2(*args):
  """Mathf_Log2(float _val) -> float"""
  return _fife.Mathf_Log2(*args)

def Mathf_Log10(*args):
  """Mathf_Log10(float _val) -> float"""
  return _fife.Mathf_Log10(*args)

def Mathf_Pow(*args):
  """Mathf_Pow(float _base, float _exponent) -> float"""
  return _fife.Mathf_Pow(*args)

def Mathf_Sin(*args):
  """Mathf_Sin(float _val) -> float"""
  return _fife.Mathf_Sin(*args)

def Mathf_Sqr(*args):
  """Mathf_Sqr(float _val) -> float"""
  return _fife.Mathf_Sqr(*args)

def Mathf_Sqrt(*args):
  """Mathf_Sqrt(float _val) -> float"""
  return _fife.Mathf_Sqrt(*args)

def Mathf_Tan(*args):
  """Mathf_Tan(float _val) -> float"""
  return _fife.Mathf_Tan(*args)

class Mathd(_object):
    """Proxy of C++ FIFE::Math<(double)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mathd, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Mathd, name)
    __repr__ = _swig_repr
    def epsilon():
        """epsilon() -> num_type"""
        return _fife.Mathd_epsilon()

    if _newclass:epsilon = staticmethod(epsilon)
    __swig_getmethods__["epsilon"] = lambda x: epsilon
    def zeroTolerance():
        """zeroTolerance() -> num_type"""
        return _fife.Mathd_zeroTolerance()

    if _newclass:zeroTolerance = staticmethod(zeroTolerance)
    __swig_getmethods__["zeroTolerance"] = lambda x: zeroTolerance
    def max():
        """max() -> num_type"""
        return _fife.Mathd_max()

    if _newclass:max = staticmethod(max)
    __swig_getmethods__["max"] = lambda x: max
    def pi():
        """pi() -> num_type"""
        return _fife.Mathd_pi()

    if _newclass:pi = staticmethod(pi)
    __swig_getmethods__["pi"] = lambda x: pi
    def twoPi():
        """twoPi() -> num_type"""
        return _fife.Mathd_twoPi()

    if _newclass:twoPi = staticmethod(twoPi)
    __swig_getmethods__["twoPi"] = lambda x: twoPi
    def halfPi():
        """halfPi() -> num_type"""
        return _fife.Mathd_halfPi()

    if _newclass:halfPi = staticmethod(halfPi)
    __swig_getmethods__["halfPi"] = lambda x: halfPi
    def inversePi():
        """inversePi() -> num_type"""
        return _fife.Mathd_inversePi()

    if _newclass:inversePi = staticmethod(inversePi)
    __swig_getmethods__["inversePi"] = lambda x: inversePi
    def inverseTwoPi():
        """inverseTwoPi() -> num_type"""
        return _fife.Mathd_inverseTwoPi()

    if _newclass:inverseTwoPi = staticmethod(inverseTwoPi)
    __swig_getmethods__["inverseTwoPi"] = lambda x: inverseTwoPi
    def degToRad():
        """degToRad() -> num_type"""
        return _fife.Mathd_degToRad()

    if _newclass:degToRad = staticmethod(degToRad)
    __swig_getmethods__["degToRad"] = lambda x: degToRad
    def radToDeg():
        """radToDeg() -> num_type"""
        return _fife.Mathd_radToDeg()

    if _newclass:radToDeg = staticmethod(radToDeg)
    __swig_getmethods__["radToDeg"] = lambda x: radToDeg
    def log2():
        """log2() -> num_type"""
        return _fife.Mathd_log2()

    if _newclass:log2 = staticmethod(log2)
    __swig_getmethods__["log2"] = lambda x: log2
    def log10():
        """log10() -> num_type"""
        return _fife.Mathd_log10()

    if _newclass:log10 = staticmethod(log10)
    __swig_getmethods__["log10"] = lambda x: log10
    def invLog2():
        """invLog2() -> num_type"""
        return _fife.Mathd_invLog2()

    if _newclass:invLog2 = staticmethod(invLog2)
    __swig_getmethods__["invLog2"] = lambda x: invLog2
    def invLog10():
        """invLog10() -> num_type"""
        return _fife.Mathd_invLog10()

    if _newclass:invLog10 = staticmethod(invLog10)
    __swig_getmethods__["invLog10"] = lambda x: invLog10
    def ACos(*args):
        """ACos(double _val) -> double"""
        return _fife.Mathd_ACos(*args)

    if _newclass:ACos = staticmethod(ACos)
    __swig_getmethods__["ACos"] = lambda x: ACos
    def ASin(*args):
        """ASin(double _val) -> double"""
        return _fife.Mathd_ASin(*args)

    if _newclass:ASin = staticmethod(ASin)
    __swig_getmethods__["ASin"] = lambda x: ASin
    def ATan(*args):
        """ATan(double _val) -> double"""
        return _fife.Mathd_ATan(*args)

    if _newclass:ATan = staticmethod(ATan)
    __swig_getmethods__["ATan"] = lambda x: ATan
    def ATan2(*args):
        """ATan2(double _x, double _y) -> double"""
        return _fife.Mathd_ATan2(*args)

    if _newclass:ATan2 = staticmethod(ATan2)
    __swig_getmethods__["ATan2"] = lambda x: ATan2
    def Ceil(*args):
        """Ceil(double _val) -> double"""
        return _fife.Mathd_Ceil(*args)

    if _newclass:Ceil = staticmethod(Ceil)
    __swig_getmethods__["Ceil"] = lambda x: Ceil
    def Cos(*args):
        """Cos(double _val) -> double"""
        return _fife.Mathd_Cos(*args)

    if _newclass:Cos = staticmethod(Cos)
    __swig_getmethods__["Cos"] = lambda x: Cos
    def Exp(*args):
        """Exp(double _val) -> double"""
        return _fife.Mathd_Exp(*args)

    if _newclass:Exp = staticmethod(Exp)
    __swig_getmethods__["Exp"] = lambda x: Exp
    def FAbs(*args):
        """FAbs(double _val) -> double"""
        return _fife.Mathd_FAbs(*args)

    if _newclass:FAbs = staticmethod(FAbs)
    __swig_getmethods__["FAbs"] = lambda x: FAbs
    def Floor(*args):
        """Floor(double _val) -> double"""
        return _fife.Mathd_Floor(*args)

    if _newclass:Floor = staticmethod(Floor)
    __swig_getmethods__["Floor"] = lambda x: Floor
    def FMod(*args):
        """FMod(double _x, double _y) -> double"""
        return _fife.Mathd_FMod(*args)

    if _newclass:FMod = staticmethod(FMod)
    __swig_getmethods__["FMod"] = lambda x: FMod
    def InvSqrt(*args):
        """InvSqrt(double _val) -> double"""
        return _fife.Mathd_InvSqrt(*args)

    if _newclass:InvSqrt = staticmethod(InvSqrt)
    __swig_getmethods__["InvSqrt"] = lambda x: InvSqrt
    def Log(*args):
        """Log(double _val) -> double"""
        return _fife.Mathd_Log(*args)

    if _newclass:Log = staticmethod(Log)
    __swig_getmethods__["Log"] = lambda x: Log
    def Log2(*args):
        """Log2(double _val) -> double"""
        return _fife.Mathd_Log2(*args)

    if _newclass:Log2 = staticmethod(Log2)
    __swig_getmethods__["Log2"] = lambda x: Log2
    def Log10(*args):
        """Log10(double _val) -> double"""
        return _fife.Mathd_Log10(*args)

    if _newclass:Log10 = staticmethod(Log10)
    __swig_getmethods__["Log10"] = lambda x: Log10
    def Pow(*args):
        """Pow(double _base, double _exponent) -> double"""
        return _fife.Mathd_Pow(*args)

    if _newclass:Pow = staticmethod(Pow)
    __swig_getmethods__["Pow"] = lambda x: Pow
    def Sin(*args):
        """Sin(double _val) -> double"""
        return _fife.Mathd_Sin(*args)

    if _newclass:Sin = staticmethod(Sin)
    __swig_getmethods__["Sin"] = lambda x: Sin
    def Sqr(*args):
        """Sqr(double _val) -> double"""
        return _fife.Mathd_Sqr(*args)

    if _newclass:Sqr = staticmethod(Sqr)
    __swig_getmethods__["Sqr"] = lambda x: Sqr
    def Sqrt(*args):
        """Sqrt(double _val) -> double"""
        return _fife.Mathd_Sqrt(*args)

    if _newclass:Sqrt = staticmethod(Sqrt)
    __swig_getmethods__["Sqrt"] = lambda x: Sqrt
    def Tan(*args):
        """Tan(double _val) -> double"""
        return _fife.Mathd_Tan(*args)

    if _newclass:Tan = staticmethod(Tan)
    __swig_getmethods__["Tan"] = lambda x: Tan
    def __init__(self): 
        """__init__(self) -> Mathd"""
        this = _fife.new_Mathd()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_Mathd
    __del__ = lambda self : None;
Mathd_swigregister = _fife.Mathd_swigregister
Mathd_swigregister(Mathd)

def Mathd_epsilon():
  """Mathd_epsilon() -> num_type"""
  return _fife.Mathd_epsilon()

def Mathd_zeroTolerance():
  """Mathd_zeroTolerance() -> num_type"""
  return _fife.Mathd_zeroTolerance()

def Mathd_max():
  """Mathd_max() -> num_type"""
  return _fife.Mathd_max()

def Mathd_pi():
  """Mathd_pi() -> num_type"""
  return _fife.Mathd_pi()

def Mathd_twoPi():
  """Mathd_twoPi() -> num_type"""
  return _fife.Mathd_twoPi()

def Mathd_halfPi():
  """Mathd_halfPi() -> num_type"""
  return _fife.Mathd_halfPi()

def Mathd_inversePi():
  """Mathd_inversePi() -> num_type"""
  return _fife.Mathd_inversePi()

def Mathd_inverseTwoPi():
  """Mathd_inverseTwoPi() -> num_type"""
  return _fife.Mathd_inverseTwoPi()

def Mathd_degToRad():
  """Mathd_degToRad() -> num_type"""
  return _fife.Mathd_degToRad()

def Mathd_radToDeg():
  """Mathd_radToDeg() -> num_type"""
  return _fife.Mathd_radToDeg()

def Mathd_log2():
  """Mathd_log2() -> num_type"""
  return _fife.Mathd_log2()

def Mathd_log10():
  """Mathd_log10() -> num_type"""
  return _fife.Mathd_log10()

def Mathd_invLog2():
  """Mathd_invLog2() -> num_type"""
  return _fife.Mathd_invLog2()

def Mathd_invLog10():
  """Mathd_invLog10() -> num_type"""
  return _fife.Mathd_invLog10()

def Mathd_ACos(*args):
  """Mathd_ACos(double _val) -> double"""
  return _fife.Mathd_ACos(*args)

def Mathd_ASin(*args):
  """Mathd_ASin(double _val) -> double"""
  return _fife.Mathd_ASin(*args)

def Mathd_ATan(*args):
  """Mathd_ATan(double _val) -> double"""
  return _fife.Mathd_ATan(*args)

def Mathd_ATan2(*args):
  """Mathd_ATan2(double _x, double _y) -> double"""
  return _fife.Mathd_ATan2(*args)

def Mathd_Ceil(*args):
  """Mathd_Ceil(double _val) -> double"""
  return _fife.Mathd_Ceil(*args)

def Mathd_Cos(*args):
  """Mathd_Cos(double _val) -> double"""
  return _fife.Mathd_Cos(*args)

def Mathd_Exp(*args):
  """Mathd_Exp(double _val) -> double"""
  return _fife.Mathd_Exp(*args)

def Mathd_FAbs(*args):
  """Mathd_FAbs(double _val) -> double"""
  return _fife.Mathd_FAbs(*args)

def Mathd_Floor(*args):
  """Mathd_Floor(double _val) -> double"""
  return _fife.Mathd_Floor(*args)

def Mathd_FMod(*args):
  """Mathd_FMod(double _x, double _y) -> double"""
  return _fife.Mathd_FMod(*args)

def Mathd_InvSqrt(*args):
  """Mathd_InvSqrt(double _val) -> double"""
  return _fife.Mathd_InvSqrt(*args)

def Mathd_Log(*args):
  """Mathd_Log(double _val) -> double"""
  return _fife.Mathd_Log(*args)

def Mathd_Log2(*args):
  """Mathd_Log2(double _val) -> double"""
  return _fife.Mathd_Log2(*args)

def Mathd_Log10(*args):
  """Mathd_Log10(double _val) -> double"""
  return _fife.Mathd_Log10(*args)

def Mathd_Pow(*args):
  """Mathd_Pow(double _base, double _exponent) -> double"""
  return _fife.Mathd_Pow(*args)

def Mathd_Sin(*args):
  """Mathd_Sin(double _val) -> double"""
  return _fife.Mathd_Sin(*args)

def Mathd_Sqr(*args):
  """Mathd_Sqr(double _val) -> double"""
  return _fife.Mathd_Sqr(*args)

def Mathd_Sqrt(*args):
  """Mathd_Sqrt(double _val) -> double"""
  return _fife.Mathd_Sqrt(*args)

def Mathd_Tan(*args):
  """Mathd_Tan(double _val) -> double"""
  return _fife.Mathd_Tan(*args)

class TimeEvent(_object):
    """Proxy of C++ FIFE::TimeEvent class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeEvent, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimeEvent, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, int32_t period = -1) -> TimeEvent
        __init__(self) -> TimeEvent
        """
        if self.__class__ == TimeEvent:
            _self = None
        else:
            _self = self
        this = _fife.new_TimeEvent(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_TimeEvent
    __del__ = lambda self : None;
    def updateEvent(self, *args):
        """updateEvent(self, uint32_t time)"""
        return _fife.TimeEvent_updateEvent(self, *args)

    def setPeriod(self, *args):
        """setPeriod(self, int32_t period)"""
        return _fife.TimeEvent_setPeriod(self, *args)

    def getPeriod(self):
        """getPeriod(self) -> int32_t"""
        return _fife.TimeEvent_getPeriod(self)

    def getLastUpdateTime(self):
        """getLastUpdateTime(self) -> uint32_t"""
        return _fife.TimeEvent_getLastUpdateTime(self)

    def setLastUpdateTime(self, *args):
        """setLastUpdateTime(self, uint32_t arg0)"""
        return _fife.TimeEvent_setLastUpdateTime(self, *args)

    def __disown__(self):
        self.this.disown()
        _fife.disown_TimeEvent(self)
        return weakref_proxy(self)
TimeEvent_swigregister = _fife.TimeEvent_swigregister
TimeEvent_swigregister(TimeEvent)

class TimeManager(_object):
    """Proxy of C++ FIFE::TimeManager class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimeManager, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimeManager, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> TimeManager"""
        this = _fife.new_TimeManager()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_TimeManager
    __del__ = lambda self : None;
    def update(self):
        """update(self)"""
        return _fife.TimeManager_update(self)

    def getTime(self):
        """getTime(self) -> uint32_t"""
        return _fife.TimeManager_getTime(self)

    def getTimeDelta(self):
        """getTimeDelta(self) -> uint32_t"""
        return _fife.TimeManager_getTimeDelta(self)

    def getAverageFrameTime(self):
        """getAverageFrameTime(self) -> double"""
        return _fife.TimeManager_getAverageFrameTime(self)

    def printStatistics(self):
        """printStatistics(self)"""
        return _fife.TimeManager_printStatistics(self)

    def registerEvent(self, *args):
        """registerEvent(self, TimeEvent event)"""
        return _fife.TimeManager_registerEvent(self, *args)

    def unregisterEvent(self, *args):
        """unregisterEvent(self, TimeEvent event)"""
        return _fife.TimeManager_unregisterEvent(self, *args)

TimeManager_swigregister = _fife.TimeManager_swigregister
TimeManager_swigregister(TimeManager)


def getVersion():
  """getVersion() -> char"""
  return _fife.getVersion()

def getMajor():
  """getMajor() -> int"""
  return _fife.getMajor()

def getMinor():
  """getMinor() -> int"""
  return _fife.getMinor()

def getSubMinor():
  """getSubMinor() -> int"""
  return _fife.getSubMinor()

def getRevision():
  """getRevision() -> int"""
  return _fife.getRevision()
class RawDataSource(_object):
    """Proxy of C++ FIFE::RawDataSource class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RawDataSource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RawDataSource, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RawDataSource
    __del__ = lambda self : None;
    def getSize(self):
        """getSize(self) -> uint32_t"""
        return _fife.RawDataSource_getSize(self)

    def readInto(self, *args):
        """readInto(self, uint8_t buffer, uint32_t start, uint32_t length)"""
        return _fife.RawDataSource_readInto(self, *args)

RawDataSource_swigregister = _fife.RawDataSource_swigregister
RawDataSource_swigregister(RawDataSource)

class RawData(_object):
    """Proxy of C++ FIFE::RawData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RawData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RawData, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, RawDataSource datasource) -> RawData"""
        this = _fife.new_RawData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_RawData
    __del__ = lambda self : None;
    def getDataInBytes(self):
        """getDataInBytes(self) -> vectoru"""
        return _fife.RawData_getDataInBytes(self)

    def getDataInLines(self):
        """getDataInLines(self) -> StringVector"""
        return _fife.RawData_getDataInLines(self)

    def getDataLength(self):
        """getDataLength(self) -> uint32_t"""
        return _fife.RawData_getDataLength(self)

    def getCurrentIndex(self):
        """getCurrentIndex(self) -> uint32_t"""
        return _fife.RawData_getCurrentIndex(self)

    def setIndex(self, *args):
        """setIndex(self, uint32_t index)"""
        return _fife.RawData_setIndex(self, *args)

    def moveIndex(self, *args):
        """moveIndex(self, int32_t offset)"""
        return _fife.RawData_moveIndex(self, *args)

    def readInto(self, *args):
        """readInto(self, size_t len)"""
        return _fife.RawData_readInto(self, *args)

    def read8(self):
        """read8(self) -> uint8_t"""
        return _fife.RawData_read8(self)

    def read16Little(self):
        """read16Little(self) -> uint16_t"""
        return _fife.RawData_read16Little(self)

    def read32Little(self):
        """read32Little(self) -> uint32_t"""
        return _fife.RawData_read32Little(self)

    def read16Big(self):
        """read16Big(self) -> uint16_t"""
        return _fife.RawData_read16Big(self)

    def read32Big(self):
        """read32Big(self) -> uint32_t"""
        return _fife.RawData_read32Big(self)

    def read(self, *args):
        """
        read(self, int32_t size = -1)
        read(self)
        """
        return _fife.RawData_read(self, *args)

    def readString(self, *args):
        """readString(self, size_t len) -> string"""
        return _fife.RawData_readString(self, *args)

    def getLine(self, *args):
        """getLine(self, string buffer) -> bool"""
        return _fife.RawData_getLine(self, *args)

RawData_swigregister = _fife.RawData_swigregister
RawData_swigregister(RawData)

class StringSet(_object):
    """Proxy of C++ std::set<(std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringSet, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.StringSet_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.StringSet___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.StringSet___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.StringSet___len__(self)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.StringSet_append(self, *args)

    def __contains__(self, *args):
        """__contains__(self, value_type x) -> bool"""
        return _fife.StringSet___contains__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, difference_type i) -> value_type"""
        return _fife.StringSet___getitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> StringSet
        __init__(self) -> StringSet
        __init__(self, StringSet arg0) -> StringSet
        """
        this = _fife.new_StringSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _fife.StringSet_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.StringSet_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.StringSet_clear(self)

    def swap(self, *args):
        """swap(self, StringSet v)"""
        return _fife.StringSet_swap(self, *args)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _fife.StringSet_count(self, *args)

    def begin(self):
        """begin(self) -> iterator"""
        return _fife.StringSet_begin(self)

    def end(self):
        """end(self) -> iterator"""
        return _fife.StringSet_end(self)

    def rbegin(self):
        """rbegin(self) -> reverse_iterator"""
        return _fife.StringSet_rbegin(self)

    def rend(self):
        """rend(self) -> reverse_iterator"""
        return _fife.StringSet_rend(self)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator pos)
        erase(self, iterator first, iterator last)
        """
        return _fife.StringSet_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _fife.StringSet_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _fife.StringSet_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _fife.StringSet_upper_bound(self, *args)

    def equal_range(self, *args):
        """equal_range(self, key_type x) -> std::pair<(std::set<(std::string)>::iterator,std::set<(std::string)>::iterator)>"""
        return _fife.StringSet_equal_range(self, *args)

    def insert(self, *args):
        """insert(self, value_type __x) -> std::pair<(std::set<(std::string)>::iterator,bool)>"""
        return _fife.StringSet_insert(self, *args)

    __swig_destroy__ = _fife.delete_StringSet
    __del__ = lambda self : None;
StringSet_swigregister = _fife.StringSet_swigregister
StringSet_swigregister(StringSet)

class vectoru(_object):
    """Proxy of C++ std::vector<(uint8_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, vectoru, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, vectoru, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.vectoru_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.vectoru___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.vectoru___bool__(self)

    def __len__(self):
        """__len__(self) -> std::vector<(unsigned char)>::size_type"""
        return _fife.vectoru___len__(self)

    def pop(self):
        """pop(self) -> std::vector<(unsigned char)>::value_type"""
        return _fife.vectoru_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, std::vector<(unsigned char)>::difference_type i, std::vector<(unsigned char)>::difference_type j) -> vectoru"""
        return _fife.vectoru___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(self, std::vector<(unsigned char)>::difference_type i, std::vector<(unsigned char)>::difference_type j, 
            vectoru v)
        """
        return _fife.vectoru___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, std::vector<(unsigned char)>::difference_type i, std::vector<(unsigned char)>::difference_type j)"""
        return _fife.vectoru___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, std::vector<(unsigned char)>::difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.vectoru___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> vectoru
        __getitem__(self, std::vector<(unsigned char)>::difference_type i) -> std::vector<(unsigned char)>::value_type
        """
        return _fife.vectoru___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, vectoru v)
        __setitem__(self, std::vector<(unsigned char)>::difference_type i, std::vector<(unsigned char)>::value_type x)
        """
        return _fife.vectoru___setitem__(self, *args)

    def append(self, *args):
        """append(self, std::vector<(unsigned char)>::value_type x)"""
        return _fife.vectoru_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.vectoru_empty(self)

    def size(self):
        """size(self) -> std::vector<(unsigned char)>::size_type"""
        return _fife.vectoru_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.vectoru_clear(self)

    def swap(self, *args):
        """swap(self, vectoru v)"""
        return _fife.vectoru_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> std::vector<(unsigned char)>::allocator_type"""
        return _fife.vectoru_get_allocator(self)

    def begin(self):
        """begin(self) -> std::vector<(unsigned char)>::const_iterator"""
        return _fife.vectoru_begin(self)

    def end(self):
        """end(self) -> std::vector<(unsigned char)>::const_iterator"""
        return _fife.vectoru_end(self)

    def rbegin(self):
        """rbegin(self) -> std::vector<(unsigned char)>::const_reverse_iterator"""
        return _fife.vectoru_rbegin(self)

    def rend(self):
        """rend(self) -> std::vector<(unsigned char)>::const_reverse_iterator"""
        return _fife.vectoru_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.vectoru_pop_back(self)

    def erase(self, *args):
        """
        erase(self, std::vector<(unsigned char)>::iterator pos) -> std::vector<(unsigned char)>::iterator
        erase(self, std::vector<(unsigned char)>::iterator first, std::vector<(unsigned char)>::iterator last) -> std::vector<(unsigned char)>::iterator
        """
        return _fife.vectoru_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> vectoru
        __init__(self, vectoru arg0) -> vectoru
        __init__(self, std::vector<(unsigned char)>::size_type size) -> vectoru
        __init__(self, std::vector<(unsigned char)>::size_type size, std::vector<(unsigned char)>::value_type value) -> vectoru
        """
        this = _fife.new_vectoru(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, std::vector<(unsigned char)>::value_type x)"""
        return _fife.vectoru_push_back(self, *args)

    def front(self):
        """front(self) -> std::vector<(unsigned char)>::value_type"""
        return _fife.vectoru_front(self)

    def back(self):
        """back(self) -> std::vector<(unsigned char)>::value_type"""
        return _fife.vectoru_back(self)

    def assign(self, *args):
        """assign(self, std::vector<(unsigned char)>::size_type n, std::vector<(unsigned char)>::value_type x)"""
        return _fife.vectoru_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, std::vector<(unsigned char)>::size_type new_size)
        resize(self, std::vector<(unsigned char)>::size_type new_size, std::vector<(unsigned char)>::value_type x)
        """
        return _fife.vectoru_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, std::vector<(unsigned char)>::iterator pos, std::vector<(unsigned char)>::value_type x) -> std::vector<(unsigned char)>::iterator
        insert(self, std::vector<(unsigned char)>::iterator pos, std::vector<(unsigned char)>::size_type n, 
            std::vector<(unsigned char)>::value_type x)
        """
        return _fife.vectoru_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, std::vector<(unsigned char)>::size_type n)"""
        return _fife.vectoru_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> std::vector<(unsigned char)>::size_type"""
        return _fife.vectoru_capacity(self)

    __swig_destroy__ = _fife.delete_vectoru
    __del__ = lambda self : None;
vectoru_swigregister = _fife.vectoru_swigregister
vectoru_swigregister(vectoru)

class VFS(_object):
    """Proxy of C++ FIFE::VFS class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VFS, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VFS, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> VFS"""
        this = _fife.new_VFS()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_VFS
    __del__ = lambda self : None;
    def cleanup(self):
        """cleanup(self)"""
        return _fife.VFS_cleanup(self)

    def addNewSource(self, *args):
        """addNewSource(self, string path)"""
        return _fife.VFS_addNewSource(self, *args)

    def exists(self, *args):
        """exists(self, string file) -> bool"""
        return _fife.VFS_exists(self, *args)

    def open(self, *args):
        """open(self, string path) -> RawData"""
        return _fife.VFS_open(self, *args)

    def listFiles(self, *args):
        """listFiles(self, string path) -> StringSet"""
        return _fife.VFS_listFiles(self, *args)

    def listDirectories(self, *args):
        """listDirectories(self, string path) -> StringSet"""
        return _fife.VFS_listDirectories(self, *args)

VFS_swigregister = _fife.VFS_swigregister
VFS_swigregister(VFS)

class RendererBase(_object):
    """Proxy of C++ FIFE::RendererBase class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RendererBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RendererBase, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RendererBase
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.RendererBase_getName(self)

    def getPipelinePosition(self):
        """getPipelinePosition(self) -> int32_t"""
        return _fife.RendererBase_getPipelinePosition(self)

    def setPipelinePosition(self, *args):
        """setPipelinePosition(self, int32_t position)"""
        return _fife.RendererBase_setPipelinePosition(self, *args)

    def setEnabled(self, *args):
        """setEnabled(self, bool enabled)"""
        return _fife.RendererBase_setEnabled(self, *args)

    def isEnabled(self):
        """isEnabled(self) -> bool"""
        return _fife.RendererBase_isEnabled(self)

    def addActiveLayer(self, *args):
        """addActiveLayer(self, Layer layer)"""
        return _fife.RendererBase_addActiveLayer(self, *args)

    def removeActiveLayer(self, *args):
        """removeActiveLayer(self, Layer layer)"""
        return _fife.RendererBase_removeActiveLayer(self, *args)

    def clearActiveLayers(self):
        """clearActiveLayers(self)"""
        return _fife.RendererBase_clearActiveLayers(self)

    def activateAllLayers(self, *args):
        """activateAllLayers(self, Map map)"""
        return _fife.RendererBase_activateAllLayers(self, *args)

    def getActiveLayers(self):
        """getActiveLayers(self) -> LayerList"""
        return _fife.RendererBase_getActiveLayers(self)

RendererBase_swigregister = _fife.RendererBase_swigregister
RendererBase_swigregister(RendererBase)

class IRendererContainer(_object):
    """Proxy of C++ FIFE::IRendererContainer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IRendererContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IRendererContainer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IRendererContainer
    __del__ = lambda self : None;
    def getRenderer(self, *args):
        """getRenderer(self, string renderername) -> RendererBase"""
        return _fife.IRendererContainer_getRenderer(self, *args)

IRendererContainer_swigregister = _fife.IRendererContainer_swigregister
IRendererContainer_swigregister(IRendererContainer)

class ScreenPoint(_object):
    """Proxy of C++ FIFE::PointType3D<(int32_t)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScreenPoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ScreenPoint, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _fife.ScreenPoint_x_set
    __swig_getmethods__["x"] = _fife.ScreenPoint_x_get
    if _newclass:x = _swig_property(_fife.ScreenPoint_x_get, _fife.ScreenPoint_x_set)
    __swig_setmethods__["y"] = _fife.ScreenPoint_y_set
    __swig_getmethods__["y"] = _fife.ScreenPoint_y_get
    if _newclass:y = _swig_property(_fife.ScreenPoint_y_get, _fife.ScreenPoint_y_set)
    __swig_setmethods__["z"] = _fife.ScreenPoint_z_set
    __swig_getmethods__["z"] = _fife.ScreenPoint_z_get
    if _newclass:z = _swig_property(_fife.ScreenPoint_z_get, _fife.ScreenPoint_z_set)
    def __init__(self, *args): 
        """
        __init__(self, int _x = 0, int _y = 0, int _z = 0) -> ScreenPoint
        __init__(self, int _x = 0, int _y = 0) -> ScreenPoint
        __init__(self, int _x = 0) -> ScreenPoint
        __init__(self) -> ScreenPoint
        __init__(self, Point3D rhs) -> ScreenPoint
        """
        this = _fife.new_ScreenPoint(*args)
        try: self.this.append(this)
        except: self.this = this
    def __add__(self, *args):
        """__add__(self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___add__(self, *args)

    def __sub__(self, *args):
        """__sub__(self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___sub__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___isub__(self, *args)

    def __mul__(self, *args):
        """__mul__(self, int i) -> Point3D"""
        return _fife.ScreenPoint___mul__(self, *args)

    def __div__(self, *args):
        """__div__(self, int i) -> Point3D"""
        return _fife.ScreenPoint___div__(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Point3D p) -> bool"""
        return _fife.ScreenPoint___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, Point3D p) -> bool"""
        return _fife.ScreenPoint___ne__(self, *args)

    def length(self):
        """length(self) -> int"""
        return _fife.ScreenPoint_length(self)

    def normalize(self):
        """normalize(self)"""
        return _fife.ScreenPoint_normalize(self)

    def set(self, *args):
        """set(self, int _x, int _y, int _z)"""
        return _fife.ScreenPoint_set(self, *args)

    def __str__(self):
        """__str__(self) -> string"""
        return _fife.ScreenPoint___str__(self)

    __swig_destroy__ = _fife.delete_ScreenPoint
    __del__ = lambda self : None;
ScreenPoint_swigregister = _fife.ScreenPoint_swigregister
ScreenPoint_swigregister(ScreenPoint)

class Camera(IRendererContainer):
    """Proxy of C++ FIFE::Camera class"""
    __swig_setmethods__ = {}
    for _s in [IRendererContainer]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Camera, name, value)
    __swig_getmethods__ = {}
    for _s in [IRendererContainer]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Camera, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Camera
    __del__ = lambda self : None;
    def getId(self):
        """getId(self) -> string"""
        return _fife.Camera_getId(self)

    def setId(self, *args):
        """setId(self, string id)"""
        return _fife.Camera_setId(self, *args)

    def setTilt(self, *args):
        """setTilt(self, double tilt)"""
        return _fife.Camera_setTilt(self, *args)

    def getTilt(self):
        """getTilt(self) -> double"""
        return _fife.Camera_getTilt(self)

    def setRotation(self, *args):
        """setRotation(self, double rotation)"""
        return _fife.Camera_setRotation(self, *args)

    def getRotation(self):
        """getRotation(self) -> double"""
        return _fife.Camera_getRotation(self)

    def setZoom(self, *args):
        """setZoom(self, double zoom)"""
        return _fife.Camera_setZoom(self, *args)

    def getZoom(self):
        """getZoom(self) -> double"""
        return _fife.Camera_getZoom(self)

    def getOriginalZToY(self):
        """getOriginalZToY(self) -> double"""
        return _fife.Camera_getOriginalZToY(self)

    def setZToY(self, *args):
        """setZToY(self, double zToY)"""
        return _fife.Camera_setZToY(self, *args)

    def getZToY(self):
        """getZToY(self) -> double"""
        return _fife.Camera_getZToY(self)

    def setZToYEnabled(self, *args):
        """setZToYEnabled(self, bool enabled)"""
        return _fife.Camera_setZToYEnabled(self, *args)

    def isZToYEnabled(self):
        """isZToYEnabled(self) -> bool"""
        return _fife.Camera_isZToYEnabled(self)

    def setLocation(self, *args):
        """setLocation(self, Location location)"""
        return _fife.Camera_setLocation(self, *args)

    def getLocation(self):
        """getLocation(self) -> Location"""
        return _fife.Camera_getLocation(self)

    def getLocationRef(self):
        """getLocationRef(self) -> Location"""
        return _fife.Camera_getLocationRef(self)

    def attach(self, *args):
        """attach(self, Instance instance)"""
        return _fife.Camera_attach(self, *args)

    def detach(self):
        """detach(self)"""
        return _fife.Camera_detach(self)

    def getAttached(self):
        """getAttached(self) -> Instance"""
        return _fife.Camera_getAttached(self)

    def setViewPort(self, *args):
        """setViewPort(self, Rect viewport)"""
        return _fife.Camera_setViewPort(self, *args)

    def getViewPort(self):
        """getViewPort(self) -> Rect"""
        return _fife.Camera_getViewPort(self)

    def getMapViewPort(self):
        """getMapViewPort(self) -> Rect"""
        return _fife.Camera_getMapViewPort(self)

    def getLayerViewPort(self, *args):
        """getLayerViewPort(self, Layer layer) -> Rect"""
        return _fife.Camera_getLayerViewPort(self, *args)

    def setCellImageDimensions(self, *args):
        """setCellImageDimensions(self, uint32_t width, uint32_t height)"""
        return _fife.Camera_setCellImageDimensions(self, *args)

    def getCellImageDimensions(self):
        """getCellImageDimensions(self) -> Point"""
        return _fife.Camera_getCellImageDimensions(self)

    def getZOffset(self, *args):
        """getZOffset(self, Layer layer) -> Point3D"""
        return _fife.Camera_getZOffset(self, *args)

    def toScreenCoordinates(self, *args):
        """toScreenCoordinates(self, ExactModelCoordinate map_coords) -> ScreenPoint"""
        return _fife.Camera_toScreenCoordinates(self, *args)

    def toMapCoordinates(self, *args):
        """
        toMapCoordinates(self, ScreenPoint screen_coords, bool z_calculated = True) -> ExactModelCoordinate
        toMapCoordinates(self, ScreenPoint screen_coords) -> ExactModelCoordinate
        """
        return _fife.Camera_toMapCoordinates(self, *args)

    def setEnabled(self, *args):
        """setEnabled(self, bool enabled)"""
        return _fife.Camera_setEnabled(self, *args)

    def isEnabled(self):
        """isEnabled(self) -> bool"""
        return _fife.Camera_isEnabled(self)

    def getMatchingInstances(self, *args):
        """
        getMatchingInstances(self, ScreenPoint screen_coords, Layer layer, uint8_t alpha = 0)
        getMatchingInstances(self, ScreenPoint screen_coords, Layer layer)
        getMatchingInstances(self, Rect screen_rect, Layer layer, uint8_t alpha = 0)
        getMatchingInstances(self, Rect screen_rect, Layer layer)
        getMatchingInstances(self, Location loc, bool use_exactcoordinates = False)
        getMatchingInstances(self, Location loc)
        """
        return _fife.Camera_getMatchingInstances(self, *args)

    def getRenderer(self, *args):
        """getRenderer(self, string name) -> RendererBase"""
        return _fife.Camera_getRenderer(self, *args)

    def resetRenderers(self):
        """resetRenderers(self)"""
        return _fife.Camera_resetRenderers(self)

    def setLightingColor(self, *args):
        """setLightingColor(self, float red, float green, float blue)"""
        return _fife.Camera_setLightingColor(self, *args)

    def resetLightingColor(self):
        """resetLightingColor(self)"""
        return _fife.Camera_resetLightingColor(self)

    def getLightingColor(self):
        """getLightingColor(self) -> FloatVector"""
        return _fife.Camera_getLightingColor(self)

    def setOverlayColor(self, *args):
        """setOverlayColor(self, uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)"""
        return _fife.Camera_setOverlayColor(self, *args)

    def getOverlayColor(self):
        """getOverlayColor(self) -> vectoru"""
        return _fife.Camera_getOverlayColor(self)

    def resetOverlayColor(self):
        """resetOverlayColor(self)"""
        return _fife.Camera_resetOverlayColor(self)

    def setOverlayImage(self, *args):
        """
        setOverlayImage(self, int32_t id, bool fill = False)
        setOverlayImage(self, int32_t id)
        """
        return _fife.Camera_setOverlayImage(self, *args)

    def getOverlayImage(self):
        """getOverlayImage(self) -> int32_t"""
        return _fife.Camera_getOverlayImage(self)

    def resetOverlayImage(self):
        """resetOverlayImage(self)"""
        return _fife.Camera_resetOverlayImage(self)

    def setOverlayAnimation(self, *args):
        """
        setOverlayAnimation(self, AnimationPtr anim, bool fill = False)
        setOverlayAnimation(self, AnimationPtr anim)
        """
        return _fife.Camera_setOverlayAnimation(self, *args)

    def getOverlayAnimation(self):
        """getOverlayAnimation(self) -> AnimationPtr"""
        return _fife.Camera_getOverlayAnimation(self)

    def resetOverlayAnimation(self):
        """resetOverlayAnimation(self)"""
        return _fife.Camera_resetOverlayAnimation(self)

    def refresh(self):
        """refresh(self)"""
        return _fife.Camera_refresh(self)

Camera_swigregister = _fife.Camera_swigregister
Camera_swigregister(Camera)

class BlockingInfoRenderer(RendererBase):
    """Proxy of C++ FIFE::BlockingInfoRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BlockingInfoRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, BlockingInfoRenderer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_BlockingInfoRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.BlockingInfoRenderer_getName(self)

    def setColor(self, *args):
        """setColor(self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.BlockingInfoRenderer_setColor(self, *args)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> BlockingInfoRenderer"""
        return _fife.BlockingInfoRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
BlockingInfoRenderer_swigregister = _fife.BlockingInfoRenderer_swigregister
BlockingInfoRenderer_swigregister(BlockingInfoRenderer)

def BlockingInfoRenderer_getInstance(*args):
  """BlockingInfoRenderer_getInstance(IRendererContainer cnt) -> BlockingInfoRenderer"""
  return _fife.BlockingInfoRenderer_getInstance(*args)

class CellRenderer(RendererBase):
    """Proxy of C++ FIFE::CellRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CellRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CellRenderer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.CellRenderer_getName(self)

    def setBlockerColor(self, *args):
        """setBlockerColor(self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CellRenderer_setBlockerColor(self, *args)

    def setPathColor(self, *args):
        """setPathColor(self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CellRenderer_setPathColor(self, *args)

    def setEnabledBlocking(self, *args):
        """setEnabledBlocking(self, bool enabled)"""
        return _fife.CellRenderer_setEnabledBlocking(self, *args)

    def isEnabledBlocking(self):
        """isEnabledBlocking(self) -> bool"""
        return _fife.CellRenderer_isEnabledBlocking(self)

    def setEnabledFogOfWar(self, *args):
        """setEnabledFogOfWar(self, bool enabled)"""
        return _fife.CellRenderer_setEnabledFogOfWar(self, *args)

    def isEnabledFogOfWar(self):
        """isEnabledFogOfWar(self) -> bool"""
        return _fife.CellRenderer_isEnabledFogOfWar(self)

    def setEnabledPathVisual(self, *args):
        """setEnabledPathVisual(self, bool enabled)"""
        return _fife.CellRenderer_setEnabledPathVisual(self, *args)

    def isEnabledPathVisual(self):
        """isEnabledPathVisual(self) -> bool"""
        return _fife.CellRenderer_isEnabledPathVisual(self)

    def setFogOfWarLayer(self, *args):
        """setFogOfWarLayer(self, Layer layer)"""
        return _fife.CellRenderer_setFogOfWarLayer(self, *args)

    def setConcealImage(self, *args):
        """setConcealImage(self, ImagePtr image)"""
        return _fife.CellRenderer_setConcealImage(self, *args)

    def setMaskImage(self, *args):
        """setMaskImage(self, ImagePtr image)"""
        return _fife.CellRenderer_setMaskImage(self, *args)

    def addPathVisual(self, *args):
        """addPathVisual(self, Instance instance)"""
        return _fife.CellRenderer_addPathVisual(self, *args)

    def removePathVisual(self, *args):
        """removePathVisual(self, Instance instance)"""
        return _fife.CellRenderer_removePathVisual(self, *args)

    def setEnabledCost(self, *args):
        """setEnabledCost(self, string costId, bool enabled)"""
        return _fife.CellRenderer_setEnabledCost(self, *args)

    def isEnabledCost(self, *args):
        """isEnabledCost(self, string costId) -> bool"""
        return _fife.CellRenderer_isEnabledCost(self, *args)

    def setFont(self, *args):
        """setFont(self, IFont font)"""
        return _fife.CellRenderer_setFont(self, *args)

    def getFont(self):
        """getFont(self) -> IFont"""
        return _fife.CellRenderer_getFont(self)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> CellRenderer"""
        return _fife.CellRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
CellRenderer_swigregister = _fife.CellRenderer_swigregister
CellRenderer_swigregister(CellRenderer)

def CellRenderer_getInstance(*args):
  """CellRenderer_getInstance(IRendererContainer cnt) -> CellRenderer"""
  return _fife.CellRenderer_getInstance(*args)

class CellSelectionRenderer(RendererBase):
    """Proxy of C++ FIFE::CellSelectionRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CellSelectionRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CellSelectionRenderer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellSelectionRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.CellSelectionRenderer_getName(self)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> CellSelectionRenderer"""
        return _fife.CellSelectionRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
    def reset(self):
        """reset(self)"""
        return _fife.CellSelectionRenderer_reset(self)

    def selectLocation(self, *args):
        """selectLocation(self, Location loc)"""
        return _fife.CellSelectionRenderer_selectLocation(self, *args)

    def deselectLocation(self, *args):
        """deselectLocation(self, Location loc)"""
        return _fife.CellSelectionRenderer_deselectLocation(self, *args)

    def getLocations(self):
        """getLocations(self) -> std::vector<(FIFE::Location,std::allocator<(FIFE::Location)>)>"""
        return _fife.CellSelectionRenderer_getLocations(self)

    def setColor(self, *args):
        """setColor(self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CellSelectionRenderer_setColor(self, *args)

CellSelectionRenderer_swigregister = _fife.CellSelectionRenderer_swigregister
CellSelectionRenderer_swigregister(CellSelectionRenderer)

def CellSelectionRenderer_getInstance(*args):
  """CellSelectionRenderer_getInstance(IRendererContainer cnt) -> CellSelectionRenderer"""
  return _fife.CellSelectionRenderer_getInstance(*args)

class CoordinateRenderer(RendererBase):
    """Proxy of C++ FIFE::CoordinateRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CoordinateRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CoordinateRenderer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CoordinateRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.CoordinateRenderer_getName(self)

    def setFont(self, *args):
        """setFont(self, IFont font)"""
        return _fife.CoordinateRenderer_setFont(self, *args)

    def setColor(self, *args):
        """setColor(self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CoordinateRenderer_setColor(self, *args)

    def setZoom(self, *args):
        """setZoom(self, bool enable)"""
        return _fife.CoordinateRenderer_setZoom(self, *args)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> CoordinateRenderer"""
        return _fife.CoordinateRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
CoordinateRenderer_swigregister = _fife.CoordinateRenderer_swigregister
CoordinateRenderer_swigregister(CoordinateRenderer)

def CoordinateRenderer_getInstance(*args):
  """CoordinateRenderer_getInstance(IRendererContainer cnt) -> CoordinateRenderer"""
  return _fife.CoordinateRenderer_getInstance(*args)

class FloatingTextRenderer(RendererBase):
    """Proxy of C++ FIFE::FloatingTextRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatingTextRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FloatingTextRenderer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_FloatingTextRenderer
    __del__ = lambda self : None;
    def setFont(self, *args):
        """setFont(self, IFont font)"""
        return _fife.FloatingTextRenderer_setFont(self, *args)

    def setColor(self, *args):
        """
        setColor(self, uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
        setColor(self, uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.FloatingTextRenderer_setColor(self, *args)

    def setBackground(self, *args):
        """
        setBackground(self, uint8_t br, uint8_t bg, uint8_t bb, uint8_t ba = 255)
        setBackground(self, uint8_t br, uint8_t bg, uint8_t bb)
        """
        return _fife.FloatingTextRenderer_setBackground(self, *args)

    def setBorder(self, *args):
        """
        setBorder(self, uint8_t bbr, uint8_t bbg, uint8_t bbb, uint8_t bba = 255)
        setBorder(self, uint8_t bbr, uint8_t bbg, uint8_t bbb)
        """
        return _fife.FloatingTextRenderer_setBorder(self, *args)

    def resetBackground(self):
        """resetBackground(self)"""
        return _fife.FloatingTextRenderer_resetBackground(self)

    def resetBorder(self):
        """resetBorder(self)"""
        return _fife.FloatingTextRenderer_resetBorder(self)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> FloatingTextRenderer"""
        return _fife.FloatingTextRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
FloatingTextRenderer_swigregister = _fife.FloatingTextRenderer_swigregister
FloatingTextRenderer_swigregister(FloatingTextRenderer)

def FloatingTextRenderer_getInstance(*args):
  """FloatingTextRenderer_getInstance(IRendererContainer cnt) -> FloatingTextRenderer"""
  return _fife.FloatingTextRenderer_getInstance(*args)

class GenericRendererElementInfo(_object):
    """Proxy of C++ FIFE::GenericRendererElementInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererElementInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererElementInfo, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_GenericRendererElementInfo
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> GenericRendererElementInfo"""
        this = _fife.new_GenericRendererElementInfo()
        try: self.this.append(this)
        except: self.this = this
GenericRendererElementInfo_swigregister = _fife.GenericRendererElementInfo_swigregister
GenericRendererElementInfo_swigregister(GenericRendererElementInfo)

class GenericRendererLineInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererLineInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererLineInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererLineInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a) -> GenericRendererLineInfo
        """
        this = _fife.new_GenericRendererLineInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererLineInfo
    __del__ = lambda self : None;
GenericRendererLineInfo_swigregister = _fife.GenericRendererLineInfo_swigregister
GenericRendererLineInfo_swigregister(GenericRendererLineInfo)

class GenericRendererPointInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererPointInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererPointInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererPointInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, RendererNode n, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererPointInfo"""
        this = _fife.new_GenericRendererPointInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererPointInfo
    __del__ = lambda self : None;
GenericRendererPointInfo_swigregister = _fife.GenericRendererPointInfo_swigregister
GenericRendererPointInfo_swigregister(GenericRendererPointInfo)

class GenericRendererTriangleInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererTriangleInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererTriangleInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererTriangleInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode n1, RendererNode n2, RendererNode n3, 
            uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererTriangleInfo
        """
        this = _fife.new_GenericRendererTriangleInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererTriangleInfo
    __del__ = lambda self : None;
GenericRendererTriangleInfo_swigregister = _fife.GenericRendererTriangleInfo_swigregister
GenericRendererTriangleInfo_swigregister(GenericRendererTriangleInfo)

class GenericRendererQuadInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererQuadInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererQuadInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererQuadInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode n1, RendererNode n2, RendererNode n3, 
            RendererNode n4, uint8_t r, uint8_t g, uint8_t b, 
            uint8_t a) -> GenericRendererQuadInfo
        """
        this = _fife.new_GenericRendererQuadInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererQuadInfo
    __del__ = lambda self : None;
GenericRendererQuadInfo_swigregister = _fife.GenericRendererQuadInfo_swigregister
GenericRendererQuadInfo_swigregister(GenericRendererQuadInfo)

class GenericRendererVertexInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererVertexInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererVertexInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererVertexInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode center, int32_t size, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a) -> GenericRendererVertexInfo
        """
        this = _fife.new_GenericRendererVertexInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererVertexInfo
    __del__ = lambda self : None;
GenericRendererVertexInfo_swigregister = _fife.GenericRendererVertexInfo_swigregister
GenericRendererVertexInfo_swigregister(GenericRendererVertexInfo)

class GenericRendererImageInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererImageInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererImageInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererImageInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode n, ImagePtr image, bool zoomed = True) -> GenericRendererImageInfo
        __init__(self, RendererNode n, ImagePtr image) -> GenericRendererImageInfo
        """
        this = _fife.new_GenericRendererImageInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererImageInfo
    __del__ = lambda self : None;
GenericRendererImageInfo_swigregister = _fife.GenericRendererImageInfo_swigregister
GenericRendererImageInfo_swigregister(GenericRendererImageInfo)

class GenericRendererAnimationInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererAnimationInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererAnimationInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererAnimationInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode n, AnimationPtr animation, bool zoomed = True) -> GenericRendererAnimationInfo
        __init__(self, RendererNode n, AnimationPtr animation) -> GenericRendererAnimationInfo
        """
        this = _fife.new_GenericRendererAnimationInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererAnimationInfo
    __del__ = lambda self : None;
GenericRendererAnimationInfo_swigregister = _fife.GenericRendererAnimationInfo_swigregister
GenericRendererAnimationInfo_swigregister(GenericRendererAnimationInfo)

class GenericRendererTextInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererTextInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererTextInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererTextInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode n, IFont font, string text, bool zoomed = True) -> GenericRendererTextInfo
        __init__(self, RendererNode n, IFont font, string text) -> GenericRendererTextInfo
        """
        this = _fife.new_GenericRendererTextInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererTextInfo
    __del__ = lambda self : None;
GenericRendererTextInfo_swigregister = _fife.GenericRendererTextInfo_swigregister
GenericRendererTextInfo_swigregister(GenericRendererTextInfo)

class GenericRendererResizeInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererResizeInfo class"""
    __swig_setmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRendererResizeInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [GenericRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRendererResizeInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, RendererNode n, ImagePtr image, int32_t width, int32_t height, 
            bool zoomed = True) -> GenericRendererResizeInfo
        __init__(self, RendererNode n, ImagePtr image, int32_t width, int32_t height) -> GenericRendererResizeInfo
        """
        this = _fife.new_GenericRendererResizeInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererResizeInfo
    __del__ = lambda self : None;
GenericRendererResizeInfo_swigregister = _fife.GenericRendererResizeInfo_swigregister
GenericRendererResizeInfo_swigregister(GenericRendererResizeInfo)

class GenericRenderer(RendererBase):
    """Proxy of C++ FIFE::GenericRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GenericRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GenericRenderer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, RenderBackend renderbackend, int32_t position) -> GenericRenderer"""
        this = _fife.new_GenericRenderer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_GenericRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.GenericRenderer_getName(self)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> GenericRenderer"""
        return _fife.GenericRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
    def addLine(self, *args):
        """
        addLine(self, string group, RendererNode n1, RendererNode n2, uint8_t r, 
            uint8_t g, uint8_t b, uint8_t a = 255)
        addLine(self, string group, RendererNode n1, RendererNode n2, uint8_t r, 
            uint8_t g, uint8_t b)
        """
        return _fife.GenericRenderer_addLine(self, *args)

    def addPoint(self, *args):
        """
        addPoint(self, string group, RendererNode n, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addPoint(self, string group, RendererNode n, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.GenericRenderer_addPoint(self, *args)

    def addTriangle(self, *args):
        """
        addTriangle(self, string group, RendererNode n1, RendererNode n2, RendererNode n3, 
            uint8_t r, uint8_t g, uint8_t b, 
            uint8_t a = 255)
        addTriangle(self, string group, RendererNode n1, RendererNode n2, RendererNode n3, 
            uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.GenericRenderer_addTriangle(self, *args)

    def addQuad(self, *args):
        """
        addQuad(self, string group, RendererNode n1, RendererNode n2, RendererNode n3, 
            RendererNode n4, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addQuad(self, string group, RendererNode n1, RendererNode n2, RendererNode n3, 
            RendererNode n4, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.GenericRenderer_addQuad(self, *args)

    def addVertex(self, *args):
        """
        addVertex(self, string group, RendererNode n, int32_t size, uint8_t r, 
            uint8_t g, uint8_t b, uint8_t a = 255)
        addVertex(self, string group, RendererNode n, int32_t size, uint8_t r, 
            uint8_t g, uint8_t b)
        """
        return _fife.GenericRenderer_addVertex(self, *args)

    def addText(self, *args):
        """
        addText(self, string group, RendererNode n, IFont font, string text, 
            bool zoomed = True)
        addText(self, string group, RendererNode n, IFont font, string text)
        """
        return _fife.GenericRenderer_addText(self, *args)

    def addImage(self, *args):
        """
        addImage(self, string group, RendererNode n, ImagePtr image, bool zoomed = True)
        addImage(self, string group, RendererNode n, ImagePtr image)
        """
        return _fife.GenericRenderer_addImage(self, *args)

    def addAnimation(self, *args):
        """
        addAnimation(self, string group, RendererNode n, AnimationPtr animation, 
            bool zoomed = True)
        addAnimation(self, string group, RendererNode n, AnimationPtr animation)
        """
        return _fife.GenericRenderer_addAnimation(self, *args)

    def resizeImage(self, *args):
        """
        resizeImage(self, string group, RendererNode n, ImagePtr image, int32_t width, 
            int32_t height, bool zoomed = True)
        resizeImage(self, string group, RendererNode n, ImagePtr image, int32_t width, 
            int32_t height)
        """
        return _fife.GenericRenderer_resizeImage(self, *args)

    def removeAll(self, *args):
        """
        removeAll(self, string group)
        removeAll(self)
        """
        return _fife.GenericRenderer_removeAll(self, *args)

GenericRenderer_swigregister = _fife.GenericRenderer_swigregister
GenericRenderer_swigregister(GenericRenderer)

def GenericRenderer_getInstance(*args):
  """GenericRenderer_getInstance(IRendererContainer cnt) -> GenericRenderer"""
  return _fife.GenericRenderer_getInstance(*args)

class GridRenderer(RendererBase):
    """Proxy of C++ FIFE::GridRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GridRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GridRenderer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_GridRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.GridRenderer_getName(self)

    def setColor(self, *args):
        """setColor(self, Uint8 r, Uint8 g, Uint8 b)"""
        return _fife.GridRenderer_setColor(self, *args)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> GridRenderer"""
        return _fife.GridRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
GridRenderer_swigregister = _fife.GridRenderer_swigregister
GridRenderer_swigregister(GridRenderer)

def GridRenderer_getInstance(*args):
  """GridRenderer_getInstance(IRendererContainer cnt) -> GridRenderer"""
  return _fife.GridRenderer_getInstance(*args)

class InstanceRenderer(RendererBase):
    """Proxy of C++ FIFE::InstanceRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceRenderer, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_InstanceRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.InstanceRenderer_getName(self)

    def addOutlined(self, *args):
        """
        addOutlined(self, Instance instance, int32_t r, int32_t g, int32_t b, 
            int32_t width, int32_t threshold = 1)
        addOutlined(self, Instance instance, int32_t r, int32_t g, int32_t b, 
            int32_t width)
        """
        return _fife.InstanceRenderer_addOutlined(self, *args)

    def removeOutlined(self, *args):
        """removeOutlined(self, Instance instance)"""
        return _fife.InstanceRenderer_removeOutlined(self, *args)

    def removeAllOutlines(self):
        """removeAllOutlines(self)"""
        return _fife.InstanceRenderer_removeAllOutlines(self)

    def addColored(self, *args):
        """
        addColored(self, Instance instance, int32_t r, int32_t g, int32_t b, 
            int32_t a = 128)
        addColored(self, Instance instance, int32_t r, int32_t g, int32_t b)
        """
        return _fife.InstanceRenderer_addColored(self, *args)

    def removeColored(self, *args):
        """removeColored(self, Instance instance)"""
        return _fife.InstanceRenderer_removeColored(self, *args)

    def removeAllColored(self):
        """removeAllColored(self)"""
        return _fife.InstanceRenderer_removeAllColored(self)

    def addTransparentArea(self, *args):
        """
        addTransparentArea(self, Instance instance, StringList groups, uint32_t w, uint32_t h, 
            uint8_t trans, bool front = True)
        addTransparentArea(self, Instance instance, StringList groups, uint32_t w, uint32_t h, 
            uint8_t trans)
        """
        return _fife.InstanceRenderer_addTransparentArea(self, *args)

    def removeTransparentArea(self, *args):
        """removeTransparentArea(self, Instance instance)"""
        return _fife.InstanceRenderer_removeTransparentArea(self, *args)

    def removeAllTransparentAreas(self):
        """removeAllTransparentAreas(self)"""
        return _fife.InstanceRenderer_removeAllTransparentAreas(self)

    def addIgnoreLight(self, *args):
        """addIgnoreLight(self, StringList groups)"""
        return _fife.InstanceRenderer_addIgnoreLight(self, *args)

    def removeIgnoreLight(self, *args):
        """removeIgnoreLight(self, StringList groups)"""
        return _fife.InstanceRenderer_removeIgnoreLight(self, *args)

    def removeAllIgnoreLight(self):
        """removeAllIgnoreLight(self)"""
        return _fife.InstanceRenderer_removeAllIgnoreLight(self)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> InstanceRenderer"""
        return _fife.InstanceRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
    def setRemoveInterval(self, *args):
        """setRemoveInterval(self, uint32_t interval)"""
        return _fife.InstanceRenderer_setRemoveInterval(self, *args)

    def getRemoveInterval(self):
        """getRemoveInterval(self) -> uint32_t"""
        return _fife.InstanceRenderer_getRemoveInterval(self)

InstanceRenderer_swigregister = _fife.InstanceRenderer_swigregister
InstanceRenderer_swigregister(InstanceRenderer)

def InstanceRenderer_getInstance(*args):
  """InstanceRenderer_getInstance(IRendererContainer cnt) -> InstanceRenderer"""
  return _fife.InstanceRenderer_getInstance(*args)

class LightRendererElementInfo(_object):
    """Proxy of C++ FIFE::LightRendererElementInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LightRendererElementInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LightRendererElementInfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererElementInfo
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.LightRendererElementInfo_getName(self)

    def getNode(self):
        """getNode(self) -> RendererNode"""
        return _fife.LightRendererElementInfo_getNode(self)

    def getSrcBlend(self):
        """getSrcBlend(self) -> int32_t"""
        return _fife.LightRendererElementInfo_getSrcBlend(self)

    def getDstBlend(self):
        """getDstBlend(self) -> int32_t"""
        return _fife.LightRendererElementInfo_getDstBlend(self)

    def setStencil(self, *args):
        """setStencil(self, uint8_t stencil_ref)"""
        return _fife.LightRendererElementInfo_setStencil(self, *args)

    def getStencil(self):
        """getStencil(self) -> int32_t"""
        return _fife.LightRendererElementInfo_getStencil(self)

    def removeStencil(self):
        """removeStencil(self)"""
        return _fife.LightRendererElementInfo_removeStencil(self)

    def getColor(self):
        """getColor(self) -> vectoru"""
        return _fife.LightRendererElementInfo_getColor(self)

    def getRadius(self):
        """getRadius(self) -> float"""
        return _fife.LightRendererElementInfo_getRadius(self)

    def getSubdivisions(self):
        """getSubdivisions(self) -> int32_t"""
        return _fife.LightRendererElementInfo_getSubdivisions(self)

    def getXStretch(self):
        """getXStretch(self) -> float"""
        return _fife.LightRendererElementInfo_getXStretch(self)

    def getYStretch(self):
        """getYStretch(self) -> float"""
        return _fife.LightRendererElementInfo_getYStretch(self)

LightRendererElementInfo_swigregister = _fife.LightRendererElementInfo_swigregister
LightRendererElementInfo_swigregister(LightRendererElementInfo)

class LightRendererImageInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererImageInfo class"""
    __swig_setmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LightRendererImageInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LightRendererImageInfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererImageInfo
    __del__ = lambda self : None;
    def getImage(self):
        """getImage(self) -> ImagePtr"""
        return _fife.LightRendererImageInfo_getImage(self)

LightRendererImageInfo_swigregister = _fife.LightRendererImageInfo_swigregister
LightRendererImageInfo_swigregister(LightRendererImageInfo)

class LightRendererAnimationInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererAnimationInfo class"""
    __swig_setmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LightRendererAnimationInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LightRendererAnimationInfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererAnimationInfo
    __del__ = lambda self : None;
    def getAnimation(self):
        """getAnimation(self) -> AnimationPtr"""
        return _fife.LightRendererAnimationInfo_getAnimation(self)

LightRendererAnimationInfo_swigregister = _fife.LightRendererAnimationInfo_swigregister
LightRendererAnimationInfo_swigregister(LightRendererAnimationInfo)

class LightRendererSimpleLightInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererSimpleLightInfo class"""
    __swig_setmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LightRendererSimpleLightInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LightRendererSimpleLightInfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererSimpleLightInfo
    __del__ = lambda self : None;
    def getColor(self):
        """getColor(self) -> vectoru"""
        return _fife.LightRendererSimpleLightInfo_getColor(self)

    def getRadius(self):
        """getRadius(self) -> float"""
        return _fife.LightRendererSimpleLightInfo_getRadius(self)

    def getSubdivisions(self):
        """getSubdivisions(self) -> int32_t"""
        return _fife.LightRendererSimpleLightInfo_getSubdivisions(self)

    def getXStretch(self):
        """getXStretch(self) -> float"""
        return _fife.LightRendererSimpleLightInfo_getXStretch(self)

    def getYStretch(self):
        """getYStretch(self) -> float"""
        return _fife.LightRendererSimpleLightInfo_getYStretch(self)

LightRendererSimpleLightInfo_swigregister = _fife.LightRendererSimpleLightInfo_swigregister
LightRendererSimpleLightInfo_swigregister(LightRendererSimpleLightInfo)

class LightRendererResizeInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererResizeInfo class"""
    __swig_setmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LightRendererResizeInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [LightRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LightRendererResizeInfo, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererResizeInfo
    __del__ = lambda self : None;
    def getImage(self):
        """getImage(self) -> ImagePtr"""
        return _fife.LightRendererResizeInfo_getImage(self)

LightRendererResizeInfo_swigregister = _fife.LightRendererResizeInfo_swigregister
LightRendererResizeInfo_swigregister(LightRendererResizeInfo)

class LightRenderer(RendererBase):
    """Proxy of C++ FIFE::LightRenderer class"""
    __swig_setmethods__ = {}
    for _s in [RendererBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LightRenderer, name, value)
    __swig_getmethods__ = {}
    for _s in [RendererBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LightRenderer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, RenderBackend renderbackend, int32_t position) -> LightRenderer"""
        this = _fife.new_LightRenderer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_LightRenderer
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _fife.LightRenderer_getName(self)

    def getInstance(*args):
        """getInstance(IRendererContainer cnt) -> LightRenderer"""
        return _fife.LightRenderer_getInstance(*args)

    if _newclass:getInstance = staticmethod(getInstance)
    __swig_getmethods__["getInstance"] = lambda x: getInstance
    def addImage(self, *args):
        """
        addImage(self, string group, RendererNode n, ImagePtr image, int32_t src = -1, 
            int32_t dst = -1)
        addImage(self, string group, RendererNode n, ImagePtr image, int32_t src = -1)
        addImage(self, string group, RendererNode n, ImagePtr image)
        """
        return _fife.LightRenderer_addImage(self, *args)

    def addAnimation(self, *args):
        """
        addAnimation(self, string group, RendererNode n, AnimationPtr animation, 
            int32_t src = -1, int32_t dst = -1)
        addAnimation(self, string group, RendererNode n, AnimationPtr animation, 
            int32_t src = -1)
        addAnimation(self, string group, RendererNode n, AnimationPtr animation)
        """
        return _fife.LightRenderer_addAnimation(self, *args)

    def addSimpleLight(self, *args):
        """
        addSimpleLight(self, string group, RendererNode n, uint8_t intensity, float radius, 
            int32_t subdivisions, float xstretch, 
            float ystretch, uint8_t r, uint8_t g, uint8_t b, 
            int32_t src = -1, int32_t dst = -1)
        addSimpleLight(self, string group, RendererNode n, uint8_t intensity, float radius, 
            int32_t subdivisions, float xstretch, 
            float ystretch, uint8_t r, uint8_t g, uint8_t b, 
            int32_t src = -1)
        addSimpleLight(self, string group, RendererNode n, uint8_t intensity, float radius, 
            int32_t subdivisions, float xstretch, 
            float ystretch, uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.LightRenderer_addSimpleLight(self, *args)

    def resizeImage(self, *args):
        """
        resizeImage(self, string group, RendererNode n, ImagePtr image, int32_t width, 
            int32_t height, int32_t src = -1, int32_t dst = -1)
        resizeImage(self, string group, RendererNode n, ImagePtr image, int32_t width, 
            int32_t height, int32_t src = -1)
        resizeImage(self, string group, RendererNode n, ImagePtr image, int32_t width, 
            int32_t height)
        """
        return _fife.LightRenderer_resizeImage(self, *args)

    def addStencilTest(self, *args):
        """
        addStencilTest(self, string group, uint8_t stencil_ref = 0)
        addStencilTest(self, string group)
        """
        return _fife.LightRenderer_addStencilTest(self, *args)

    def removeStencilTest(self, *args):
        """removeStencilTest(self, string group)"""
        return _fife.LightRenderer_removeStencilTest(self, *args)

    def getGroups(self):
        """getGroups(self) -> StringList"""
        return _fife.LightRenderer_getGroups(self)

    def getLightInfo(self, *args):
        """getLightInfo(self, string group) -> LightRendererElementInfoVector"""
        return _fife.LightRenderer_getLightInfo(self, *args)

    def removeAll(self, *args):
        """
        removeAll(self, string group)
        removeAll(self)
        """
        return _fife.LightRenderer_removeAll(self, *args)

LightRenderer_swigregister = _fife.LightRenderer_swigregister
LightRenderer_swigregister(LightRenderer)

def LightRenderer_getInstance(*args):
  """LightRenderer_getInstance(IRendererContainer cnt) -> LightRenderer"""
  return _fife.LightRenderer_getInstance(*args)

class LightRendererElementInfoVector(_object):
    """Proxy of C++ std::vector<(p.FIFE::LightRendererElementInfo)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LightRendererElementInfoVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LightRendererElementInfoVector, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> SwigPyIterator"""
        return _fife.LightRendererElementInfoVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _fife.LightRendererElementInfoVector___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _fife.LightRendererElementInfoVector___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _fife.LightRendererElementInfoVector___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _fife.LightRendererElementInfoVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> LightRendererElementInfoVector"""
        return _fife.LightRendererElementInfoVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, LightRendererElementInfoVector v)"""
        return _fife.LightRendererElementInfoVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _fife.LightRendererElementInfoVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _fife.LightRendererElementInfoVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> LightRendererElementInfoVector
        __getitem__(self, difference_type i) -> value_type
        """
        return _fife.LightRendererElementInfoVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, LightRendererElementInfoVector v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _fife.LightRendererElementInfoVector___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _fife.LightRendererElementInfoVector_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _fife.LightRendererElementInfoVector_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _fife.LightRendererElementInfoVector_size(self)

    def clear(self):
        """clear(self)"""
        return _fife.LightRendererElementInfoVector_clear(self)

    def swap(self, *args):
        """swap(self, LightRendererElementInfoVector v)"""
        return _fife.LightRendererElementInfoVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _fife.LightRendererElementInfoVector_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _fife.LightRendererElementInfoVector_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _fife.LightRendererElementInfoVector_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _fife.LightRendererElementInfoVector_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _fife.LightRendererElementInfoVector_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _fife.LightRendererElementInfoVector_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _fife.LightRendererElementInfoVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> LightRendererElementInfoVector
        __init__(self, LightRendererElementInfoVector arg0) -> LightRendererElementInfoVector
        __init__(self, size_type size) -> LightRendererElementInfoVector
        __init__(self, size_type size, value_type value) -> LightRendererElementInfoVector
        """
        this = _fife.new_LightRendererElementInfoVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _fife.LightRendererElementInfoVector_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _fife.LightRendererElementInfoVector_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _fife.LightRendererElementInfoVector_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _fife.LightRendererElementInfoVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _fife.LightRendererElementInfoVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _fife.LightRendererElementInfoVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _fife.LightRendererElementInfoVector_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _fife.LightRendererElementInfoVector_capacity(self)

    __swig_destroy__ = _fife.delete_LightRendererElementInfoVector
    __del__ = lambda self : None;
LightRendererElementInfoVector_swigregister = _fife.LightRendererElementInfoVector_swigregister
LightRendererElementInfoVector_swigregister(LightRendererElementInfoVector)

class OffRendererElementInfo(_object):
    """Proxy of C++ FIFE::OffRendererElementInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererElementInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererElementInfo, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_OffRendererElementInfo
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> OffRendererElementInfo"""
        this = _fife.new_OffRendererElementInfo()
        try: self.this.append(this)
        except: self.this = this
OffRendererElementInfo_swigregister = _fife.OffRendererElementInfo_swigregister
OffRendererElementInfo_swigregister(OffRendererElementInfo)

class OffRendererLineInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererLineInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererLineInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererLineInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b, 
            uint8_t a) -> OffRendererLineInfo
        """
        this = _fife.new_OffRendererLineInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererLineInfo
    __del__ = lambda self : None;
OffRendererLineInfo_swigregister = _fife.OffRendererLineInfo_swigregister
OffRendererLineInfo_swigregister(OffRendererLineInfo)

class OffRendererPointInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererPointInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererPointInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererPointInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Point n, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererPointInfo"""
        this = _fife.new_OffRendererPointInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererPointInfo
    __del__ = lambda self : None;
OffRendererPointInfo_swigregister = _fife.OffRendererPointInfo_swigregister
OffRendererPointInfo_swigregister(OffRendererPointInfo)

class OffRendererTriangleInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererTriangleInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererTriangleInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererTriangleInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a) -> OffRendererTriangleInfo
        """
        this = _fife.new_OffRendererTriangleInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererTriangleInfo
    __del__ = lambda self : None;
OffRendererTriangleInfo_swigregister = _fife.OffRendererTriangleInfo_swigregister
OffRendererTriangleInfo_swigregister(OffRendererTriangleInfo)

class OffRendererQuadInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererQuadInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererQuadInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererQuadInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Point n1, Point n2, Point n3, Point n4, uint8_t r, 
            uint8_t g, uint8_t b, uint8_t a) -> OffRendererQuadInfo
        """
        this = _fife.new_OffRendererQuadInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererQuadInfo
    __del__ = lambda self : None;
OffRendererQuadInfo_swigregister = _fife.OffRendererQuadInfo_swigregister
OffRendererQuadInfo_swigregister(OffRendererQuadInfo)

class OffRendererVertexInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererVertexInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererVertexInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererVertexInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Point center, int32_t size, uint8_t r, uint8_t g, uint8_t b, 
            uint8_t a) -> OffRendererVertexInfo
        """
        this = _fife.new_OffRendererVertexInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererVertexInfo
    __del__ = lambda self : None;
OffRendererVertexInfo_swigregister = _fife.OffRendererVertexInfo_swigregister
OffRendererVertexInfo_swigregister(OffRendererVertexInfo)

class OffRendererImageInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererImageInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererImageInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererImageInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Point n, ImagePtr image) -> OffRendererImageInfo"""
        this = _fife.new_OffRendererImageInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererImageInfo
    __del__ = lambda self : None;
OffRendererImageInfo_swigregister = _fife.OffRendererImageInfo_swigregister
OffRendererImageInfo_swigregister(OffRendererImageInfo)

class OffRendererAnimationInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererAnimationInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererAnimationInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererAnimationInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Point n, AnimationPtr animation) -> OffRendererAnimationInfo"""
        this = _fife.new_OffRendererAnimationInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererAnimationInfo
    __del__ = lambda self : None;
OffRendererAnimationInfo_swigregister = _fife.OffRendererAnimationInfo_swigregister
OffRendererAnimationInfo_swigregister(OffRendererAnimationInfo)

class OffRendererTextInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererTextInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererTextInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererTextInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Point n, IFont font, string text) -> OffRendererTextInfo"""
        this = _fife.new_OffRendererTextInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererTextInfo
    __del__ = lambda self : None;
OffRendererTextInfo_swigregister = _fife.OffRendererTextInfo_swigregister
OffRendererTextInfo_swigregister(OffRendererTextInfo)

class OffRendererResizeInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererResizeInfo class"""
    __swig_setmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRendererResizeInfo, name, value)
    __swig_getmethods__ = {}
    for _s in [OffRendererElementInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OffRendererResizeInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Point n, ImagePtr image, int32_t width, int32_t height) -> OffRendererResizeInfo"""
        this = _fife.new_OffRendererResizeInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRendererResizeInfo
    __del__ = lambda self : None;
OffRendererResizeInfo_swigregister = _fife.OffRendererResizeInfo_swigregister
OffRendererResizeInfo_swigregister(OffRendererResizeInfo)

class OffRenderer(_object):
    """Proxy of C++ FIFE::OffRenderer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, OffRenderer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, OffRenderer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, RenderBackend renderbackend) -> OffRenderer"""
        this = _fife.new_OffRenderer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_OffRenderer
    __del__ = lambda self : None;
    def setEnabled(self, *args):
        """setEnabled(self, bool enabled)"""
        return _fife.OffRenderer_setEnabled(self, *args)

    def isEnabled(self):
        """isEnabled(self) -> bool"""
        return _fife.OffRenderer_isEnabled(self)

    def setClipArea(self, *args):
        """setClipArea(self, Rect area)"""
        return _fife.OffRenderer_setClipArea(self, *args)

    def getClipArea(self):
        """getClipArea(self) -> Rect"""
        return _fife.OffRenderer_getClipArea(self)

    def addLine(self, *args):
        """
        addLine(self, string group, Point n1, Point n2, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addLine(self, string group, Point n1, Point n2, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.OffRenderer_addLine(self, *args)

    def addPoint(self, *args):
        """
        addPoint(self, string group, Point n, uint8_t r, uint8_t g, uint8_t b, 
            uint8_t a = 255)
        addPoint(self, string group, Point n, uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.OffRenderer_addPoint(self, *args)

    def addTriangle(self, *args):
        """
        addTriangle(self, string group, Point n1, Point n2, Point n3, uint8_t r, 
            uint8_t g, uint8_t b, uint8_t a = 255)
        addTriangle(self, string group, Point n1, Point n2, Point n3, uint8_t r, 
            uint8_t g, uint8_t b)
        """
        return _fife.OffRenderer_addTriangle(self, *args)

    def addQuad(self, *args):
        """
        addQuad(self, string group, Point n1, Point n2, Point n3, Point n4, 
            uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
        addQuad(self, string group, Point n1, Point n2, Point n3, Point n4, 
            uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.OffRenderer_addQuad(self, *args)

    def addVertex(self, *args):
        """
        addVertex(self, string group, Point n, int32_t size, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addVertex(self, string group, Point n, int32_t size, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.OffRenderer_addVertex(self, *args)

    def addText(self, *args):
        """addText(self, string group, Point n, IFont font, string text)"""
        return _fife.OffRenderer_addText(self, *args)

    def addImage(self, *args):
        """addImage(self, string group, Point n, ImagePtr image)"""
        return _fife.OffRenderer_addImage(self, *args)

    def addAnimation(self, *args):
        """addAnimation(self, string group, Point n, AnimationPtr animation)"""
        return _fife.OffRenderer_addAnimation(self, *args)

    def resizeImage(self, *args):
        """
        resizeImage(self, string group, Point n, ImagePtr image, int32_t width, 
            int32_t height)
        """
        return _fife.OffRenderer_resizeImage(self, *args)

    def removeAll(self, *args):
        """
        removeAll(self, string group)
        removeAll(self)
        """
        return _fife.OffRenderer_removeAll(self, *args)

OffRenderer_swigregister = _fife.OffRenderer_swigregister
OffRenderer_swigregister(OffRenderer)

class RenderTarget(_object):
    """Proxy of C++ FIFE::RenderTarget class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RenderTarget, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RenderTarget, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RenderTarget
    __del__ = lambda self : None;
    def addLine(self, *args):
        """
        addLine(self, string group, Point n1, Point n2, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addLine(self, string group, Point n1, Point n2, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.RenderTarget_addLine(self, *args)

    def addPoint(self, *args):
        """
        addPoint(self, string group, Point n, uint8_t r, uint8_t g, uint8_t b, 
            uint8_t a = 255)
        addPoint(self, string group, Point n, uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.RenderTarget_addPoint(self, *args)

    def addTriangle(self, *args):
        """
        addTriangle(self, string group, Point n1, Point n2, Point n3, uint8_t r, 
            uint8_t g, uint8_t b, uint8_t a = 255)
        addTriangle(self, string group, Point n1, Point n2, Point n3, uint8_t r, 
            uint8_t g, uint8_t b)
        """
        return _fife.RenderTarget_addTriangle(self, *args)

    def addQuad(self, *args):
        """
        addQuad(self, string group, Point n1, Point n2, Point n3, Point n4, 
            uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
        addQuad(self, string group, Point n1, Point n2, Point n3, Point n4, 
            uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.RenderTarget_addQuad(self, *args)

    def addVertex(self, *args):
        """
        addVertex(self, string group, Point n, int32_t size, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addVertex(self, string group, Point n, int32_t size, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.RenderTarget_addVertex(self, *args)

    def addText(self, *args):
        """addText(self, string group, Point n, IFont font, string text)"""
        return _fife.RenderTarget_addText(self, *args)

    def addImage(self, *args):
        """addImage(self, string group, Point n, ImagePtr image)"""
        return _fife.RenderTarget_addImage(self, *args)

    def addAnimation(self, *args):
        """addAnimation(self, string group, Point n, AnimationPtr animation)"""
        return _fife.RenderTarget_addAnimation(self, *args)

    def resizeImage(self, *args):
        """
        resizeImage(self, string group, Point n, ImagePtr image, int32_t width, 
            int32_t height)
        """
        return _fife.RenderTarget_resizeImage(self, *args)

    def removeAll(self, *args):
        """
        removeAll(self, string group)
        removeAll(self)
        """
        return _fife.RenderTarget_removeAll(self, *args)

    def render(self):
        """render(self)"""
        return _fife.RenderTarget_render(self)

    def getTarget(self):
        """getTarget(self) -> ImagePtr"""
        return _fife.RenderTarget_getTarget(self)

RenderTarget_swigregister = _fife.RenderTarget_swigregister
RenderTarget_swigregister(RenderTarget)

class SharedRenderTargetPointer(_object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::RenderTarget)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedRenderTargetPointer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedRenderTargetPointer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SharedRenderTargetPointer
        __init__(self, SharedRenderTargetPointer rhs) -> SharedRenderTargetPointer
        """
        this = _fife.new_SharedRenderTargetPointer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_SharedRenderTargetPointer
    __del__ = lambda self : None;
    def __ref__(self):
        """__ref__(self) -> RenderTarget"""
        return _fife.SharedRenderTargetPointer___ref__(self)

    def __deref__(self):
        """__deref__(self) -> RenderTarget"""
        return _fife.SharedRenderTargetPointer___deref__(self)

    def get(self):
        """get(self) -> RenderTarget"""
        return _fife.SharedRenderTargetPointer_get(self)

    def reset(self, ptr = None):
        """
        reset(self, RenderTarget ptr = None)
        reset(self)
        """
        return _fife.SharedRenderTargetPointer_reset(self, ptr)

    def useCount(self):
        """useCount(self) -> uint32_t"""
        return _fife.SharedRenderTargetPointer_useCount(self)

    def useCountPtr(self):
        """useCountPtr(self) -> uint32_t"""
        return _fife.SharedRenderTargetPointer_useCountPtr(self)

    def unique(self):
        """unique(self) -> bool"""
        return _fife.SharedRenderTargetPointer_unique(self)

    def __nonzero__(self):
        return _fife.SharedRenderTargetPointer___nonzero__(self)
    __bool__ = __nonzero__


    def addLine(self, *args):
        """
        addLine(self, string group, Point n1, Point n2, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addLine(self, string group, Point n1, Point n2, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.SharedRenderTargetPointer_addLine(self, *args)

    def addPoint(self, *args):
        """
        addPoint(self, string group, Point n, uint8_t r, uint8_t g, uint8_t b, 
            uint8_t a = 255)
        addPoint(self, string group, Point n, uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.SharedRenderTargetPointer_addPoint(self, *args)

    def addTriangle(self, *args):
        """
        addTriangle(self, string group, Point n1, Point n2, Point n3, uint8_t r, 
            uint8_t g, uint8_t b, uint8_t a = 255)
        addTriangle(self, string group, Point n1, Point n2, Point n3, uint8_t r, 
            uint8_t g, uint8_t b)
        """
        return _fife.SharedRenderTargetPointer_addTriangle(self, *args)

    def addQuad(self, *args):
        """
        addQuad(self, string group, Point n1, Point n2, Point n3, Point n4, 
            uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255)
        addQuad(self, string group, Point n1, Point n2, Point n3, Point n4, 
            uint8_t r, uint8_t g, uint8_t b)
        """
        return _fife.SharedRenderTargetPointer_addQuad(self, *args)

    def addVertex(self, *args):
        """
        addVertex(self, string group, Point n, int32_t size, uint8_t r, uint8_t g, 
            uint8_t b, uint8_t a = 255)
        addVertex(self, string group, Point n, int32_t size, uint8_t r, uint8_t g, 
            uint8_t b)
        """
        return _fife.SharedRenderTargetPointer_addVertex(self, *args)

    def addText(self, *args):
        """addText(self, string group, Point n, IFont font, string text)"""
        return _fife.SharedRenderTargetPointer_addText(self, *args)

    def addImage(self, *args):
        """addImage(self, string group, Point n, ImagePtr image)"""
        return _fife.SharedRenderTargetPointer_addImage(self, *args)

    def addAnimation(self, *args):
        """addAnimation(self, string group, Point n, AnimationPtr animation)"""
        return _fife.SharedRenderTargetPointer_addAnimation(self, *args)

    def resizeImage(self, *args):
        """
        resizeImage(self, string group, Point n, ImagePtr image, int32_t width, 
            int32_t height)
        """
        return _fife.SharedRenderTargetPointer_resizeImage(self, *args)

    def removeAll(self, *args):
        """
        removeAll(self, string group)
        removeAll(self)
        """
        return _fife.SharedRenderTargetPointer_removeAll(self, *args)

    def render(self):
        """render(self)"""
        return _fife.SharedRenderTargetPointer_render(self)

    def getTarget(self):
        """getTarget(self) -> ImagePtr"""
        return _fife.SharedRenderTargetPointer_getTarget(self)

SharedRenderTargetPointer_swigregister = _fife.SharedRenderTargetPointer_swigregister
SharedRenderTargetPointer_swigregister(SharedRenderTargetPointer)

class TargetRenderer(_object):
    """Proxy of C++ FIFE::TargetRenderer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TargetRenderer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TargetRenderer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, RenderBackend renderbackend) -> TargetRenderer"""
        this = _fife.new_TargetRenderer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _fife.delete_TargetRenderer
    __del__ = lambda self : None;
    def createRenderTarget(self, *args):
        """
        createRenderTarget(self, string name, uint32_t width, uint32_t height) -> RenderTargetPtr
        createRenderTarget(self, ImagePtr image) -> RenderTargetPtr
        """
        return _fife.TargetRenderer_createRenderTarget(self, *args)

    def setRenderTarget(self, *args):
        """
        setRenderTarget(self, string targetname, bool discard, int32_t ndraws = 0)
        setRenderTarget(self, string targetname, bool discard)
        """
        return _fife.TargetRenderer_setRenderTarget(self, *args)

    def render(self):
        """render(self)"""
        return _fife.TargetRenderer_render(self)

TargetRenderer_swigregister = _fife.TargetRenderer_swigregister
TargetRenderer_swigregister(TargetRenderer)

class Visual2DGfx(_object):
    """Proxy of C++ FIFE::Visual2DGfx class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Visual2DGfx, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Visual2DGfx, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Visual2DGfx
    __del__ = lambda self : None;
Visual2DGfx_swigregister = _fife.Visual2DGfx_swigregister
Visual2DGfx_swigregister(Visual2DGfx)

class ObjectVisual(Visual2DGfx):
    """Proxy of C++ FIFE::ObjectVisual class"""
    __swig_setmethods__ = {}
    for _s in [Visual2DGfx]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ObjectVisual, name, value)
    __swig_getmethods__ = {}
    for _s in [Visual2DGfx]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ObjectVisual, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def create(*args):
        """create(Object object) -> ObjectVisual"""
        return _fife.ObjectVisual_create(*args)

    if _newclass:create = staticmethod(create)
    __swig_getmethods__["create"] = lambda x: create
    __swig_destroy__ = _fife.delete_ObjectVisual
    __del__ = lambda self : None;
    def addStaticImage(self, *args):
        """addStaticImage(self, uint32_t angle, int32_t image_index)"""
        return _fife.ObjectVisual_addStaticImage(self, *args)

    def getStaticImageIndexByAngle(self, *args):
        """getStaticImageIndexByAngle(self, int32_t angle) -> int32_t"""
        return _fife.ObjectVisual_getStaticImageIndexByAngle(self, *args)

    def getClosestMatchingAngle(self, *args):
        """getClosestMatchingAngle(self, int32_t angle) -> int32_t"""
        return _fife.ObjectVisual_getClosestMatchingAngle(self, *args)

    def getStaticImageAngles(self):
        """getStaticImageAngles(self)"""
        return _fife.ObjectVisual_getStaticImageAngles(self)

ObjectVisual_swigregister = _fife.ObjectVisual_swigregister
ObjectVisual_swigregister(ObjectVisual)

def ObjectVisual_create(*args):
  """ObjectVisual_create(Object object) -> ObjectVisual"""
  return _fife.ObjectVisual_create(*args)

class InstanceVisual(Visual2DGfx):
    """Proxy of C++ FIFE::InstanceVisual class"""
    __swig_setmethods__ = {}
    for _s in [Visual2DGfx]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceVisual, name, value)
    __swig_getmethods__ = {}
    for _s in [Visual2DGfx]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceVisual, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def create(*args):
        """create(Instance instance) -> InstanceVisual"""
        return _fife.InstanceVisual_create(*args)

    if _newclass:create = staticmethod(create)
    __swig_getmethods__["create"] = lambda x: create
    __swig_destroy__ = _fife.delete_InstanceVisual
    __del__ = lambda self : None;
    def setTransparency(self, *args):
        """setTransparency(self, uint8_t transparency)"""
        return _fife.InstanceVisual_setTransparency(self, *args)

    def getTransparency(self):
        """getTransparency(self) -> uint8_t"""
        return _fife.InstanceVisual_getTransparency(self)

    def setVisible(self, *args):
        """setVisible(self, bool visible)"""
        return _fife.InstanceVisual_setVisible(self, *args)

    def isVisible(self):
        """isVisible(self) -> bool"""
        return _fife.InstanceVisual_isVisible(self)

    def setStackPosition(self, *args):
        """setStackPosition(self, int32_t stackposition)"""
        return _fife.InstanceVisual_setStackPosition(self, *args)

    def getStackPosition(self):
        """getStackPosition(self) -> int32_t"""
        return _fife.InstanceVisual_getStackPosition(self)

InstanceVisual_swigregister = _fife.InstanceVisual_swigregister
InstanceVisual_swigregister(InstanceVisual)

def InstanceVisual_create(*args):
  """InstanceVisual_create(Instance instance) -> InstanceVisual"""
  return _fife.InstanceVisual_create(*args)

class ActionVisual(Visual2DGfx):
    """Proxy of C++ FIFE::ActionVisual class"""
    __swig_setmethods__ = {}
    for _s in [Visual2DGfx]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ActionVisual, name, value)
    __swig_getmethods__ = {}
    for _s in [Visual2DGfx]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ActionVisual, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def create(*args):
        """create(Action action) -> ActionVisual"""
        return _fife.ActionVisual_create(*args)

    if _newclass:create = staticmethod(create)
    __swig_getmethods__["create"] = lambda x: create
    __swig_destroy__ = _fife.delete_ActionVisual
    __del__ = lambda self : None;
    def addAnimation(self, *args):
        """addAnimation(self, uint32_t angle, AnimationPtr animationptr)"""
        return _fife.ActionVisual_addAnimation(self, *args)

    def getAnimationByAngle(self, *args):
        """getAnimationByAngle(self, int32_t angle) -> AnimationPtr"""
        return _fife.ActionVisual_getAnimationByAngle(self, *args)

    def getActionImageAngles(self):
        """getActionImageAngles(self)"""
        return _fife.ActionVisual_getActionImageAngles(self)

ActionVisual_swigregister = _fife.ActionVisual_swigregister
ActionVisual_swigregister(ActionVisual)

def ActionVisual_create(*args):
  """ActionVisual_create(Action action) -> ActionVisual"""
  return _fife.ActionVisual_create(*args)



