# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (3, 0, 0):
    new_instancemethod = lambda func, inst, cls: _fife.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_fife')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_fife')
    _fife = swig_import_helper()
    del swig_import_helper
elif _swig_python_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
        try:
            _mod = imp.load_module('_fife', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _fife = swig_import_helper()
    del swig_import_helper
else:
    import _fife
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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):
        object.__setattr__(self, 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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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


def _swig_setattr_nondynamic_method(set):
    def set_attr(self, name, value):
        if (name == "thisown"):
            return self.this.own(value)
        if hasattr(self, name) or (name == "this"):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


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


class SwigPyIterator(object):
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

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

import fife.fifechan
class StringVector(object):
    """Proxy of C++ std::vector<(std::string)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(StringVector self) -> SwigPyIterator"""
        return _fife.StringVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


    def __len__(self):
        """__len__(StringVector self) -> std::vector< std::string >::size_type"""
        return _fife.StringVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> StringVector"""
        return _fife.StringVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        __setslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, StringVector v)
        """
        return _fife.StringVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _fife.StringVector___delslice__(self, i, j)


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


    def __getitem__(self, *args):
        """
        __getitem__(StringVector self, PySliceObject * slice) -> StringVector
        __getitem__(StringVector self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _fife.StringVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(StringVector self, PySliceObject * slice, StringVector v)
        __setitem__(StringVector self, PySliceObject * slice)
        __setitem__(StringVector self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _fife.StringVector___setitem__(self, *args)


    def pop(self):
        """pop(StringVector self) -> std::vector< std::string >::value_type"""
        return _fife.StringVector_pop(self)


    def append(self, x):
        """append(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _fife.StringVector_append(self, x)


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


    def size(self):
        """size(StringVector self) -> std::vector< std::string >::size_type"""
        return _fife.StringVector_size(self)


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


    def begin(self):
        """begin(StringVector self) -> std::vector< std::string >::iterator"""
        return _fife.StringVector_begin(self)


    def end(self):
        """end(StringVector self) -> std::vector< std::string >::iterator"""
        return _fife.StringVector_end(self)


    def rbegin(self):
        """rbegin(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _fife.StringVector_rbegin(self)


    def rend(self):
        """rend(StringVector self) -> std::vector< std::string >::reverse_iterator"""
        return _fife.StringVector_rend(self)


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


    def get_allocator(self):
        """get_allocator(StringVector self) -> std::vector< std::string >::allocator_type"""
        return _fife.StringVector_get_allocator(self)


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


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


    def __init__(self, *args):
        """
        __init__(std::vector<(std::string)> self) -> StringVector
        __init__(std::vector<(std::string)> self, StringVector arg2) -> StringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> StringVector
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> StringVector
        """
        _fife.StringVector_swiginit(self, _fife.new_StringVector(*args))

    def push_back(self, x):
        """push_back(StringVector self, std::vector< std::string >::value_type const & x)"""
        return _fife.StringVector_push_back(self, x)


    def front(self):
        """front(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _fife.StringVector_front(self)


    def back(self):
        """back(StringVector self) -> std::vector< std::string >::value_type const &"""
        return _fife.StringVector_back(self)


    def assign(self, n, x):
        """assign(StringVector self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _fife.StringVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(StringVector self, std::vector< std::string >::size_type new_size)
        resize(StringVector self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _fife.StringVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(StringVector self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)
        """
        return _fife.StringVector_insert(self, *args)


    def reserve(self, n):
        """reserve(StringVector self, std::vector< std::string >::size_type n)"""
        return _fife.StringVector_reserve(self, n)


    def capacity(self):
        """capacity(StringVector self) -> std::vector< std::string >::size_type"""
        return _fife.StringVector_capacity(self)

    __swig_destroy__ = _fife.delete_StringVector
StringVector.iterator = new_instancemethod(_fife.StringVector_iterator, None, StringVector)
StringVector.__nonzero__ = new_instancemethod(_fife.StringVector___nonzero__, None, StringVector)
StringVector.__bool__ = new_instancemethod(_fife.StringVector___bool__, None, StringVector)
StringVector.__len__ = new_instancemethod(_fife.StringVector___len__, None, StringVector)
StringVector.__getslice__ = new_instancemethod(_fife.StringVector___getslice__, None, StringVector)
StringVector.__setslice__ = new_instancemethod(_fife.StringVector___setslice__, None, StringVector)
StringVector.__delslice__ = new_instancemethod(_fife.StringVector___delslice__, None, StringVector)
StringVector.__delitem__ = new_instancemethod(_fife.StringVector___delitem__, None, StringVector)
StringVector.__getitem__ = new_instancemethod(_fife.StringVector___getitem__, None, StringVector)
StringVector.__setitem__ = new_instancemethod(_fife.StringVector___setitem__, None, StringVector)
StringVector.pop = new_instancemethod(_fife.StringVector_pop, None, StringVector)
StringVector.append = new_instancemethod(_fife.StringVector_append, None, StringVector)
StringVector.empty = new_instancemethod(_fife.StringVector_empty, None, StringVector)
StringVector.size = new_instancemethod(_fife.StringVector_size, None, StringVector)
StringVector.swap = new_instancemethod(_fife.StringVector_swap, None, StringVector)
StringVector.begin = new_instancemethod(_fife.StringVector_begin, None, StringVector)
StringVector.end = new_instancemethod(_fife.StringVector_end, None, StringVector)
StringVector.rbegin = new_instancemethod(_fife.StringVector_rbegin, None, StringVector)
StringVector.rend = new_instancemethod(_fife.StringVector_rend, None, StringVector)
StringVector.clear = new_instancemethod(_fife.StringVector_clear, None, StringVector)
StringVector.get_allocator = new_instancemethod(_fife.StringVector_get_allocator, None, StringVector)
StringVector.pop_back = new_instancemethod(_fife.StringVector_pop_back, None, StringVector)
StringVector.erase = new_instancemethod(_fife.StringVector_erase, None, StringVector)
StringVector.push_back = new_instancemethod(_fife.StringVector_push_back, None, StringVector)
StringVector.front = new_instancemethod(_fife.StringVector_front, None, StringVector)
StringVector.back = new_instancemethod(_fife.StringVector_back, None, StringVector)
StringVector.assign = new_instancemethod(_fife.StringVector_assign, None, StringVector)
StringVector.resize = new_instancemethod(_fife.StringVector_resize, None, StringVector)
StringVector.insert = new_instancemethod(_fife.StringVector_insert, None, StringVector)
StringVector.reserve = new_instancemethod(_fife.StringVector_reserve, None, StringVector)
StringVector.capacity = new_instancemethod(_fife.StringVector_capacity, None, StringVector)
StringVector_swigregister = _fife.StringVector_swigregister
StringVector_swigregister(StringVector)

class UintVector(object):
    """Proxy of C++ std::vector<(uint32_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(UintVector self) -> SwigPyIterator"""
        return _fife.UintVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


    def __setslice__(self, *args):
        """
        __setslice__(UintVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)
        __setslice__(UintVector 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, i, j):
        """__delslice__(UintVector self, std::vector< unsigned int >::difference_type i, std::vector< unsigned int >::difference_type j)"""
        return _fife.UintVector___delslice__(self, i, j)


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


    def erase(self, *args):
        """
        erase(UintVector self, std::vector< unsigned int >::iterator pos) -> std::vector< unsigned int >::iterator
        erase(UintVector 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__(std::vector<(uint32_t)> self) -> UintVector
        __init__(std::vector<(uint32_t)> self, UintVector arg2) -> UintVector
        __init__(std::vector<(uint32_t)> self, std::vector< unsigned int >::size_type size) -> UintVector
        __init__(std::vector<(uint32_t)> self, std::vector< unsigned int >::size_type size, std::vector< unsigned int >::value_type const & value) -> UintVector
        """
        _fife.UintVector_swiginit(self, _fife.new_UintVector(*args))

    def push_back(self, x):
        """push_back(UintVector self, std::vector< unsigned int >::value_type const & x)"""
        return _fife.UintVector_push_back(self, x)


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


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


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


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


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


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


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

    __swig_destroy__ = _fife.delete_UintVector
UintVector.iterator = new_instancemethod(_fife.UintVector_iterator, None, UintVector)
UintVector.__nonzero__ = new_instancemethod(_fife.UintVector___nonzero__, None, UintVector)
UintVector.__bool__ = new_instancemethod(_fife.UintVector___bool__, None, UintVector)
UintVector.__len__ = new_instancemethod(_fife.UintVector___len__, None, UintVector)
UintVector.__getslice__ = new_instancemethod(_fife.UintVector___getslice__, None, UintVector)
UintVector.__setslice__ = new_instancemethod(_fife.UintVector___setslice__, None, UintVector)
UintVector.__delslice__ = new_instancemethod(_fife.UintVector___delslice__, None, UintVector)
UintVector.__delitem__ = new_instancemethod(_fife.UintVector___delitem__, None, UintVector)
UintVector.__getitem__ = new_instancemethod(_fife.UintVector___getitem__, None, UintVector)
UintVector.__setitem__ = new_instancemethod(_fife.UintVector___setitem__, None, UintVector)
UintVector.pop = new_instancemethod(_fife.UintVector_pop, None, UintVector)
UintVector.append = new_instancemethod(_fife.UintVector_append, None, UintVector)
UintVector.empty = new_instancemethod(_fife.UintVector_empty, None, UintVector)
UintVector.size = new_instancemethod(_fife.UintVector_size, None, UintVector)
UintVector.swap = new_instancemethod(_fife.UintVector_swap, None, UintVector)
UintVector.begin = new_instancemethod(_fife.UintVector_begin, None, UintVector)
UintVector.end = new_instancemethod(_fife.UintVector_end, None, UintVector)
UintVector.rbegin = new_instancemethod(_fife.UintVector_rbegin, None, UintVector)
UintVector.rend = new_instancemethod(_fife.UintVector_rend, None, UintVector)
UintVector.clear = new_instancemethod(_fife.UintVector_clear, None, UintVector)
UintVector.get_allocator = new_instancemethod(_fife.UintVector_get_allocator, None, UintVector)
UintVector.pop_back = new_instancemethod(_fife.UintVector_pop_back, None, UintVector)
UintVector.erase = new_instancemethod(_fife.UintVector_erase, None, UintVector)
UintVector.push_back = new_instancemethod(_fife.UintVector_push_back, None, UintVector)
UintVector.front = new_instancemethod(_fife.UintVector_front, None, UintVector)
UintVector.back = new_instancemethod(_fife.UintVector_back, None, UintVector)
UintVector.assign = new_instancemethod(_fife.UintVector_assign, None, UintVector)
UintVector.resize = new_instancemethod(_fife.UintVector_resize, None, UintVector)
UintVector.insert = new_instancemethod(_fife.UintVector_insert, None, UintVector)
UintVector.reserve = new_instancemethod(_fife.UintVector_reserve, None, UintVector)
UintVector.capacity = new_instancemethod(_fife.UintVector_capacity, None, UintVector)
UintVector_swigregister = _fife.UintVector_swigregister
UintVector_swigregister(UintVector)

class IntVector(object):
    """Proxy of C++ std::vector<(int32_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(IntVector self) -> SwigPyIterator"""
        return _fife.IntVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


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


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


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


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


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


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


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


    def append(self, x):
        """append(IntVector self, std::vector< int >::value_type const & x)"""
        return _fife.IntVector_append(self, x)


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


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


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


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


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


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


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


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


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


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


    def erase(self, *args):
        """
        erase(IntVector self, std::vector< int >::iterator pos) -> std::vector< int >::iterator
        erase(IntVector 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__(std::vector<(int32_t)> self) -> IntVector
        __init__(std::vector<(int32_t)> self, IntVector arg2) -> IntVector
        __init__(std::vector<(int32_t)> self, std::vector< int >::size_type size) -> IntVector
        __init__(std::vector<(int32_t)> self, std::vector< int >::size_type size, std::vector< int >::value_type const & value) -> IntVector
        """
        _fife.IntVector_swiginit(self, _fife.new_IntVector(*args))

    def push_back(self, x):
        """push_back(IntVector self, std::vector< int >::value_type const & x)"""
        return _fife.IntVector_push_back(self, x)


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


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


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


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


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


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


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

    __swig_destroy__ = _fife.delete_IntVector
IntVector.iterator = new_instancemethod(_fife.IntVector_iterator, None, IntVector)
IntVector.__nonzero__ = new_instancemethod(_fife.IntVector___nonzero__, None, IntVector)
IntVector.__bool__ = new_instancemethod(_fife.IntVector___bool__, None, IntVector)
IntVector.__len__ = new_instancemethod(_fife.IntVector___len__, None, IntVector)
IntVector.__getslice__ = new_instancemethod(_fife.IntVector___getslice__, None, IntVector)
IntVector.__setslice__ = new_instancemethod(_fife.IntVector___setslice__, None, IntVector)
IntVector.__delslice__ = new_instancemethod(_fife.IntVector___delslice__, None, IntVector)
IntVector.__delitem__ = new_instancemethod(_fife.IntVector___delitem__, None, IntVector)
IntVector.__getitem__ = new_instancemethod(_fife.IntVector___getitem__, None, IntVector)
IntVector.__setitem__ = new_instancemethod(_fife.IntVector___setitem__, None, IntVector)
IntVector.pop = new_instancemethod(_fife.IntVector_pop, None, IntVector)
IntVector.append = new_instancemethod(_fife.IntVector_append, None, IntVector)
IntVector.empty = new_instancemethod(_fife.IntVector_empty, None, IntVector)
IntVector.size = new_instancemethod(_fife.IntVector_size, None, IntVector)
IntVector.swap = new_instancemethod(_fife.IntVector_swap, None, IntVector)
IntVector.begin = new_instancemethod(_fife.IntVector_begin, None, IntVector)
IntVector.end = new_instancemethod(_fife.IntVector_end, None, IntVector)
IntVector.rbegin = new_instancemethod(_fife.IntVector_rbegin, None, IntVector)
IntVector.rend = new_instancemethod(_fife.IntVector_rend, None, IntVector)
IntVector.clear = new_instancemethod(_fife.IntVector_clear, None, IntVector)
IntVector.get_allocator = new_instancemethod(_fife.IntVector_get_allocator, None, IntVector)
IntVector.pop_back = new_instancemethod(_fife.IntVector_pop_back, None, IntVector)
IntVector.erase = new_instancemethod(_fife.IntVector_erase, None, IntVector)
IntVector.push_back = new_instancemethod(_fife.IntVector_push_back, None, IntVector)
IntVector.front = new_instancemethod(_fife.IntVector_front, None, IntVector)
IntVector.back = new_instancemethod(_fife.IntVector_back, None, IntVector)
IntVector.assign = new_instancemethod(_fife.IntVector_assign, None, IntVector)
IntVector.resize = new_instancemethod(_fife.IntVector_resize, None, IntVector)
IntVector.insert = new_instancemethod(_fife.IntVector_insert, None, IntVector)
IntVector.reserve = new_instancemethod(_fife.IntVector_reserve, None, IntVector)
IntVector.capacity = new_instancemethod(_fife.IntVector_capacity, None, IntVector)
IntVector_swigregister = _fife.IntVector_swigregister
IntVector_swigregister(IntVector)

class FloatVector(object):
    """Proxy of C++ std::vector<(float)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(FloatVector self) -> SwigPyIterator"""
        return _fife.FloatVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


    def __len__(self):
        """__len__(FloatVector self) -> std::vector< float >::size_type"""
        return _fife.FloatVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(FloatVector self, std::vector< float >::difference_type i, std::vector< float >::difference_type j) -> FloatVector"""
        return _fife.FloatVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(FloatVector self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)
        __setslice__(FloatVector self, std::vector< float >::difference_type i, std::vector< float >::difference_type j, FloatVector v)
        """
        return _fife.FloatVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(FloatVector self, std::vector< float >::difference_type i, std::vector< float >::difference_type j)"""
        return _fife.FloatVector___delslice__(self, i, j)


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


    def __getitem__(self, *args):
        """
        __getitem__(FloatVector self, PySliceObject * slice) -> FloatVector
        __getitem__(FloatVector self, std::vector< float >::difference_type i) -> std::vector< float >::value_type const &
        """
        return _fife.FloatVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(FloatVector self, PySliceObject * slice, FloatVector v)
        __setitem__(FloatVector self, PySliceObject * slice)
        __setitem__(FloatVector self, std::vector< float >::difference_type i, std::vector< float >::value_type const & x)
        """
        return _fife.FloatVector___setitem__(self, *args)


    def pop(self):
        """pop(FloatVector self) -> std::vector< float >::value_type"""
        return _fife.FloatVector_pop(self)


    def append(self, x):
        """append(FloatVector self, std::vector< float >::value_type const & x)"""
        return _fife.FloatVector_append(self, x)


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


    def size(self):
        """size(FloatVector self) -> std::vector< float >::size_type"""
        return _fife.FloatVector_size(self)


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


    def begin(self):
        """begin(FloatVector self) -> std::vector< float >::iterator"""
        return _fife.FloatVector_begin(self)


    def end(self):
        """end(FloatVector self) -> std::vector< float >::iterator"""
        return _fife.FloatVector_end(self)


    def rbegin(self):
        """rbegin(FloatVector self) -> std::vector< float >::reverse_iterator"""
        return _fife.FloatVector_rbegin(self)


    def rend(self):
        """rend(FloatVector self) -> std::vector< float >::reverse_iterator"""
        return _fife.FloatVector_rend(self)


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


    def get_allocator(self):
        """get_allocator(FloatVector self) -> std::vector< float >::allocator_type"""
        return _fife.FloatVector_get_allocator(self)


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


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


    def __init__(self, *args):
        """
        __init__(std::vector<(float)> self) -> FloatVector
        __init__(std::vector<(float)> self, FloatVector arg2) -> FloatVector
        __init__(std::vector<(float)> self, std::vector< float >::size_type size) -> FloatVector
        __init__(std::vector<(float)> self, std::vector< float >::size_type size, std::vector< float >::value_type const & value) -> FloatVector
        """
        _fife.FloatVector_swiginit(self, _fife.new_FloatVector(*args))

    def push_back(self, x):
        """push_back(FloatVector self, std::vector< float >::value_type const & x)"""
        return _fife.FloatVector_push_back(self, x)


    def front(self):
        """front(FloatVector self) -> std::vector< float >::value_type const &"""
        return _fife.FloatVector_front(self)


    def back(self):
        """back(FloatVector self) -> std::vector< float >::value_type const &"""
        return _fife.FloatVector_back(self)


    def assign(self, n, x):
        """assign(FloatVector self, std::vector< float >::size_type n, std::vector< float >::value_type const & x)"""
        return _fife.FloatVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(FloatVector self, std::vector< float >::size_type new_size)
        resize(FloatVector self, std::vector< float >::size_type new_size, std::vector< float >::value_type const & x)
        """
        return _fife.FloatVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(FloatVector self, std::vector< float >::iterator pos, std::vector< float >::value_type const & x) -> std::vector< float >::iterator
        insert(FloatVector self, std::vector< float >::iterator pos, std::vector< float >::size_type n, std::vector< float >::value_type const & x)
        """
        return _fife.FloatVector_insert(self, *args)


    def reserve(self, n):
        """reserve(FloatVector self, std::vector< float >::size_type n)"""
        return _fife.FloatVector_reserve(self, n)


    def capacity(self):
        """capacity(FloatVector self) -> std::vector< float >::size_type"""
        return _fife.FloatVector_capacity(self)

    __swig_destroy__ = _fife.delete_FloatVector
FloatVector.iterator = new_instancemethod(_fife.FloatVector_iterator, None, FloatVector)
FloatVector.__nonzero__ = new_instancemethod(_fife.FloatVector___nonzero__, None, FloatVector)
FloatVector.__bool__ = new_instancemethod(_fife.FloatVector___bool__, None, FloatVector)
FloatVector.__len__ = new_instancemethod(_fife.FloatVector___len__, None, FloatVector)
FloatVector.__getslice__ = new_instancemethod(_fife.FloatVector___getslice__, None, FloatVector)
FloatVector.__setslice__ = new_instancemethod(_fife.FloatVector___setslice__, None, FloatVector)
FloatVector.__delslice__ = new_instancemethod(_fife.FloatVector___delslice__, None, FloatVector)
FloatVector.__delitem__ = new_instancemethod(_fife.FloatVector___delitem__, None, FloatVector)
FloatVector.__getitem__ = new_instancemethod(_fife.FloatVector___getitem__, None, FloatVector)
FloatVector.__setitem__ = new_instancemethod(_fife.FloatVector___setitem__, None, FloatVector)
FloatVector.pop = new_instancemethod(_fife.FloatVector_pop, None, FloatVector)
FloatVector.append = new_instancemethod(_fife.FloatVector_append, None, FloatVector)
FloatVector.empty = new_instancemethod(_fife.FloatVector_empty, None, FloatVector)
FloatVector.size = new_instancemethod(_fife.FloatVector_size, None, FloatVector)
FloatVector.swap = new_instancemethod(_fife.FloatVector_swap, None, FloatVector)
FloatVector.begin = new_instancemethod(_fife.FloatVector_begin, None, FloatVector)
FloatVector.end = new_instancemethod(_fife.FloatVector_end, None, FloatVector)
FloatVector.rbegin = new_instancemethod(_fife.FloatVector_rbegin, None, FloatVector)
FloatVector.rend = new_instancemethod(_fife.FloatVector_rend, None, FloatVector)
FloatVector.clear = new_instancemethod(_fife.FloatVector_clear, None, FloatVector)
FloatVector.get_allocator = new_instancemethod(_fife.FloatVector_get_allocator, None, FloatVector)
FloatVector.pop_back = new_instancemethod(_fife.FloatVector_pop_back, None, FloatVector)
FloatVector.erase = new_instancemethod(_fife.FloatVector_erase, None, FloatVector)
FloatVector.push_back = new_instancemethod(_fife.FloatVector_push_back, None, FloatVector)
FloatVector.front = new_instancemethod(_fife.FloatVector_front, None, FloatVector)
FloatVector.back = new_instancemethod(_fife.FloatVector_back, None, FloatVector)
FloatVector.assign = new_instancemethod(_fife.FloatVector_assign, None, FloatVector)
FloatVector.resize = new_instancemethod(_fife.FloatVector_resize, None, FloatVector)
FloatVector.insert = new_instancemethod(_fife.FloatVector_insert, None, FloatVector)
FloatVector.reserve = new_instancemethod(_fife.FloatVector_reserve, None, FloatVector)
FloatVector.capacity = new_instancemethod(_fife.FloatVector_capacity, None, FloatVector)
FloatVector_swigregister = _fife.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

class DoubleVector(object):
    """Proxy of C++ std::vector<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(DoubleVector self) -> SwigPyIterator"""
        return _fife.DoubleVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


    def __len__(self):
        """__len__(DoubleVector self) -> std::vector< double >::size_type"""
        return _fife.DoubleVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j) -> DoubleVector"""
        return _fife.DoubleVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)
        __setslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j, DoubleVector v)
        """
        return _fife.DoubleVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::difference_type j)"""
        return _fife.DoubleVector___delslice__(self, i, j)


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


    def __getitem__(self, *args):
        """
        __getitem__(DoubleVector self, PySliceObject * slice) -> DoubleVector
        __getitem__(DoubleVector self, std::vector< double >::difference_type i) -> std::vector< double >::value_type const &
        """
        return _fife.DoubleVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(DoubleVector self, PySliceObject * slice, DoubleVector v)
        __setitem__(DoubleVector self, PySliceObject * slice)
        __setitem__(DoubleVector self, std::vector< double >::difference_type i, std::vector< double >::value_type const & x)
        """
        return _fife.DoubleVector___setitem__(self, *args)


    def pop(self):
        """pop(DoubleVector self) -> std::vector< double >::value_type"""
        return _fife.DoubleVector_pop(self)


    def append(self, x):
        """append(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _fife.DoubleVector_append(self, x)


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


    def size(self):
        """size(DoubleVector self) -> std::vector< double >::size_type"""
        return _fife.DoubleVector_size(self)


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


    def begin(self):
        """begin(DoubleVector self) -> std::vector< double >::iterator"""
        return _fife.DoubleVector_begin(self)


    def end(self):
        """end(DoubleVector self) -> std::vector< double >::iterator"""
        return _fife.DoubleVector_end(self)


    def rbegin(self):
        """rbegin(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _fife.DoubleVector_rbegin(self)


    def rend(self):
        """rend(DoubleVector self) -> std::vector< double >::reverse_iterator"""
        return _fife.DoubleVector_rend(self)


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


    def get_allocator(self):
        """get_allocator(DoubleVector self) -> std::vector< double >::allocator_type"""
        return _fife.DoubleVector_get_allocator(self)


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


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


    def __init__(self, *args):
        """
        __init__(std::vector<(double)> self) -> DoubleVector
        __init__(std::vector<(double)> self, DoubleVector arg2) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size) -> DoubleVector
        __init__(std::vector<(double)> self, std::vector< double >::size_type size, std::vector< double >::value_type const & value) -> DoubleVector
        """
        _fife.DoubleVector_swiginit(self, _fife.new_DoubleVector(*args))

    def push_back(self, x):
        """push_back(DoubleVector self, std::vector< double >::value_type const & x)"""
        return _fife.DoubleVector_push_back(self, x)


    def front(self):
        """front(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _fife.DoubleVector_front(self)


    def back(self):
        """back(DoubleVector self) -> std::vector< double >::value_type const &"""
        return _fife.DoubleVector_back(self)


    def assign(self, n, x):
        """assign(DoubleVector self, std::vector< double >::size_type n, std::vector< double >::value_type const & x)"""
        return _fife.DoubleVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(DoubleVector self, std::vector< double >::size_type new_size)
        resize(DoubleVector self, std::vector< double >::size_type new_size, std::vector< double >::value_type const & x)
        """
        return _fife.DoubleVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::value_type const & x) -> std::vector< double >::iterator
        insert(DoubleVector self, std::vector< double >::iterator pos, std::vector< double >::size_type n, std::vector< double >::value_type const & x)
        """
        return _fife.DoubleVector_insert(self, *args)


    def reserve(self, n):
        """reserve(DoubleVector self, std::vector< double >::size_type n)"""
        return _fife.DoubleVector_reserve(self, n)


    def capacity(self):
        """capacity(DoubleVector self) -> std::vector< double >::size_type"""
        return _fife.DoubleVector_capacity(self)

    __swig_destroy__ = _fife.delete_DoubleVector
DoubleVector.iterator = new_instancemethod(_fife.DoubleVector_iterator, None, DoubleVector)
DoubleVector.__nonzero__ = new_instancemethod(_fife.DoubleVector___nonzero__, None, DoubleVector)
DoubleVector.__bool__ = new_instancemethod(_fife.DoubleVector___bool__, None, DoubleVector)
DoubleVector.__len__ = new_instancemethod(_fife.DoubleVector___len__, None, DoubleVector)
DoubleVector.__getslice__ = new_instancemethod(_fife.DoubleVector___getslice__, None, DoubleVector)
DoubleVector.__setslice__ = new_instancemethod(_fife.DoubleVector___setslice__, None, DoubleVector)
DoubleVector.__delslice__ = new_instancemethod(_fife.DoubleVector___delslice__, None, DoubleVector)
DoubleVector.__delitem__ = new_instancemethod(_fife.DoubleVector___delitem__, None, DoubleVector)
DoubleVector.__getitem__ = new_instancemethod(_fife.DoubleVector___getitem__, None, DoubleVector)
DoubleVector.__setitem__ = new_instancemethod(_fife.DoubleVector___setitem__, None, DoubleVector)
DoubleVector.pop = new_instancemethod(_fife.DoubleVector_pop, None, DoubleVector)
DoubleVector.append = new_instancemethod(_fife.DoubleVector_append, None, DoubleVector)
DoubleVector.empty = new_instancemethod(_fife.DoubleVector_empty, None, DoubleVector)
DoubleVector.size = new_instancemethod(_fife.DoubleVector_size, None, DoubleVector)
DoubleVector.swap = new_instancemethod(_fife.DoubleVector_swap, None, DoubleVector)
DoubleVector.begin = new_instancemethod(_fife.DoubleVector_begin, None, DoubleVector)
DoubleVector.end = new_instancemethod(_fife.DoubleVector_end, None, DoubleVector)
DoubleVector.rbegin = new_instancemethod(_fife.DoubleVector_rbegin, None, DoubleVector)
DoubleVector.rend = new_instancemethod(_fife.DoubleVector_rend, None, DoubleVector)
DoubleVector.clear = new_instancemethod(_fife.DoubleVector_clear, None, DoubleVector)
DoubleVector.get_allocator = new_instancemethod(_fife.DoubleVector_get_allocator, None, DoubleVector)
DoubleVector.pop_back = new_instancemethod(_fife.DoubleVector_pop_back, None, DoubleVector)
DoubleVector.erase = new_instancemethod(_fife.DoubleVector_erase, None, DoubleVector)
DoubleVector.push_back = new_instancemethod(_fife.DoubleVector_push_back, None, DoubleVector)
DoubleVector.front = new_instancemethod(_fife.DoubleVector_front, None, DoubleVector)
DoubleVector.back = new_instancemethod(_fife.DoubleVector_back, None, DoubleVector)
DoubleVector.assign = new_instancemethod(_fife.DoubleVector_assign, None, DoubleVector)
DoubleVector.resize = new_instancemethod(_fife.DoubleVector_resize, None, DoubleVector)
DoubleVector.insert = new_instancemethod(_fife.DoubleVector_insert, None, DoubleVector)
DoubleVector.reserve = new_instancemethod(_fife.DoubleVector_reserve, None, DoubleVector)
DoubleVector.capacity = new_instancemethod(_fife.DoubleVector_capacity, None, DoubleVector)
DoubleVector_swigregister = _fife.DoubleVector_swigregister
DoubleVector_swigregister(DoubleVector)

class BoolVector(object):
    """Proxy of C++ std::vector<(bool)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(BoolVector self) -> SwigPyIterator"""
        return _fife.BoolVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


    def __len__(self):
        """__len__(BoolVector self) -> std::vector< bool >::size_type"""
        return _fife.BoolVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j) -> BoolVector"""
        return _fife.BoolVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)
        __setslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j, BoolVector v)
        """
        return _fife.BoolVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(BoolVector self, std::vector< bool >::difference_type i, std::vector< bool >::difference_type j)"""
        return _fife.BoolVector___delslice__(self, i, j)


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


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


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


    def pop(self):
        """pop(BoolVector self) -> std::vector< bool >::value_type"""
        return _fife.BoolVector_pop(self)


    def append(self, x):
        """append(BoolVector self, std::vector< bool >::value_type x)"""
        return _fife.BoolVector_append(self, x)


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


    def size(self):
        """size(BoolVector self) -> std::vector< bool >::size_type"""
        return _fife.BoolVector_size(self)


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


    def begin(self):
        """begin(BoolVector self) -> std::vector< bool >::iterator"""
        return _fife.BoolVector_begin(self)


    def end(self):
        """end(BoolVector self) -> std::vector< bool >::iterator"""
        return _fife.BoolVector_end(self)


    def rbegin(self):
        """rbegin(BoolVector self) -> std::vector< bool >::reverse_iterator"""
        return _fife.BoolVector_rbegin(self)


    def rend(self):
        """rend(BoolVector self) -> std::vector< bool >::reverse_iterator"""
        return _fife.BoolVector_rend(self)


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


    def get_allocator(self):
        """get_allocator(BoolVector self) -> std::vector< bool >::allocator_type"""
        return _fife.BoolVector_get_allocator(self)


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


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


    def __init__(self, *args):
        """
        __init__(std::vector<(bool)> self) -> BoolVector
        __init__(std::vector<(bool)> self, BoolVector arg2) -> BoolVector
        __init__(std::vector<(bool)> self, std::vector< bool >::size_type size) -> BoolVector
        __init__(std::vector<(bool)> self, std::vector< bool >::size_type size, std::vector< bool >::value_type value) -> BoolVector
        """
        _fife.BoolVector_swiginit(self, _fife.new_BoolVector(*args))

    def push_back(self, x):
        """push_back(BoolVector self, std::vector< bool >::value_type x)"""
        return _fife.BoolVector_push_back(self, x)


    def front(self):
        """front(BoolVector self) -> std::vector< bool >::value_type"""
        return _fife.BoolVector_front(self)


    def back(self):
        """back(BoolVector self) -> std::vector< bool >::value_type"""
        return _fife.BoolVector_back(self)


    def assign(self, n, x):
        """assign(BoolVector self, std::vector< bool >::size_type n, std::vector< bool >::value_type x)"""
        return _fife.BoolVector_assign(self, n, x)


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


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


    def reserve(self, n):
        """reserve(BoolVector self, std::vector< bool >::size_type n)"""
        return _fife.BoolVector_reserve(self, n)


    def capacity(self):
        """capacity(BoolVector self) -> std::vector< bool >::size_type"""
        return _fife.BoolVector_capacity(self)

    __swig_destroy__ = _fife.delete_BoolVector
BoolVector.iterator = new_instancemethod(_fife.BoolVector_iterator, None, BoolVector)
BoolVector.__nonzero__ = new_instancemethod(_fife.BoolVector___nonzero__, None, BoolVector)
BoolVector.__bool__ = new_instancemethod(_fife.BoolVector___bool__, None, BoolVector)
BoolVector.__len__ = new_instancemethod(_fife.BoolVector___len__, None, BoolVector)
BoolVector.__getslice__ = new_instancemethod(_fife.BoolVector___getslice__, None, BoolVector)
BoolVector.__setslice__ = new_instancemethod(_fife.BoolVector___setslice__, None, BoolVector)
BoolVector.__delslice__ = new_instancemethod(_fife.BoolVector___delslice__, None, BoolVector)
BoolVector.__delitem__ = new_instancemethod(_fife.BoolVector___delitem__, None, BoolVector)
BoolVector.__getitem__ = new_instancemethod(_fife.BoolVector___getitem__, None, BoolVector)
BoolVector.__setitem__ = new_instancemethod(_fife.BoolVector___setitem__, None, BoolVector)
BoolVector.pop = new_instancemethod(_fife.BoolVector_pop, None, BoolVector)
BoolVector.append = new_instancemethod(_fife.BoolVector_append, None, BoolVector)
BoolVector.empty = new_instancemethod(_fife.BoolVector_empty, None, BoolVector)
BoolVector.size = new_instancemethod(_fife.BoolVector_size, None, BoolVector)
BoolVector.swap = new_instancemethod(_fife.BoolVector_swap, None, BoolVector)
BoolVector.begin = new_instancemethod(_fife.BoolVector_begin, None, BoolVector)
BoolVector.end = new_instancemethod(_fife.BoolVector_end, None, BoolVector)
BoolVector.rbegin = new_instancemethod(_fife.BoolVector_rbegin, None, BoolVector)
BoolVector.rend = new_instancemethod(_fife.BoolVector_rend, None, BoolVector)
BoolVector.clear = new_instancemethod(_fife.BoolVector_clear, None, BoolVector)
BoolVector.get_allocator = new_instancemethod(_fife.BoolVector_get_allocator, None, BoolVector)
BoolVector.pop_back = new_instancemethod(_fife.BoolVector_pop_back, None, BoolVector)
BoolVector.erase = new_instancemethod(_fife.BoolVector_erase, None, BoolVector)
BoolVector.push_back = new_instancemethod(_fife.BoolVector_push_back, None, BoolVector)
BoolVector.front = new_instancemethod(_fife.BoolVector_front, None, BoolVector)
BoolVector.back = new_instancemethod(_fife.BoolVector_back, None, BoolVector)
BoolVector.assign = new_instancemethod(_fife.BoolVector_assign, None, BoolVector)
BoolVector.resize = new_instancemethod(_fife.BoolVector_resize, None, BoolVector)
BoolVector.insert = new_instancemethod(_fife.BoolVector_insert, None, BoolVector)
BoolVector.reserve = new_instancemethod(_fife.BoolVector_reserve, None, BoolVector)
BoolVector.capacity = new_instancemethod(_fife.BoolVector_capacity, None, BoolVector)
BoolVector_swigregister = _fife.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

class Uint16Uint16Pair(object):
    """Proxy of C++ std::pair<(uint16_t,uint16_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(std::pair<(uint16_t,uint16_t)> self) -> Uint16Uint16Pair
        __init__(std::pair<(uint16_t,uint16_t)> self, unsigned short first, unsigned short second) -> Uint16Uint16Pair
        __init__(std::pair<(uint16_t,uint16_t)> self, Uint16Uint16Pair p) -> Uint16Uint16Pair
        """
        _fife.Uint16Uint16Pair_swiginit(self, _fife.new_Uint16Uint16Pair(*args))
    first = _swig_property(_fife.Uint16Uint16Pair_first_get, _fife.Uint16Uint16Pair_first_set)
    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
Uint16Uint16Pair_swigregister = _fife.Uint16Uint16Pair_swigregister
Uint16Uint16Pair_swigregister(Uint16Uint16Pair)

class Uint16Uint16PairVector(object):
    """Proxy of C++ std::vector<(std::pair<(uint16_t,uint16_t)>)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(Uint16Uint16PairVector self) -> SwigPyIterator"""
        return _fife.Uint16Uint16PairVector_iterator(self)

    def __iter__(self):
        return self.iterator()

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


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


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


    def __getslice__(self, i, j):
        """__getslice__(Uint16Uint16PairVector 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, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(Uint16Uint16PairVector self, std::vector< std::pair< unsigned short,unsigned short > >::difference_type i, std::vector< std::pair< unsigned short,unsigned short > >::difference_type j)
        __setslice__(Uint16Uint16PairVector 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, i, j):
        """__delslice__(Uint16Uint16PairVector 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, i, j)


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


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


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


    def pop(self):
        """pop(Uint16Uint16PairVector self) -> Uint16Uint16Pair"""
        return _fife.Uint16Uint16PairVector_pop(self)


    def append(self, x):
        """append(Uint16Uint16PairVector self, Uint16Uint16Pair x)"""
        return _fife.Uint16Uint16PairVector_append(self, x)


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


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


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


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


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


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


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


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


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


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


    def erase(self, *args):
        """
        erase(Uint16Uint16PairVector self, std::vector< std::pair< unsigned short,unsigned short > >::iterator pos) -> std::vector< std::pair< unsigned short,unsigned short > >::iterator
        erase(Uint16Uint16PairVector 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__(std::vector<(std::pair<(uint16_t,uint16_t)>)> self) -> Uint16Uint16PairVector
        __init__(std::vector<(std::pair<(uint16_t,uint16_t)>)> self, Uint16Uint16PairVector arg2) -> Uint16Uint16PairVector
        __init__(std::vector<(std::pair<(uint16_t,uint16_t)>)> self, std::vector< std::pair< unsigned short,unsigned short > >::size_type size) -> Uint16Uint16PairVector
        __init__(std::vector<(std::pair<(uint16_t,uint16_t)>)> self, std::vector< std::pair< unsigned short,unsigned short > >::size_type size, Uint16Uint16Pair value) -> Uint16Uint16PairVector
        """
        _fife.Uint16Uint16PairVector_swiginit(self, _fife.new_Uint16Uint16PairVector(*args))

    def push_back(self, x):
        """push_back(Uint16Uint16PairVector self, Uint16Uint16Pair x)"""
        return _fife.Uint16Uint16PairVector_push_back(self, x)


    def front(self):
        """front(Uint16Uint16PairVector self) -> Uint16Uint16Pair"""
        return _fife.Uint16Uint16PairVector_front(self)


    def back(self):
        """back(Uint16Uint16PairVector self) -> Uint16Uint16Pair"""
        return _fife.Uint16Uint16PairVector_back(self)


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


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


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


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


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

    __swig_destroy__ = _fife.delete_Uint16Uint16PairVector
Uint16Uint16PairVector.iterator = new_instancemethod(_fife.Uint16Uint16PairVector_iterator, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__nonzero__ = new_instancemethod(_fife.Uint16Uint16PairVector___nonzero__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__bool__ = new_instancemethod(_fife.Uint16Uint16PairVector___bool__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__len__ = new_instancemethod(_fife.Uint16Uint16PairVector___len__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__getslice__ = new_instancemethod(_fife.Uint16Uint16PairVector___getslice__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__setslice__ = new_instancemethod(_fife.Uint16Uint16PairVector___setslice__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__delslice__ = new_instancemethod(_fife.Uint16Uint16PairVector___delslice__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__delitem__ = new_instancemethod(_fife.Uint16Uint16PairVector___delitem__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__getitem__ = new_instancemethod(_fife.Uint16Uint16PairVector___getitem__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.__setitem__ = new_instancemethod(_fife.Uint16Uint16PairVector___setitem__, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.pop = new_instancemethod(_fife.Uint16Uint16PairVector_pop, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.append = new_instancemethod(_fife.Uint16Uint16PairVector_append, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.empty = new_instancemethod(_fife.Uint16Uint16PairVector_empty, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.size = new_instancemethod(_fife.Uint16Uint16PairVector_size, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.swap = new_instancemethod(_fife.Uint16Uint16PairVector_swap, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.begin = new_instancemethod(_fife.Uint16Uint16PairVector_begin, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.end = new_instancemethod(_fife.Uint16Uint16PairVector_end, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.rbegin = new_instancemethod(_fife.Uint16Uint16PairVector_rbegin, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.rend = new_instancemethod(_fife.Uint16Uint16PairVector_rend, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.clear = new_instancemethod(_fife.Uint16Uint16PairVector_clear, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.get_allocator = new_instancemethod(_fife.Uint16Uint16PairVector_get_allocator, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.pop_back = new_instancemethod(_fife.Uint16Uint16PairVector_pop_back, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.erase = new_instancemethod(_fife.Uint16Uint16PairVector_erase, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.push_back = new_instancemethod(_fife.Uint16Uint16PairVector_push_back, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.front = new_instancemethod(_fife.Uint16Uint16PairVector_front, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.back = new_instancemethod(_fife.Uint16Uint16PairVector_back, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.assign = new_instancemethod(_fife.Uint16Uint16PairVector_assign, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.resize = new_instancemethod(_fife.Uint16Uint16PairVector_resize, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.insert = new_instancemethod(_fife.Uint16Uint16PairVector_insert, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.reserve = new_instancemethod(_fife.Uint16Uint16PairVector_reserve, None, Uint16Uint16PairVector)
Uint16Uint16PairVector.capacity = new_instancemethod(_fife.Uint16Uint16PairVector_capacity, None, Uint16Uint16PairVector)
Uint16Uint16PairVector_swigregister = _fife.Uint16Uint16PairVector_swigregister
Uint16Uint16PairVector_swigregister(Uint16Uint16PairVector)


def getVersion():
    """getVersion() -> char const *"""
    return _fife.getVersion()

def getVersionShort():
    """getVersionShort() -> char const *"""
    return _fife.getVersionShort()

def getMajor():
    """getMajor() -> int"""
    return _fife.getMajor()

def getMinor():
    """getMinor() -> int"""
    return _fife.getMinor()

def getPatch():
    """getPatch() -> int"""
    return _fife.getPatch()

def getHash():
    """getHash() -> char const *"""
    return _fife.getHash()

def getVersionId():
    """getVersionId() -> int const"""
    return _fife.getVersionId()
class Point(object):
    """Proxy of C++ FIFE::PointType2D<(int32_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.Point_x_get, _fife.Point_x_set)
    y = _swig_property(_fife.Point_y_get, _fife.Point_y_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType2D<(int32_t)> self, int _x=0, int _y=0) -> Point
        __init__(FIFE::PointType2D<(int32_t)> self, Point rhs) -> Point
        """
        _fife.Point_swiginit(self, _fife.new_Point(*args))

    def __add__(self, p):
        """__add__(Point self, Point p) -> Point"""
        return _fife.Point___add__(self, p)


    def __sub__(self, p):
        """__sub__(Point self, Point p) -> Point"""
        return _fife.Point___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(Point self, Point p) -> Point"""
        return _fife.Point___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(Point self, Point p) -> Point"""
        return _fife.Point___isub__(self, p)


    def __mul__(self, i):
        """__mul__(Point self, int const & i) -> Point"""
        return _fife.Point___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.Point___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(Point self, Point p) -> bool"""
        return _fife.Point___eq__(self, p)


    def __ne__(self, p):
        """__ne__(Point self, Point p) -> bool"""
        return _fife.Point___ne__(self, p)


    def length(self):
        """length(Point self) -> int"""
        return _fife.Point_length(self)


    def normalize(self):
        """normalize(Point self)"""
        return _fife.Point_normalize(self)


    def rotate(self, *args):
        """
        rotate(Point self, int angle)
        rotate(Point self, Point origin, int angle)
        """
        return _fife.Point_rotate(self, *args)


    def set(self, _x, _y):
        """set(Point self, int _x, int _y)"""
        return _fife.Point_set(self, _x, _y)


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


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


    def setX(self, _x):
        """setX(Point self, int32_t _x)"""
        return _fife.Point_setX(self, _x)


    def setY(self, _y):
        """setY(Point self, int32_t _y)"""
        return _fife.Point_setY(self, _y)


    def __str__(self):
        """__str__(Point self) -> std::string"""
        return _fife.Point___str__(self)

    __swig_destroy__ = _fife.delete_Point
Point.__add__ = new_instancemethod(_fife.Point___add__, None, Point)
Point.__sub__ = new_instancemethod(_fife.Point___sub__, None, Point)
Point.__iadd__ = new_instancemethod(_fife.Point___iadd__, None, Point)
Point.__isub__ = new_instancemethod(_fife.Point___isub__, None, Point)
Point.__mul__ = new_instancemethod(_fife.Point___mul__, None, Point)
Point.__eq__ = new_instancemethod(_fife.Point___eq__, None, Point)
Point.__ne__ = new_instancemethod(_fife.Point___ne__, None, Point)
Point.length = new_instancemethod(_fife.Point_length, None, Point)
Point.normalize = new_instancemethod(_fife.Point_normalize, None, Point)
Point.rotate = new_instancemethod(_fife.Point_rotate, None, Point)
Point.set = new_instancemethod(_fife.Point_set, None, Point)
Point.getX = new_instancemethod(_fife.Point_getX, None, Point)
Point.getY = new_instancemethod(_fife.Point_getY, None, Point)
Point.setX = new_instancemethod(_fife.Point_setX, None, Point)
Point.setY = new_instancemethod(_fife.Point_setY, None, Point)
Point.__str__ = new_instancemethod(_fife.Point___str__, None, Point)
Point_swigregister = _fife.Point_swigregister
Point_swigregister(Point)

class DoublePoint(object):
    """Proxy of C++ FIFE::PointType2D<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.DoublePoint_x_get, _fife.DoublePoint_x_set)
    y = _swig_property(_fife.DoublePoint_y_get, _fife.DoublePoint_y_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType2D<(double)> self, double _x=0, double _y=0) -> DoublePoint
        __init__(FIFE::PointType2D<(double)> self, DoublePoint rhs) -> DoublePoint
        """
        _fife.DoublePoint_swiginit(self, _fife.new_DoublePoint(*args))

    def __add__(self, p):
        """__add__(DoublePoint self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___add__(self, p)


    def __sub__(self, p):
        """__sub__(DoublePoint self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(DoublePoint self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(DoublePoint self, DoublePoint p) -> DoublePoint"""
        return _fife.DoublePoint___isub__(self, p)


    def __mul__(self, i):
        """__mul__(DoublePoint self, double const & i) -> DoublePoint"""
        return _fife.DoublePoint___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.DoublePoint___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(DoublePoint self, DoublePoint p) -> bool"""
        return _fife.DoublePoint___eq__(self, p)


    def __ne__(self, p):
        """__ne__(DoublePoint self, DoublePoint p) -> bool"""
        return _fife.DoublePoint___ne__(self, p)


    def length(self):
        """length(DoublePoint self) -> double"""
        return _fife.DoublePoint_length(self)


    def normalize(self):
        """normalize(DoublePoint self)"""
        return _fife.DoublePoint_normalize(self)


    def rotate(self, *args):
        """
        rotate(DoublePoint self, double angle)
        rotate(DoublePoint self, DoublePoint origin, double angle)
        """
        return _fife.DoublePoint_rotate(self, *args)


    def set(self, _x, _y):
        """set(DoublePoint self, double _x, double _y)"""
        return _fife.DoublePoint_set(self, _x, _y)


    def getX(self):
        """getX(DoublePoint self) -> double"""
        return _fife.DoublePoint_getX(self)


    def getY(self):
        """getY(DoublePoint self) -> double"""
        return _fife.DoublePoint_getY(self)


    def setX(self, _x):
        """setX(DoublePoint self, double _x)"""
        return _fife.DoublePoint_setX(self, _x)


    def setY(self, _y):
        """setY(DoublePoint self, double _y)"""
        return _fife.DoublePoint_setY(self, _y)


    def __str__(self):
        """__str__(DoublePoint self) -> std::string"""
        return _fife.DoublePoint___str__(self)

    __swig_destroy__ = _fife.delete_DoublePoint
DoublePoint.__add__ = new_instancemethod(_fife.DoublePoint___add__, None, DoublePoint)
DoublePoint.__sub__ = new_instancemethod(_fife.DoublePoint___sub__, None, DoublePoint)
DoublePoint.__iadd__ = new_instancemethod(_fife.DoublePoint___iadd__, None, DoublePoint)
DoublePoint.__isub__ = new_instancemethod(_fife.DoublePoint___isub__, None, DoublePoint)
DoublePoint.__mul__ = new_instancemethod(_fife.DoublePoint___mul__, None, DoublePoint)
DoublePoint.__eq__ = new_instancemethod(_fife.DoublePoint___eq__, None, DoublePoint)
DoublePoint.__ne__ = new_instancemethod(_fife.DoublePoint___ne__, None, DoublePoint)
DoublePoint.length = new_instancemethod(_fife.DoublePoint_length, None, DoublePoint)
DoublePoint.normalize = new_instancemethod(_fife.DoublePoint_normalize, None, DoublePoint)
DoublePoint.rotate = new_instancemethod(_fife.DoublePoint_rotate, None, DoublePoint)
DoublePoint.set = new_instancemethod(_fife.DoublePoint_set, None, DoublePoint)
DoublePoint.getX = new_instancemethod(_fife.DoublePoint_getX, None, DoublePoint)
DoublePoint.getY = new_instancemethod(_fife.DoublePoint_getY, None, DoublePoint)
DoublePoint.setX = new_instancemethod(_fife.DoublePoint_setX, None, DoublePoint)
DoublePoint.setY = new_instancemethod(_fife.DoublePoint_setY, None, DoublePoint)
DoublePoint.__str__ = new_instancemethod(_fife.DoublePoint___str__, None, DoublePoint)
DoublePoint_swigregister = _fife.DoublePoint_swigregister
DoublePoint_swigregister(DoublePoint)

class Point3D(object):
    """Proxy of C++ FIFE::PointType3D<(int32_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.Point3D_x_get, _fife.Point3D_x_set)
    y = _swig_property(_fife.Point3D_y_get, _fife.Point3D_y_set)
    z = _swig_property(_fife.Point3D_z_get, _fife.Point3D_z_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType3D<(int32_t)> self, int _x=0, int _y=0, int _z=0) -> Point3D
        __init__(FIFE::PointType3D<(int32_t)> self, Point3D rhs) -> Point3D
        """
        _fife.Point3D_swiginit(self, _fife.new_Point3D(*args))

    def __add__(self, p):
        """__add__(Point3D self, Point3D p) -> Point3D"""
        return _fife.Point3D___add__(self, p)


    def __sub__(self, p):
        """__sub__(Point3D self, Point3D p) -> Point3D"""
        return _fife.Point3D___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(Point3D self, Point3D p) -> Point3D"""
        return _fife.Point3D___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(Point3D self, Point3D p) -> Point3D"""
        return _fife.Point3D___isub__(self, p)


    def __mul__(self, i):
        """__mul__(Point3D self, int const & i) -> Point3D"""
        return _fife.Point3D___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.Point3D___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(Point3D self, Point3D p) -> bool"""
        return _fife.Point3D___eq__(self, p)


    def __ne__(self, p):
        """__ne__(Point3D self, Point3D p) -> bool"""
        return _fife.Point3D___ne__(self, p)


    def length(self):
        """length(Point3D self) -> int"""
        return _fife.Point3D_length(self)


    def normalize(self):
        """normalize(Point3D self)"""
        return _fife.Point3D_normalize(self)


    def set(self, _x, _y, _z):
        """set(Point3D self, int _x, int _y, int _z)"""
        return _fife.Point3D_set(self, _x, _y, _z)

    __swig_destroy__ = _fife.delete_Point3D
Point3D.__add__ = new_instancemethod(_fife.Point3D___add__, None, Point3D)
Point3D.__sub__ = new_instancemethod(_fife.Point3D___sub__, None, Point3D)
Point3D.__iadd__ = new_instancemethod(_fife.Point3D___iadd__, None, Point3D)
Point3D.__isub__ = new_instancemethod(_fife.Point3D___isub__, None, Point3D)
Point3D.__mul__ = new_instancemethod(_fife.Point3D___mul__, None, Point3D)
Point3D.__eq__ = new_instancemethod(_fife.Point3D___eq__, None, Point3D)
Point3D.__ne__ = new_instancemethod(_fife.Point3D___ne__, None, Point3D)
Point3D.length = new_instancemethod(_fife.Point3D_length, None, Point3D)
Point3D.normalize = new_instancemethod(_fife.Point3D_normalize, None, Point3D)
Point3D.set = new_instancemethod(_fife.Point3D_set, None, Point3D)
Point3D_swigregister = _fife.Point3D_swigregister
Point3D_swigregister(Point3D)

class DoublePoint3D(object):
    """Proxy of C++ FIFE::PointType3D<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.DoublePoint3D_x_get, _fife.DoublePoint3D_x_set)
    y = _swig_property(_fife.DoublePoint3D_y_get, _fife.DoublePoint3D_y_set)
    z = _swig_property(_fife.DoublePoint3D_z_get, _fife.DoublePoint3D_z_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType3D<(double)> self, double _x=0, double _y=0, double _z=0) -> DoublePoint3D
        __init__(FIFE::PointType3D<(double)> self, DoublePoint3D rhs) -> DoublePoint3D
        """
        _fife.DoublePoint3D_swiginit(self, _fife.new_DoublePoint3D(*args))

    def __add__(self, p):
        """__add__(DoublePoint3D self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___add__(self, p)


    def __sub__(self, p):
        """__sub__(DoublePoint3D self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(DoublePoint3D self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(DoublePoint3D self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.DoublePoint3D___isub__(self, p)


    def __mul__(self, i):
        """__mul__(DoublePoint3D self, double const & i) -> DoublePoint3D"""
        return _fife.DoublePoint3D___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.DoublePoint3D___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(DoublePoint3D self, DoublePoint3D p) -> bool"""
        return _fife.DoublePoint3D___eq__(self, p)


    def __ne__(self, p):
        """__ne__(DoublePoint3D self, DoublePoint3D p) -> bool"""
        return _fife.DoublePoint3D___ne__(self, p)


    def length(self):
        """length(DoublePoint3D self) -> double"""
        return _fife.DoublePoint3D_length(self)


    def normalize(self):
        """normalize(DoublePoint3D self)"""
        return _fife.DoublePoint3D_normalize(self)


    def set(self, _x, _y, _z):
        """set(DoublePoint3D self, double _x, double _y, double _z)"""
        return _fife.DoublePoint3D_set(self, _x, _y, _z)

    __swig_destroy__ = _fife.delete_DoublePoint3D
DoublePoint3D.__add__ = new_instancemethod(_fife.DoublePoint3D___add__, None, DoublePoint3D)
DoublePoint3D.__sub__ = new_instancemethod(_fife.DoublePoint3D___sub__, None, DoublePoint3D)
DoublePoint3D.__iadd__ = new_instancemethod(_fife.DoublePoint3D___iadd__, None, DoublePoint3D)
DoublePoint3D.__isub__ = new_instancemethod(_fife.DoublePoint3D___isub__, None, DoublePoint3D)
DoublePoint3D.__mul__ = new_instancemethod(_fife.DoublePoint3D___mul__, None, DoublePoint3D)
DoublePoint3D.__eq__ = new_instancemethod(_fife.DoublePoint3D___eq__, None, DoublePoint3D)
DoublePoint3D.__ne__ = new_instancemethod(_fife.DoublePoint3D___ne__, None, DoublePoint3D)
DoublePoint3D.length = new_instancemethod(_fife.DoublePoint3D_length, None, DoublePoint3D)
DoublePoint3D.normalize = new_instancemethod(_fife.DoublePoint3D_normalize, None, DoublePoint3D)
DoublePoint3D.set = new_instancemethod(_fife.DoublePoint3D_set, None, DoublePoint3D)
DoublePoint3D_swigregister = _fife.DoublePoint3D_swigregister
DoublePoint3D_swigregister(DoublePoint3D)

class Rect(object):
    """Proxy of C++ FIFE::RectType<(int32_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.Rect_x_get, _fife.Rect_x_set)
    y = _swig_property(_fife.Rect_y_get, _fife.Rect_y_set)
    w = _swig_property(_fife.Rect_w_get, _fife.Rect_w_set)
    h = _swig_property(_fife.Rect_h_get, _fife.Rect_h_set)

    def __init__(self, x=0, y=0, width=0, height=0):
        """__init__(FIFE::RectType<(int32_t)> self, int x=0, int y=0, int width=0, int height=0) -> Rect"""
        _fife.Rect_swiginit(self, _fife.new_Rect(x, y, width, height))

    def right(self):
        """right(Rect self) -> int"""
        return _fife.Rect_right(self)


    def bottom(self):
        """bottom(Rect self) -> int"""
        return _fife.Rect_bottom(self)


    def __eq__(self, rect):
        """__eq__(Rect self, Rect rect) -> bool"""
        return _fife.Rect___eq__(self, rect)


    def contains(self, point):
        """contains(Rect self, Point point) -> bool"""
        return _fife.Rect_contains(self, point)


    def intersects(self, rect):
        """intersects(Rect self, Rect rect) -> bool"""
        return _fife.Rect_intersects(self, rect)


    def intersectInplace(self, rect):
        """intersectInplace(Rect self, Rect rect) -> bool"""
        return _fife.Rect_intersectInplace(self, rect)


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


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


    def setX(self, _x):
        """setX(Rect self, int32_t _x)"""
        return _fife.Rect_setX(self, _x)


    def setY(self, _y):
        """setY(Rect self, int32_t _y)"""
        return _fife.Rect_setY(self, _y)


    def getW(self):
        """getW(Rect self) -> int32_t"""
        return _fife.Rect_getW(self)


    def getH(self):
        """getH(Rect self) -> int32_t"""
        return _fife.Rect_getH(self)


    def setW(self, _w):
        """setW(Rect self, int32_t _w)"""
        return _fife.Rect_setW(self, _w)


    def setH(self, _h):
        """setH(Rect self, int32_t _h)"""
        return _fife.Rect_setH(self, _h)


    def __str__(self):
        """__str__(Rect self) -> std::string"""
        return _fife.Rect___str__(self)

    __swig_destroy__ = _fife.delete_Rect
Rect.right = new_instancemethod(_fife.Rect_right, None, Rect)
Rect.bottom = new_instancemethod(_fife.Rect_bottom, None, Rect)
Rect.__eq__ = new_instancemethod(_fife.Rect___eq__, None, Rect)
Rect.contains = new_instancemethod(_fife.Rect_contains, None, Rect)
Rect.intersects = new_instancemethod(_fife.Rect_intersects, None, Rect)
Rect.intersectInplace = new_instancemethod(_fife.Rect_intersectInplace, None, Rect)
Rect.getX = new_instancemethod(_fife.Rect_getX, None, Rect)
Rect.getY = new_instancemethod(_fife.Rect_getY, None, Rect)
Rect.setX = new_instancemethod(_fife.Rect_setX, None, Rect)
Rect.setY = new_instancemethod(_fife.Rect_setY, None, Rect)
Rect.getW = new_instancemethod(_fife.Rect_getW, None, Rect)
Rect.getH = new_instancemethod(_fife.Rect_getH, None, Rect)
Rect.setW = new_instancemethod(_fife.Rect_setW, None, Rect)
Rect.setH = new_instancemethod(_fife.Rect_setH, None, Rect)
Rect.__str__ = new_instancemethod(_fife.Rect___str__, None, Rect)
Rect_swigregister = _fife.Rect_swigregister
Rect_swigregister(Rect)

class FloatRect(object):
    """Proxy of C++ FIFE::RectType<(float)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.FloatRect_x_get, _fife.FloatRect_x_set)
    y = _swig_property(_fife.FloatRect_y_get, _fife.FloatRect_y_set)
    w = _swig_property(_fife.FloatRect_w_get, _fife.FloatRect_w_set)
    h = _swig_property(_fife.FloatRect_h_get, _fife.FloatRect_h_set)

    def __init__(self, x=0, y=0, width=0, height=0):
        """__init__(FIFE::RectType<(float)> self, float x=0, float y=0, float width=0, float height=0) -> FloatRect"""
        _fife.FloatRect_swiginit(self, _fife.new_FloatRect(x, y, width, height))

    def right(self):
        """right(FloatRect self) -> float"""
        return _fife.FloatRect_right(self)


    def bottom(self):
        """bottom(FloatRect self) -> float"""
        return _fife.FloatRect_bottom(self)


    def __eq__(self, rect):
        """__eq__(FloatRect self, FloatRect rect) -> bool"""
        return _fife.FloatRect___eq__(self, rect)


    def contains(self, point):
        """contains(FloatRect self, FIFE::PointType2D< float > const & point) -> bool"""
        return _fife.FloatRect_contains(self, point)


    def intersects(self, rect):
        """intersects(FloatRect self, FloatRect rect) -> bool"""
        return _fife.FloatRect_intersects(self, rect)


    def intersectInplace(self, rect):
        """intersectInplace(FloatRect self, FloatRect rect) -> bool"""
        return _fife.FloatRect_intersectInplace(self, rect)


    def getX(self):
        """getX(FloatRect self) -> float"""
        return _fife.FloatRect_getX(self)


    def getY(self):
        """getY(FloatRect self) -> float"""
        return _fife.FloatRect_getY(self)


    def setX(self, _x):
        """setX(FloatRect self, float _x)"""
        return _fife.FloatRect_setX(self, _x)


    def setY(self, _y):
        """setY(FloatRect self, float _y)"""
        return _fife.FloatRect_setY(self, _y)


    def getW(self):
        """getW(FloatRect self) -> float"""
        return _fife.FloatRect_getW(self)


    def getH(self):
        """getH(FloatRect self) -> float"""
        return _fife.FloatRect_getH(self)


    def setW(self, _w):
        """setW(FloatRect self, float _w)"""
        return _fife.FloatRect_setW(self, _w)


    def setH(self, _h):
        """setH(FloatRect self, float _h)"""
        return _fife.FloatRect_setH(self, _h)


    def __str__(self):
        """__str__(FloatRect self) -> std::string"""
        return _fife.FloatRect___str__(self)

    __swig_destroy__ = _fife.delete_FloatRect
FloatRect.right = new_instancemethod(_fife.FloatRect_right, None, FloatRect)
FloatRect.bottom = new_instancemethod(_fife.FloatRect_bottom, None, FloatRect)
FloatRect.__eq__ = new_instancemethod(_fife.FloatRect___eq__, None, FloatRect)
FloatRect.contains = new_instancemethod(_fife.FloatRect_contains, None, FloatRect)
FloatRect.intersects = new_instancemethod(_fife.FloatRect_intersects, None, FloatRect)
FloatRect.intersectInplace = new_instancemethod(_fife.FloatRect_intersectInplace, None, FloatRect)
FloatRect.getX = new_instancemethod(_fife.FloatRect_getX, None, FloatRect)
FloatRect.getY = new_instancemethod(_fife.FloatRect_getY, None, FloatRect)
FloatRect.setX = new_instancemethod(_fife.FloatRect_setX, None, FloatRect)
FloatRect.setY = new_instancemethod(_fife.FloatRect_setY, None, FloatRect)
FloatRect.getW = new_instancemethod(_fife.FloatRect_getW, None, FloatRect)
FloatRect.getH = new_instancemethod(_fife.FloatRect_getH, None, FloatRect)
FloatRect.setW = new_instancemethod(_fife.FloatRect_setW, None, FloatRect)
FloatRect.setH = new_instancemethod(_fife.FloatRect_setH, None, FloatRect)
FloatRect.__str__ = new_instancemethod(_fife.FloatRect___str__, None, FloatRect)
FloatRect_swigregister = _fife.FloatRect_swigregister
FloatRect_swigregister(FloatRect)

class DoubleRect(object):
    """Proxy of C++ FIFE::RectType<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.DoubleRect_x_get, _fife.DoubleRect_x_set)
    y = _swig_property(_fife.DoubleRect_y_get, _fife.DoubleRect_y_set)
    w = _swig_property(_fife.DoubleRect_w_get, _fife.DoubleRect_w_set)
    h = _swig_property(_fife.DoubleRect_h_get, _fife.DoubleRect_h_set)

    def __init__(self, x=0, y=0, width=0, height=0):
        """__init__(FIFE::RectType<(double)> self, double x=0, double y=0, double width=0, double height=0) -> DoubleRect"""
        _fife.DoubleRect_swiginit(self, _fife.new_DoubleRect(x, y, width, height))

    def right(self):
        """right(DoubleRect self) -> double"""
        return _fife.DoubleRect_right(self)


    def bottom(self):
        """bottom(DoubleRect self) -> double"""
        return _fife.DoubleRect_bottom(self)


    def __eq__(self, rect):
        """__eq__(DoubleRect self, DoubleRect rect) -> bool"""
        return _fife.DoubleRect___eq__(self, rect)


    def contains(self, point):
        """contains(DoubleRect self, DoublePoint point) -> bool"""
        return _fife.DoubleRect_contains(self, point)


    def intersects(self, rect):
        """intersects(DoubleRect self, DoubleRect rect) -> bool"""
        return _fife.DoubleRect_intersects(self, rect)


    def intersectInplace(self, rect):
        """intersectInplace(DoubleRect self, DoubleRect rect) -> bool"""
        return _fife.DoubleRect_intersectInplace(self, rect)


    def getX(self):
        """getX(DoubleRect self) -> double"""
        return _fife.DoubleRect_getX(self)


    def getY(self):
        """getY(DoubleRect self) -> double"""
        return _fife.DoubleRect_getY(self)


    def setX(self, _x):
        """setX(DoubleRect self, double _x)"""
        return _fife.DoubleRect_setX(self, _x)


    def setY(self, _y):
        """setY(DoubleRect self, double _y)"""
        return _fife.DoubleRect_setY(self, _y)


    def getW(self):
        """getW(DoubleRect self) -> double"""
        return _fife.DoubleRect_getW(self)


    def getH(self):
        """getH(DoubleRect self) -> double"""
        return _fife.DoubleRect_getH(self)


    def setW(self, _w):
        """setW(DoubleRect self, double _w)"""
        return _fife.DoubleRect_setW(self, _w)


    def setH(self, _h):
        """setH(DoubleRect self, double _h)"""
        return _fife.DoubleRect_setH(self, _h)


    def __str__(self):
        """__str__(DoubleRect self) -> std::string"""
        return _fife.DoubleRect___str__(self)

    __swig_destroy__ = _fife.delete_DoubleRect
DoubleRect.right = new_instancemethod(_fife.DoubleRect_right, None, DoubleRect)
DoubleRect.bottom = new_instancemethod(_fife.DoubleRect_bottom, None, DoubleRect)
DoubleRect.__eq__ = new_instancemethod(_fife.DoubleRect___eq__, None, DoubleRect)
DoubleRect.contains = new_instancemethod(_fife.DoubleRect_contains, None, DoubleRect)
DoubleRect.intersects = new_instancemethod(_fife.DoubleRect_intersects, None, DoubleRect)
DoubleRect.intersectInplace = new_instancemethod(_fife.DoubleRect_intersectInplace, None, DoubleRect)
DoubleRect.getX = new_instancemethod(_fife.DoubleRect_getX, None, DoubleRect)
DoubleRect.getY = new_instancemethod(_fife.DoubleRect_getY, None, DoubleRect)
DoubleRect.setX = new_instancemethod(_fife.DoubleRect_setX, None, DoubleRect)
DoubleRect.setY = new_instancemethod(_fife.DoubleRect_setY, None, DoubleRect)
DoubleRect.getW = new_instancemethod(_fife.DoubleRect_getW, None, DoubleRect)
DoubleRect.getH = new_instancemethod(_fife.DoubleRect_getH, None, DoubleRect)
DoubleRect.setW = new_instancemethod(_fife.DoubleRect_setW, None, DoubleRect)
DoubleRect.setH = new_instancemethod(_fife.DoubleRect_setH, None, DoubleRect)
DoubleRect.__str__ = new_instancemethod(_fife.DoubleRect___str__, None, DoubleRect)
DoubleRect_swigregister = _fife.DoubleRect_swigregister
DoubleRect_swigregister(DoubleRect)

class FifePointVector(object):
    """Proxy of C++ std::vector<(FIFE::Point)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(FifePointVector self) -> SwigPyIterator"""
        return _fife.FifePointVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(FifePointVector self) -> bool"""
        return _fife.FifePointVector___nonzero__(self)


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


    def __len__(self):
        """__len__(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::size_type"""
        return _fife.FifePointVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::difference_type i, std::vector< FIFE::PointType2D< int > >::difference_type j) -> std::vector< FIFE::PointType2D< int32_t >,std::allocator< FIFE::PointType2D< int32_t > > > *"""
        return _fife.FifePointVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::difference_type i, std::vector< FIFE::PointType2D< int > >::difference_type j)
        __setslice__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::difference_type i, std::vector< FIFE::PointType2D< int > >::difference_type j, std::vector< FIFE::PointType2D< int32_t >,std::allocator< FIFE::PointType2D< int32_t > > > const & v)
        """
        return _fife.FifePointVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::difference_type i, std::vector< FIFE::PointType2D< int > >::difference_type j)"""
        return _fife.FifePointVector___delslice__(self, i, j)


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


    def __getitem__(self, *args):
        """
        __getitem__(FifePointVector self, PySliceObject * slice) -> std::vector< FIFE::PointType2D< int32_t >,std::allocator< FIFE::PointType2D< int32_t > > >
        __getitem__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::difference_type i) -> Point
        """
        return _fife.FifePointVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(FifePointVector self, PySliceObject * slice, std::vector< FIFE::PointType2D< int32_t >,std::allocator< FIFE::PointType2D< int32_t > > > const & v)
        __setitem__(FifePointVector self, PySliceObject * slice)
        __setitem__(FifePointVector self, std::vector< FIFE::PointType2D< int > >::difference_type i, Point x)
        """
        return _fife.FifePointVector___setitem__(self, *args)


    def pop(self):
        """pop(FifePointVector self) -> Point"""
        return _fife.FifePointVector_pop(self)


    def append(self, x):
        """append(FifePointVector self, Point x)"""
        return _fife.FifePointVector_append(self, x)


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


    def size(self):
        """size(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::size_type"""
        return _fife.FifePointVector_size(self)


    def swap(self, v):
        """swap(FifePointVector self, FifePointVector v)"""
        return _fife.FifePointVector_swap(self, v)


    def begin(self):
        """begin(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::iterator"""
        return _fife.FifePointVector_begin(self)


    def end(self):
        """end(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::iterator"""
        return _fife.FifePointVector_end(self)


    def rbegin(self):
        """rbegin(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::reverse_iterator"""
        return _fife.FifePointVector_rbegin(self)


    def rend(self):
        """rend(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::reverse_iterator"""
        return _fife.FifePointVector_rend(self)


    def clear(self):
        """clear(FifePointVector self)"""
        return _fife.FifePointVector_clear(self)


    def get_allocator(self):
        """get_allocator(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::allocator_type"""
        return _fife.FifePointVector_get_allocator(self)


    def pop_back(self):
        """pop_back(FifePointVector self)"""
        return _fife.FifePointVector_pop_back(self)


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


    def __init__(self, *args):
        """
        __init__(std::vector<(FIFE::Point)> self) -> FifePointVector
        __init__(std::vector<(FIFE::Point)> self, FifePointVector arg2) -> FifePointVector
        __init__(std::vector<(FIFE::Point)> self, std::vector< FIFE::PointType2D< int > >::size_type size) -> FifePointVector
        __init__(std::vector<(FIFE::Point)> self, std::vector< FIFE::PointType2D< int > >::size_type size, Point value) -> FifePointVector
        """
        _fife.FifePointVector_swiginit(self, _fife.new_FifePointVector(*args))

    def push_back(self, x):
        """push_back(FifePointVector self, Point x)"""
        return _fife.FifePointVector_push_back(self, x)


    def front(self):
        """front(FifePointVector self) -> Point"""
        return _fife.FifePointVector_front(self)


    def back(self):
        """back(FifePointVector self) -> Point"""
        return _fife.FifePointVector_back(self)


    def assign(self, n, x):
        """assign(FifePointVector self, std::vector< FIFE::PointType2D< int > >::size_type n, Point x)"""
        return _fife.FifePointVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(FifePointVector self, std::vector< FIFE::PointType2D< int > >::size_type new_size)
        resize(FifePointVector self, std::vector< FIFE::PointType2D< int > >::size_type new_size, Point x)
        """
        return _fife.FifePointVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(FifePointVector self, std::vector< FIFE::PointType2D< int > >::iterator pos, Point x) -> std::vector< FIFE::PointType2D< int > >::iterator
        insert(FifePointVector self, std::vector< FIFE::PointType2D< int > >::iterator pos, std::vector< FIFE::PointType2D< int > >::size_type n, Point x)
        """
        return _fife.FifePointVector_insert(self, *args)


    def reserve(self, n):
        """reserve(FifePointVector self, std::vector< FIFE::PointType2D< int > >::size_type n)"""
        return _fife.FifePointVector_reserve(self, n)


    def capacity(self):
        """capacity(FifePointVector self) -> std::vector< FIFE::PointType2D< int > >::size_type"""
        return _fife.FifePointVector_capacity(self)

    __swig_destroy__ = _fife.delete_FifePointVector
FifePointVector.iterator = new_instancemethod(_fife.FifePointVector_iterator, None, FifePointVector)
FifePointVector.__nonzero__ = new_instancemethod(_fife.FifePointVector___nonzero__, None, FifePointVector)
FifePointVector.__bool__ = new_instancemethod(_fife.FifePointVector___bool__, None, FifePointVector)
FifePointVector.__len__ = new_instancemethod(_fife.FifePointVector___len__, None, FifePointVector)
FifePointVector.__getslice__ = new_instancemethod(_fife.FifePointVector___getslice__, None, FifePointVector)
FifePointVector.__setslice__ = new_instancemethod(_fife.FifePointVector___setslice__, None, FifePointVector)
FifePointVector.__delslice__ = new_instancemethod(_fife.FifePointVector___delslice__, None, FifePointVector)
FifePointVector.__delitem__ = new_instancemethod(_fife.FifePointVector___delitem__, None, FifePointVector)
FifePointVector.__getitem__ = new_instancemethod(_fife.FifePointVector___getitem__, None, FifePointVector)
FifePointVector.__setitem__ = new_instancemethod(_fife.FifePointVector___setitem__, None, FifePointVector)
FifePointVector.pop = new_instancemethod(_fife.FifePointVector_pop, None, FifePointVector)
FifePointVector.append = new_instancemethod(_fife.FifePointVector_append, None, FifePointVector)
FifePointVector.empty = new_instancemethod(_fife.FifePointVector_empty, None, FifePointVector)
FifePointVector.size = new_instancemethod(_fife.FifePointVector_size, None, FifePointVector)
FifePointVector.swap = new_instancemethod(_fife.FifePointVector_swap, None, FifePointVector)
FifePointVector.begin = new_instancemethod(_fife.FifePointVector_begin, None, FifePointVector)
FifePointVector.end = new_instancemethod(_fife.FifePointVector_end, None, FifePointVector)
FifePointVector.rbegin = new_instancemethod(_fife.FifePointVector_rbegin, None, FifePointVector)
FifePointVector.rend = new_instancemethod(_fife.FifePointVector_rend, None, FifePointVector)
FifePointVector.clear = new_instancemethod(_fife.FifePointVector_clear, None, FifePointVector)
FifePointVector.get_allocator = new_instancemethod(_fife.FifePointVector_get_allocator, None, FifePointVector)
FifePointVector.pop_back = new_instancemethod(_fife.FifePointVector_pop_back, None, FifePointVector)
FifePointVector.erase = new_instancemethod(_fife.FifePointVector_erase, None, FifePointVector)
FifePointVector.push_back = new_instancemethod(_fife.FifePointVector_push_back, None, FifePointVector)
FifePointVector.front = new_instancemethod(_fife.FifePointVector_front, None, FifePointVector)
FifePointVector.back = new_instancemethod(_fife.FifePointVector_back, None, FifePointVector)
FifePointVector.assign = new_instancemethod(_fife.FifePointVector_assign, None, FifePointVector)
FifePointVector.resize = new_instancemethod(_fife.FifePointVector_resize, None, FifePointVector)
FifePointVector.insert = new_instancemethod(_fife.FifePointVector_insert, None, FifePointVector)
FifePointVector.reserve = new_instancemethod(_fife.FifePointVector_reserve, None, FifePointVector)
FifePointVector.capacity = new_instancemethod(_fife.FifePointVector_capacity, None, FifePointVector)
FifePointVector_swigregister = _fife.FifePointVector_swigregister
FifePointVector_swigregister(FifePointVector)

class AudioSpaceCoordinate(object):
    """Proxy of C++ FIFE::PointType3D<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.AudioSpaceCoordinate_x_get, _fife.AudioSpaceCoordinate_x_set)
    y = _swig_property(_fife.AudioSpaceCoordinate_y_get, _fife.AudioSpaceCoordinate_y_set)
    z = _swig_property(_fife.AudioSpaceCoordinate_z_get, _fife.AudioSpaceCoordinate_z_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType3D<(double)> self, double _x=0, double _y=0, double _z=0) -> AudioSpaceCoordinate
        __init__(FIFE::PointType3D<(double)> self, DoublePoint3D rhs) -> AudioSpaceCoordinate
        """
        _fife.AudioSpaceCoordinate_swiginit(self, _fife.new_AudioSpaceCoordinate(*args))

    def __add__(self, p):
        """__add__(AudioSpaceCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.AudioSpaceCoordinate___add__(self, p)


    def __sub__(self, p):
        """__sub__(AudioSpaceCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.AudioSpaceCoordinate___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(AudioSpaceCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.AudioSpaceCoordinate___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(AudioSpaceCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.AudioSpaceCoordinate___isub__(self, p)


    def __mul__(self, i):
        """__mul__(AudioSpaceCoordinate self, double const & i) -> DoublePoint3D"""
        return _fife.AudioSpaceCoordinate___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.AudioSpaceCoordinate___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(AudioSpaceCoordinate self, DoublePoint3D p) -> bool"""
        return _fife.AudioSpaceCoordinate___eq__(self, p)


    def __ne__(self, p):
        """__ne__(AudioSpaceCoordinate self, DoublePoint3D p) -> bool"""
        return _fife.AudioSpaceCoordinate___ne__(self, p)


    def length(self):
        """length(AudioSpaceCoordinate self) -> double"""
        return _fife.AudioSpaceCoordinate_length(self)


    def normalize(self):
        """normalize(AudioSpaceCoordinate self)"""
        return _fife.AudioSpaceCoordinate_normalize(self)


    def set(self, _x, _y, _z):
        """set(AudioSpaceCoordinate self, double _x, double _y, double _z)"""
        return _fife.AudioSpaceCoordinate_set(self, _x, _y, _z)

    __swig_destroy__ = _fife.delete_AudioSpaceCoordinate
AudioSpaceCoordinate.__add__ = new_instancemethod(_fife.AudioSpaceCoordinate___add__, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.__sub__ = new_instancemethod(_fife.AudioSpaceCoordinate___sub__, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.__iadd__ = new_instancemethod(_fife.AudioSpaceCoordinate___iadd__, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.__isub__ = new_instancemethod(_fife.AudioSpaceCoordinate___isub__, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.__mul__ = new_instancemethod(_fife.AudioSpaceCoordinate___mul__, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.__eq__ = new_instancemethod(_fife.AudioSpaceCoordinate___eq__, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.__ne__ = new_instancemethod(_fife.AudioSpaceCoordinate___ne__, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.length = new_instancemethod(_fife.AudioSpaceCoordinate_length, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.normalize = new_instancemethod(_fife.AudioSpaceCoordinate_normalize, None, AudioSpaceCoordinate)
AudioSpaceCoordinate.set = new_instancemethod(_fife.AudioSpaceCoordinate_set, None, AudioSpaceCoordinate)
AudioSpaceCoordinate_swigregister = _fife.AudioSpaceCoordinate_swigregister
AudioSpaceCoordinate_swigregister(AudioSpaceCoordinate)

class ModelCoordinate(object):
    """Proxy of C++ FIFE::PointType3D<(int32_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.ModelCoordinate_x_get, _fife.ModelCoordinate_x_set)
    y = _swig_property(_fife.ModelCoordinate_y_get, _fife.ModelCoordinate_y_set)
    z = _swig_property(_fife.ModelCoordinate_z_get, _fife.ModelCoordinate_z_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType3D<(int32_t)> self, int _x=0, int _y=0, int _z=0) -> ModelCoordinate
        __init__(FIFE::PointType3D<(int32_t)> self, Point3D rhs) -> ModelCoordinate
        """
        _fife.ModelCoordinate_swiginit(self, _fife.new_ModelCoordinate(*args))

    def __add__(self, p):
        """__add__(ModelCoordinate self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___add__(self, p)


    def __sub__(self, p):
        """__sub__(ModelCoordinate self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(ModelCoordinate self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(ModelCoordinate self, Point3D p) -> Point3D"""
        return _fife.ModelCoordinate___isub__(self, p)


    def __mul__(self, i):
        """__mul__(ModelCoordinate self, int const & i) -> Point3D"""
        return _fife.ModelCoordinate___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.ModelCoordinate___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(ModelCoordinate self, Point3D p) -> bool"""
        return _fife.ModelCoordinate___eq__(self, p)


    def __ne__(self, p):
        """__ne__(ModelCoordinate self, Point3D p) -> bool"""
        return _fife.ModelCoordinate___ne__(self, p)


    def length(self):
        """length(ModelCoordinate self) -> int"""
        return _fife.ModelCoordinate_length(self)


    def normalize(self):
        """normalize(ModelCoordinate self)"""
        return _fife.ModelCoordinate_normalize(self)


    def set(self, _x, _y, _z):
        """set(ModelCoordinate self, int _x, int _y, int _z)"""
        return _fife.ModelCoordinate_set(self, _x, _y, _z)

    __swig_destroy__ = _fife.delete_ModelCoordinate
ModelCoordinate.__add__ = new_instancemethod(_fife.ModelCoordinate___add__, None, ModelCoordinate)
ModelCoordinate.__sub__ = new_instancemethod(_fife.ModelCoordinate___sub__, None, ModelCoordinate)
ModelCoordinate.__iadd__ = new_instancemethod(_fife.ModelCoordinate___iadd__, None, ModelCoordinate)
ModelCoordinate.__isub__ = new_instancemethod(_fife.ModelCoordinate___isub__, None, ModelCoordinate)
ModelCoordinate.__mul__ = new_instancemethod(_fife.ModelCoordinate___mul__, None, ModelCoordinate)
ModelCoordinate.__eq__ = new_instancemethod(_fife.ModelCoordinate___eq__, None, ModelCoordinate)
ModelCoordinate.__ne__ = new_instancemethod(_fife.ModelCoordinate___ne__, None, ModelCoordinate)
ModelCoordinate.length = new_instancemethod(_fife.ModelCoordinate_length, None, ModelCoordinate)
ModelCoordinate.normalize = new_instancemethod(_fife.ModelCoordinate_normalize, None, ModelCoordinate)
ModelCoordinate.set = new_instancemethod(_fife.ModelCoordinate_set, None, ModelCoordinate)
ModelCoordinate_swigregister = _fife.ModelCoordinate_swigregister
ModelCoordinate_swigregister(ModelCoordinate)

class ExactModelCoordinate(object):
    """Proxy of C++ FIFE::PointType3D<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.ExactModelCoordinate_x_get, _fife.ExactModelCoordinate_x_set)
    y = _swig_property(_fife.ExactModelCoordinate_y_get, _fife.ExactModelCoordinate_y_set)
    z = _swig_property(_fife.ExactModelCoordinate_z_get, _fife.ExactModelCoordinate_z_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType3D<(double)> self, double _x=0, double _y=0, double _z=0) -> ExactModelCoordinate
        __init__(FIFE::PointType3D<(double)> self, DoublePoint3D rhs) -> ExactModelCoordinate
        """
        _fife.ExactModelCoordinate_swiginit(self, _fife.new_ExactModelCoordinate(*args))

    def __add__(self, p):
        """__add__(ExactModelCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___add__(self, p)


    def __sub__(self, p):
        """__sub__(ExactModelCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(ExactModelCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(ExactModelCoordinate self, DoublePoint3D p) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___isub__(self, p)


    def __mul__(self, i):
        """__mul__(ExactModelCoordinate self, double const & i) -> DoublePoint3D"""
        return _fife.ExactModelCoordinate___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.ExactModelCoordinate___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(ExactModelCoordinate self, DoublePoint3D p) -> bool"""
        return _fife.ExactModelCoordinate___eq__(self, p)


    def __ne__(self, p):
        """__ne__(ExactModelCoordinate self, DoublePoint3D p) -> bool"""
        return _fife.ExactModelCoordinate___ne__(self, p)


    def length(self):
        """length(ExactModelCoordinate self) -> double"""
        return _fife.ExactModelCoordinate_length(self)


    def normalize(self):
        """normalize(ExactModelCoordinate self)"""
        return _fife.ExactModelCoordinate_normalize(self)


    def set(self, _x, _y, _z):
        """set(ExactModelCoordinate self, double _x, double _y, double _z)"""
        return _fife.ExactModelCoordinate_set(self, _x, _y, _z)


    def __str__(self):
        """__str__(ExactModelCoordinate self) -> std::string"""
        return _fife.ExactModelCoordinate___str__(self)

    __swig_destroy__ = _fife.delete_ExactModelCoordinate
ExactModelCoordinate.__add__ = new_instancemethod(_fife.ExactModelCoordinate___add__, None, ExactModelCoordinate)
ExactModelCoordinate.__sub__ = new_instancemethod(_fife.ExactModelCoordinate___sub__, None, ExactModelCoordinate)
ExactModelCoordinate.__iadd__ = new_instancemethod(_fife.ExactModelCoordinate___iadd__, None, ExactModelCoordinate)
ExactModelCoordinate.__isub__ = new_instancemethod(_fife.ExactModelCoordinate___isub__, None, ExactModelCoordinate)
ExactModelCoordinate.__mul__ = new_instancemethod(_fife.ExactModelCoordinate___mul__, None, ExactModelCoordinate)
ExactModelCoordinate.__eq__ = new_instancemethod(_fife.ExactModelCoordinate___eq__, None, ExactModelCoordinate)
ExactModelCoordinate.__ne__ = new_instancemethod(_fife.ExactModelCoordinate___ne__, None, ExactModelCoordinate)
ExactModelCoordinate.length = new_instancemethod(_fife.ExactModelCoordinate_length, None, ExactModelCoordinate)
ExactModelCoordinate.normalize = new_instancemethod(_fife.ExactModelCoordinate_normalize, None, ExactModelCoordinate)
ExactModelCoordinate.set = new_instancemethod(_fife.ExactModelCoordinate_set, None, ExactModelCoordinate)
ExactModelCoordinate.__str__ = new_instancemethod(_fife.ExactModelCoordinate___str__, None, ExactModelCoordinate)
ExactModelCoordinate_swigregister = _fife.ExactModelCoordinate_swigregister
ExactModelCoordinate_swigregister(ExactModelCoordinate)

SE_EFFECT_NULL = _fife.SE_EFFECT_NULL
SE_EFFECT_REVERB = _fife.SE_EFFECT_REVERB
SE_EFFECT_CHORUS = _fife.SE_EFFECT_CHORUS
SE_EFFECT_DISTORTION = _fife.SE_EFFECT_DISTORTION
SE_EFFECT_ECHO = _fife.SE_EFFECT_ECHO
SE_EFFECT_FLANGER = _fife.SE_EFFECT_FLANGER
SE_EFFECT_FREQUENCY_SHIFTER = _fife.SE_EFFECT_FREQUENCY_SHIFTER
SE_EFFECT_VOCAL_MORPHER = _fife.SE_EFFECT_VOCAL_MORPHER
SE_EFFECT_PITCH_SHIFTER = _fife.SE_EFFECT_PITCH_SHIFTER
SE_EFFECT_RING_MODULATOR = _fife.SE_EFFECT_RING_MODULATOR
SE_EFFECT_AUTOWAH = _fife.SE_EFFECT_AUTOWAH
SE_EFFECT_COMPRESSOR = _fife.SE_EFFECT_COMPRESSOR
SE_EFFECT_EQUALIZER = _fife.SE_EFFECT_EQUALIZER
SE_EFFECT_EAXREVERB = _fife.SE_EFFECT_EAXREVERB
class SoundEffect(object):
    """Proxy of C++ FIFE::SoundEffect class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getEffectType(self):
        """getEffectType(SoundEffect self) -> FIFE::SoundEffectType"""
        return _fife.SoundEffect_getEffectType(self)


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

    __swig_destroy__ = _fife.delete_SoundEffect
SoundEffect.getEffectType = new_instancemethod(_fife.SoundEffect_getEffectType, None, SoundEffect)
SoundEffect.isEnabled = new_instancemethod(_fife.SoundEffect_isEnabled, None, SoundEffect)
SoundEffect_swigregister = _fife.SoundEffect_swigregister
SoundEffect_swigregister(SoundEffect)

class Reverb(SoundEffect):
    """Proxy of C++ FIFE::Reverb class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setDensity(self, value):
        """setDensity(Reverb self, float value)"""
        return _fife.Reverb_setDensity(self, value)


    def getDensity(self):
        """getDensity(Reverb self) -> float"""
        return _fife.Reverb_getDensity(self)


    def setDiffusion(self, value):
        """setDiffusion(Reverb self, float value)"""
        return _fife.Reverb_setDiffusion(self, value)


    def getDiffusion(self):
        """getDiffusion(Reverb self) -> float"""
        return _fife.Reverb_getDiffusion(self)


    def setGain(self, value):
        """setGain(Reverb self, float value)"""
        return _fife.Reverb_setGain(self, value)


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


    def setGainHf(self, value):
        """setGainHf(Reverb self, float value)"""
        return _fife.Reverb_setGainHf(self, value)


    def getGainHf(self):
        """getGainHf(Reverb self) -> float"""
        return _fife.Reverb_getGainHf(self)


    def setDecayTime(self, value):
        """setDecayTime(Reverb self, float value)"""
        return _fife.Reverb_setDecayTime(self, value)


    def getDecayTime(self):
        """getDecayTime(Reverb self) -> float"""
        return _fife.Reverb_getDecayTime(self)


    def setDecayHfRatio(self, value):
        """setDecayHfRatio(Reverb self, float value)"""
        return _fife.Reverb_setDecayHfRatio(self, value)


    def getDecayHfRatio(self):
        """getDecayHfRatio(Reverb self) -> float"""
        return _fife.Reverb_getDecayHfRatio(self)


    def setReflectionsGain(self, value):
        """setReflectionsGain(Reverb self, float value)"""
        return _fife.Reverb_setReflectionsGain(self, value)


    def getReflectionsGain(self):
        """getReflectionsGain(Reverb self) -> float"""
        return _fife.Reverb_getReflectionsGain(self)


    def setReflectionsDelay(self, value):
        """setReflectionsDelay(Reverb self, float value)"""
        return _fife.Reverb_setReflectionsDelay(self, value)


    def getReflectionsDelay(self):
        """getReflectionsDelay(Reverb self) -> float"""
        return _fife.Reverb_getReflectionsDelay(self)


    def setLateReverbGain(self, value):
        """setLateReverbGain(Reverb self, float value)"""
        return _fife.Reverb_setLateReverbGain(self, value)


    def getLateReverbGain(self):
        """getLateReverbGain(Reverb self) -> float"""
        return _fife.Reverb_getLateReverbGain(self)


    def setLateReverbDelay(self, value):
        """setLateReverbDelay(Reverb self, float value)"""
        return _fife.Reverb_setLateReverbDelay(self, value)


    def getLateReverbDelay(self):
        """getLateReverbDelay(Reverb self) -> float"""
        return _fife.Reverb_getLateReverbDelay(self)


    def setAirAbsorptionGainHf(self, value):
        """setAirAbsorptionGainHf(Reverb self, float value)"""
        return _fife.Reverb_setAirAbsorptionGainHf(self, value)


    def getAirAbsorptionGainHf(self):
        """getAirAbsorptionGainHf(Reverb self) -> float"""
        return _fife.Reverb_getAirAbsorptionGainHf(self)


    def setRoomRolloffFactor(self, value):
        """setRoomRolloffFactor(Reverb self, float value)"""
        return _fife.Reverb_setRoomRolloffFactor(self, value)


    def getRoomRolloffFactor(self):
        """getRoomRolloffFactor(Reverb self) -> float"""
        return _fife.Reverb_getRoomRolloffFactor(self)


    def setDecayHfLimit(self, value):
        """setDecayHfLimit(Reverb self, bool value)"""
        return _fife.Reverb_setDecayHfLimit(self, value)


    def isDecayHfLimit(self):
        """isDecayHfLimit(Reverb self) -> bool"""
        return _fife.Reverb_isDecayHfLimit(self)

    __swig_destroy__ = _fife.delete_Reverb
Reverb.setDensity = new_instancemethod(_fife.Reverb_setDensity, None, Reverb)
Reverb.getDensity = new_instancemethod(_fife.Reverb_getDensity, None, Reverb)
Reverb.setDiffusion = new_instancemethod(_fife.Reverb_setDiffusion, None, Reverb)
Reverb.getDiffusion = new_instancemethod(_fife.Reverb_getDiffusion, None, Reverb)
Reverb.setGain = new_instancemethod(_fife.Reverb_setGain, None, Reverb)
Reverb.getGain = new_instancemethod(_fife.Reverb_getGain, None, Reverb)
Reverb.setGainHf = new_instancemethod(_fife.Reverb_setGainHf, None, Reverb)
Reverb.getGainHf = new_instancemethod(_fife.Reverb_getGainHf, None, Reverb)
Reverb.setDecayTime = new_instancemethod(_fife.Reverb_setDecayTime, None, Reverb)
Reverb.getDecayTime = new_instancemethod(_fife.Reverb_getDecayTime, None, Reverb)
Reverb.setDecayHfRatio = new_instancemethod(_fife.Reverb_setDecayHfRatio, None, Reverb)
Reverb.getDecayHfRatio = new_instancemethod(_fife.Reverb_getDecayHfRatio, None, Reverb)
Reverb.setReflectionsGain = new_instancemethod(_fife.Reverb_setReflectionsGain, None, Reverb)
Reverb.getReflectionsGain = new_instancemethod(_fife.Reverb_getReflectionsGain, None, Reverb)
Reverb.setReflectionsDelay = new_instancemethod(_fife.Reverb_setReflectionsDelay, None, Reverb)
Reverb.getReflectionsDelay = new_instancemethod(_fife.Reverb_getReflectionsDelay, None, Reverb)
Reverb.setLateReverbGain = new_instancemethod(_fife.Reverb_setLateReverbGain, None, Reverb)
Reverb.getLateReverbGain = new_instancemethod(_fife.Reverb_getLateReverbGain, None, Reverb)
Reverb.setLateReverbDelay = new_instancemethod(_fife.Reverb_setLateReverbDelay, None, Reverb)
Reverb.getLateReverbDelay = new_instancemethod(_fife.Reverb_getLateReverbDelay, None, Reverb)
Reverb.setAirAbsorptionGainHf = new_instancemethod(_fife.Reverb_setAirAbsorptionGainHf, None, Reverb)
Reverb.getAirAbsorptionGainHf = new_instancemethod(_fife.Reverb_getAirAbsorptionGainHf, None, Reverb)
Reverb.setRoomRolloffFactor = new_instancemethod(_fife.Reverb_setRoomRolloffFactor, None, Reverb)
Reverb.getRoomRolloffFactor = new_instancemethod(_fife.Reverb_getRoomRolloffFactor, None, Reverb)
Reverb.setDecayHfLimit = new_instancemethod(_fife.Reverb_setDecayHfLimit, None, Reverb)
Reverb.isDecayHfLimit = new_instancemethod(_fife.Reverb_isDecayHfLimit, None, Reverb)
Reverb_swigregister = _fife.Reverb_swigregister
Reverb_swigregister(Reverb)

class Chorus(SoundEffect):
    """Proxy of C++ FIFE::Chorus class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setWaveformTriangle(self, value):
        """setWaveformTriangle(Chorus self, bool value)"""
        return _fife.Chorus_setWaveformTriangle(self, value)


    def isWaveformTriangle(self):
        """isWaveformTriangle(Chorus self) -> bool"""
        return _fife.Chorus_isWaveformTriangle(self)


    def setPhase(self, value):
        """setPhase(Chorus self, int32_t value)"""
        return _fife.Chorus_setPhase(self, value)


    def getPhase(self):
        """getPhase(Chorus self) -> int32_t"""
        return _fife.Chorus_getPhase(self)


    def setRate(self, value):
        """setRate(Chorus self, float value)"""
        return _fife.Chorus_setRate(self, value)


    def getRate(self):
        """getRate(Chorus self) -> float"""
        return _fife.Chorus_getRate(self)


    def setDepth(self, value):
        """setDepth(Chorus self, float value)"""
        return _fife.Chorus_setDepth(self, value)


    def getDepth(self):
        """getDepth(Chorus self) -> float"""
        return _fife.Chorus_getDepth(self)


    def setFeedback(self, value):
        """setFeedback(Chorus self, float value)"""
        return _fife.Chorus_setFeedback(self, value)


    def getFeedback(self):
        """getFeedback(Chorus self) -> float"""
        return _fife.Chorus_getFeedback(self)


    def setDelay(self, value):
        """setDelay(Chorus self, float value)"""
        return _fife.Chorus_setDelay(self, value)


    def getDelay(self):
        """getDelay(Chorus self) -> float"""
        return _fife.Chorus_getDelay(self)

    __swig_destroy__ = _fife.delete_Chorus
Chorus.setWaveformTriangle = new_instancemethod(_fife.Chorus_setWaveformTriangle, None, Chorus)
Chorus.isWaveformTriangle = new_instancemethod(_fife.Chorus_isWaveformTriangle, None, Chorus)
Chorus.setPhase = new_instancemethod(_fife.Chorus_setPhase, None, Chorus)
Chorus.getPhase = new_instancemethod(_fife.Chorus_getPhase, None, Chorus)
Chorus.setRate = new_instancemethod(_fife.Chorus_setRate, None, Chorus)
Chorus.getRate = new_instancemethod(_fife.Chorus_getRate, None, Chorus)
Chorus.setDepth = new_instancemethod(_fife.Chorus_setDepth, None, Chorus)
Chorus.getDepth = new_instancemethod(_fife.Chorus_getDepth, None, Chorus)
Chorus.setFeedback = new_instancemethod(_fife.Chorus_setFeedback, None, Chorus)
Chorus.getFeedback = new_instancemethod(_fife.Chorus_getFeedback, None, Chorus)
Chorus.setDelay = new_instancemethod(_fife.Chorus_setDelay, None, Chorus)
Chorus.getDelay = new_instancemethod(_fife.Chorus_getDelay, None, Chorus)
Chorus_swigregister = _fife.Chorus_swigregister
Chorus_swigregister(Chorus)

class Distortion(SoundEffect):
    """Proxy of C++ FIFE::Distortion class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setEdge(self, value):
        """setEdge(Distortion self, float value)"""
        return _fife.Distortion_setEdge(self, value)


    def getEdge(self):
        """getEdge(Distortion self) -> float"""
        return _fife.Distortion_getEdge(self)


    def setGain(self, value):
        """setGain(Distortion self, float value)"""
        return _fife.Distortion_setGain(self, value)


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


    def setLowpassCutoff(self, value):
        """setLowpassCutoff(Distortion self, float value)"""
        return _fife.Distortion_setLowpassCutoff(self, value)


    def getLowpassCutoff(self):
        """getLowpassCutoff(Distortion self) -> float"""
        return _fife.Distortion_getLowpassCutoff(self)


    def setEqCenter(self, value):
        """setEqCenter(Distortion self, float value)"""
        return _fife.Distortion_setEqCenter(self, value)


    def getEqCenter(self):
        """getEqCenter(Distortion self) -> float"""
        return _fife.Distortion_getEqCenter(self)


    def setEqBandwidth(self, value):
        """setEqBandwidth(Distortion self, float value)"""
        return _fife.Distortion_setEqBandwidth(self, value)


    def getEqBandwidth(self):
        """getEqBandwidth(Distortion self) -> float"""
        return _fife.Distortion_getEqBandwidth(self)

    __swig_destroy__ = _fife.delete_Distortion
Distortion.setEdge = new_instancemethod(_fife.Distortion_setEdge, None, Distortion)
Distortion.getEdge = new_instancemethod(_fife.Distortion_getEdge, None, Distortion)
Distortion.setGain = new_instancemethod(_fife.Distortion_setGain, None, Distortion)
Distortion.getGain = new_instancemethod(_fife.Distortion_getGain, None, Distortion)
Distortion.setLowpassCutoff = new_instancemethod(_fife.Distortion_setLowpassCutoff, None, Distortion)
Distortion.getLowpassCutoff = new_instancemethod(_fife.Distortion_getLowpassCutoff, None, Distortion)
Distortion.setEqCenter = new_instancemethod(_fife.Distortion_setEqCenter, None, Distortion)
Distortion.getEqCenter = new_instancemethod(_fife.Distortion_getEqCenter, None, Distortion)
Distortion.setEqBandwidth = new_instancemethod(_fife.Distortion_setEqBandwidth, None, Distortion)
Distortion.getEqBandwidth = new_instancemethod(_fife.Distortion_getEqBandwidth, None, Distortion)
Distortion_swigregister = _fife.Distortion_swigregister
Distortion_swigregister(Distortion)

class Echo(SoundEffect):
    """Proxy of C++ FIFE::Echo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setDelay(self, value):
        """setDelay(Echo self, float value)"""
        return _fife.Echo_setDelay(self, value)


    def getDelay(self):
        """getDelay(Echo self) -> float"""
        return _fife.Echo_getDelay(self)


    def setLrDelay(self, value):
        """setLrDelay(Echo self, float value)"""
        return _fife.Echo_setLrDelay(self, value)


    def getLrDelay(self):
        """getLrDelay(Echo self) -> float"""
        return _fife.Echo_getLrDelay(self)


    def setDamping(self, value):
        """setDamping(Echo self, float value)"""
        return _fife.Echo_setDamping(self, value)


    def getDamping(self):
        """getDamping(Echo self) -> float"""
        return _fife.Echo_getDamping(self)


    def setFeedback(self, value):
        """setFeedback(Echo self, float value)"""
        return _fife.Echo_setFeedback(self, value)


    def getFeedback(self):
        """getFeedback(Echo self) -> float"""
        return _fife.Echo_getFeedback(self)


    def setSpread(self, value):
        """setSpread(Echo self, float value)"""
        return _fife.Echo_setSpread(self, value)


    def getSpread(self):
        """getSpread(Echo self) -> float"""
        return _fife.Echo_getSpread(self)

    __swig_destroy__ = _fife.delete_Echo
Echo.setDelay = new_instancemethod(_fife.Echo_setDelay, None, Echo)
Echo.getDelay = new_instancemethod(_fife.Echo_getDelay, None, Echo)
Echo.setLrDelay = new_instancemethod(_fife.Echo_setLrDelay, None, Echo)
Echo.getLrDelay = new_instancemethod(_fife.Echo_getLrDelay, None, Echo)
Echo.setDamping = new_instancemethod(_fife.Echo_setDamping, None, Echo)
Echo.getDamping = new_instancemethod(_fife.Echo_getDamping, None, Echo)
Echo.setFeedback = new_instancemethod(_fife.Echo_setFeedback, None, Echo)
Echo.getFeedback = new_instancemethod(_fife.Echo_getFeedback, None, Echo)
Echo.setSpread = new_instancemethod(_fife.Echo_setSpread, None, Echo)
Echo.getSpread = new_instancemethod(_fife.Echo_getSpread, None, Echo)
Echo_swigregister = _fife.Echo_swigregister
Echo_swigregister(Echo)

class Flanger(SoundEffect):
    """Proxy of C++ FIFE::Flanger class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setWaveformTriangle(self, value):
        """setWaveformTriangle(Flanger self, bool value)"""
        return _fife.Flanger_setWaveformTriangle(self, value)


    def isWaveformTriangle(self):
        """isWaveformTriangle(Flanger self) -> bool"""
        return _fife.Flanger_isWaveformTriangle(self)


    def setPhase(self, value):
        """setPhase(Flanger self, int32_t value)"""
        return _fife.Flanger_setPhase(self, value)


    def getPhase(self):
        """getPhase(Flanger self) -> int32_t"""
        return _fife.Flanger_getPhase(self)


    def setRate(self, value):
        """setRate(Flanger self, float value)"""
        return _fife.Flanger_setRate(self, value)


    def getRate(self):
        """getRate(Flanger self) -> float"""
        return _fife.Flanger_getRate(self)


    def setDepth(self, value):
        """setDepth(Flanger self, float value)"""
        return _fife.Flanger_setDepth(self, value)


    def getDepth(self):
        """getDepth(Flanger self) -> float"""
        return _fife.Flanger_getDepth(self)


    def setFeedback(self, value):
        """setFeedback(Flanger self, float value)"""
        return _fife.Flanger_setFeedback(self, value)


    def getFeedback(self):
        """getFeedback(Flanger self) -> float"""
        return _fife.Flanger_getFeedback(self)


    def setDelay(self, value):
        """setDelay(Flanger self, float value)"""
        return _fife.Flanger_setDelay(self, value)


    def getDelay(self):
        """getDelay(Flanger self) -> float"""
        return _fife.Flanger_getDelay(self)

    __swig_destroy__ = _fife.delete_Flanger
Flanger.setWaveformTriangle = new_instancemethod(_fife.Flanger_setWaveformTriangle, None, Flanger)
Flanger.isWaveformTriangle = new_instancemethod(_fife.Flanger_isWaveformTriangle, None, Flanger)
Flanger.setPhase = new_instancemethod(_fife.Flanger_setPhase, None, Flanger)
Flanger.getPhase = new_instancemethod(_fife.Flanger_getPhase, None, Flanger)
Flanger.setRate = new_instancemethod(_fife.Flanger_setRate, None, Flanger)
Flanger.getRate = new_instancemethod(_fife.Flanger_getRate, None, Flanger)
Flanger.setDepth = new_instancemethod(_fife.Flanger_setDepth, None, Flanger)
Flanger.getDepth = new_instancemethod(_fife.Flanger_getDepth, None, Flanger)
Flanger.setFeedback = new_instancemethod(_fife.Flanger_setFeedback, None, Flanger)
Flanger.getFeedback = new_instancemethod(_fife.Flanger_getFeedback, None, Flanger)
Flanger.setDelay = new_instancemethod(_fife.Flanger_setDelay, None, Flanger)
Flanger.getDelay = new_instancemethod(_fife.Flanger_getDelay, None, Flanger)
Flanger_swigregister = _fife.Flanger_swigregister
Flanger_swigregister(Flanger)

class FrequencyShifter(SoundEffect):
    """Proxy of C++ FIFE::FrequencyShifter class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setFrequency(self, value):
        """setFrequency(FrequencyShifter self, float value)"""
        return _fife.FrequencyShifter_setFrequency(self, value)


    def getFrequency(self):
        """getFrequency(FrequencyShifter self) -> float"""
        return _fife.FrequencyShifter_getFrequency(self)


    def setLeftDirection(self, value):
        """setLeftDirection(FrequencyShifter self, uint8_t value)"""
        return _fife.FrequencyShifter_setLeftDirection(self, value)


    def getLeftDirection(self):
        """getLeftDirection(FrequencyShifter self) -> uint8_t"""
        return _fife.FrequencyShifter_getLeftDirection(self)


    def setRightDirection(self, value):
        """setRightDirection(FrequencyShifter self, uint8_t value)"""
        return _fife.FrequencyShifter_setRightDirection(self, value)


    def getRightDirection(self):
        """getRightDirection(FrequencyShifter self) -> uint8_t"""
        return _fife.FrequencyShifter_getRightDirection(self)

    __swig_destroy__ = _fife.delete_FrequencyShifter
FrequencyShifter.setFrequency = new_instancemethod(_fife.FrequencyShifter_setFrequency, None, FrequencyShifter)
FrequencyShifter.getFrequency = new_instancemethod(_fife.FrequencyShifter_getFrequency, None, FrequencyShifter)
FrequencyShifter.setLeftDirection = new_instancemethod(_fife.FrequencyShifter_setLeftDirection, None, FrequencyShifter)
FrequencyShifter.getLeftDirection = new_instancemethod(_fife.FrequencyShifter_getLeftDirection, None, FrequencyShifter)
FrequencyShifter.setRightDirection = new_instancemethod(_fife.FrequencyShifter_setRightDirection, None, FrequencyShifter)
FrequencyShifter.getRightDirection = new_instancemethod(_fife.FrequencyShifter_getRightDirection, None, FrequencyShifter)
FrequencyShifter_swigregister = _fife.FrequencyShifter_swigregister
FrequencyShifter_swigregister(FrequencyShifter)

class VocalMorpher(SoundEffect):
    """Proxy of C++ FIFE::VocalMorpher class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setPhonemeA(self, value):
        """setPhonemeA(VocalMorpher self, uint16_t value)"""
        return _fife.VocalMorpher_setPhonemeA(self, value)


    def getPhonemeA(self):
        """getPhonemeA(VocalMorpher self) -> uint16_t"""
        return _fife.VocalMorpher_getPhonemeA(self)


    def setPhonemeB(self, value):
        """setPhonemeB(VocalMorpher self, uint16_t value)"""
        return _fife.VocalMorpher_setPhonemeB(self, value)


    def getPhonemeB(self):
        """getPhonemeB(VocalMorpher self) -> uint16_t"""
        return _fife.VocalMorpher_getPhonemeB(self)


    def setPhonemeCoarseA(self, value):
        """setPhonemeCoarseA(VocalMorpher self, int16_t value)"""
        return _fife.VocalMorpher_setPhonemeCoarseA(self, value)


    def getPhonemeCoarseA(self):
        """getPhonemeCoarseA(VocalMorpher self) -> int16_t"""
        return _fife.VocalMorpher_getPhonemeCoarseA(self)


    def setPhonemeCoarseB(self, value):
        """setPhonemeCoarseB(VocalMorpher self, int16_t value)"""
        return _fife.VocalMorpher_setPhonemeCoarseB(self, value)


    def getPhonemeCoarseB(self):
        """getPhonemeCoarseB(VocalMorpher self) -> int16_t"""
        return _fife.VocalMorpher_getPhonemeCoarseB(self)


    def setWaveform(self, value):
        """setWaveform(VocalMorpher self, uint8_t value)"""
        return _fife.VocalMorpher_setWaveform(self, value)


    def getWaveform(self):
        """getWaveform(VocalMorpher self) -> uint8_t"""
        return _fife.VocalMorpher_getWaveform(self)


    def setRate(self, value):
        """setRate(VocalMorpher self, float value)"""
        return _fife.VocalMorpher_setRate(self, value)


    def getRate(self):
        """getRate(VocalMorpher self) -> float"""
        return _fife.VocalMorpher_getRate(self)

    __swig_destroy__ = _fife.delete_VocalMorpher
VocalMorpher.setPhonemeA = new_instancemethod(_fife.VocalMorpher_setPhonemeA, None, VocalMorpher)
VocalMorpher.getPhonemeA = new_instancemethod(_fife.VocalMorpher_getPhonemeA, None, VocalMorpher)
VocalMorpher.setPhonemeB = new_instancemethod(_fife.VocalMorpher_setPhonemeB, None, VocalMorpher)
VocalMorpher.getPhonemeB = new_instancemethod(_fife.VocalMorpher_getPhonemeB, None, VocalMorpher)
VocalMorpher.setPhonemeCoarseA = new_instancemethod(_fife.VocalMorpher_setPhonemeCoarseA, None, VocalMorpher)
VocalMorpher.getPhonemeCoarseA = new_instancemethod(_fife.VocalMorpher_getPhonemeCoarseA, None, VocalMorpher)
VocalMorpher.setPhonemeCoarseB = new_instancemethod(_fife.VocalMorpher_setPhonemeCoarseB, None, VocalMorpher)
VocalMorpher.getPhonemeCoarseB = new_instancemethod(_fife.VocalMorpher_getPhonemeCoarseB, None, VocalMorpher)
VocalMorpher.setWaveform = new_instancemethod(_fife.VocalMorpher_setWaveform, None, VocalMorpher)
VocalMorpher.getWaveform = new_instancemethod(_fife.VocalMorpher_getWaveform, None, VocalMorpher)
VocalMorpher.setRate = new_instancemethod(_fife.VocalMorpher_setRate, None, VocalMorpher)
VocalMorpher.getRate = new_instancemethod(_fife.VocalMorpher_getRate, None, VocalMorpher)
VocalMorpher_swigregister = _fife.VocalMorpher_swigregister
VocalMorpher_swigregister(VocalMorpher)

class PitchShifter(SoundEffect):
    """Proxy of C++ FIFE::PitchShifter class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setCoarseTune(self, value):
        """setCoarseTune(PitchShifter self, int16_t value)"""
        return _fife.PitchShifter_setCoarseTune(self, value)


    def getCoarseTune(self):
        """getCoarseTune(PitchShifter self) -> int16_t"""
        return _fife.PitchShifter_getCoarseTune(self)


    def setFineTune(self, value):
        """setFineTune(PitchShifter self, int16_t value)"""
        return _fife.PitchShifter_setFineTune(self, value)


    def getFineTune(self):
        """getFineTune(PitchShifter self) -> int16_t"""
        return _fife.PitchShifter_getFineTune(self)

    __swig_destroy__ = _fife.delete_PitchShifter
PitchShifter.setCoarseTune = new_instancemethod(_fife.PitchShifter_setCoarseTune, None, PitchShifter)
PitchShifter.getCoarseTune = new_instancemethod(_fife.PitchShifter_getCoarseTune, None, PitchShifter)
PitchShifter.setFineTune = new_instancemethod(_fife.PitchShifter_setFineTune, None, PitchShifter)
PitchShifter.getFineTune = new_instancemethod(_fife.PitchShifter_getFineTune, None, PitchShifter)
PitchShifter_swigregister = _fife.PitchShifter_swigregister
PitchShifter_swigregister(PitchShifter)

class RingModulator(SoundEffect):
    """Proxy of C++ FIFE::RingModulator class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setFrequency(self, value):
        """setFrequency(RingModulator self, float value)"""
        return _fife.RingModulator_setFrequency(self, value)


    def getFrequency(self):
        """getFrequency(RingModulator self) -> float"""
        return _fife.RingModulator_getFrequency(self)


    def setHighpassCutoff(self, value):
        """setHighpassCutoff(RingModulator self, float value)"""
        return _fife.RingModulator_setHighpassCutoff(self, value)


    def getHighpassCutoff(self):
        """getHighpassCutoff(RingModulator self) -> float"""
        return _fife.RingModulator_getHighpassCutoff(self)


    def setWaveform(self, value):
        """setWaveform(RingModulator self, uint8_t value)"""
        return _fife.RingModulator_setWaveform(self, value)


    def getWaveform(self):
        """getWaveform(RingModulator self) -> uint8_t"""
        return _fife.RingModulator_getWaveform(self)

    __swig_destroy__ = _fife.delete_RingModulator
RingModulator.setFrequency = new_instancemethod(_fife.RingModulator_setFrequency, None, RingModulator)
RingModulator.getFrequency = new_instancemethod(_fife.RingModulator_getFrequency, None, RingModulator)
RingModulator.setHighpassCutoff = new_instancemethod(_fife.RingModulator_setHighpassCutoff, None, RingModulator)
RingModulator.getHighpassCutoff = new_instancemethod(_fife.RingModulator_getHighpassCutoff, None, RingModulator)
RingModulator.setWaveform = new_instancemethod(_fife.RingModulator_setWaveform, None, RingModulator)
RingModulator.getWaveform = new_instancemethod(_fife.RingModulator_getWaveform, None, RingModulator)
RingModulator_swigregister = _fife.RingModulator_swigregister
RingModulator_swigregister(RingModulator)

class Autowah(SoundEffect):
    """Proxy of C++ FIFE::Autowah class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setAttackTime(self, value):
        """setAttackTime(Autowah self, float value)"""
        return _fife.Autowah_setAttackTime(self, value)


    def getAttackTime(self):
        """getAttackTime(Autowah self) -> float"""
        return _fife.Autowah_getAttackTime(self)


    def setReleaseTime(self, value):
        """setReleaseTime(Autowah self, float value)"""
        return _fife.Autowah_setReleaseTime(self, value)


    def getReleaseTime(self):
        """getReleaseTime(Autowah self) -> float"""
        return _fife.Autowah_getReleaseTime(self)


    def setResonance(self, value):
        """setResonance(Autowah self, float value)"""
        return _fife.Autowah_setResonance(self, value)


    def getResonance(self):
        """getResonance(Autowah self) -> float"""
        return _fife.Autowah_getResonance(self)


    def setPeakGain(self, value):
        """setPeakGain(Autowah self, float value)"""
        return _fife.Autowah_setPeakGain(self, value)


    def getPeakGain(self):
        """getPeakGain(Autowah self) -> float"""
        return _fife.Autowah_getPeakGain(self)

    __swig_destroy__ = _fife.delete_Autowah
Autowah.setAttackTime = new_instancemethod(_fife.Autowah_setAttackTime, None, Autowah)
Autowah.getAttackTime = new_instancemethod(_fife.Autowah_getAttackTime, None, Autowah)
Autowah.setReleaseTime = new_instancemethod(_fife.Autowah_setReleaseTime, None, Autowah)
Autowah.getReleaseTime = new_instancemethod(_fife.Autowah_getReleaseTime, None, Autowah)
Autowah.setResonance = new_instancemethod(_fife.Autowah_setResonance, None, Autowah)
Autowah.getResonance = new_instancemethod(_fife.Autowah_getResonance, None, Autowah)
Autowah.setPeakGain = new_instancemethod(_fife.Autowah_setPeakGain, None, Autowah)
Autowah.getPeakGain = new_instancemethod(_fife.Autowah_getPeakGain, None, Autowah)
Autowah_swigregister = _fife.Autowah_swigregister
Autowah_swigregister(Autowah)

class Compressor(SoundEffect):
    """Proxy of C++ FIFE::Compressor class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setCompressor(self, value):
        """setCompressor(Compressor self, bool value)"""
        return _fife.Compressor_setCompressor(self, value)


    def isCompressor(self):
        """isCompressor(Compressor self) -> bool"""
        return _fife.Compressor_isCompressor(self)

    __swig_destroy__ = _fife.delete_Compressor
Compressor.setCompressor = new_instancemethod(_fife.Compressor_setCompressor, None, Compressor)
Compressor.isCompressor = new_instancemethod(_fife.Compressor_isCompressor, None, Compressor)
Compressor_swigregister = _fife.Compressor_swigregister
Compressor_swigregister(Compressor)

class Equalizer(SoundEffect):
    """Proxy of C++ FIFE::Equalizer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setLowGain(self, value):
        """setLowGain(Equalizer self, float value)"""
        return _fife.Equalizer_setLowGain(self, value)


    def getLowGain(self):
        """getLowGain(Equalizer self) -> float"""
        return _fife.Equalizer_getLowGain(self)


    def setLowCutoff(self, value):
        """setLowCutoff(Equalizer self, float value)"""
        return _fife.Equalizer_setLowCutoff(self, value)


    def getLowCutoff(self):
        """getLowCutoff(Equalizer self) -> float"""
        return _fife.Equalizer_getLowCutoff(self)


    def setMid1Gain(self, value):
        """setMid1Gain(Equalizer self, float value)"""
        return _fife.Equalizer_setMid1Gain(self, value)


    def getMid1Gain(self):
        """getMid1Gain(Equalizer self) -> float"""
        return _fife.Equalizer_getMid1Gain(self)


    def setMid1Center(self, value):
        """setMid1Center(Equalizer self, float value)"""
        return _fife.Equalizer_setMid1Center(self, value)


    def getMid1Center(self):
        """getMid1Center(Equalizer self) -> float"""
        return _fife.Equalizer_getMid1Center(self)


    def setMid1Width(self, value):
        """setMid1Width(Equalizer self, float value)"""
        return _fife.Equalizer_setMid1Width(self, value)


    def getMid1Width(self):
        """getMid1Width(Equalizer self) -> float"""
        return _fife.Equalizer_getMid1Width(self)


    def setMid2Gain(self, value):
        """setMid2Gain(Equalizer self, float value)"""
        return _fife.Equalizer_setMid2Gain(self, value)


    def getMid2Gain(self):
        """getMid2Gain(Equalizer self) -> float"""
        return _fife.Equalizer_getMid2Gain(self)


    def setMid2Center(self, value):
        """setMid2Center(Equalizer self, float value)"""
        return _fife.Equalizer_setMid2Center(self, value)


    def getMid2Center(self):
        """getMid2Center(Equalizer self) -> float"""
        return _fife.Equalizer_getMid2Center(self)


    def setMid2Width(self, value):
        """setMid2Width(Equalizer self, float value)"""
        return _fife.Equalizer_setMid2Width(self, value)


    def getMid2Width(self):
        """getMid2Width(Equalizer self) -> float"""
        return _fife.Equalizer_getMid2Width(self)


    def setHighGain(self, value):
        """setHighGain(Equalizer self, float value)"""
        return _fife.Equalizer_setHighGain(self, value)


    def getHighGain(self):
        """getHighGain(Equalizer self) -> float"""
        return _fife.Equalizer_getHighGain(self)


    def setHighCutoff(self, value):
        """setHighCutoff(Equalizer self, float value)"""
        return _fife.Equalizer_setHighCutoff(self, value)


    def getHighCutoff(self):
        """getHighCutoff(Equalizer self) -> float"""
        return _fife.Equalizer_getHighCutoff(self)

    __swig_destroy__ = _fife.delete_Equalizer
Equalizer.setLowGain = new_instancemethod(_fife.Equalizer_setLowGain, None, Equalizer)
Equalizer.getLowGain = new_instancemethod(_fife.Equalizer_getLowGain, None, Equalizer)
Equalizer.setLowCutoff = new_instancemethod(_fife.Equalizer_setLowCutoff, None, Equalizer)
Equalizer.getLowCutoff = new_instancemethod(_fife.Equalizer_getLowCutoff, None, Equalizer)
Equalizer.setMid1Gain = new_instancemethod(_fife.Equalizer_setMid1Gain, None, Equalizer)
Equalizer.getMid1Gain = new_instancemethod(_fife.Equalizer_getMid1Gain, None, Equalizer)
Equalizer.setMid1Center = new_instancemethod(_fife.Equalizer_setMid1Center, None, Equalizer)
Equalizer.getMid1Center = new_instancemethod(_fife.Equalizer_getMid1Center, None, Equalizer)
Equalizer.setMid1Width = new_instancemethod(_fife.Equalizer_setMid1Width, None, Equalizer)
Equalizer.getMid1Width = new_instancemethod(_fife.Equalizer_getMid1Width, None, Equalizer)
Equalizer.setMid2Gain = new_instancemethod(_fife.Equalizer_setMid2Gain, None, Equalizer)
Equalizer.getMid2Gain = new_instancemethod(_fife.Equalizer_getMid2Gain, None, Equalizer)
Equalizer.setMid2Center = new_instancemethod(_fife.Equalizer_setMid2Center, None, Equalizer)
Equalizer.getMid2Center = new_instancemethod(_fife.Equalizer_getMid2Center, None, Equalizer)
Equalizer.setMid2Width = new_instancemethod(_fife.Equalizer_setMid2Width, None, Equalizer)
Equalizer.getMid2Width = new_instancemethod(_fife.Equalizer_getMid2Width, None, Equalizer)
Equalizer.setHighGain = new_instancemethod(_fife.Equalizer_setHighGain, None, Equalizer)
Equalizer.getHighGain = new_instancemethod(_fife.Equalizer_getHighGain, None, Equalizer)
Equalizer.setHighCutoff = new_instancemethod(_fife.Equalizer_setHighCutoff, None, Equalizer)
Equalizer.getHighCutoff = new_instancemethod(_fife.Equalizer_getHighCutoff, None, Equalizer)
Equalizer_swigregister = _fife.Equalizer_swigregister
Equalizer_swigregister(Equalizer)

class EaxReverb(SoundEffect):
    """Proxy of C++ FIFE::EaxReverb class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def setDensity(self, value):
        """setDensity(EaxReverb self, float value)"""
        return _fife.EaxReverb_setDensity(self, value)


    def getDensity(self):
        """getDensity(EaxReverb self) -> float"""
        return _fife.EaxReverb_getDensity(self)


    def setDiffusion(self, value):
        """setDiffusion(EaxReverb self, float value)"""
        return _fife.EaxReverb_setDiffusion(self, value)


    def getDiffusion(self):
        """getDiffusion(EaxReverb self) -> float"""
        return _fife.EaxReverb_getDiffusion(self)


    def setGain(self, value):
        """setGain(EaxReverb self, float value)"""
        return _fife.EaxReverb_setGain(self, value)


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


    def setGainHf(self, value):
        """setGainHf(EaxReverb self, float value)"""
        return _fife.EaxReverb_setGainHf(self, value)


    def getGainHf(self):
        """getGainHf(EaxReverb self) -> float"""
        return _fife.EaxReverb_getGainHf(self)


    def setGainLf(self, value):
        """setGainLf(EaxReverb self, float value)"""
        return _fife.EaxReverb_setGainLf(self, value)


    def getGainLf(self):
        """getGainLf(EaxReverb self) -> float"""
        return _fife.EaxReverb_getGainLf(self)


    def setDecayTime(self, value):
        """setDecayTime(EaxReverb self, float value)"""
        return _fife.EaxReverb_setDecayTime(self, value)


    def getDecayTime(self):
        """getDecayTime(EaxReverb self) -> float"""
        return _fife.EaxReverb_getDecayTime(self)


    def setDecayHfRatio(self, value):
        """setDecayHfRatio(EaxReverb self, float value)"""
        return _fife.EaxReverb_setDecayHfRatio(self, value)


    def getDecayHfRatio(self):
        """getDecayHfRatio(EaxReverb self) -> float"""
        return _fife.EaxReverb_getDecayHfRatio(self)


    def setDecayLfRatio(self, value):
        """setDecayLfRatio(EaxReverb self, float value)"""
        return _fife.EaxReverb_setDecayLfRatio(self, value)


    def getDecayLfRatio(self):
        """getDecayLfRatio(EaxReverb self) -> float"""
        return _fife.EaxReverb_getDecayLfRatio(self)


    def setReflectionsGain(self, value):
        """setReflectionsGain(EaxReverb self, float value)"""
        return _fife.EaxReverb_setReflectionsGain(self, value)


    def getReflectionsGain(self):
        """getReflectionsGain(EaxReverb self) -> float"""
        return _fife.EaxReverb_getReflectionsGain(self)


    def setReflectionsDelay(self, value):
        """setReflectionsDelay(EaxReverb self, float value)"""
        return _fife.EaxReverb_setReflectionsDelay(self, value)


    def getReflectionsDelay(self):
        """getReflectionsDelay(EaxReverb self) -> float"""
        return _fife.EaxReverb_getReflectionsDelay(self)


    def setReflectionsPan(self, coordinate):
        """setReflectionsPan(EaxReverb self, DoublePoint3D coordinate)"""
        return _fife.EaxReverb_setReflectionsPan(self, coordinate)


    def getReflectionsPan(self):
        """getReflectionsPan(EaxReverb self) -> DoublePoint3D"""
        return _fife.EaxReverb_getReflectionsPan(self)


    def setLateReverbGain(self, value):
        """setLateReverbGain(EaxReverb self, float value)"""
        return _fife.EaxReverb_setLateReverbGain(self, value)


    def getLateReverbGain(self):
        """getLateReverbGain(EaxReverb self) -> float"""
        return _fife.EaxReverb_getLateReverbGain(self)


    def setLateReverbDelay(self, value):
        """setLateReverbDelay(EaxReverb self, float value)"""
        return _fife.EaxReverb_setLateReverbDelay(self, value)


    def getLateReverbDelay(self):
        """getLateReverbDelay(EaxReverb self) -> float"""
        return _fife.EaxReverb_getLateReverbDelay(self)


    def setLateReverbPan(self, coordinate):
        """setLateReverbPan(EaxReverb self, DoublePoint3D coordinate)"""
        return _fife.EaxReverb_setLateReverbPan(self, coordinate)


    def getLateReverbPan(self):
        """getLateReverbPan(EaxReverb self) -> DoublePoint3D"""
        return _fife.EaxReverb_getLateReverbPan(self)


    def setEchoTime(self, value):
        """setEchoTime(EaxReverb self, float value)"""
        return _fife.EaxReverb_setEchoTime(self, value)


    def getEchoTime(self):
        """getEchoTime(EaxReverb self) -> float"""
        return _fife.EaxReverb_getEchoTime(self)


    def setEchoDepth(self, value):
        """setEchoDepth(EaxReverb self, float value)"""
        return _fife.EaxReverb_setEchoDepth(self, value)


    def getEchoDepth(self):
        """getEchoDepth(EaxReverb self) -> float"""
        return _fife.EaxReverb_getEchoDepth(self)


    def setModulationTime(self, value):
        """setModulationTime(EaxReverb self, float value)"""
        return _fife.EaxReverb_setModulationTime(self, value)


    def getModulationTime(self):
        """getModulationTime(EaxReverb self) -> float"""
        return _fife.EaxReverb_getModulationTime(self)


    def setModulationDepth(self, value):
        """setModulationDepth(EaxReverb self, float value)"""
        return _fife.EaxReverb_setModulationDepth(self, value)


    def getModulationDepth(self):
        """getModulationDepth(EaxReverb self) -> float"""
        return _fife.EaxReverb_getModulationDepth(self)


    def setAirAbsorptionGainHf(self, value):
        """setAirAbsorptionGainHf(EaxReverb self, float value)"""
        return _fife.EaxReverb_setAirAbsorptionGainHf(self, value)


    def getAirAbsorptionGainHf(self):
        """getAirAbsorptionGainHf(EaxReverb self) -> float"""
        return _fife.EaxReverb_getAirAbsorptionGainHf(self)


    def setHfReference(self, value):
        """setHfReference(EaxReverb self, float value)"""
        return _fife.EaxReverb_setHfReference(self, value)


    def getHfReference(self):
        """getHfReference(EaxReverb self) -> float"""
        return _fife.EaxReverb_getHfReference(self)


    def setLfReference(self, value):
        """setLfReference(EaxReverb self, float value)"""
        return _fife.EaxReverb_setLfReference(self, value)


    def getLfReference(self):
        """getLfReference(EaxReverb self) -> float"""
        return _fife.EaxReverb_getLfReference(self)


    def setRoomRolloffFactor(self, value):
        """setRoomRolloffFactor(EaxReverb self, float value)"""
        return _fife.EaxReverb_setRoomRolloffFactor(self, value)


    def getRoomRolloffFactor(self):
        """getRoomRolloffFactor(EaxReverb self) -> float"""
        return _fife.EaxReverb_getRoomRolloffFactor(self)


    def setDecayHfLimit(self, value):
        """setDecayHfLimit(EaxReverb self, bool value)"""
        return _fife.EaxReverb_setDecayHfLimit(self, value)


    def isDecayHfLimit(self):
        """isDecayHfLimit(EaxReverb self) -> bool"""
        return _fife.EaxReverb_isDecayHfLimit(self)

    __swig_destroy__ = _fife.delete_EaxReverb
EaxReverb.setDensity = new_instancemethod(_fife.EaxReverb_setDensity, None, EaxReverb)
EaxReverb.getDensity = new_instancemethod(_fife.EaxReverb_getDensity, None, EaxReverb)
EaxReverb.setDiffusion = new_instancemethod(_fife.EaxReverb_setDiffusion, None, EaxReverb)
EaxReverb.getDiffusion = new_instancemethod(_fife.EaxReverb_getDiffusion, None, EaxReverb)
EaxReverb.setGain = new_instancemethod(_fife.EaxReverb_setGain, None, EaxReverb)
EaxReverb.getGain = new_instancemethod(_fife.EaxReverb_getGain, None, EaxReverb)
EaxReverb.setGainHf = new_instancemethod(_fife.EaxReverb_setGainHf, None, EaxReverb)
EaxReverb.getGainHf = new_instancemethod(_fife.EaxReverb_getGainHf, None, EaxReverb)
EaxReverb.setGainLf = new_instancemethod(_fife.EaxReverb_setGainLf, None, EaxReverb)
EaxReverb.getGainLf = new_instancemethod(_fife.EaxReverb_getGainLf, None, EaxReverb)
EaxReverb.setDecayTime = new_instancemethod(_fife.EaxReverb_setDecayTime, None, EaxReverb)
EaxReverb.getDecayTime = new_instancemethod(_fife.EaxReverb_getDecayTime, None, EaxReverb)
EaxReverb.setDecayHfRatio = new_instancemethod(_fife.EaxReverb_setDecayHfRatio, None, EaxReverb)
EaxReverb.getDecayHfRatio = new_instancemethod(_fife.EaxReverb_getDecayHfRatio, None, EaxReverb)
EaxReverb.setDecayLfRatio = new_instancemethod(_fife.EaxReverb_setDecayLfRatio, None, EaxReverb)
EaxReverb.getDecayLfRatio = new_instancemethod(_fife.EaxReverb_getDecayLfRatio, None, EaxReverb)
EaxReverb.setReflectionsGain = new_instancemethod(_fife.EaxReverb_setReflectionsGain, None, EaxReverb)
EaxReverb.getReflectionsGain = new_instancemethod(_fife.EaxReverb_getReflectionsGain, None, EaxReverb)
EaxReverb.setReflectionsDelay = new_instancemethod(_fife.EaxReverb_setReflectionsDelay, None, EaxReverb)
EaxReverb.getReflectionsDelay = new_instancemethod(_fife.EaxReverb_getReflectionsDelay, None, EaxReverb)
EaxReverb.setReflectionsPan = new_instancemethod(_fife.EaxReverb_setReflectionsPan, None, EaxReverb)
EaxReverb.getReflectionsPan = new_instancemethod(_fife.EaxReverb_getReflectionsPan, None, EaxReverb)
EaxReverb.setLateReverbGain = new_instancemethod(_fife.EaxReverb_setLateReverbGain, None, EaxReverb)
EaxReverb.getLateReverbGain = new_instancemethod(_fife.EaxReverb_getLateReverbGain, None, EaxReverb)
EaxReverb.setLateReverbDelay = new_instancemethod(_fife.EaxReverb_setLateReverbDelay, None, EaxReverb)
EaxReverb.getLateReverbDelay = new_instancemethod(_fife.EaxReverb_getLateReverbDelay, None, EaxReverb)
EaxReverb.setLateReverbPan = new_instancemethod(_fife.EaxReverb_setLateReverbPan, None, EaxReverb)
EaxReverb.getLateReverbPan = new_instancemethod(_fife.EaxReverb_getLateReverbPan, None, EaxReverb)
EaxReverb.setEchoTime = new_instancemethod(_fife.EaxReverb_setEchoTime, None, EaxReverb)
EaxReverb.getEchoTime = new_instancemethod(_fife.EaxReverb_getEchoTime, None, EaxReverb)
EaxReverb.setEchoDepth = new_instancemethod(_fife.EaxReverb_setEchoDepth, None, EaxReverb)
EaxReverb.getEchoDepth = new_instancemethod(_fife.EaxReverb_getEchoDepth, None, EaxReverb)
EaxReverb.setModulationTime = new_instancemethod(_fife.EaxReverb_setModulationTime, None, EaxReverb)
EaxReverb.getModulationTime = new_instancemethod(_fife.EaxReverb_getModulationTime, None, EaxReverb)
EaxReverb.setModulationDepth = new_instancemethod(_fife.EaxReverb_setModulationDepth, None, EaxReverb)
EaxReverb.getModulationDepth = new_instancemethod(_fife.EaxReverb_getModulationDepth, None, EaxReverb)
EaxReverb.setAirAbsorptionGainHf = new_instancemethod(_fife.EaxReverb_setAirAbsorptionGainHf, None, EaxReverb)
EaxReverb.getAirAbsorptionGainHf = new_instancemethod(_fife.EaxReverb_getAirAbsorptionGainHf, None, EaxReverb)
EaxReverb.setHfReference = new_instancemethod(_fife.EaxReverb_setHfReference, None, EaxReverb)
EaxReverb.getHfReference = new_instancemethod(_fife.EaxReverb_getHfReference, None, EaxReverb)
EaxReverb.setLfReference = new_instancemethod(_fife.EaxReverb_setLfReference, None, EaxReverb)
EaxReverb.getLfReference = new_instancemethod(_fife.EaxReverb_getLfReference, None, EaxReverb)
EaxReverb.setRoomRolloffFactor = new_instancemethod(_fife.EaxReverb_setRoomRolloffFactor, None, EaxReverb)
EaxReverb.getRoomRolloffFactor = new_instancemethod(_fife.EaxReverb_getRoomRolloffFactor, None, EaxReverb)
EaxReverb.setDecayHfLimit = new_instancemethod(_fife.EaxReverb_setDecayHfLimit, None, EaxReverb)
EaxReverb.isDecayHfLimit = new_instancemethod(_fife.EaxReverb_isDecayHfLimit, None, EaxReverb)
EaxReverb_swigregister = _fife.EaxReverb_swigregister
EaxReverb_swigregister(EaxReverb)

SF_FILTER_NULL = _fife.SF_FILTER_NULL
SF_FILTER_LOWPASS = _fife.SF_FILTER_LOWPASS
SF_FILTER_HIGHPASS = _fife.SF_FILTER_HIGHPASS
SF_FILTER_BANDPASS = _fife.SF_FILTER_BANDPASS
class SoundFilter(object):
    """Proxy of C++ FIFE::SoundFilter class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getFilterType(self):
        """getFilterType(SoundFilter self) -> FIFE::SoundFilterType"""
        return _fife.SoundFilter_getFilterType(self)


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


    def setGain(self, gain):
        """setGain(SoundFilter self, float gain)"""
        return _fife.SoundFilter_setGain(self, gain)


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


    def setGainHf(self, gain):
        """setGainHf(SoundFilter self, float gain)"""
        return _fife.SoundFilter_setGainHf(self, gain)


    def getGainHf(self):
        """getGainHf(SoundFilter self) -> float"""
        return _fife.SoundFilter_getGainHf(self)


    def setGainLf(self, gain):
        """setGainLf(SoundFilter self, float gain)"""
        return _fife.SoundFilter_setGainLf(self, gain)


    def getGainLf(self):
        """getGainLf(SoundFilter self) -> float"""
        return _fife.SoundFilter_getGainLf(self)

    __swig_destroy__ = _fife.delete_SoundFilter
SoundFilter.getFilterType = new_instancemethod(_fife.SoundFilter_getFilterType, None, SoundFilter)
SoundFilter.isEnabled = new_instancemethod(_fife.SoundFilter_isEnabled, None, SoundFilter)
SoundFilter.setGain = new_instancemethod(_fife.SoundFilter_setGain, None, SoundFilter)
SoundFilter.getGain = new_instancemethod(_fife.SoundFilter_getGain, None, SoundFilter)
SoundFilter.setGainHf = new_instancemethod(_fife.SoundFilter_setGainHf, None, SoundFilter)
SoundFilter.getGainHf = new_instancemethod(_fife.SoundFilter_getGainHf, None, SoundFilter)
SoundFilter.setGainLf = new_instancemethod(_fife.SoundFilter_setGainLf, None, SoundFilter)
SoundFilter.getGainLf = new_instancemethod(_fife.SoundFilter_getGainLf, None, SoundFilter)
SoundFilter_swigregister = _fife.SoundFilter_swigregister
SoundFilter_swigregister(SoundFilter)

class IResourceLoader(object):
    """Proxy of C++ FIFE::IResourceLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IResourceLoader

    def load(self, resource):
        """load(IResourceLoader self, IResource resource)"""
        return _fife.IResourceLoader_load(self, resource)

IResourceLoader.load = new_instancemethod(_fife.IResourceLoader_load, None, IResourceLoader)
IResourceLoader_swigregister = _fife.IResourceLoader_swigregister
IResourceLoader_swigregister(IResourceLoader)

class IResource(object):
    """Proxy of C++ FIFE::IResource class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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

    def getName(self):
        """getName(IResource self) -> std::string const &"""
        return _fife.IResource_getName(self)


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


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


    def setState(self, state):
        """setState(IResource self, FIFE::IResource::ResourceState const & state)"""
        return _fife.IResource_setState(self, state)


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


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


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

IResource.getName = new_instancemethod(_fife.IResource_getName, None, IResource)
IResource.getHandle = new_instancemethod(_fife.IResource_getHandle, None, IResource)
IResource.getState = new_instancemethod(_fife.IResource_getState, None, IResource)
IResource.setState = new_instancemethod(_fife.IResource_setState, None, IResource)
IResource.getSize = new_instancemethod(_fife.IResource_getSize, None, IResource)
IResource.load = new_instancemethod(_fife.IResource_load, None, IResource)
IResource.free = new_instancemethod(_fife.IResource_free, None, IResource)
IResource_swigregister = _fife.IResource_swigregister
IResource_swigregister(IResource)

class SharedResourcePointer(object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::IResource)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::SharedPtr<(FIFE::IResource)> self) -> SharedResourcePointer
        __init__(FIFE::SharedPtr<(FIFE::IResource)> self, SharedResourcePointer rhs) -> SharedResourcePointer
        """
        _fife.SharedResourcePointer_swiginit(self, _fife.new_SharedResourcePointer(*args))
    __swig_destroy__ = _fife.delete_SharedResourcePointer

    def __ref__(self):
        """__ref__(SharedResourcePointer self) -> IResource"""
        return _fife.SharedResourcePointer___ref__(self)


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


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


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


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


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


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


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



    def getName(self):
        """getName(SharedResourcePointer self) -> std::string const &"""
        return _fife.SharedResourcePointer_getName(self)


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


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


    def setState(self, state):
        """setState(SharedResourcePointer self, FIFE::IResource::ResourceState const & state)"""
        return _fife.SharedResourcePointer_setState(self, state)


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


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


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

SharedResourcePointer.__ref__ = new_instancemethod(_fife.SharedResourcePointer___ref__, None, SharedResourcePointer)
SharedResourcePointer.__deref__ = new_instancemethod(_fife.SharedResourcePointer___deref__, None, SharedResourcePointer)
SharedResourcePointer.get = new_instancemethod(_fife.SharedResourcePointer_get, None, SharedResourcePointer)
SharedResourcePointer.reset = new_instancemethod(_fife.SharedResourcePointer_reset, None, SharedResourcePointer)
SharedResourcePointer.useCount = new_instancemethod(_fife.SharedResourcePointer_useCount, None, SharedResourcePointer)
SharedResourcePointer.useCountPtr = new_instancemethod(_fife.SharedResourcePointer_useCountPtr, None, SharedResourcePointer)
SharedResourcePointer.unique = new_instancemethod(_fife.SharedResourcePointer_unique, None, SharedResourcePointer)
SharedResourcePointer.getName = new_instancemethod(_fife.SharedResourcePointer_getName, None, SharedResourcePointer)
SharedResourcePointer.getHandle = new_instancemethod(_fife.SharedResourcePointer_getHandle, None, SharedResourcePointer)
SharedResourcePointer.getState = new_instancemethod(_fife.SharedResourcePointer_getState, None, SharedResourcePointer)
SharedResourcePointer.setState = new_instancemethod(_fife.SharedResourcePointer_setState, None, SharedResourcePointer)
SharedResourcePointer.getSize = new_instancemethod(_fife.SharedResourcePointer_getSize, None, SharedResourcePointer)
SharedResourcePointer.load = new_instancemethod(_fife.SharedResourcePointer_load, None, SharedResourcePointer)
SharedResourcePointer.free = new_instancemethod(_fife.SharedResourcePointer_free, None, SharedResourcePointer)
SharedResourcePointer_swigregister = _fife.SharedResourcePointer_swigregister
SharedResourcePointer_swigregister(SharedResourcePointer)

class IResourceManager(object):
    """Proxy of C++ FIFE::IResourceManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def getMemoryUsed(self):
        """getMemoryUsed(IResourceManager self) -> size_t"""
        return _fife.IResourceManager_getMemoryUsed(self)


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


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


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

    __swig_destroy__ = _fife.delete_IResourceManager
IResourceManager.getMemoryUsed = new_instancemethod(_fife.IResourceManager_getMemoryUsed, None, IResourceManager)
IResourceManager.getTotalResourcesCreated = new_instancemethod(_fife.IResourceManager_getTotalResourcesCreated, None, IResourceManager)
IResourceManager.getTotalResourcesLoaded = new_instancemethod(_fife.IResourceManager_getTotalResourcesLoaded, None, IResourceManager)
IResourceManager.getTotalResources = new_instancemethod(_fife.IResourceManager_getTotalResources, None, IResourceManager)
IResourceManager_swigregister = _fife.IResourceManager_swigregister
IResourceManager_swigregister(IResourceManager)

class SoundClip(IResource):
    """Proxy of C++ FIFE::SoundClip class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SoundClip

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

SoundClip.isStream = new_instancemethod(_fife.SoundClip_isStream, None, SoundClip)
SoundClip_swigregister = _fife.SoundClip_swigregister
SoundClip_swigregister(SoundClip)

class SharedSoundClipPointer(object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::SoundClip)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::SharedPtr<(FIFE::SoundClip)> self) -> SharedSoundClipPointer
        __init__(FIFE::SharedPtr<(FIFE::SoundClip)> self, SharedSoundClipPointer rhs) -> SharedSoundClipPointer
        """
        _fife.SharedSoundClipPointer_swiginit(self, _fife.new_SharedSoundClipPointer(*args))
    __swig_destroy__ = _fife.delete_SharedSoundClipPointer

    def __ref__(self):
        """__ref__(SharedSoundClipPointer self) -> SoundClip"""
        return _fife.SharedSoundClipPointer___ref__(self)


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


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


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


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


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


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


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



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


    def getName(self):
        """getName(SharedSoundClipPointer self) -> std::string const &"""
        return _fife.SharedSoundClipPointer_getName(self)


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


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


    def setState(self, state):
        """setState(SharedSoundClipPointer self, FIFE::IResource::ResourceState const & state)"""
        return _fife.SharedSoundClipPointer_setState(self, state)


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


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


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

SharedSoundClipPointer.__ref__ = new_instancemethod(_fife.SharedSoundClipPointer___ref__, None, SharedSoundClipPointer)
SharedSoundClipPointer.__deref__ = new_instancemethod(_fife.SharedSoundClipPointer___deref__, None, SharedSoundClipPointer)
SharedSoundClipPointer.get = new_instancemethod(_fife.SharedSoundClipPointer_get, None, SharedSoundClipPointer)
SharedSoundClipPointer.reset = new_instancemethod(_fife.SharedSoundClipPointer_reset, None, SharedSoundClipPointer)
SharedSoundClipPointer.useCount = new_instancemethod(_fife.SharedSoundClipPointer_useCount, None, SharedSoundClipPointer)
SharedSoundClipPointer.useCountPtr = new_instancemethod(_fife.SharedSoundClipPointer_useCountPtr, None, SharedSoundClipPointer)
SharedSoundClipPointer.unique = new_instancemethod(_fife.SharedSoundClipPointer_unique, None, SharedSoundClipPointer)
SharedSoundClipPointer.isStream = new_instancemethod(_fife.SharedSoundClipPointer_isStream, None, SharedSoundClipPointer)
SharedSoundClipPointer.getName = new_instancemethod(_fife.SharedSoundClipPointer_getName, None, SharedSoundClipPointer)
SharedSoundClipPointer.getHandle = new_instancemethod(_fife.SharedSoundClipPointer_getHandle, None, SharedSoundClipPointer)
SharedSoundClipPointer.getState = new_instancemethod(_fife.SharedSoundClipPointer_getState, None, SharedSoundClipPointer)
SharedSoundClipPointer.setState = new_instancemethod(_fife.SharedSoundClipPointer_setState, None, SharedSoundClipPointer)
SharedSoundClipPointer.getSize = new_instancemethod(_fife.SharedSoundClipPointer_getSize, None, SharedSoundClipPointer)
SharedSoundClipPointer.load = new_instancemethod(_fife.SharedSoundClipPointer_load, None, SharedSoundClipPointer)
SharedSoundClipPointer.free = new_instancemethod(_fife.SharedSoundClipPointer_free, None, SharedSoundClipPointer)
SharedSoundClipPointer_swigregister = _fife.SharedSoundClipPointer_swigregister
SharedSoundClipPointer_swigregister(SharedSoundClipPointer)

class SoundClipManager(IResourceManager):
    """Proxy of C++ FIFE::SoundClipManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SoundClipManager

    def getMemoryUsed(self):
        """getMemoryUsed(SoundClipManager self) -> size_t"""
        return _fife.SoundClipManager_getMemoryUsed(self)


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


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


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


    def create(self, name, loader=None):
        """create(SoundClipManager self, std::string const & name, IResourceLoader loader=None) -> SharedSoundClipPointer"""
        return _fife.SoundClipManager_create(self, name, loader)


    def load(self, name, loader=None):
        """load(SoundClipManager self, std::string const & name, IResourceLoader loader=None) -> SharedSoundClipPointer"""
        return _fife.SoundClipManager_load(self, name, loader)


    def add(self, res):
        """add(SoundClipManager self, SoundClip res) -> SharedSoundClipPointer"""
        return _fife.SoundClipManager_add(self, res)


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


    def reload(self, *args):
        """
        reload(SoundClipManager self, std::string const & name)
        reload(SoundClipManager self, FIFE::ResourceHandle handle)
        """
        return _fife.SoundClipManager_reload(self, *args)


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


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


    def free(self, *args):
        """
        free(SoundClipManager self, std::string const & name)
        free(SoundClipManager self, FIFE::ResourceHandle handle)
        """
        return _fife.SoundClipManager_free(self, *args)


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


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


    def remove(self, *args):
        """
        remove(SoundClipManager self, SharedSoundClipPointer resource)
        remove(SoundClipManager self, std::string const & name)
        remove(SoundClipManager self, FIFE::ResourceHandle handle)
        """
        return _fife.SoundClipManager_remove(self, *args)


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


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


    def get(self, *args):
        """
        get(SoundClipManager self, std::string const & name) -> SharedSoundClipPointer
        get(SoundClipManager self, FIFE::ResourceHandle handle) -> SharedSoundClipPointer
        """
        return _fife.SoundClipManager_get(self, *args)


    def getResourceHandle(self, name):
        """getResourceHandle(SoundClipManager self, std::string const & name) -> FIFE::ResourceHandle"""
        return _fife.SoundClipManager_getResourceHandle(self, name)


    def __init__(self):
        """__init__(FIFE::SoundClipManager self) -> SoundClipManager"""
        _fife.SoundClipManager_swiginit(self, _fife.new_SoundClipManager())
SoundClipManager.getMemoryUsed = new_instancemethod(_fife.SoundClipManager_getMemoryUsed, None, SoundClipManager)
SoundClipManager.getTotalResourcesCreated = new_instancemethod(_fife.SoundClipManager_getTotalResourcesCreated, None, SoundClipManager)
SoundClipManager.getTotalResourcesLoaded = new_instancemethod(_fife.SoundClipManager_getTotalResourcesLoaded, None, SoundClipManager)
SoundClipManager.getTotalResources = new_instancemethod(_fife.SoundClipManager_getTotalResources, None, SoundClipManager)
SoundClipManager.create = new_instancemethod(_fife.SoundClipManager_create, None, SoundClipManager)
SoundClipManager.load = new_instancemethod(_fife.SoundClipManager_load, None, SoundClipManager)
SoundClipManager.add = new_instancemethod(_fife.SoundClipManager_add, None, SoundClipManager)
SoundClipManager.exists = new_instancemethod(_fife.SoundClipManager_exists, None, SoundClipManager)
SoundClipManager.reload = new_instancemethod(_fife.SoundClipManager_reload, None, SoundClipManager)
SoundClipManager.reloadAll = new_instancemethod(_fife.SoundClipManager_reloadAll, None, SoundClipManager)
SoundClipManager.loadUnreferenced = new_instancemethod(_fife.SoundClipManager_loadUnreferenced, None, SoundClipManager)
SoundClipManager.free = new_instancemethod(_fife.SoundClipManager_free, None, SoundClipManager)
SoundClipManager.freeAll = new_instancemethod(_fife.SoundClipManager_freeAll, None, SoundClipManager)
SoundClipManager.freeUnreferenced = new_instancemethod(_fife.SoundClipManager_freeUnreferenced, None, SoundClipManager)
SoundClipManager.remove = new_instancemethod(_fife.SoundClipManager_remove, None, SoundClipManager)
SoundClipManager.removeAll = new_instancemethod(_fife.SoundClipManager_removeAll, None, SoundClipManager)
SoundClipManager.removeUnreferenced = new_instancemethod(_fife.SoundClipManager_removeUnreferenced, None, SoundClipManager)
SoundClipManager.get = new_instancemethod(_fife.SoundClipManager_get, None, SoundClipManager)
SoundClipManager.getResourceHandle = new_instancemethod(_fife.SoundClipManager_getResourceHandle, None, SoundClipManager)
SoundClipManager_swigregister = _fife.SoundClipManager_swigregister
SoundClipManager_swigregister(SoundClipManager)

class SoundEmitterListener(object):
    """Proxy of C++ FIFE::SoundEmitterListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SoundEmitterListener

    def onSoundFinished(self, emitterId, soundClipId):
        """onSoundFinished(SoundEmitterListener self, uint32_t emitterId, uint32_t soundClipId)"""
        return _fife.SoundEmitterListener_onSoundFinished(self, emitterId, soundClipId)


    def __init__(self):
        """__init__(FIFE::SoundEmitterListener self) -> SoundEmitterListener"""
        if self.__class__ == SoundEmitterListener:
            _self = None
        else:
            _self = self
        _fife.SoundEmitterListener_swiginit(self, _fife.new_SoundEmitterListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_SoundEmitterListener(self)
        return weakref_proxy(self)
SoundEmitterListener.onSoundFinished = new_instancemethod(_fife.SoundEmitterListener_onSoundFinished, None, SoundEmitterListener)
SoundEmitterListener_swigregister = _fife.SoundEmitterListener_swigregister
SoundEmitterListener_swigregister(SoundEmitterListener)

SD_SAMPLE_POS = _fife.SD_SAMPLE_POS
SD_TIME_POS = _fife.SD_TIME_POS
SD_BYTE_POS = _fife.SD_BYTE_POS
SD_UNKNOWN_STATE = _fife.SD_UNKNOWN_STATE
SD_INITIAL_STATE = _fife.SD_INITIAL_STATE
SD_PLAYING_STATE = _fife.SD_PLAYING_STATE
SD_PAUSED_STATE = _fife.SD_PAUSED_STATE
SD_STOPPED_STATE = _fife.SD_STOPPED_STATE
class SoundEmitter(object):
    """Proxy of C++ FIFE::SoundEmitter class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getId(self):
        """getId(SoundEmitter self) -> uint32_t"""
        return _fife.SoundEmitter_getId(self)


    def isActive(self):
        """isActive(SoundEmitter self) -> bool"""
        return _fife.SoundEmitter_isActive(self)


    def getEffectCount(self):
        """getEffectCount(SoundEmitter self) -> uint8_t"""
        return _fife.SoundEmitter_getEffectCount(self)


    def setSoundClip(self, soundClip):
        """setSoundClip(SoundEmitter self, SharedSoundClipPointer soundClip)"""
        return _fife.SoundEmitter_setSoundClip(self, soundClip)


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


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


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


    def play(self, *args):
        """
        play(SoundEmitter self)
        play(SoundEmitter self, float inTime, float outTime)
        """
        return _fife.SoundEmitter_play(self, *args)


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


    def stop(self, *args):
        """
        stop(SoundEmitter self)
        stop(SoundEmitter self, float time)
        """
        return _fife.SoundEmitter_stop(self, *args)


    def rewind(self):
        """rewind(SoundEmitter self)"""
        return _fife.SoundEmitter_rewind(self)


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


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


    def setMaxGain(self, gain):
        """setMaxGain(SoundEmitter self, float gain)"""
        return _fife.SoundEmitter_setMaxGain(self, gain)


    def getMaxGain(self):
        """getMaxGain(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getMaxGain(self)


    def setMinGain(self, gain):
        """setMinGain(SoundEmitter self, float gain)"""
        return _fife.SoundEmitter_setMinGain(self, gain)


    def getMinGain(self):
        """getMinGain(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getMinGain(self)


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


    def isLooping(self):
        """isLooping(SoundEmitter self) -> bool"""
        return _fife.SoundEmitter_isLooping(self)


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


    def getRolloff(self):
        """getRolloff(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getRolloff(self)


    def setRelativePositioning(self, relative):
        """setRelativePositioning(SoundEmitter self, bool relative)"""
        return _fife.SoundEmitter_setRelativePositioning(self, relative)


    def isRelativePositioning(self):
        """isRelativePositioning(SoundEmitter self) -> bool"""
        return _fife.SoundEmitter_isRelativePositioning(self)


    def setPosition(self, position):
        """setPosition(SoundEmitter self, DoublePoint3D position)"""
        return _fife.SoundEmitter_setPosition(self, position)


    def getPosition(self):
        """getPosition(SoundEmitter self) -> DoublePoint3D"""
        return _fife.SoundEmitter_getPosition(self)


    def setReferenceDistance(self, distance):
        """setReferenceDistance(SoundEmitter self, float distance)"""
        return _fife.SoundEmitter_setReferenceDistance(self, distance)


    def getReferenceDistance(self):
        """getReferenceDistance(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getReferenceDistance(self)


    def setMaxDistance(self, distance):
        """setMaxDistance(SoundEmitter self, float distance)"""
        return _fife.SoundEmitter_setMaxDistance(self, distance)


    def getMaxDistance(self):
        """getMaxDistance(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getMaxDistance(self)


    def setDirection(self, direction):
        """setDirection(SoundEmitter self, DoublePoint3D direction)"""
        return _fife.SoundEmitter_setDirection(self, direction)


    def getDirection(self):
        """getDirection(SoundEmitter self) -> DoublePoint3D"""
        return _fife.SoundEmitter_getDirection(self)


    def setVelocity(self, velocity):
        """setVelocity(SoundEmitter self, DoublePoint3D velocity)"""
        return _fife.SoundEmitter_setVelocity(self, velocity)


    def getVelocity(self):
        """getVelocity(SoundEmitter self) -> DoublePoint3D"""
        return _fife.SoundEmitter_getVelocity(self)


    def setPitch(self, pitch):
        """setPitch(SoundEmitter self, float pitch)"""
        return _fife.SoundEmitter_setPitch(self, pitch)


    def getPitch(self):
        """getPitch(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getPitch(self)


    def setConeInnerAngle(self, inner):
        """setConeInnerAngle(SoundEmitter self, float inner)"""
        return _fife.SoundEmitter_setConeInnerAngle(self, inner)


    def getConeInnerAngle(self):
        """getConeInnerAngle(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getConeInnerAngle(self)


    def setConeOuterAngle(self, outer):
        """setConeOuterAngle(SoundEmitter self, float outer)"""
        return _fife.SoundEmitter_setConeOuterAngle(self, outer)


    def getConeOuterAngle(self):
        """getConeOuterAngle(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getConeOuterAngle(self)


    def setConeOuterGain(self, gain):
        """setConeOuterGain(SoundEmitter self, float gain)"""
        return _fife.SoundEmitter_setConeOuterGain(self, gain)


    def getConeOuterGain(self):
        """getConeOuterGain(SoundEmitter self) -> float"""
        return _fife.SoundEmitter_getConeOuterGain(self)


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


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


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


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


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


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


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


    def getState(self):
        """getState(SoundEmitter self) -> FIFE::SoundStateType"""
        return _fife.SoundEmitter_getState(self)


    def setGroup(self, group):
        """setGroup(SoundEmitter self, std::string const & group)"""
        return _fife.SoundEmitter_setGroup(self, group)


    def getGroup(self):
        """getGroup(SoundEmitter self) -> std::string const &"""
        return _fife.SoundEmitter_getGroup(self)


    def addListener(self, listener):
        """addListener(SoundEmitter self, SoundEmitterListener listener)"""
        return _fife.SoundEmitter_addListener(self, listener)


    def removeListener(self, listener):
        """removeListener(SoundEmitter self, SoundEmitterListener listener)"""
        return _fife.SoundEmitter_removeListener(self, listener)

    __swig_destroy__ = _fife.delete_SoundEmitter
SoundEmitter.getId = new_instancemethod(_fife.SoundEmitter_getId, None, SoundEmitter)
SoundEmitter.isActive = new_instancemethod(_fife.SoundEmitter_isActive, None, SoundEmitter)
SoundEmitter.getEffectCount = new_instancemethod(_fife.SoundEmitter_getEffectCount, None, SoundEmitter)
SoundEmitter.setSoundClip = new_instancemethod(_fife.SoundEmitter_setSoundClip, None, SoundEmitter)
SoundEmitter.getSoundClip = new_instancemethod(_fife.SoundEmitter_getSoundClip, None, SoundEmitter)
SoundEmitter.reset = new_instancemethod(_fife.SoundEmitter_reset, None, SoundEmitter)
SoundEmitter.release = new_instancemethod(_fife.SoundEmitter_release, None, SoundEmitter)
SoundEmitter.play = new_instancemethod(_fife.SoundEmitter_play, None, SoundEmitter)
SoundEmitter.pause = new_instancemethod(_fife.SoundEmitter_pause, None, SoundEmitter)
SoundEmitter.stop = new_instancemethod(_fife.SoundEmitter_stop, None, SoundEmitter)
SoundEmitter.rewind = new_instancemethod(_fife.SoundEmitter_rewind, None, SoundEmitter)
SoundEmitter.setGain = new_instancemethod(_fife.SoundEmitter_setGain, None, SoundEmitter)
SoundEmitter.getGain = new_instancemethod(_fife.SoundEmitter_getGain, None, SoundEmitter)
SoundEmitter.setMaxGain = new_instancemethod(_fife.SoundEmitter_setMaxGain, None, SoundEmitter)
SoundEmitter.getMaxGain = new_instancemethod(_fife.SoundEmitter_getMaxGain, None, SoundEmitter)
SoundEmitter.setMinGain = new_instancemethod(_fife.SoundEmitter_setMinGain, None, SoundEmitter)
SoundEmitter.getMinGain = new_instancemethod(_fife.SoundEmitter_getMinGain, None, SoundEmitter)
SoundEmitter.setLooping = new_instancemethod(_fife.SoundEmitter_setLooping, None, SoundEmitter)
SoundEmitter.isLooping = new_instancemethod(_fife.SoundEmitter_isLooping, None, SoundEmitter)
SoundEmitter.setRolloff = new_instancemethod(_fife.SoundEmitter_setRolloff, None, SoundEmitter)
SoundEmitter.getRolloff = new_instancemethod(_fife.SoundEmitter_getRolloff, None, SoundEmitter)
SoundEmitter.setRelativePositioning = new_instancemethod(_fife.SoundEmitter_setRelativePositioning, None, SoundEmitter)
SoundEmitter.isRelativePositioning = new_instancemethod(_fife.SoundEmitter_isRelativePositioning, None, SoundEmitter)
SoundEmitter.setPosition = new_instancemethod(_fife.SoundEmitter_setPosition, None, SoundEmitter)
SoundEmitter.getPosition = new_instancemethod(_fife.SoundEmitter_getPosition, None, SoundEmitter)
SoundEmitter.setReferenceDistance = new_instancemethod(_fife.SoundEmitter_setReferenceDistance, None, SoundEmitter)
SoundEmitter.getReferenceDistance = new_instancemethod(_fife.SoundEmitter_getReferenceDistance, None, SoundEmitter)
SoundEmitter.setMaxDistance = new_instancemethod(_fife.SoundEmitter_setMaxDistance, None, SoundEmitter)
SoundEmitter.getMaxDistance = new_instancemethod(_fife.SoundEmitter_getMaxDistance, None, SoundEmitter)
SoundEmitter.setDirection = new_instancemethod(_fife.SoundEmitter_setDirection, None, SoundEmitter)
SoundEmitter.getDirection = new_instancemethod(_fife.SoundEmitter_getDirection, None, SoundEmitter)
SoundEmitter.setVelocity = new_instancemethod(_fife.SoundEmitter_setVelocity, None, SoundEmitter)
SoundEmitter.getVelocity = new_instancemethod(_fife.SoundEmitter_getVelocity, None, SoundEmitter)
SoundEmitter.setPitch = new_instancemethod(_fife.SoundEmitter_setPitch, None, SoundEmitter)
SoundEmitter.getPitch = new_instancemethod(_fife.SoundEmitter_getPitch, None, SoundEmitter)
SoundEmitter.setConeInnerAngle = new_instancemethod(_fife.SoundEmitter_setConeInnerAngle, None, SoundEmitter)
SoundEmitter.getConeInnerAngle = new_instancemethod(_fife.SoundEmitter_getConeInnerAngle, None, SoundEmitter)
SoundEmitter.setConeOuterAngle = new_instancemethod(_fife.SoundEmitter_setConeOuterAngle, None, SoundEmitter)
SoundEmitter.getConeOuterAngle = new_instancemethod(_fife.SoundEmitter_getConeOuterAngle, None, SoundEmitter)
SoundEmitter.setConeOuterGain = new_instancemethod(_fife.SoundEmitter_setConeOuterGain, None, SoundEmitter)
SoundEmitter.getConeOuterGain = new_instancemethod(_fife.SoundEmitter_getConeOuterGain, None, SoundEmitter)
SoundEmitter.isStereo = new_instancemethod(_fife.SoundEmitter_isStereo, None, SoundEmitter)
SoundEmitter.getBitResolution = new_instancemethod(_fife.SoundEmitter_getBitResolution, None, SoundEmitter)
SoundEmitter.getSampleRate = new_instancemethod(_fife.SoundEmitter_getSampleRate, None, SoundEmitter)
SoundEmitter.getDecodedLength = new_instancemethod(_fife.SoundEmitter_getDecodedLength, None, SoundEmitter)
SoundEmitter.getDuration = new_instancemethod(_fife.SoundEmitter_getDuration, None, SoundEmitter)
SoundEmitter.setCursor = new_instancemethod(_fife.SoundEmitter_setCursor, None, SoundEmitter)
SoundEmitter.getCursor = new_instancemethod(_fife.SoundEmitter_getCursor, None, SoundEmitter)
SoundEmitter.getState = new_instancemethod(_fife.SoundEmitter_getState, None, SoundEmitter)
SoundEmitter.setGroup = new_instancemethod(_fife.SoundEmitter_setGroup, None, SoundEmitter)
SoundEmitter.getGroup = new_instancemethod(_fife.SoundEmitter_getGroup, None, SoundEmitter)
SoundEmitter.addListener = new_instancemethod(_fife.SoundEmitter_addListener, None, SoundEmitter)
SoundEmitter.removeListener = new_instancemethod(_fife.SoundEmitter_removeListener, None, SoundEmitter)
SoundEmitter_swigregister = _fife.SoundEmitter_swigregister
SoundEmitter_swigregister(SoundEmitter)

SD_DISTANCE_NONE = _fife.SD_DISTANCE_NONE
SD_DISTANCE_INVERSE = _fife.SD_DISTANCE_INVERSE
SD_DISTANCE_INVERSE_CLAMPED = _fife.SD_DISTANCE_INVERSE_CLAMPED
SD_DISTANCE_LINEAR = _fife.SD_DISTANCE_LINEAR
SD_DISTANCE_LINEAR_CLAMPED = _fife.SD_DISTANCE_LINEAR_CLAMPED
SD_DISTANCE_EXPONENT = _fife.SD_DISTANCE_EXPONENT
SD_DISTANCE_EXPONENT_CLAMPED = _fife.SD_DISTANCE_EXPONENT_CLAMPED
SE_PRESET_GENERIC = _fife.SE_PRESET_GENERIC
SE_PRESET_PADDEDCELL = _fife.SE_PRESET_PADDEDCELL
SE_PRESET_ROOM = _fife.SE_PRESET_ROOM
SE_PRESET_BATHROOM = _fife.SE_PRESET_BATHROOM
SE_PRESET_LIVINGROOM = _fife.SE_PRESET_LIVINGROOM
SE_PRESET_STONEROOM = _fife.SE_PRESET_STONEROOM
SE_PRESET_AUDITORIUM = _fife.SE_PRESET_AUDITORIUM
SE_PRESET_CONCERTHALL = _fife.SE_PRESET_CONCERTHALL
SE_PRESET_CAVE = _fife.SE_PRESET_CAVE
SE_PRESET_ARENA = _fife.SE_PRESET_ARENA
SE_PRESET_HANGAR = _fife.SE_PRESET_HANGAR
SE_PRESET_CARPETEDHALLWAY = _fife.SE_PRESET_CARPETEDHALLWAY
SE_PRESET_HALLWAY = _fife.SE_PRESET_HALLWAY
SE_PRESET_STONECORRIDOR = _fife.SE_PRESET_STONECORRIDOR
SE_PRESET_ALLEY = _fife.SE_PRESET_ALLEY
SE_PRESET_FOREST = _fife.SE_PRESET_FOREST
SE_PRESET_CITY = _fife.SE_PRESET_CITY
SE_PRESET_MOUNTAINS = _fife.SE_PRESET_MOUNTAINS
SE_PRESET_QUARRY = _fife.SE_PRESET_QUARRY
SE_PRESET_PLAIN = _fife.SE_PRESET_PLAIN
SE_PRESET_PARKINGLOT = _fife.SE_PRESET_PARKINGLOT
SE_PRESET_SEWERPIPE = _fife.SE_PRESET_SEWERPIPE
SE_PRESET_UNDERWATER = _fife.SE_PRESET_UNDERWATER
SE_PRESET_DRUGGED = _fife.SE_PRESET_DRUGGED
SE_PRESET_DIZZY = _fife.SE_PRESET_DIZZY
SE_PRESET_PSYCHOTIC = _fife.SE_PRESET_PSYCHOTIC
SE_PRESET_CASTLE_SMALLROOM = _fife.SE_PRESET_CASTLE_SMALLROOM
SE_PRESET_CASTLE_SHORTPASSAGE = _fife.SE_PRESET_CASTLE_SHORTPASSAGE
SE_PRESET_CASTLE_MEDIUMROOM = _fife.SE_PRESET_CASTLE_MEDIUMROOM
SE_PRESET_CASTLE_LARGEROOM = _fife.SE_PRESET_CASTLE_LARGEROOM
SE_PRESET_CASTLE_LONGPASSAGE = _fife.SE_PRESET_CASTLE_LONGPASSAGE
SE_PRESET_CASTLE_HALL = _fife.SE_PRESET_CASTLE_HALL
SE_PRESET_CASTLE_CUPBOARD = _fife.SE_PRESET_CASTLE_CUPBOARD
SE_PRESET_CASTLE_COURTYARD = _fife.SE_PRESET_CASTLE_COURTYARD
SE_PRESET_CASTLE_ALCOVE = _fife.SE_PRESET_CASTLE_ALCOVE
SE_PRESET_FACTORY_SMALLROOM = _fife.SE_PRESET_FACTORY_SMALLROOM
SE_PRESET_FACTORY_SHORTPASSAGE = _fife.SE_PRESET_FACTORY_SHORTPASSAGE
SE_PRESET_FACTORY_MEDIUMROOM = _fife.SE_PRESET_FACTORY_MEDIUMROOM
SE_PRESET_FACTORY_LARGEROOM = _fife.SE_PRESET_FACTORY_LARGEROOM
SE_PRESET_FACTORY_LONGPASSAGE = _fife.SE_PRESET_FACTORY_LONGPASSAGE
SE_PRESET_FACTORY_HALL = _fife.SE_PRESET_FACTORY_HALL
SE_PRESET_FACTORY_CUPBOARD = _fife.SE_PRESET_FACTORY_CUPBOARD
SE_PRESET_FACTORY_COURTYARD = _fife.SE_PRESET_FACTORY_COURTYARD
SE_PRESET_FACTORY_ALCOVE = _fife.SE_PRESET_FACTORY_ALCOVE
SE_PRESET_ICEPALACE_SMALLROOM = _fife.SE_PRESET_ICEPALACE_SMALLROOM
SE_PRESET_ICEPALACE_SHORTPASSAGE = _fife.SE_PRESET_ICEPALACE_SHORTPASSAGE
SE_PRESET_ICEPALACE_MEDIUMROOM = _fife.SE_PRESET_ICEPALACE_MEDIUMROOM
SE_PRESET_ICEPALACE_LARGEROOM = _fife.SE_PRESET_ICEPALACE_LARGEROOM
SE_PRESET_ICEPALACE_LONGPASSAGE = _fife.SE_PRESET_ICEPALACE_LONGPASSAGE
SE_PRESET_ICEPALACE_HALL = _fife.SE_PRESET_ICEPALACE_HALL
SE_PRESET_ICEPALACE_CUPBOARD = _fife.SE_PRESET_ICEPALACE_CUPBOARD
SE_PRESET_ICEPALACE_COURTYARD = _fife.SE_PRESET_ICEPALACE_COURTYARD
SE_PRESET_ICEPALACE_ALCOVE = _fife.SE_PRESET_ICEPALACE_ALCOVE
SE_PRESET_SPACESTATION_SMALLROOM = _fife.SE_PRESET_SPACESTATION_SMALLROOM
SE_PRESET_SPACESTATION_SHORTPASSAGE = _fife.SE_PRESET_SPACESTATION_SHORTPASSAGE
SE_PRESET_SPACESTATION_MEDIUMROOM = _fife.SE_PRESET_SPACESTATION_MEDIUMROOM
SE_PRESET_SPACESTATION_LARGEROOM = _fife.SE_PRESET_SPACESTATION_LARGEROOM
SE_PRESET_SPACESTATION_LONGPASSAGE = _fife.SE_PRESET_SPACESTATION_LONGPASSAGE
SE_PRESET_SPACESTATION_HALL = _fife.SE_PRESET_SPACESTATION_HALL
SE_PRESET_SPACESTATION_CUPBOARD = _fife.SE_PRESET_SPACESTATION_CUPBOARD
SE_PRESET_SPACESTATION_ALCOVE = _fife.SE_PRESET_SPACESTATION_ALCOVE
SE_PRESET_WOODEN_SMALLROOM = _fife.SE_PRESET_WOODEN_SMALLROOM
SE_PRESET_WOODEN_SHORTPASSAGE = _fife.SE_PRESET_WOODEN_SHORTPASSAGE
SE_PRESET_WOODEN_MEDIUMROOM = _fife.SE_PRESET_WOODEN_MEDIUMROOM
SE_PRESET_WOODEN_LARGEROOM = _fife.SE_PRESET_WOODEN_LARGEROOM
SE_PRESET_WOODEN_LONGPASSAGE = _fife.SE_PRESET_WOODEN_LONGPASSAGE
SE_PRESET_WOODEN_HALL = _fife.SE_PRESET_WOODEN_HALL
SE_PRESET_WOODEN_CUPBOARD = _fife.SE_PRESET_WOODEN_CUPBOARD
SE_PRESET_WOODEN_COURTYARD = _fife.SE_PRESET_WOODEN_COURTYARD
SE_PRESET_WOODEN_ALCOVE = _fife.SE_PRESET_WOODEN_ALCOVE
SE_PRESET_SPORT_EMPTYSTADIUM = _fife.SE_PRESET_SPORT_EMPTYSTADIUM
SE_PRESET_SPORT_SQUASHCOURT = _fife.SE_PRESET_SPORT_SQUASHCOURT
SE_PRESET_SPORT_SMALLSWIMMINGPOOL = _fife.SE_PRESET_SPORT_SMALLSWIMMINGPOOL
SE_PRESET_SPORT_LARGESWIMMINGPOOL = _fife.SE_PRESET_SPORT_LARGESWIMMINGPOOL
SE_PRESET_SPORT_GYMNASIUM = _fife.SE_PRESET_SPORT_GYMNASIUM
SE_PRESET_SPORT_FULLSTADIUM = _fife.SE_PRESET_SPORT_FULLSTADIUM
SE_PRESET_SPORT_STADIUMTANNOY = _fife.SE_PRESET_SPORT_STADIUMTANNOY
SE_PRESET_PREFAB_WORKSHOP = _fife.SE_PRESET_PREFAB_WORKSHOP
SE_PRESET_PREFAB_SCHOOLROOM = _fife.SE_PRESET_PREFAB_SCHOOLROOM
SE_PRESET_PREFAB_PRACTISEROOM = _fife.SE_PRESET_PREFAB_PRACTISEROOM
SE_PRESET_PREFAB_OUTHOUSE = _fife.SE_PRESET_PREFAB_OUTHOUSE
SE_PRESET_PREFAB_CARAVAN = _fife.SE_PRESET_PREFAB_CARAVAN
SE_PRESET_DOME_TOMB = _fife.SE_PRESET_DOME_TOMB
SE_PRESET_PIPE_SMALL = _fife.SE_PRESET_PIPE_SMALL
SE_PRESET_DOME_SAINTPAULS = _fife.SE_PRESET_DOME_SAINTPAULS
SE_PRESET_PIPE_LONGTHIN = _fife.SE_PRESET_PIPE_LONGTHIN
SE_PRESET_PIPE_LARGE = _fife.SE_PRESET_PIPE_LARGE
SE_PRESET_PIPE_RESONANT = _fife.SE_PRESET_PIPE_RESONANT
SE_PRESET_OUTDOORS_BACKYARD = _fife.SE_PRESET_OUTDOORS_BACKYARD
SE_PRESET_OUTDOORS_ROLLINGPLAINS = _fife.SE_PRESET_OUTDOORS_ROLLINGPLAINS
SE_PRESET_OUTDOORS_DEEPCANYON = _fife.SE_PRESET_OUTDOORS_DEEPCANYON
SE_PRESET_OUTDOORS_CREEK = _fife.SE_PRESET_OUTDOORS_CREEK
SE_PRESET_OUTDOORS_VALLEY = _fife.SE_PRESET_OUTDOORS_VALLEY
SE_PRESET_MOOD_HEAVEN = _fife.SE_PRESET_MOOD_HEAVEN
SE_PRESET_MOOD_HELL = _fife.SE_PRESET_MOOD_HELL
SE_PRESET_MOOD_MEMORY = _fife.SE_PRESET_MOOD_MEMORY
SE_PRESET_DRIVING_COMMENTATOR = _fife.SE_PRESET_DRIVING_COMMENTATOR
SE_PRESET_DRIVING_PITGARAGE = _fife.SE_PRESET_DRIVING_PITGARAGE
SE_PRESET_DRIVING_INCAR_RACER = _fife.SE_PRESET_DRIVING_INCAR_RACER
SE_PRESET_DRIVING_INCAR_SPORTS = _fife.SE_PRESET_DRIVING_INCAR_SPORTS
SE_PRESET_DRIVING_INCAR_LUXURY = _fife.SE_PRESET_DRIVING_INCAR_LUXURY
SE_PRESET_DRIVING_FULLGRANDSTAND = _fife.SE_PRESET_DRIVING_FULLGRANDSTAND
SE_PRESET_DRIVING_EMPTYGRANDSTAND = _fife.SE_PRESET_DRIVING_EMPTYGRANDSTAND
SE_PRESET_DRIVING_TUNNEL = _fife.SE_PRESET_DRIVING_TUNNEL
SE_PRESET_CITY_STREETS = _fife.SE_PRESET_CITY_STREETS
SE_PRESET_CITY_SUBWAY = _fife.SE_PRESET_CITY_SUBWAY
SE_PRESET_CITY_MUSEUM = _fife.SE_PRESET_CITY_MUSEUM
SE_PRESET_CITY_LIBRARY = _fife.SE_PRESET_CITY_LIBRARY
SE_PRESET_CITY_UNDERPASS = _fife.SE_PRESET_CITY_UNDERPASS
SE_PRESET_CITY_ABANDONED = _fife.SE_PRESET_CITY_ABANDONED
SE_PRESET_DUSTYROOM = _fife.SE_PRESET_DUSTYROOM
SE_PRESET_CHAPEL = _fife.SE_PRESET_CHAPEL
SE_PRESET_SMALLWATERROOM = _fife.SE_PRESET_SMALLWATERROOM
class SoundManager(object):
    """Proxy of C++ FIFE::SoundManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def init(self):
        """init(SoundManager self)"""
        return _fife.SoundManager_init(self)


    def isActive(self):
        """isActive(SoundManager self) -> bool"""
        return _fife.SoundManager_isActive(self)


    def createEmitter(self, *args):
        """
        createEmitter(SoundManager self) -> SoundEmitter
        createEmitter(SoundManager self, std::string const & name) -> SoundEmitter
        """
        return _fife.SoundManager_createEmitter(self, *args)


    def deleteEmitter(self, emitter):
        """deleteEmitter(SoundManager self, SoundEmitter emitter)"""
        return _fife.SoundManager_deleteEmitter(self, emitter)


    def getEmitter(self, emitterId):
        """getEmitter(SoundManager self, uint32_t emitterId) -> SoundEmitter"""
        return _fife.SoundManager_getEmitter(self, emitterId)


    def releaseEmitter(self, emitterId):
        """releaseEmitter(SoundManager self, uint32_t emitterId)"""
        return _fife.SoundManager_releaseEmitter(self, emitterId)


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


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


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


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


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


    def setDistanceModel(self, model):
        """setDistanceModel(SoundManager self, FIFE::SoundDistanceModelType model)"""
        return _fife.SoundManager_setDistanceModel(self, model)


    def getDistanceModel(self):
        """getDistanceModel(SoundManager self) -> FIFE::SoundDistanceModelType"""
        return _fife.SoundManager_getDistanceModel(self)


    def setListenerPosition(self, position):
        """setListenerPosition(SoundManager self, DoublePoint3D position)"""
        return _fife.SoundManager_setListenerPosition(self, position)


    def getListenerPosition(self):
        """getListenerPosition(SoundManager self) -> DoublePoint3D"""
        return _fife.SoundManager_getListenerPosition(self)


    def setListenerOrientation(self, orientation):
        """setListenerOrientation(SoundManager self, DoublePoint3D orientation)"""
        return _fife.SoundManager_setListenerOrientation(self, orientation)


    def getListenerOrientation(self):
        """getListenerOrientation(SoundManager self) -> DoublePoint3D"""
        return _fife.SoundManager_getListenerOrientation(self)


    def setListenerVelocity(self, velocity):
        """setListenerVelocity(SoundManager self, DoublePoint3D velocity)"""
        return _fife.SoundManager_setListenerVelocity(self, velocity)


    def getListenerVelocity(self):
        """getListenerVelocity(SoundManager self) -> DoublePoint3D"""
        return _fife.SoundManager_getListenerVelocity(self)


    def setDopplerFactor(self, factor):
        """setDopplerFactor(SoundManager self, float factor)"""
        return _fife.SoundManager_setDopplerFactor(self, factor)


    def getDopplerFactor(self):
        """getDopplerFactor(SoundManager self) -> float"""
        return _fife.SoundManager_getDopplerFactor(self)


    def setListenerMaxDistance(self, distance):
        """setListenerMaxDistance(SoundManager self, float distance)"""
        return _fife.SoundManager_setListenerMaxDistance(self, distance)


    def getListenerMaxDistance(self):
        """getListenerMaxDistance(SoundManager self) -> float"""
        return _fife.SoundManager_getListenerMaxDistance(self)


    def createSoundEffect(self, type):
        """createSoundEffect(SoundManager self, FIFE::SoundEffectType type) -> SoundEffect"""
        return _fife.SoundManager_createSoundEffect(self, type)


    def createSoundEffectPreset(self, type):
        """createSoundEffectPreset(SoundManager self, FIFE::SoundEffectPreset type) -> SoundEffect"""
        return _fife.SoundManager_createSoundEffectPreset(self, type)


    def deleteSoundEffect(self, effect):
        """deleteSoundEffect(SoundManager self, SoundEffect effect)"""
        return _fife.SoundManager_deleteSoundEffect(self, effect)


    def enableSoundEffect(self, effect):
        """enableSoundEffect(SoundManager self, SoundEffect effect)"""
        return _fife.SoundManager_enableSoundEffect(self, effect)


    def disableSoundEffect(self, effect):
        """disableSoundEffect(SoundManager self, SoundEffect effect)"""
        return _fife.SoundManager_disableSoundEffect(self, effect)


    def addEmitterToSoundEffect(self, effect, emitter):
        """addEmitterToSoundEffect(SoundManager self, SoundEffect effect, SoundEmitter emitter)"""
        return _fife.SoundManager_addEmitterToSoundEffect(self, effect, emitter)


    def removeEmitterFromSoundEffect(self, effect, emitter):
        """removeEmitterFromSoundEffect(SoundManager self, SoundEffect effect, SoundEmitter emitter)"""
        return _fife.SoundManager_removeEmitterFromSoundEffect(self, effect, emitter)


    def addSoundFilterToSoundEffect(self, effect, filter):
        """addSoundFilterToSoundEffect(SoundManager self, SoundEffect effect, SoundFilter filter)"""
        return _fife.SoundManager_addSoundFilterToSoundEffect(self, effect, filter)


    def removeSoundFilterFromSoundEffect(self, effect, filter):
        """removeSoundFilterFromSoundEffect(SoundManager self, SoundEffect effect, SoundFilter filter)"""
        return _fife.SoundManager_removeSoundFilterFromSoundEffect(self, effect, filter)


    def createSoundFilter(self, type):
        """createSoundFilter(SoundManager self, FIFE::SoundFilterType type) -> SoundFilter"""
        return _fife.SoundManager_createSoundFilter(self, type)


    def deleteSoundFilter(self, filter):
        """deleteSoundFilter(SoundManager self, SoundFilter filter)"""
        return _fife.SoundManager_deleteSoundFilter(self, filter)


    def enableDirectSoundFilter(self, filter):
        """enableDirectSoundFilter(SoundManager self, SoundFilter filter)"""
        return _fife.SoundManager_enableDirectSoundFilter(self, filter)


    def disableDirectSoundFilter(self, filter):
        """disableDirectSoundFilter(SoundManager self, SoundFilter filter)"""
        return _fife.SoundManager_disableDirectSoundFilter(self, filter)


    def addEmitterToDirectSoundFilter(self, filter, emitter):
        """addEmitterToDirectSoundFilter(SoundManager self, SoundFilter filter, SoundEmitter emitter)"""
        return _fife.SoundManager_addEmitterToDirectSoundFilter(self, filter, emitter)


    def removeEmitterFromDirectSoundFilter(self, filter, emitter):
        """removeEmitterFromDirectSoundFilter(SoundManager self, SoundFilter filter, SoundEmitter emitter)"""
        return _fife.SoundManager_removeEmitterFromDirectSoundFilter(self, filter, emitter)


    def removeGroup(self, group):
        """removeGroup(SoundManager self, std::string const & group)"""
        return _fife.SoundManager_removeGroup(self, group)


    def removeAllGroups(self):
        """removeAllGroups(SoundManager self)"""
        return _fife.SoundManager_removeAllGroups(self)


    def play(self, *args):
        """
        play(SoundManager self)
        play(SoundManager self, std::string const & group)
        """
        return _fife.SoundManager_play(self, *args)


    def pause(self, *args):
        """
        pause(SoundManager self)
        pause(SoundManager self, std::string const & group)
        """
        return _fife.SoundManager_pause(self, *args)


    def stop(self, *args):
        """
        stop(SoundManager self)
        stop(SoundManager self, std::string const & group)
        """
        return _fife.SoundManager_stop(self, *args)


    def rewind(self, *args):
        """
        rewind(SoundManager self)
        rewind(SoundManager self, std::string const & group)
        """
        return _fife.SoundManager_rewind(self, *args)


    def setGain(self, group, gain):
        """setGain(SoundManager self, std::string const & group, float gain)"""
        return _fife.SoundManager_setGain(self, group, gain)


    def setMaxGain(self, group, gain):
        """setMaxGain(SoundManager self, std::string const & group, float gain)"""
        return _fife.SoundManager_setMaxGain(self, group, gain)


    def setMinGain(self, group, gain):
        """setMinGain(SoundManager self, std::string const & group, float gain)"""
        return _fife.SoundManager_setMinGain(self, group, gain)


    def __init__(self):
        """__init__(FIFE::SoundManager self) -> SoundManager"""
        _fife.SoundManager_swiginit(self, _fife.new_SoundManager())
    __swig_destroy__ = _fife.delete_SoundManager
SoundManager.init = new_instancemethod(_fife.SoundManager_init, None, SoundManager)
SoundManager.isActive = new_instancemethod(_fife.SoundManager_isActive, None, SoundManager)
SoundManager.createEmitter = new_instancemethod(_fife.SoundManager_createEmitter, None, SoundManager)
SoundManager.deleteEmitter = new_instancemethod(_fife.SoundManager_deleteEmitter, None, SoundManager)
SoundManager.getEmitter = new_instancemethod(_fife.SoundManager_getEmitter, None, SoundManager)
SoundManager.releaseEmitter = new_instancemethod(_fife.SoundManager_releaseEmitter, None, SoundManager)
SoundManager.getContext = new_instancemethod(_fife.SoundManager_getContext, None, SoundManager)
SoundManager.setVolume = new_instancemethod(_fife.SoundManager_setVolume, None, SoundManager)
SoundManager.getVolume = new_instancemethod(_fife.SoundManager_getVolume, None, SoundManager)
SoundManager.mute = new_instancemethod(_fife.SoundManager_mute, None, SoundManager)
SoundManager.unmute = new_instancemethod(_fife.SoundManager_unmute, None, SoundManager)
SoundManager.setDistanceModel = new_instancemethod(_fife.SoundManager_setDistanceModel, None, SoundManager)
SoundManager.getDistanceModel = new_instancemethod(_fife.SoundManager_getDistanceModel, None, SoundManager)
SoundManager.setListenerPosition = new_instancemethod(_fife.SoundManager_setListenerPosition, None, SoundManager)
SoundManager.getListenerPosition = new_instancemethod(_fife.SoundManager_getListenerPosition, None, SoundManager)
SoundManager.setListenerOrientation = new_instancemethod(_fife.SoundManager_setListenerOrientation, None, SoundManager)
SoundManager.getListenerOrientation = new_instancemethod(_fife.SoundManager_getListenerOrientation, None, SoundManager)
SoundManager.setListenerVelocity = new_instancemethod(_fife.SoundManager_setListenerVelocity, None, SoundManager)
SoundManager.getListenerVelocity = new_instancemethod(_fife.SoundManager_getListenerVelocity, None, SoundManager)
SoundManager.setDopplerFactor = new_instancemethod(_fife.SoundManager_setDopplerFactor, None, SoundManager)
SoundManager.getDopplerFactor = new_instancemethod(_fife.SoundManager_getDopplerFactor, None, SoundManager)
SoundManager.setListenerMaxDistance = new_instancemethod(_fife.SoundManager_setListenerMaxDistance, None, SoundManager)
SoundManager.getListenerMaxDistance = new_instancemethod(_fife.SoundManager_getListenerMaxDistance, None, SoundManager)
SoundManager.createSoundEffect = new_instancemethod(_fife.SoundManager_createSoundEffect, None, SoundManager)
SoundManager.createSoundEffectPreset = new_instancemethod(_fife.SoundManager_createSoundEffectPreset, None, SoundManager)
SoundManager.deleteSoundEffect = new_instancemethod(_fife.SoundManager_deleteSoundEffect, None, SoundManager)
SoundManager.enableSoundEffect = new_instancemethod(_fife.SoundManager_enableSoundEffect, None, SoundManager)
SoundManager.disableSoundEffect = new_instancemethod(_fife.SoundManager_disableSoundEffect, None, SoundManager)
SoundManager.addEmitterToSoundEffect = new_instancemethod(_fife.SoundManager_addEmitterToSoundEffect, None, SoundManager)
SoundManager.removeEmitterFromSoundEffect = new_instancemethod(_fife.SoundManager_removeEmitterFromSoundEffect, None, SoundManager)
SoundManager.addSoundFilterToSoundEffect = new_instancemethod(_fife.SoundManager_addSoundFilterToSoundEffect, None, SoundManager)
SoundManager.removeSoundFilterFromSoundEffect = new_instancemethod(_fife.SoundManager_removeSoundFilterFromSoundEffect, None, SoundManager)
SoundManager.createSoundFilter = new_instancemethod(_fife.SoundManager_createSoundFilter, None, SoundManager)
SoundManager.deleteSoundFilter = new_instancemethod(_fife.SoundManager_deleteSoundFilter, None, SoundManager)
SoundManager.enableDirectSoundFilter = new_instancemethod(_fife.SoundManager_enableDirectSoundFilter, None, SoundManager)
SoundManager.disableDirectSoundFilter = new_instancemethod(_fife.SoundManager_disableDirectSoundFilter, None, SoundManager)
SoundManager.addEmitterToDirectSoundFilter = new_instancemethod(_fife.SoundManager_addEmitterToDirectSoundFilter, None, SoundManager)
SoundManager.removeEmitterFromDirectSoundFilter = new_instancemethod(_fife.SoundManager_removeEmitterFromDirectSoundFilter, None, SoundManager)
SoundManager.removeGroup = new_instancemethod(_fife.SoundManager_removeGroup, None, SoundManager)
SoundManager.removeAllGroups = new_instancemethod(_fife.SoundManager_removeAllGroups, None, SoundManager)
SoundManager.play = new_instancemethod(_fife.SoundManager_play, None, SoundManager)
SoundManager.pause = new_instancemethod(_fife.SoundManager_pause, None, SoundManager)
SoundManager.stop = new_instancemethod(_fife.SoundManager_stop, None, SoundManager)
SoundManager.rewind = new_instancemethod(_fife.SoundManager_rewind, None, SoundManager)
SoundManager.setGain = new_instancemethod(_fife.SoundManager_setGain, None, SoundManager)
SoundManager.setMaxGain = new_instancemethod(_fife.SoundManager_setMaxGain, None, SoundManager)
SoundManager.setMinGain = new_instancemethod(_fife.SoundManager_setMinGain, None, SoundManager)
SoundManager_swigregister = _fife.SoundManager_swigregister
SoundManager_swigregister(SoundManager)

class EngineSettings(object):
    """Proxy of C++ FIFE::EngineSettings class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_EngineSettings

    def setBitsPerPixel(self, bitsperpixel):
        """setBitsPerPixel(EngineSettings self, uint8_t bitsperpixel)"""
        return _fife.EngineSettings_setBitsPerPixel(self, bitsperpixel)


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


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


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


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


    def setRefreshRate(self, rate):
        """setRefreshRate(EngineSettings self, uint16_t rate)"""
        return _fife.EngineSettings_setRefreshRate(self, rate)


    def getRefreshRate(self):
        """getRefreshRate(EngineSettings self) -> uint16_t"""
        return _fife.EngineSettings_getRefreshRate(self)


    def setDisplay(self, display):
        """setDisplay(EngineSettings self, uint8_t display)"""
        return _fife.EngineSettings_setDisplay(self, display)


    def getDisplay(self):
        """getDisplay(EngineSettings self) -> uint8_t"""
        return _fife.EngineSettings_getDisplay(self)


    def setVSync(self, vsync):
        """setVSync(EngineSettings self, bool vsync)"""
        return _fife.EngineSettings_setVSync(self, vsync)


    def isVSync(self):
        """isVSync(EngineSettings self) -> bool"""
        return _fife.EngineSettings_isVSync(self)


    def setSDLDriver(self, driver):
        """setSDLDriver(EngineSettings self, std::string const & driver)"""
        return _fife.EngineSettings_setSDLDriver(self, driver)


    def getSDLDriver(self):
        """getSDLDriver(EngineSettings self) -> std::string const &"""
        return _fife.EngineSettings_getSDLDriver(self)


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


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


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


    def setRenderBackend(self, renderbackend):
        """setRenderBackend(EngineSettings self, std::string const & renderbackend)"""
        return _fife.EngineSettings_setRenderBackend(self, renderbackend)


    def getRenderBackend(self):
        """getRenderBackend(EngineSettings self) -> std::string const &"""
        return _fife.EngineSettings_getRenderBackend(self)


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


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


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


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


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


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


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


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


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


    def setGLTextureFiltering(self, filter):
        """setGLTextureFiltering(EngineSettings self, FIFE::TextureFiltering filter)"""
        return _fife.EngineSettings_setGLTextureFiltering(self, filter)


    def getGLTextureFiltering(self):
        """getGLTextureFiltering(EngineSettings self) -> FIFE::TextureFiltering"""
        return _fife.EngineSettings_getGLTextureFiltering(self)


    def setGLUseMipmapping(self, mipmapping):
        """setGLUseMipmapping(EngineSettings self, bool mipmapping)"""
        return _fife.EngineSettings_setGLUseMipmapping(self, mipmapping)


    def isGLUseMipmapping(self):
        """isGLUseMipmapping(EngineSettings self) -> bool"""
        return _fife.EngineSettings_isGLUseMipmapping(self)


    def setGLUseMonochrome(self, monochrome):
        """setGLUseMonochrome(EngineSettings self, bool monochrome)"""
        return _fife.EngineSettings_setGLUseMonochrome(self, monochrome)


    def isGLUseMonochrome(self):
        """isGLUseMonochrome(EngineSettings self) -> bool"""
        return _fife.EngineSettings_isGLUseMonochrome(self)


    def setGLUseDepthBuffer(self, buffer):
        """setGLUseDepthBuffer(EngineSettings self, bool buffer)"""
        return _fife.EngineSettings_setGLUseDepthBuffer(self, buffer)


    def isGLUseDepthBuffer(self):
        """isGLUseDepthBuffer(EngineSettings self) -> bool"""
        return _fife.EngineSettings_isGLUseDepthBuffer(self)


    def setGLAlphaTestValue(self, alpha):
        """setGLAlphaTestValue(EngineSettings self, float alpha)"""
        return _fife.EngineSettings_setGLAlphaTestValue(self, alpha)


    def getGLAlphaTestValue(self):
        """getGLAlphaTestValue(EngineSettings self) -> float"""
        return _fife.EngineSettings_getGLAlphaTestValue(self)


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


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


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


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


    def setDefaultFontPath(self, defaultfontpath):
        """setDefaultFontPath(EngineSettings self, std::string const & defaultfontpath)"""
        return _fife.EngineSettings_setDefaultFontPath(self, defaultfontpath)


    def getDefaultFontPath(self):
        """getDefaultFontPath(EngineSettings self) -> std::string const &"""
        return _fife.EngineSettings_getDefaultFontPath(self)


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


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


    def setDefaultFontGlyphs(self, defaultfontglyphs):
        """setDefaultFontGlyphs(EngineSettings self, std::string const & defaultfontglyphs)"""
        return _fife.EngineSettings_setDefaultFontGlyphs(self, defaultfontglyphs)


    def getDefaultFontGlyphs(self):
        """getDefaultFontGlyphs(EngineSettings self) -> std::string const &"""
        return _fife.EngineSettings_getDefaultFontGlyphs(self)


    def setWindowTitle(self, title):
        """setWindowTitle(EngineSettings self, std::string const & title)"""
        return _fife.EngineSettings_setWindowTitle(self, title)


    def getWindowTitle(self):
        """getWindowTitle(EngineSettings self) -> std::string const &"""
        return _fife.EngineSettings_getWindowTitle(self)


    def setWindowIcon(self, icon):
        """setWindowIcon(EngineSettings self, std::string const & icon)"""
        return _fife.EngineSettings_setWindowIcon(self, icon)


    def getWindowIcon(self):
        """getWindowIcon(EngineSettings self) -> std::string const &"""
        return _fife.EngineSettings_getWindowIcon(self)


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


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


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


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


    def setVideoDriver(self, driver):
        """setVideoDriver(EngineSettings self, std::string const & driver)"""
        return _fife.EngineSettings_setVideoDriver(self, driver)


    def getVideoDriver(self):
        """getVideoDriver(EngineSettings self) -> std::string const &"""
        return _fife.EngineSettings_getVideoDriver(self)


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


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


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


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


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


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


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


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


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


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


    def setNativeImageCursorEnabled(self, nativeimagecursor):
        """setNativeImageCursorEnabled(EngineSettings self, bool nativeimagecursor)"""
        return _fife.EngineSettings_setNativeImageCursorEnabled(self, nativeimagecursor)


    def isNativeImageCursorEnabled(self):
        """isNativeImageCursorEnabled(EngineSettings self) -> bool"""
        return _fife.EngineSettings_isNativeImageCursorEnabled(self)


    def setJoystickSupport(self, support):
        """setJoystickSupport(EngineSettings self, bool support)"""
        return _fife.EngineSettings_setJoystickSupport(self, support)


    def isJoystickSupport(self):
        """isJoystickSupport(EngineSettings self) -> bool"""
        return _fife.EngineSettings_isJoystickSupport(self)

EngineSettings.setBitsPerPixel = new_instancemethod(_fife.EngineSettings_setBitsPerPixel, None, EngineSettings)
EngineSettings.getBitsPerPixel = new_instancemethod(_fife.EngineSettings_getBitsPerPixel, None, EngineSettings)
EngineSettings.getPossibleBitsPerPixel = new_instancemethod(_fife.EngineSettings_getPossibleBitsPerPixel, None, EngineSettings)
EngineSettings.setFullScreen = new_instancemethod(_fife.EngineSettings_setFullScreen, None, EngineSettings)
EngineSettings.isFullScreen = new_instancemethod(_fife.EngineSettings_isFullScreen, None, EngineSettings)
EngineSettings.setRefreshRate = new_instancemethod(_fife.EngineSettings_setRefreshRate, None, EngineSettings)
EngineSettings.getRefreshRate = new_instancemethod(_fife.EngineSettings_getRefreshRate, None, EngineSettings)
EngineSettings.setDisplay = new_instancemethod(_fife.EngineSettings_setDisplay, None, EngineSettings)
EngineSettings.getDisplay = new_instancemethod(_fife.EngineSettings_getDisplay, None, EngineSettings)
EngineSettings.setVSync = new_instancemethod(_fife.EngineSettings_setVSync, None, EngineSettings)
EngineSettings.isVSync = new_instancemethod(_fife.EngineSettings_isVSync, None, EngineSettings)
EngineSettings.setSDLDriver = new_instancemethod(_fife.EngineSettings_setSDLDriver, None, EngineSettings)
EngineSettings.getSDLDriver = new_instancemethod(_fife.EngineSettings_getSDLDriver, None, EngineSettings)
EngineSettings.setInitialVolume = new_instancemethod(_fife.EngineSettings_setInitialVolume, None, EngineSettings)
EngineSettings.getInitialVolume = new_instancemethod(_fife.EngineSettings_getInitialVolume, None, EngineSettings)
EngineSettings.getMaxVolume = new_instancemethod(_fife.EngineSettings_getMaxVolume, None, EngineSettings)
EngineSettings.setRenderBackend = new_instancemethod(_fife.EngineSettings_setRenderBackend, None, EngineSettings)
EngineSettings.getRenderBackend = new_instancemethod(_fife.EngineSettings_getRenderBackend, None, EngineSettings)
EngineSettings.getPossibleRenderBackends = new_instancemethod(_fife.EngineSettings_getPossibleRenderBackends, None, EngineSettings)
EngineSettings.setSDLRemoveFakeAlpha = new_instancemethod(_fife.EngineSettings_setSDLRemoveFakeAlpha, None, EngineSettings)
EngineSettings.isSDLRemoveFakeAlpha = new_instancemethod(_fife.EngineSettings_isSDLRemoveFakeAlpha, None, EngineSettings)
EngineSettings.setGLCompressImages = new_instancemethod(_fife.EngineSettings_setGLCompressImages, None, EngineSettings)
EngineSettings.isGLCompressImages = new_instancemethod(_fife.EngineSettings_isGLCompressImages, None, EngineSettings)
EngineSettings.setGLUseFramebuffer = new_instancemethod(_fife.EngineSettings_setGLUseFramebuffer, None, EngineSettings)
EngineSettings.isGLUseFramebuffer = new_instancemethod(_fife.EngineSettings_isGLUseFramebuffer, None, EngineSettings)
EngineSettings.setGLUseNPOT = new_instancemethod(_fife.EngineSettings_setGLUseNPOT, None, EngineSettings)
EngineSettings.isGLUseNPOT = new_instancemethod(_fife.EngineSettings_isGLUseNPOT, None, EngineSettings)
EngineSettings.setGLTextureFiltering = new_instancemethod(_fife.EngineSettings_setGLTextureFiltering, None, EngineSettings)
EngineSettings.getGLTextureFiltering = new_instancemethod(_fife.EngineSettings_getGLTextureFiltering, None, EngineSettings)
EngineSettings.setGLUseMipmapping = new_instancemethod(_fife.EngineSettings_setGLUseMipmapping, None, EngineSettings)
EngineSettings.isGLUseMipmapping = new_instancemethod(_fife.EngineSettings_isGLUseMipmapping, None, EngineSettings)
EngineSettings.setGLUseMonochrome = new_instancemethod(_fife.EngineSettings_setGLUseMonochrome, None, EngineSettings)
EngineSettings.isGLUseMonochrome = new_instancemethod(_fife.EngineSettings_isGLUseMonochrome, None, EngineSettings)
EngineSettings.setGLUseDepthBuffer = new_instancemethod(_fife.EngineSettings_setGLUseDepthBuffer, None, EngineSettings)
EngineSettings.isGLUseDepthBuffer = new_instancemethod(_fife.EngineSettings_isGLUseDepthBuffer, None, EngineSettings)
EngineSettings.setGLAlphaTestValue = new_instancemethod(_fife.EngineSettings_setGLAlphaTestValue, None, EngineSettings)
EngineSettings.getGLAlphaTestValue = new_instancemethod(_fife.EngineSettings_getGLAlphaTestValue, None, EngineSettings)
EngineSettings.setScreenWidth = new_instancemethod(_fife.EngineSettings_setScreenWidth, None, EngineSettings)
EngineSettings.getScreenWidth = new_instancemethod(_fife.EngineSettings_getScreenWidth, None, EngineSettings)
EngineSettings.setScreenHeight = new_instancemethod(_fife.EngineSettings_setScreenHeight, None, EngineSettings)
EngineSettings.getScreenHeight = new_instancemethod(_fife.EngineSettings_getScreenHeight, None, EngineSettings)
EngineSettings.setDefaultFontPath = new_instancemethod(_fife.EngineSettings_setDefaultFontPath, None, EngineSettings)
EngineSettings.getDefaultFontPath = new_instancemethod(_fife.EngineSettings_getDefaultFontPath, None, EngineSettings)
EngineSettings.setDefaultFontSize = new_instancemethod(_fife.EngineSettings_setDefaultFontSize, None, EngineSettings)
EngineSettings.getDefaultFontSize = new_instancemethod(_fife.EngineSettings_getDefaultFontSize, None, EngineSettings)
EngineSettings.setDefaultFontGlyphs = new_instancemethod(_fife.EngineSettings_setDefaultFontGlyphs, None, EngineSettings)
EngineSettings.getDefaultFontGlyphs = new_instancemethod(_fife.EngineSettings_getDefaultFontGlyphs, None, EngineSettings)
EngineSettings.setWindowTitle = new_instancemethod(_fife.EngineSettings_setWindowTitle, None, EngineSettings)
EngineSettings.getWindowTitle = new_instancemethod(_fife.EngineSettings_getWindowTitle, None, EngineSettings)
EngineSettings.setWindowIcon = new_instancemethod(_fife.EngineSettings_setWindowIcon, None, EngineSettings)
EngineSettings.getWindowIcon = new_instancemethod(_fife.EngineSettings_getWindowIcon, None, EngineSettings)
EngineSettings.setColorKeyEnabled = new_instancemethod(_fife.EngineSettings_setColorKeyEnabled, None, EngineSettings)
EngineSettings.isColorKeyEnabled = new_instancemethod(_fife.EngineSettings_isColorKeyEnabled, None, EngineSettings)
EngineSettings.setColorKey = new_instancemethod(_fife.EngineSettings_setColorKey, None, EngineSettings)
EngineSettings.getColorKey = new_instancemethod(_fife.EngineSettings_getColorKey, None, EngineSettings)
EngineSettings.setVideoDriver = new_instancemethod(_fife.EngineSettings_setVideoDriver, None, EngineSettings)
EngineSettings.getVideoDriver = new_instancemethod(_fife.EngineSettings_getVideoDriver, None, EngineSettings)
EngineSettings.setLightingModel = new_instancemethod(_fife.EngineSettings_setLightingModel, None, EngineSettings)
EngineSettings.getLightingModel = new_instancemethod(_fife.EngineSettings_getLightingModel, None, EngineSettings)
EngineSettings.setFrameLimitEnabled = new_instancemethod(_fife.EngineSettings_setFrameLimitEnabled, None, EngineSettings)
EngineSettings.isFrameLimitEnabled = new_instancemethod(_fife.EngineSettings_isFrameLimitEnabled, None, EngineSettings)
EngineSettings.setFrameLimit = new_instancemethod(_fife.EngineSettings_setFrameLimit, None, EngineSettings)
EngineSettings.getFrameLimit = new_instancemethod(_fife.EngineSettings_getFrameLimit, None, EngineSettings)
EngineSettings.setMouseSensitivity = new_instancemethod(_fife.EngineSettings_setMouseSensitivity, None, EngineSettings)
EngineSettings.getMouseSensitivity = new_instancemethod(_fife.EngineSettings_getMouseSensitivity, None, EngineSettings)
EngineSettings.setMouseAccelerationEnabled = new_instancemethod(_fife.EngineSettings_setMouseAccelerationEnabled, None, EngineSettings)
EngineSettings.isMouseAccelerationEnabled = new_instancemethod(_fife.EngineSettings_isMouseAccelerationEnabled, None, EngineSettings)
EngineSettings.setNativeImageCursorEnabled = new_instancemethod(_fife.EngineSettings_setNativeImageCursorEnabled, None, EngineSettings)
EngineSettings.isNativeImageCursorEnabled = new_instancemethod(_fife.EngineSettings_isNativeImageCursorEnabled, None, EngineSettings)
EngineSettings.setJoystickSupport = new_instancemethod(_fife.EngineSettings_setJoystickSupport, None, EngineSettings)
EngineSettings.isJoystickSupport = new_instancemethod(_fife.EngineSettings_isJoystickSupport, None, EngineSettings)
EngineSettings_swigregister = _fife.EngineSettings_swigregister
EngineSettings_swigregister(EngineSettings)

class IEngineChangeListener(object):
    """Proxy of C++ FIFE::IEngineChangeListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IEngineChangeListener

    def onScreenModeChanged(self, newmode):
        """onScreenModeChanged(IEngineChangeListener self, ScreenMode newmode)"""
        return _fife.IEngineChangeListener_onScreenModeChanged(self, newmode)


    def __init__(self):
        """__init__(FIFE::IEngineChangeListener self) -> IEngineChangeListener"""
        if self.__class__ == IEngineChangeListener:
            _self = None
        else:
            _self = self
        _fife.IEngineChangeListener_swiginit(self, _fife.new_IEngineChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEngineChangeListener(self)
        return weakref_proxy(self)
IEngineChangeListener.onScreenModeChanged = new_instancemethod(_fife.IEngineChangeListener_onScreenModeChanged, None, IEngineChangeListener)
IEngineChangeListener_swigregister = _fife.IEngineChangeListener_swigregister
IEngineChangeListener_swigregister(IEngineChangeListener)

class Engine(object):
    """Proxy of C++ FIFE::Engine class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::Engine self) -> Engine"""
        _fife.Engine_swiginit(self, _fife.new_Engine())
    __swig_destroy__ = _fife.delete_Engine

    def initializePumping(self):
        """initializePumping(Engine self)"""
        return _fife.Engine_initializePumping(self)


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


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


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


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


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


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


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


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


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


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


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


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


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


    def getAnimationManager(self):
        """getAnimationManager(Engine self) -> AnimationManager"""
        return _fife.Engine_getAnimationManager(self)


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


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


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


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


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


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


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


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


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


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

Engine.initializePumping = new_instancemethod(_fife.Engine_initializePumping, None, Engine)
Engine.finalizePumping = new_instancemethod(_fife.Engine_finalizePumping, None, Engine)
Engine.pump = new_instancemethod(_fife.Engine_pump, None, Engine)
Engine.getSettings = new_instancemethod(_fife.Engine_getSettings, None, Engine)
Engine.getDeviceCaps = new_instancemethod(_fife.Engine_getDeviceCaps, None, Engine)
Engine.changeScreenMode = new_instancemethod(_fife.Engine_changeScreenMode, None, Engine)
Engine.init = new_instancemethod(_fife.Engine_init, None, Engine)
Engine.destroy = new_instancemethod(_fife.Engine_destroy, None, Engine)
Engine.getSoundManager = new_instancemethod(_fife.Engine_getSoundManager, None, Engine)
Engine.getEventManager = new_instancemethod(_fife.Engine_getEventManager, None, Engine)
Engine.getTimeManager = new_instancemethod(_fife.Engine_getTimeManager, None, Engine)
Engine.setGuiManager = new_instancemethod(_fife.Engine_setGuiManager, None, Engine)
Engine.getGuiManager = new_instancemethod(_fife.Engine_getGuiManager, None, Engine)
Engine.getImageManager = new_instancemethod(_fife.Engine_getImageManager, None, Engine)
Engine.getAnimationManager = new_instancemethod(_fife.Engine_getAnimationManager, None, Engine)
Engine.getSoundClipManager = new_instancemethod(_fife.Engine_getSoundClipManager, None, Engine)
Engine.getRenderBackend = new_instancemethod(_fife.Engine_getRenderBackend, None, Engine)
Engine.getModel = new_instancemethod(_fife.Engine_getModel, None, Engine)
Engine.getLogManager = new_instancemethod(_fife.Engine_getLogManager, None, Engine)
Engine.getVFS = new_instancemethod(_fife.Engine_getVFS, None, Engine)
Engine.getCursor = new_instancemethod(_fife.Engine_getCursor, None, Engine)
Engine.getOffRenderer = new_instancemethod(_fife.Engine_getOffRenderer, None, Engine)
Engine.getTargetRenderer = new_instancemethod(_fife.Engine_getTargetRenderer, None, Engine)
Engine.addChangeListener = new_instancemethod(_fife.Engine_addChangeListener, None, Engine)
Engine.removeChangeListener = new_instancemethod(_fife.Engine_removeChangeListener, None, Engine)
Engine_swigregister = _fife.Engine_swigregister
Engine_swigregister(Engine)

class Key(object):
    """Proxy of C++ FIFE::Key class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    INVALID_KEY = _fife.Key_INVALID_KEY
    ENTER = _fife.Key_ENTER
    ESCAPE = _fife.Key_ESCAPE
    BACKSPACE = _fife.Key_BACKSPACE
    TAB = _fife.Key_TAB
    SPACE = _fife.Key_SPACE
    EXCLAIM = _fife.Key_EXCLAIM
    QUOTEDBL = _fife.Key_QUOTEDBL
    HASH = _fife.Key_HASH
    PERCENT = _fife.Key_PERCENT
    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
    CAPS_LOCK = _fife.Key_CAPS_LOCK
    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
    PRINT_SCREEN = _fife.Key_PRINT_SCREEN
    SCROLL_LOCK = _fife.Key_SCROLL_LOCK
    PAUSE = _fife.Key_PAUSE
    INSERT = _fife.Key_INSERT
    HOME = _fife.Key_HOME
    PAGE_UP = _fife.Key_PAGE_UP
    DELETE = _fife.Key_DELETE
    END = _fife.Key_END
    PAGE_DOWN = _fife.Key_PAGE_DOWN
    RIGHT = _fife.Key_RIGHT
    LEFT = _fife.Key_LEFT
    DOWN = _fife.Key_DOWN
    UP = _fife.Key_UP
    NUM_LOCK = _fife.Key_NUM_LOCK
    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_0 = _fife.Key_KP_0
    KP_1 = _fife.Key_KP_1
    KP_2 = _fife.Key_KP_2
    KP_3 = _fife.Key_KP_3
    KP_4 = _fife.Key_KP_4
    KP_5 = _fife.Key_KP_5
    KP_6 = _fife.Key_KP_6
    KP_7 = _fife.Key_KP_7
    KP_8 = _fife.Key_KP_8
    KP_9 = _fife.Key_KP_9
    KP_PERIOD = _fife.Key_KP_PERIOD
    APPLICATION = _fife.Key_APPLICATION
    POWER = _fife.Key_POWER
    KP_EQUALS = _fife.Key_KP_EQUALS
    F13 = _fife.Key_F13
    F14 = _fife.Key_F14
    F15 = _fife.Key_F15
    F16 = _fife.Key_F16
    F17 = _fife.Key_F17
    F18 = _fife.Key_F18
    F19 = _fife.Key_F19
    F20 = _fife.Key_F20
    F21 = _fife.Key_F21
    F22 = _fife.Key_F22
    F23 = _fife.Key_F23
    F24 = _fife.Key_F24
    EXECUTE = _fife.Key_EXECUTE
    HELP = _fife.Key_HELP
    MENU = _fife.Key_MENU
    SELECT = _fife.Key_SELECT
    STOP = _fife.Key_STOP
    AGAIN = _fife.Key_AGAIN
    UNDO = _fife.Key_UNDO
    CUT = _fife.Key_CUT
    COPY = _fife.Key_COPY
    PASTE = _fife.Key_PASTE
    FIND = _fife.Key_FIND
    MUTE = _fife.Key_MUTE
    VOLUME_UP = _fife.Key_VOLUME_UP
    VOLUME_DOWN = _fife.Key_VOLUME_DOWN
    KP_COMMA = _fife.Key_KP_COMMA
    KP_EQUALSAS400 = _fife.Key_KP_EQUALSAS400
    ERASE = _fife.Key_ERASE
    SYS_REQ = _fife.Key_SYS_REQ
    CANCEL = _fife.Key_CANCEL
    CLEAR = _fife.Key_CLEAR
    PRIOR = _fife.Key_PRIOR
    RETURN = _fife.Key_RETURN
    SEPARATOR = _fife.Key_SEPARATOR
    FORTH = _fife.Key_FORTH
    OPER = _fife.Key_OPER
    CLEAR_AGAIN = _fife.Key_CLEAR_AGAIN
    CR_SEL = _fife.Key_CR_SEL
    EX_SEL = _fife.Key_EX_SEL
    KP_00 = _fife.Key_KP_00
    KP_000 = _fife.Key_KP_000
    THOUSANDS_SEPARATOR = _fife.Key_THOUSANDS_SEPARATOR
    DECIMAL_SEPARATOR = _fife.Key_DECIMAL_SEPARATOR
    CURRENCY_UNIT = _fife.Key_CURRENCY_UNIT
    CURRENCY_SUBUNIT = _fife.Key_CURRENCY_SUBUNIT
    KP_LEFTPAREN = _fife.Key_KP_LEFTPAREN
    KP_RIGHTPAREN = _fife.Key_KP_RIGHTPAREN
    KP_LEFTBRACE = _fife.Key_KP_LEFTBRACE
    KP_RIGHTBRACE = _fife.Key_KP_RIGHTBRACE
    KP_TAB = _fife.Key_KP_TAB
    KP_BACKSPACE = _fife.Key_KP_BACKSPACE
    KP_A = _fife.Key_KP_A
    KP_B = _fife.Key_KP_B
    KP_C = _fife.Key_KP_C
    KP_D = _fife.Key_KP_D
    KP_E = _fife.Key_KP_E
    KP_F = _fife.Key_KP_F
    KP_XOR = _fife.Key_KP_XOR
    KP_POWER = _fife.Key_KP_POWER
    KP_PERCENT = _fife.Key_KP_PERCENT
    KP_LESS = _fife.Key_KP_LESS
    KP_GREATER = _fife.Key_KP_GREATER
    KP_AMPERSAND = _fife.Key_KP_AMPERSAND
    KP_DBLAMPERSAND = _fife.Key_KP_DBLAMPERSAND
    KP_VERTICALBAR = _fife.Key_KP_VERTICALBAR
    KP_DBLVERTICALBAR = _fife.Key_KP_DBLVERTICALBAR
    KP_COLON = _fife.Key_KP_COLON
    KP_HASH = _fife.Key_KP_HASH
    KP_SPACE = _fife.Key_KP_SPACE
    KP_AT = _fife.Key_KP_AT
    KP_EXCLAM = _fife.Key_KP_EXCLAM
    KP_MEMSTORE = _fife.Key_KP_MEMSTORE
    KP_MEMRECALL = _fife.Key_KP_MEMRECALL
    KP_MEMCLEAR = _fife.Key_KP_MEMCLEAR
    KP_MEMADD = _fife.Key_KP_MEMADD
    KP_MEMSUBSTRACT = _fife.Key_KP_MEMSUBSTRACT
    KP_MEMMULTIPLY = _fife.Key_KP_MEMMULTIPLY
    KP_MEMDIVIDE = _fife.Key_KP_MEMDIVIDE
    KP_PLUSMINUS = _fife.Key_KP_PLUSMINUS
    KP_CLEAR = _fife.Key_KP_CLEAR
    KP_CLEARENTRY = _fife.Key_KP_CLEARENTRY
    KP_BINARY = _fife.Key_KP_BINARY
    KP_OCTAL = _fife.Key_KP_OCTAL
    KP_DECIMAL = _fife.Key_KP_DECIMAL
    KP_HEXADECIMAL = _fife.Key_KP_HEXADECIMAL
    LEFT_CONTROL = _fife.Key_LEFT_CONTROL
    LEFT_SHIFT = _fife.Key_LEFT_SHIFT
    LEFT_ALT = _fife.Key_LEFT_ALT
    LEFT_SUPER = _fife.Key_LEFT_SUPER
    RIGHT_CONTROL = _fife.Key_RIGHT_CONTROL
    RIGHT_SHIFT = _fife.Key_RIGHT_SHIFT
    RIGHT_ALT = _fife.Key_RIGHT_ALT
    RIGHT_SUPER = _fife.Key_RIGHT_SUPER
    ALT_GR = _fife.Key_ALT_GR
    AUDIO_NEXT = _fife.Key_AUDIO_NEXT
    AUDIO_PREV = _fife.Key_AUDIO_PREV
    AUDIO_STOP = _fife.Key_AUDIO_STOP
    AUDIO_PLAY = _fife.Key_AUDIO_PLAY
    AUDIO_MUTE = _fife.Key_AUDIO_MUTE
    MEDIASELECT = _fife.Key_MEDIASELECT
    WWW = _fife.Key_WWW
    MAIL = _fife.Key_MAIL
    CALCULATOR = _fife.Key_CALCULATOR
    COMPUTER = _fife.Key_COMPUTER
    AC_SEARCH = _fife.Key_AC_SEARCH
    AC_HOME = _fife.Key_AC_HOME
    AC_BACK = _fife.Key_AC_BACK
    AC_FORWARD = _fife.Key_AC_FORWARD
    AC_STOP = _fife.Key_AC_STOP
    AC_REFRESH = _fife.Key_AC_REFRESH
    AC_BOOKMARKS = _fife.Key_AC_BOOKMARKS
    BRIGHTNESS_DOWN = _fife.Key_BRIGHTNESS_DOWN
    BRIGHTNESS_UP = _fife.Key_BRIGHTNESS_UP
    DISPLAY_SWITCH = _fife.Key_DISPLAY_SWITCH
    ILLUM_TOGGLE = _fife.Key_ILLUM_TOGGLE
    ILLUM_DOWN = _fife.Key_ILLUM_DOWN
    ILLUM_UP = _fife.Key_ILLUM_UP
    EJECT = _fife.Key_EJECT
    SLEEP = _fife.Key_SLEEP

    def __init__(self, *args, **kwargs):
        """__init__(FIFE::Key self, FIFE::Key::KeyType key) -> Key"""
        _fife.Key_swiginit(self, _fife.new_Key(*args, **kwargs))
    __swig_destroy__ = _fife.delete_Key

    def isPrintable(self):
        """isPrintable(Key self) -> bool"""
        return _fife.Key_isPrintable(self)


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


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


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

Key.isPrintable = new_instancemethod(_fife.Key_isPrintable, None, Key)
Key.isFunctionKey = new_instancemethod(_fife.Key_isFunctionKey, None, Key)
Key.getValue = new_instancemethod(_fife.Key_getValue, None, Key)
Key.getAsString = new_instancemethod(_fife.Key_getAsString, None, Key)
Key_swigregister = _fife.Key_swigregister
Key_swigregister(Key)

class Text(object):
    """Proxy of C++ FIFE::Text class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, text=None, start=0, length=0):
        """__init__(FIFE::Text self, char const * text=None, int32_t start=0, int32_t length=0) -> Text"""
        _fife.Text_swiginit(self, _fife.new_Text(text, start, length))
    __swig_destroy__ = _fife.delete_Text

    def isPrintable(self):
        """isPrintable(Text self) -> bool"""
        return _fife.Text_isPrintable(self)


    def getAsString(self):
        """getAsString(Text self) -> std::string"""
        return _fife.Text_getAsString(self)


    def getStart(self):
        """getStart(Text self) -> int32_t"""
        return _fife.Text_getStart(self)


    def getLength(self):
        """getLength(Text self) -> int32_t"""
        return _fife.Text_getLength(self)

Text.isPrintable = new_instancemethod(_fife.Text_isPrintable, None, Text)
Text.getAsString = new_instancemethod(_fife.Text_getAsString, None, Text)
Text.getStart = new_instancemethod(_fife.Text_getStart, None, Text)
Text.getLength = new_instancemethod(_fife.Text_getLength, None, Text)
Text_swigregister = _fife.Text_swigregister
Text_swigregister(Text)

ES_ENGINE = _fife.ES_ENGINE
ES_FIFECHAN_WIDGET = _fife.ES_FIFECHAN_WIDGET
ES_CEGUI_WIDGET = _fife.ES_CEGUI_WIDGET
ES_LIBROCKET_WIDGET = _fife.ES_LIBROCKET_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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def getEventSourceType(self):
        """getEventSourceType(IEventSource self) -> FIFE::EventSourceType"""
        return _fife.IEventSource_getEventSourceType(self)

    __swig_destroy__ = _fife.delete_IEventSource

    def __init__(self):
        """__init__(FIFE::IEventSource self) -> IEventSource"""
        if self.__class__ == IEventSource:
            _self = None
        else:
            _self = self
        _fife.IEventSource_swiginit(self, _fife.new_IEventSource(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEventSource(self)
        return weakref_proxy(self)
IEventSource.getEventSourceType = new_instancemethod(_fife.IEventSource_getEventSourceType, None, IEventSource)
IEventSource_swigregister = _fife.IEventSource_swigregister
IEventSource_swigregister(IEventSource)

class Event(object):
    """Proxy of C++ FIFE::Event class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def consume(self):
        """consume(Event self)"""
        return _fife.Event_consume(self)


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


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


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


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


    def getName(self):
        """getName(Event self) -> std::string const &"""
        return _fife.Event_getName(self)

    __swig_destroy__ = _fife.delete_Event
Event.consume = new_instancemethod(_fife.Event_consume, None, Event)
Event.isConsumed = new_instancemethod(_fife.Event_isConsumed, None, Event)
Event.getSource = new_instancemethod(_fife.Event_getSource, None, Event)
Event.getTimeStamp = new_instancemethod(_fife.Event_getTimeStamp, None, Event)
Event.getDebugString = new_instancemethod(_fife.Event_getDebugString, None, Event)
Event.getName = new_instancemethod(_fife.Event_getName, None, Event)
Event_swigregister = _fife.Event_swigregister
Event_swigregister(Event)

class InputEvent(Event):
    """Proxy of C++ FIFE::InputEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def isConsumedByWidgets(self):
        """isConsumedByWidgets(InputEvent self) -> bool"""
        return _fife.InputEvent_isConsumedByWidgets(self)


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


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


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


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

    __swig_destroy__ = _fife.delete_InputEvent
InputEvent.isConsumedByWidgets = new_instancemethod(_fife.InputEvent_isConsumedByWidgets, None, InputEvent)
InputEvent.isAltPressed = new_instancemethod(_fife.InputEvent_isAltPressed, None, InputEvent)
InputEvent.isControlPressed = new_instancemethod(_fife.InputEvent_isControlPressed, None, InputEvent)
InputEvent.isMetaPressed = new_instancemethod(_fife.InputEvent_isMetaPressed, None, InputEvent)
InputEvent.isShiftPressed = new_instancemethod(_fife.InputEvent_isShiftPressed, None, InputEvent)
InputEvent_swigregister = _fife.InputEvent_swigregister
InputEvent_swigregister(InputEvent)

class Command(Event):
    """Proxy of C++ FIFE::Command class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::Command self) -> Command"""
        _fife.Command_swiginit(self, _fife.new_Command())
    __swig_destroy__ = _fife.delete_Command

    def getCommandType(self):
        """getCommandType(Command self) -> FIFE::CommandType"""
        return _fife.Command_getCommandType(self)


    def setCommandType(self, type):
        """setCommandType(Command self, FIFE::CommandType type)"""
        return _fife.Command_setCommandType(self, type)


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


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


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


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

Command.getCommandType = new_instancemethod(_fife.Command_getCommandType, None, Command)
Command.setCommandType = new_instancemethod(_fife.Command_setCommandType, None, Command)
Command.getCode = new_instancemethod(_fife.Command_getCode, None, Command)
Command.setCode = new_instancemethod(_fife.Command_setCode, None, Command)
Command.setSource = new_instancemethod(_fife.Command_setSource, None, Command)
Command.setTimeStamp = new_instancemethod(_fife.Command_setTimeStamp, None, Command)
Command_swigregister = _fife.Command_swigregister
Command_swigregister(Command)

class ICommandListener(object):
    """Proxy of C++ FIFE::ICommandListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def onCommand(self, command):
        """onCommand(ICommandListener self, Command command)"""
        return _fife.ICommandListener_onCommand(self, command)

    __swig_destroy__ = _fife.delete_ICommandListener

    def __init__(self):
        """__init__(FIFE::ICommandListener self) -> ICommandListener"""
        if self.__class__ == ICommandListener:
            _self = None
        else:
            _self = self
        _fife.ICommandListener_swiginit(self, _fife.new_ICommandListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ICommandListener(self)
        return weakref_proxy(self)
ICommandListener.onCommand = new_instancemethod(_fife.ICommandListener_onCommand, None, ICommandListener)
ICommandListener_swigregister = _fife.ICommandListener_swigregister
ICommandListener_swigregister(ICommandListener)

class KeyEvent(InputEvent):
    """Proxy of C++ FIFE::KeyEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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(KeyEvent self) -> FIFE::KeyEvent::KeyEventType"""
        return _fife.KeyEvent_getType(self)


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


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

    __swig_destroy__ = _fife.delete_KeyEvent
KeyEvent.getType = new_instancemethod(_fife.KeyEvent_getType, None, KeyEvent)
KeyEvent.isNumericPad = new_instancemethod(_fife.KeyEvent_isNumericPad, None, KeyEvent)
KeyEvent.getKey = new_instancemethod(_fife.KeyEvent_getKey, None, KeyEvent)
KeyEvent_swigregister = _fife.KeyEvent_swigregister
KeyEvent_swigregister(KeyEvent)

class IKeyListener(object):
    """Proxy of C++ FIFE::IKeyListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def keyPressed(self, evt):
        """keyPressed(IKeyListener self, KeyEvent evt)"""
        return _fife.IKeyListener_keyPressed(self, evt)


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


    def isGlobalListener(self):
        """isGlobalListener(IKeyListener self) -> bool"""
        return _fife.IKeyListener_isGlobalListener(self)


    def setGlobalListener(self, _global):
        """setGlobalListener(IKeyListener self, bool _global)"""
        return _fife.IKeyListener_setGlobalListener(self, _global)

    __swig_destroy__ = _fife.delete_IKeyListener

    def __init__(self):
        """__init__(FIFE::IKeyListener self) -> IKeyListener"""
        if self.__class__ == IKeyListener:
            _self = None
        else:
            _self = self
        _fife.IKeyListener_swiginit(self, _fife.new_IKeyListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyListener(self)
        return weakref_proxy(self)
IKeyListener.keyPressed = new_instancemethod(_fife.IKeyListener_keyPressed, None, IKeyListener)
IKeyListener.keyReleased = new_instancemethod(_fife.IKeyListener_keyReleased, None, IKeyListener)
IKeyListener.isGlobalListener = new_instancemethod(_fife.IKeyListener_isGlobalListener, None, IKeyListener)
IKeyListener.setGlobalListener = new_instancemethod(_fife.IKeyListener_setGlobalListener, None, IKeyListener)
IKeyListener_swigregister = _fife.IKeyListener_swigregister
IKeyListener_swigregister(IKeyListener)

class TextEvent(InputEvent):
    """Proxy of C++ FIFE::TextEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    UNKNOWN = _fife.TextEvent_UNKNOWN
    INPUT = _fife.TextEvent_INPUT
    EDIT = _fife.TextEvent_EDIT

    def getType(self):
        """getType(TextEvent self) -> FIFE::TextEvent::TextEventType"""
        return _fife.TextEvent_getType(self)


    def getText(self):
        """getText(TextEvent self) -> Text"""
        return _fife.TextEvent_getText(self)

    __swig_destroy__ = _fife.delete_TextEvent
TextEvent.getType = new_instancemethod(_fife.TextEvent_getType, None, TextEvent)
TextEvent.getText = new_instancemethod(_fife.TextEvent_getText, None, TextEvent)
TextEvent_swigregister = _fife.TextEvent_swigregister
TextEvent_swigregister(TextEvent)

class ITextListener(object):
    """Proxy of C++ FIFE::ITextListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def textInput(self, evt):
        """textInput(ITextListener self, TextEvent evt)"""
        return _fife.ITextListener_textInput(self, evt)


    def textEdit(self, evt):
        """textEdit(ITextListener self, TextEvent evt)"""
        return _fife.ITextListener_textEdit(self, evt)

    __swig_destroy__ = _fife.delete_ITextListener

    def __init__(self):
        """__init__(FIFE::ITextListener self) -> ITextListener"""
        if self.__class__ == ITextListener:
            _self = None
        else:
            _self = self
        _fife.ITextListener_swiginit(self, _fife.new_ITextListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ITextListener(self)
        return weakref_proxy(self)
ITextListener.textInput = new_instancemethod(_fife.ITextListener_textInput, None, ITextListener)
ITextListener.textEdit = new_instancemethod(_fife.ITextListener_textEdit, None, ITextListener)
ITextListener_swigregister = _fife.ITextListener_swigregister
ITextListener_swigregister(ITextListener)

class ISdlEventListener(object):
    """Proxy of C++ FIFE::ISdlEventListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def onSdlEvent(self, evt):
        """onSdlEvent(ISdlEventListener self, SDL_Event & evt) -> bool"""
        return _fife.ISdlEventListener_onSdlEvent(self, evt)

    __swig_destroy__ = _fife.delete_ISdlEventListener

    def __init__(self):
        """__init__(FIFE::ISdlEventListener self) -> ISdlEventListener"""
        if self.__class__ == ISdlEventListener:
            _self = None
        else:
            _self = self
        _fife.ISdlEventListener_swiginit(self, _fife.new_ISdlEventListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ISdlEventListener(self)
        return weakref_proxy(self)
ISdlEventListener.onSdlEvent = new_instancemethod(_fife.ISdlEventListener_onSdlEvent, None, ISdlEventListener)
ISdlEventListener_swigregister = _fife.ISdlEventListener_swigregister
ISdlEventListener_swigregister(ISdlEventListener)

class MouseEvent(InputEvent):
    """Proxy of C++ FIFE::MouseEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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
    WHEEL_MOVED_RIGHT = _fife.MouseEvent_WHEEL_MOVED_RIGHT
    WHEEL_MOVED_LEFT = _fife.MouseEvent_WHEEL_MOVED_LEFT
    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
    X1 = _fife.MouseEvent_X1
    X2 = _fife.MouseEvent_X2
    UNKNOWN_BUTTON = _fife.MouseEvent_UNKNOWN_BUTTON

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


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


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


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

    __swig_destroy__ = _fife.delete_MouseEvent
MouseEvent.getX = new_instancemethod(_fife.MouseEvent_getX, None, MouseEvent)
MouseEvent.getY = new_instancemethod(_fife.MouseEvent_getY, None, MouseEvent)
MouseEvent.getType = new_instancemethod(_fife.MouseEvent_getType, None, MouseEvent)
MouseEvent.getButton = new_instancemethod(_fife.MouseEvent_getButton, None, MouseEvent)
MouseEvent_swigregister = _fife.MouseEvent_swigregister
MouseEvent_swigregister(MouseEvent)

class IMouseListener(object):
    """Proxy of C++ FIFE::IMouseListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def mouseEntered(self, evt):
        """mouseEntered(IMouseListener self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseEntered(self, evt)


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


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


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


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


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


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


    def mouseWheelMovedRight(self, evt):
        """mouseWheelMovedRight(IMouseListener self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseWheelMovedRight(self, evt)


    def mouseWheelMovedLeft(self, evt):
        """mouseWheelMovedLeft(IMouseListener self, MouseEvent evt)"""
        return _fife.IMouseListener_mouseWheelMovedLeft(self, evt)


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


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


    def isGlobalListener(self):
        """isGlobalListener(IMouseListener self) -> bool"""
        return _fife.IMouseListener_isGlobalListener(self)


    def setGlobalListener(self, _global):
        """setGlobalListener(IMouseListener self, bool _global)"""
        return _fife.IMouseListener_setGlobalListener(self, _global)

    __swig_destroy__ = _fife.delete_IMouseListener

    def __init__(self):
        """__init__(FIFE::IMouseListener self) -> IMouseListener"""
        if self.__class__ == IMouseListener:
            _self = None
        else:
            _self = self
        _fife.IMouseListener_swiginit(self, _fife.new_IMouseListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMouseListener(self)
        return weakref_proxy(self)
IMouseListener.mouseEntered = new_instancemethod(_fife.IMouseListener_mouseEntered, None, IMouseListener)
IMouseListener.mouseExited = new_instancemethod(_fife.IMouseListener_mouseExited, None, IMouseListener)
IMouseListener.mousePressed = new_instancemethod(_fife.IMouseListener_mousePressed, None, IMouseListener)
IMouseListener.mouseReleased = new_instancemethod(_fife.IMouseListener_mouseReleased, None, IMouseListener)
IMouseListener.mouseClicked = new_instancemethod(_fife.IMouseListener_mouseClicked, None, IMouseListener)
IMouseListener.mouseWheelMovedUp = new_instancemethod(_fife.IMouseListener_mouseWheelMovedUp, None, IMouseListener)
IMouseListener.mouseWheelMovedDown = new_instancemethod(_fife.IMouseListener_mouseWheelMovedDown, None, IMouseListener)
IMouseListener.mouseWheelMovedRight = new_instancemethod(_fife.IMouseListener_mouseWheelMovedRight, None, IMouseListener)
IMouseListener.mouseWheelMovedLeft = new_instancemethod(_fife.IMouseListener_mouseWheelMovedLeft, None, IMouseListener)
IMouseListener.mouseMoved = new_instancemethod(_fife.IMouseListener_mouseMoved, None, IMouseListener)
IMouseListener.mouseDragged = new_instancemethod(_fife.IMouseListener_mouseDragged, None, IMouseListener)
IMouseListener.isGlobalListener = new_instancemethod(_fife.IMouseListener_isGlobalListener, None, IMouseListener)
IMouseListener.setGlobalListener = new_instancemethod(_fife.IMouseListener_setGlobalListener, None, IMouseListener)
IMouseListener_swigregister = _fife.IMouseListener_swigregister
IMouseListener_swigregister(IMouseListener)

class IKeyFilter(object):
    """Proxy of C++ FIFE::IKeyFilter class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def isFiltered(self, evt):
        """isFiltered(IKeyFilter self, KeyEvent evt) -> bool"""
        return _fife.IKeyFilter_isFiltered(self, evt)

    __swig_destroy__ = _fife.delete_IKeyFilter

    def __init__(self):
        """__init__(FIFE::IKeyFilter self) -> IKeyFilter"""
        if self.__class__ == IKeyFilter:
            _self = None
        else:
            _self = self
        _fife.IKeyFilter_swiginit(self, _fife.new_IKeyFilter(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyFilter(self)
        return weakref_proxy(self)
IKeyFilter.isFiltered = new_instancemethod(_fife.IKeyFilter_isFiltered, None, IKeyFilter)
IKeyFilter_swigregister = _fife.IKeyFilter_swigregister
IKeyFilter_swigregister(IKeyFilter)

class DropEvent(InputEvent):
    """Proxy of C++ FIFE::DropEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def getPath(self):
        """getPath(DropEvent self) -> std::string const &"""
        return _fife.DropEvent_getPath(self)

    __swig_destroy__ = _fife.delete_DropEvent
DropEvent.getPath = new_instancemethod(_fife.DropEvent_getPath, None, DropEvent)
DropEvent_swigregister = _fife.DropEvent_swigregister
DropEvent_swigregister(DropEvent)

class IDropListener(object):
    """Proxy of C++ FIFE::IDropListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def fileDropped(self, evt):
        """fileDropped(IDropListener self, DropEvent evt)"""
        return _fife.IDropListener_fileDropped(self, evt)

    __swig_destroy__ = _fife.delete_IDropListener

    def __init__(self):
        """__init__(FIFE::IDropListener self) -> IDropListener"""
        if self.__class__ == IDropListener:
            _self = None
        else:
            _self = self
        _fife.IDropListener_swiginit(self, _fife.new_IDropListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IDropListener(self)
        return weakref_proxy(self)
IDropListener.fileDropped = new_instancemethod(_fife.IDropListener_fileDropped, None, IDropListener)
IDropListener_swigregister = _fife.IDropListener_swigregister
IDropListener_swigregister(IDropListener)

class Joystick(object):
    """Proxy of C++ FIFE::Joystick class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    HAT_INVALID = _fife.Joystick_HAT_INVALID
    HAT_CENTERED = _fife.Joystick_HAT_CENTERED
    HAT_UP = _fife.Joystick_HAT_UP
    HAT_RIGHT = _fife.Joystick_HAT_RIGHT
    HAT_DOWN = _fife.Joystick_HAT_DOWN
    HAT_LEFT = _fife.Joystick_HAT_LEFT
    HAT_RIGHTUP = _fife.Joystick_HAT_RIGHTUP
    HAT_RIGHTDOWN = _fife.Joystick_HAT_RIGHTDOWN
    HAT_LEFTUP = _fife.Joystick_HAT_LEFTUP
    HAT_LEFTDOWN = _fife.Joystick_HAT_LEFTDOWN
    CONTOLLER_AXIS_INVALID = _fife.Joystick_CONTOLLER_AXIS_INVALID
    CONTOLLER_AXIS_LEFTX = _fife.Joystick_CONTOLLER_AXIS_LEFTX
    CONTOLLER_AXIS_LEFTY = _fife.Joystick_CONTOLLER_AXIS_LEFTY
    CONTOLLER_AXIS_RIGHTX = _fife.Joystick_CONTOLLER_AXIS_RIGHTX
    CONTOLLER_AXIS_RIGHTY = _fife.Joystick_CONTOLLER_AXIS_RIGHTY
    CONTOLLER_AXIS_TRIGGERLEFT = _fife.Joystick_CONTOLLER_AXIS_TRIGGERLEFT
    CONTOLLER_AXIS_TRIGGERRIGHT = _fife.Joystick_CONTOLLER_AXIS_TRIGGERRIGHT
    CONTOLLER_AXIS_MAX = _fife.Joystick_CONTOLLER_AXIS_MAX
    CONTOLLER_BUTTON_INVALID = _fife.Joystick_CONTOLLER_BUTTON_INVALID
    CONTOLLER_BUTTON_A = _fife.Joystick_CONTOLLER_BUTTON_A
    CONTOLLER_BUTTON_B = _fife.Joystick_CONTOLLER_BUTTON_B
    CONTOLLER_BUTTON_X = _fife.Joystick_CONTOLLER_BUTTON_X
    CONTOLLER_BUTTON_Y = _fife.Joystick_CONTOLLER_BUTTON_Y
    CONTOLLER_BUTTON_BACK = _fife.Joystick_CONTOLLER_BUTTON_BACK
    CONTOLLER_BUTTON_GUIDE = _fife.Joystick_CONTOLLER_BUTTON_GUIDE
    CONTOLLER_BUTTON_START = _fife.Joystick_CONTOLLER_BUTTON_START
    CONTOLLER_BUTTON_LEFTSTICK = _fife.Joystick_CONTOLLER_BUTTON_LEFTSTICK
    CONTOLLER_BUTTON_RIGHTSTICK = _fife.Joystick_CONTOLLER_BUTTON_RIGHTSTICK
    CONTOLLER_BUTTON_LEFTSHOULDER = _fife.Joystick_CONTOLLER_BUTTON_LEFTSHOULDER
    CONTOLLER_BUTTON_RIGHTSHOULDER = _fife.Joystick_CONTOLLER_BUTTON_RIGHTSHOULDER
    CONTOLLER_BUTTON_DPAD_UP = _fife.Joystick_CONTOLLER_BUTTON_DPAD_UP
    CONTOLLER_BUTTON_DPAD_DOWN = _fife.Joystick_CONTOLLER_BUTTON_DPAD_DOWN
    CONTOLLER_BUTTON_DPAD_LEFT = _fife.Joystick_CONTOLLER_BUTTON_DPAD_LEFT
    CONTOLLER_BUTTON_DPAD_RIGHT = _fife.Joystick_CONTOLLER_BUTTON_DPAD_RIGHT
    CONTOLLER_BUTTON_MAX = _fife.Joystick_CONTOLLER_BUTTON_MAX
    __swig_destroy__ = _fife.delete_Joystick

    def getDeviceIndex(self):
        """getDeviceIndex(Joystick self) -> int32_t"""
        return _fife.Joystick_getDeviceIndex(self)


    def getInstanceId(self):
        """getInstanceId(Joystick self) -> int32_t"""
        return _fife.Joystick_getInstanceId(self)


    def getGuid(self):
        """getGuid(Joystick self) -> std::string"""
        return _fife.Joystick_getGuid(self)


    def getName(self):
        """getName(Joystick self) -> std::string"""
        return _fife.Joystick_getName(self)


    def isConnected(self):
        """isConnected(Joystick self) -> bool"""
        return _fife.Joystick_isConnected(self)


    def isController(self):
        """isController(Joystick self) -> bool"""
        return _fife.Joystick_isController(self)


    def getNumberOfAxes(self):
        """getNumberOfAxes(Joystick self) -> uint8_t"""
        return _fife.Joystick_getNumberOfAxes(self)


    def getNumberOfButtons(self):
        """getNumberOfButtons(Joystick self) -> uint8_t"""
        return _fife.Joystick_getNumberOfButtons(self)


    def getNumberOfHats(self):
        """getNumberOfHats(Joystick self) -> uint8_t"""
        return _fife.Joystick_getNumberOfHats(self)


    def getAxisValue(self, axis):
        """getAxisValue(Joystick self, int8_t axis) -> float"""
        return _fife.Joystick_getAxisValue(self, axis)


    def getHatValue(self, hat):
        """getHatValue(Joystick self, int8_t hat) -> int8_t"""
        return _fife.Joystick_getHatValue(self, hat)


    def isButtonPressed(self, button):
        """isButtonPressed(Joystick self, int8_t button) -> bool"""
        return _fife.Joystick_isButtonPressed(self, button)

Joystick.getDeviceIndex = new_instancemethod(_fife.Joystick_getDeviceIndex, None, Joystick)
Joystick.getInstanceId = new_instancemethod(_fife.Joystick_getInstanceId, None, Joystick)
Joystick.getGuid = new_instancemethod(_fife.Joystick_getGuid, None, Joystick)
Joystick.getName = new_instancemethod(_fife.Joystick_getName, None, Joystick)
Joystick.isConnected = new_instancemethod(_fife.Joystick_isConnected, None, Joystick)
Joystick.isController = new_instancemethod(_fife.Joystick_isController, None, Joystick)
Joystick.getNumberOfAxes = new_instancemethod(_fife.Joystick_getNumberOfAxes, None, Joystick)
Joystick.getNumberOfButtons = new_instancemethod(_fife.Joystick_getNumberOfButtons, None, Joystick)
Joystick.getNumberOfHats = new_instancemethod(_fife.Joystick_getNumberOfHats, None, Joystick)
Joystick.getAxisValue = new_instancemethod(_fife.Joystick_getAxisValue, None, Joystick)
Joystick.getHatValue = new_instancemethod(_fife.Joystick_getHatValue, None, Joystick)
Joystick.isButtonPressed = new_instancemethod(_fife.Joystick_isButtonPressed, None, Joystick)
Joystick_swigregister = _fife.Joystick_swigregister
Joystick_swigregister(Joystick)

class JoystickEvent(InputEvent):
    """Proxy of C++ FIFE::JoystickEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    UNKNOWN_EVENT = _fife.JoystickEvent_UNKNOWN_EVENT
    AXIS_MOTION = _fife.JoystickEvent_AXIS_MOTION
    HAT_MOTION = _fife.JoystickEvent_HAT_MOTION
    BUTTON_PRESSED = _fife.JoystickEvent_BUTTON_PRESSED
    BUTTON_RELEASED = _fife.JoystickEvent_BUTTON_RELEASED
    DEVICE_ADDED = _fife.JoystickEvent_DEVICE_ADDED
    DEVICE_REMOVED = _fife.JoystickEvent_DEVICE_REMOVED

    def getType(self):
        """getType(JoystickEvent self) -> FIFE::JoystickEvent::JoystickEventType"""
        return _fife.JoystickEvent_getType(self)


    def getInstanceId(self):
        """getInstanceId(JoystickEvent self) -> int32_t"""
        return _fife.JoystickEvent_getInstanceId(self)


    def getAxis(self):
        """getAxis(JoystickEvent self) -> int8_t"""
        return _fife.JoystickEvent_getAxis(self)


    def getAxisValue(self):
        """getAxisValue(JoystickEvent self) -> float"""
        return _fife.JoystickEvent_getAxisValue(self)


    def getHat(self):
        """getHat(JoystickEvent self) -> int8_t"""
        return _fife.JoystickEvent_getHat(self)


    def getHatValue(self):
        """getHatValue(JoystickEvent self) -> int8_t"""
        return _fife.JoystickEvent_getHatValue(self)


    def getButton(self):
        """getButton(JoystickEvent self) -> int8_t"""
        return _fife.JoystickEvent_getButton(self)


    def isController(self):
        """isController(JoystickEvent self) -> bool"""
        return _fife.JoystickEvent_isController(self)

    __swig_destroy__ = _fife.delete_JoystickEvent
JoystickEvent.getType = new_instancemethod(_fife.JoystickEvent_getType, None, JoystickEvent)
JoystickEvent.getInstanceId = new_instancemethod(_fife.JoystickEvent_getInstanceId, None, JoystickEvent)
JoystickEvent.getAxis = new_instancemethod(_fife.JoystickEvent_getAxis, None, JoystickEvent)
JoystickEvent.getAxisValue = new_instancemethod(_fife.JoystickEvent_getAxisValue, None, JoystickEvent)
JoystickEvent.getHat = new_instancemethod(_fife.JoystickEvent_getHat, None, JoystickEvent)
JoystickEvent.getHatValue = new_instancemethod(_fife.JoystickEvent_getHatValue, None, JoystickEvent)
JoystickEvent.getButton = new_instancemethod(_fife.JoystickEvent_getButton, None, JoystickEvent)
JoystickEvent.isController = new_instancemethod(_fife.JoystickEvent_isController, None, JoystickEvent)
JoystickEvent_swigregister = _fife.JoystickEvent_swigregister
JoystickEvent_swigregister(JoystickEvent)

class IJoystickListener(object):
    """Proxy of C++ FIFE::IJoystickListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def axisMotion(self, evt):
        """axisMotion(IJoystickListener self, JoystickEvent evt)"""
        return _fife.IJoystickListener_axisMotion(self, evt)


    def hatMotion(self, evt):
        """hatMotion(IJoystickListener self, JoystickEvent evt)"""
        return _fife.IJoystickListener_hatMotion(self, evt)


    def buttonPressed(self, evt):
        """buttonPressed(IJoystickListener self, JoystickEvent evt)"""
        return _fife.IJoystickListener_buttonPressed(self, evt)


    def buttonReleased(self, evt):
        """buttonReleased(IJoystickListener self, JoystickEvent evt)"""
        return _fife.IJoystickListener_buttonReleased(self, evt)


    def deviceAdded(self, evt):
        """deviceAdded(IJoystickListener self, JoystickEvent evt)"""
        return _fife.IJoystickListener_deviceAdded(self, evt)


    def deviceRemoved(self, evt):
        """deviceRemoved(IJoystickListener self, JoystickEvent evt)"""
        return _fife.IJoystickListener_deviceRemoved(self, evt)

    __swig_destroy__ = _fife.delete_IJoystickListener

    def __init__(self):
        """__init__(FIFE::IJoystickListener self) -> IJoystickListener"""
        if self.__class__ == IJoystickListener:
            _self = None
        else:
            _self = self
        _fife.IJoystickListener_swiginit(self, _fife.new_IJoystickListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IJoystickListener(self)
        return weakref_proxy(self)
IJoystickListener.axisMotion = new_instancemethod(_fife.IJoystickListener_axisMotion, None, IJoystickListener)
IJoystickListener.hatMotion = new_instancemethod(_fife.IJoystickListener_hatMotion, None, IJoystickListener)
IJoystickListener.buttonPressed = new_instancemethod(_fife.IJoystickListener_buttonPressed, None, IJoystickListener)
IJoystickListener.buttonReleased = new_instancemethod(_fife.IJoystickListener_buttonReleased, None, IJoystickListener)
IJoystickListener.deviceAdded = new_instancemethod(_fife.IJoystickListener_deviceAdded, None, IJoystickListener)
IJoystickListener.deviceRemoved = new_instancemethod(_fife.IJoystickListener_deviceRemoved, None, IJoystickListener)
IJoystickListener_swigregister = _fife.IJoystickListener_swigregister
IJoystickListener_swigregister(IJoystickListener)

class EventManager(object):
    """Proxy of C++ FIFE::EventManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::EventManager self) -> EventManager"""
        _fife.EventManager_swiginit(self, _fife.new_EventManager())
    __swig_destroy__ = _fife.delete_EventManager

    def addCommandListener(self, listener):
        """addCommandListener(EventManager self, ICommandListener listener)"""
        return _fife.EventManager_addCommandListener(self, listener)


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


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


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


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


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


    def addTextListener(self, listener):
        """addTextListener(EventManager self, ITextListener listener)"""
        return _fife.EventManager_addTextListener(self, listener)


    def addTextListenerFront(self, listener):
        """addTextListenerFront(EventManager self, ITextListener listener)"""
        return _fife.EventManager_addTextListenerFront(self, listener)


    def removeTextListener(self, listener):
        """removeTextListener(EventManager self, ITextListener listener)"""
        return _fife.EventManager_removeTextListener(self, listener)


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


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


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


    def addDropListener(self, listener):
        """addDropListener(EventManager self, IDropListener listener)"""
        return _fife.EventManager_addDropListener(self, listener)


    def addDropListenerFront(self, listener):
        """addDropListenerFront(EventManager self, IDropListener listener)"""
        return _fife.EventManager_addDropListenerFront(self, listener)


    def removeDropListener(self, listener):
        """removeDropListener(EventManager self, IDropListener listener)"""
        return _fife.EventManager_removeDropListener(self, listener)


    def addJoystickListener(self, listener):
        """addJoystickListener(EventManager self, IJoystickListener listener)"""
        return _fife.EventManager_addJoystickListener(self, listener)


    def addJoystickListenerFront(self, listener):
        """addJoystickListenerFront(EventManager self, IJoystickListener listener)"""
        return _fife.EventManager_addJoystickListenerFront(self, listener)


    def removeJoystickListener(self, listener):
        """removeJoystickListener(EventManager self, IJoystickListener listener)"""
        return _fife.EventManager_removeJoystickListener(self, listener)


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


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


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


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


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


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


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


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


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


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


    def isClipboardText(self):
        """isClipboardText(EventManager self) -> bool"""
        return _fife.EventManager_isClipboardText(self)


    def getClipboardText(self):
        """getClipboardText(EventManager self) -> std::string"""
        return _fife.EventManager_getClipboardText(self)


    def setClipboardText(self, text):
        """setClipboardText(EventManager self, std::string const & text)"""
        return _fife.EventManager_setClipboardText(self, text)


    def getJoystick(self, instanceId):
        """getJoystick(EventManager self, int32_t instanceId) -> Joystick"""
        return _fife.EventManager_getJoystick(self, instanceId)


    def getJoystickCount(self):
        """getJoystickCount(EventManager self) -> uint8_t"""
        return _fife.EventManager_getJoystickCount(self)


    def loadGamepadMapping(self, file):
        """loadGamepadMapping(EventManager self, std::string const & file)"""
        return _fife.EventManager_loadGamepadMapping(self, file)


    def saveGamepadMapping(self, guid, file):
        """saveGamepadMapping(EventManager self, std::string const guid, std::string const & file)"""
        return _fife.EventManager_saveGamepadMapping(self, guid, file)


    def saveGamepadMappings(self, file):
        """saveGamepadMappings(EventManager self, std::string const & file)"""
        return _fife.EventManager_saveGamepadMappings(self, file)


    def getGamepadStringMapping(self, guid):
        """getGamepadStringMapping(EventManager self, std::string const & guid) -> std::string"""
        return _fife.EventManager_getGamepadStringMapping(self, guid)


    def setGamepadStringMapping(self, mapping):
        """setGamepadStringMapping(EventManager self, std::string const & mapping)"""
        return _fife.EventManager_setGamepadStringMapping(self, mapping)

EventManager.addCommandListener = new_instancemethod(_fife.EventManager_addCommandListener, None, EventManager)
EventManager.addCommandListenerFront = new_instancemethod(_fife.EventManager_addCommandListenerFront, None, EventManager)
EventManager.removeCommandListener = new_instancemethod(_fife.EventManager_removeCommandListener, None, EventManager)
EventManager.addKeyListener = new_instancemethod(_fife.EventManager_addKeyListener, None, EventManager)
EventManager.addKeyListenerFront = new_instancemethod(_fife.EventManager_addKeyListenerFront, None, EventManager)
EventManager.removeKeyListener = new_instancemethod(_fife.EventManager_removeKeyListener, None, EventManager)
EventManager.addTextListener = new_instancemethod(_fife.EventManager_addTextListener, None, EventManager)
EventManager.addTextListenerFront = new_instancemethod(_fife.EventManager_addTextListenerFront, None, EventManager)
EventManager.removeTextListener = new_instancemethod(_fife.EventManager_removeTextListener, None, EventManager)
EventManager.addMouseListener = new_instancemethod(_fife.EventManager_addMouseListener, None, EventManager)
EventManager.addMouseListenerFront = new_instancemethod(_fife.EventManager_addMouseListenerFront, None, EventManager)
EventManager.removeMouseListener = new_instancemethod(_fife.EventManager_removeMouseListener, None, EventManager)
EventManager.addDropListener = new_instancemethod(_fife.EventManager_addDropListener, None, EventManager)
EventManager.addDropListenerFront = new_instancemethod(_fife.EventManager_addDropListenerFront, None, EventManager)
EventManager.removeDropListener = new_instancemethod(_fife.EventManager_removeDropListener, None, EventManager)
EventManager.addJoystickListener = new_instancemethod(_fife.EventManager_addJoystickListener, None, EventManager)
EventManager.addJoystickListenerFront = new_instancemethod(_fife.EventManager_addJoystickListenerFront, None, EventManager)
EventManager.removeJoystickListener = new_instancemethod(_fife.EventManager_removeJoystickListener, None, EventManager)
EventManager.addSdlEventListener = new_instancemethod(_fife.EventManager_addSdlEventListener, None, EventManager)
EventManager.addSdlEventListenerFront = new_instancemethod(_fife.EventManager_addSdlEventListenerFront, None, EventManager)
EventManager.removeSdlEventListener = new_instancemethod(_fife.EventManager_removeSdlEventListener, None, EventManager)
EventManager.getEventSourceType = new_instancemethod(_fife.EventManager_getEventSourceType, None, EventManager)
EventManager.dispatchCommand = new_instancemethod(_fife.EventManager_dispatchCommand, None, EventManager)
EventManager.setKeyFilter = new_instancemethod(_fife.EventManager_setKeyFilter, None, EventManager)
EventManager.setMouseSensitivity = new_instancemethod(_fife.EventManager_setMouseSensitivity, None, EventManager)
EventManager.getMouseSensitivity = new_instancemethod(_fife.EventManager_getMouseSensitivity, None, EventManager)
EventManager.setMouseAccelerationEnabled = new_instancemethod(_fife.EventManager_setMouseAccelerationEnabled, None, EventManager)
EventManager.isMouseAccelerationEnabled = new_instancemethod(_fife.EventManager_isMouseAccelerationEnabled, None, EventManager)
EventManager.isClipboardText = new_instancemethod(_fife.EventManager_isClipboardText, None, EventManager)
EventManager.getClipboardText = new_instancemethod(_fife.EventManager_getClipboardText, None, EventManager)
EventManager.setClipboardText = new_instancemethod(_fife.EventManager_setClipboardText, None, EventManager)
EventManager.getJoystick = new_instancemethod(_fife.EventManager_getJoystick, None, EventManager)
EventManager.getJoystickCount = new_instancemethod(_fife.EventManager_getJoystickCount, None, EventManager)
EventManager.loadGamepadMapping = new_instancemethod(_fife.EventManager_loadGamepadMapping, None, EventManager)
EventManager.saveGamepadMapping = new_instancemethod(_fife.EventManager_saveGamepadMapping, None, EventManager)
EventManager.saveGamepadMappings = new_instancemethod(_fife.EventManager_saveGamepadMappings, None, EventManager)
EventManager.getGamepadStringMapping = new_instancemethod(_fife.EventManager_getGamepadStringMapping, None, EventManager)
EventManager.setGamepadStringMapping = new_instancemethod(_fife.EventManager_setGamepadStringMapping, None, EventManager)
EventManager_swigregister = _fife.EventManager_swigregister
EventManager_swigregister(EventManager)

class Exception(Exception):
    """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, msg):
        """__init__(FIFE::Exception self, std::string const & msg) -> Exception"""
        _fife.Exception_swiginit(self, _fife.new_Exception(msg))
    __swig_destroy__ = _fife.delete_Exception

    def what(self):
        """what(Exception self) -> char const *"""
        return _fife.Exception_what(self)


    def getTypeStr(self):
        """getTypeStr(Exception self) -> std::string const &"""
        return _fife.Exception_getTypeStr(self)


    def getDescription(self):
        """getDescription(Exception self) -> std::string const &"""
        return _fife.Exception_getDescription(self)


    def update(self):
        """update(Exception self)"""
        return _fife.Exception_update(self)


    def __str__(self):
        """__str__(Exception self) -> char const *"""
        return _fife.Exception___str__(self)

Exception.what = new_instancemethod(_fife.Exception_what, None, Exception)
Exception.getTypeStr = new_instancemethod(_fife.Exception_getTypeStr, None, Exception)
Exception.getDescription = new_instancemethod(_fife.Exception_getDescription, None, Exception)
Exception.update = new_instancemethod(_fife.Exception_update, None, Exception)
Exception.__str__ = new_instancemethod(_fife.Exception___str__, None, Exception)
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, msg):
        """__init__(FIFE::SDLException self, std::string const & msg) -> SDLException"""
        _fife.SDLException_swiginit(self, _fife.new_SDLException(msg))

    def getTypeStr(self):
        """getTypeStr(SDLException self) -> std::string const &"""
        return _fife.SDLException_getTypeStr(self)


    def getDescription(self):
        """getDescription(SDLException self) -> std::string const &"""
        return _fife.SDLException_getDescription(self)

    __swig_destroy__ = _fife.delete_SDLException
SDLException.getTypeStr = new_instancemethod(_fife.SDLException_getTypeStr, None, SDLException)
SDLException.getDescription = new_instancemethod(_fife.SDLException_getDescription, None, SDLException)
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, msg):
        """__init__(FIFE::NotFound self, std::string const & msg) -> NotFound"""
        _fife.NotFound_swiginit(self, _fife.new_NotFound(msg))

    def getTypeStr(self):
        """getTypeStr(NotFound self) -> std::string const &"""
        return _fife.NotFound_getTypeStr(self)


    def getDescription(self):
        """getDescription(NotFound self) -> std::string const &"""
        return _fife.NotFound_getDescription(self)

    __swig_destroy__ = _fife.delete_NotFound
NotFound.getTypeStr = new_instancemethod(_fife.NotFound_getTypeStr, None, NotFound)
NotFound.getDescription = new_instancemethod(_fife.NotFound_getDescription, None, NotFound)
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, msg):
        """__init__(FIFE::NotSet self, std::string const & msg) -> NotSet"""
        _fife.NotSet_swiginit(self, _fife.new_NotSet(msg))

    def getTypeStr(self):
        """getTypeStr(NotSet self) -> std::string const &"""
        return _fife.NotSet_getTypeStr(self)


    def getDescription(self):
        """getDescription(NotSet self) -> std::string const &"""
        return _fife.NotSet_getDescription(self)

    __swig_destroy__ = _fife.delete_NotSet
NotSet.getTypeStr = new_instancemethod(_fife.NotSet_getTypeStr, None, NotSet)
NotSet.getDescription = new_instancemethod(_fife.NotSet_getDescription, None, NotSet)
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, msg):
        """__init__(FIFE::IndexOverflow self, std::string const & msg) -> IndexOverflow"""
        _fife.IndexOverflow_swiginit(self, _fife.new_IndexOverflow(msg))

    def getTypeStr(self):
        """getTypeStr(IndexOverflow self) -> std::string const &"""
        return _fife.IndexOverflow_getTypeStr(self)


    def getDescription(self):
        """getDescription(IndexOverflow self) -> std::string const &"""
        return _fife.IndexOverflow_getDescription(self)

    __swig_destroy__ = _fife.delete_IndexOverflow
IndexOverflow.getTypeStr = new_instancemethod(_fife.IndexOverflow_getTypeStr, None, IndexOverflow)
IndexOverflow.getDescription = new_instancemethod(_fife.IndexOverflow_getDescription, None, IndexOverflow)
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, msg):
        """__init__(FIFE::InvalidFormat self, std::string const & msg) -> InvalidFormat"""
        _fife.InvalidFormat_swiginit(self, _fife.new_InvalidFormat(msg))

    def getTypeStr(self):
        """getTypeStr(InvalidFormat self) -> std::string const &"""
        return _fife.InvalidFormat_getTypeStr(self)


    def getDescription(self):
        """getDescription(InvalidFormat self) -> std::string const &"""
        return _fife.InvalidFormat_getDescription(self)

    __swig_destroy__ = _fife.delete_InvalidFormat
InvalidFormat.getTypeStr = new_instancemethod(_fife.InvalidFormat_getTypeStr, None, InvalidFormat)
InvalidFormat.getDescription = new_instancemethod(_fife.InvalidFormat_getDescription, None, InvalidFormat)
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, msg):
        """__init__(FIFE::CannotOpenFile self, std::string const & msg) -> CannotOpenFile"""
        _fife.CannotOpenFile_swiginit(self, _fife.new_CannotOpenFile(msg))

    def getTypeStr(self):
        """getTypeStr(CannotOpenFile self) -> std::string const &"""
        return _fife.CannotOpenFile_getTypeStr(self)


    def getDescription(self):
        """getDescription(CannotOpenFile self) -> std::string const &"""
        return _fife.CannotOpenFile_getDescription(self)

    __swig_destroy__ = _fife.delete_CannotOpenFile
CannotOpenFile.getTypeStr = new_instancemethod(_fife.CannotOpenFile_getTypeStr, None, CannotOpenFile)
CannotOpenFile.getDescription = new_instancemethod(_fife.CannotOpenFile_getDescription, None, CannotOpenFile)
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, msg):
        """__init__(FIFE::InvalidConversion self, std::string const & msg) -> InvalidConversion"""
        _fife.InvalidConversion_swiginit(self, _fife.new_InvalidConversion(msg))

    def getTypeStr(self):
        """getTypeStr(InvalidConversion self) -> std::string const &"""
        return _fife.InvalidConversion_getTypeStr(self)


    def getDescription(self):
        """getDescription(InvalidConversion self) -> std::string const &"""
        return _fife.InvalidConversion_getDescription(self)

    __swig_destroy__ = _fife.delete_InvalidConversion
InvalidConversion.getTypeStr = new_instancemethod(_fife.InvalidConversion_getTypeStr, None, InvalidConversion)
InvalidConversion.getDescription = new_instancemethod(_fife.InvalidConversion_getDescription, None, InvalidConversion)
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, msg):
        """__init__(FIFE::NotSupported self, std::string const & msg) -> NotSupported"""
        _fife.NotSupported_swiginit(self, _fife.new_NotSupported(msg))

    def getTypeStr(self):
        """getTypeStr(NotSupported self) -> std::string const &"""
        return _fife.NotSupported_getTypeStr(self)


    def getDescription(self):
        """getDescription(NotSupported self) -> std::string const &"""
        return _fife.NotSupported_getDescription(self)

    __swig_destroy__ = _fife.delete_NotSupported
NotSupported.getTypeStr = new_instancemethod(_fife.NotSupported_getTypeStr, None, NotSupported)
NotSupported.getDescription = new_instancemethod(_fife.NotSupported_getDescription, None, NotSupported)
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, msg):
        """__init__(FIFE::NameClash self, std::string const & msg) -> NameClash"""
        _fife.NameClash_swiginit(self, _fife.new_NameClash(msg))

    def getTypeStr(self):
        """getTypeStr(NameClash self) -> std::string const &"""
        return _fife.NameClash_getTypeStr(self)


    def getDescription(self):
        """getDescription(NameClash self) -> std::string const &"""
        return _fife.NameClash_getDescription(self)

    __swig_destroy__ = _fife.delete_NameClash
NameClash.getTypeStr = new_instancemethod(_fife.NameClash_getTypeStr, None, NameClash)
NameClash.getDescription = new_instancemethod(_fife.NameClash_getDescription, None, NameClash)
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, msg):
        """__init__(FIFE::Duplicate self, std::string const & msg) -> Duplicate"""
        _fife.Duplicate_swiginit(self, _fife.new_Duplicate(msg))

    def getTypeStr(self):
        """getTypeStr(Duplicate self) -> std::string const &"""
        return _fife.Duplicate_getTypeStr(self)


    def getDescription(self):
        """getDescription(Duplicate self) -> std::string const &"""
        return _fife.Duplicate_getDescription(self)

    __swig_destroy__ = _fife.delete_Duplicate
Duplicate.getTypeStr = new_instancemethod(_fife.Duplicate_getTypeStr, None, Duplicate)
Duplicate.getDescription = new_instancemethod(_fife.Duplicate_getDescription, None, Duplicate)
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, msg):
        """__init__(FIFE::ScriptException self, std::string const & msg) -> ScriptException"""
        _fife.ScriptException_swiginit(self, _fife.new_ScriptException(msg))

    def getTypeStr(self):
        """getTypeStr(ScriptException self) -> std::string const &"""
        return _fife.ScriptException_getTypeStr(self)


    def getDescription(self):
        """getDescription(ScriptException self) -> std::string const &"""
        return _fife.ScriptException_getDescription(self)

    __swig_destroy__ = _fife.delete_ScriptException
ScriptException.getTypeStr = new_instancemethod(_fife.ScriptException_getTypeStr, None, ScriptException)
ScriptException.getDescription = new_instancemethod(_fife.ScriptException_getDescription, None, ScriptException)
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, msg):
        """__init__(FIFE::EventException self, std::string const & msg) -> EventException"""
        _fife.EventException_swiginit(self, _fife.new_EventException(msg))

    def getTypeStr(self):
        """getTypeStr(EventException self) -> std::string const &"""
        return _fife.EventException_getTypeStr(self)


    def getDescription(self):
        """getDescription(EventException self) -> std::string const &"""
        return _fife.EventException_getDescription(self)

    __swig_destroy__ = _fife.delete_EventException
EventException.getTypeStr = new_instancemethod(_fife.EventException_getTypeStr, None, EventException)
EventException.getDescription = new_instancemethod(_fife.EventException_getDescription, None, EventException)
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, msg):
        """__init__(FIFE::GuiException self, std::string const & msg) -> GuiException"""
        _fife.GuiException_swiginit(self, _fife.new_GuiException(msg))

    def getTypeStr(self):
        """getTypeStr(GuiException self) -> std::string const &"""
        return _fife.GuiException_getTypeStr(self)


    def getDescription(self):
        """getDescription(GuiException self) -> std::string const &"""
        return _fife.GuiException_getDescription(self)

    __swig_destroy__ = _fife.delete_GuiException
GuiException.getTypeStr = new_instancemethod(_fife.GuiException_getTypeStr, None, GuiException)
GuiException.getDescription = new_instancemethod(_fife.GuiException_getDescription, None, GuiException)
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, msg):
        """__init__(FIFE::InconsistencyDetected self, std::string const & msg) -> InconsistencyDetected"""
        _fife.InconsistencyDetected_swiginit(self, _fife.new_InconsistencyDetected(msg))

    def getTypeStr(self):
        """getTypeStr(InconsistencyDetected self) -> std::string const &"""
        return _fife.InconsistencyDetected_getTypeStr(self)


    def getDescription(self):
        """getDescription(InconsistencyDetected self) -> std::string const &"""
        return _fife.InconsistencyDetected_getDescription(self)

    __swig_destroy__ = _fife.delete_InconsistencyDetected
InconsistencyDetected.getTypeStr = new_instancemethod(_fife.InconsistencyDetected_getTypeStr, None, InconsistencyDetected)
InconsistencyDetected.getDescription = new_instancemethod(_fife.InconsistencyDetected_getDescription, None, InconsistencyDetected)
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, msg):
        """__init__(FIFE::OutOfMemory self, std::string const & msg) -> OutOfMemory"""
        _fife.OutOfMemory_swiginit(self, _fife.new_OutOfMemory(msg))

    def getTypeStr(self):
        """getTypeStr(OutOfMemory self) -> std::string const &"""
        return _fife.OutOfMemory_getTypeStr(self)


    def getDescription(self):
        """getDescription(OutOfMemory self) -> std::string const &"""
        return _fife.OutOfMemory_getDescription(self)

    __swig_destroy__ = _fife.delete_OutOfMemory
OutOfMemory.getTypeStr = new_instancemethod(_fife.OutOfMemory_getTypeStr, None, OutOfMemory)
OutOfMemory.getDescription = new_instancemethod(_fife.OutOfMemory_getDescription, None, OutOfMemory)
OutOfMemory_swigregister = _fife.OutOfMemory_swigregister
OutOfMemory_swigregister(OutOfMemory)

class FifeClass(object):
    """Proxy of C++ FIFE::FifeClass class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_FifeClass

    def getFifeId(self):
        """getFifeId(FifeClass self) -> FIFE::fifeid_t"""
        return _fife.FifeClass_getFifeId(self)


    def __eq__(self, *args):
        """
        __eq__(FifeClass self, PyObject const * other) -> bool
        __eq__(FifeClass self, FifeClass other) -> bool
        """
        return _fife.FifeClass___eq__(self, *args)


    def __ne__(self, *args):
        """
        __ne__(FifeClass self, PyObject const * other) -> bool
        __ne__(FifeClass self, FifeClass other) -> bool
        """
        return _fife.FifeClass___ne__(self, *args)


    def __hash__(self):
        """__hash__(FifeClass self) -> FIFE::fifeid_t"""
        return _fife.FifeClass___hash__(self)


    def __init__(self):
        """__init__(FIFE::FifeClass self) -> FifeClass"""
        _fife.FifeClass_swiginit(self, _fife.new_FifeClass())
FifeClass.getFifeId = new_instancemethod(_fife.FifeClass_getFifeId, None, FifeClass)
FifeClass.__eq__ = new_instancemethod(_fife.FifeClass___eq__, None, FifeClass)
FifeClass.__ne__ = new_instancemethod(_fife.FifeClass___ne__, None, FifeClass)
FifeClass.__hash__ = new_instancemethod(_fife.FifeClass___hash__, None, FifeClass)
FifeClass_swigregister = _fife.FifeClass_swigregister
FifeClass_swigregister(FifeClass)

class ScreenModeVector(object):
    """Proxy of C++ std::vector<(FIFE::ScreenMode)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(ScreenModeVector self) -> SwigPyIterator"""
        return _fife.ScreenModeVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ScreenModeVector self) -> bool"""
        return _fife.ScreenModeVector___nonzero__(self)


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


    def __len__(self):
        """__len__(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::size_type"""
        return _fife.ScreenModeVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::difference_type i, std::vector< FIFE::ScreenMode >::difference_type j) -> ScreenModeVector"""
        return _fife.ScreenModeVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::difference_type i, std::vector< FIFE::ScreenMode >::difference_type j)
        __setslice__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::difference_type i, std::vector< FIFE::ScreenMode >::difference_type j, ScreenModeVector v)
        """
        return _fife.ScreenModeVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::difference_type i, std::vector< FIFE::ScreenMode >::difference_type j)"""
        return _fife.ScreenModeVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::difference_type i)
        __delitem__(ScreenModeVector self, PySliceObject * slice)
        """
        return _fife.ScreenModeVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ScreenModeVector self, PySliceObject * slice) -> ScreenModeVector
        __getitem__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::difference_type i) -> ScreenMode
        """
        return _fife.ScreenModeVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ScreenModeVector self, PySliceObject * slice, ScreenModeVector v)
        __setitem__(ScreenModeVector self, PySliceObject * slice)
        __setitem__(ScreenModeVector self, std::vector< FIFE::ScreenMode >::difference_type i, ScreenMode x)
        """
        return _fife.ScreenModeVector___setitem__(self, *args)


    def pop(self):
        """pop(ScreenModeVector self) -> ScreenMode"""
        return _fife.ScreenModeVector_pop(self)


    def append(self, x):
        """append(ScreenModeVector self, ScreenMode x)"""
        return _fife.ScreenModeVector_append(self, x)


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


    def size(self):
        """size(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::size_type"""
        return _fife.ScreenModeVector_size(self)


    def swap(self, v):
        """swap(ScreenModeVector self, ScreenModeVector v)"""
        return _fife.ScreenModeVector_swap(self, v)


    def begin(self):
        """begin(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::iterator"""
        return _fife.ScreenModeVector_begin(self)


    def end(self):
        """end(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::iterator"""
        return _fife.ScreenModeVector_end(self)


    def rbegin(self):
        """rbegin(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::reverse_iterator"""
        return _fife.ScreenModeVector_rbegin(self)


    def rend(self):
        """rend(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::reverse_iterator"""
        return _fife.ScreenModeVector_rend(self)


    def clear(self):
        """clear(ScreenModeVector self)"""
        return _fife.ScreenModeVector_clear(self)


    def get_allocator(self):
        """get_allocator(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::allocator_type"""
        return _fife.ScreenModeVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ScreenModeVector self)"""
        return _fife.ScreenModeVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ScreenModeVector self, std::vector< FIFE::ScreenMode >::iterator pos) -> std::vector< FIFE::ScreenMode >::iterator
        erase(ScreenModeVector self, std::vector< FIFE::ScreenMode >::iterator first, std::vector< FIFE::ScreenMode >::iterator last) -> std::vector< FIFE::ScreenMode >::iterator
        """
        return _fife.ScreenModeVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(FIFE::ScreenMode)> self) -> ScreenModeVector
        __init__(std::vector<(FIFE::ScreenMode)> self, ScreenModeVector arg2) -> ScreenModeVector
        __init__(std::vector<(FIFE::ScreenMode)> self, std::vector< FIFE::ScreenMode >::size_type size) -> ScreenModeVector
        __init__(std::vector<(FIFE::ScreenMode)> self, std::vector< FIFE::ScreenMode >::size_type size, ScreenMode value) -> ScreenModeVector
        """
        _fife.ScreenModeVector_swiginit(self, _fife.new_ScreenModeVector(*args))

    def push_back(self, x):
        """push_back(ScreenModeVector self, ScreenMode x)"""
        return _fife.ScreenModeVector_push_back(self, x)


    def front(self):
        """front(ScreenModeVector self) -> ScreenMode"""
        return _fife.ScreenModeVector_front(self)


    def back(self):
        """back(ScreenModeVector self) -> ScreenMode"""
        return _fife.ScreenModeVector_back(self)


    def assign(self, n, x):
        """assign(ScreenModeVector self, std::vector< FIFE::ScreenMode >::size_type n, ScreenMode x)"""
        return _fife.ScreenModeVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ScreenModeVector self, std::vector< FIFE::ScreenMode >::size_type new_size)
        resize(ScreenModeVector self, std::vector< FIFE::ScreenMode >::size_type new_size, ScreenMode x)
        """
        return _fife.ScreenModeVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ScreenModeVector self, std::vector< FIFE::ScreenMode >::iterator pos, ScreenMode x) -> std::vector< FIFE::ScreenMode >::iterator
        insert(ScreenModeVector self, std::vector< FIFE::ScreenMode >::iterator pos, std::vector< FIFE::ScreenMode >::size_type n, ScreenMode x)
        """
        return _fife.ScreenModeVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ScreenModeVector self, std::vector< FIFE::ScreenMode >::size_type n)"""
        return _fife.ScreenModeVector_reserve(self, n)


    def capacity(self):
        """capacity(ScreenModeVector self) -> std::vector< FIFE::ScreenMode >::size_type"""
        return _fife.ScreenModeVector_capacity(self)

    __swig_destroy__ = _fife.delete_ScreenModeVector
ScreenModeVector.iterator = new_instancemethod(_fife.ScreenModeVector_iterator, None, ScreenModeVector)
ScreenModeVector.__nonzero__ = new_instancemethod(_fife.ScreenModeVector___nonzero__, None, ScreenModeVector)
ScreenModeVector.__bool__ = new_instancemethod(_fife.ScreenModeVector___bool__, None, ScreenModeVector)
ScreenModeVector.__len__ = new_instancemethod(_fife.ScreenModeVector___len__, None, ScreenModeVector)
ScreenModeVector.__getslice__ = new_instancemethod(_fife.ScreenModeVector___getslice__, None, ScreenModeVector)
ScreenModeVector.__setslice__ = new_instancemethod(_fife.ScreenModeVector___setslice__, None, ScreenModeVector)
ScreenModeVector.__delslice__ = new_instancemethod(_fife.ScreenModeVector___delslice__, None, ScreenModeVector)
ScreenModeVector.__delitem__ = new_instancemethod(_fife.ScreenModeVector___delitem__, None, ScreenModeVector)
ScreenModeVector.__getitem__ = new_instancemethod(_fife.ScreenModeVector___getitem__, None, ScreenModeVector)
ScreenModeVector.__setitem__ = new_instancemethod(_fife.ScreenModeVector___setitem__, None, ScreenModeVector)
ScreenModeVector.pop = new_instancemethod(_fife.ScreenModeVector_pop, None, ScreenModeVector)
ScreenModeVector.append = new_instancemethod(_fife.ScreenModeVector_append, None, ScreenModeVector)
ScreenModeVector.empty = new_instancemethod(_fife.ScreenModeVector_empty, None, ScreenModeVector)
ScreenModeVector.size = new_instancemethod(_fife.ScreenModeVector_size, None, ScreenModeVector)
ScreenModeVector.swap = new_instancemethod(_fife.ScreenModeVector_swap, None, ScreenModeVector)
ScreenModeVector.begin = new_instancemethod(_fife.ScreenModeVector_begin, None, ScreenModeVector)
ScreenModeVector.end = new_instancemethod(_fife.ScreenModeVector_end, None, ScreenModeVector)
ScreenModeVector.rbegin = new_instancemethod(_fife.ScreenModeVector_rbegin, None, ScreenModeVector)
ScreenModeVector.rend = new_instancemethod(_fife.ScreenModeVector_rend, None, ScreenModeVector)
ScreenModeVector.clear = new_instancemethod(_fife.ScreenModeVector_clear, None, ScreenModeVector)
ScreenModeVector.get_allocator = new_instancemethod(_fife.ScreenModeVector_get_allocator, None, ScreenModeVector)
ScreenModeVector.pop_back = new_instancemethod(_fife.ScreenModeVector_pop_back, None, ScreenModeVector)
ScreenModeVector.erase = new_instancemethod(_fife.ScreenModeVector_erase, None, ScreenModeVector)
ScreenModeVector.push_back = new_instancemethod(_fife.ScreenModeVector_push_back, None, ScreenModeVector)
ScreenModeVector.front = new_instancemethod(_fife.ScreenModeVector_front, None, ScreenModeVector)
ScreenModeVector.back = new_instancemethod(_fife.ScreenModeVector_back, None, ScreenModeVector)
ScreenModeVector.assign = new_instancemethod(_fife.ScreenModeVector_assign, None, ScreenModeVector)
ScreenModeVector.resize = new_instancemethod(_fife.ScreenModeVector_resize, None, ScreenModeVector)
ScreenModeVector.insert = new_instancemethod(_fife.ScreenModeVector_insert, None, ScreenModeVector)
ScreenModeVector.reserve = new_instancemethod(_fife.ScreenModeVector_reserve, None, ScreenModeVector)
ScreenModeVector.capacity = new_instancemethod(_fife.ScreenModeVector_capacity, None, ScreenModeVector)
ScreenModeVector_swigregister = _fife.ScreenModeVector_swigregister
ScreenModeVector_swigregister(ScreenModeVector)

class Image(IResource):
    """Proxy of C++ FIFE::Image class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Image

    def getSurface(self):
        """getSurface(Image self) -> SDL_Surface *"""
        return _fife.Image_getSurface(self)


    def getWidth(self):
        """getWidth(Image self) -> uint32_t"""
        return _fife.Image_getWidth(self)


    def getHeight(self):
        """getHeight(Image self) -> uint32_t"""
        return _fife.Image_getHeight(self)


    def getArea(self):
        """getArea(Image self) -> Rect"""
        return _fife.Image_getArea(self)


    def setXShift(self, xshift):
        """setXShift(Image self, int32_t xshift)"""
        return _fife.Image_setXShift(self, xshift)


    def getXShift(self):
        """getXShift(Image self) -> int32_t"""
        return _fife.Image_getXShift(self)


    def setYShift(self, yshift):
        """setYShift(Image self, int32_t yshift)"""
        return _fife.Image_setYShift(self, yshift)


    def getYShift(self):
        """getYShift(Image self) -> int32_t"""
        return _fife.Image_getYShift(self)


    def getPixelRGBA(self, x, y):
        """getPixelRGBA(Image self, int32_t x, int32_t y)"""
        return _fife.Image_getPixelRGBA(self, x, y)


    def saveImage(self, filename):
        """saveImage(Image self, std::string const & filename)"""
        return _fife.Image_saveImage(self, filename)


    def useSharedImage(self, shared, region):
        """useSharedImage(Image self, SharedImagePointer shared, Rect region)"""
        return _fife.Image_useSharedImage(self, shared, region)


    def forceLoadInternal(self):
        """forceLoadInternal(Image self)"""
        return _fife.Image_forceLoadInternal(self)


    def isSharedImage(self):
        """isSharedImage(Image self) -> bool"""
        return _fife.Image_isSharedImage(self)


    def getSubImageRect(self):
        """getSubImageRect(Image self) -> Rect"""
        return _fife.Image_getSubImageRect(self)


    def copySubimage(self, xoffset, yoffset, img):
        """copySubimage(Image self, uint32_t xoffset, uint32_t yoffset, SharedImagePointer img)"""
        return _fife.Image_copySubimage(self, xoffset, yoffset, img)

Image.getSurface = new_instancemethod(_fife.Image_getSurface, None, Image)
Image.getWidth = new_instancemethod(_fife.Image_getWidth, None, Image)
Image.getHeight = new_instancemethod(_fife.Image_getHeight, None, Image)
Image.getArea = new_instancemethod(_fife.Image_getArea, None, Image)
Image.setXShift = new_instancemethod(_fife.Image_setXShift, None, Image)
Image.getXShift = new_instancemethod(_fife.Image_getXShift, None, Image)
Image.setYShift = new_instancemethod(_fife.Image_setYShift, None, Image)
Image.getYShift = new_instancemethod(_fife.Image_getYShift, None, Image)
Image.getPixelRGBA = new_instancemethod(_fife.Image_getPixelRGBA, None, Image)
Image.saveImage = new_instancemethod(_fife.Image_saveImage, None, Image)
Image.useSharedImage = new_instancemethod(_fife.Image_useSharedImage, None, Image)
Image.forceLoadInternal = new_instancemethod(_fife.Image_forceLoadInternal, None, Image)
Image.isSharedImage = new_instancemethod(_fife.Image_isSharedImage, None, Image)
Image.getSubImageRect = new_instancemethod(_fife.Image_getSubImageRect, None, Image)
Image.copySubimage = new_instancemethod(_fife.Image_copySubimage, None, Image)
Image_swigregister = _fife.Image_swigregister
Image_swigregister(Image)

class SharedImagePointer(object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::Image)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::SharedPtr<(FIFE::Image)> self) -> SharedImagePointer
        __init__(FIFE::SharedPtr<(FIFE::Image)> self, SharedImagePointer rhs) -> SharedImagePointer
        """
        _fife.SharedImagePointer_swiginit(self, _fife.new_SharedImagePointer(*args))
    __swig_destroy__ = _fife.delete_SharedImagePointer

    def __ref__(self):
        """__ref__(SharedImagePointer self) -> Image"""
        return _fife.SharedImagePointer___ref__(self)


    def __deref__(self):
        """__deref__(SharedImagePointer self) -> Image"""
        return _fife.SharedImagePointer___deref__(self)


    def get(self):
        """get(SharedImagePointer self) -> Image"""
        return _fife.SharedImagePointer_get(self)


    def reset(self, ptr=None):
        """reset(SharedImagePointer self, Image ptr=None)"""
        return _fife.SharedImagePointer_reset(self, ptr)


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


    def useCountPtr(self):
        """useCountPtr(SharedImagePointer self) -> uint32_t *"""
        return _fife.SharedImagePointer_useCountPtr(self)


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


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



    def getSurface(self):
        """getSurface(SharedImagePointer self) -> SDL_Surface *"""
        return _fife.SharedImagePointer_getSurface(self)


    def getWidth(self):
        """getWidth(SharedImagePointer self) -> uint32_t"""
        return _fife.SharedImagePointer_getWidth(self)


    def getHeight(self):
        """getHeight(SharedImagePointer self) -> uint32_t"""
        return _fife.SharedImagePointer_getHeight(self)


    def getArea(self):
        """getArea(SharedImagePointer self) -> Rect"""
        return _fife.SharedImagePointer_getArea(self)


    def setXShift(self, xshift):
        """setXShift(SharedImagePointer self, int32_t xshift)"""
        return _fife.SharedImagePointer_setXShift(self, xshift)


    def getXShift(self):
        """getXShift(SharedImagePointer self) -> int32_t"""
        return _fife.SharedImagePointer_getXShift(self)


    def setYShift(self, yshift):
        """setYShift(SharedImagePointer self, int32_t yshift)"""
        return _fife.SharedImagePointer_setYShift(self, yshift)


    def getYShift(self):
        """getYShift(SharedImagePointer self) -> int32_t"""
        return _fife.SharedImagePointer_getYShift(self)


    def getPixelRGBA(self, x, y):
        """getPixelRGBA(SharedImagePointer self, int32_t x, int32_t y)"""
        return _fife.SharedImagePointer_getPixelRGBA(self, x, y)


    def saveImage(self, filename):
        """saveImage(SharedImagePointer self, std::string const & filename)"""
        return _fife.SharedImagePointer_saveImage(self, filename)


    def useSharedImage(self, shared, region):
        """useSharedImage(SharedImagePointer self, SharedImagePointer shared, Rect region)"""
        return _fife.SharedImagePointer_useSharedImage(self, shared, region)


    def forceLoadInternal(self):
        """forceLoadInternal(SharedImagePointer self)"""
        return _fife.SharedImagePointer_forceLoadInternal(self)


    def isSharedImage(self):
        """isSharedImage(SharedImagePointer self) -> bool"""
        return _fife.SharedImagePointer_isSharedImage(self)


    def getSubImageRect(self):
        """getSubImageRect(SharedImagePointer self) -> Rect"""
        return _fife.SharedImagePointer_getSubImageRect(self)


    def copySubimage(self, xoffset, yoffset, img):
        """copySubimage(SharedImagePointer self, uint32_t xoffset, uint32_t yoffset, SharedImagePointer img)"""
        return _fife.SharedImagePointer_copySubimage(self, xoffset, yoffset, img)


    def getName(self):
        """getName(SharedImagePointer self) -> std::string const &"""
        return _fife.SharedImagePointer_getName(self)


    def getHandle(self):
        """getHandle(SharedImagePointer self) -> FIFE::ResourceHandle"""
        return _fife.SharedImagePointer_getHandle(self)


    def getState(self):
        """getState(SharedImagePointer self) -> FIFE::IResource::ResourceState"""
        return _fife.SharedImagePointer_getState(self)


    def setState(self, state):
        """setState(SharedImagePointer self, FIFE::IResource::ResourceState const & state)"""
        return _fife.SharedImagePointer_setState(self, state)


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


    def load(self):
        """load(SharedImagePointer self)"""
        return _fife.SharedImagePointer_load(self)


    def free(self):
        """free(SharedImagePointer self)"""
        return _fife.SharedImagePointer_free(self)

SharedImagePointer.__ref__ = new_instancemethod(_fife.SharedImagePointer___ref__, None, SharedImagePointer)
SharedImagePointer.__deref__ = new_instancemethod(_fife.SharedImagePointer___deref__, None, SharedImagePointer)
SharedImagePointer.get = new_instancemethod(_fife.SharedImagePointer_get, None, SharedImagePointer)
SharedImagePointer.reset = new_instancemethod(_fife.SharedImagePointer_reset, None, SharedImagePointer)
SharedImagePointer.useCount = new_instancemethod(_fife.SharedImagePointer_useCount, None, SharedImagePointer)
SharedImagePointer.useCountPtr = new_instancemethod(_fife.SharedImagePointer_useCountPtr, None, SharedImagePointer)
SharedImagePointer.unique = new_instancemethod(_fife.SharedImagePointer_unique, None, SharedImagePointer)
SharedImagePointer.getSurface = new_instancemethod(_fife.SharedImagePointer_getSurface, None, SharedImagePointer)
SharedImagePointer.getWidth = new_instancemethod(_fife.SharedImagePointer_getWidth, None, SharedImagePointer)
SharedImagePointer.getHeight = new_instancemethod(_fife.SharedImagePointer_getHeight, None, SharedImagePointer)
SharedImagePointer.getArea = new_instancemethod(_fife.SharedImagePointer_getArea, None, SharedImagePointer)
SharedImagePointer.setXShift = new_instancemethod(_fife.SharedImagePointer_setXShift, None, SharedImagePointer)
SharedImagePointer.getXShift = new_instancemethod(_fife.SharedImagePointer_getXShift, None, SharedImagePointer)
SharedImagePointer.setYShift = new_instancemethod(_fife.SharedImagePointer_setYShift, None, SharedImagePointer)
SharedImagePointer.getYShift = new_instancemethod(_fife.SharedImagePointer_getYShift, None, SharedImagePointer)
SharedImagePointer.getPixelRGBA = new_instancemethod(_fife.SharedImagePointer_getPixelRGBA, None, SharedImagePointer)
SharedImagePointer.saveImage = new_instancemethod(_fife.SharedImagePointer_saveImage, None, SharedImagePointer)
SharedImagePointer.useSharedImage = new_instancemethod(_fife.SharedImagePointer_useSharedImage, None, SharedImagePointer)
SharedImagePointer.forceLoadInternal = new_instancemethod(_fife.SharedImagePointer_forceLoadInternal, None, SharedImagePointer)
SharedImagePointer.isSharedImage = new_instancemethod(_fife.SharedImagePointer_isSharedImage, None, SharedImagePointer)
SharedImagePointer.getSubImageRect = new_instancemethod(_fife.SharedImagePointer_getSubImageRect, None, SharedImagePointer)
SharedImagePointer.copySubimage = new_instancemethod(_fife.SharedImagePointer_copySubimage, None, SharedImagePointer)
SharedImagePointer.getName = new_instancemethod(_fife.SharedImagePointer_getName, None, SharedImagePointer)
SharedImagePointer.getHandle = new_instancemethod(_fife.SharedImagePointer_getHandle, None, SharedImagePointer)
SharedImagePointer.getState = new_instancemethod(_fife.SharedImagePointer_getState, None, SharedImagePointer)
SharedImagePointer.setState = new_instancemethod(_fife.SharedImagePointer_setState, None, SharedImagePointer)
SharedImagePointer.getSize = new_instancemethod(_fife.SharedImagePointer_getSize, None, SharedImagePointer)
SharedImagePointer.load = new_instancemethod(_fife.SharedImagePointer_load, None, SharedImagePointer)
SharedImagePointer.free = new_instancemethod(_fife.SharedImagePointer_free, None, SharedImagePointer)
SharedImagePointer_swigregister = _fife.SharedImagePointer_swigregister
SharedImagePointer_swigregister(SharedImagePointer)

class ImageManager(IResourceManager):
    """Proxy of C++ FIFE::ImageManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ImageManager

    def getMemoryUsed(self):
        """getMemoryUsed(ImageManager self) -> size_t"""
        return _fife.ImageManager_getMemoryUsed(self)


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


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


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


    def create(self, name, loader=None):
        """create(ImageManager self, std::string const & name, IResourceLoader loader=None) -> SharedImagePointer"""
        return _fife.ImageManager_create(self, name, loader)


    def load(self, name, loader=None):
        """load(ImageManager self, std::string const & name, IResourceLoader loader=None) -> SharedImagePointer"""
        return _fife.ImageManager_load(self, name, loader)


    def loadBlank(self, width, height):
        """loadBlank(ImageManager self, uint32_t width, uint32_t height) -> SharedImagePointer"""
        return _fife.ImageManager_loadBlank(self, width, height)


    def add(self, res):
        """add(ImageManager self, Image res) -> SharedImagePointer"""
        return _fife.ImageManager_add(self, res)


    def exists(self, *args):
        """
        exists(ImageManager self, std::string const & name) -> bool
        exists(ImageManager self, FIFE::ResourceHandle handle) -> bool
        """
        return _fife.ImageManager_exists(self, *args)


    def reload(self, *args):
        """
        reload(ImageManager self, std::string const & name)
        reload(ImageManager self, FIFE::ResourceHandle handle)
        """
        return _fife.ImageManager_reload(self, *args)


    def reloadAll(self):
        """reloadAll(ImageManager self)"""
        return _fife.ImageManager_reloadAll(self)


    def loadUnreferenced(self):
        """loadUnreferenced(ImageManager self)"""
        return _fife.ImageManager_loadUnreferenced(self)


    def free(self, *args):
        """
        free(ImageManager self, std::string const & name)
        free(ImageManager self, FIFE::ResourceHandle handle)
        """
        return _fife.ImageManager_free(self, *args)


    def freeAll(self):
        """freeAll(ImageManager self)"""
        return _fife.ImageManager_freeAll(self)


    def freeUnreferenced(self):
        """freeUnreferenced(ImageManager self)"""
        return _fife.ImageManager_freeUnreferenced(self)


    def remove(self, *args):
        """
        remove(ImageManager self, SharedImagePointer resource)
        remove(ImageManager self, std::string const & name)
        remove(ImageManager self, FIFE::ResourceHandle handle)
        """
        return _fife.ImageManager_remove(self, *args)


    def removeAll(self):
        """removeAll(ImageManager self)"""
        return _fife.ImageManager_removeAll(self)


    def removeUnreferenced(self):
        """removeUnreferenced(ImageManager self)"""
        return _fife.ImageManager_removeUnreferenced(self)


    def get(self, *args):
        """
        get(ImageManager self, std::string const & name) -> SharedImagePointer
        get(ImageManager self, FIFE::ResourceHandle handle) -> SharedImagePointer
        """
        return _fife.ImageManager_get(self, *args)


    def getResourceHandle(self, name):
        """getResourceHandle(ImageManager self, std::string const & name) -> FIFE::ResourceHandle"""
        return _fife.ImageManager_getResourceHandle(self, name)


    def invalidate(self, *args):
        """
        invalidate(ImageManager self, std::string const & name)
        invalidate(ImageManager self, FIFE::ResourceHandle handle)
        """
        return _fife.ImageManager_invalidate(self, *args)


    def invalidateAll(self):
        """invalidateAll(ImageManager self)"""
        return _fife.ImageManager_invalidateAll(self)


    def __init__(self):
        """__init__(FIFE::ImageManager self) -> ImageManager"""
        _fife.ImageManager_swiginit(self, _fife.new_ImageManager())
ImageManager.getMemoryUsed = new_instancemethod(_fife.ImageManager_getMemoryUsed, None, ImageManager)
ImageManager.getTotalResourcesCreated = new_instancemethod(_fife.ImageManager_getTotalResourcesCreated, None, ImageManager)
ImageManager.getTotalResourcesLoaded = new_instancemethod(_fife.ImageManager_getTotalResourcesLoaded, None, ImageManager)
ImageManager.getTotalResources = new_instancemethod(_fife.ImageManager_getTotalResources, None, ImageManager)
ImageManager.create = new_instancemethod(_fife.ImageManager_create, None, ImageManager)
ImageManager.load = new_instancemethod(_fife.ImageManager_load, None, ImageManager)
ImageManager.loadBlank = new_instancemethod(_fife.ImageManager_loadBlank, None, ImageManager)
ImageManager.add = new_instancemethod(_fife.ImageManager_add, None, ImageManager)
ImageManager.exists = new_instancemethod(_fife.ImageManager_exists, None, ImageManager)
ImageManager.reload = new_instancemethod(_fife.ImageManager_reload, None, ImageManager)
ImageManager.reloadAll = new_instancemethod(_fife.ImageManager_reloadAll, None, ImageManager)
ImageManager.loadUnreferenced = new_instancemethod(_fife.ImageManager_loadUnreferenced, None, ImageManager)
ImageManager.free = new_instancemethod(_fife.ImageManager_free, None, ImageManager)
ImageManager.freeAll = new_instancemethod(_fife.ImageManager_freeAll, None, ImageManager)
ImageManager.freeUnreferenced = new_instancemethod(_fife.ImageManager_freeUnreferenced, None, ImageManager)
ImageManager.remove = new_instancemethod(_fife.ImageManager_remove, None, ImageManager)
ImageManager.removeAll = new_instancemethod(_fife.ImageManager_removeAll, None, ImageManager)
ImageManager.removeUnreferenced = new_instancemethod(_fife.ImageManager_removeUnreferenced, None, ImageManager)
ImageManager.get = new_instancemethod(_fife.ImageManager_get, None, ImageManager)
ImageManager.getResourceHandle = new_instancemethod(_fife.ImageManager_getResourceHandle, None, ImageManager)
ImageManager.invalidate = new_instancemethod(_fife.ImageManager_invalidate, None, ImageManager)
ImageManager.invalidateAll = new_instancemethod(_fife.ImageManager_invalidateAll, None, ImageManager)
ImageManager_swigregister = _fife.ImageManager_swigregister
ImageManager_swigregister(ImageManager)

class Animation(IResource):
    """Proxy of C++ FIFE::Animation class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Animation

    def addFrame(self, image, duration):
        """addFrame(Animation self, SharedImagePointer image, uint32_t duration)"""
        return _fife.Animation_addFrame(self, image, duration)


    def getFrameIndex(self, timestamp):
        """getFrameIndex(Animation self, uint32_t timestamp) -> int32_t"""
        return _fife.Animation_getFrameIndex(self, timestamp)


    def getFrame(self, index):
        """getFrame(Animation self, int32_t index) -> SharedImagePointer"""
        return _fife.Animation_getFrame(self, index)


    def getFrameByTimestamp(self, timestamp):
        """getFrameByTimestamp(Animation self, uint32_t timestamp) -> SharedImagePointer"""
        return _fife.Animation_getFrameByTimestamp(self, timestamp)


    def getFrameDuration(self, index):
        """getFrameDuration(Animation self, int32_t index) -> int32_t"""
        return _fife.Animation_getFrameDuration(self, index)


    def getFrameCount(self):
        """getFrameCount(Animation self) -> uint32_t"""
        return _fife.Animation_getFrameCount(self)


    def setActionFrame(self, num):
        """setActionFrame(Animation self, int32_t num)"""
        return _fife.Animation_setActionFrame(self, num)


    def getActionFrame(self):
        """getActionFrame(Animation self) -> int32_t"""
        return _fife.Animation_getActionFrame(self)


    def setDirection(self, direction):
        """setDirection(Animation self, uint32_t direction)"""
        return _fife.Animation_setDirection(self, direction)


    def getDirection(self):
        """getDirection(Animation self) -> uint32_t"""
        return _fife.Animation_getDirection(self)


    def getDuration(self):
        """getDuration(Animation self) -> int32_t"""
        return _fife.Animation_getDuration(self)

Animation.addFrame = new_instancemethod(_fife.Animation_addFrame, None, Animation)
Animation.getFrameIndex = new_instancemethod(_fife.Animation_getFrameIndex, None, Animation)
Animation.getFrame = new_instancemethod(_fife.Animation_getFrame, None, Animation)
Animation.getFrameByTimestamp = new_instancemethod(_fife.Animation_getFrameByTimestamp, None, Animation)
Animation.getFrameDuration = new_instancemethod(_fife.Animation_getFrameDuration, None, Animation)
Animation.getFrameCount = new_instancemethod(_fife.Animation_getFrameCount, None, Animation)
Animation.setActionFrame = new_instancemethod(_fife.Animation_setActionFrame, None, Animation)
Animation.getActionFrame = new_instancemethod(_fife.Animation_getActionFrame, None, Animation)
Animation.setDirection = new_instancemethod(_fife.Animation_setDirection, None, Animation)
Animation.getDirection = new_instancemethod(_fife.Animation_getDirection, None, Animation)
Animation.getDuration = new_instancemethod(_fife.Animation_getDuration, None, Animation)
Animation_swigregister = _fife.Animation_swigregister
Animation_swigregister(Animation)

class SharedAnimationPointer(object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::Animation)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::SharedPtr<(FIFE::Animation)> self) -> SharedAnimationPointer
        __init__(FIFE::SharedPtr<(FIFE::Animation)> self, SharedAnimationPointer rhs) -> SharedAnimationPointer
        """
        _fife.SharedAnimationPointer_swiginit(self, _fife.new_SharedAnimationPointer(*args))
    __swig_destroy__ = _fife.delete_SharedAnimationPointer

    def __ref__(self):
        """__ref__(SharedAnimationPointer self) -> Animation"""
        return _fife.SharedAnimationPointer___ref__(self)


    def __deref__(self):
        """__deref__(SharedAnimationPointer self) -> Animation"""
        return _fife.SharedAnimationPointer___deref__(self)


    def get(self):
        """get(SharedAnimationPointer self) -> Animation"""
        return _fife.SharedAnimationPointer_get(self)


    def reset(self, ptr=None):
        """reset(SharedAnimationPointer self, Animation ptr=None)"""
        return _fife.SharedAnimationPointer_reset(self, ptr)


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


    def useCountPtr(self):
        """useCountPtr(SharedAnimationPointer self) -> uint32_t *"""
        return _fife.SharedAnimationPointer_useCountPtr(self)


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


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



    def addFrame(self, image, duration):
        """addFrame(SharedAnimationPointer self, SharedImagePointer image, uint32_t duration)"""
        return _fife.SharedAnimationPointer_addFrame(self, image, duration)


    def getFrameIndex(self, timestamp):
        """getFrameIndex(SharedAnimationPointer self, uint32_t timestamp) -> int32_t"""
        return _fife.SharedAnimationPointer_getFrameIndex(self, timestamp)


    def getFrame(self, index):
        """getFrame(SharedAnimationPointer self, int32_t index) -> SharedImagePointer"""
        return _fife.SharedAnimationPointer_getFrame(self, index)


    def getFrameByTimestamp(self, timestamp):
        """getFrameByTimestamp(SharedAnimationPointer self, uint32_t timestamp) -> SharedImagePointer"""
        return _fife.SharedAnimationPointer_getFrameByTimestamp(self, timestamp)


    def getFrameDuration(self, index):
        """getFrameDuration(SharedAnimationPointer self, int32_t index) -> int32_t"""
        return _fife.SharedAnimationPointer_getFrameDuration(self, index)


    def getFrameCount(self):
        """getFrameCount(SharedAnimationPointer self) -> uint32_t"""
        return _fife.SharedAnimationPointer_getFrameCount(self)


    def setActionFrame(self, num):
        """setActionFrame(SharedAnimationPointer self, int32_t num)"""
        return _fife.SharedAnimationPointer_setActionFrame(self, num)


    def getActionFrame(self):
        """getActionFrame(SharedAnimationPointer self) -> int32_t"""
        return _fife.SharedAnimationPointer_getActionFrame(self)


    def setDirection(self, direction):
        """setDirection(SharedAnimationPointer self, uint32_t direction)"""
        return _fife.SharedAnimationPointer_setDirection(self, direction)


    def getDirection(self):
        """getDirection(SharedAnimationPointer self) -> uint32_t"""
        return _fife.SharedAnimationPointer_getDirection(self)


    def getDuration(self):
        """getDuration(SharedAnimationPointer self) -> int32_t"""
        return _fife.SharedAnimationPointer_getDuration(self)


    def getName(self):
        """getName(SharedAnimationPointer self) -> std::string const &"""
        return _fife.SharedAnimationPointer_getName(self)


    def getHandle(self):
        """getHandle(SharedAnimationPointer self) -> FIFE::ResourceHandle"""
        return _fife.SharedAnimationPointer_getHandle(self)


    def getState(self):
        """getState(SharedAnimationPointer self) -> FIFE::IResource::ResourceState"""
        return _fife.SharedAnimationPointer_getState(self)


    def setState(self, state):
        """setState(SharedAnimationPointer self, FIFE::IResource::ResourceState const & state)"""
        return _fife.SharedAnimationPointer_setState(self, state)


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


    def load(self):
        """load(SharedAnimationPointer self)"""
        return _fife.SharedAnimationPointer_load(self)


    def free(self):
        """free(SharedAnimationPointer self)"""
        return _fife.SharedAnimationPointer_free(self)

SharedAnimationPointer.__ref__ = new_instancemethod(_fife.SharedAnimationPointer___ref__, None, SharedAnimationPointer)
SharedAnimationPointer.__deref__ = new_instancemethod(_fife.SharedAnimationPointer___deref__, None, SharedAnimationPointer)
SharedAnimationPointer.get = new_instancemethod(_fife.SharedAnimationPointer_get, None, SharedAnimationPointer)
SharedAnimationPointer.reset = new_instancemethod(_fife.SharedAnimationPointer_reset, None, SharedAnimationPointer)
SharedAnimationPointer.useCount = new_instancemethod(_fife.SharedAnimationPointer_useCount, None, SharedAnimationPointer)
SharedAnimationPointer.useCountPtr = new_instancemethod(_fife.SharedAnimationPointer_useCountPtr, None, SharedAnimationPointer)
SharedAnimationPointer.unique = new_instancemethod(_fife.SharedAnimationPointer_unique, None, SharedAnimationPointer)
SharedAnimationPointer.addFrame = new_instancemethod(_fife.SharedAnimationPointer_addFrame, None, SharedAnimationPointer)
SharedAnimationPointer.getFrameIndex = new_instancemethod(_fife.SharedAnimationPointer_getFrameIndex, None, SharedAnimationPointer)
SharedAnimationPointer.getFrame = new_instancemethod(_fife.SharedAnimationPointer_getFrame, None, SharedAnimationPointer)
SharedAnimationPointer.getFrameByTimestamp = new_instancemethod(_fife.SharedAnimationPointer_getFrameByTimestamp, None, SharedAnimationPointer)
SharedAnimationPointer.getFrameDuration = new_instancemethod(_fife.SharedAnimationPointer_getFrameDuration, None, SharedAnimationPointer)
SharedAnimationPointer.getFrameCount = new_instancemethod(_fife.SharedAnimationPointer_getFrameCount, None, SharedAnimationPointer)
SharedAnimationPointer.setActionFrame = new_instancemethod(_fife.SharedAnimationPointer_setActionFrame, None, SharedAnimationPointer)
SharedAnimationPointer.getActionFrame = new_instancemethod(_fife.SharedAnimationPointer_getActionFrame, None, SharedAnimationPointer)
SharedAnimationPointer.setDirection = new_instancemethod(_fife.SharedAnimationPointer_setDirection, None, SharedAnimationPointer)
SharedAnimationPointer.getDirection = new_instancemethod(_fife.SharedAnimationPointer_getDirection, None, SharedAnimationPointer)
SharedAnimationPointer.getDuration = new_instancemethod(_fife.SharedAnimationPointer_getDuration, None, SharedAnimationPointer)
SharedAnimationPointer.getName = new_instancemethod(_fife.SharedAnimationPointer_getName, None, SharedAnimationPointer)
SharedAnimationPointer.getHandle = new_instancemethod(_fife.SharedAnimationPointer_getHandle, None, SharedAnimationPointer)
SharedAnimationPointer.getState = new_instancemethod(_fife.SharedAnimationPointer_getState, None, SharedAnimationPointer)
SharedAnimationPointer.setState = new_instancemethod(_fife.SharedAnimationPointer_setState, None, SharedAnimationPointer)
SharedAnimationPointer.getSize = new_instancemethod(_fife.SharedAnimationPointer_getSize, None, SharedAnimationPointer)
SharedAnimationPointer.load = new_instancemethod(_fife.SharedAnimationPointer_load, None, SharedAnimationPointer)
SharedAnimationPointer.free = new_instancemethod(_fife.SharedAnimationPointer_free, None, SharedAnimationPointer)
SharedAnimationPointer_swigregister = _fife.SharedAnimationPointer_swigregister
SharedAnimationPointer_swigregister(SharedAnimationPointer)

class AnimationManager(IResourceManager):
    """Proxy of C++ FIFE::AnimationManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_AnimationManager

    def getMemoryUsed(self):
        """getMemoryUsed(AnimationManager self) -> size_t"""
        return _fife.AnimationManager_getMemoryUsed(self)


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


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


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


    def create(self, name, loader=None):
        """create(AnimationManager self, std::string const & name, IResourceLoader loader=None) -> SharedAnimationPointer"""
        return _fife.AnimationManager_create(self, name, loader)


    def add(self, res):
        """add(AnimationManager self, Animation res) -> SharedAnimationPointer"""
        return _fife.AnimationManager_add(self, res)


    def exists(self, *args):
        """
        exists(AnimationManager self, std::string const & name) -> bool
        exists(AnimationManager self, FIFE::ResourceHandle handle) -> bool
        """
        return _fife.AnimationManager_exists(self, *args)


    def reload(self, *args):
        """
        reload(AnimationManager self, std::string const & name)
        reload(AnimationManager self, FIFE::ResourceHandle handle)
        """
        return _fife.AnimationManager_reload(self, *args)


    def reloadAll(self):
        """reloadAll(AnimationManager self)"""
        return _fife.AnimationManager_reloadAll(self)


    def loadUnreferenced(self):
        """loadUnreferenced(AnimationManager self)"""
        return _fife.AnimationManager_loadUnreferenced(self)


    def free(self, *args):
        """
        free(AnimationManager self, std::string const & name)
        free(AnimationManager self, FIFE::ResourceHandle handle)
        """
        return _fife.AnimationManager_free(self, *args)


    def freeAll(self):
        """freeAll(AnimationManager self)"""
        return _fife.AnimationManager_freeAll(self)


    def freeUnreferenced(self):
        """freeUnreferenced(AnimationManager self)"""
        return _fife.AnimationManager_freeUnreferenced(self)


    def remove(self, *args):
        """
        remove(AnimationManager self, SharedImagePointer resource)
        remove(AnimationManager self, std::string const & name)
        remove(AnimationManager self, FIFE::ResourceHandle handle)
        """
        return _fife.AnimationManager_remove(self, *args)


    def removeAll(self):
        """removeAll(AnimationManager self)"""
        return _fife.AnimationManager_removeAll(self)


    def removeUnreferenced(self):
        """removeUnreferenced(AnimationManager self)"""
        return _fife.AnimationManager_removeUnreferenced(self)


    def get(self, *args):
        """
        get(AnimationManager self, std::string const & name) -> SharedAnimationPointer
        get(AnimationManager self, FIFE::ResourceHandle handle) -> SharedAnimationPointer
        """
        return _fife.AnimationManager_get(self, *args)


    def getPtr(self, *args):
        """
        getPtr(AnimationManager self, std::string const & name) -> SharedAnimationPointer
        getPtr(AnimationManager self, FIFE::ResourceHandle handle) -> SharedAnimationPointer
        """
        return _fife.AnimationManager_getPtr(self, *args)


    def getResourceHandle(self, name):
        """getResourceHandle(AnimationManager self, std::string const & name) -> FIFE::ResourceHandle"""
        return _fife.AnimationManager_getResourceHandle(self, name)


    def invalidate(self, *args):
        """
        invalidate(AnimationManager self, std::string const & name)
        invalidate(AnimationManager self, FIFE::ResourceHandle handle)
        """
        return _fife.AnimationManager_invalidate(self, *args)


    def invalidateAll(self):
        """invalidateAll(AnimationManager self)"""
        return _fife.AnimationManager_invalidateAll(self)


    def __init__(self):
        """__init__(FIFE::AnimationManager self) -> AnimationManager"""
        _fife.AnimationManager_swiginit(self, _fife.new_AnimationManager())
AnimationManager.getMemoryUsed = new_instancemethod(_fife.AnimationManager_getMemoryUsed, None, AnimationManager)
AnimationManager.getTotalResourcesCreated = new_instancemethod(_fife.AnimationManager_getTotalResourcesCreated, None, AnimationManager)
AnimationManager.getTotalResourcesLoaded = new_instancemethod(_fife.AnimationManager_getTotalResourcesLoaded, None, AnimationManager)
AnimationManager.getTotalResources = new_instancemethod(_fife.AnimationManager_getTotalResources, None, AnimationManager)
AnimationManager.create = new_instancemethod(_fife.AnimationManager_create, None, AnimationManager)
AnimationManager.add = new_instancemethod(_fife.AnimationManager_add, None, AnimationManager)
AnimationManager.exists = new_instancemethod(_fife.AnimationManager_exists, None, AnimationManager)
AnimationManager.reload = new_instancemethod(_fife.AnimationManager_reload, None, AnimationManager)
AnimationManager.reloadAll = new_instancemethod(_fife.AnimationManager_reloadAll, None, AnimationManager)
AnimationManager.loadUnreferenced = new_instancemethod(_fife.AnimationManager_loadUnreferenced, None, AnimationManager)
AnimationManager.free = new_instancemethod(_fife.AnimationManager_free, None, AnimationManager)
AnimationManager.freeAll = new_instancemethod(_fife.AnimationManager_freeAll, None, AnimationManager)
AnimationManager.freeUnreferenced = new_instancemethod(_fife.AnimationManager_freeUnreferenced, None, AnimationManager)
AnimationManager.remove = new_instancemethod(_fife.AnimationManager_remove, None, AnimationManager)
AnimationManager.removeAll = new_instancemethod(_fife.AnimationManager_removeAll, None, AnimationManager)
AnimationManager.removeUnreferenced = new_instancemethod(_fife.AnimationManager_removeUnreferenced, None, AnimationManager)
AnimationManager.get = new_instancemethod(_fife.AnimationManager_get, None, AnimationManager)
AnimationManager.getPtr = new_instancemethod(_fife.AnimationManager_getPtr, None, AnimationManager)
AnimationManager.getResourceHandle = new_instancemethod(_fife.AnimationManager_getResourceHandle, None, AnimationManager)
AnimationManager.invalidate = new_instancemethod(_fife.AnimationManager_invalidate, None, AnimationManager)
AnimationManager.invalidateAll = new_instancemethod(_fife.AnimationManager_invalidateAll, None, AnimationManager)
AnimationManager_swigregister = _fife.AnimationManager_swigregister
AnimationManager_swigregister(AnimationManager)

TEXTURE_FILTER_NONE = _fife.TEXTURE_FILTER_NONE
TEXTURE_FILTER_BILINEAR = _fife.TEXTURE_FILTER_BILINEAR
TEXTURE_FILTER_TRILINEAR = _fife.TEXTURE_FILTER_TRILINEAR
TEXTURE_FILTER_ANISOTROPIC = _fife.TEXTURE_FILTER_ANISOTROPIC
class RenderBackend(object):
    """Proxy of C++ FIFE::RenderBackend class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RenderBackend

    def getName(self):
        """getName(RenderBackend self) -> std::string const &"""
        return _fife.RenderBackend_getName(self)


    def captureScreen(self, *args):
        """
        captureScreen(RenderBackend self, std::string const & filename)
        captureScreen(RenderBackend self, std::string const & filename, uint32_t width, uint32_t height)
        """
        return _fife.RenderBackend_captureScreen(self, *args)


    def getCurrentScreenMode(self):
        """getCurrentScreenMode(RenderBackend self) -> ScreenMode"""
        return _fife.RenderBackend_getCurrentScreenMode(self)


    def getWidth(self):
        """getWidth(RenderBackend self) -> uint32_t"""
        return _fife.RenderBackend_getWidth(self)


    def getHeight(self):
        """getHeight(RenderBackend self) -> uint32_t"""
        return _fife.RenderBackend_getHeight(self)


    def getScreenWidth(self):
        """getScreenWidth(RenderBackend self) -> uint32_t"""
        return _fife.RenderBackend_getScreenWidth(self)


    def getScreenHeight(self):
        """getScreenHeight(RenderBackend self) -> uint32_t"""
        return _fife.RenderBackend_getScreenHeight(self)


    def getArea(self):
        """getArea(RenderBackend self) -> Rect"""
        return _fife.RenderBackend_getArea(self)


    def getClipArea(self):
        """getClipArea(RenderBackend self) -> Rect"""
        return _fife.RenderBackend_getClipArea(self)


    def setAlphaOptimizerEnabled(self, enabled):
        """setAlphaOptimizerEnabled(RenderBackend self, bool enabled)"""
        return _fife.RenderBackend_setAlphaOptimizerEnabled(self, enabled)


    def isAlphaOptimizerEnabled(self):
        """isAlphaOptimizerEnabled(RenderBackend self) -> bool"""
        return _fife.RenderBackend_isAlphaOptimizerEnabled(self)


    def setImageCompressingEnabled(self, enabled):
        """setImageCompressingEnabled(RenderBackend self, bool enabled)"""
        return _fife.RenderBackend_setImageCompressingEnabled(self, enabled)


    def isImageCompressingEnabled(self):
        """isImageCompressingEnabled(RenderBackend self) -> bool"""
        return _fife.RenderBackend_isImageCompressingEnabled(self)


    def setFramebufferEnabled(self, enabled):
        """setFramebufferEnabled(RenderBackend self, bool enabled)"""
        return _fife.RenderBackend_setFramebufferEnabled(self, enabled)


    def isFramebufferEnabled(self):
        """isFramebufferEnabled(RenderBackend self) -> bool"""
        return _fife.RenderBackend_isFramebufferEnabled(self)


    def setNPOTEnabled(self, enabled):
        """setNPOTEnabled(RenderBackend self, bool enabled)"""
        return _fife.RenderBackend_setNPOTEnabled(self, enabled)


    def isNPOTEnabled(self):
        """isNPOTEnabled(RenderBackend self) -> bool"""
        return _fife.RenderBackend_isNPOTEnabled(self)


    def setTextureFiltering(self, filter):
        """setTextureFiltering(RenderBackend self, FIFE::TextureFiltering filter)"""
        return _fife.RenderBackend_setTextureFiltering(self, filter)


    def getTextureFiltering(self):
        """getTextureFiltering(RenderBackend self) -> FIFE::TextureFiltering"""
        return _fife.RenderBackend_getTextureFiltering(self)


    def setMipmappingEnabled(self, enabled):
        """setMipmappingEnabled(RenderBackend self, bool enabled)"""
        return _fife.RenderBackend_setMipmappingEnabled(self, enabled)


    def isMipmappingEnabled(self):
        """isMipmappingEnabled(RenderBackend self) -> bool"""
        return _fife.RenderBackend_isMipmappingEnabled(self)


    def setMonochromeEnabled(self, enabled):
        """setMonochromeEnabled(RenderBackend self, bool enabled)"""
        return _fife.RenderBackend_setMonochromeEnabled(self, enabled)


    def isMonochromeEnabled(self):
        """isMonochromeEnabled(RenderBackend self) -> bool"""
        return _fife.RenderBackend_isMonochromeEnabled(self)


    def setColorKeyEnabled(self, colorkeyenable):
        """setColorKeyEnabled(RenderBackend self, bool colorkeyenable)"""
        return _fife.RenderBackend_setColorKeyEnabled(self, colorkeyenable)


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


    def setColorKey(self, colorkey):
        """setColorKey(RenderBackend self, SDL_Color const & colorkey)"""
        return _fife.RenderBackend_setColorKey(self, colorkey)


    def getColorKey(self):
        """getColorKey(RenderBackend self) -> SDL_Color const &"""
        return _fife.RenderBackend_getColorKey(self)


    def getPixelFormat(self):
        """getPixelFormat(RenderBackend self) -> SDL_PixelFormat const &"""
        return _fife.RenderBackend_getPixelFormat(self)


    def setBackgroundColor(self, r, g, b):
        """setBackgroundColor(RenderBackend self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.RenderBackend_setBackgroundColor(self, r, g, b)


    def resetBackgroundColor(self):
        """resetBackgroundColor(RenderBackend self)"""
        return _fife.RenderBackend_resetBackgroundColor(self)


    def setVSyncEnabled(self, vsync):
        """setVSyncEnabled(RenderBackend self, bool vsync)"""
        return _fife.RenderBackend_setVSyncEnabled(self, vsync)


    def isVSyncEnabled(self):
        """isVSyncEnabled(RenderBackend self) -> bool"""
        return _fife.RenderBackend_isVSyncEnabled(self)


    def setFrameLimitEnabled(self, limited):
        """setFrameLimitEnabled(RenderBackend self, bool limited)"""
        return _fife.RenderBackend_setFrameLimitEnabled(self, limited)


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


    def setFrameLimit(self, framelimit):
        """setFrameLimit(RenderBackend self, uint16_t framelimit)"""
        return _fife.RenderBackend_setFrameLimit(self, framelimit)


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

RenderBackend.getName = new_instancemethod(_fife.RenderBackend_getName, None, RenderBackend)
RenderBackend.captureScreen = new_instancemethod(_fife.RenderBackend_captureScreen, None, RenderBackend)
RenderBackend.getCurrentScreenMode = new_instancemethod(_fife.RenderBackend_getCurrentScreenMode, None, RenderBackend)
RenderBackend.getWidth = new_instancemethod(_fife.RenderBackend_getWidth, None, RenderBackend)
RenderBackend.getHeight = new_instancemethod(_fife.RenderBackend_getHeight, None, RenderBackend)
RenderBackend.getScreenWidth = new_instancemethod(_fife.RenderBackend_getScreenWidth, None, RenderBackend)
RenderBackend.getScreenHeight = new_instancemethod(_fife.RenderBackend_getScreenHeight, None, RenderBackend)
RenderBackend.getArea = new_instancemethod(_fife.RenderBackend_getArea, None, RenderBackend)
RenderBackend.getClipArea = new_instancemethod(_fife.RenderBackend_getClipArea, None, RenderBackend)
RenderBackend.setAlphaOptimizerEnabled = new_instancemethod(_fife.RenderBackend_setAlphaOptimizerEnabled, None, RenderBackend)
RenderBackend.isAlphaOptimizerEnabled = new_instancemethod(_fife.RenderBackend_isAlphaOptimizerEnabled, None, RenderBackend)
RenderBackend.setImageCompressingEnabled = new_instancemethod(_fife.RenderBackend_setImageCompressingEnabled, None, RenderBackend)
RenderBackend.isImageCompressingEnabled = new_instancemethod(_fife.RenderBackend_isImageCompressingEnabled, None, RenderBackend)
RenderBackend.setFramebufferEnabled = new_instancemethod(_fife.RenderBackend_setFramebufferEnabled, None, RenderBackend)
RenderBackend.isFramebufferEnabled = new_instancemethod(_fife.RenderBackend_isFramebufferEnabled, None, RenderBackend)
RenderBackend.setNPOTEnabled = new_instancemethod(_fife.RenderBackend_setNPOTEnabled, None, RenderBackend)
RenderBackend.isNPOTEnabled = new_instancemethod(_fife.RenderBackend_isNPOTEnabled, None, RenderBackend)
RenderBackend.setTextureFiltering = new_instancemethod(_fife.RenderBackend_setTextureFiltering, None, RenderBackend)
RenderBackend.getTextureFiltering = new_instancemethod(_fife.RenderBackend_getTextureFiltering, None, RenderBackend)
RenderBackend.setMipmappingEnabled = new_instancemethod(_fife.RenderBackend_setMipmappingEnabled, None, RenderBackend)
RenderBackend.isMipmappingEnabled = new_instancemethod(_fife.RenderBackend_isMipmappingEnabled, None, RenderBackend)
RenderBackend.setMonochromeEnabled = new_instancemethod(_fife.RenderBackend_setMonochromeEnabled, None, RenderBackend)
RenderBackend.isMonochromeEnabled = new_instancemethod(_fife.RenderBackend_isMonochromeEnabled, None, RenderBackend)
RenderBackend.setColorKeyEnabled = new_instancemethod(_fife.RenderBackend_setColorKeyEnabled, None, RenderBackend)
RenderBackend.isColorKeyEnabled = new_instancemethod(_fife.RenderBackend_isColorKeyEnabled, None, RenderBackend)
RenderBackend.setColorKey = new_instancemethod(_fife.RenderBackend_setColorKey, None, RenderBackend)
RenderBackend.getColorKey = new_instancemethod(_fife.RenderBackend_getColorKey, None, RenderBackend)
RenderBackend.getPixelFormat = new_instancemethod(_fife.RenderBackend_getPixelFormat, None, RenderBackend)
RenderBackend.setBackgroundColor = new_instancemethod(_fife.RenderBackend_setBackgroundColor, None, RenderBackend)
RenderBackend.resetBackgroundColor = new_instancemethod(_fife.RenderBackend_resetBackgroundColor, None, RenderBackend)
RenderBackend.setVSyncEnabled = new_instancemethod(_fife.RenderBackend_setVSyncEnabled, None, RenderBackend)
RenderBackend.isVSyncEnabled = new_instancemethod(_fife.RenderBackend_isVSyncEnabled, None, RenderBackend)
RenderBackend.setFrameLimitEnabled = new_instancemethod(_fife.RenderBackend_setFrameLimitEnabled, None, RenderBackend)
RenderBackend.isFrameLimitEnabled = new_instancemethod(_fife.RenderBackend_isFrameLimitEnabled, None, RenderBackend)
RenderBackend.setFrameLimit = new_instancemethod(_fife.RenderBackend_setFrameLimit, None, RenderBackend)
RenderBackend.getFrameLimit = new_instancemethod(_fife.RenderBackend_getFrameLimit, None, RenderBackend)
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_WAITARROW = _fife.NC_WAITARROW
NC_RESIZENWSE = _fife.NC_RESIZENWSE
NC_RESIZENESW = _fife.NC_RESIZENESW
NC_RESIZEWE = _fife.NC_RESIZEWE
NC_RESIZENS = _fife.NC_RESIZENS
NC_RESIZEALL = _fife.NC_RESIZEALL
NC_NO = _fife.NC_NO
NC_HAND = _fife.NC_HAND
class Cursor(object):
    """Proxy of C++ FIFE::Cursor class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Cursor

    def draw(self):
        """draw(Cursor self)"""
        return _fife.Cursor_draw(self)


    def set(self, *args):
        """
        set(Cursor self, uint32_t cursor_id=0)
        set(Cursor self, SharedAnimationPointer anim)
        set(Cursor self, SharedImagePointer image)
        """
        return _fife.Cursor_set(self, *args)


    def setDrag(self, *args):
        """
        setDrag(Cursor self, SharedAnimationPointer anim, int32_t drag_offset_x=0, int32_t drag_offset_y=0)
        setDrag(Cursor self, SharedImagePointer image, int32_t drag_offset_x=0, int32_t drag_offset_y=0)
        """
        return _fife.Cursor_setDrag(self, *args)


    def resetDrag(self):
        """resetDrag(Cursor self)"""
        return _fife.Cursor_resetDrag(self)


    def getType(self):
        """getType(Cursor self) -> FIFE::MouseCursorType"""
        return _fife.Cursor_getType(self)


    def getId(self):
        """getId(Cursor self) -> uint32_t"""
        return _fife.Cursor_getId(self)


    def getImage(self):
        """getImage(Cursor self) -> SharedImagePointer"""
        return _fife.Cursor_getImage(self)


    def getAnimation(self):
        """getAnimation(Cursor self) -> SharedAnimationPointer"""
        return _fife.Cursor_getAnimation(self)


    def getDragType(self):
        """getDragType(Cursor self) -> FIFE::MouseCursorType"""
        return _fife.Cursor_getDragType(self)


    def getDragImage(self):
        """getDragImage(Cursor self) -> SharedImagePointer"""
        return _fife.Cursor_getDragImage(self)


    def getDragAnimation(self):
        """getDragAnimation(Cursor self) -> SharedAnimationPointer"""
        return _fife.Cursor_getDragAnimation(self)


    def getX(self):
        """getX(Cursor self) -> uint32_t"""
        return _fife.Cursor_getX(self)


    def getY(self):
        """getY(Cursor self) -> uint32_t"""
        return _fife.Cursor_getY(self)


    def setPosition(self, x, y):
        """setPosition(Cursor self, uint32_t x, uint32_t y)"""
        return _fife.Cursor_setPosition(self, x, y)


    def getPosition(self):
        """getPosition(Cursor self)"""
        return _fife.Cursor_getPosition(self)


    def setNativeImageCursorEnabled(self, native_image_cursor_enabled):
        """setNativeImageCursorEnabled(Cursor self, bool native_image_cursor_enabled)"""
        return _fife.Cursor_setNativeImageCursorEnabled(self, native_image_cursor_enabled)


    def isNativeImageCursorEnabled(self):
        """isNativeImageCursorEnabled(Cursor self) -> bool"""
        return _fife.Cursor_isNativeImageCursorEnabled(self)

Cursor.draw = new_instancemethod(_fife.Cursor_draw, None, Cursor)
Cursor.set = new_instancemethod(_fife.Cursor_set, None, Cursor)
Cursor.setDrag = new_instancemethod(_fife.Cursor_setDrag, None, Cursor)
Cursor.resetDrag = new_instancemethod(_fife.Cursor_resetDrag, None, Cursor)
Cursor.getType = new_instancemethod(_fife.Cursor_getType, None, Cursor)
Cursor.getId = new_instancemethod(_fife.Cursor_getId, None, Cursor)
Cursor.getImage = new_instancemethod(_fife.Cursor_getImage, None, Cursor)
Cursor.getAnimation = new_instancemethod(_fife.Cursor_getAnimation, None, Cursor)
Cursor.getDragType = new_instancemethod(_fife.Cursor_getDragType, None, Cursor)
Cursor.getDragImage = new_instancemethod(_fife.Cursor_getDragImage, None, Cursor)
Cursor.getDragAnimation = new_instancemethod(_fife.Cursor_getDragAnimation, None, Cursor)
Cursor.getX = new_instancemethod(_fife.Cursor_getX, None, Cursor)
Cursor.getY = new_instancemethod(_fife.Cursor_getY, None, Cursor)
Cursor.setPosition = new_instancemethod(_fife.Cursor_setPosition, None, Cursor)
Cursor.getPosition = new_instancemethod(_fife.Cursor_getPosition, None, Cursor)
Cursor.setNativeImageCursorEnabled = new_instancemethod(_fife.Cursor_setNativeImageCursorEnabled, None, Cursor)
Cursor.isNativeImageCursorEnabled = new_instancemethod(_fife.Cursor_isNativeImageCursorEnabled, None, Cursor)
Cursor_swigregister = _fife.Cursor_swigregister
Cursor_swigregister(Cursor)

class ScreenMode(object):
    """Proxy of C++ FIFE::ScreenMode class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ScreenMode

    def getWidth(self):
        """getWidth(ScreenMode self) -> uint16_t"""
        return _fife.ScreenMode_getWidth(self)


    def getHeight(self):
        """getHeight(ScreenMode self) -> uint16_t"""
        return _fife.ScreenMode_getHeight(self)


    def getBPP(self):
        """getBPP(ScreenMode self) -> uint16_t"""
        return _fife.ScreenMode_getBPP(self)


    def getRefreshRate(self):
        """getRefreshRate(ScreenMode self) -> uint16_t"""
        return _fife.ScreenMode_getRefreshRate(self)


    def getSDLFlags(self):
        """getSDLFlags(ScreenMode self) -> uint32_t"""
        return _fife.ScreenMode_getSDLFlags(self)


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


    def isOpenGL(self):
        """isOpenGL(ScreenMode self) -> bool"""
        return _fife.ScreenMode_isOpenGL(self)


    def isSDL(self):
        """isSDL(ScreenMode self) -> bool"""
        return _fife.ScreenMode_isSDL(self)


    def getDisplay(self):
        """getDisplay(ScreenMode self) -> uint8_t"""
        return _fife.ScreenMode_getDisplay(self)


    def getRenderDriverName(self):
        """getRenderDriverName(ScreenMode self) -> std::string const &"""
        return _fife.ScreenMode_getRenderDriverName(self)


    def __init__(self):
        """__init__(FIFE::ScreenMode self) -> ScreenMode"""
        _fife.ScreenMode_swiginit(self, _fife.new_ScreenMode())
ScreenMode.getWidth = new_instancemethod(_fife.ScreenMode_getWidth, None, ScreenMode)
ScreenMode.getHeight = new_instancemethod(_fife.ScreenMode_getHeight, None, ScreenMode)
ScreenMode.getBPP = new_instancemethod(_fife.ScreenMode_getBPP, None, ScreenMode)
ScreenMode.getRefreshRate = new_instancemethod(_fife.ScreenMode_getRefreshRate, None, ScreenMode)
ScreenMode.getSDLFlags = new_instancemethod(_fife.ScreenMode_getSDLFlags, None, ScreenMode)
ScreenMode.isFullScreen = new_instancemethod(_fife.ScreenMode_isFullScreen, None, ScreenMode)
ScreenMode.isOpenGL = new_instancemethod(_fife.ScreenMode_isOpenGL, None, ScreenMode)
ScreenMode.isSDL = new_instancemethod(_fife.ScreenMode_isSDL, None, ScreenMode)
ScreenMode.getDisplay = new_instancemethod(_fife.ScreenMode_getDisplay, None, ScreenMode)
ScreenMode.getRenderDriverName = new_instancemethod(_fife.ScreenMode_getRenderDriverName, None, ScreenMode)
ScreenMode_swigregister = _fife.ScreenMode_swigregister
ScreenMode_swigregister(ScreenMode)
cvar = _fife.cvar
ScreenMode.WINDOWED_OPENGL = _fife.cvar.ScreenMode_WINDOWED_OPENGL
ScreenMode.FULLSCREEN_OPENGL = _fife.cvar.ScreenMode_FULLSCREEN_OPENGL
ScreenMode.WINDOWED_SDL = _fife.cvar.ScreenMode_WINDOWED_SDL
ScreenMode.FULLSCREEN_SDL = _fife.cvar.ScreenMode_FULLSCREEN_SDL

class DeviceCaps(object):
    """Proxy of C++ FIFE::DeviceCaps class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::DeviceCaps self) -> DeviceCaps"""
        _fife.DeviceCaps_swiginit(self, _fife.new_DeviceCaps())
    __swig_destroy__ = _fife.delete_DeviceCaps

    def fillDeviceCaps(self):
        """fillDeviceCaps(DeviceCaps self)"""
        return _fife.DeviceCaps_fillDeviceCaps(self)


    def getSupportedScreenModes(self):
        """getSupportedScreenModes(DeviceCaps self) -> ScreenModeVector"""
        return _fife.DeviceCaps_getSupportedScreenModes(self)


    def getNearestScreenMode(self, *args):
        """
        getNearestScreenMode(DeviceCaps self, uint16_t width, uint16_t height, uint16_t bpp, std::string const & renderer, bool fs) -> ScreenMode
        getNearestScreenMode(DeviceCaps self, uint16_t width, uint16_t height, uint16_t bpp, std::string const & renderer, bool fs, uint16_t refresh, uint8_t display=0) -> ScreenMode
        """
        return _fife.DeviceCaps_getNearestScreenMode(self, *args)


    def getVideoDriverName(self):
        """getVideoDriverName(DeviceCaps self) -> std::string"""
        return _fife.DeviceCaps_getVideoDriverName(self)


    def getAvailableVideoDrivers(self):
        """getAvailableVideoDrivers(DeviceCaps self) -> StringVector"""
        return _fife.DeviceCaps_getAvailableVideoDrivers(self)


    def getRenderDriverName(self):
        """getRenderDriverName(DeviceCaps self) -> std::string"""
        return _fife.DeviceCaps_getRenderDriverName(self)


    def setRenderDriverName(self, driver):
        """setRenderDriverName(DeviceCaps self, std::string const & driver)"""
        return _fife.DeviceCaps_setRenderDriverName(self, driver)


    def getAvailableRenderDrivers(self):
        """getAvailableRenderDrivers(DeviceCaps self) -> StringVector"""
        return _fife.DeviceCaps_getAvailableRenderDrivers(self)


    def getDisplayCount(self):
        """getDisplayCount(DeviceCaps self) -> uint8_t"""
        return _fife.DeviceCaps_getDisplayCount(self)


    def getDisplayName(self, display=0):
        """getDisplayName(DeviceCaps self, uint8_t display=0) -> std::string"""
        return _fife.DeviceCaps_getDisplayName(self, display)


    def getDesktopFormat(self, display=0):
        """getDesktopFormat(DeviceCaps self, uint8_t display=0) -> uint32_t"""
        return _fife.DeviceCaps_getDesktopFormat(self, display)


    def getDesktopRefreshRate(self, display=0):
        """getDesktopRefreshRate(DeviceCaps self, uint8_t display=0) -> int32_t"""
        return _fife.DeviceCaps_getDesktopRefreshRate(self, display)


    def getDesktopWidth(self, display=0):
        """getDesktopWidth(DeviceCaps self, uint8_t display=0) -> int32_t"""
        return _fife.DeviceCaps_getDesktopWidth(self, display)


    def getDesktopHeight(self, display=0):
        """getDesktopHeight(DeviceCaps self, uint8_t display=0) -> int32_t"""
        return _fife.DeviceCaps_getDesktopHeight(self, display)


    def getDisplayBounds(self, display=0):
        """getDisplayBounds(DeviceCaps self, uint8_t display=0) -> Rect"""
        return _fife.DeviceCaps_getDisplayBounds(self, display)

DeviceCaps.fillDeviceCaps = new_instancemethod(_fife.DeviceCaps_fillDeviceCaps, None, DeviceCaps)
DeviceCaps.getSupportedScreenModes = new_instancemethod(_fife.DeviceCaps_getSupportedScreenModes, None, DeviceCaps)
DeviceCaps.getNearestScreenMode = new_instancemethod(_fife.DeviceCaps_getNearestScreenMode, None, DeviceCaps)
DeviceCaps.getVideoDriverName = new_instancemethod(_fife.DeviceCaps_getVideoDriverName, None, DeviceCaps)
DeviceCaps.getAvailableVideoDrivers = new_instancemethod(_fife.DeviceCaps_getAvailableVideoDrivers, None, DeviceCaps)
DeviceCaps.getRenderDriverName = new_instancemethod(_fife.DeviceCaps_getRenderDriverName, None, DeviceCaps)
DeviceCaps.setRenderDriverName = new_instancemethod(_fife.DeviceCaps_setRenderDriverName, None, DeviceCaps)
DeviceCaps.getAvailableRenderDrivers = new_instancemethod(_fife.DeviceCaps_getAvailableRenderDrivers, None, DeviceCaps)
DeviceCaps.getDisplayCount = new_instancemethod(_fife.DeviceCaps_getDisplayCount, None, DeviceCaps)
DeviceCaps.getDisplayName = new_instancemethod(_fife.DeviceCaps_getDisplayName, None, DeviceCaps)
DeviceCaps.getDesktopFormat = new_instancemethod(_fife.DeviceCaps_getDesktopFormat, None, DeviceCaps)
DeviceCaps.getDesktopRefreshRate = new_instancemethod(_fife.DeviceCaps_getDesktopRefreshRate, None, DeviceCaps)
DeviceCaps.getDesktopWidth = new_instancemethod(_fife.DeviceCaps_getDesktopWidth, None, DeviceCaps)
DeviceCaps.getDesktopHeight = new_instancemethod(_fife.DeviceCaps_getDesktopHeight, None, DeviceCaps)
DeviceCaps.getDisplayBounds = new_instancemethod(_fife.DeviceCaps_getDisplayBounds, None, DeviceCaps)
DeviceCaps_swigregister = _fife.DeviceCaps_swigregister
DeviceCaps_swigregister(DeviceCaps)

class AtlasBlock(object):
    """Proxy of C++ FIFE::AtlasBlock class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    page = _swig_property(_fife.AtlasBlock_page_get, _fife.AtlasBlock_page_set)
    left = _swig_property(_fife.AtlasBlock_left_get, _fife.AtlasBlock_left_set)
    right = _swig_property(_fife.AtlasBlock_right_get, _fife.AtlasBlock_right_set)
    top = _swig_property(_fife.AtlasBlock_top_get, _fife.AtlasBlock_top_set)
    bottom = _swig_property(_fife.AtlasBlock_bottom_get, _fife.AtlasBlock_bottom_set)

    def __init__(self, *args):
        """
        __init__(FIFE::AtlasBlock self, Rect rect, uint32_t page) -> AtlasBlock
        __init__(FIFE::AtlasBlock self) -> AtlasBlock
        """
        _fife.AtlasBlock_swiginit(self, _fife.new_AtlasBlock(*args))

    def setTrivial(self):
        """setTrivial(AtlasBlock self)"""
        return _fife.AtlasBlock_setTrivial(self)


    def isTrivial(self):
        """isTrivial(AtlasBlock self) -> bool"""
        return _fife.AtlasBlock_isTrivial(self)


    def getWidth(self):
        """getWidth(AtlasBlock self) -> uint32_t"""
        return _fife.AtlasBlock_getWidth(self)


    def getHeight(self):
        """getHeight(AtlasBlock self) -> uint32_t"""
        return _fife.AtlasBlock_getHeight(self)


    def intersects(self, rect):
        """intersects(AtlasBlock self, AtlasBlock rect) -> AtlasBlock"""
        return _fife.AtlasBlock_intersects(self, rect)


    def merge(self, rect):
        """merge(AtlasBlock self, AtlasBlock rect)"""
        return _fife.AtlasBlock_merge(self, rect)

    __swig_destroy__ = _fife.delete_AtlasBlock
AtlasBlock.setTrivial = new_instancemethod(_fife.AtlasBlock_setTrivial, None, AtlasBlock)
AtlasBlock.isTrivial = new_instancemethod(_fife.AtlasBlock_isTrivial, None, AtlasBlock)
AtlasBlock.getWidth = new_instancemethod(_fife.AtlasBlock_getWidth, None, AtlasBlock)
AtlasBlock.getHeight = new_instancemethod(_fife.AtlasBlock_getHeight, None, AtlasBlock)
AtlasBlock.intersects = new_instancemethod(_fife.AtlasBlock_intersects, None, AtlasBlock)
AtlasBlock.merge = new_instancemethod(_fife.AtlasBlock_merge, None, AtlasBlock)
AtlasBlock_swigregister = _fife.AtlasBlock_swigregister
AtlasBlock_swigregister(AtlasBlock)

class AtlasBook(object):
    """Proxy of C++ FIFE::AtlasBook class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, pageWidth, pageHeight, pixelSize=4):
        """__init__(FIFE::AtlasBook self, uint32_t pageWidth, uint32_t pageHeight, uint32_t pixelSize=4) -> AtlasBook"""
        _fife.AtlasBook_swiginit(self, _fife.new_AtlasBook(pageWidth, pageHeight, pixelSize))

    def getBlock(self, width, height):
        """getBlock(AtlasBook self, uint32_t width, uint32_t height) -> AtlasBlock"""
        return _fife.AtlasBook_getBlock(self, width, height)


    def shrink(self, pot):
        """shrink(AtlasBook self, bool pot)"""
        return _fife.AtlasBook_shrink(self, pot)


    def getPageWidth(self, index):
        """getPageWidth(AtlasBook self, uint32_t index) -> uint32_t"""
        return _fife.AtlasBook_getPageWidth(self, index)


    def getPageHeight(self, index):
        """getPageHeight(AtlasBook self, uint32_t index) -> uint32_t"""
        return _fife.AtlasBook_getPageHeight(self, index)

    __swig_destroy__ = _fife.delete_AtlasBook
AtlasBook.getBlock = new_instancemethod(_fife.AtlasBook_getBlock, None, AtlasBook)
AtlasBook.shrink = new_instancemethod(_fife.AtlasBook_shrink, None, AtlasBook)
AtlasBook.getPageWidth = new_instancemethod(_fife.AtlasBook_getPageWidth, None, AtlasBook)
AtlasBook.getPageHeight = new_instancemethod(_fife.AtlasBook_getPageHeight, None, AtlasBook)
AtlasBook_swigregister = _fife.AtlasBook_swigregister
AtlasBook_swigregister(AtlasBook)

class Color(object):
    """Proxy of C++ FIFE::Color class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, r=0, g=0, b=0, alpha=255):
        """__init__(FIFE::Color self, uint8_t r=0, uint8_t g=0, uint8_t b=0, uint8_t alpha=255) -> Color"""
        _fife.Color_swiginit(self, _fife.new_Color(r, g, b, alpha))
    __swig_destroy__ = _fife.delete_Color

    def set(self, r, g, b, alpha):
        """set(Color self, uint8_t r, uint8_t g, uint8_t b, uint8_t alpha)"""
        return _fife.Color_set(self, r, g, b, alpha)

    r = _swig_property(_fife.Color_r_get, _fife.Color_r_set)
    g = _swig_property(_fife.Color_g_get, _fife.Color_g_set)
    b = _swig_property(_fife.Color_b_get, _fife.Color_b_set)
    a = _swig_property(_fife.Color_a_get, _fife.Color_a_set)
Color.set = new_instancemethod(_fife.Color_set, None, Color)
Color_swigregister = _fife.Color_swigregister
Color_swigregister(Color)

class IAnimationLoader(object):
    """Proxy of C++ FIFE::IAnimationLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAnimationLoader

    def isLoadable(self, filename):
        """isLoadable(IAnimationLoader self, std::string const & filename) -> bool"""
        return _fife.IAnimationLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(IAnimationLoader self, std::string const & filename) -> SharedAnimationPointer"""
        return _fife.IAnimationLoader_load(self, filename)


    def loadMultiple(self, filename):
        """loadMultiple(IAnimationLoader self, std::string const & filename) -> std::vector< FIFE::AnimationPtr,std::allocator< FIFE::AnimationPtr > >"""
        return _fife.IAnimationLoader_loadMultiple(self, filename)


    def __init__(self):
        """__init__(FIFE::IAnimationLoader self) -> IAnimationLoader"""
        if self.__class__ == IAnimationLoader:
            _self = None
        else:
            _self = self
        _fife.IAnimationLoader_swiginit(self, _fife.new_IAnimationLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationLoader(self)
        return weakref_proxy(self)
IAnimationLoader.isLoadable = new_instancemethod(_fife.IAnimationLoader_isLoadable, None, IAnimationLoader)
IAnimationLoader.load = new_instancemethod(_fife.IAnimationLoader_load, None, IAnimationLoader)
IAnimationLoader.loadMultiple = new_instancemethod(_fife.IAnimationLoader_loadMultiple, None, IAnimationLoader)
IAnimationLoader_swigregister = _fife.IAnimationLoader_swigregister
IAnimationLoader_swigregister(IAnimationLoader)

class AnimationLoader(IAnimationLoader):
    """Proxy of C++ FIFE::AnimationLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, vfs, imageManager, animationManager):
        """__init__(FIFE::AnimationLoader self, VFS vfs, ImageManager imageManager, AnimationManager animationManager) -> AnimationLoader"""
        _fife.AnimationLoader_swiginit(self, _fife.new_AnimationLoader(vfs, imageManager, animationManager))

    def isLoadable(self, filename):
        """isLoadable(AnimationLoader self, std::string const & filename) -> bool"""
        return _fife.AnimationLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(AnimationLoader self, std::string const & filename) -> SharedAnimationPointer"""
        return _fife.AnimationLoader_load(self, filename)


    def loadMultiple(self, filename):
        """loadMultiple(AnimationLoader self, std::string const & filename) -> std::vector< FIFE::AnimationPtr,std::allocator< FIFE::AnimationPtr > >"""
        return _fife.AnimationLoader_loadMultiple(self, filename)

    __swig_destroy__ = _fife.delete_AnimationLoader
AnimationLoader.isLoadable = new_instancemethod(_fife.AnimationLoader_isLoadable, None, AnimationLoader)
AnimationLoader.load = new_instancemethod(_fife.AnimationLoader_load, None, AnimationLoader)
AnimationLoader.loadMultiple = new_instancemethod(_fife.AnimationLoader_loadMultiple, None, AnimationLoader)
AnimationLoader_swigregister = _fife.AnimationLoader_swigregister
AnimationLoader_swigregister(AnimationLoader)

class IAtlasLoader(object):
    """Proxy of C++ FIFE::IAtlasLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAtlasLoader

    def isLoadable(self, filename):
        """isLoadable(IAtlasLoader self, std::string const & filename) -> bool"""
        return _fife.IAtlasLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(IAtlasLoader self, std::string const & filename) -> FIFE::AtlasPtr"""
        return _fife.IAtlasLoader_load(self, filename)


    def loadMultiple(self, filename):
        """loadMultiple(IAtlasLoader self, std::string const & filename) -> std::vector< FIFE::AtlasPtr,std::allocator< FIFE::AtlasPtr > >"""
        return _fife.IAtlasLoader_loadMultiple(self, filename)


    def __init__(self):
        """__init__(FIFE::IAtlasLoader self) -> IAtlasLoader"""
        if self.__class__ == IAtlasLoader:
            _self = None
        else:
            _self = self
        _fife.IAtlasLoader_swiginit(self, _fife.new_IAtlasLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasLoader(self)
        return weakref_proxy(self)
IAtlasLoader.isLoadable = new_instancemethod(_fife.IAtlasLoader_isLoadable, None, IAtlasLoader)
IAtlasLoader.load = new_instancemethod(_fife.IAtlasLoader_load, None, IAtlasLoader)
IAtlasLoader.loadMultiple = new_instancemethod(_fife.IAtlasLoader_loadMultiple, None, IAtlasLoader)
IAtlasLoader_swigregister = _fife.IAtlasLoader_swigregister
IAtlasLoader_swigregister(IAtlasLoader)

class AtlasData(object):
    """Proxy of C++ FIFE::AtlasData class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    rect = _swig_property(_fife.AtlasData_rect_get, _fife.AtlasData_rect_set)
    image = _swig_property(_fife.AtlasData_image_get, _fife.AtlasData_image_set)

    def __init__(self):
        """__init__(FIFE::AtlasData self) -> AtlasData"""
        _fife.AtlasData_swiginit(self, _fife.new_AtlasData())
    __swig_destroy__ = _fife.delete_AtlasData
AtlasData_swigregister = _fife.AtlasData_swigregister
AtlasData_swigregister(AtlasData)

class Atlas(object):
    """Proxy of C++ FIFE::Atlas class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, name):
        """__init__(FIFE::Atlas self, std::string const & name) -> Atlas"""
        _fife.Atlas_swiginit(self, _fife.new_Atlas(name))
    __swig_destroy__ = _fife.delete_Atlas

    def getImageCount(self):
        """getImageCount(Atlas self) -> size_t"""
        return _fife.Atlas_getImageCount(self)


    def getPackedImage(self):
        """getPackedImage(Atlas self) -> SharedImagePointer"""
        return _fife.Atlas_getPackedImage(self)


    def getImage(self, *args):
        """
        getImage(Atlas self, std::string const & id) -> SharedImagePointer
        getImage(Atlas self, uint32_t index) -> SharedImagePointer
        """
        return _fife.Atlas_getImage(self, *args)


    def addImage(self, imagename, data):
        """addImage(Atlas self, std::string const & imagename, AtlasData data) -> bool"""
        return _fife.Atlas_addImage(self, imagename, data)


    def setPackedImage(self, image):
        """setPackedImage(Atlas self, SharedImagePointer image)"""
        return _fife.Atlas_setPackedImage(self, image)


    def getName(self):
        """getName(Atlas self) -> std::string const &"""
        return _fife.Atlas_getName(self)

Atlas.getImageCount = new_instancemethod(_fife.Atlas_getImageCount, None, Atlas)
Atlas.getPackedImage = new_instancemethod(_fife.Atlas_getPackedImage, None, Atlas)
Atlas.getImage = new_instancemethod(_fife.Atlas_getImage, None, Atlas)
Atlas.addImage = new_instancemethod(_fife.Atlas_addImage, None, Atlas)
Atlas.setPackedImage = new_instancemethod(_fife.Atlas_setPackedImage, None, Atlas)
Atlas.getName = new_instancemethod(_fife.Atlas_getName, None, Atlas)
Atlas_swigregister = _fife.Atlas_swigregister
Atlas_swigregister(Atlas)

class AtlasLoader(IAtlasLoader):
    """Proxy of C++ FIFE::AtlasLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, model, vfs, imageManager, animationManager):
        """__init__(FIFE::AtlasLoader self, Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager) -> AtlasLoader"""
        _fife.AtlasLoader_swiginit(self, _fife.new_AtlasLoader(model, vfs, imageManager, animationManager))
    __swig_destroy__ = _fife.delete_AtlasLoader

    def isLoadable(self, filename):
        """isLoadable(AtlasLoader self, std::string const & filename) -> bool"""
        return _fife.AtlasLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(AtlasLoader self, std::string const & filename) -> FIFE::AtlasPtr"""
        return _fife.AtlasLoader_load(self, filename)


    def loadMultiple(self, filename):
        """loadMultiple(AtlasLoader self, std::string const & filename) -> std::vector< FIFE::AtlasPtr,std::allocator< FIFE::AtlasPtr > >"""
        return _fife.AtlasLoader_loadMultiple(self, filename)

AtlasLoader.isLoadable = new_instancemethod(_fife.AtlasLoader_isLoadable, None, AtlasLoader)
AtlasLoader.load = new_instancemethod(_fife.AtlasLoader_load, None, AtlasLoader)
AtlasLoader.loadMultiple = new_instancemethod(_fife.AtlasLoader_loadMultiple, None, AtlasLoader)
AtlasLoader_swigregister = _fife.AtlasLoader_swigregister
AtlasLoader_swigregister(AtlasLoader)


def createDefaultAtlasLoader(model, vfs, imageManager, animationManager):
    """createDefaultAtlasLoader(Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager) -> AtlasLoader"""
    return _fife.createDefaultAtlasLoader(model, vfs, imageManager, animationManager)
class IMapLoader(object):
    """Proxy of C++ FIFE::IMapLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IMapLoader

    def setObjectLoader(self, objectLoader):
        """setObjectLoader(IMapLoader self, FIFE::ObjectLoaderPtr const & objectLoader)"""
        return _fife.IMapLoader_setObjectLoader(self, objectLoader)


    def setAnimationLoader(self, animationLoader):
        """setAnimationLoader(IMapLoader self, FIFE::AnimationLoaderPtr const & animationLoader)"""
        return _fife.IMapLoader_setAnimationLoader(self, animationLoader)


    def setAtlasLoader(self, atlasLoader):
        """setAtlasLoader(IMapLoader self, FIFE::AtlasLoaderPtr const & atlasLoader)"""
        return _fife.IMapLoader_setAtlasLoader(self, atlasLoader)


    def isLoadable(self, filename):
        """isLoadable(IMapLoader self, std::string const & filename) -> bool"""
        return _fife.IMapLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(IMapLoader self, std::string const & filename) -> Map"""
        return _fife.IMapLoader_load(self, filename)


    def __init__(self):
        """__init__(FIFE::IMapLoader self) -> IMapLoader"""
        if self.__class__ == IMapLoader:
            _self = None
        else:
            _self = self
        _fife.IMapLoader_swiginit(self, _fife.new_IMapLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapLoader(self)
        return weakref_proxy(self)
IMapLoader.setObjectLoader = new_instancemethod(_fife.IMapLoader_setObjectLoader, None, IMapLoader)
IMapLoader.setAnimationLoader = new_instancemethod(_fife.IMapLoader_setAnimationLoader, None, IMapLoader)
IMapLoader.setAtlasLoader = new_instancemethod(_fife.IMapLoader_setAtlasLoader, None, IMapLoader)
IMapLoader.isLoadable = new_instancemethod(_fife.IMapLoader_isLoadable, None, IMapLoader)
IMapLoader.load = new_instancemethod(_fife.IMapLoader_load, None, IMapLoader)
IMapLoader_swigregister = _fife.IMapLoader_swigregister
IMapLoader_swigregister(IMapLoader)

class IObjectLoader(object):
    """Proxy of C++ FIFE::IObjectLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IObjectLoader

    def setAnimationLoader(self, animationLoader):
        """setAnimationLoader(IObjectLoader self, FIFE::AnimationLoaderPtr const & animationLoader)"""
        return _fife.IObjectLoader_setAnimationLoader(self, animationLoader)


    def getAnimationLoader(self):
        """getAnimationLoader(IObjectLoader self) -> FIFE::AnimationLoaderPtr"""
        return _fife.IObjectLoader_getAnimationLoader(self)


    def setAtlasLoader(self, atlasLoader):
        """setAtlasLoader(IObjectLoader self, FIFE::AtlasLoaderPtr const & atlasLoader)"""
        return _fife.IObjectLoader_setAtlasLoader(self, atlasLoader)


    def getAtlasLoader(self):
        """getAtlasLoader(IObjectLoader self) -> FIFE::AtlasLoaderPtr"""
        return _fife.IObjectLoader_getAtlasLoader(self)


    def isLoadable(self, filename):
        """isLoadable(IObjectLoader self, std::string const & filename) -> bool"""
        return _fife.IObjectLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(IObjectLoader self, std::string const & filename)"""
        return _fife.IObjectLoader_load(self, filename)


    def __init__(self):
        """__init__(FIFE::IObjectLoader self) -> IObjectLoader"""
        if self.__class__ == IObjectLoader:
            _self = None
        else:
            _self = self
        _fife.IObjectLoader_swiginit(self, _fife.new_IObjectLoader(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectLoader(self)
        return weakref_proxy(self)
IObjectLoader.setAnimationLoader = new_instancemethod(_fife.IObjectLoader_setAnimationLoader, None, IObjectLoader)
IObjectLoader.getAnimationLoader = new_instancemethod(_fife.IObjectLoader_getAnimationLoader, None, IObjectLoader)
IObjectLoader.setAtlasLoader = new_instancemethod(_fife.IObjectLoader_setAtlasLoader, None, IObjectLoader)
IObjectLoader.getAtlasLoader = new_instancemethod(_fife.IObjectLoader_getAtlasLoader, None, IObjectLoader)
IObjectLoader.isLoadable = new_instancemethod(_fife.IObjectLoader_isLoadable, None, IObjectLoader)
IObjectLoader.load = new_instancemethod(_fife.IObjectLoader_load, None, IObjectLoader)
IObjectLoader_swigregister = _fife.IObjectLoader_swigregister
IObjectLoader_swigregister(IObjectLoader)

class ObjectLoader(IObjectLoader):
    """Proxy of C++ FIFE::ObjectLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        """__init__(FIFE::ObjectLoader self, Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager, FIFE::AnimationLoaderPtr const & animationLoader, FIFE::AtlasLoaderPtr const & atlasLoader) -> ObjectLoader"""
        _fife.ObjectLoader_swiginit(self, _fife.new_ObjectLoader(*args, **kwargs))
    __swig_destroy__ = _fife.delete_ObjectLoader

    def setAnimationLoader(self, animationLoader):
        """setAnimationLoader(ObjectLoader self, FIFE::AnimationLoaderPtr const & animationLoader)"""
        return _fife.ObjectLoader_setAnimationLoader(self, animationLoader)


    def getAnimationLoader(self):
        """getAnimationLoader(ObjectLoader self) -> FIFE::AnimationLoaderPtr"""
        return _fife.ObjectLoader_getAnimationLoader(self)


    def setAtlasLoader(self, atlasLoader):
        """setAtlasLoader(ObjectLoader self, FIFE::AtlasLoaderPtr const & atlasLoader)"""
        return _fife.ObjectLoader_setAtlasLoader(self, atlasLoader)


    def getAtlasLoader(self):
        """getAtlasLoader(ObjectLoader self) -> FIFE::AtlasLoaderPtr"""
        return _fife.ObjectLoader_getAtlasLoader(self)


    def isLoadable(self, filename):
        """isLoadable(ObjectLoader self, std::string const & filename) -> bool"""
        return _fife.ObjectLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(ObjectLoader self, std::string const & filename)"""
        return _fife.ObjectLoader_load(self, filename)


    def loadImportFile(self, *args, **kwargs):
        """loadImportFile(ObjectLoader self, std::string const & file, std::string const & directory)"""
        return _fife.ObjectLoader_loadImportFile(self, *args, **kwargs)


    def loadImportDirectory(self, directory):
        """loadImportDirectory(ObjectLoader self, std::string const & directory)"""
        return _fife.ObjectLoader_loadImportDirectory(self, directory)

ObjectLoader.setAnimationLoader = new_instancemethod(_fife.ObjectLoader_setAnimationLoader, None, ObjectLoader)
ObjectLoader.getAnimationLoader = new_instancemethod(_fife.ObjectLoader_getAnimationLoader, None, ObjectLoader)
ObjectLoader.setAtlasLoader = new_instancemethod(_fife.ObjectLoader_setAtlasLoader, None, ObjectLoader)
ObjectLoader.getAtlasLoader = new_instancemethod(_fife.ObjectLoader_getAtlasLoader, None, ObjectLoader)
ObjectLoader.isLoadable = new_instancemethod(_fife.ObjectLoader_isLoadable, None, ObjectLoader)
ObjectLoader.load = new_instancemethod(_fife.ObjectLoader_load, None, ObjectLoader)
ObjectLoader.loadImportFile = new_instancemethod(_fife.ObjectLoader_loadImportFile, None, ObjectLoader)
ObjectLoader.loadImportDirectory = new_instancemethod(_fife.ObjectLoader_loadImportDirectory, None, ObjectLoader)
ObjectLoader_swigregister = _fife.ObjectLoader_swigregister
ObjectLoader_swigregister(ObjectLoader)

class MapLoader(IMapLoader):
    """Proxy of C++ FIFE::MapLoader class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, model, vfs, imageManager, renderBackend):
        """__init__(FIFE::MapLoader self, Model model, VFS vfs, ImageManager imageManager, RenderBackend renderBackend) -> MapLoader"""
        _fife.MapLoader_swiginit(self, _fife.new_MapLoader(model, vfs, imageManager, renderBackend))
    __swig_destroy__ = _fife.delete_MapLoader

    def setObjectLoader(self, objectLoader):
        """setObjectLoader(MapLoader self, FIFE::ObjectLoaderPtr const & objectLoader)"""
        return _fife.MapLoader_setObjectLoader(self, objectLoader)


    def getObjectLoader(self):
        """getObjectLoader(MapLoader self) -> FIFE::ObjectLoaderPtr"""
        return _fife.MapLoader_getObjectLoader(self)


    def setAnimationLoader(self, animationLoader):
        """setAnimationLoader(MapLoader self, FIFE::AnimationLoaderPtr const & animationLoader)"""
        return _fife.MapLoader_setAnimationLoader(self, animationLoader)


    def getAnimationLoader(self):
        """getAnimationLoader(MapLoader self) -> FIFE::AnimationLoaderPtr"""
        return _fife.MapLoader_getAnimationLoader(self)


    def setAtlasLoader(self, atlasLoader):
        """setAtlasLoader(MapLoader self, FIFE::AtlasLoaderPtr const & atlasLoader)"""
        return _fife.MapLoader_setAtlasLoader(self, atlasLoader)


    def getAtlasLoader(self):
        """getAtlasLoader(MapLoader self) -> FIFE::AtlasLoaderPtr"""
        return _fife.MapLoader_getAtlasLoader(self)


    def isLoadable(self, filename):
        """isLoadable(MapLoader self, std::string const & filename) -> bool"""
        return _fife.MapLoader_isLoadable(self, filename)


    def load(self, filename):
        """load(MapLoader self, std::string const & filename) -> Map"""
        return _fife.MapLoader_load(self, filename)


    def loadImportFile(self, *args, **kwargs):
        """loadImportFile(MapLoader self, std::string const & file, std::string const & directory)"""
        return _fife.MapLoader_loadImportFile(self, *args, **kwargs)


    def loadImportDirectory(self, directory):
        """loadImportDirectory(MapLoader self, std::string const & directory)"""
        return _fife.MapLoader_loadImportDirectory(self, directory)


    def addPercentDoneListener(self, listener):
        """addPercentDoneListener(MapLoader self, PercentDoneListener listener)"""
        return _fife.MapLoader_addPercentDoneListener(self, listener)


    def getLoaderName(self):
        """getLoaderName(MapLoader self) -> std::string const &"""
        return _fife.MapLoader_getLoaderName(self)

MapLoader.setObjectLoader = new_instancemethod(_fife.MapLoader_setObjectLoader, None, MapLoader)
MapLoader.getObjectLoader = new_instancemethod(_fife.MapLoader_getObjectLoader, None, MapLoader)
MapLoader.setAnimationLoader = new_instancemethod(_fife.MapLoader_setAnimationLoader, None, MapLoader)
MapLoader.getAnimationLoader = new_instancemethod(_fife.MapLoader_getAnimationLoader, None, MapLoader)
MapLoader.setAtlasLoader = new_instancemethod(_fife.MapLoader_setAtlasLoader, None, MapLoader)
MapLoader.getAtlasLoader = new_instancemethod(_fife.MapLoader_getAtlasLoader, None, MapLoader)
MapLoader.isLoadable = new_instancemethod(_fife.MapLoader_isLoadable, None, MapLoader)
MapLoader.load = new_instancemethod(_fife.MapLoader_load, None, MapLoader)
MapLoader.loadImportFile = new_instancemethod(_fife.MapLoader_loadImportFile, None, MapLoader)
MapLoader.loadImportDirectory = new_instancemethod(_fife.MapLoader_loadImportDirectory, None, MapLoader)
MapLoader.addPercentDoneListener = new_instancemethod(_fife.MapLoader_addPercentDoneListener, None, MapLoader)
MapLoader.getLoaderName = new_instancemethod(_fife.MapLoader_getLoaderName, None, MapLoader)
MapLoader_swigregister = _fife.MapLoader_swigregister
MapLoader_swigregister(MapLoader)


def createDefaultMapLoader(model, vfs, imageManager, renderBackend):
    """createDefaultMapLoader(Model model, VFS vfs, ImageManager imageManager, RenderBackend renderBackend) -> MapLoader"""
    return _fife.createDefaultMapLoader(model, vfs, imageManager, renderBackend)
class PercentDoneListener(object):
    """Proxy of C++ FIFE::PercentDoneListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_PercentDoneListener

    def OnEvent(self, percentDone):
        """OnEvent(PercentDoneListener self, unsigned int percentDone)"""
        return _fife.PercentDoneListener_OnEvent(self, percentDone)


    def __init__(self):
        """__init__(FIFE::PercentDoneListener self) -> PercentDoneListener"""
        if self.__class__ == PercentDoneListener:
            _self = None
        else:
            _self = self
        _fife.PercentDoneListener_swiginit(self, _fife.new_PercentDoneListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_PercentDoneListener(self)
        return weakref_proxy(self)
PercentDoneListener.OnEvent = new_instancemethod(_fife.PercentDoneListener_OnEvent, None, PercentDoneListener)
PercentDoneListener_swigregister = _fife.PercentDoneListener_swigregister
PercentDoneListener_swigregister(PercentDoneListener)

class IVisual(object):
    """Proxy of C++ FIFE::IVisual class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IVisual
IVisual_swigregister = _fife.IVisual_swigregister
IVisual_swigregister(IVisual)

class Action(FifeClass):
    """Proxy of C++ FIFE::Action class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, identifier):
        """__init__(FIFE::Action self, std::string const & identifier) -> Action"""
        _fife.Action_swiginit(self, _fife.new_Action(identifier))
    __swig_destroy__ = _fife.delete_Action

    def getId(self):
        """getId(Action self) -> std::string const &"""
        return _fife.Action_getId(self)


    def adoptVisual(self, visual):
        """adoptVisual(Action self, IVisual visual)"""
        return _fife.Action_adoptVisual(self, visual)


    def setDuration(self, duration):
        """setDuration(Action self, uint32_t duration)"""
        return _fife.Action_setDuration(self, duration)


    def getDuration(self):
        """getDuration(Action self) -> uint32_t"""
        return _fife.Action_getDuration(self)


    def get2dGfxVisual(self):
        """get2dGfxVisual(Action self) -> ActionVisual"""
        return _fife.Action_get2dGfxVisual(self)

Action.getId = new_instancemethod(_fife.Action_getId, None, Action)
Action.adoptVisual = new_instancemethod(_fife.Action_adoptVisual, None, Action)
Action.setDuration = new_instancemethod(_fife.Action_setDuration, None, Action)
Action.getDuration = new_instancemethod(_fife.Action_getDuration, None, Action)
Action.get2dGfxVisual = new_instancemethod(_fife.Action_get2dGfxVisual, None, Action)
Action_swigregister = _fife.Action_swigregister
Action_swigregister(Action)

class Location(object):
    """Proxy of C++ FIFE::Location class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::Location self) -> Location
        __init__(FIFE::Location self, Location loc) -> Location
        __init__(FIFE::Location self, Layer layer) -> Location
        """
        _fife.Location_swiginit(self, _fife.new_Location(*args))
    __swig_destroy__ = _fife.delete_Location

    def reset(self):
        """reset(Location self)"""
        return _fife.Location_reset(self)


    def __eq__(self, loc):
        """__eq__(Location self, Location loc) -> bool"""
        return _fife.Location___eq__(self, loc)


    def getMap(self):
        """getMap(Location self) -> Map"""
        return _fife.Location_getMap(self)


    def setLayer(self, layer):
        """setLayer(Location self, Layer layer)"""
        return _fife.Location_setLayer(self, layer)


    def getLayer(self):
        """getLayer(Location self) -> Layer"""
        return _fife.Location_getLayer(self)


    def setExactLayerCoordinates(self, coordinates):
        """setExactLayerCoordinates(Location self, DoublePoint3D coordinates)"""
        return _fife.Location_setExactLayerCoordinates(self, coordinates)


    def setLayerCoordinates(self, coordinates):
        """setLayerCoordinates(Location self, Point3D coordinates)"""
        return _fife.Location_setLayerCoordinates(self, coordinates)


    def setMapCoordinates(self, coordinates):
        """setMapCoordinates(Location self, DoublePoint3D coordinates)"""
        return _fife.Location_setMapCoordinates(self, coordinates)


    def getExactLayerCoordinatesRef(self):
        """getExactLayerCoordinatesRef(Location self) -> DoublePoint3D"""
        return _fife.Location_getExactLayerCoordinatesRef(self)


    def getExactLayerCoordinates(self, *args):
        """
        getExactLayerCoordinates(Location self) -> DoublePoint3D
        getExactLayerCoordinates(Location self, Layer layer) -> DoublePoint3D
        """
        return _fife.Location_getExactLayerCoordinates(self, *args)


    def getLayerCoordinates(self, *args):
        """
        getLayerCoordinates(Location self) -> Point3D
        getLayerCoordinates(Location self, Layer layer) -> Point3D
        """
        return _fife.Location_getLayerCoordinates(self, *args)


    def getMapCoordinates(self):
        """getMapCoordinates(Location self) -> DoublePoint3D"""
        return _fife.Location_getMapCoordinates(self)


    def isValid(self):
        """isValid(Location self) -> bool"""
        return _fife.Location_isValid(self)


    def getCellOffsetDistance(self):
        """getCellOffsetDistance(Location self) -> double"""
        return _fife.Location_getCellOffsetDistance(self)


    def getMapDistanceTo(self, location):
        """getMapDistanceTo(Location self, Location location) -> double"""
        return _fife.Location_getMapDistanceTo(self, location)


    def getLayerDistanceTo(self, location):
        """getLayerDistanceTo(Location self, Location location) -> double"""
        return _fife.Location_getLayerDistanceTo(self, location)

Location.reset = new_instancemethod(_fife.Location_reset, None, Location)
Location.__eq__ = new_instancemethod(_fife.Location___eq__, None, Location)
Location.getMap = new_instancemethod(_fife.Location_getMap, None, Location)
Location.setLayer = new_instancemethod(_fife.Location_setLayer, None, Location)
Location.getLayer = new_instancemethod(_fife.Location_getLayer, None, Location)
Location.setExactLayerCoordinates = new_instancemethod(_fife.Location_setExactLayerCoordinates, None, Location)
Location.setLayerCoordinates = new_instancemethod(_fife.Location_setLayerCoordinates, None, Location)
Location.setMapCoordinates = new_instancemethod(_fife.Location_setMapCoordinates, None, Location)
Location.getExactLayerCoordinatesRef = new_instancemethod(_fife.Location_getExactLayerCoordinatesRef, None, Location)
Location.getExactLayerCoordinates = new_instancemethod(_fife.Location_getExactLayerCoordinates, None, Location)
Location.getLayerCoordinates = new_instancemethod(_fife.Location_getLayerCoordinates, None, Location)
Location.getMapCoordinates = new_instancemethod(_fife.Location_getMapCoordinates, None, Location)
Location.isValid = new_instancemethod(_fife.Location_isValid, None, Location)
Location.getCellOffsetDistance = new_instancemethod(_fife.Location_getCellOffsetDistance, None, Location)
Location.getMapDistanceTo = new_instancemethod(_fife.Location_getMapDistanceTo, None, Location)
Location.getLayerDistanceTo = new_instancemethod(_fife.Location_getLayerDistanceTo, None, Location)
Location_swigregister = _fife.Location_swigregister
Location_swigregister(Location)


def __lshift__(os, l):
    """__lshift__(std::ostream & os, Location l) -> std::ostream &"""
    return _fife.__lshift__(os, l)
class LocationVector(object):
    """Proxy of C++ std::vector<(FIFE::Location)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(LocationVector self) -> SwigPyIterator"""
        return _fife.LocationVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(LocationVector self) -> bool"""
        return _fife.LocationVector___nonzero__(self)


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


    def __len__(self):
        """__len__(LocationVector self) -> std::vector< FIFE::Location >::size_type"""
        return _fife.LocationVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(LocationVector self, std::vector< FIFE::Location >::difference_type i, std::vector< FIFE::Location >::difference_type j) -> LocationVector"""
        return _fife.LocationVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(LocationVector self, std::vector< FIFE::Location >::difference_type i, std::vector< FIFE::Location >::difference_type j)
        __setslice__(LocationVector self, std::vector< FIFE::Location >::difference_type i, std::vector< FIFE::Location >::difference_type j, LocationVector v)
        """
        return _fife.LocationVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(LocationVector self, std::vector< FIFE::Location >::difference_type i, std::vector< FIFE::Location >::difference_type j)"""
        return _fife.LocationVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(LocationVector self, std::vector< FIFE::Location >::difference_type i)
        __delitem__(LocationVector self, PySliceObject * slice)
        """
        return _fife.LocationVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(LocationVector self, PySliceObject * slice) -> LocationVector
        __getitem__(LocationVector self, std::vector< FIFE::Location >::difference_type i) -> Location
        """
        return _fife.LocationVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(LocationVector self, PySliceObject * slice, LocationVector v)
        __setitem__(LocationVector self, PySliceObject * slice)
        __setitem__(LocationVector self, std::vector< FIFE::Location >::difference_type i, Location x)
        """
        return _fife.LocationVector___setitem__(self, *args)


    def pop(self):
        """pop(LocationVector self) -> Location"""
        return _fife.LocationVector_pop(self)


    def append(self, x):
        """append(LocationVector self, Location x)"""
        return _fife.LocationVector_append(self, x)


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


    def size(self):
        """size(LocationVector self) -> std::vector< FIFE::Location >::size_type"""
        return _fife.LocationVector_size(self)


    def swap(self, v):
        """swap(LocationVector self, LocationVector v)"""
        return _fife.LocationVector_swap(self, v)


    def begin(self):
        """begin(LocationVector self) -> std::vector< FIFE::Location >::iterator"""
        return _fife.LocationVector_begin(self)


    def end(self):
        """end(LocationVector self) -> std::vector< FIFE::Location >::iterator"""
        return _fife.LocationVector_end(self)


    def rbegin(self):
        """rbegin(LocationVector self) -> std::vector< FIFE::Location >::reverse_iterator"""
        return _fife.LocationVector_rbegin(self)


    def rend(self):
        """rend(LocationVector self) -> std::vector< FIFE::Location >::reverse_iterator"""
        return _fife.LocationVector_rend(self)


    def clear(self):
        """clear(LocationVector self)"""
        return _fife.LocationVector_clear(self)


    def get_allocator(self):
        """get_allocator(LocationVector self) -> std::vector< FIFE::Location >::allocator_type"""
        return _fife.LocationVector_get_allocator(self)


    def pop_back(self):
        """pop_back(LocationVector self)"""
        return _fife.LocationVector_pop_back(self)


    def erase(self, *args):
        """
        erase(LocationVector self, std::vector< FIFE::Location >::iterator pos) -> std::vector< FIFE::Location >::iterator
        erase(LocationVector self, std::vector< FIFE::Location >::iterator first, std::vector< FIFE::Location >::iterator last) -> std::vector< FIFE::Location >::iterator
        """
        return _fife.LocationVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(FIFE::Location)> self) -> LocationVector
        __init__(std::vector<(FIFE::Location)> self, LocationVector arg2) -> LocationVector
        __init__(std::vector<(FIFE::Location)> self, std::vector< FIFE::Location >::size_type size) -> LocationVector
        __init__(std::vector<(FIFE::Location)> self, std::vector< FIFE::Location >::size_type size, Location value) -> LocationVector
        """
        _fife.LocationVector_swiginit(self, _fife.new_LocationVector(*args))

    def push_back(self, x):
        """push_back(LocationVector self, Location x)"""
        return _fife.LocationVector_push_back(self, x)


    def front(self):
        """front(LocationVector self) -> Location"""
        return _fife.LocationVector_front(self)


    def back(self):
        """back(LocationVector self) -> Location"""
        return _fife.LocationVector_back(self)


    def assign(self, n, x):
        """assign(LocationVector self, std::vector< FIFE::Location >::size_type n, Location x)"""
        return _fife.LocationVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(LocationVector self, std::vector< FIFE::Location >::size_type new_size)
        resize(LocationVector self, std::vector< FIFE::Location >::size_type new_size, Location x)
        """
        return _fife.LocationVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(LocationVector self, std::vector< FIFE::Location >::iterator pos, Location x) -> std::vector< FIFE::Location >::iterator
        insert(LocationVector self, std::vector< FIFE::Location >::iterator pos, std::vector< FIFE::Location >::size_type n, Location x)
        """
        return _fife.LocationVector_insert(self, *args)


    def reserve(self, n):
        """reserve(LocationVector self, std::vector< FIFE::Location >::size_type n)"""
        return _fife.LocationVector_reserve(self, n)


    def capacity(self):
        """capacity(LocationVector self) -> std::vector< FIFE::Location >::size_type"""
        return _fife.LocationVector_capacity(self)

    __swig_destroy__ = _fife.delete_LocationVector
LocationVector.iterator = new_instancemethod(_fife.LocationVector_iterator, None, LocationVector)
LocationVector.__nonzero__ = new_instancemethod(_fife.LocationVector___nonzero__, None, LocationVector)
LocationVector.__bool__ = new_instancemethod(_fife.LocationVector___bool__, None, LocationVector)
LocationVector.__len__ = new_instancemethod(_fife.LocationVector___len__, None, LocationVector)
LocationVector.__getslice__ = new_instancemethod(_fife.LocationVector___getslice__, None, LocationVector)
LocationVector.__setslice__ = new_instancemethod(_fife.LocationVector___setslice__, None, LocationVector)
LocationVector.__delslice__ = new_instancemethod(_fife.LocationVector___delslice__, None, LocationVector)
LocationVector.__delitem__ = new_instancemethod(_fife.LocationVector___delitem__, None, LocationVector)
LocationVector.__getitem__ = new_instancemethod(_fife.LocationVector___getitem__, None, LocationVector)
LocationVector.__setitem__ = new_instancemethod(_fife.LocationVector___setitem__, None, LocationVector)
LocationVector.pop = new_instancemethod(_fife.LocationVector_pop, None, LocationVector)
LocationVector.append = new_instancemethod(_fife.LocationVector_append, None, LocationVector)
LocationVector.empty = new_instancemethod(_fife.LocationVector_empty, None, LocationVector)
LocationVector.size = new_instancemethod(_fife.LocationVector_size, None, LocationVector)
LocationVector.swap = new_instancemethod(_fife.LocationVector_swap, None, LocationVector)
LocationVector.begin = new_instancemethod(_fife.LocationVector_begin, None, LocationVector)
LocationVector.end = new_instancemethod(_fife.LocationVector_end, None, LocationVector)
LocationVector.rbegin = new_instancemethod(_fife.LocationVector_rbegin, None, LocationVector)
LocationVector.rend = new_instancemethod(_fife.LocationVector_rend, None, LocationVector)
LocationVector.clear = new_instancemethod(_fife.LocationVector_clear, None, LocationVector)
LocationVector.get_allocator = new_instancemethod(_fife.LocationVector_get_allocator, None, LocationVector)
LocationVector.pop_back = new_instancemethod(_fife.LocationVector_pop_back, None, LocationVector)
LocationVector.erase = new_instancemethod(_fife.LocationVector_erase, None, LocationVector)
LocationVector.push_back = new_instancemethod(_fife.LocationVector_push_back, None, LocationVector)
LocationVector.front = new_instancemethod(_fife.LocationVector_front, None, LocationVector)
LocationVector.back = new_instancemethod(_fife.LocationVector_back, None, LocationVector)
LocationVector.assign = new_instancemethod(_fife.LocationVector_assign, None, LocationVector)
LocationVector.resize = new_instancemethod(_fife.LocationVector_resize, None, LocationVector)
LocationVector.insert = new_instancemethod(_fife.LocationVector_insert, None, LocationVector)
LocationVector.reserve = new_instancemethod(_fife.LocationVector_reserve, None, LocationVector)
LocationVector.capacity = new_instancemethod(_fife.LocationVector_capacity, None, LocationVector)
LocationVector_swigregister = _fife.LocationVector_swigregister
LocationVector_swigregister(LocationVector)

class InstanceActionListener(object):
    """Proxy of C++ FIFE::InstanceActionListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_InstanceActionListener

    def onInstanceActionFinished(self, instance, action):
        """onInstanceActionFinished(InstanceActionListener self, Instance instance, Action action)"""
        return _fife.InstanceActionListener_onInstanceActionFinished(self, instance, action)


    def onInstanceActionCancelled(self, instance, action):
        """onInstanceActionCancelled(InstanceActionListener self, Instance instance, Action action)"""
        return _fife.InstanceActionListener_onInstanceActionCancelled(self, instance, action)


    def onInstanceActionFrame(self, instance, action, frame):
        """onInstanceActionFrame(InstanceActionListener self, Instance instance, Action action, int32_t frame)"""
        return _fife.InstanceActionListener_onInstanceActionFrame(self, instance, action, frame)


    def __init__(self):
        """__init__(FIFE::InstanceActionListener self) -> InstanceActionListener"""
        if self.__class__ == InstanceActionListener:
            _self = None
        else:
            _self = self
        _fife.InstanceActionListener_swiginit(self, _fife.new_InstanceActionListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceActionListener(self)
        return weakref_proxy(self)
InstanceActionListener.onInstanceActionFinished = new_instancemethod(_fife.InstanceActionListener_onInstanceActionFinished, None, InstanceActionListener)
InstanceActionListener.onInstanceActionCancelled = new_instancemethod(_fife.InstanceActionListener_onInstanceActionCancelled, None, InstanceActionListener)
InstanceActionListener.onInstanceActionFrame = new_instancemethod(_fife.InstanceActionListener_onInstanceActionFrame, None, InstanceActionListener)
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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_InstanceChangeListener

    def onInstanceChanged(self, instance, info):
        """onInstanceChanged(InstanceChangeListener self, Instance instance, FIFE::InstanceChangeInfo info)"""
        return _fife.InstanceChangeListener_onInstanceChanged(self, instance, info)


    def __init__(self):
        """__init__(FIFE::InstanceChangeListener self) -> InstanceChangeListener"""
        if self.__class__ == InstanceChangeListener:
            _self = None
        else:
            _self = self
        _fife.InstanceChangeListener_swiginit(self, _fife.new_InstanceChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceChangeListener(self)
        return weakref_proxy(self)
InstanceChangeListener.onInstanceChanged = new_instancemethod(_fife.InstanceChangeListener_onInstanceChanged, None, InstanceChangeListener)
InstanceChangeListener_swigregister = _fife.InstanceChangeListener_swigregister
InstanceChangeListener_swigregister(InstanceChangeListener)

class InstanceDeleteListener(object):
    """Proxy of C++ FIFE::InstanceDeleteListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_InstanceDeleteListener

    def onInstanceDeleted(self, instance):
        """onInstanceDeleted(InstanceDeleteListener self, Instance instance)"""
        return _fife.InstanceDeleteListener_onInstanceDeleted(self, instance)


    def __init__(self):
        """__init__(FIFE::InstanceDeleteListener self) -> InstanceDeleteListener"""
        if self.__class__ == InstanceDeleteListener:
            _self = None
        else:
            _self = self
        _fife.InstanceDeleteListener_swiginit(self, _fife.new_InstanceDeleteListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceDeleteListener(self)
        return weakref_proxy(self)
InstanceDeleteListener.onInstanceDeleted = new_instancemethod(_fife.InstanceDeleteListener_onInstanceDeleted, None, InstanceDeleteListener)
InstanceDeleteListener_swigregister = _fife.InstanceDeleteListener_swigregister
InstanceDeleteListener_swigregister(InstanceDeleteListener)

class Instance(FifeClass):
    """Proxy of C++ FIFE::Instance class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args, **kwargs):
        """__init__(FIFE::Instance self, Object object, Location location, std::string const & identifier) -> Instance"""
        _fife.Instance_swiginit(self, _fife.new_Instance(*args, **kwargs))
    __swig_destroy__ = _fife.delete_Instance

    def getId(self):
        """getId(Instance self) -> std::string const &"""
        return _fife.Instance_getId(self)


    def setId(self, *args, **kwargs):
        """setId(Instance self, std::string const & identifier)"""
        return _fife.Instance_setId(self, *args, **kwargs)


    def getObject(self):
        """getObject(Instance self) -> Object"""
        return _fife.Instance_getObject(self)


    def setLocation(self, loc):
        """setLocation(Instance self, Location loc)"""
        return _fife.Instance_setLocation(self, loc)


    def getLocation(self):
        """getLocation(Instance self) -> Location"""
        return _fife.Instance_getLocation(self)


    def getLocationRef(self):
        """getLocationRef(Instance self) -> Location"""
        return _fife.Instance_getLocationRef(self)


    def getTargetLocation(self):
        """getTargetLocation(Instance self) -> Location"""
        return _fife.Instance_getTargetLocation(self)


    def setRotation(self, arg2):
        """setRotation(Instance self, int32_t arg2)"""
        return _fife.Instance_setRotation(self, arg2)


    def getRotation(self):
        """getRotation(Instance self) -> int32_t"""
        return _fife.Instance_getRotation(self)


    def getOldRotation(self):
        """getOldRotation(Instance self) -> int32_t"""
        return _fife.Instance_getOldRotation(self)


    def setBlocking(self, blocking):
        """setBlocking(Instance self, bool blocking)"""
        return _fife.Instance_setBlocking(self, blocking)


    def isBlocking(self):
        """isBlocking(Instance self) -> bool"""
        return _fife.Instance_isBlocking(self)


    def setOverrideBlocking(self, overblock):
        """setOverrideBlocking(Instance self, bool overblock)"""
        return _fife.Instance_setOverrideBlocking(self, overblock)


    def isOverrideBlocking(self):
        """isOverrideBlocking(Instance self) -> bool"""
        return _fife.Instance_isOverrideBlocking(self)


    def addActionListener(self, listener):
        """addActionListener(Instance self, InstanceActionListener listener)"""
        return _fife.Instance_addActionListener(self, listener)


    def removeActionListener(self, listener):
        """removeActionListener(Instance self, InstanceActionListener listener)"""
        return _fife.Instance_removeActionListener(self, listener)


    def addChangeListener(self, listener):
        """addChangeListener(Instance self, InstanceChangeListener listener)"""
        return _fife.Instance_addChangeListener(self, listener)


    def removeChangeListener(self, listener):
        """removeChangeListener(Instance self, InstanceChangeListener listener)"""
        return _fife.Instance_removeChangeListener(self, listener)


    def addDeleteListener(self, listener):
        """addDeleteListener(Instance self, InstanceDeleteListener listener)"""
        return _fife.Instance_addDeleteListener(self, listener)


    def removeDeleteListener(self, listener):
        """removeDeleteListener(Instance self, InstanceDeleteListener listener)"""
        return _fife.Instance_removeDeleteListener(self, listener)


    def getCurrentAction(self):
        """getCurrentAction(Instance self) -> Action"""
        return _fife.Instance_getCurrentAction(self)


    def getMovementSpeed(self):
        """getMovementSpeed(Instance self) -> double"""
        return _fife.Instance_getMovementSpeed(self)


    def setFacingLocation(self, loc):
        """setFacingLocation(Instance self, Location loc)"""
        return _fife.Instance_setFacingLocation(self, loc)


    def getFacingLocation(self):
        """getFacingLocation(Instance self) -> Location"""
        return _fife.Instance_getFacingLocation(self)


    def getActionRuntime(self):
        """getActionRuntime(Instance self) -> uint32_t"""
        return _fife.Instance_getActionRuntime(self)


    def setActionRuntime(self, time_offset):
        """setActionRuntime(Instance self, uint32_t time_offset)"""
        return _fife.Instance_setActionRuntime(self, time_offset)


    def move(self, *args, **kwargs):
        """move(Instance self, std::string const & actionName, Location target, double const speed, std::string const & costId)"""
        return _fife.Instance_move(self, *args, **kwargs)


    def actOnce(self, *args):
        """
        actOnce(Instance self, std::string const & actionName, Location direction)
        actOnce(Instance self, std::string const & actionName, int32_t rotation)
        actOnce(Instance self, std::string const & actionName)
        """
        return _fife.Instance_actOnce(self, *args)


    def actRepeat(self, *args):
        """
        actRepeat(Instance self, std::string const & actionName, Location direction)
        actRepeat(Instance self, std::string const & actionName, int32_t rotation)
        actRepeat(Instance self, std::string const & actionName)
        """
        return _fife.Instance_actRepeat(self, *args)


    def follow(self, *args):
        """
        follow(Instance self, std::string const & actionName, Instance leader, double const speed)
        follow(Instance self, std::string const & actionName, Route route, double const speed)
        """
        return _fife.Instance_follow(self, *args)


    def cancelMovement(self, length=1):
        """cancelMovement(Instance self, uint32_t length=1)"""
        return _fife.Instance_cancelMovement(self, length)


    def say(self, text, duration=0):
        """say(Instance self, std::string const & text, uint32_t duration=0)"""
        return _fife.Instance_say(self, text, duration)


    def setTimeMultiplier(self, multip):
        """setTimeMultiplier(Instance self, float multip)"""
        return _fife.Instance_setTimeMultiplier(self, multip)


    def getTimeMultiplier(self):
        """getTimeMultiplier(Instance self) -> float"""
        return _fife.Instance_getTimeMultiplier(self)


    def getRuntime(self):
        """getRuntime(Instance self) -> uint32_t"""
        return _fife.Instance_getRuntime(self)


    def refresh(self):
        """refresh(Instance self)"""
        return _fife.Instance_refresh(self)


    def getChangeInfo(self):
        """getChangeInfo(Instance self) -> FIFE::InstanceChangeInfo"""
        return _fife.Instance_getChangeInfo(self)


    def setVisual(self, visual):
        """setVisual(Instance self, IVisual visual)"""
        return _fife.Instance_setVisual(self, visual)


    def getRoute(self):
        """getRoute(Instance self) -> Route"""
        return _fife.Instance_getRoute(self)


    def setCellStackPosition(self, stack):
        """setCellStackPosition(Instance self, uint8_t stack)"""
        return _fife.Instance_setCellStackPosition(self, stack)


    def getCellStackPosition(self):
        """getCellStackPosition(Instance self) -> uint8_t"""
        return _fife.Instance_getCellStackPosition(self)


    def isSpecialCost(self):
        """isSpecialCost(Instance self) -> bool"""
        return _fife.Instance_isSpecialCost(self)


    def setCost(self, id, cost):
        """setCost(Instance self, std::string const & id, double cost)"""
        return _fife.Instance_setCost(self, id, cost)


    def resetCost(self):
        """resetCost(Instance self)"""
        return _fife.Instance_resetCost(self)


    def getCost(self):
        """getCost(Instance self) -> double"""
        return _fife.Instance_getCost(self)


    def getCostId(self):
        """getCostId(Instance self) -> std::string"""
        return _fife.Instance_getCostId(self)


    def getSpeed(self):
        """getSpeed(Instance self) -> double"""
        return _fife.Instance_getSpeed(self)


    def isSpecialSpeed(self):
        """isSpecialSpeed(Instance self) -> bool"""
        return _fife.Instance_isSpecialSpeed(self)


    def isMultiCell(self):
        """isMultiCell(Instance self) -> bool"""
        return _fife.Instance_isMultiCell(self)


    def isMultiObject(self):
        """isMultiObject(Instance self) -> bool"""
        return _fife.Instance_isMultiObject(self)


    def getMultiInstances(self):
        """getMultiInstances(Instance self) -> InstanceVector"""
        return _fife.Instance_getMultiInstances(self)


    def getMainMultiInstance(self):
        """getMainMultiInstance(Instance self) -> Instance"""
        return _fife.Instance_getMainMultiInstance(self)


    def addStaticColorOverlay(self, angle, colors):
        """addStaticColorOverlay(Instance self, uint32_t angle, OverlayColors colors)"""
        return _fife.Instance_addStaticColorOverlay(self, angle, colors)


    def getStaticColorOverlay(self, angle):
        """getStaticColorOverlay(Instance self, int32_t angle) -> OverlayColors"""
        return _fife.Instance_getStaticColorOverlay(self, angle)


    def removeStaticColorOverlay(self, angle):
        """removeStaticColorOverlay(Instance self, int32_t angle)"""
        return _fife.Instance_removeStaticColorOverlay(self, angle)


    def isStaticColorOverlay(self):
        """isStaticColorOverlay(Instance self) -> bool"""
        return _fife.Instance_isStaticColorOverlay(self)


    def addAnimationOverlay(self, actionName, angle, order, animationptr):
        """addAnimationOverlay(Instance self, std::string const & actionName, uint32_t angle, int32_t order, SharedAnimationPointer animationptr)"""
        return _fife.Instance_addAnimationOverlay(self, actionName, angle, order, animationptr)


    def getAnimationOverlay(self, actionName, angle):
        """getAnimationOverlay(Instance self, std::string const & actionName, int32_t angle) -> AnimationOverlayMap"""
        return _fife.Instance_getAnimationOverlay(self, actionName, angle)


    def removeAnimationOverlay(self, actionName, angle, order):
        """removeAnimationOverlay(Instance self, std::string const & actionName, uint32_t angle, int32_t order)"""
        return _fife.Instance_removeAnimationOverlay(self, actionName, angle, order)


    def addColorOverlay(self, *args):
        """
        addColorOverlay(Instance self, std::string const & actionName, uint32_t angle, OverlayColors colors)
        addColorOverlay(Instance self, std::string const & actionName, uint32_t angle, int32_t order, OverlayColors colors)
        """
        return _fife.Instance_addColorOverlay(self, *args)


    def getColorOverlay(self, *args):
        """
        getColorOverlay(Instance self, std::string const & actionName, uint32_t angle) -> OverlayColors
        getColorOverlay(Instance self, std::string const & actionName, uint32_t angle, int32_t order) -> OverlayColors
        """
        return _fife.Instance_getColorOverlay(self, *args)


    def removeColorOverlay(self, *args):
        """
        removeColorOverlay(Instance self, std::string const & actionName, int32_t angle)
        removeColorOverlay(Instance self, std::string const & actionName, int32_t angle, int32_t order)
        """
        return _fife.Instance_removeColorOverlay(self, *args)


    def convertToOverlays(self, actionName, color):
        """convertToOverlays(Instance self, std::string const & actionName, bool color)"""
        return _fife.Instance_convertToOverlays(self, actionName, color)


    def isAnimationOverlay(self, actionName):
        """isAnimationOverlay(Instance self, std::string const & actionName) -> bool"""
        return _fife.Instance_isAnimationOverlay(self, actionName)


    def isColorOverlay(self, actionName):
        """isColorOverlay(Instance self, std::string const & actionName) -> bool"""
        return _fife.Instance_isColorOverlay(self, actionName)


    def get2dGfxVisual(self):
        """get2dGfxVisual(Instance self) -> InstanceVisual"""
        return _fife.Instance_get2dGfxVisual(self)

Instance.getId = new_instancemethod(_fife.Instance_getId, None, Instance)
Instance.setId = new_instancemethod(_fife.Instance_setId, None, Instance)
Instance.getObject = new_instancemethod(_fife.Instance_getObject, None, Instance)
Instance.setLocation = new_instancemethod(_fife.Instance_setLocation, None, Instance)
Instance.getLocation = new_instancemethod(_fife.Instance_getLocation, None, Instance)
Instance.getLocationRef = new_instancemethod(_fife.Instance_getLocationRef, None, Instance)
Instance.getTargetLocation = new_instancemethod(_fife.Instance_getTargetLocation, None, Instance)
Instance.setRotation = new_instancemethod(_fife.Instance_setRotation, None, Instance)
Instance.getRotation = new_instancemethod(_fife.Instance_getRotation, None, Instance)
Instance.getOldRotation = new_instancemethod(_fife.Instance_getOldRotation, None, Instance)
Instance.setBlocking = new_instancemethod(_fife.Instance_setBlocking, None, Instance)
Instance.isBlocking = new_instancemethod(_fife.Instance_isBlocking, None, Instance)
Instance.setOverrideBlocking = new_instancemethod(_fife.Instance_setOverrideBlocking, None, Instance)
Instance.isOverrideBlocking = new_instancemethod(_fife.Instance_isOverrideBlocking, None, Instance)
Instance.addActionListener = new_instancemethod(_fife.Instance_addActionListener, None, Instance)
Instance.removeActionListener = new_instancemethod(_fife.Instance_removeActionListener, None, Instance)
Instance.addChangeListener = new_instancemethod(_fife.Instance_addChangeListener, None, Instance)
Instance.removeChangeListener = new_instancemethod(_fife.Instance_removeChangeListener, None, Instance)
Instance.addDeleteListener = new_instancemethod(_fife.Instance_addDeleteListener, None, Instance)
Instance.removeDeleteListener = new_instancemethod(_fife.Instance_removeDeleteListener, None, Instance)
Instance.getCurrentAction = new_instancemethod(_fife.Instance_getCurrentAction, None, Instance)
Instance.getMovementSpeed = new_instancemethod(_fife.Instance_getMovementSpeed, None, Instance)
Instance.setFacingLocation = new_instancemethod(_fife.Instance_setFacingLocation, None, Instance)
Instance.getFacingLocation = new_instancemethod(_fife.Instance_getFacingLocation, None, Instance)
Instance.getActionRuntime = new_instancemethod(_fife.Instance_getActionRuntime, None, Instance)
Instance.setActionRuntime = new_instancemethod(_fife.Instance_setActionRuntime, None, Instance)
Instance.move = new_instancemethod(_fife.Instance_move, None, Instance)
Instance.actOnce = new_instancemethod(_fife.Instance_actOnce, None, Instance)
Instance.actRepeat = new_instancemethod(_fife.Instance_actRepeat, None, Instance)
Instance.follow = new_instancemethod(_fife.Instance_follow, None, Instance)
Instance.cancelMovement = new_instancemethod(_fife.Instance_cancelMovement, None, Instance)
Instance.say = new_instancemethod(_fife.Instance_say, None, Instance)
Instance.setTimeMultiplier = new_instancemethod(_fife.Instance_setTimeMultiplier, None, Instance)
Instance.getTimeMultiplier = new_instancemethod(_fife.Instance_getTimeMultiplier, None, Instance)
Instance.getRuntime = new_instancemethod(_fife.Instance_getRuntime, None, Instance)
Instance.refresh = new_instancemethod(_fife.Instance_refresh, None, Instance)
Instance.getChangeInfo = new_instancemethod(_fife.Instance_getChangeInfo, None, Instance)
Instance.setVisual = new_instancemethod(_fife.Instance_setVisual, None, Instance)
Instance.getRoute = new_instancemethod(_fife.Instance_getRoute, None, Instance)
Instance.setCellStackPosition = new_instancemethod(_fife.Instance_setCellStackPosition, None, Instance)
Instance.getCellStackPosition = new_instancemethod(_fife.Instance_getCellStackPosition, None, Instance)
Instance.isSpecialCost = new_instancemethod(_fife.Instance_isSpecialCost, None, Instance)
Instance.setCost = new_instancemethod(_fife.Instance_setCost, None, Instance)
Instance.resetCost = new_instancemethod(_fife.Instance_resetCost, None, Instance)
Instance.getCost = new_instancemethod(_fife.Instance_getCost, None, Instance)
Instance.getCostId = new_instancemethod(_fife.Instance_getCostId, None, Instance)
Instance.getSpeed = new_instancemethod(_fife.Instance_getSpeed, None, Instance)
Instance.isSpecialSpeed = new_instancemethod(_fife.Instance_isSpecialSpeed, None, Instance)
Instance.isMultiCell = new_instancemethod(_fife.Instance_isMultiCell, None, Instance)
Instance.isMultiObject = new_instancemethod(_fife.Instance_isMultiObject, None, Instance)
Instance.getMultiInstances = new_instancemethod(_fife.Instance_getMultiInstances, None, Instance)
Instance.getMainMultiInstance = new_instancemethod(_fife.Instance_getMainMultiInstance, None, Instance)
Instance.addStaticColorOverlay = new_instancemethod(_fife.Instance_addStaticColorOverlay, None, Instance)
Instance.getStaticColorOverlay = new_instancemethod(_fife.Instance_getStaticColorOverlay, None, Instance)
Instance.removeStaticColorOverlay = new_instancemethod(_fife.Instance_removeStaticColorOverlay, None, Instance)
Instance.isStaticColorOverlay = new_instancemethod(_fife.Instance_isStaticColorOverlay, None, Instance)
Instance.addAnimationOverlay = new_instancemethod(_fife.Instance_addAnimationOverlay, None, Instance)
Instance.getAnimationOverlay = new_instancemethod(_fife.Instance_getAnimationOverlay, None, Instance)
Instance.removeAnimationOverlay = new_instancemethod(_fife.Instance_removeAnimationOverlay, None, Instance)
Instance.addColorOverlay = new_instancemethod(_fife.Instance_addColorOverlay, None, Instance)
Instance.getColorOverlay = new_instancemethod(_fife.Instance_getColorOverlay, None, Instance)
Instance.removeColorOverlay = new_instancemethod(_fife.Instance_removeColorOverlay, None, Instance)
Instance.convertToOverlays = new_instancemethod(_fife.Instance_convertToOverlays, None, Instance)
Instance.isAnimationOverlay = new_instancemethod(_fife.Instance_isAnimationOverlay, None, Instance)
Instance.isColorOverlay = new_instancemethod(_fife.Instance_isColorOverlay, None, Instance)
Instance.get2dGfxVisual = new_instancemethod(_fife.Instance_get2dGfxVisual, None, Instance)
Instance_swigregister = _fife.Instance_swigregister
Instance_swigregister(Instance)

class InstanceVector(object):
    """Proxy of C++ std::vector<(p.FIFE::Instance)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(InstanceVector self) -> SwigPyIterator"""
        return _fife.InstanceVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(InstanceVector self) -> bool"""
        return _fife.InstanceVector___nonzero__(self)


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


    def __len__(self):
        """__len__(InstanceVector self) -> std::vector< FIFE::Instance * >::size_type"""
        return _fife.InstanceVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(InstanceVector self, std::vector< FIFE::Instance * >::difference_type i, std::vector< FIFE::Instance * >::difference_type j) -> InstanceVector"""
        return _fife.InstanceVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(InstanceVector self, std::vector< FIFE::Instance * >::difference_type i, std::vector< FIFE::Instance * >::difference_type j)
        __setslice__(InstanceVector self, std::vector< FIFE::Instance * >::difference_type i, std::vector< FIFE::Instance * >::difference_type j, InstanceVector v)
        """
        return _fife.InstanceVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(InstanceVector self, std::vector< FIFE::Instance * >::difference_type i, std::vector< FIFE::Instance * >::difference_type j)"""
        return _fife.InstanceVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(InstanceVector self, std::vector< FIFE::Instance * >::difference_type i)
        __delitem__(InstanceVector self, PySliceObject * slice)
        """
        return _fife.InstanceVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(InstanceVector self, PySliceObject * slice) -> InstanceVector
        __getitem__(InstanceVector self, std::vector< FIFE::Instance * >::difference_type i) -> Instance
        """
        return _fife.InstanceVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(InstanceVector self, PySliceObject * slice, InstanceVector v)
        __setitem__(InstanceVector self, PySliceObject * slice)
        __setitem__(InstanceVector self, std::vector< FIFE::Instance * >::difference_type i, Instance x)
        """
        return _fife.InstanceVector___setitem__(self, *args)


    def pop(self):
        """pop(InstanceVector self) -> Instance"""
        return _fife.InstanceVector_pop(self)


    def append(self, x):
        """append(InstanceVector self, Instance x)"""
        return _fife.InstanceVector_append(self, x)


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


    def size(self):
        """size(InstanceVector self) -> std::vector< FIFE::Instance * >::size_type"""
        return _fife.InstanceVector_size(self)


    def swap(self, v):
        """swap(InstanceVector self, InstanceVector v)"""
        return _fife.InstanceVector_swap(self, v)


    def begin(self):
        """begin(InstanceVector self) -> std::vector< FIFE::Instance * >::iterator"""
        return _fife.InstanceVector_begin(self)


    def end(self):
        """end(InstanceVector self) -> std::vector< FIFE::Instance * >::iterator"""
        return _fife.InstanceVector_end(self)


    def rbegin(self):
        """rbegin(InstanceVector self) -> std::vector< FIFE::Instance * >::reverse_iterator"""
        return _fife.InstanceVector_rbegin(self)


    def rend(self):
        """rend(InstanceVector self) -> std::vector< FIFE::Instance * >::reverse_iterator"""
        return _fife.InstanceVector_rend(self)


    def clear(self):
        """clear(InstanceVector self)"""
        return _fife.InstanceVector_clear(self)


    def get_allocator(self):
        """get_allocator(InstanceVector self) -> std::vector< FIFE::Instance * >::allocator_type"""
        return _fife.InstanceVector_get_allocator(self)


    def pop_back(self):
        """pop_back(InstanceVector self)"""
        return _fife.InstanceVector_pop_back(self)


    def erase(self, *args):
        """
        erase(InstanceVector self, std::vector< FIFE::Instance * >::iterator pos) -> std::vector< FIFE::Instance * >::iterator
        erase(InstanceVector self, std::vector< FIFE::Instance * >::iterator first, std::vector< FIFE::Instance * >::iterator last) -> std::vector< FIFE::Instance * >::iterator
        """
        return _fife.InstanceVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.FIFE::Instance)> self) -> InstanceVector
        __init__(std::vector<(p.FIFE::Instance)> self, InstanceVector arg2) -> InstanceVector
        __init__(std::vector<(p.FIFE::Instance)> self, std::vector< FIFE::Instance * >::size_type size) -> InstanceVector
        __init__(std::vector<(p.FIFE::Instance)> self, std::vector< FIFE::Instance * >::size_type size, Instance value) -> InstanceVector
        """
        _fife.InstanceVector_swiginit(self, _fife.new_InstanceVector(*args))

    def push_back(self, x):
        """push_back(InstanceVector self, Instance x)"""
        return _fife.InstanceVector_push_back(self, x)


    def front(self):
        """front(InstanceVector self) -> Instance"""
        return _fife.InstanceVector_front(self)


    def back(self):
        """back(InstanceVector self) -> Instance"""
        return _fife.InstanceVector_back(self)


    def assign(self, n, x):
        """assign(InstanceVector self, std::vector< FIFE::Instance * >::size_type n, Instance x)"""
        return _fife.InstanceVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(InstanceVector self, std::vector< FIFE::Instance * >::size_type new_size)
        resize(InstanceVector self, std::vector< FIFE::Instance * >::size_type new_size, Instance x)
        """
        return _fife.InstanceVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(InstanceVector self, std::vector< FIFE::Instance * >::iterator pos, Instance x) -> std::vector< FIFE::Instance * >::iterator
        insert(InstanceVector self, std::vector< FIFE::Instance * >::iterator pos, std::vector< FIFE::Instance * >::size_type n, Instance x)
        """
        return _fife.InstanceVector_insert(self, *args)


    def reserve(self, n):
        """reserve(InstanceVector self, std::vector< FIFE::Instance * >::size_type n)"""
        return _fife.InstanceVector_reserve(self, n)


    def capacity(self):
        """capacity(InstanceVector self) -> std::vector< FIFE::Instance * >::size_type"""
        return _fife.InstanceVector_capacity(self)

    __swig_destroy__ = _fife.delete_InstanceVector
InstanceVector.iterator = new_instancemethod(_fife.InstanceVector_iterator, None, InstanceVector)
InstanceVector.__nonzero__ = new_instancemethod(_fife.InstanceVector___nonzero__, None, InstanceVector)
InstanceVector.__bool__ = new_instancemethod(_fife.InstanceVector___bool__, None, InstanceVector)
InstanceVector.__len__ = new_instancemethod(_fife.InstanceVector___len__, None, InstanceVector)
InstanceVector.__getslice__ = new_instancemethod(_fife.InstanceVector___getslice__, None, InstanceVector)
InstanceVector.__setslice__ = new_instancemethod(_fife.InstanceVector___setslice__, None, InstanceVector)
InstanceVector.__delslice__ = new_instancemethod(_fife.InstanceVector___delslice__, None, InstanceVector)
InstanceVector.__delitem__ = new_instancemethod(_fife.InstanceVector___delitem__, None, InstanceVector)
InstanceVector.__getitem__ = new_instancemethod(_fife.InstanceVector___getitem__, None, InstanceVector)
InstanceVector.__setitem__ = new_instancemethod(_fife.InstanceVector___setitem__, None, InstanceVector)
InstanceVector.pop = new_instancemethod(_fife.InstanceVector_pop, None, InstanceVector)
InstanceVector.append = new_instancemethod(_fife.InstanceVector_append, None, InstanceVector)
InstanceVector.empty = new_instancemethod(_fife.InstanceVector_empty, None, InstanceVector)
InstanceVector.size = new_instancemethod(_fife.InstanceVector_size, None, InstanceVector)
InstanceVector.swap = new_instancemethod(_fife.InstanceVector_swap, None, InstanceVector)
InstanceVector.begin = new_instancemethod(_fife.InstanceVector_begin, None, InstanceVector)
InstanceVector.end = new_instancemethod(_fife.InstanceVector_end, None, InstanceVector)
InstanceVector.rbegin = new_instancemethod(_fife.InstanceVector_rbegin, None, InstanceVector)
InstanceVector.rend = new_instancemethod(_fife.InstanceVector_rend, None, InstanceVector)
InstanceVector.clear = new_instancemethod(_fife.InstanceVector_clear, None, InstanceVector)
InstanceVector.get_allocator = new_instancemethod(_fife.InstanceVector_get_allocator, None, InstanceVector)
InstanceVector.pop_back = new_instancemethod(_fife.InstanceVector_pop_back, None, InstanceVector)
InstanceVector.erase = new_instancemethod(_fife.InstanceVector_erase, None, InstanceVector)
InstanceVector.push_back = new_instancemethod(_fife.InstanceVector_push_back, None, InstanceVector)
InstanceVector.front = new_instancemethod(_fife.InstanceVector_front, None, InstanceVector)
InstanceVector.back = new_instancemethod(_fife.InstanceVector_back, None, InstanceVector)
InstanceVector.assign = new_instancemethod(_fife.InstanceVector_assign, None, InstanceVector)
InstanceVector.resize = new_instancemethod(_fife.InstanceVector_resize, None, InstanceVector)
InstanceVector.insert = new_instancemethod(_fife.InstanceVector_insert, None, InstanceVector)
InstanceVector.reserve = new_instancemethod(_fife.InstanceVector_reserve, None, InstanceVector)
InstanceVector.capacity = new_instancemethod(_fife.InstanceVector_capacity, None, InstanceVector)
InstanceVector_swigregister = _fife.InstanceVector_swigregister
InstanceVector_swigregister(InstanceVector)

class InstanceList(object):
    """Proxy of C++ std::list<(p.FIFE::Instance)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(InstanceList self) -> SwigPyIterator"""
        return _fife.InstanceList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(InstanceList self) -> bool"""
        return _fife.InstanceList___nonzero__(self)


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


    def __len__(self):
        """__len__(InstanceList self) -> std::list< FIFE::Instance * >::size_type"""
        return _fife.InstanceList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(InstanceList self, std::list< FIFE::Instance * >::difference_type i, std::list< FIFE::Instance * >::difference_type j) -> InstanceList"""
        return _fife.InstanceList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(InstanceList self, std::list< FIFE::Instance * >::difference_type i, std::list< FIFE::Instance * >::difference_type j)
        __setslice__(InstanceList self, std::list< FIFE::Instance * >::difference_type i, std::list< FIFE::Instance * >::difference_type j, InstanceList v)
        """
        return _fife.InstanceList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(InstanceList self, std::list< FIFE::Instance * >::difference_type i, std::list< FIFE::Instance * >::difference_type j)"""
        return _fife.InstanceList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(InstanceList self, std::list< FIFE::Instance * >::difference_type i)
        __delitem__(InstanceList self, PySliceObject * slice)
        """
        return _fife.InstanceList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(InstanceList self, PySliceObject * slice) -> InstanceList
        __getitem__(InstanceList self, std::list< FIFE::Instance * >::difference_type i) -> Instance
        """
        return _fife.InstanceList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(InstanceList self, PySliceObject * slice, InstanceList v)
        __setitem__(InstanceList self, PySliceObject * slice)
        __setitem__(InstanceList self, std::list< FIFE::Instance * >::difference_type i, Instance x)
        """
        return _fife.InstanceList___setitem__(self, *args)


    def pop(self):
        """pop(InstanceList self) -> Instance"""
        return _fife.InstanceList_pop(self)


    def append(self, x):
        """append(InstanceList self, Instance x)"""
        return _fife.InstanceList_append(self, x)


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


    def size(self):
        """size(InstanceList self) -> std::list< FIFE::Instance * >::size_type"""
        return _fife.InstanceList_size(self)


    def swap(self, v):
        """swap(InstanceList self, InstanceList v)"""
        return _fife.InstanceList_swap(self, v)


    def begin(self):
        """begin(InstanceList self) -> std::list< FIFE::Instance * >::iterator"""
        return _fife.InstanceList_begin(self)


    def end(self):
        """end(InstanceList self) -> std::list< FIFE::Instance * >::iterator"""
        return _fife.InstanceList_end(self)


    def rbegin(self):
        """rbegin(InstanceList self) -> std::list< FIFE::Instance * >::reverse_iterator"""
        return _fife.InstanceList_rbegin(self)


    def rend(self):
        """rend(InstanceList self) -> std::list< FIFE::Instance * >::reverse_iterator"""
        return _fife.InstanceList_rend(self)


    def clear(self):
        """clear(InstanceList self)"""
        return _fife.InstanceList_clear(self)


    def get_allocator(self):
        """get_allocator(InstanceList self) -> std::list< FIFE::Instance * >::allocator_type"""
        return _fife.InstanceList_get_allocator(self)


    def pop_back(self):
        """pop_back(InstanceList self)"""
        return _fife.InstanceList_pop_back(self)


    def erase(self, *args):
        """
        erase(InstanceList self, std::list< FIFE::Instance * >::iterator pos) -> std::list< FIFE::Instance * >::iterator
        erase(InstanceList self, std::list< FIFE::Instance * >::iterator first, std::list< FIFE::Instance * >::iterator last) -> std::list< FIFE::Instance * >::iterator
        """
        return _fife.InstanceList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.FIFE::Instance)> self) -> InstanceList
        __init__(std::list<(p.FIFE::Instance)> self, InstanceList arg2) -> InstanceList
        __init__(std::list<(p.FIFE::Instance)> self, std::list< FIFE::Instance * >::size_type size) -> InstanceList
        __init__(std::list<(p.FIFE::Instance)> self, std::list< FIFE::Instance * >::size_type size, Instance value) -> InstanceList
        """
        _fife.InstanceList_swiginit(self, _fife.new_InstanceList(*args))

    def push_back(self, x):
        """push_back(InstanceList self, Instance x)"""
        return _fife.InstanceList_push_back(self, x)


    def front(self):
        """front(InstanceList self) -> Instance"""
        return _fife.InstanceList_front(self)


    def back(self):
        """back(InstanceList self) -> Instance"""
        return _fife.InstanceList_back(self)


    def assign(self, n, x):
        """assign(InstanceList self, std::list< FIFE::Instance * >::size_type n, Instance x)"""
        return _fife.InstanceList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(InstanceList self, std::list< FIFE::Instance * >::size_type new_size)
        resize(InstanceList self, std::list< FIFE::Instance * >::size_type new_size, Instance x)
        """
        return _fife.InstanceList_resize(self, *args)


    def insert(self, *args):
        """
        insert(InstanceList self, std::list< FIFE::Instance * >::iterator pos, Instance x) -> std::list< FIFE::Instance * >::iterator
        insert(InstanceList self, std::list< FIFE::Instance * >::iterator pos, std::list< FIFE::Instance * >::size_type n, Instance x)
        """
        return _fife.InstanceList_insert(self, *args)


    def pop_front(self):
        """pop_front(InstanceList self)"""
        return _fife.InstanceList_pop_front(self)


    def push_front(self, x):
        """push_front(InstanceList self, Instance x)"""
        return _fife.InstanceList_push_front(self, x)


    def remove(self, x):
        """remove(InstanceList self, Instance x)"""
        return _fife.InstanceList_remove(self, x)


    def unique(self):
        """unique(InstanceList self)"""
        return _fife.InstanceList_unique(self)


    def reverse(self):
        """reverse(InstanceList self)"""
        return _fife.InstanceList_reverse(self)


    def sort(self):
        """sort(InstanceList self)"""
        return _fife.InstanceList_sort(self)


    def merge(self, x):
        """merge(InstanceList self, InstanceList x)"""
        return _fife.InstanceList_merge(self, x)

    __swig_destroy__ = _fife.delete_InstanceList
InstanceList.iterator = new_instancemethod(_fife.InstanceList_iterator, None, InstanceList)
InstanceList.__nonzero__ = new_instancemethod(_fife.InstanceList___nonzero__, None, InstanceList)
InstanceList.__bool__ = new_instancemethod(_fife.InstanceList___bool__, None, InstanceList)
InstanceList.__len__ = new_instancemethod(_fife.InstanceList___len__, None, InstanceList)
InstanceList.__getslice__ = new_instancemethod(_fife.InstanceList___getslice__, None, InstanceList)
InstanceList.__setslice__ = new_instancemethod(_fife.InstanceList___setslice__, None, InstanceList)
InstanceList.__delslice__ = new_instancemethod(_fife.InstanceList___delslice__, None, InstanceList)
InstanceList.__delitem__ = new_instancemethod(_fife.InstanceList___delitem__, None, InstanceList)
InstanceList.__getitem__ = new_instancemethod(_fife.InstanceList___getitem__, None, InstanceList)
InstanceList.__setitem__ = new_instancemethod(_fife.InstanceList___setitem__, None, InstanceList)
InstanceList.pop = new_instancemethod(_fife.InstanceList_pop, None, InstanceList)
InstanceList.append = new_instancemethod(_fife.InstanceList_append, None, InstanceList)
InstanceList.empty = new_instancemethod(_fife.InstanceList_empty, None, InstanceList)
InstanceList.size = new_instancemethod(_fife.InstanceList_size, None, InstanceList)
InstanceList.swap = new_instancemethod(_fife.InstanceList_swap, None, InstanceList)
InstanceList.begin = new_instancemethod(_fife.InstanceList_begin, None, InstanceList)
InstanceList.end = new_instancemethod(_fife.InstanceList_end, None, InstanceList)
InstanceList.rbegin = new_instancemethod(_fife.InstanceList_rbegin, None, InstanceList)
InstanceList.rend = new_instancemethod(_fife.InstanceList_rend, None, InstanceList)
InstanceList.clear = new_instancemethod(_fife.InstanceList_clear, None, InstanceList)
InstanceList.get_allocator = new_instancemethod(_fife.InstanceList_get_allocator, None, InstanceList)
InstanceList.pop_back = new_instancemethod(_fife.InstanceList_pop_back, None, InstanceList)
InstanceList.erase = new_instancemethod(_fife.InstanceList_erase, None, InstanceList)
InstanceList.push_back = new_instancemethod(_fife.InstanceList_push_back, None, InstanceList)
InstanceList.front = new_instancemethod(_fife.InstanceList_front, None, InstanceList)
InstanceList.back = new_instancemethod(_fife.InstanceList_back, None, InstanceList)
InstanceList.assign = new_instancemethod(_fife.InstanceList_assign, None, InstanceList)
InstanceList.resize = new_instancemethod(_fife.InstanceList_resize, None, InstanceList)
InstanceList.insert = new_instancemethod(_fife.InstanceList_insert, None, InstanceList)
InstanceList.pop_front = new_instancemethod(_fife.InstanceList_pop_front, None, InstanceList)
InstanceList.push_front = new_instancemethod(_fife.InstanceList_push_front, None, InstanceList)
InstanceList.remove = new_instancemethod(_fife.InstanceList_remove, None, InstanceList)
InstanceList.unique = new_instancemethod(_fife.InstanceList_unique, None, InstanceList)
InstanceList.reverse = new_instancemethod(_fife.InstanceList_reverse, None, InstanceList)
InstanceList.sort = new_instancemethod(_fife.InstanceList_sort, None, InstanceList)
InstanceList.merge = new_instancemethod(_fife.InstanceList_merge, None, InstanceList)
InstanceList_swigregister = _fife.InstanceList_swigregister
InstanceList_swigregister(InstanceList)

class AnimationOverlayMap(object):
    """Proxy of C++ std::map<(int32_t,FIFE::AnimationPtr)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(AnimationOverlayMap self) -> SwigPyIterator"""
        return _fife.AnimationOverlayMap_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(AnimationOverlayMap self) -> bool"""
        return _fife.AnimationOverlayMap___nonzero__(self)


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


    def __len__(self):
        """__len__(AnimationOverlayMap self) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::size_type"""
        return _fife.AnimationOverlayMap___len__(self)

    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        """__getitem__(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & key) -> SharedAnimationPointer"""
        return _fife.AnimationOverlayMap___getitem__(self, key)


    def __delitem__(self, key):
        """__delitem__(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & key)"""
        return _fife.AnimationOverlayMap___delitem__(self, key)


    def has_key(self, key):
        """has_key(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & key) -> bool"""
        return _fife.AnimationOverlayMap_has_key(self, key)


    def keys(self):
        """keys(AnimationOverlayMap self) -> PyObject *"""
        return _fife.AnimationOverlayMap_keys(self)


    def values(self):
        """values(AnimationOverlayMap self) -> PyObject *"""
        return _fife.AnimationOverlayMap_values(self)


    def items(self):
        """items(AnimationOverlayMap self) -> PyObject *"""
        return _fife.AnimationOverlayMap_items(self)


    def __contains__(self, key):
        """__contains__(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & key) -> bool"""
        return _fife.AnimationOverlayMap___contains__(self, key)


    def key_iterator(self):
        """key_iterator(AnimationOverlayMap self) -> SwigPyIterator"""
        return _fife.AnimationOverlayMap_key_iterator(self)


    def value_iterator(self):
        """value_iterator(AnimationOverlayMap self) -> SwigPyIterator"""
        return _fife.AnimationOverlayMap_value_iterator(self)


    def __setitem__(self, *args):
        """
        __setitem__(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & key)
        __setitem__(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & key, SharedAnimationPointer x)
        """
        return _fife.AnimationOverlayMap___setitem__(self, *args)


    def asdict(self):
        """asdict(AnimationOverlayMap self) -> PyObject *"""
        return _fife.AnimationOverlayMap_asdict(self)


    def __init__(self, *args):
        """
        __init__(std::map<(int32_t,FIFE::AnimationPtr)> self, std::less< int > const & arg2) -> AnimationOverlayMap
        __init__(std::map<(int32_t,FIFE::AnimationPtr)> self) -> AnimationOverlayMap
        __init__(std::map<(int32_t,FIFE::AnimationPtr)> self, AnimationOverlayMap arg2) -> AnimationOverlayMap
        """
        _fife.AnimationOverlayMap_swiginit(self, _fife.new_AnimationOverlayMap(*args))

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


    def size(self):
        """size(AnimationOverlayMap self) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::size_type"""
        return _fife.AnimationOverlayMap_size(self)


    def swap(self, v):
        """swap(AnimationOverlayMap self, AnimationOverlayMap v)"""
        return _fife.AnimationOverlayMap_swap(self, v)


    def begin(self):
        """begin(AnimationOverlayMap self) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator"""
        return _fife.AnimationOverlayMap_begin(self)


    def end(self):
        """end(AnimationOverlayMap self) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator"""
        return _fife.AnimationOverlayMap_end(self)


    def rbegin(self):
        """rbegin(AnimationOverlayMap self) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::reverse_iterator"""
        return _fife.AnimationOverlayMap_rbegin(self)


    def rend(self):
        """rend(AnimationOverlayMap self) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::reverse_iterator"""
        return _fife.AnimationOverlayMap_rend(self)


    def clear(self):
        """clear(AnimationOverlayMap self)"""
        return _fife.AnimationOverlayMap_clear(self)


    def get_allocator(self):
        """get_allocator(AnimationOverlayMap self) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::allocator_type"""
        return _fife.AnimationOverlayMap_get_allocator(self)


    def count(self, x):
        """count(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & x) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::size_type"""
        return _fife.AnimationOverlayMap_count(self, x)


    def erase(self, *args):
        """
        erase(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & x) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::size_type
        erase(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator position)
        erase(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator first, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator last)
        """
        return _fife.AnimationOverlayMap_erase(self, *args)


    def find(self, x):
        """find(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & x) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator"""
        return _fife.AnimationOverlayMap_find(self, x)


    def lower_bound(self, x):
        """lower_bound(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & x) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator"""
        return _fife.AnimationOverlayMap_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(AnimationOverlayMap self, std::map< int,FIFE::SharedPtr< FIFE::Animation > >::key_type const & x) -> std::map< int,FIFE::SharedPtr< FIFE::Animation > >::iterator"""
        return _fife.AnimationOverlayMap_upper_bound(self, x)

    __swig_destroy__ = _fife.delete_AnimationOverlayMap
AnimationOverlayMap.iterator = new_instancemethod(_fife.AnimationOverlayMap_iterator, None, AnimationOverlayMap)
AnimationOverlayMap.__nonzero__ = new_instancemethod(_fife.AnimationOverlayMap___nonzero__, None, AnimationOverlayMap)
AnimationOverlayMap.__bool__ = new_instancemethod(_fife.AnimationOverlayMap___bool__, None, AnimationOverlayMap)
AnimationOverlayMap.__len__ = new_instancemethod(_fife.AnimationOverlayMap___len__, None, AnimationOverlayMap)
AnimationOverlayMap.__getitem__ = new_instancemethod(_fife.AnimationOverlayMap___getitem__, None, AnimationOverlayMap)
AnimationOverlayMap.__delitem__ = new_instancemethod(_fife.AnimationOverlayMap___delitem__, None, AnimationOverlayMap)
AnimationOverlayMap.has_key = new_instancemethod(_fife.AnimationOverlayMap_has_key, None, AnimationOverlayMap)
AnimationOverlayMap.keys = new_instancemethod(_fife.AnimationOverlayMap_keys, None, AnimationOverlayMap)
AnimationOverlayMap.values = new_instancemethod(_fife.AnimationOverlayMap_values, None, AnimationOverlayMap)
AnimationOverlayMap.items = new_instancemethod(_fife.AnimationOverlayMap_items, None, AnimationOverlayMap)
AnimationOverlayMap.__contains__ = new_instancemethod(_fife.AnimationOverlayMap___contains__, None, AnimationOverlayMap)
AnimationOverlayMap.key_iterator = new_instancemethod(_fife.AnimationOverlayMap_key_iterator, None, AnimationOverlayMap)
AnimationOverlayMap.value_iterator = new_instancemethod(_fife.AnimationOverlayMap_value_iterator, None, AnimationOverlayMap)
AnimationOverlayMap.__setitem__ = new_instancemethod(_fife.AnimationOverlayMap___setitem__, None, AnimationOverlayMap)
AnimationOverlayMap.asdict = new_instancemethod(_fife.AnimationOverlayMap_asdict, None, AnimationOverlayMap)
AnimationOverlayMap.empty = new_instancemethod(_fife.AnimationOverlayMap_empty, None, AnimationOverlayMap)
AnimationOverlayMap.size = new_instancemethod(_fife.AnimationOverlayMap_size, None, AnimationOverlayMap)
AnimationOverlayMap.swap = new_instancemethod(_fife.AnimationOverlayMap_swap, None, AnimationOverlayMap)
AnimationOverlayMap.begin = new_instancemethod(_fife.AnimationOverlayMap_begin, None, AnimationOverlayMap)
AnimationOverlayMap.end = new_instancemethod(_fife.AnimationOverlayMap_end, None, AnimationOverlayMap)
AnimationOverlayMap.rbegin = new_instancemethod(_fife.AnimationOverlayMap_rbegin, None, AnimationOverlayMap)
AnimationOverlayMap.rend = new_instancemethod(_fife.AnimationOverlayMap_rend, None, AnimationOverlayMap)
AnimationOverlayMap.clear = new_instancemethod(_fife.AnimationOverlayMap_clear, None, AnimationOverlayMap)
AnimationOverlayMap.get_allocator = new_instancemethod(_fife.AnimationOverlayMap_get_allocator, None, AnimationOverlayMap)
AnimationOverlayMap.count = new_instancemethod(_fife.AnimationOverlayMap_count, None, AnimationOverlayMap)
AnimationOverlayMap.erase = new_instancemethod(_fife.AnimationOverlayMap_erase, None, AnimationOverlayMap)
AnimationOverlayMap.find = new_instancemethod(_fife.AnimationOverlayMap_find, None, AnimationOverlayMap)
AnimationOverlayMap.lower_bound = new_instancemethod(_fife.AnimationOverlayMap_lower_bound, None, AnimationOverlayMap)
AnimationOverlayMap.upper_bound = new_instancemethod(_fife.AnimationOverlayMap_upper_bound, None, AnimationOverlayMap)
AnimationOverlayMap_swigregister = _fife.AnimationOverlayMap_swigregister
AnimationOverlayMap_swigregister(AnimationOverlayMap)

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

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, start, end):
        """__init__(FIFE::Route self, Location start, Location end) -> Route"""
        _fife.Route_swiginit(self, _fife.new_Route(start, end))
    __swig_destroy__ = _fife.delete_Route

    def setRouteStatus(self, status):
        """setRouteStatus(Route self, FIFE::RouteStatusInfo status)"""
        return _fife.Route_setRouteStatus(self, status)


    def getRouteStatus(self):
        """getRouteStatus(Route self) -> FIFE::RouteStatusInfo"""
        return _fife.Route_getRouteStatus(self)


    def setStartNode(self, node):
        """setStartNode(Route self, Location node)"""
        return _fife.Route_setStartNode(self, node)


    def getStartNode(self):
        """getStartNode(Route self) -> Location"""
        return _fife.Route_getStartNode(self)


    def setEndNode(self, node):
        """setEndNode(Route self, Location node)"""
        return _fife.Route_setEndNode(self, node)


    def getEndNode(self):
        """getEndNode(Route self) -> Location"""
        return _fife.Route_getEndNode(self)


    def getCurrentNode(self):
        """getCurrentNode(Route self) -> Location"""
        return _fife.Route_getCurrentNode(self)


    def getPreviousNode(self):
        """getPreviousNode(Route self) -> Location"""
        return _fife.Route_getPreviousNode(self)


    def getNextNode(self):
        """getNextNode(Route self) -> Location"""
        return _fife.Route_getNextNode(self)


    def walkToNextNode(self, step=1):
        """walkToNextNode(Route self, int32_t step=1) -> bool"""
        return _fife.Route_walkToNextNode(self, step)


    def reachedEnd(self):
        """reachedEnd(Route self) -> bool"""
        return _fife.Route_reachedEnd(self)


    def setPath(self, path):
        """setPath(Route self, LocationList path)"""
        return _fife.Route_setPath(self, path)


    def getPath(self):
        """getPath(Route self) -> LocationList"""
        return _fife.Route_getPath(self)


    def cutPath(self, length=1):
        """cutPath(Route self, uint32_t length=1)"""
        return _fife.Route_cutPath(self, length)


    def setReplanned(self, replanned):
        """setReplanned(Route self, bool replanned)"""
        return _fife.Route_setReplanned(self, replanned)


    def isReplanned(self):
        """isReplanned(Route self) -> bool"""
        return _fife.Route_isReplanned(self)


    def getPathLength(self):
        """getPathLength(Route self) -> uint32_t"""
        return _fife.Route_getPathLength(self)


    def getWalkedLength(self):
        """getWalkedLength(Route self) -> uint32_t"""
        return _fife.Route_getWalkedLength(self)


    def setSessionId(self, id):
        """setSessionId(Route self, int32_t id)"""
        return _fife.Route_setSessionId(self, id)


    def getSessionId(self):
        """getSessionId(Route self) -> int32_t"""
        return _fife.Route_getSessionId(self)


    def setRotation(self, rotation):
        """setRotation(Route self, int32_t rotation)"""
        return _fife.Route_setRotation(self, rotation)


    def getRotation(self):
        """getRotation(Route self) -> int32_t"""
        return _fife.Route_getRotation(self)


    def setCostId(self, cost):
        """setCostId(Route self, std::string const & cost)"""
        return _fife.Route_setCostId(self, cost)


    def getCostId(self):
        """getCostId(Route self) -> std::string const &"""
        return _fife.Route_getCostId(self)


    def isMultiCell(self):
        """isMultiCell(Route self) -> bool"""
        return _fife.Route_isMultiCell(self)


    def setOccupiedArea(self, area):
        """setOccupiedArea(Route self, std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > > const & area)"""
        return _fife.Route_setOccupiedArea(self, area)


    def getOccupiedArea(self):
        """getOccupiedArea(Route self) -> std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > > const &"""
        return _fife.Route_getOccupiedArea(self)


    def getOccupiedCells(self, rotation):
        """getOccupiedCells(Route self, int32_t rotation) -> std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > >"""
        return _fife.Route_getOccupiedCells(self, rotation)


    def getZStepRange(self):
        """getZStepRange(Route self) -> int32_t"""
        return _fife.Route_getZStepRange(self)


    def isAreaLimited(self):
        """isAreaLimited(Route self) -> bool"""
        return _fife.Route_isAreaLimited(self)


    def getLimitedAreas(self):
        """getLimitedAreas(Route self) -> StringList"""
        return _fife.Route_getLimitedAreas(self)


    def setDynamicBlockerIgnored(self, ignore):
        """setDynamicBlockerIgnored(Route self, bool ignore)"""
        return _fife.Route_setDynamicBlockerIgnored(self, ignore)


    def isDynamicBlockerIgnored(self):
        """isDynamicBlockerIgnored(Route self) -> bool"""
        return _fife.Route_isDynamicBlockerIgnored(self)


    def getBlockingPathLocations(self):
        """getBlockingPathLocations(Route self) -> LocationList"""
        return _fife.Route_getBlockingPathLocations(self)


    def setObject(self, obj):
        """setObject(Route self, Object obj)"""
        return _fife.Route_setObject(self, obj)


    def getObject(self):
        """getObject(Route self) -> Object"""
        return _fife.Route_getObject(self)

Route.setRouteStatus = new_instancemethod(_fife.Route_setRouteStatus, None, Route)
Route.getRouteStatus = new_instancemethod(_fife.Route_getRouteStatus, None, Route)
Route.setStartNode = new_instancemethod(_fife.Route_setStartNode, None, Route)
Route.getStartNode = new_instancemethod(_fife.Route_getStartNode, None, Route)
Route.setEndNode = new_instancemethod(_fife.Route_setEndNode, None, Route)
Route.getEndNode = new_instancemethod(_fife.Route_getEndNode, None, Route)
Route.getCurrentNode = new_instancemethod(_fife.Route_getCurrentNode, None, Route)
Route.getPreviousNode = new_instancemethod(_fife.Route_getPreviousNode, None, Route)
Route.getNextNode = new_instancemethod(_fife.Route_getNextNode, None, Route)
Route.walkToNextNode = new_instancemethod(_fife.Route_walkToNextNode, None, Route)
Route.reachedEnd = new_instancemethod(_fife.Route_reachedEnd, None, Route)
Route.setPath = new_instancemethod(_fife.Route_setPath, None, Route)
Route.getPath = new_instancemethod(_fife.Route_getPath, None, Route)
Route.cutPath = new_instancemethod(_fife.Route_cutPath, None, Route)
Route.setReplanned = new_instancemethod(_fife.Route_setReplanned, None, Route)
Route.isReplanned = new_instancemethod(_fife.Route_isReplanned, None, Route)
Route.getPathLength = new_instancemethod(_fife.Route_getPathLength, None, Route)
Route.getWalkedLength = new_instancemethod(_fife.Route_getWalkedLength, None, Route)
Route.setSessionId = new_instancemethod(_fife.Route_setSessionId, None, Route)
Route.getSessionId = new_instancemethod(_fife.Route_getSessionId, None, Route)
Route.setRotation = new_instancemethod(_fife.Route_setRotation, None, Route)
Route.getRotation = new_instancemethod(_fife.Route_getRotation, None, Route)
Route.setCostId = new_instancemethod(_fife.Route_setCostId, None, Route)
Route.getCostId = new_instancemethod(_fife.Route_getCostId, None, Route)
Route.isMultiCell = new_instancemethod(_fife.Route_isMultiCell, None, Route)
Route.setOccupiedArea = new_instancemethod(_fife.Route_setOccupiedArea, None, Route)
Route.getOccupiedArea = new_instancemethod(_fife.Route_getOccupiedArea, None, Route)
Route.getOccupiedCells = new_instancemethod(_fife.Route_getOccupiedCells, None, Route)
Route.getZStepRange = new_instancemethod(_fife.Route_getZStepRange, None, Route)
Route.isAreaLimited = new_instancemethod(_fife.Route_isAreaLimited, None, Route)
Route.getLimitedAreas = new_instancemethod(_fife.Route_getLimitedAreas, None, Route)
Route.setDynamicBlockerIgnored = new_instancemethod(_fife.Route_setDynamicBlockerIgnored, None, Route)
Route.isDynamicBlockerIgnored = new_instancemethod(_fife.Route_isDynamicBlockerIgnored, None, Route)
Route.getBlockingPathLocations = new_instancemethod(_fife.Route_getBlockingPathLocations, None, Route)
Route.setObject = new_instancemethod(_fife.Route_setObject, None, Route)
Route.getObject = new_instancemethod(_fife.Route_getObject, None, Route)
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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IPather

    def createRoute(self, *args, **kwargs):
        """createRoute(IPather self, Location start, Location end, bool immediate=False, std::string const & cost_id) -> Route"""
        return _fife.IPather_createRoute(self, *args, **kwargs)


    def solveRoute(self, *args, **kwargs):
        """solveRoute(IPather self, Route route, int32_t priority, bool immediate=False) -> bool"""
        return _fife.IPather_solveRoute(self, *args, **kwargs)


    def followRoute(self, current, route, speed, nextLocation):
        """followRoute(IPather self, Location current, Route route, double speed, Location nextLocation) -> bool"""
        return _fife.IPather_followRoute(self, current, route, speed, nextLocation)


    def update(self):
        """update(IPather self)"""
        return _fife.IPather_update(self)


    def cancelSession(self, sessionId):
        """cancelSession(IPather self, int32_t const sessionId) -> bool"""
        return _fife.IPather_cancelSession(self, sessionId)


    def setMaxTicks(self, ticks):
        """setMaxTicks(IPather self, int32_t ticks)"""
        return _fife.IPather_setMaxTicks(self, ticks)


    def getMaxTicks(self):
        """getMaxTicks(IPather self) -> int32_t"""
        return _fife.IPather_getMaxTicks(self)


    def getName(self):
        """getName(IPather self) -> std::string"""
        return _fife.IPather_getName(self)


    def __init__(self):
        """__init__(FIFE::IPather self) -> IPather"""
        if self.__class__ == IPather:
            _self = None
        else:
            _self = self
        _fife.IPather_swiginit(self, _fife.new_IPather(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IPather(self)
        return weakref_proxy(self)
IPather.createRoute = new_instancemethod(_fife.IPather_createRoute, None, IPather)
IPather.solveRoute = new_instancemethod(_fife.IPather_solveRoute, None, IPather)
IPather.followRoute = new_instancemethod(_fife.IPather_followRoute, None, IPather)
IPather.update = new_instancemethod(_fife.IPather_update, None, IPather)
IPather.cancelSession = new_instancemethod(_fife.IPather_cancelSession, None, IPather)
IPather.setMaxTicks = new_instancemethod(_fife.IPather_setMaxTicks, None, IPather)
IPather.getMaxTicks = new_instancemethod(_fife.IPather_getMaxTicks, None, IPather)
IPather.getName = new_instancemethod(_fife.IPather_getName, None, IPather)
IPather_swigregister = _fife.IPather_swigregister
IPather_swigregister(IPather)

class Object(object):
    """Proxy of C++ FIFE::Object class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, identifier, name_space, inherited=None):
        """__init__(FIFE::Object self, std::string const & identifier, std::string const & name_space, Object inherited=None) -> Object"""
        _fife.Object_swiginit(self, _fife.new_Object(identifier, name_space, inherited))
    __swig_destroy__ = _fife.delete_Object

    def getId(self):
        """getId(Object self) -> std::string const &"""
        return _fife.Object_getId(self)


    def getNamespace(self):
        """getNamespace(Object self) -> std::string const &"""
        return _fife.Object_getNamespace(self)


    def setId(self, id):
        """setId(Object self, std::string const & id)"""
        return _fife.Object_setId(self, id)


    def createAction(self, identifier, is_default=False):
        """createAction(Object self, std::string const & identifier, bool is_default=False) -> Action"""
        return _fife.Object_createAction(self, identifier, is_default)


    def getAction(self, identifier, deepsearch=True):
        """getAction(Object self, std::string const & identifier, bool deepsearch=True) -> Action"""
        return _fife.Object_getAction(self, identifier, deepsearch)


    def getActionIds(self):
        """getActionIds(Object self) -> StringList"""
        return _fife.Object_getActionIds(self)


    def setDefaultAction(self, identifier):
        """setDefaultAction(Object self, std::string const & identifier)"""
        return _fife.Object_setDefaultAction(self, identifier)


    def getDefaultAction(self):
        """getDefaultAction(Object self) -> Action"""
        return _fife.Object_getDefaultAction(self)


    def setPather(self, pather):
        """setPather(Object self, IPather pather)"""
        return _fife.Object_setPather(self, pather)


    def getPather(self):
        """getPather(Object self) -> IPather"""
        return _fife.Object_getPather(self)


    def getInherited(self):
        """getInherited(Object self) -> Object"""
        return _fife.Object_getInherited(self)


    def adoptVisual(self, visual):
        """adoptVisual(Object self, IVisual visual)"""
        return _fife.Object_adoptVisual(self, visual)


    def setBlocking(self, blocking):
        """setBlocking(Object self, bool blocking)"""
        return _fife.Object_setBlocking(self, blocking)


    def isBlocking(self):
        """isBlocking(Object self) -> bool"""
        return _fife.Object_isBlocking(self)


    def setStatic(self, stat):
        """setStatic(Object self, bool stat)"""
        return _fife.Object_setStatic(self, stat)


    def isStatic(self):
        """isStatic(Object self) -> bool"""
        return _fife.Object_isStatic(self)


    def setFilename(self, file):
        """setFilename(Object self, std::string const & file)"""
        return _fife.Object_setFilename(self, file)


    def getFilename(self):
        """getFilename(Object self) -> std::string const &"""
        return _fife.Object_getFilename(self)


    def setCellStackPosition(self, position):
        """setCellStackPosition(Object self, uint8_t position)"""
        return _fife.Object_setCellStackPosition(self, position)


    def getCellStackPosition(self):
        """getCellStackPosition(Object self) -> uint8_t"""
        return _fife.Object_getCellStackPosition(self)


    def isSpecialCost(self):
        """isSpecialCost(Object self) -> bool"""
        return _fife.Object_isSpecialCost(self)


    def setCostId(self, cost):
        """setCostId(Object self, std::string const & cost)"""
        return _fife.Object_setCostId(self, cost)


    def getCostId(self):
        """getCostId(Object self) -> std::string"""
        return _fife.Object_getCostId(self)


    def setCost(self, cost):
        """setCost(Object self, double cost)"""
        return _fife.Object_setCost(self, cost)


    def getCost(self):
        """getCost(Object self) -> double"""
        return _fife.Object_getCost(self)


    def isSpecialSpeed(self):
        """isSpecialSpeed(Object self) -> bool"""
        return _fife.Object_isSpecialSpeed(self)


    def setSpeed(self, cost):
        """setSpeed(Object self, double cost)"""
        return _fife.Object_setSpeed(self, cost)


    def getSpeed(self):
        """getSpeed(Object self) -> double"""
        return _fife.Object_getSpeed(self)


    def isMultiObject(self):
        """isMultiObject(Object self) -> bool"""
        return _fife.Object_isMultiObject(self)


    def addMultiPartId(self, partId):
        """addMultiPartId(Object self, std::string const & partId)"""
        return _fife.Object_addMultiPartId(self, partId)


    def getMultiPartIds(self):
        """getMultiPartIds(Object self) -> StringList"""
        return _fife.Object_getMultiPartIds(self)


    def removeMultiPartId(self, partId):
        """removeMultiPartId(Object self, std::string const & partId)"""
        return _fife.Object_removeMultiPartId(self, partId)


    def removeAllMultiPartIds(self):
        """removeAllMultiPartIds(Object self)"""
        return _fife.Object_removeAllMultiPartIds(self)


    def isMultiPart(self):
        """isMultiPart(Object self) -> bool"""
        return _fife.Object_isMultiPart(self)


    def setMultiPart(self, part):
        """setMultiPart(Object self, bool part)"""
        return _fife.Object_setMultiPart(self, part)


    def addMultiPart(self, obj):
        """addMultiPart(Object self, Object obj)"""
        return _fife.Object_addMultiPart(self, obj)


    def getMultiParts(self):
        """getMultiParts(Object self) -> std::set< FIFE::Object *,std::less< FIFE::Object * >,std::allocator< FIFE::Object * > >"""
        return _fife.Object_getMultiParts(self)


    def removeMultiPart(self, obj):
        """removeMultiPart(Object self, Object obj)"""
        return _fife.Object_removeMultiPart(self, obj)


    def removeMultiParts(self):
        """removeMultiParts(Object self)"""
        return _fife.Object_removeMultiParts(self)


    def addMultiPartCoordinate(self, rotation, coord):
        """addMultiPartCoordinate(Object self, int32_t rotation, Point3D coord)"""
        return _fife.Object_addMultiPartCoordinate(self, rotation, coord)


    def getMultiPartCoordinates(self, *args):
        """
        getMultiPartCoordinates(Object self) -> std::multimap< int32_t,FIFE::ModelCoordinate >
        getMultiPartCoordinates(Object self, int32_t rotation) -> std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > >
        """
        return _fife.Object_getMultiPartCoordinates(self, *args)


    def getMultiObjectCoordinates(self, rotation):
        """getMultiObjectCoordinates(Object self, int32_t rotation) -> std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > >"""
        return _fife.Object_getMultiObjectCoordinates(self, rotation)


    def setRotationAnchor(self, anchor):
        """setRotationAnchor(Object self, DoublePoint3D anchor)"""
        return _fife.Object_setRotationAnchor(self, anchor)


    def getRotationAnchor(self):
        """getRotationAnchor(Object self) -> DoublePoint3D"""
        return _fife.Object_getRotationAnchor(self)


    def setRestrictedRotation(self, restrict):
        """setRestrictedRotation(Object self, bool restrict)"""
        return _fife.Object_setRestrictedRotation(self, restrict)


    def isRestrictedRotation(self):
        """isRestrictedRotation(Object self) -> bool"""
        return _fife.Object_isRestrictedRotation(self)


    def getRestrictedRotation(self, rotation):
        """getRestrictedRotation(Object self, int32_t rotation) -> int32_t"""
        return _fife.Object_getRestrictedRotation(self, rotation)


    def setZStepRange(self, zRange):
        """setZStepRange(Object self, int32_t zRange)"""
        return _fife.Object_setZStepRange(self, zRange)


    def getZStepRange(self):
        """getZStepRange(Object self) -> int32_t"""
        return _fife.Object_getZStepRange(self)


    def setArea(self, id):
        """setArea(Object self, std::string const & id)"""
        return _fife.Object_setArea(self, id)


    def getArea(self):
        """getArea(Object self) -> std::string"""
        return _fife.Object_getArea(self)


    def addWalkableArea(self, id):
        """addWalkableArea(Object self, std::string const & id)"""
        return _fife.Object_addWalkableArea(self, id)


    def removeWalkableArea(self, id):
        """removeWalkableArea(Object self, std::string const & id)"""
        return _fife.Object_removeWalkableArea(self, id)


    def getWalkableAreas(self):
        """getWalkableAreas(Object self) -> StringList"""
        return _fife.Object_getWalkableAreas(self)


    def __eq__(self, obj):
        """__eq__(Object self, Object obj) -> bool"""
        return _fife.Object___eq__(self, obj)


    def __ne__(self, obj):
        """__ne__(Object self, Object obj) -> bool"""
        return _fife.Object___ne__(self, obj)


    def get2dGfxVisual(self):
        """get2dGfxVisual(Object self) -> ObjectVisual"""
        return _fife.Object_get2dGfxVisual(self)

Object.getId = new_instancemethod(_fife.Object_getId, None, Object)
Object.getNamespace = new_instancemethod(_fife.Object_getNamespace, None, Object)
Object.setId = new_instancemethod(_fife.Object_setId, None, Object)
Object.createAction = new_instancemethod(_fife.Object_createAction, None, Object)
Object.getAction = new_instancemethod(_fife.Object_getAction, None, Object)
Object.getActionIds = new_instancemethod(_fife.Object_getActionIds, None, Object)
Object.setDefaultAction = new_instancemethod(_fife.Object_setDefaultAction, None, Object)
Object.getDefaultAction = new_instancemethod(_fife.Object_getDefaultAction, None, Object)
Object.setPather = new_instancemethod(_fife.Object_setPather, None, Object)
Object.getPather = new_instancemethod(_fife.Object_getPather, None, Object)
Object.getInherited = new_instancemethod(_fife.Object_getInherited, None, Object)
Object.adoptVisual = new_instancemethod(_fife.Object_adoptVisual, None, Object)
Object.setBlocking = new_instancemethod(_fife.Object_setBlocking, None, Object)
Object.isBlocking = new_instancemethod(_fife.Object_isBlocking, None, Object)
Object.setStatic = new_instancemethod(_fife.Object_setStatic, None, Object)
Object.isStatic = new_instancemethod(_fife.Object_isStatic, None, Object)
Object.setFilename = new_instancemethod(_fife.Object_setFilename, None, Object)
Object.getFilename = new_instancemethod(_fife.Object_getFilename, None, Object)
Object.setCellStackPosition = new_instancemethod(_fife.Object_setCellStackPosition, None, Object)
Object.getCellStackPosition = new_instancemethod(_fife.Object_getCellStackPosition, None, Object)
Object.isSpecialCost = new_instancemethod(_fife.Object_isSpecialCost, None, Object)
Object.setCostId = new_instancemethod(_fife.Object_setCostId, None, Object)
Object.getCostId = new_instancemethod(_fife.Object_getCostId, None, Object)
Object.setCost = new_instancemethod(_fife.Object_setCost, None, Object)
Object.getCost = new_instancemethod(_fife.Object_getCost, None, Object)
Object.isSpecialSpeed = new_instancemethod(_fife.Object_isSpecialSpeed, None, Object)
Object.setSpeed = new_instancemethod(_fife.Object_setSpeed, None, Object)
Object.getSpeed = new_instancemethod(_fife.Object_getSpeed, None, Object)
Object.isMultiObject = new_instancemethod(_fife.Object_isMultiObject, None, Object)
Object.addMultiPartId = new_instancemethod(_fife.Object_addMultiPartId, None, Object)
Object.getMultiPartIds = new_instancemethod(_fife.Object_getMultiPartIds, None, Object)
Object.removeMultiPartId = new_instancemethod(_fife.Object_removeMultiPartId, None, Object)
Object.removeAllMultiPartIds = new_instancemethod(_fife.Object_removeAllMultiPartIds, None, Object)
Object.isMultiPart = new_instancemethod(_fife.Object_isMultiPart, None, Object)
Object.setMultiPart = new_instancemethod(_fife.Object_setMultiPart, None, Object)
Object.addMultiPart = new_instancemethod(_fife.Object_addMultiPart, None, Object)
Object.getMultiParts = new_instancemethod(_fife.Object_getMultiParts, None, Object)
Object.removeMultiPart = new_instancemethod(_fife.Object_removeMultiPart, None, Object)
Object.removeMultiParts = new_instancemethod(_fife.Object_removeMultiParts, None, Object)
Object.addMultiPartCoordinate = new_instancemethod(_fife.Object_addMultiPartCoordinate, None, Object)
Object.getMultiPartCoordinates = new_instancemethod(_fife.Object_getMultiPartCoordinates, None, Object)
Object.getMultiObjectCoordinates = new_instancemethod(_fife.Object_getMultiObjectCoordinates, None, Object)
Object.setRotationAnchor = new_instancemethod(_fife.Object_setRotationAnchor, None, Object)
Object.getRotationAnchor = new_instancemethod(_fife.Object_getRotationAnchor, None, Object)
Object.setRestrictedRotation = new_instancemethod(_fife.Object_setRestrictedRotation, None, Object)
Object.isRestrictedRotation = new_instancemethod(_fife.Object_isRestrictedRotation, None, Object)
Object.getRestrictedRotation = new_instancemethod(_fife.Object_getRestrictedRotation, None, Object)
Object.setZStepRange = new_instancemethod(_fife.Object_setZStepRange, None, Object)
Object.getZStepRange = new_instancemethod(_fife.Object_getZStepRange, None, Object)
Object.setArea = new_instancemethod(_fife.Object_setArea, None, Object)
Object.getArea = new_instancemethod(_fife.Object_getArea, None, Object)
Object.addWalkableArea = new_instancemethod(_fife.Object_addWalkableArea, None, Object)
Object.removeWalkableArea = new_instancemethod(_fife.Object_removeWalkableArea, None, Object)
Object.getWalkableAreas = new_instancemethod(_fife.Object_getWalkableAreas, None, Object)
Object.__eq__ = new_instancemethod(_fife.Object___eq__, None, Object)
Object.__ne__ = new_instancemethod(_fife.Object___ne__, None, Object)
Object.get2dGfxVisual = new_instancemethod(_fife.Object_get2dGfxVisual, None, Object)
Object_swigregister = _fife.Object_swigregister
Object_swigregister(Object)

class TimeProvider(object):
    """Proxy of C++ FIFE::TimeProvider class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, master):
        """__init__(FIFE::TimeProvider self, TimeProvider master) -> TimeProvider"""
        _fife.TimeProvider_swiginit(self, _fife.new_TimeProvider(master))
    __swig_destroy__ = _fife.delete_TimeProvider

    def setMultiplier(self, multiplier):
        """setMultiplier(TimeProvider self, float multiplier)"""
        return _fife.TimeProvider_setMultiplier(self, multiplier)


    def getMultiplier(self):
        """getMultiplier(TimeProvider self) -> float"""
        return _fife.TimeProvider_getMultiplier(self)


    def getTotalMultiplier(self):
        """getTotalMultiplier(TimeProvider self) -> float"""
        return _fife.TimeProvider_getTotalMultiplier(self)


    def getGameTime(self):
        """getGameTime(TimeProvider self) -> uint32_t"""
        return _fife.TimeProvider_getGameTime(self)

TimeProvider.setMultiplier = new_instancemethod(_fife.TimeProvider_setMultiplier, None, TimeProvider)
TimeProvider.getMultiplier = new_instancemethod(_fife.TimeProvider_getMultiplier, None, TimeProvider)
TimeProvider.getTotalMultiplier = new_instancemethod(_fife.TimeProvider_getTotalMultiplier, None, TimeProvider)
TimeProvider.getGameTime = new_instancemethod(_fife.TimeProvider_getGameTime, None, TimeProvider)
TimeProvider_swigregister = _fife.TimeProvider_swigregister
TimeProvider_swigregister(TimeProvider)

class ModelCoordinateVector(object):
    """Proxy of C++ std::vector<(FIFE::ModelCoordinate)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(ModelCoordinateVector self) -> SwigPyIterator"""
        return _fife.ModelCoordinateVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ModelCoordinateVector self) -> bool"""
        return _fife.ModelCoordinateVector___nonzero__(self)


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


    def __len__(self):
        """__len__(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::size_type"""
        return _fife.ModelCoordinateVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::difference_type i, std::vector< FIFE::PointType3D< int > >::difference_type j) -> std::vector< FIFE::PointType3D< int32_t >,std::allocator< FIFE::PointType3D< int32_t > > > *"""
        return _fife.ModelCoordinateVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::difference_type i, std::vector< FIFE::PointType3D< int > >::difference_type j)
        __setslice__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::difference_type i, std::vector< FIFE::PointType3D< int > >::difference_type j, std::vector< FIFE::PointType3D< int32_t >,std::allocator< FIFE::PointType3D< int32_t > > > const & v)
        """
        return _fife.ModelCoordinateVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::difference_type i, std::vector< FIFE::PointType3D< int > >::difference_type j)"""
        return _fife.ModelCoordinateVector___delslice__(self, i, j)


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


    def __getitem__(self, *args):
        """
        __getitem__(ModelCoordinateVector self, PySliceObject * slice) -> std::vector< FIFE::PointType3D< int32_t >,std::allocator< FIFE::PointType3D< int32_t > > >
        __getitem__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::difference_type i) -> Point3D
        """
        return _fife.ModelCoordinateVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ModelCoordinateVector self, PySliceObject * slice, std::vector< FIFE::PointType3D< int32_t >,std::allocator< FIFE::PointType3D< int32_t > > > const & v)
        __setitem__(ModelCoordinateVector self, PySliceObject * slice)
        __setitem__(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::difference_type i, Point3D x)
        """
        return _fife.ModelCoordinateVector___setitem__(self, *args)


    def pop(self):
        """pop(ModelCoordinateVector self) -> Point3D"""
        return _fife.ModelCoordinateVector_pop(self)


    def append(self, x):
        """append(ModelCoordinateVector self, Point3D x)"""
        return _fife.ModelCoordinateVector_append(self, x)


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


    def size(self):
        """size(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::size_type"""
        return _fife.ModelCoordinateVector_size(self)


    def swap(self, v):
        """swap(ModelCoordinateVector self, ModelCoordinateVector v)"""
        return _fife.ModelCoordinateVector_swap(self, v)


    def begin(self):
        """begin(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::iterator"""
        return _fife.ModelCoordinateVector_begin(self)


    def end(self):
        """end(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::iterator"""
        return _fife.ModelCoordinateVector_end(self)


    def rbegin(self):
        """rbegin(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::reverse_iterator"""
        return _fife.ModelCoordinateVector_rbegin(self)


    def rend(self):
        """rend(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::reverse_iterator"""
        return _fife.ModelCoordinateVector_rend(self)


    def clear(self):
        """clear(ModelCoordinateVector self)"""
        return _fife.ModelCoordinateVector_clear(self)


    def get_allocator(self):
        """get_allocator(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::allocator_type"""
        return _fife.ModelCoordinateVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ModelCoordinateVector self)"""
        return _fife.ModelCoordinateVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::iterator pos) -> std::vector< FIFE::PointType3D< int > >::iterator
        erase(ModelCoordinateVector 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__(std::vector<(FIFE::ModelCoordinate)> self) -> ModelCoordinateVector
        __init__(std::vector<(FIFE::ModelCoordinate)> self, ModelCoordinateVector arg2) -> ModelCoordinateVector
        __init__(std::vector<(FIFE::ModelCoordinate)> self, std::vector< FIFE::PointType3D< int > >::size_type size) -> ModelCoordinateVector
        __init__(std::vector<(FIFE::ModelCoordinate)> self, std::vector< FIFE::PointType3D< int > >::size_type size, Point3D value) -> ModelCoordinateVector
        """
        _fife.ModelCoordinateVector_swiginit(self, _fife.new_ModelCoordinateVector(*args))

    def push_back(self, x):
        """push_back(ModelCoordinateVector self, Point3D x)"""
        return _fife.ModelCoordinateVector_push_back(self, x)


    def front(self):
        """front(ModelCoordinateVector self) -> Point3D"""
        return _fife.ModelCoordinateVector_front(self)


    def back(self):
        """back(ModelCoordinateVector self) -> Point3D"""
        return _fife.ModelCoordinateVector_back(self)


    def assign(self, n, x):
        """assign(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::size_type n, Point3D x)"""
        return _fife.ModelCoordinateVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::size_type new_size)
        resize(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::size_type new_size, Point3D x)
        """
        return _fife.ModelCoordinateVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::iterator pos, Point3D x) -> std::vector< FIFE::PointType3D< int > >::iterator
        insert(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::iterator pos, std::vector< FIFE::PointType3D< int > >::size_type n, Point3D x)
        """
        return _fife.ModelCoordinateVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ModelCoordinateVector self, std::vector< FIFE::PointType3D< int > >::size_type n)"""
        return _fife.ModelCoordinateVector_reserve(self, n)


    def capacity(self):
        """capacity(ModelCoordinateVector self) -> std::vector< FIFE::PointType3D< int > >::size_type"""
        return _fife.ModelCoordinateVector_capacity(self)

    __swig_destroy__ = _fife.delete_ModelCoordinateVector
ModelCoordinateVector.iterator = new_instancemethod(_fife.ModelCoordinateVector_iterator, None, ModelCoordinateVector)
ModelCoordinateVector.__nonzero__ = new_instancemethod(_fife.ModelCoordinateVector___nonzero__, None, ModelCoordinateVector)
ModelCoordinateVector.__bool__ = new_instancemethod(_fife.ModelCoordinateVector___bool__, None, ModelCoordinateVector)
ModelCoordinateVector.__len__ = new_instancemethod(_fife.ModelCoordinateVector___len__, None, ModelCoordinateVector)
ModelCoordinateVector.__getslice__ = new_instancemethod(_fife.ModelCoordinateVector___getslice__, None, ModelCoordinateVector)
ModelCoordinateVector.__setslice__ = new_instancemethod(_fife.ModelCoordinateVector___setslice__, None, ModelCoordinateVector)
ModelCoordinateVector.__delslice__ = new_instancemethod(_fife.ModelCoordinateVector___delslice__, None, ModelCoordinateVector)
ModelCoordinateVector.__delitem__ = new_instancemethod(_fife.ModelCoordinateVector___delitem__, None, ModelCoordinateVector)
ModelCoordinateVector.__getitem__ = new_instancemethod(_fife.ModelCoordinateVector___getitem__, None, ModelCoordinateVector)
ModelCoordinateVector.__setitem__ = new_instancemethod(_fife.ModelCoordinateVector___setitem__, None, ModelCoordinateVector)
ModelCoordinateVector.pop = new_instancemethod(_fife.ModelCoordinateVector_pop, None, ModelCoordinateVector)
ModelCoordinateVector.append = new_instancemethod(_fife.ModelCoordinateVector_append, None, ModelCoordinateVector)
ModelCoordinateVector.empty = new_instancemethod(_fife.ModelCoordinateVector_empty, None, ModelCoordinateVector)
ModelCoordinateVector.size = new_instancemethod(_fife.ModelCoordinateVector_size, None, ModelCoordinateVector)
ModelCoordinateVector.swap = new_instancemethod(_fife.ModelCoordinateVector_swap, None, ModelCoordinateVector)
ModelCoordinateVector.begin = new_instancemethod(_fife.ModelCoordinateVector_begin, None, ModelCoordinateVector)
ModelCoordinateVector.end = new_instancemethod(_fife.ModelCoordinateVector_end, None, ModelCoordinateVector)
ModelCoordinateVector.rbegin = new_instancemethod(_fife.ModelCoordinateVector_rbegin, None, ModelCoordinateVector)
ModelCoordinateVector.rend = new_instancemethod(_fife.ModelCoordinateVector_rend, None, ModelCoordinateVector)
ModelCoordinateVector.clear = new_instancemethod(_fife.ModelCoordinateVector_clear, None, ModelCoordinateVector)
ModelCoordinateVector.get_allocator = new_instancemethod(_fife.ModelCoordinateVector_get_allocator, None, ModelCoordinateVector)
ModelCoordinateVector.pop_back = new_instancemethod(_fife.ModelCoordinateVector_pop_back, None, ModelCoordinateVector)
ModelCoordinateVector.erase = new_instancemethod(_fife.ModelCoordinateVector_erase, None, ModelCoordinateVector)
ModelCoordinateVector.push_back = new_instancemethod(_fife.ModelCoordinateVector_push_back, None, ModelCoordinateVector)
ModelCoordinateVector.front = new_instancemethod(_fife.ModelCoordinateVector_front, None, ModelCoordinateVector)
ModelCoordinateVector.back = new_instancemethod(_fife.ModelCoordinateVector_back, None, ModelCoordinateVector)
ModelCoordinateVector.assign = new_instancemethod(_fife.ModelCoordinateVector_assign, None, ModelCoordinateVector)
ModelCoordinateVector.resize = new_instancemethod(_fife.ModelCoordinateVector_resize, None, ModelCoordinateVector)
ModelCoordinateVector.insert = new_instancemethod(_fife.ModelCoordinateVector_insert, None, ModelCoordinateVector)
ModelCoordinateVector.reserve = new_instancemethod(_fife.ModelCoordinateVector_reserve, None, ModelCoordinateVector)
ModelCoordinateVector.capacity = new_instancemethod(_fife.ModelCoordinateVector_capacity, None, ModelCoordinateVector)
ModelCoordinateVector_swigregister = _fife.ModelCoordinateVector_swigregister
ModelCoordinateVector_swigregister(ModelCoordinateVector)

class ExactModelCoordinateVector(object):
    """Proxy of C++ std::vector<(FIFE::ExactModelCoordinate)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(ExactModelCoordinateVector self) -> SwigPyIterator"""
        return _fife.ExactModelCoordinateVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ExactModelCoordinateVector self) -> bool"""
        return _fife.ExactModelCoordinateVector___nonzero__(self)


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


    def __len__(self):
        """__len__(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::size_type"""
        return _fife.ExactModelCoordinateVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::difference_type i, std::vector< FIFE::PointType3D< double > >::difference_type j) -> ExactModelCoordinateVector"""
        return _fife.ExactModelCoordinateVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::difference_type i, std::vector< FIFE::PointType3D< double > >::difference_type j)
        __setslice__(ExactModelCoordinateVector 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, i, j):
        """__delslice__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::difference_type i, std::vector< FIFE::PointType3D< double > >::difference_type j)"""
        return _fife.ExactModelCoordinateVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::difference_type i)
        __delitem__(ExactModelCoordinateVector self, PySliceObject * slice)
        """
        return _fife.ExactModelCoordinateVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ExactModelCoordinateVector self, PySliceObject * slice) -> ExactModelCoordinateVector
        __getitem__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::difference_type i) -> DoublePoint3D
        """
        return _fife.ExactModelCoordinateVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ExactModelCoordinateVector self, PySliceObject * slice, ExactModelCoordinateVector v)
        __setitem__(ExactModelCoordinateVector self, PySliceObject * slice)
        __setitem__(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::difference_type i, DoublePoint3D x)
        """
        return _fife.ExactModelCoordinateVector___setitem__(self, *args)


    def pop(self):
        """pop(ExactModelCoordinateVector self) -> DoublePoint3D"""
        return _fife.ExactModelCoordinateVector_pop(self)


    def append(self, x):
        """append(ExactModelCoordinateVector self, DoublePoint3D x)"""
        return _fife.ExactModelCoordinateVector_append(self, x)


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


    def size(self):
        """size(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::size_type"""
        return _fife.ExactModelCoordinateVector_size(self)


    def swap(self, v):
        """swap(ExactModelCoordinateVector self, ExactModelCoordinateVector v)"""
        return _fife.ExactModelCoordinateVector_swap(self, v)


    def begin(self):
        """begin(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::iterator"""
        return _fife.ExactModelCoordinateVector_begin(self)


    def end(self):
        """end(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::iterator"""
        return _fife.ExactModelCoordinateVector_end(self)


    def rbegin(self):
        """rbegin(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::reverse_iterator"""
        return _fife.ExactModelCoordinateVector_rbegin(self)


    def rend(self):
        """rend(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::reverse_iterator"""
        return _fife.ExactModelCoordinateVector_rend(self)


    def clear(self):
        """clear(ExactModelCoordinateVector self)"""
        return _fife.ExactModelCoordinateVector_clear(self)


    def get_allocator(self):
        """get_allocator(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::allocator_type"""
        return _fife.ExactModelCoordinateVector_get_allocator(self)


    def pop_back(self):
        """pop_back(ExactModelCoordinateVector self)"""
        return _fife.ExactModelCoordinateVector_pop_back(self)


    def erase(self, *args):
        """
        erase(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::iterator pos) -> std::vector< FIFE::PointType3D< double > >::iterator
        erase(ExactModelCoordinateVector 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__(std::vector<(FIFE::ExactModelCoordinate)> self) -> ExactModelCoordinateVector
        __init__(std::vector<(FIFE::ExactModelCoordinate)> self, ExactModelCoordinateVector arg2) -> ExactModelCoordinateVector
        __init__(std::vector<(FIFE::ExactModelCoordinate)> self, std::vector< FIFE::PointType3D< double > >::size_type size) -> ExactModelCoordinateVector
        __init__(std::vector<(FIFE::ExactModelCoordinate)> self, std::vector< FIFE::PointType3D< double > >::size_type size, DoublePoint3D value) -> ExactModelCoordinateVector
        """
        _fife.ExactModelCoordinateVector_swiginit(self, _fife.new_ExactModelCoordinateVector(*args))

    def push_back(self, x):
        """push_back(ExactModelCoordinateVector self, DoublePoint3D x)"""
        return _fife.ExactModelCoordinateVector_push_back(self, x)


    def front(self):
        """front(ExactModelCoordinateVector self) -> DoublePoint3D"""
        return _fife.ExactModelCoordinateVector_front(self)


    def back(self):
        """back(ExactModelCoordinateVector self) -> DoublePoint3D"""
        return _fife.ExactModelCoordinateVector_back(self)


    def assign(self, n, x):
        """assign(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::size_type n, DoublePoint3D x)"""
        return _fife.ExactModelCoordinateVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::size_type new_size)
        resize(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::size_type new_size, DoublePoint3D x)
        """
        return _fife.ExactModelCoordinateVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::iterator pos, DoublePoint3D x) -> std::vector< FIFE::PointType3D< double > >::iterator
        insert(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::iterator pos, std::vector< FIFE::PointType3D< double > >::size_type n, DoublePoint3D x)
        """
        return _fife.ExactModelCoordinateVector_insert(self, *args)


    def reserve(self, n):
        """reserve(ExactModelCoordinateVector self, std::vector< FIFE::PointType3D< double > >::size_type n)"""
        return _fife.ExactModelCoordinateVector_reserve(self, n)


    def capacity(self):
        """capacity(ExactModelCoordinateVector self) -> std::vector< FIFE::PointType3D< double > >::size_type"""
        return _fife.ExactModelCoordinateVector_capacity(self)

    __swig_destroy__ = _fife.delete_ExactModelCoordinateVector
ExactModelCoordinateVector.iterator = new_instancemethod(_fife.ExactModelCoordinateVector_iterator, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__nonzero__ = new_instancemethod(_fife.ExactModelCoordinateVector___nonzero__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__bool__ = new_instancemethod(_fife.ExactModelCoordinateVector___bool__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__len__ = new_instancemethod(_fife.ExactModelCoordinateVector___len__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__getslice__ = new_instancemethod(_fife.ExactModelCoordinateVector___getslice__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__setslice__ = new_instancemethod(_fife.ExactModelCoordinateVector___setslice__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__delslice__ = new_instancemethod(_fife.ExactModelCoordinateVector___delslice__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__delitem__ = new_instancemethod(_fife.ExactModelCoordinateVector___delitem__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__getitem__ = new_instancemethod(_fife.ExactModelCoordinateVector___getitem__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.__setitem__ = new_instancemethod(_fife.ExactModelCoordinateVector___setitem__, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.pop = new_instancemethod(_fife.ExactModelCoordinateVector_pop, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.append = new_instancemethod(_fife.ExactModelCoordinateVector_append, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.empty = new_instancemethod(_fife.ExactModelCoordinateVector_empty, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.size = new_instancemethod(_fife.ExactModelCoordinateVector_size, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.swap = new_instancemethod(_fife.ExactModelCoordinateVector_swap, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.begin = new_instancemethod(_fife.ExactModelCoordinateVector_begin, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.end = new_instancemethod(_fife.ExactModelCoordinateVector_end, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.rbegin = new_instancemethod(_fife.ExactModelCoordinateVector_rbegin, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.rend = new_instancemethod(_fife.ExactModelCoordinateVector_rend, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.clear = new_instancemethod(_fife.ExactModelCoordinateVector_clear, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.get_allocator = new_instancemethod(_fife.ExactModelCoordinateVector_get_allocator, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.pop_back = new_instancemethod(_fife.ExactModelCoordinateVector_pop_back, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.erase = new_instancemethod(_fife.ExactModelCoordinateVector_erase, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.push_back = new_instancemethod(_fife.ExactModelCoordinateVector_push_back, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.front = new_instancemethod(_fife.ExactModelCoordinateVector_front, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.back = new_instancemethod(_fife.ExactModelCoordinateVector_back, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.assign = new_instancemethod(_fife.ExactModelCoordinateVector_assign, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.resize = new_instancemethod(_fife.ExactModelCoordinateVector_resize, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.insert = new_instancemethod(_fife.ExactModelCoordinateVector_insert, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.reserve = new_instancemethod(_fife.ExactModelCoordinateVector_reserve, None, ExactModelCoordinateVector)
ExactModelCoordinateVector.capacity = new_instancemethod(_fife.ExactModelCoordinateVector_capacity, None, ExactModelCoordinateVector)
ExactModelCoordinateVector_swigregister = _fife.ExactModelCoordinateVector_swigregister
ExactModelCoordinateVector_swigregister(ExactModelCoordinateVector)

class CellGrid(object):
    """Proxy of C++ FIFE::CellGrid class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellGrid

    def getAccessibleCoordinates(self, curpos, coordinates):
        """getAccessibleCoordinates(CellGrid self, Point3D curpos, std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > > & coordinates)"""
        return _fife.CellGrid_getAccessibleCoordinates(self, curpos, coordinates)


    def getType(self):
        """getType(CellGrid self) -> std::string const &"""
        return _fife.CellGrid_getType(self)


    def getName(self):
        """getName(CellGrid self) -> std::string const &"""
        return _fife.CellGrid_getName(self)


    def isAccessible(self, curpos, target):
        """isAccessible(CellGrid self, Point3D curpos, Point3D target) -> bool"""
        return _fife.CellGrid_isAccessible(self, curpos, target)


    def getAdjacentCost(self, curpos, target):
        """getAdjacentCost(CellGrid self, Point3D curpos, Point3D target) -> double"""
        return _fife.CellGrid_getAdjacentCost(self, curpos, target)


    def getHeuristicCost(self, curpos, target):
        """getHeuristicCost(CellGrid self, Point3D curpos, Point3D target) -> double"""
        return _fife.CellGrid_getHeuristicCost(self, curpos, target)


    def getCellSideCount(self):
        """getCellSideCount(CellGrid self) -> uint32_t"""
        return _fife.CellGrid_getCellSideCount(self)


    def toMapCoordinates(self, *args):
        """
        toMapCoordinates(CellGrid self, Point3D layer_coords) -> DoublePoint3D
        toMapCoordinates(CellGrid self, DoublePoint3D layer_coords) -> DoublePoint3D
        """
        return _fife.CellGrid_toMapCoordinates(self, *args)


    def toLayerCoordinates(self, map_coord):
        """toLayerCoordinates(CellGrid self, DoublePoint3D map_coord) -> Point3D"""
        return _fife.CellGrid_toLayerCoordinates(self, map_coord)


    def toExactLayerCoordinates(self, map_coord):
        """toExactLayerCoordinates(CellGrid self, DoublePoint3D map_coord) -> DoublePoint3D"""
        return _fife.CellGrid_toExactLayerCoordinates(self, map_coord)


    def toLayerCoordinatesFromExactLayerCoordinates(self, exact_layer_coords):
        """toLayerCoordinatesFromExactLayerCoordinates(CellGrid self, DoublePoint3D exact_layer_coords) -> Point3D"""
        return _fife.CellGrid_toLayerCoordinatesFromExactLayerCoordinates(self, exact_layer_coords)


    def getVertices(self, cell):
        """getVertices(CellGrid self, Point3D cell)"""
        return _fife.CellGrid_getVertices(self, cell)


    def getCoordinatesInLine(self, start, end):
        """getCoordinatesInLine(CellGrid self, Point3D start, Point3D end) -> std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > >"""
        return _fife.CellGrid_getCoordinatesInLine(self, start, end)


    def setXShift(self, xshift):
        """setXShift(CellGrid self, double const & xshift)"""
        return _fife.CellGrid_setXShift(self, xshift)


    def getXShift(self):
        """getXShift(CellGrid self) -> double const"""
        return _fife.CellGrid_getXShift(self)


    def setYShift(self, yshift):
        """setYShift(CellGrid self, double const yshift)"""
        return _fife.CellGrid_setYShift(self, yshift)


    def getYShift(self):
        """getYShift(CellGrid self) -> double const"""
        return _fife.CellGrid_getYShift(self)


    def setZShift(self, zshift):
        """setZShift(CellGrid self, double const zshift)"""
        return _fife.CellGrid_setZShift(self, zshift)


    def getZShift(self):
        """getZShift(CellGrid self) -> double const"""
        return _fife.CellGrid_getZShift(self)


    def setXScale(self, scale):
        """setXScale(CellGrid self, double const scale)"""
        return _fife.CellGrid_setXScale(self, scale)


    def setYScale(self, scale):
        """setYScale(CellGrid self, double const scale)"""
        return _fife.CellGrid_setYScale(self, scale)


    def setZScale(self, scale):
        """setZScale(CellGrid self, double const scale)"""
        return _fife.CellGrid_setZScale(self, scale)


    def getXScale(self):
        """getXScale(CellGrid self) -> double const"""
        return _fife.CellGrid_getXScale(self)


    def getYScale(self):
        """getYScale(CellGrid self) -> double const"""
        return _fife.CellGrid_getYScale(self)


    def getZScale(self):
        """getZScale(CellGrid self) -> double const"""
        return _fife.CellGrid_getZScale(self)


    def setRotation(self, rotation):
        """setRotation(CellGrid self, double const rotation)"""
        return _fife.CellGrid_setRotation(self, rotation)


    def getRotation(self):
        """getRotation(CellGrid self) -> double const"""
        return _fife.CellGrid_getRotation(self)


    def setAllowDiagonals(self, allow_diagonals):
        """setAllowDiagonals(CellGrid self, bool const allow_diagonals)"""
        return _fife.CellGrid_setAllowDiagonals(self, allow_diagonals)


    def getAllowDiagonals(self):
        """getAllowDiagonals(CellGrid self) -> bool const"""
        return _fife.CellGrid_getAllowDiagonals(self)

CellGrid.getAccessibleCoordinates = new_instancemethod(_fife.CellGrid_getAccessibleCoordinates, None, CellGrid)
CellGrid.getType = new_instancemethod(_fife.CellGrid_getType, None, CellGrid)
CellGrid.getName = new_instancemethod(_fife.CellGrid_getName, None, CellGrid)
CellGrid.isAccessible = new_instancemethod(_fife.CellGrid_isAccessible, None, CellGrid)
CellGrid.getAdjacentCost = new_instancemethod(_fife.CellGrid_getAdjacentCost, None, CellGrid)
CellGrid.getHeuristicCost = new_instancemethod(_fife.CellGrid_getHeuristicCost, None, CellGrid)
CellGrid.getCellSideCount = new_instancemethod(_fife.CellGrid_getCellSideCount, None, CellGrid)
CellGrid.toMapCoordinates = new_instancemethod(_fife.CellGrid_toMapCoordinates, None, CellGrid)
CellGrid.toLayerCoordinates = new_instancemethod(_fife.CellGrid_toLayerCoordinates, None, CellGrid)
CellGrid.toExactLayerCoordinates = new_instancemethod(_fife.CellGrid_toExactLayerCoordinates, None, CellGrid)
CellGrid.toLayerCoordinatesFromExactLayerCoordinates = new_instancemethod(_fife.CellGrid_toLayerCoordinatesFromExactLayerCoordinates, None, CellGrid)
CellGrid.getVertices = new_instancemethod(_fife.CellGrid_getVertices, None, CellGrid)
CellGrid.getCoordinatesInLine = new_instancemethod(_fife.CellGrid_getCoordinatesInLine, None, CellGrid)
CellGrid.setXShift = new_instancemethod(_fife.CellGrid_setXShift, None, CellGrid)
CellGrid.getXShift = new_instancemethod(_fife.CellGrid_getXShift, None, CellGrid)
CellGrid.setYShift = new_instancemethod(_fife.CellGrid_setYShift, None, CellGrid)
CellGrid.getYShift = new_instancemethod(_fife.CellGrid_getYShift, None, CellGrid)
CellGrid.setZShift = new_instancemethod(_fife.CellGrid_setZShift, None, CellGrid)
CellGrid.getZShift = new_instancemethod(_fife.CellGrid_getZShift, None, CellGrid)
CellGrid.setXScale = new_instancemethod(_fife.CellGrid_setXScale, None, CellGrid)
CellGrid.setYScale = new_instancemethod(_fife.CellGrid_setYScale, None, CellGrid)
CellGrid.setZScale = new_instancemethod(_fife.CellGrid_setZScale, None, CellGrid)
CellGrid.getXScale = new_instancemethod(_fife.CellGrid_getXScale, None, CellGrid)
CellGrid.getYScale = new_instancemethod(_fife.CellGrid_getYScale, None, CellGrid)
CellGrid.getZScale = new_instancemethod(_fife.CellGrid_getZScale, None, CellGrid)
CellGrid.setRotation = new_instancemethod(_fife.CellGrid_setRotation, None, CellGrid)
CellGrid.getRotation = new_instancemethod(_fife.CellGrid_getRotation, None, CellGrid)
CellGrid.setAllowDiagonals = new_instancemethod(_fife.CellGrid_setAllowDiagonals, None, CellGrid)
CellGrid.getAllowDiagonals = new_instancemethod(_fife.CellGrid_getAllowDiagonals, None, CellGrid)
CellGrid_swigregister = _fife.CellGrid_swigregister
CellGrid_swigregister(CellGrid)

class HexGrid(CellGrid):
    """Proxy of C++ FIFE::HexGrid class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_HexGrid

    def isAccessible(self, curpos, target):
        """isAccessible(HexGrid self, Point3D curpos, Point3D target) -> bool"""
        return _fife.HexGrid_isAccessible(self, curpos, target)


    def getType(self):
        """getType(HexGrid self) -> std::string const &"""
        return _fife.HexGrid_getType(self)


    def getName(self):
        """getName(HexGrid self) -> std::string const &"""
        return _fife.HexGrid_getName(self)


    def getAdjacentCost(self, curpos, target):
        """getAdjacentCost(HexGrid self, Point3D curpos, Point3D target) -> double"""
        return _fife.HexGrid_getAdjacentCost(self, curpos, target)


    def getCellSideCount(self):
        """getCellSideCount(HexGrid self) -> uint32_t"""
        return _fife.HexGrid_getCellSideCount(self)


    def toMapCoordinates(self, layer_coords):
        """toMapCoordinates(HexGrid self, DoublePoint3D layer_coords) -> DoublePoint3D"""
        return _fife.HexGrid_toMapCoordinates(self, layer_coords)


    def toLayerCoordinates(self, map_coord):
        """toLayerCoordinates(HexGrid self, DoublePoint3D map_coord) -> Point3D"""
        return _fife.HexGrid_toLayerCoordinates(self, map_coord)


    def toExactLayerCoordinates(self, map_coord):
        """toExactLayerCoordinates(HexGrid self, DoublePoint3D map_coord) -> DoublePoint3D"""
        return _fife.HexGrid_toExactLayerCoordinates(self, map_coord)


    def toLayerCoordinatesFromExactLayerCoordinates(self, exact_layer_coords):
        """toLayerCoordinatesFromExactLayerCoordinates(HexGrid self, DoublePoint3D exact_layer_coords) -> Point3D"""
        return _fife.HexGrid_toLayerCoordinatesFromExactLayerCoordinates(self, exact_layer_coords)


    def getVertices(self, cell):
        """getVertices(HexGrid self, Point3D cell)"""
        return _fife.HexGrid_getVertices(self, cell)


    def getCoordinatesInLine(self, start, end):
        """getCoordinatesInLine(HexGrid self, Point3D start, Point3D end) -> std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > >"""
        return _fife.HexGrid_getCoordinatesInLine(self, start, end)

HexGrid.isAccessible = new_instancemethod(_fife.HexGrid_isAccessible, None, HexGrid)
HexGrid.getType = new_instancemethod(_fife.HexGrid_getType, None, HexGrid)
HexGrid.getName = new_instancemethod(_fife.HexGrid_getName, None, HexGrid)
HexGrid.getAdjacentCost = new_instancemethod(_fife.HexGrid_getAdjacentCost, None, HexGrid)
HexGrid.getCellSideCount = new_instancemethod(_fife.HexGrid_getCellSideCount, None, HexGrid)
HexGrid.toMapCoordinates = new_instancemethod(_fife.HexGrid_toMapCoordinates, None, HexGrid)
HexGrid.toLayerCoordinates = new_instancemethod(_fife.HexGrid_toLayerCoordinates, None, HexGrid)
HexGrid.toExactLayerCoordinates = new_instancemethod(_fife.HexGrid_toExactLayerCoordinates, None, HexGrid)
HexGrid.toLayerCoordinatesFromExactLayerCoordinates = new_instancemethod(_fife.HexGrid_toLayerCoordinatesFromExactLayerCoordinates, None, HexGrid)
HexGrid.getVertices = new_instancemethod(_fife.HexGrid_getVertices, None, HexGrid)
HexGrid.getCoordinatesInLine = new_instancemethod(_fife.HexGrid_getCoordinatesInLine, None, HexGrid)
HexGrid_swigregister = _fife.HexGrid_swigregister
HexGrid_swigregister(HexGrid)

class SquareGrid(CellGrid):
    """Proxy of C++ FIFE::SquareGrid class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_SquareGrid

    def getType(self):
        """getType(SquareGrid self) -> std::string const &"""
        return _fife.SquareGrid_getType(self)


    def getName(self):
        """getName(SquareGrid self) -> std::string const &"""
        return _fife.SquareGrid_getName(self)


    def isAccessible(self, curpos, target):
        """isAccessible(SquareGrid self, Point3D curpos, Point3D target) -> bool"""
        return _fife.SquareGrid_isAccessible(self, curpos, target)


    def getAdjacentCost(self, curpos, target):
        """getAdjacentCost(SquareGrid self, Point3D curpos, Point3D target) -> double"""
        return _fife.SquareGrid_getAdjacentCost(self, curpos, target)


    def getCellSideCount(self):
        """getCellSideCount(SquareGrid self) -> uint32_t"""
        return _fife.SquareGrid_getCellSideCount(self)


    def toMapCoordinates(self, layer_coords):
        """toMapCoordinates(SquareGrid self, DoublePoint3D layer_coords) -> DoublePoint3D"""
        return _fife.SquareGrid_toMapCoordinates(self, layer_coords)


    def toLayerCoordinates(self, map_coord):
        """toLayerCoordinates(SquareGrid self, DoublePoint3D map_coord) -> Point3D"""
        return _fife.SquareGrid_toLayerCoordinates(self, map_coord)


    def toExactLayerCoordinates(self, map_coord):
        """toExactLayerCoordinates(SquareGrid self, DoublePoint3D map_coord) -> DoublePoint3D"""
        return _fife.SquareGrid_toExactLayerCoordinates(self, map_coord)


    def toLayerCoordinatesFromExactLayerCoordinates(self, exact_layer_coords):
        """toLayerCoordinatesFromExactLayerCoordinates(SquareGrid self, DoublePoint3D exact_layer_coords) -> Point3D"""
        return _fife.SquareGrid_toLayerCoordinatesFromExactLayerCoordinates(self, exact_layer_coords)


    def getVertices(self, cell):
        """getVertices(SquareGrid self, Point3D cell)"""
        return _fife.SquareGrid_getVertices(self, cell)


    def getCoordinatesInLine(self, start, end):
        """getCoordinatesInLine(SquareGrid self, Point3D start, Point3D end) -> std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > >"""
        return _fife.SquareGrid_getCoordinatesInLine(self, start, end)

SquareGrid.getType = new_instancemethod(_fife.SquareGrid_getType, None, SquareGrid)
SquareGrid.getName = new_instancemethod(_fife.SquareGrid_getName, None, SquareGrid)
SquareGrid.isAccessible = new_instancemethod(_fife.SquareGrid_isAccessible, None, SquareGrid)
SquareGrid.getAdjacentCost = new_instancemethod(_fife.SquareGrid_getAdjacentCost, None, SquareGrid)
SquareGrid.getCellSideCount = new_instancemethod(_fife.SquareGrid_getCellSideCount, None, SquareGrid)
SquareGrid.toMapCoordinates = new_instancemethod(_fife.SquareGrid_toMapCoordinates, None, SquareGrid)
SquareGrid.toLayerCoordinates = new_instancemethod(_fife.SquareGrid_toLayerCoordinates, None, SquareGrid)
SquareGrid.toExactLayerCoordinates = new_instancemethod(_fife.SquareGrid_toExactLayerCoordinates, None, SquareGrid)
SquareGrid.toLayerCoordinatesFromExactLayerCoordinates = new_instancemethod(_fife.SquareGrid_toLayerCoordinatesFromExactLayerCoordinates, None, SquareGrid)
SquareGrid.getVertices = new_instancemethod(_fife.SquareGrid_getVertices, None, SquareGrid)
SquareGrid.getCoordinatesInLine = new_instancemethod(_fife.SquareGrid_getCoordinatesInLine, None, SquareGrid)
SquareGrid_swigregister = _fife.SquareGrid_swigregister
SquareGrid_swigregister(SquareGrid)

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
class CellChangeListener(object):
    """Proxy of C++ FIFE::CellChangeListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellChangeListener

    def onInstanceEnteredCell(self, cell, instance):
        """onInstanceEnteredCell(CellChangeListener self, Cell cell, Instance instance)"""
        return _fife.CellChangeListener_onInstanceEnteredCell(self, cell, instance)


    def onInstanceExitedCell(self, cell, instance):
        """onInstanceExitedCell(CellChangeListener self, Cell cell, Instance instance)"""
        return _fife.CellChangeListener_onInstanceExitedCell(self, cell, instance)


    def onBlockingChangedCell(self, cell, type, blocks):
        """onBlockingChangedCell(CellChangeListener self, Cell cell, FIFE::CellTypeInfo type, bool blocks)"""
        return _fife.CellChangeListener_onBlockingChangedCell(self, cell, type, blocks)


    def __init__(self):
        """__init__(FIFE::CellChangeListener self) -> CellChangeListener"""
        if self.__class__ == CellChangeListener:
            _self = None
        else:
            _self = self
        _fife.CellChangeListener_swiginit(self, _fife.new_CellChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_CellChangeListener(self)
        return weakref_proxy(self)
CellChangeListener.onInstanceEnteredCell = new_instancemethod(_fife.CellChangeListener_onInstanceEnteredCell, None, CellChangeListener)
CellChangeListener.onInstanceExitedCell = new_instancemethod(_fife.CellChangeListener_onInstanceExitedCell, None, CellChangeListener)
CellChangeListener.onBlockingChangedCell = new_instancemethod(_fife.CellChangeListener_onBlockingChangedCell, None, CellChangeListener)
CellChangeListener_swigregister = _fife.CellChangeListener_swigregister
CellChangeListener_swigregister(CellChangeListener)

class CellDeleteListener(object):
    """Proxy of C++ FIFE::CellDeleteListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellDeleteListener

    def onCellDeleted(self, cell):
        """onCellDeleted(CellDeleteListener self, Cell cell)"""
        return _fife.CellDeleteListener_onCellDeleted(self, cell)


    def __init__(self):
        """__init__(FIFE::CellDeleteListener self) -> CellDeleteListener"""
        if self.__class__ == CellDeleteListener:
            _self = None
        else:
            _self = self
        _fife.CellDeleteListener_swiginit(self, _fife.new_CellDeleteListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_CellDeleteListener(self)
        return weakref_proxy(self)
CellDeleteListener.onCellDeleted = new_instancemethod(_fife.CellDeleteListener_onCellDeleted, None, CellDeleteListener)
CellDeleteListener_swigregister = _fife.CellDeleteListener_swigregister
CellDeleteListener_swigregister(CellDeleteListener)

class Cell(FifeClass):
    """Proxy of C++ FIFE::Cell class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, coordint, coordinate, layer):
        """__init__(FIFE::Cell self, int32_t coordint, Point3D coordinate, Layer layer) -> Cell"""
        _fife.Cell_swiginit(self, _fife.new_Cell(coordint, coordinate, layer))
    __swig_destroy__ = _fife.delete_Cell

    def addInstances(self, instances):
        """addInstances(Cell self, InstanceList instances)"""
        return _fife.Cell_addInstances(self, instances)


    def addInstance(self, instance):
        """addInstance(Cell self, Instance instance)"""
        return _fife.Cell_addInstance(self, instance)


    def changeInstance(self, instance):
        """changeInstance(Cell self, Instance instance)"""
        return _fife.Cell_changeInstance(self, instance)


    def removeInstance(self, instance):
        """removeInstance(Cell self, Instance instance)"""
        return _fife.Cell_removeInstance(self, instance)


    def isNeighbor(self, cell):
        """isNeighbor(Cell self, Cell cell) -> bool"""
        return _fife.Cell_isNeighbor(self, cell)


    def getNeighbors(self):
        """getNeighbors(Cell self) -> CellVector"""
        return _fife.Cell_getNeighbors(self)


    def updateCellInfo(self):
        """updateCellInfo(Cell self)"""
        return _fife.Cell_updateCellInfo(self)


    def getCellId(self):
        """getCellId(Cell self) -> int32_t"""
        return _fife.Cell_getCellId(self)


    def getLayerCoordinates(self):
        """getLayerCoordinates(Cell self) -> Point3D"""
        return _fife.Cell_getLayerCoordinates(self)


    def defaultCost(self):
        """defaultCost(Cell self) -> bool"""
        return _fife.Cell_defaultCost(self)


    def setCostMultiplier(self, multi):
        """setCostMultiplier(Cell self, double multi)"""
        return _fife.Cell_setCostMultiplier(self, multi)


    def getCostMultiplier(self):
        """getCostMultiplier(Cell self) -> double"""
        return _fife.Cell_getCostMultiplier(self)


    def resetCostMultiplier(self):
        """resetCostMultiplier(Cell self)"""
        return _fife.Cell_resetCostMultiplier(self)


    def defaultSpeed(self):
        """defaultSpeed(Cell self) -> bool"""
        return _fife.Cell_defaultSpeed(self)


    def setSpeedMultiplier(self, multi):
        """setSpeedMultiplier(Cell self, double multi)"""
        return _fife.Cell_setSpeedMultiplier(self, multi)


    def getSpeedMultiplier(self):
        """getSpeedMultiplier(Cell self) -> double"""
        return _fife.Cell_getSpeedMultiplier(self)


    def resetSpeedMultiplier(self):
        """resetSpeedMultiplier(Cell self)"""
        return _fife.Cell_resetSpeedMultiplier(self)


    def getInstances(self):
        """getInstances(Cell self) -> InstanceSet"""
        return _fife.Cell_getInstances(self)


    def setCellType(self, type):
        """setCellType(Cell self, FIFE::CellTypeInfo type)"""
        return _fife.Cell_setCellType(self, type)


    def getCellType(self):
        """getCellType(Cell self) -> FIFE::CellTypeInfo"""
        return _fife.Cell_getCellType(self)


    def getLayer(self):
        """getLayer(Cell self) -> Layer"""
        return _fife.Cell_getLayer(self)


    def createTransition(self, layer, mc):
        """createTransition(Cell self, Layer layer, Point3D mc)"""
        return _fife.Cell_createTransition(self, layer, mc)


    def deleteTransition(self):
        """deleteTransition(Cell self)"""
        return _fife.Cell_deleteTransition(self)


    def addChangeListener(self, listener):
        """addChangeListener(Cell self, CellChangeListener listener)"""
        return _fife.Cell_addChangeListener(self, listener)


    def removeChangeListener(self, listener):
        """removeChangeListener(Cell self, CellChangeListener listener)"""
        return _fife.Cell_removeChangeListener(self, listener)


    def addDeleteListener(self, listener):
        """addDeleteListener(Cell self, CellDeleteListener listener)"""
        return _fife.Cell_addDeleteListener(self, listener)


    def removeDeleteListener(self, listener):
        """removeDeleteListener(Cell self, CellDeleteListener listener)"""
        return _fife.Cell_removeDeleteListener(self, listener)

Cell.addInstances = new_instancemethod(_fife.Cell_addInstances, None, Cell)
Cell.addInstance = new_instancemethod(_fife.Cell_addInstance, None, Cell)
Cell.changeInstance = new_instancemethod(_fife.Cell_changeInstance, None, Cell)
Cell.removeInstance = new_instancemethod(_fife.Cell_removeInstance, None, Cell)
Cell.isNeighbor = new_instancemethod(_fife.Cell_isNeighbor, None, Cell)
Cell.getNeighbors = new_instancemethod(_fife.Cell_getNeighbors, None, Cell)
Cell.updateCellInfo = new_instancemethod(_fife.Cell_updateCellInfo, None, Cell)
Cell.getCellId = new_instancemethod(_fife.Cell_getCellId, None, Cell)
Cell.getLayerCoordinates = new_instancemethod(_fife.Cell_getLayerCoordinates, None, Cell)
Cell.defaultCost = new_instancemethod(_fife.Cell_defaultCost, None, Cell)
Cell.setCostMultiplier = new_instancemethod(_fife.Cell_setCostMultiplier, None, Cell)
Cell.getCostMultiplier = new_instancemethod(_fife.Cell_getCostMultiplier, None, Cell)
Cell.resetCostMultiplier = new_instancemethod(_fife.Cell_resetCostMultiplier, None, Cell)
Cell.defaultSpeed = new_instancemethod(_fife.Cell_defaultSpeed, None, Cell)
Cell.setSpeedMultiplier = new_instancemethod(_fife.Cell_setSpeedMultiplier, None, Cell)
Cell.getSpeedMultiplier = new_instancemethod(_fife.Cell_getSpeedMultiplier, None, Cell)
Cell.resetSpeedMultiplier = new_instancemethod(_fife.Cell_resetSpeedMultiplier, None, Cell)
Cell.getInstances = new_instancemethod(_fife.Cell_getInstances, None, Cell)
Cell.setCellType = new_instancemethod(_fife.Cell_setCellType, None, Cell)
Cell.getCellType = new_instancemethod(_fife.Cell_getCellType, None, Cell)
Cell.getLayer = new_instancemethod(_fife.Cell_getLayer, None, Cell)
Cell.createTransition = new_instancemethod(_fife.Cell_createTransition, None, Cell)
Cell.deleteTransition = new_instancemethod(_fife.Cell_deleteTransition, None, Cell)
Cell.addChangeListener = new_instancemethod(_fife.Cell_addChangeListener, None, Cell)
Cell.removeChangeListener = new_instancemethod(_fife.Cell_removeChangeListener, None, Cell)
Cell.addDeleteListener = new_instancemethod(_fife.Cell_addDeleteListener, None, Cell)
Cell.removeDeleteListener = new_instancemethod(_fife.Cell_removeDeleteListener, None, Cell)
Cell_swigregister = _fife.Cell_swigregister
Cell_swigregister(Cell)

class InstanceSet(object):
    """Proxy of C++ std::set<(p.FIFE::Instance)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(InstanceSet self) -> SwigPyIterator"""
        return _fife.InstanceSet_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(InstanceSet self) -> bool"""
        return _fife.InstanceSet___nonzero__(self)


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


    def __len__(self):
        """__len__(InstanceSet self) -> std::set< FIFE::Instance * >::size_type"""
        return _fife.InstanceSet___len__(self)


    def append(self, x):
        """append(InstanceSet self, Instance x)"""
        return _fife.InstanceSet_append(self, x)


    def __contains__(self, x):
        """__contains__(InstanceSet self, Instance x) -> bool"""
        return _fife.InstanceSet___contains__(self, x)


    def __getitem__(self, i):
        """__getitem__(InstanceSet self, std::set< FIFE::Instance * >::difference_type i) -> Instance"""
        return _fife.InstanceSet___getitem__(self, i)


    def add(self, x):
        """add(InstanceSet self, Instance x)"""
        return _fife.InstanceSet_add(self, x)


    def discard(self, x):
        """discard(InstanceSet self, Instance x)"""
        return _fife.InstanceSet_discard(self, x)


    def __init__(self, *args):
        """
        __init__(std::set<(p.FIFE::Instance)> self, std::less< FIFE::Instance * > const & arg2) -> InstanceSet
        __init__(std::set<(p.FIFE::Instance)> self) -> InstanceSet
        __init__(std::set<(p.FIFE::Instance)> self, InstanceSet arg2) -> InstanceSet
        """
        _fife.InstanceSet_swiginit(self, _fife.new_InstanceSet(*args))

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


    def size(self):
        """size(InstanceSet self) -> std::set< FIFE::Instance * >::size_type"""
        return _fife.InstanceSet_size(self)


    def clear(self):
        """clear(InstanceSet self)"""
        return _fife.InstanceSet_clear(self)


    def swap(self, v):
        """swap(InstanceSet self, InstanceSet v)"""
        return _fife.InstanceSet_swap(self, v)


    def count(self, x):
        """count(InstanceSet self, Instance x) -> std::set< FIFE::Instance * >::size_type"""
        return _fife.InstanceSet_count(self, x)


    def begin(self):
        """begin(InstanceSet self) -> std::set< FIFE::Instance * >::iterator"""
        return _fife.InstanceSet_begin(self)


    def end(self):
        """end(InstanceSet self) -> std::set< FIFE::Instance * >::iterator"""
        return _fife.InstanceSet_end(self)


    def rbegin(self):
        """rbegin(InstanceSet self) -> std::set< FIFE::Instance * >::reverse_iterator"""
        return _fife.InstanceSet_rbegin(self)


    def rend(self):
        """rend(InstanceSet self) -> std::set< FIFE::Instance * >::reverse_iterator"""
        return _fife.InstanceSet_rend(self)


    def erase(self, *args):
        """
        erase(InstanceSet self, Instance x) -> std::set< FIFE::Instance * >::size_type
        erase(InstanceSet self, std::set< FIFE::Instance * >::iterator pos)
        erase(InstanceSet self, std::set< FIFE::Instance * >::iterator first, std::set< FIFE::Instance * >::iterator last)
        """
        return _fife.InstanceSet_erase(self, *args)


    def find(self, x):
        """find(InstanceSet self, Instance x) -> std::set< FIFE::Instance * >::iterator"""
        return _fife.InstanceSet_find(self, x)


    def lower_bound(self, x):
        """lower_bound(InstanceSet self, Instance x) -> std::set< FIFE::Instance * >::iterator"""
        return _fife.InstanceSet_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(InstanceSet self, Instance x) -> std::set< FIFE::Instance * >::iterator"""
        return _fife.InstanceSet_upper_bound(self, x)


    def equal_range(self, x):
        """equal_range(InstanceSet self, Instance x) -> std::pair< std::set< FIFE::Instance * >::iterator,std::set< FIFE::Instance * >::iterator >"""
        return _fife.InstanceSet_equal_range(self, x)


    def insert(self, __x):
        """insert(InstanceSet self, Instance __x) -> std::pair< std::set< FIFE::Instance * >::iterator,bool >"""
        return _fife.InstanceSet_insert(self, __x)

    __swig_destroy__ = _fife.delete_InstanceSet
InstanceSet.iterator = new_instancemethod(_fife.InstanceSet_iterator, None, InstanceSet)
InstanceSet.__nonzero__ = new_instancemethod(_fife.InstanceSet___nonzero__, None, InstanceSet)
InstanceSet.__bool__ = new_instancemethod(_fife.InstanceSet___bool__, None, InstanceSet)
InstanceSet.__len__ = new_instancemethod(_fife.InstanceSet___len__, None, InstanceSet)
InstanceSet.append = new_instancemethod(_fife.InstanceSet_append, None, InstanceSet)
InstanceSet.__contains__ = new_instancemethod(_fife.InstanceSet___contains__, None, InstanceSet)
InstanceSet.__getitem__ = new_instancemethod(_fife.InstanceSet___getitem__, None, InstanceSet)
InstanceSet.add = new_instancemethod(_fife.InstanceSet_add, None, InstanceSet)
InstanceSet.discard = new_instancemethod(_fife.InstanceSet_discard, None, InstanceSet)
InstanceSet.empty = new_instancemethod(_fife.InstanceSet_empty, None, InstanceSet)
InstanceSet.size = new_instancemethod(_fife.InstanceSet_size, None, InstanceSet)
InstanceSet.clear = new_instancemethod(_fife.InstanceSet_clear, None, InstanceSet)
InstanceSet.swap = new_instancemethod(_fife.InstanceSet_swap, None, InstanceSet)
InstanceSet.count = new_instancemethod(_fife.InstanceSet_count, None, InstanceSet)
InstanceSet.begin = new_instancemethod(_fife.InstanceSet_begin, None, InstanceSet)
InstanceSet.end = new_instancemethod(_fife.InstanceSet_end, None, InstanceSet)
InstanceSet.rbegin = new_instancemethod(_fife.InstanceSet_rbegin, None, InstanceSet)
InstanceSet.rend = new_instancemethod(_fife.InstanceSet_rend, None, InstanceSet)
InstanceSet.erase = new_instancemethod(_fife.InstanceSet_erase, None, InstanceSet)
InstanceSet.find = new_instancemethod(_fife.InstanceSet_find, None, InstanceSet)
InstanceSet.lower_bound = new_instancemethod(_fife.InstanceSet_lower_bound, None, InstanceSet)
InstanceSet.upper_bound = new_instancemethod(_fife.InstanceSet_upper_bound, None, InstanceSet)
InstanceSet.equal_range = new_instancemethod(_fife.InstanceSet_equal_range, None, InstanceSet)
InstanceSet.insert = new_instancemethod(_fife.InstanceSet_insert, None, InstanceSet)
InstanceSet_swigregister = _fife.InstanceSet_swigregister
InstanceSet_swigregister(InstanceSet)

class CellSet(object):
    """Proxy of C++ std::set<(p.FIFE::Cell)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(CellSet self) -> SwigPyIterator"""
        return _fife.CellSet_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(CellSet self) -> bool"""
        return _fife.CellSet___nonzero__(self)


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


    def __len__(self):
        """__len__(CellSet self) -> std::set< FIFE::Cell * >::size_type"""
        return _fife.CellSet___len__(self)


    def append(self, x):
        """append(CellSet self, Cell x)"""
        return _fife.CellSet_append(self, x)


    def __contains__(self, x):
        """__contains__(CellSet self, Cell x) -> bool"""
        return _fife.CellSet___contains__(self, x)


    def __getitem__(self, i):
        """__getitem__(CellSet self, std::set< FIFE::Cell * >::difference_type i) -> Cell"""
        return _fife.CellSet___getitem__(self, i)


    def add(self, x):
        """add(CellSet self, Cell x)"""
        return _fife.CellSet_add(self, x)


    def discard(self, x):
        """discard(CellSet self, Cell x)"""
        return _fife.CellSet_discard(self, x)


    def __init__(self, *args):
        """
        __init__(std::set<(p.FIFE::Cell)> self, std::less< FIFE::Cell * > const & arg2) -> CellSet
        __init__(std::set<(p.FIFE::Cell)> self) -> CellSet
        __init__(std::set<(p.FIFE::Cell)> self, CellSet arg2) -> CellSet
        """
        _fife.CellSet_swiginit(self, _fife.new_CellSet(*args))

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


    def size(self):
        """size(CellSet self) -> std::set< FIFE::Cell * >::size_type"""
        return _fife.CellSet_size(self)


    def clear(self):
        """clear(CellSet self)"""
        return _fife.CellSet_clear(self)


    def swap(self, v):
        """swap(CellSet self, CellSet v)"""
        return _fife.CellSet_swap(self, v)


    def count(self, x):
        """count(CellSet self, Cell x) -> std::set< FIFE::Cell * >::size_type"""
        return _fife.CellSet_count(self, x)


    def begin(self):
        """begin(CellSet self) -> std::set< FIFE::Cell * >::iterator"""
        return _fife.CellSet_begin(self)


    def end(self):
        """end(CellSet self) -> std::set< FIFE::Cell * >::iterator"""
        return _fife.CellSet_end(self)


    def rbegin(self):
        """rbegin(CellSet self) -> std::set< FIFE::Cell * >::reverse_iterator"""
        return _fife.CellSet_rbegin(self)


    def rend(self):
        """rend(CellSet self) -> std::set< FIFE::Cell * >::reverse_iterator"""
        return _fife.CellSet_rend(self)


    def erase(self, *args):
        """
        erase(CellSet self, Cell x) -> std::set< FIFE::Cell * >::size_type
        erase(CellSet self, std::set< FIFE::Cell * >::iterator pos)
        erase(CellSet self, std::set< FIFE::Cell * >::iterator first, std::set< FIFE::Cell * >::iterator last)
        """
        return _fife.CellSet_erase(self, *args)


    def find(self, x):
        """find(CellSet self, Cell x) -> std::set< FIFE::Cell * >::iterator"""
        return _fife.CellSet_find(self, x)


    def lower_bound(self, x):
        """lower_bound(CellSet self, Cell x) -> std::set< FIFE::Cell * >::iterator"""
        return _fife.CellSet_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(CellSet self, Cell x) -> std::set< FIFE::Cell * >::iterator"""
        return _fife.CellSet_upper_bound(self, x)


    def equal_range(self, x):
        """equal_range(CellSet self, Cell x) -> std::pair< std::set< FIFE::Cell * >::iterator,std::set< FIFE::Cell * >::iterator >"""
        return _fife.CellSet_equal_range(self, x)


    def insert(self, __x):
        """insert(CellSet self, Cell __x) -> std::pair< std::set< FIFE::Cell * >::iterator,bool >"""
        return _fife.CellSet_insert(self, __x)

    __swig_destroy__ = _fife.delete_CellSet
CellSet.iterator = new_instancemethod(_fife.CellSet_iterator, None, CellSet)
CellSet.__nonzero__ = new_instancemethod(_fife.CellSet___nonzero__, None, CellSet)
CellSet.__bool__ = new_instancemethod(_fife.CellSet___bool__, None, CellSet)
CellSet.__len__ = new_instancemethod(_fife.CellSet___len__, None, CellSet)
CellSet.append = new_instancemethod(_fife.CellSet_append, None, CellSet)
CellSet.__contains__ = new_instancemethod(_fife.CellSet___contains__, None, CellSet)
CellSet.__getitem__ = new_instancemethod(_fife.CellSet___getitem__, None, CellSet)
CellSet.add = new_instancemethod(_fife.CellSet_add, None, CellSet)
CellSet.discard = new_instancemethod(_fife.CellSet_discard, None, CellSet)
CellSet.empty = new_instancemethod(_fife.CellSet_empty, None, CellSet)
CellSet.size = new_instancemethod(_fife.CellSet_size, None, CellSet)
CellSet.clear = new_instancemethod(_fife.CellSet_clear, None, CellSet)
CellSet.swap = new_instancemethod(_fife.CellSet_swap, None, CellSet)
CellSet.count = new_instancemethod(_fife.CellSet_count, None, CellSet)
CellSet.begin = new_instancemethod(_fife.CellSet_begin, None, CellSet)
CellSet.end = new_instancemethod(_fife.CellSet_end, None, CellSet)
CellSet.rbegin = new_instancemethod(_fife.CellSet_rbegin, None, CellSet)
CellSet.rend = new_instancemethod(_fife.CellSet_rend, None, CellSet)
CellSet.erase = new_instancemethod(_fife.CellSet_erase, None, CellSet)
CellSet.find = new_instancemethod(_fife.CellSet_find, None, CellSet)
CellSet.lower_bound = new_instancemethod(_fife.CellSet_lower_bound, None, CellSet)
CellSet.upper_bound = new_instancemethod(_fife.CellSet_upper_bound, None, CellSet)
CellSet.equal_range = new_instancemethod(_fife.CellSet_equal_range, None, CellSet)
CellSet.insert = new_instancemethod(_fife.CellSet_insert, None, CellSet)
CellSet_swigregister = _fife.CellSet_swigregister
CellSet_swigregister(CellSet)

class CellVector(object):
    """Proxy of C++ std::vector<(p.FIFE::Cell)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(CellVector self) -> SwigPyIterator"""
        return _fife.CellVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(CellVector self) -> bool"""
        return _fife.CellVector___nonzero__(self)


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


    def __len__(self):
        """__len__(CellVector self) -> std::vector< FIFE::Cell * >::size_type"""
        return _fife.CellVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(CellVector self, std::vector< FIFE::Cell * >::difference_type i, std::vector< FIFE::Cell * >::difference_type j) -> CellVector"""
        return _fife.CellVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(CellVector self, std::vector< FIFE::Cell * >::difference_type i, std::vector< FIFE::Cell * >::difference_type j)
        __setslice__(CellVector self, std::vector< FIFE::Cell * >::difference_type i, std::vector< FIFE::Cell * >::difference_type j, CellVector v)
        """
        return _fife.CellVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(CellVector self, std::vector< FIFE::Cell * >::difference_type i, std::vector< FIFE::Cell * >::difference_type j)"""
        return _fife.CellVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(CellVector self, std::vector< FIFE::Cell * >::difference_type i)
        __delitem__(CellVector self, PySliceObject * slice)
        """
        return _fife.CellVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(CellVector self, PySliceObject * slice) -> CellVector
        __getitem__(CellVector self, std::vector< FIFE::Cell * >::difference_type i) -> Cell
        """
        return _fife.CellVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(CellVector self, PySliceObject * slice, CellVector v)
        __setitem__(CellVector self, PySliceObject * slice)
        __setitem__(CellVector self, std::vector< FIFE::Cell * >::difference_type i, Cell x)
        """
        return _fife.CellVector___setitem__(self, *args)


    def pop(self):
        """pop(CellVector self) -> Cell"""
        return _fife.CellVector_pop(self)


    def append(self, x):
        """append(CellVector self, Cell x)"""
        return _fife.CellVector_append(self, x)


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


    def size(self):
        """size(CellVector self) -> std::vector< FIFE::Cell * >::size_type"""
        return _fife.CellVector_size(self)


    def swap(self, v):
        """swap(CellVector self, CellVector v)"""
        return _fife.CellVector_swap(self, v)


    def begin(self):
        """begin(CellVector self) -> std::vector< FIFE::Cell * >::iterator"""
        return _fife.CellVector_begin(self)


    def end(self):
        """end(CellVector self) -> std::vector< FIFE::Cell * >::iterator"""
        return _fife.CellVector_end(self)


    def rbegin(self):
        """rbegin(CellVector self) -> std::vector< FIFE::Cell * >::reverse_iterator"""
        return _fife.CellVector_rbegin(self)


    def rend(self):
        """rend(CellVector self) -> std::vector< FIFE::Cell * >::reverse_iterator"""
        return _fife.CellVector_rend(self)


    def clear(self):
        """clear(CellVector self)"""
        return _fife.CellVector_clear(self)


    def get_allocator(self):
        """get_allocator(CellVector self) -> std::vector< FIFE::Cell * >::allocator_type"""
        return _fife.CellVector_get_allocator(self)


    def pop_back(self):
        """pop_back(CellVector self)"""
        return _fife.CellVector_pop_back(self)


    def erase(self, *args):
        """
        erase(CellVector self, std::vector< FIFE::Cell * >::iterator pos) -> std::vector< FIFE::Cell * >::iterator
        erase(CellVector self, std::vector< FIFE::Cell * >::iterator first, std::vector< FIFE::Cell * >::iterator last) -> std::vector< FIFE::Cell * >::iterator
        """
        return _fife.CellVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.FIFE::Cell)> self) -> CellVector
        __init__(std::vector<(p.FIFE::Cell)> self, CellVector arg2) -> CellVector
        __init__(std::vector<(p.FIFE::Cell)> self, std::vector< FIFE::Cell * >::size_type size) -> CellVector
        __init__(std::vector<(p.FIFE::Cell)> self, std::vector< FIFE::Cell * >::size_type size, Cell value) -> CellVector
        """
        _fife.CellVector_swiginit(self, _fife.new_CellVector(*args))

    def push_back(self, x):
        """push_back(CellVector self, Cell x)"""
        return _fife.CellVector_push_back(self, x)


    def front(self):
        """front(CellVector self) -> Cell"""
        return _fife.CellVector_front(self)


    def back(self):
        """back(CellVector self) -> Cell"""
        return _fife.CellVector_back(self)


    def assign(self, n, x):
        """assign(CellVector self, std::vector< FIFE::Cell * >::size_type n, Cell x)"""
        return _fife.CellVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(CellVector self, std::vector< FIFE::Cell * >::size_type new_size)
        resize(CellVector self, std::vector< FIFE::Cell * >::size_type new_size, Cell x)
        """
        return _fife.CellVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(CellVector self, std::vector< FIFE::Cell * >::iterator pos, Cell x) -> std::vector< FIFE::Cell * >::iterator
        insert(CellVector self, std::vector< FIFE::Cell * >::iterator pos, std::vector< FIFE::Cell * >::size_type n, Cell x)
        """
        return _fife.CellVector_insert(self, *args)


    def reserve(self, n):
        """reserve(CellVector self, std::vector< FIFE::Cell * >::size_type n)"""
        return _fife.CellVector_reserve(self, n)


    def capacity(self):
        """capacity(CellVector self) -> std::vector< FIFE::Cell * >::size_type"""
        return _fife.CellVector_capacity(self)

    __swig_destroy__ = _fife.delete_CellVector
CellVector.iterator = new_instancemethod(_fife.CellVector_iterator, None, CellVector)
CellVector.__nonzero__ = new_instancemethod(_fife.CellVector___nonzero__, None, CellVector)
CellVector.__bool__ = new_instancemethod(_fife.CellVector___bool__, None, CellVector)
CellVector.__len__ = new_instancemethod(_fife.CellVector___len__, None, CellVector)
CellVector.__getslice__ = new_instancemethod(_fife.CellVector___getslice__, None, CellVector)
CellVector.__setslice__ = new_instancemethod(_fife.CellVector___setslice__, None, CellVector)
CellVector.__delslice__ = new_instancemethod(_fife.CellVector___delslice__, None, CellVector)
CellVector.__delitem__ = new_instancemethod(_fife.CellVector___delitem__, None, CellVector)
CellVector.__getitem__ = new_instancemethod(_fife.CellVector___getitem__, None, CellVector)
CellVector.__setitem__ = new_instancemethod(_fife.CellVector___setitem__, None, CellVector)
CellVector.pop = new_instancemethod(_fife.CellVector_pop, None, CellVector)
CellVector.append = new_instancemethod(_fife.CellVector_append, None, CellVector)
CellVector.empty = new_instancemethod(_fife.CellVector_empty, None, CellVector)
CellVector.size = new_instancemethod(_fife.CellVector_size, None, CellVector)
CellVector.swap = new_instancemethod(_fife.CellVector_swap, None, CellVector)
CellVector.begin = new_instancemethod(_fife.CellVector_begin, None, CellVector)
CellVector.end = new_instancemethod(_fife.CellVector_end, None, CellVector)
CellVector.rbegin = new_instancemethod(_fife.CellVector_rbegin, None, CellVector)
CellVector.rend = new_instancemethod(_fife.CellVector_rend, None, CellVector)
CellVector.clear = new_instancemethod(_fife.CellVector_clear, None, CellVector)
CellVector.get_allocator = new_instancemethod(_fife.CellVector_get_allocator, None, CellVector)
CellVector.pop_back = new_instancemethod(_fife.CellVector_pop_back, None, CellVector)
CellVector.erase = new_instancemethod(_fife.CellVector_erase, None, CellVector)
CellVector.push_back = new_instancemethod(_fife.CellVector_push_back, None, CellVector)
CellVector.front = new_instancemethod(_fife.CellVector_front, None, CellVector)
CellVector.back = new_instancemethod(_fife.CellVector_back, None, CellVector)
CellVector.assign = new_instancemethod(_fife.CellVector_assign, None, CellVector)
CellVector.resize = new_instancemethod(_fife.CellVector_resize, None, CellVector)
CellVector.insert = new_instancemethod(_fife.CellVector_insert, None, CellVector)
CellVector.reserve = new_instancemethod(_fife.CellVector_reserve, None, CellVector)
CellVector.capacity = new_instancemethod(_fife.CellVector_capacity, None, CellVector)
CellVector_swigregister = _fife.CellVector_swigregister
CellVector_swigregister(CellVector)

class CellCache(FifeClass):
    """Proxy of C++ FIFE::CellCache class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, layer):
        """__init__(FIFE::CellCache self, Layer layer) -> CellCache"""
        _fife.CellCache_swiginit(self, _fife.new_CellCache(layer))
    __swig_destroy__ = _fife.delete_CellCache

    def createCells(self):
        """createCells(CellCache self)"""
        return _fife.CellCache_createCells(self)


    def forceUpdate(self):
        """forceUpdate(CellCache self)"""
        return _fife.CellCache_forceUpdate(self)


    def addCell(self, cell):
        """addCell(CellCache self, Cell cell)"""
        return _fife.CellCache_addCell(self, cell)


    def createCell(self, mc):
        """createCell(CellCache self, Point3D mc) -> Cell"""
        return _fife.CellCache_createCell(self, mc)


    def getCell(self, mc):
        """getCell(CellCache self, Point3D mc) -> Cell"""
        return _fife.CellCache_getCell(self, mc)


    def addInteractOnRuntime(self, interact):
        """addInteractOnRuntime(CellCache self, Layer interact)"""
        return _fife.CellCache_addInteractOnRuntime(self, interact)


    def removeInteractOnRuntime(self, interact):
        """removeInteractOnRuntime(CellCache self, Layer interact)"""
        return _fife.CellCache_removeInteractOnRuntime(self, interact)


    def getSize(self):
        """getSize(CellCache self) -> Rect"""
        return _fife.CellCache_getSize(self)


    def setSize(self, rec):
        """setSize(CellCache self, Rect rec)"""
        return _fife.CellCache_setSize(self, rec)


    def getWidth(self):
        """getWidth(CellCache self) -> uint32_t"""
        return _fife.CellCache_getWidth(self)


    def getHeight(self):
        """getHeight(CellCache self) -> uint32_t"""
        return _fife.CellCache_getHeight(self)


    def getMaxIndex(self):
        """getMaxIndex(CellCache self) -> int32_t"""
        return _fife.CellCache_getMaxIndex(self)


    def setMaxNeighborZ(self, z):
        """setMaxNeighborZ(CellCache self, int32_t z)"""
        return _fife.CellCache_setMaxNeighborZ(self, z)


    def getMaxNeighborZ(self):
        """getMaxNeighborZ(CellCache self) -> int32_t"""
        return _fife.CellCache_getMaxNeighborZ(self)


    def isInCellCache(self, location):
        """isInCellCache(CellCache self, Location location) -> bool"""
        return _fife.CellCache_isInCellCache(self, location)


    def getCellsInLine(self, pt1, pt2, blocker=False):
        """getCellsInLine(CellCache self, Point3D pt1, Point3D pt2, bool blocker=False) -> CellVector"""
        return _fife.CellCache_getCellsInLine(self, pt1, pt2, blocker)


    def getCellsInRect(self, rec):
        """getCellsInRect(CellCache self, Rect rec) -> CellVector"""
        return _fife.CellCache_getCellsInRect(self, rec)


    def getCellsInCircle(self, center, radius):
        """getCellsInCircle(CellCache self, Point3D center, uint16_t radius) -> CellVector"""
        return _fife.CellCache_getCellsInCircle(self, center, radius)


    def getCellsInCircleSegment(self, center, radius, sangle, eangle):
        """getCellsInCircleSegment(CellCache self, Point3D center, uint16_t radius, int32_t sangle, int32_t eangle) -> CellVector"""
        return _fife.CellCache_getCellsInCircleSegment(self, center, radius, sangle, eangle)


    def registerCost(self, costId, cost):
        """registerCost(CellCache self, std::string const & costId, double cost)"""
        return _fife.CellCache_registerCost(self, costId, cost)


    def unregisterCost(self, costId):
        """unregisterCost(CellCache self, std::string const & costId)"""
        return _fife.CellCache_unregisterCost(self, costId)


    def getCost(self, costId):
        """getCost(CellCache self, std::string const & costId) -> double"""
        return _fife.CellCache_getCost(self, costId)


    def existsCost(self, costId):
        """existsCost(CellCache self, std::string const & costId) -> bool"""
        return _fife.CellCache_existsCost(self, costId)


    def getCosts(self):
        """getCosts(CellCache self) -> StringList"""
        return _fife.CellCache_getCosts(self)


    def unregisterAllCosts(self):
        """unregisterAllCosts(CellCache self)"""
        return _fife.CellCache_unregisterAllCosts(self)


    def addCellToCost(self, costId, cell):
        """addCellToCost(CellCache self, std::string const & costId, Cell cell)"""
        return _fife.CellCache_addCellToCost(self, costId, cell)


    def addCellsToCost(self, costId, cells):
        """addCellsToCost(CellCache self, std::string const & costId, CellVector cells)"""
        return _fife.CellCache_addCellsToCost(self, costId, cells)


    def removeCellFromCost(self, *args):
        """
        removeCellFromCost(CellCache self, Cell cell)
        removeCellFromCost(CellCache self, std::string const & costId, Cell cell)
        """
        return _fife.CellCache_removeCellFromCost(self, *args)


    def removeCellsFromCost(self, costId, cells):
        """removeCellsFromCost(CellCache self, std::string const & costId, CellVector cells)"""
        return _fife.CellCache_removeCellsFromCost(self, costId, cells)


    def getCostCells(self, costId):
        """getCostCells(CellCache self, std::string const & costId) -> CellVector"""
        return _fife.CellCache_getCostCells(self, costId)


    def getCellCosts(self, cell):
        """getCellCosts(CellCache self, Cell cell) -> StringVector"""
        return _fife.CellCache_getCellCosts(self, cell)


    def existsCostForCell(self, costId, cell):
        """existsCostForCell(CellCache self, std::string const & costId, Cell cell) -> bool"""
        return _fife.CellCache_existsCostForCell(self, costId, cell)


    def setDefaultCostMultiplier(self, multi):
        """setDefaultCostMultiplier(CellCache self, double multi)"""
        return _fife.CellCache_setDefaultCostMultiplier(self, multi)


    def getDefaultCostMultiplier(self):
        """getDefaultCostMultiplier(CellCache self) -> double"""
        return _fife.CellCache_getDefaultCostMultiplier(self)


    def setDefaultSpeedMultiplier(self, multi):
        """setDefaultSpeedMultiplier(CellCache self, double multi)"""
        return _fife.CellCache_setDefaultSpeedMultiplier(self, multi)


    def getDefaultSpeedMultiplier(self):
        """getDefaultSpeedMultiplier(CellCache self) -> double"""
        return _fife.CellCache_getDefaultSpeedMultiplier(self)


    def addCellToArea(self, id, cell):
        """addCellToArea(CellCache self, std::string const & id, Cell cell)"""
        return _fife.CellCache_addCellToArea(self, id, cell)


    def addCellsToArea(self, id, cells):
        """addCellsToArea(CellCache self, std::string const & id, CellVector cells)"""
        return _fife.CellCache_addCellsToArea(self, id, cells)


    def removeCellFromArea(self, id, cell):
        """removeCellFromArea(CellCache self, std::string const & id, Cell cell)"""
        return _fife.CellCache_removeCellFromArea(self, id, cell)


    def removeCellsFromArea(self, id, cells):
        """removeCellsFromArea(CellCache self, std::string const & id, CellVector cells)"""
        return _fife.CellCache_removeCellsFromArea(self, id, cells)


    def removeArea(self, id):
        """removeArea(CellCache self, std::string const & id)"""
        return _fife.CellCache_removeArea(self, id)


    def existsArea(self, id):
        """existsArea(CellCache self, std::string const & id) -> bool"""
        return _fife.CellCache_existsArea(self, id)


    def getAreas(self):
        """getAreas(CellCache self) -> StringVector"""
        return _fife.CellCache_getAreas(self)


    def getCellAreas(self, cell):
        """getCellAreas(CellCache self, Cell cell) -> StringVector"""
        return _fife.CellCache_getCellAreas(self, cell)


    def getAreaCells(self, id):
        """getAreaCells(CellCache self, std::string const & id) -> CellVector"""
        return _fife.CellCache_getAreaCells(self, id)


    def isCellInArea(self, id, cell):
        """isCellInArea(CellCache self, std::string const & id, Cell cell) -> bool"""
        return _fife.CellCache_isCellInArea(self, id, cell)


    def setStaticSize(self, staticSize):
        """setStaticSize(CellCache self, bool staticSize)"""
        return _fife.CellCache_setStaticSize(self, staticSize)


    def isStaticSize(self):
        """isStaticSize(CellCache self) -> bool"""
        return _fife.CellCache_isStaticSize(self)

CellCache.createCells = new_instancemethod(_fife.CellCache_createCells, None, CellCache)
CellCache.forceUpdate = new_instancemethod(_fife.CellCache_forceUpdate, None, CellCache)
CellCache.addCell = new_instancemethod(_fife.CellCache_addCell, None, CellCache)
CellCache.createCell = new_instancemethod(_fife.CellCache_createCell, None, CellCache)
CellCache.getCell = new_instancemethod(_fife.CellCache_getCell, None, CellCache)
CellCache.addInteractOnRuntime = new_instancemethod(_fife.CellCache_addInteractOnRuntime, None, CellCache)
CellCache.removeInteractOnRuntime = new_instancemethod(_fife.CellCache_removeInteractOnRuntime, None, CellCache)
CellCache.getSize = new_instancemethod(_fife.CellCache_getSize, None, CellCache)
CellCache.setSize = new_instancemethod(_fife.CellCache_setSize, None, CellCache)
CellCache.getWidth = new_instancemethod(_fife.CellCache_getWidth, None, CellCache)
CellCache.getHeight = new_instancemethod(_fife.CellCache_getHeight, None, CellCache)
CellCache.getMaxIndex = new_instancemethod(_fife.CellCache_getMaxIndex, None, CellCache)
CellCache.setMaxNeighborZ = new_instancemethod(_fife.CellCache_setMaxNeighborZ, None, CellCache)
CellCache.getMaxNeighborZ = new_instancemethod(_fife.CellCache_getMaxNeighborZ, None, CellCache)
CellCache.isInCellCache = new_instancemethod(_fife.CellCache_isInCellCache, None, CellCache)
CellCache.getCellsInLine = new_instancemethod(_fife.CellCache_getCellsInLine, None, CellCache)
CellCache.getCellsInRect = new_instancemethod(_fife.CellCache_getCellsInRect, None, CellCache)
CellCache.getCellsInCircle = new_instancemethod(_fife.CellCache_getCellsInCircle, None, CellCache)
CellCache.getCellsInCircleSegment = new_instancemethod(_fife.CellCache_getCellsInCircleSegment, None, CellCache)
CellCache.registerCost = new_instancemethod(_fife.CellCache_registerCost, None, CellCache)
CellCache.unregisterCost = new_instancemethod(_fife.CellCache_unregisterCost, None, CellCache)
CellCache.getCost = new_instancemethod(_fife.CellCache_getCost, None, CellCache)
CellCache.existsCost = new_instancemethod(_fife.CellCache_existsCost, None, CellCache)
CellCache.getCosts = new_instancemethod(_fife.CellCache_getCosts, None, CellCache)
CellCache.unregisterAllCosts = new_instancemethod(_fife.CellCache_unregisterAllCosts, None, CellCache)
CellCache.addCellToCost = new_instancemethod(_fife.CellCache_addCellToCost, None, CellCache)
CellCache.addCellsToCost = new_instancemethod(_fife.CellCache_addCellsToCost, None, CellCache)
CellCache.removeCellFromCost = new_instancemethod(_fife.CellCache_removeCellFromCost, None, CellCache)
CellCache.removeCellsFromCost = new_instancemethod(_fife.CellCache_removeCellsFromCost, None, CellCache)
CellCache.getCostCells = new_instancemethod(_fife.CellCache_getCostCells, None, CellCache)
CellCache.getCellCosts = new_instancemethod(_fife.CellCache_getCellCosts, None, CellCache)
CellCache.existsCostForCell = new_instancemethod(_fife.CellCache_existsCostForCell, None, CellCache)
CellCache.setDefaultCostMultiplier = new_instancemethod(_fife.CellCache_setDefaultCostMultiplier, None, CellCache)
CellCache.getDefaultCostMultiplier = new_instancemethod(_fife.CellCache_getDefaultCostMultiplier, None, CellCache)
CellCache.setDefaultSpeedMultiplier = new_instancemethod(_fife.CellCache_setDefaultSpeedMultiplier, None, CellCache)
CellCache.getDefaultSpeedMultiplier = new_instancemethod(_fife.CellCache_getDefaultSpeedMultiplier, None, CellCache)
CellCache.addCellToArea = new_instancemethod(_fife.CellCache_addCellToArea, None, CellCache)
CellCache.addCellsToArea = new_instancemethod(_fife.CellCache_addCellsToArea, None, CellCache)
CellCache.removeCellFromArea = new_instancemethod(_fife.CellCache_removeCellFromArea, None, CellCache)
CellCache.removeCellsFromArea = new_instancemethod(_fife.CellCache_removeCellsFromArea, None, CellCache)
CellCache.removeArea = new_instancemethod(_fife.CellCache_removeArea, None, CellCache)
CellCache.existsArea = new_instancemethod(_fife.CellCache_existsArea, None, CellCache)
CellCache.getAreas = new_instancemethod(_fife.CellCache_getAreas, None, CellCache)
CellCache.getCellAreas = new_instancemethod(_fife.CellCache_getCellAreas, None, CellCache)
CellCache.getAreaCells = new_instancemethod(_fife.CellCache_getAreaCells, None, CellCache)
CellCache.isCellInArea = new_instancemethod(_fife.CellCache_isCellInArea, None, CellCache)
CellCache.setStaticSize = new_instancemethod(_fife.CellCache_setStaticSize, None, CellCache)
CellCache.isStaticSize = new_instancemethod(_fife.CellCache_isStaticSize, None, CellCache)
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."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LayerChangeListener

    def onLayerChanged(self, layer, changedInstances):
        """onLayerChanged(LayerChangeListener self, Layer layer, InstanceVector changedInstances)"""
        return _fife.LayerChangeListener_onLayerChanged(self, layer, changedInstances)


    def onInstanceCreate(self, layer, instance):
        """onInstanceCreate(LayerChangeListener self, Layer layer, Instance instance)"""
        return _fife.LayerChangeListener_onInstanceCreate(self, layer, instance)


    def onInstanceDelete(self, layer, instance):
        """onInstanceDelete(LayerChangeListener self, Layer layer, Instance instance)"""
        return _fife.LayerChangeListener_onInstanceDelete(self, layer, instance)


    def __init__(self):
        """__init__(FIFE::LayerChangeListener self) -> LayerChangeListener"""
        if self.__class__ == LayerChangeListener:
            _self = None
        else:
            _self = self
        _fife.LayerChangeListener_swiginit(self, _fife.new_LayerChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_LayerChangeListener(self)
        return weakref_proxy(self)
LayerChangeListener.onLayerChanged = new_instancemethod(_fife.LayerChangeListener_onLayerChanged, None, LayerChangeListener)
LayerChangeListener.onInstanceCreate = new_instancemethod(_fife.LayerChangeListener_onInstanceCreate, None, LayerChangeListener)
LayerChangeListener.onInstanceDelete = new_instancemethod(_fife.LayerChangeListener_onInstanceDelete, None, LayerChangeListener)
LayerChangeListener_swigregister = _fife.LayerChangeListener_swigregister
LayerChangeListener_swigregister(LayerChangeListener)

class Layer(FifeClass):
    """Proxy of C++ FIFE::Layer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, identifier, map, geometry):
        """__init__(FIFE::Layer self, std::string const & identifier, Map map, CellGrid geometry) -> Layer"""
        _fife.Layer_swiginit(self, _fife.new_Layer(identifier, map, geometry))
    __swig_destroy__ = _fife.delete_Layer

    def getId(self):
        """getId(Layer self) -> std::string const &"""
        return _fife.Layer_getId(self)


    def setId(self, id):
        """setId(Layer self, std::string const & id)"""
        return _fife.Layer_setId(self, id)


    def getCellGrid(self):
        """getCellGrid(Layer self) -> CellGrid"""
        return _fife.Layer_getCellGrid(self)


    def setCellGrid(self, grid):
        """setCellGrid(Layer self, CellGrid grid)"""
        return _fife.Layer_setCellGrid(self, grid)


    def getMap(self):
        """getMap(Layer self) -> Map"""
        return _fife.Layer_getMap(self)


    def hasInstances(self):
        """hasInstances(Layer self) -> bool"""
        return _fife.Layer_hasInstances(self)


    def createInstance(self, *args):
        """
        createInstance(Layer self, Object object, Point3D p, std::string const & id) -> Instance
        createInstance(Layer self, Object object, DoublePoint3D p, std::string const & id) -> Instance
        """
        return _fife.Layer_createInstance(self, *args)


    def addInstance(self, instance, p):
        """addInstance(Layer self, Instance instance, DoublePoint3D p) -> bool"""
        return _fife.Layer_addInstance(self, instance, p)


    def deleteInstance(self, object):
        """deleteInstance(Layer self, Instance object)"""
        return _fife.Layer_deleteInstance(self, object)


    def removeInstance(self, object):
        """removeInstance(Layer self, Instance object)"""
        return _fife.Layer_removeInstance(self, object)


    def getInstances(self, *args):
        """
        getInstances(Layer self) -> InstanceVector
        getInstances(Layer self, std::string const & identifier) -> InstanceVector
        """
        return _fife.Layer_getInstances(self, *args)


    def getInstancesAt(self, loc, use_exactcoordinates=False):
        """getInstancesAt(Layer self, Location loc, bool use_exactcoordinates=False) -> InstanceVector"""
        return _fife.Layer_getInstancesAt(self, loc, use_exactcoordinates)


    def getInstancesIn(self, rec):
        """getInstancesIn(Layer self, Rect rec) -> InstanceList"""
        return _fife.Layer_getInstancesIn(self, rec)


    def getInstancesInLine(self, pt1, pt2):
        """getInstancesInLine(Layer self, Point3D pt1, Point3D pt2) -> InstanceVector"""
        return _fife.Layer_getInstancesInLine(self, pt1, pt2)


    def getInstancesInCircle(self, center, radius):
        """getInstancesInCircle(Layer self, Point3D center, uint16_t radius) -> InstanceVector"""
        return _fife.Layer_getInstancesInCircle(self, center, radius)


    def getInstancesInCircleSegment(self, center, radius, sangle, eangle):
        """getInstancesInCircleSegment(Layer self, Point3D center, uint16_t radius, int32_t sangle, int32_t eangle) -> InstanceVector"""
        return _fife.Layer_getInstancesInCircleSegment(self, center, radius, sangle, eangle)


    def getInstance(self, id):
        """getInstance(Layer self, std::string const & id) -> Instance"""
        return _fife.Layer_getInstance(self, id)


    def setInstancesVisible(self, vis):
        """setInstancesVisible(Layer self, bool vis)"""
        return _fife.Layer_setInstancesVisible(self, vis)


    def setLayerTransparency(self, transparency):
        """setLayerTransparency(Layer self, uint8_t transparency)"""
        return _fife.Layer_setLayerTransparency(self, transparency)


    def getLayerTransparency(self):
        """getLayerTransparency(Layer self) -> uint8_t"""
        return _fife.Layer_getLayerTransparency(self)


    def getMinMaxCoordinates(self, min, max, layer=None):
        """getMinMaxCoordinates(Layer self, Point3D min, Point3D max, Layer layer=None)"""
        return _fife.Layer_getMinMaxCoordinates(self, min, max, layer)


    def cellContainsBlockingInstance(self, cellCoordinate):
        """cellContainsBlockingInstance(Layer self, Point3D cellCoordinate) -> bool"""
        return _fife.Layer_cellContainsBlockingInstance(self, cellCoordinate)


    def getBlockingInstances(self, cellCoordinate):
        """getBlockingInstances(Layer self, Point3D cellCoordinate) -> InstanceVector"""
        return _fife.Layer_getBlockingInstances(self, cellCoordinate)


    def toggleInstancesVisible(self):
        """toggleInstancesVisible(Layer self)"""
        return _fife.Layer_toggleInstancesVisible(self)


    def areInstancesVisible(self):
        """areInstancesVisible(Layer self) -> bool"""
        return _fife.Layer_areInstancesVisible(self)


    def setPathingStrategy(self, strategy):
        """setPathingStrategy(Layer self, FIFE::PathingStrategy strategy)"""
        return _fife.Layer_setPathingStrategy(self, strategy)


    def getPathingStrategy(self):
        """getPathingStrategy(Layer self) -> FIFE::PathingStrategy"""
        return _fife.Layer_getPathingStrategy(self)


    def setSortingStrategy(self, strategy):
        """setSortingStrategy(Layer self, FIFE::SortingStrategy strategy)"""
        return _fife.Layer_setSortingStrategy(self, strategy)


    def getSortingStrategy(self):
        """getSortingStrategy(Layer self) -> FIFE::SortingStrategy"""
        return _fife.Layer_getSortingStrategy(self)


    def setWalkable(self, walkable):
        """setWalkable(Layer self, bool walkable)"""
        return _fife.Layer_setWalkable(self, walkable)


    def isWalkable(self):
        """isWalkable(Layer self) -> bool"""
        return _fife.Layer_isWalkable(self)


    def setInteract(self, interact, id):
        """setInteract(Layer self, bool interact, std::string const & id)"""
        return _fife.Layer_setInteract(self, interact, id)


    def isInteract(self):
        """isInteract(Layer self) -> bool"""
        return _fife.Layer_isInteract(self)


    def getWalkableId(self):
        """getWalkableId(Layer self) -> std::string const &"""
        return _fife.Layer_getWalkableId(self)


    def addInteractLayer(self, layer):
        """addInteractLayer(Layer self, Layer layer)"""
        return _fife.Layer_addInteractLayer(self, layer)


    def getInteractLayers(self):
        """getInteractLayers(Layer self) -> LayerVector"""
        return _fife.Layer_getInteractLayers(self)


    def removeInteractLayer(self, layer):
        """removeInteractLayer(Layer self, Layer layer)"""
        return _fife.Layer_removeInteractLayer(self, layer)


    def createCellCache(self):
        """createCellCache(Layer self)"""
        return _fife.Layer_createCellCache(self)


    def getCellCache(self):
        """getCellCache(Layer self) -> CellCache"""
        return _fife.Layer_getCellCache(self)


    def destroyCellCache(self):
        """destroyCellCache(Layer self)"""
        return _fife.Layer_destroyCellCache(self)


    def addChangeListener(self, listener):
        """addChangeListener(Layer self, LayerChangeListener listener)"""
        return _fife.Layer_addChangeListener(self, listener)


    def removeChangeListener(self, listener):
        """removeChangeListener(Layer self, LayerChangeListener listener)"""
        return _fife.Layer_removeChangeListener(self, listener)


    def isChanged(self):
        """isChanged(Layer self) -> bool"""
        return _fife.Layer_isChanged(self)


    def getChangedInstances(self):
        """getChangedInstances(Layer self) -> InstanceVector"""
        return _fife.Layer_getChangedInstances(self)


    def setStatic(self, stati):
        """setStatic(Layer self, bool stati)"""
        return _fife.Layer_setStatic(self, stati)


    def isStatic(self):
        """isStatic(Layer self) -> bool"""
        return _fife.Layer_isStatic(self)

Layer.getId = new_instancemethod(_fife.Layer_getId, None, Layer)
Layer.setId = new_instancemethod(_fife.Layer_setId, None, Layer)
Layer.getCellGrid = new_instancemethod(_fife.Layer_getCellGrid, None, Layer)
Layer.setCellGrid = new_instancemethod(_fife.Layer_setCellGrid, None, Layer)
Layer.getMap = new_instancemethod(_fife.Layer_getMap, None, Layer)
Layer.hasInstances = new_instancemethod(_fife.Layer_hasInstances, None, Layer)
Layer.createInstance = new_instancemethod(_fife.Layer_createInstance, None, Layer)
Layer.addInstance = new_instancemethod(_fife.Layer_addInstance, None, Layer)
Layer.deleteInstance = new_instancemethod(_fife.Layer_deleteInstance, None, Layer)
Layer.removeInstance = new_instancemethod(_fife.Layer_removeInstance, None, Layer)
Layer.getInstances = new_instancemethod(_fife.Layer_getInstances, None, Layer)
Layer.getInstancesAt = new_instancemethod(_fife.Layer_getInstancesAt, None, Layer)
Layer.getInstancesIn = new_instancemethod(_fife.Layer_getInstancesIn, None, Layer)
Layer.getInstancesInLine = new_instancemethod(_fife.Layer_getInstancesInLine, None, Layer)
Layer.getInstancesInCircle = new_instancemethod(_fife.Layer_getInstancesInCircle, None, Layer)
Layer.getInstancesInCircleSegment = new_instancemethod(_fife.Layer_getInstancesInCircleSegment, None, Layer)
Layer.getInstance = new_instancemethod(_fife.Layer_getInstance, None, Layer)
Layer.setInstancesVisible = new_instancemethod(_fife.Layer_setInstancesVisible, None, Layer)
Layer.setLayerTransparency = new_instancemethod(_fife.Layer_setLayerTransparency, None, Layer)
Layer.getLayerTransparency = new_instancemethod(_fife.Layer_getLayerTransparency, None, Layer)
Layer.getMinMaxCoordinates = new_instancemethod(_fife.Layer_getMinMaxCoordinates, None, Layer)
Layer.cellContainsBlockingInstance = new_instancemethod(_fife.Layer_cellContainsBlockingInstance, None, Layer)
Layer.getBlockingInstances = new_instancemethod(_fife.Layer_getBlockingInstances, None, Layer)
Layer.toggleInstancesVisible = new_instancemethod(_fife.Layer_toggleInstancesVisible, None, Layer)
Layer.areInstancesVisible = new_instancemethod(_fife.Layer_areInstancesVisible, None, Layer)
Layer.setPathingStrategy = new_instancemethod(_fife.Layer_setPathingStrategy, None, Layer)
Layer.getPathingStrategy = new_instancemethod(_fife.Layer_getPathingStrategy, None, Layer)
Layer.setSortingStrategy = new_instancemethod(_fife.Layer_setSortingStrategy, None, Layer)
Layer.getSortingStrategy = new_instancemethod(_fife.Layer_getSortingStrategy, None, Layer)
Layer.setWalkable = new_instancemethod(_fife.Layer_setWalkable, None, Layer)
Layer.isWalkable = new_instancemethod(_fife.Layer_isWalkable, None, Layer)
Layer.setInteract = new_instancemethod(_fife.Layer_setInteract, None, Layer)
Layer.isInteract = new_instancemethod(_fife.Layer_isInteract, None, Layer)
Layer.getWalkableId = new_instancemethod(_fife.Layer_getWalkableId, None, Layer)
Layer.addInteractLayer = new_instancemethod(_fife.Layer_addInteractLayer, None, Layer)
Layer.getInteractLayers = new_instancemethod(_fife.Layer_getInteractLayers, None, Layer)
Layer.removeInteractLayer = new_instancemethod(_fife.Layer_removeInteractLayer, None, Layer)
Layer.createCellCache = new_instancemethod(_fife.Layer_createCellCache, None, Layer)
Layer.getCellCache = new_instancemethod(_fife.Layer_getCellCache, None, Layer)
Layer.destroyCellCache = new_instancemethod(_fife.Layer_destroyCellCache, None, Layer)
Layer.addChangeListener = new_instancemethod(_fife.Layer_addChangeListener, None, Layer)
Layer.removeChangeListener = new_instancemethod(_fife.Layer_removeChangeListener, None, Layer)
Layer.isChanged = new_instancemethod(_fife.Layer_isChanged, None, Layer)
Layer.getChangedInstances = new_instancemethod(_fife.Layer_getChangedInstances, None, Layer)
Layer.setStatic = new_instancemethod(_fife.Layer_setStatic, None, Layer)
Layer.isStatic = new_instancemethod(_fife.Layer_isStatic, None, Layer)
Layer_swigregister = _fife.Layer_swigregister
Layer_swigregister(Layer)

class LayerList(object):
    """Proxy of C++ std::list<(p.FIFE::Layer)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(LayerList self) -> SwigPyIterator"""
        return _fife.LayerList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(LayerList self) -> bool"""
        return _fife.LayerList___nonzero__(self)


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


    def __len__(self):
        """__len__(LayerList self) -> std::list< FIFE::Layer * >::size_type"""
        return _fife.LayerList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(LayerList self, std::list< FIFE::Layer * >::difference_type i, std::list< FIFE::Layer * >::difference_type j) -> LayerList"""
        return _fife.LayerList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(LayerList self, std::list< FIFE::Layer * >::difference_type i, std::list< FIFE::Layer * >::difference_type j)
        __setslice__(LayerList self, std::list< FIFE::Layer * >::difference_type i, std::list< FIFE::Layer * >::difference_type j, LayerList v)
        """
        return _fife.LayerList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(LayerList self, std::list< FIFE::Layer * >::difference_type i, std::list< FIFE::Layer * >::difference_type j)"""
        return _fife.LayerList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(LayerList self, std::list< FIFE::Layer * >::difference_type i)
        __delitem__(LayerList self, PySliceObject * slice)
        """
        return _fife.LayerList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(LayerList self, PySliceObject * slice) -> LayerList
        __getitem__(LayerList self, std::list< FIFE::Layer * >::difference_type i) -> Layer
        """
        return _fife.LayerList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(LayerList self, PySliceObject * slice, LayerList v)
        __setitem__(LayerList self, PySliceObject * slice)
        __setitem__(LayerList self, std::list< FIFE::Layer * >::difference_type i, Layer x)
        """
        return _fife.LayerList___setitem__(self, *args)


    def pop(self):
        """pop(LayerList self) -> Layer"""
        return _fife.LayerList_pop(self)


    def append(self, x):
        """append(LayerList self, Layer x)"""
        return _fife.LayerList_append(self, x)


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


    def size(self):
        """size(LayerList self) -> std::list< FIFE::Layer * >::size_type"""
        return _fife.LayerList_size(self)


    def swap(self, v):
        """swap(LayerList self, LayerList v)"""
        return _fife.LayerList_swap(self, v)


    def begin(self):
        """begin(LayerList self) -> std::list< FIFE::Layer * >::iterator"""
        return _fife.LayerList_begin(self)


    def end(self):
        """end(LayerList self) -> std::list< FIFE::Layer * >::iterator"""
        return _fife.LayerList_end(self)


    def rbegin(self):
        """rbegin(LayerList self) -> std::list< FIFE::Layer * >::reverse_iterator"""
        return _fife.LayerList_rbegin(self)


    def rend(self):
        """rend(LayerList self) -> std::list< FIFE::Layer * >::reverse_iterator"""
        return _fife.LayerList_rend(self)


    def clear(self):
        """clear(LayerList self)"""
        return _fife.LayerList_clear(self)


    def get_allocator(self):
        """get_allocator(LayerList self) -> std::list< FIFE::Layer * >::allocator_type"""
        return _fife.LayerList_get_allocator(self)


    def pop_back(self):
        """pop_back(LayerList self)"""
        return _fife.LayerList_pop_back(self)


    def erase(self, *args):
        """
        erase(LayerList self, std::list< FIFE::Layer * >::iterator pos) -> std::list< FIFE::Layer * >::iterator
        erase(LayerList self, std::list< FIFE::Layer * >::iterator first, std::list< FIFE::Layer * >::iterator last) -> std::list< FIFE::Layer * >::iterator
        """
        return _fife.LayerList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.FIFE::Layer)> self) -> LayerList
        __init__(std::list<(p.FIFE::Layer)> self, LayerList arg2) -> LayerList
        __init__(std::list<(p.FIFE::Layer)> self, std::list< FIFE::Layer * >::size_type size) -> LayerList
        __init__(std::list<(p.FIFE::Layer)> self, std::list< FIFE::Layer * >::size_type size, Layer value) -> LayerList
        """
        _fife.LayerList_swiginit(self, _fife.new_LayerList(*args))

    def push_back(self, x):
        """push_back(LayerList self, Layer x)"""
        return _fife.LayerList_push_back(self, x)


    def front(self):
        """front(LayerList self) -> Layer"""
        return _fife.LayerList_front(self)


    def back(self):
        """back(LayerList self) -> Layer"""
        return _fife.LayerList_back(self)


    def assign(self, n, x):
        """assign(LayerList self, std::list< FIFE::Layer * >::size_type n, Layer x)"""
        return _fife.LayerList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(LayerList self, std::list< FIFE::Layer * >::size_type new_size)
        resize(LayerList self, std::list< FIFE::Layer * >::size_type new_size, Layer x)
        """
        return _fife.LayerList_resize(self, *args)


    def insert(self, *args):
        """
        insert(LayerList self, std::list< FIFE::Layer * >::iterator pos, Layer x) -> std::list< FIFE::Layer * >::iterator
        insert(LayerList self, std::list< FIFE::Layer * >::iterator pos, std::list< FIFE::Layer * >::size_type n, Layer x)
        """
        return _fife.LayerList_insert(self, *args)


    def pop_front(self):
        """pop_front(LayerList self)"""
        return _fife.LayerList_pop_front(self)


    def push_front(self, x):
        """push_front(LayerList self, Layer x)"""
        return _fife.LayerList_push_front(self, x)


    def remove(self, x):
        """remove(LayerList self, Layer x)"""
        return _fife.LayerList_remove(self, x)


    def unique(self):
        """unique(LayerList self)"""
        return _fife.LayerList_unique(self)


    def reverse(self):
        """reverse(LayerList self)"""
        return _fife.LayerList_reverse(self)


    def sort(self):
        """sort(LayerList self)"""
        return _fife.LayerList_sort(self)


    def merge(self, x):
        """merge(LayerList self, LayerList x)"""
        return _fife.LayerList_merge(self, x)

    __swig_destroy__ = _fife.delete_LayerList
LayerList.iterator = new_instancemethod(_fife.LayerList_iterator, None, LayerList)
LayerList.__nonzero__ = new_instancemethod(_fife.LayerList___nonzero__, None, LayerList)
LayerList.__bool__ = new_instancemethod(_fife.LayerList___bool__, None, LayerList)
LayerList.__len__ = new_instancemethod(_fife.LayerList___len__, None, LayerList)
LayerList.__getslice__ = new_instancemethod(_fife.LayerList___getslice__, None, LayerList)
LayerList.__setslice__ = new_instancemethod(_fife.LayerList___setslice__, None, LayerList)
LayerList.__delslice__ = new_instancemethod(_fife.LayerList___delslice__, None, LayerList)
LayerList.__delitem__ = new_instancemethod(_fife.LayerList___delitem__, None, LayerList)
LayerList.__getitem__ = new_instancemethod(_fife.LayerList___getitem__, None, LayerList)
LayerList.__setitem__ = new_instancemethod(_fife.LayerList___setitem__, None, LayerList)
LayerList.pop = new_instancemethod(_fife.LayerList_pop, None, LayerList)
LayerList.append = new_instancemethod(_fife.LayerList_append, None, LayerList)
LayerList.empty = new_instancemethod(_fife.LayerList_empty, None, LayerList)
LayerList.size = new_instancemethod(_fife.LayerList_size, None, LayerList)
LayerList.swap = new_instancemethod(_fife.LayerList_swap, None, LayerList)
LayerList.begin = new_instancemethod(_fife.LayerList_begin, None, LayerList)
LayerList.end = new_instancemethod(_fife.LayerList_end, None, LayerList)
LayerList.rbegin = new_instancemethod(_fife.LayerList_rbegin, None, LayerList)
LayerList.rend = new_instancemethod(_fife.LayerList_rend, None, LayerList)
LayerList.clear = new_instancemethod(_fife.LayerList_clear, None, LayerList)
LayerList.get_allocator = new_instancemethod(_fife.LayerList_get_allocator, None, LayerList)
LayerList.pop_back = new_instancemethod(_fife.LayerList_pop_back, None, LayerList)
LayerList.erase = new_instancemethod(_fife.LayerList_erase, None, LayerList)
LayerList.push_back = new_instancemethod(_fife.LayerList_push_back, None, LayerList)
LayerList.front = new_instancemethod(_fife.LayerList_front, None, LayerList)
LayerList.back = new_instancemethod(_fife.LayerList_back, None, LayerList)
LayerList.assign = new_instancemethod(_fife.LayerList_assign, None, LayerList)
LayerList.resize = new_instancemethod(_fife.LayerList_resize, None, LayerList)
LayerList.insert = new_instancemethod(_fife.LayerList_insert, None, LayerList)
LayerList.pop_front = new_instancemethod(_fife.LayerList_pop_front, None, LayerList)
LayerList.push_front = new_instancemethod(_fife.LayerList_push_front, None, LayerList)
LayerList.remove = new_instancemethod(_fife.LayerList_remove, None, LayerList)
LayerList.unique = new_instancemethod(_fife.LayerList_unique, None, LayerList)
LayerList.reverse = new_instancemethod(_fife.LayerList_reverse, None, LayerList)
LayerList.sort = new_instancemethod(_fife.LayerList_sort, None, LayerList)
LayerList.merge = new_instancemethod(_fife.LayerList_merge, None, LayerList)
LayerList_swigregister = _fife.LayerList_swigregister
LayerList_swigregister(LayerList)

class LayerVector(object):
    """Proxy of C++ std::vector<(p.FIFE::Layer)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(LayerVector self) -> SwigPyIterator"""
        return _fife.LayerVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(LayerVector self) -> bool"""
        return _fife.LayerVector___nonzero__(self)


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


    def __len__(self):
        """__len__(LayerVector self) -> std::vector< FIFE::Layer * >::size_type"""
        return _fife.LayerVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(LayerVector self, std::vector< FIFE::Layer * >::difference_type i, std::vector< FIFE::Layer * >::difference_type j) -> LayerVector"""
        return _fife.LayerVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(LayerVector self, std::vector< FIFE::Layer * >::difference_type i, std::vector< FIFE::Layer * >::difference_type j)
        __setslice__(LayerVector self, std::vector< FIFE::Layer * >::difference_type i, std::vector< FIFE::Layer * >::difference_type j, LayerVector v)
        """
        return _fife.LayerVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(LayerVector self, std::vector< FIFE::Layer * >::difference_type i, std::vector< FIFE::Layer * >::difference_type j)"""
        return _fife.LayerVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(LayerVector self, std::vector< FIFE::Layer * >::difference_type i)
        __delitem__(LayerVector self, PySliceObject * slice)
        """
        return _fife.LayerVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(LayerVector self, PySliceObject * slice) -> LayerVector
        __getitem__(LayerVector self, std::vector< FIFE::Layer * >::difference_type i) -> Layer
        """
        return _fife.LayerVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(LayerVector self, PySliceObject * slice, LayerVector v)
        __setitem__(LayerVector self, PySliceObject * slice)
        __setitem__(LayerVector self, std::vector< FIFE::Layer * >::difference_type i, Layer x)
        """
        return _fife.LayerVector___setitem__(self, *args)


    def pop(self):
        """pop(LayerVector self) -> Layer"""
        return _fife.LayerVector_pop(self)


    def append(self, x):
        """append(LayerVector self, Layer x)"""
        return _fife.LayerVector_append(self, x)


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


    def size(self):
        """size(LayerVector self) -> std::vector< FIFE::Layer * >::size_type"""
        return _fife.LayerVector_size(self)


    def swap(self, v):
        """swap(LayerVector self, LayerVector v)"""
        return _fife.LayerVector_swap(self, v)


    def begin(self):
        """begin(LayerVector self) -> std::vector< FIFE::Layer * >::iterator"""
        return _fife.LayerVector_begin(self)


    def end(self):
        """end(LayerVector self) -> std::vector< FIFE::Layer * >::iterator"""
        return _fife.LayerVector_end(self)


    def rbegin(self):
        """rbegin(LayerVector self) -> std::vector< FIFE::Layer * >::reverse_iterator"""
        return _fife.LayerVector_rbegin(self)


    def rend(self):
        """rend(LayerVector self) -> std::vector< FIFE::Layer * >::reverse_iterator"""
        return _fife.LayerVector_rend(self)


    def clear(self):
        """clear(LayerVector self)"""
        return _fife.LayerVector_clear(self)


    def get_allocator(self):
        """get_allocator(LayerVector self) -> std::vector< FIFE::Layer * >::allocator_type"""
        return _fife.LayerVector_get_allocator(self)


    def pop_back(self):
        """pop_back(LayerVector self)"""
        return _fife.LayerVector_pop_back(self)


    def erase(self, *args):
        """
        erase(LayerVector self, std::vector< FIFE::Layer * >::iterator pos) -> std::vector< FIFE::Layer * >::iterator
        erase(LayerVector self, std::vector< FIFE::Layer * >::iterator first, std::vector< FIFE::Layer * >::iterator last) -> std::vector< FIFE::Layer * >::iterator
        """
        return _fife.LayerVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.FIFE::Layer)> self) -> LayerVector
        __init__(std::vector<(p.FIFE::Layer)> self, LayerVector arg2) -> LayerVector
        __init__(std::vector<(p.FIFE::Layer)> self, std::vector< FIFE::Layer * >::size_type size) -> LayerVector
        __init__(std::vector<(p.FIFE::Layer)> self, std::vector< FIFE::Layer * >::size_type size, Layer value) -> LayerVector
        """
        _fife.LayerVector_swiginit(self, _fife.new_LayerVector(*args))

    def push_back(self, x):
        """push_back(LayerVector self, Layer x)"""
        return _fife.LayerVector_push_back(self, x)


    def front(self):
        """front(LayerVector self) -> Layer"""
        return _fife.LayerVector_front(self)


    def back(self):
        """back(LayerVector self) -> Layer"""
        return _fife.LayerVector_back(self)


    def assign(self, n, x):
        """assign(LayerVector self, std::vector< FIFE::Layer * >::size_type n, Layer x)"""
        return _fife.LayerVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(LayerVector self, std::vector< FIFE::Layer * >::size_type new_size)
        resize(LayerVector self, std::vector< FIFE::Layer * >::size_type new_size, Layer x)
        """
        return _fife.LayerVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(LayerVector self, std::vector< FIFE::Layer * >::iterator pos, Layer x) -> std::vector< FIFE::Layer * >::iterator
        insert(LayerVector self, std::vector< FIFE::Layer * >::iterator pos, std::vector< FIFE::Layer * >::size_type n, Layer x)
        """
        return _fife.LayerVector_insert(self, *args)


    def reserve(self, n):
        """reserve(LayerVector self, std::vector< FIFE::Layer * >::size_type n)"""
        return _fife.LayerVector_reserve(self, n)


    def capacity(self):
        """capacity(LayerVector self) -> std::vector< FIFE::Layer * >::size_type"""
        return _fife.LayerVector_capacity(self)

    __swig_destroy__ = _fife.delete_LayerVector
LayerVector.iterator = new_instancemethod(_fife.LayerVector_iterator, None, LayerVector)
LayerVector.__nonzero__ = new_instancemethod(_fife.LayerVector___nonzero__, None, LayerVector)
LayerVector.__bool__ = new_instancemethod(_fife.LayerVector___bool__, None, LayerVector)
LayerVector.__len__ = new_instancemethod(_fife.LayerVector___len__, None, LayerVector)
LayerVector.__getslice__ = new_instancemethod(_fife.LayerVector___getslice__, None, LayerVector)
LayerVector.__setslice__ = new_instancemethod(_fife.LayerVector___setslice__, None, LayerVector)
LayerVector.__delslice__ = new_instancemethod(_fife.LayerVector___delslice__, None, LayerVector)
LayerVector.__delitem__ = new_instancemethod(_fife.LayerVector___delitem__, None, LayerVector)
LayerVector.__getitem__ = new_instancemethod(_fife.LayerVector___getitem__, None, LayerVector)
LayerVector.__setitem__ = new_instancemethod(_fife.LayerVector___setitem__, None, LayerVector)
LayerVector.pop = new_instancemethod(_fife.LayerVector_pop, None, LayerVector)
LayerVector.append = new_instancemethod(_fife.LayerVector_append, None, LayerVector)
LayerVector.empty = new_instancemethod(_fife.LayerVector_empty, None, LayerVector)
LayerVector.size = new_instancemethod(_fife.LayerVector_size, None, LayerVector)
LayerVector.swap = new_instancemethod(_fife.LayerVector_swap, None, LayerVector)
LayerVector.begin = new_instancemethod(_fife.LayerVector_begin, None, LayerVector)
LayerVector.end = new_instancemethod(_fife.LayerVector_end, None, LayerVector)
LayerVector.rbegin = new_instancemethod(_fife.LayerVector_rbegin, None, LayerVector)
LayerVector.rend = new_instancemethod(_fife.LayerVector_rend, None, LayerVector)
LayerVector.clear = new_instancemethod(_fife.LayerVector_clear, None, LayerVector)
LayerVector.get_allocator = new_instancemethod(_fife.LayerVector_get_allocator, None, LayerVector)
LayerVector.pop_back = new_instancemethod(_fife.LayerVector_pop_back, None, LayerVector)
LayerVector.erase = new_instancemethod(_fife.LayerVector_erase, None, LayerVector)
LayerVector.push_back = new_instancemethod(_fife.LayerVector_push_back, None, LayerVector)
LayerVector.front = new_instancemethod(_fife.LayerVector_front, None, LayerVector)
LayerVector.back = new_instancemethod(_fife.LayerVector_back, None, LayerVector)
LayerVector.assign = new_instancemethod(_fife.LayerVector_assign, None, LayerVector)
LayerVector.resize = new_instancemethod(_fife.LayerVector_resize, None, LayerVector)
LayerVector.insert = new_instancemethod(_fife.LayerVector_insert, None, LayerVector)
LayerVector.reserve = new_instancemethod(_fife.LayerVector_reserve, None, LayerVector)
LayerVector.capacity = new_instancemethod(_fife.LayerVector_capacity, None, LayerVector)
LayerVector_swigregister = _fife.LayerVector_swigregister
LayerVector_swigregister(LayerVector)

class CameraVector(object):
    """Proxy of C++ std::vector<(p.FIFE::Camera)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(CameraVector self) -> SwigPyIterator"""
        return _fife.CameraVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(CameraVector self) -> bool"""
        return _fife.CameraVector___nonzero__(self)


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


    def __len__(self):
        """__len__(CameraVector self) -> std::vector< FIFE::Camera * >::size_type"""
        return _fife.CameraVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(CameraVector self, std::vector< FIFE::Camera * >::difference_type i, std::vector< FIFE::Camera * >::difference_type j) -> CameraVector"""
        return _fife.CameraVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(CameraVector self, std::vector< FIFE::Camera * >::difference_type i, std::vector< FIFE::Camera * >::difference_type j)
        __setslice__(CameraVector self, std::vector< FIFE::Camera * >::difference_type i, std::vector< FIFE::Camera * >::difference_type j, CameraVector v)
        """
        return _fife.CameraVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(CameraVector self, std::vector< FIFE::Camera * >::difference_type i, std::vector< FIFE::Camera * >::difference_type j)"""
        return _fife.CameraVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(CameraVector self, std::vector< FIFE::Camera * >::difference_type i)
        __delitem__(CameraVector self, PySliceObject * slice)
        """
        return _fife.CameraVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(CameraVector self, PySliceObject * slice) -> CameraVector
        __getitem__(CameraVector self, std::vector< FIFE::Camera * >::difference_type i) -> Camera
        """
        return _fife.CameraVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(CameraVector self, PySliceObject * slice, CameraVector v)
        __setitem__(CameraVector self, PySliceObject * slice)
        __setitem__(CameraVector self, std::vector< FIFE::Camera * >::difference_type i, Camera x)
        """
        return _fife.CameraVector___setitem__(self, *args)


    def pop(self):
        """pop(CameraVector self) -> Camera"""
        return _fife.CameraVector_pop(self)


    def append(self, x):
        """append(CameraVector self, Camera x)"""
        return _fife.CameraVector_append(self, x)


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


    def size(self):
        """size(CameraVector self) -> std::vector< FIFE::Camera * >::size_type"""
        return _fife.CameraVector_size(self)


    def swap(self, v):
        """swap(CameraVector self, CameraVector v)"""
        return _fife.CameraVector_swap(self, v)


    def begin(self):
        """begin(CameraVector self) -> std::vector< FIFE::Camera * >::iterator"""
        return _fife.CameraVector_begin(self)


    def end(self):
        """end(CameraVector self) -> std::vector< FIFE::Camera * >::iterator"""
        return _fife.CameraVector_end(self)


    def rbegin(self):
        """rbegin(CameraVector self) -> std::vector< FIFE::Camera * >::reverse_iterator"""
        return _fife.CameraVector_rbegin(self)


    def rend(self):
        """rend(CameraVector self) -> std::vector< FIFE::Camera * >::reverse_iterator"""
        return _fife.CameraVector_rend(self)


    def clear(self):
        """clear(CameraVector self)"""
        return _fife.CameraVector_clear(self)


    def get_allocator(self):
        """get_allocator(CameraVector self) -> std::vector< FIFE::Camera * >::allocator_type"""
        return _fife.CameraVector_get_allocator(self)


    def pop_back(self):
        """pop_back(CameraVector self)"""
        return _fife.CameraVector_pop_back(self)


    def erase(self, *args):
        """
        erase(CameraVector self, std::vector< FIFE::Camera * >::iterator pos) -> std::vector< FIFE::Camera * >::iterator
        erase(CameraVector self, std::vector< FIFE::Camera * >::iterator first, std::vector< FIFE::Camera * >::iterator last) -> std::vector< FIFE::Camera * >::iterator
        """
        return _fife.CameraVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.FIFE::Camera)> self) -> CameraVector
        __init__(std::vector<(p.FIFE::Camera)> self, CameraVector arg2) -> CameraVector
        __init__(std::vector<(p.FIFE::Camera)> self, std::vector< FIFE::Camera * >::size_type size) -> CameraVector
        __init__(std::vector<(p.FIFE::Camera)> self, std::vector< FIFE::Camera * >::size_type size, Camera value) -> CameraVector
        """
        _fife.CameraVector_swiginit(self, _fife.new_CameraVector(*args))

    def push_back(self, x):
        """push_back(CameraVector self, Camera x)"""
        return _fife.CameraVector_push_back(self, x)


    def front(self):
        """front(CameraVector self) -> Camera"""
        return _fife.CameraVector_front(self)


    def back(self):
        """back(CameraVector self) -> Camera"""
        return _fife.CameraVector_back(self)


    def assign(self, n, x):
        """assign(CameraVector self, std::vector< FIFE::Camera * >::size_type n, Camera x)"""
        return _fife.CameraVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(CameraVector self, std::vector< FIFE::Camera * >::size_type new_size)
        resize(CameraVector self, std::vector< FIFE::Camera * >::size_type new_size, Camera x)
        """
        return _fife.CameraVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(CameraVector self, std::vector< FIFE::Camera * >::iterator pos, Camera x) -> std::vector< FIFE::Camera * >::iterator
        insert(CameraVector self, std::vector< FIFE::Camera * >::iterator pos, std::vector< FIFE::Camera * >::size_type n, Camera x)
        """
        return _fife.CameraVector_insert(self, *args)


    def reserve(self, n):
        """reserve(CameraVector self, std::vector< FIFE::Camera * >::size_type n)"""
        return _fife.CameraVector_reserve(self, n)


    def capacity(self):
        """capacity(CameraVector self) -> std::vector< FIFE::Camera * >::size_type"""
        return _fife.CameraVector_capacity(self)

    __swig_destroy__ = _fife.delete_CameraVector
CameraVector.iterator = new_instancemethod(_fife.CameraVector_iterator, None, CameraVector)
CameraVector.__nonzero__ = new_instancemethod(_fife.CameraVector___nonzero__, None, CameraVector)
CameraVector.__bool__ = new_instancemethod(_fife.CameraVector___bool__, None, CameraVector)
CameraVector.__len__ = new_instancemethod(_fife.CameraVector___len__, None, CameraVector)
CameraVector.__getslice__ = new_instancemethod(_fife.CameraVector___getslice__, None, CameraVector)
CameraVector.__setslice__ = new_instancemethod(_fife.CameraVector___setslice__, None, CameraVector)
CameraVector.__delslice__ = new_instancemethod(_fife.CameraVector___delslice__, None, CameraVector)
CameraVector.__delitem__ = new_instancemethod(_fife.CameraVector___delitem__, None, CameraVector)
CameraVector.__getitem__ = new_instancemethod(_fife.CameraVector___getitem__, None, CameraVector)
CameraVector.__setitem__ = new_instancemethod(_fife.CameraVector___setitem__, None, CameraVector)
CameraVector.pop = new_instancemethod(_fife.CameraVector_pop, None, CameraVector)
CameraVector.append = new_instancemethod(_fife.CameraVector_append, None, CameraVector)
CameraVector.empty = new_instancemethod(_fife.CameraVector_empty, None, CameraVector)
CameraVector.size = new_instancemethod(_fife.CameraVector_size, None, CameraVector)
CameraVector.swap = new_instancemethod(_fife.CameraVector_swap, None, CameraVector)
CameraVector.begin = new_instancemethod(_fife.CameraVector_begin, None, CameraVector)
CameraVector.end = new_instancemethod(_fife.CameraVector_end, None, CameraVector)
CameraVector.rbegin = new_instancemethod(_fife.CameraVector_rbegin, None, CameraVector)
CameraVector.rend = new_instancemethod(_fife.CameraVector_rend, None, CameraVector)
CameraVector.clear = new_instancemethod(_fife.CameraVector_clear, None, CameraVector)
CameraVector.get_allocator = new_instancemethod(_fife.CameraVector_get_allocator, None, CameraVector)
CameraVector.pop_back = new_instancemethod(_fife.CameraVector_pop_back, None, CameraVector)
CameraVector.erase = new_instancemethod(_fife.CameraVector_erase, None, CameraVector)
CameraVector.push_back = new_instancemethod(_fife.CameraVector_push_back, None, CameraVector)
CameraVector.front = new_instancemethod(_fife.CameraVector_front, None, CameraVector)
CameraVector.back = new_instancemethod(_fife.CameraVector_back, None, CameraVector)
CameraVector.assign = new_instancemethod(_fife.CameraVector_assign, None, CameraVector)
CameraVector.resize = new_instancemethod(_fife.CameraVector_resize, None, CameraVector)
CameraVector.insert = new_instancemethod(_fife.CameraVector_insert, None, CameraVector)
CameraVector.reserve = new_instancemethod(_fife.CameraVector_reserve, None, CameraVector)
CameraVector.capacity = new_instancemethod(_fife.CameraVector_capacity, None, CameraVector)
CameraVector_swigregister = _fife.CameraVector_swigregister
CameraVector_swigregister(CameraVector)

class MapChangeListener(object):
    """Proxy of C++ FIFE::MapChangeListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_MapChangeListener

    def onMapChanged(self, map, changedLayers):
        """onMapChanged(MapChangeListener self, Map map, LayerVector changedLayers)"""
        return _fife.MapChangeListener_onMapChanged(self, map, changedLayers)


    def onLayerCreate(self, map, layer):
        """onLayerCreate(MapChangeListener self, Map map, Layer layer)"""
        return _fife.MapChangeListener_onLayerCreate(self, map, layer)


    def onLayerDelete(self, map, layer):
        """onLayerDelete(MapChangeListener self, Map map, Layer layer)"""
        return _fife.MapChangeListener_onLayerDelete(self, map, layer)


    def __init__(self):
        """__init__(FIFE::MapChangeListener self) -> MapChangeListener"""
        if self.__class__ == MapChangeListener:
            _self = None
        else:
            _self = self
        _fife.MapChangeListener_swiginit(self, _fife.new_MapChangeListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_MapChangeListener(self)
        return weakref_proxy(self)
MapChangeListener.onMapChanged = new_instancemethod(_fife.MapChangeListener_onMapChanged, None, MapChangeListener)
MapChangeListener.onLayerCreate = new_instancemethod(_fife.MapChangeListener_onLayerCreate, None, MapChangeListener)
MapChangeListener.onLayerDelete = new_instancemethod(_fife.MapChangeListener_onLayerDelete, None, MapChangeListener)
MapChangeListener_swigregister = _fife.MapChangeListener_swigregister
MapChangeListener_swigregister(MapChangeListener)

class Map(FifeClass):
    """Proxy of C++ FIFE::Map class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, identifier, renderbackend, renderers, tp_master=None):
        """__init__(FIFE::Map self, std::string const & identifier, RenderBackend renderbackend, std::vector< FIFE::RendererBase *,std::allocator< FIFE::RendererBase * > > const & renderers, TimeProvider tp_master=None) -> Map"""
        _fife.Map_swiginit(self, _fife.new_Map(identifier, renderbackend, renderers, tp_master))
    __swig_destroy__ = _fife.delete_Map

    def getId(self):
        """getId(Map self) -> std::string const &"""
        return _fife.Map_getId(self)


    def setId(self, id):
        """setId(Map self, std::string const & id)"""
        return _fife.Map_setId(self, id)


    def createLayer(self, identifier, grid):
        """createLayer(Map self, std::string const & identifier, CellGrid grid) -> Layer"""
        return _fife.Map_createLayer(self, identifier, grid)


    def deleteLayer(self, index):
        """deleteLayer(Map self, Layer index)"""
        return _fife.Map_deleteLayer(self, index)


    def getLayers(self):
        """getLayers(Map self) -> LayerList"""
        return _fife.Map_getLayers(self)


    def getLayer(self, id):
        """getLayer(Map self, std::string const & id) -> Layer"""
        return _fife.Map_getLayer(self, id)


    def getLayerCount(self):
        """getLayerCount(Map self) -> uint32_t"""
        return _fife.Map_getLayerCount(self)


    def deleteLayers(self):
        """deleteLayers(Map self)"""
        return _fife.Map_deleteLayers(self)


    def getMinMaxCoordinates(self, min, max):
        """getMinMaxCoordinates(Map self, DoublePoint3D min, DoublePoint3D max)"""
        return _fife.Map_getMinMaxCoordinates(self, min, max)


    def setTimeMultiplier(self, multip):
        """setTimeMultiplier(Map self, float multip)"""
        return _fife.Map_setTimeMultiplier(self, multip)


    def getTimeMultiplier(self):
        """getTimeMultiplier(Map self) -> double"""
        return _fife.Map_getTimeMultiplier(self)


    def addChangeListener(self, listener):
        """addChangeListener(Map self, MapChangeListener listener)"""
        return _fife.Map_addChangeListener(self, listener)


    def removeChangeListener(self, listener):
        """removeChangeListener(Map self, MapChangeListener listener)"""
        return _fife.Map_removeChangeListener(self, listener)


    def isChanged(self):
        """isChanged(Map self) -> bool"""
        return _fife.Map_isChanged(self)


    def getChangedLayers(self):
        """getChangedLayers(Map self) -> LayerVector"""
        return _fife.Map_getChangedLayers(self)


    def addCamera(self, id, viewport):
        """addCamera(Map self, std::string const & id, Rect viewport) -> Camera"""
        return _fife.Map_addCamera(self, id, viewport)


    def removeCamera(self, id):
        """removeCamera(Map self, std::string const & id)"""
        return _fife.Map_removeCamera(self, id)


    def getCamera(self, id):
        """getCamera(Map self, std::string const & id) -> Camera"""
        return _fife.Map_getCamera(self, id)


    def getCameras(self):
        """getCameras(Map self) -> CameraVector"""
        return _fife.Map_getCameras(self)


    def setFilename(self, file):
        """setFilename(Map self, std::string const & file)"""
        return _fife.Map_setFilename(self, file)


    def getFilename(self):
        """getFilename(Map self) -> std::string const &"""
        return _fife.Map_getFilename(self)


    def initializeCellCaches(self):
        """initializeCellCaches(Map self)"""
        return _fife.Map_initializeCellCaches(self)


    def finalizeCellCaches(self):
        """finalizeCellCaches(Map self)"""
        return _fife.Map_finalizeCellCaches(self)


    def getTriggerController(self):
        """getTriggerController(Map self) -> TriggerController"""
        return _fife.Map_getTriggerController(self)

Map.getId = new_instancemethod(_fife.Map_getId, None, Map)
Map.setId = new_instancemethod(_fife.Map_setId, None, Map)
Map.createLayer = new_instancemethod(_fife.Map_createLayer, None, Map)
Map.deleteLayer = new_instancemethod(_fife.Map_deleteLayer, None, Map)
Map.getLayers = new_instancemethod(_fife.Map_getLayers, None, Map)
Map.getLayer = new_instancemethod(_fife.Map_getLayer, None, Map)
Map.getLayerCount = new_instancemethod(_fife.Map_getLayerCount, None, Map)
Map.deleteLayers = new_instancemethod(_fife.Map_deleteLayers, None, Map)
Map.getMinMaxCoordinates = new_instancemethod(_fife.Map_getMinMaxCoordinates, None, Map)
Map.setTimeMultiplier = new_instancemethod(_fife.Map_setTimeMultiplier, None, Map)
Map.getTimeMultiplier = new_instancemethod(_fife.Map_getTimeMultiplier, None, Map)
Map.addChangeListener = new_instancemethod(_fife.Map_addChangeListener, None, Map)
Map.removeChangeListener = new_instancemethod(_fife.Map_removeChangeListener, None, Map)
Map.isChanged = new_instancemethod(_fife.Map_isChanged, None, Map)
Map.getChangedLayers = new_instancemethod(_fife.Map_getChangedLayers, None, Map)
Map.addCamera = new_instancemethod(_fife.Map_addCamera, None, Map)
Map.removeCamera = new_instancemethod(_fife.Map_removeCamera, None, Map)
Map.getCamera = new_instancemethod(_fife.Map_getCamera, None, Map)
Map.getCameras = new_instancemethod(_fife.Map_getCameras, None, Map)
Map.setFilename = new_instancemethod(_fife.Map_setFilename, None, Map)
Map.getFilename = new_instancemethod(_fife.Map_getFilename, None, Map)
Map.initializeCellCaches = new_instancemethod(_fife.Map_initializeCellCaches, None, Map)
Map.finalizeCellCaches = new_instancemethod(_fife.Map_finalizeCellCaches, None, Map)
Map.getTriggerController = new_instancemethod(_fife.Map_getTriggerController, None, Map)
Map_swigregister = _fife.Map_swigregister
Map_swigregister(Map)

class RendererNode(object):
    """Proxy of C++ FIFE::RendererNode class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::RendererNode self, Instance attached_instance, Location relative_location, Layer relative_layer, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Location relative_location, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Layer relative_layer, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Location attached_location, Layer relative_layer, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Location attached_location, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Layer attached_layer, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Point attached_point) -> RendererNode
        __init__(FIFE::RendererNode self, RendererNode old) -> RendererNode
        """
        _fife.RendererNode_swiginit(self, _fife.new_RendererNode(*args))
    __swig_destroy__ = _fife.delete_RendererNode

    def setAttached(self, *args):
        """
        setAttached(RendererNode self, Instance attached_instance, Location relative_location, Point relative_point)
        setAttached(RendererNode self, Instance attached_instance, Location relative_location)
        setAttached(RendererNode self, Instance attached_instance, Point relative_point)
        setAttached(RendererNode self, Instance attached_instance)
        setAttached(RendererNode self, Location attached_location, Point relative_point)
        setAttached(RendererNode self, Location attached_location)
        setAttached(RendererNode self, Layer attached_layer)
        setAttached(RendererNode self, Point attached_point)
        """
        return _fife.RendererNode_setAttached(self, *args)


    def setRelative(self, *args):
        """
        setRelative(RendererNode self, Location relative_location)
        setRelative(RendererNode self, Location relative_location, Point relative_point)
        setRelative(RendererNode self, Point relative_point)
        """
        return _fife.RendererNode_setRelative(self, *args)


    def getAttachedInstance(self):
        """getAttachedInstance(RendererNode self) -> Instance"""
        return _fife.RendererNode_getAttachedInstance(self)


    def getAttachedLocation(self):
        """getAttachedLocation(RendererNode self) -> Location"""
        return _fife.RendererNode_getAttachedLocation(self)


    def getAttachedLayer(self):
        """getAttachedLayer(RendererNode self) -> Layer"""
        return _fife.RendererNode_getAttachedLayer(self)


    def getAttachedPoint(self):
        """getAttachedPoint(RendererNode self) -> Point"""
        return _fife.RendererNode_getAttachedPoint(self)


    def getOffsetLocation(self):
        """getOffsetLocation(RendererNode self) -> Location"""
        return _fife.RendererNode_getOffsetLocation(self)


    def getOffsetPoint(self):
        """getOffsetPoint(RendererNode self) -> Point"""
        return _fife.RendererNode_getOffsetPoint(self)


    def getInstance(self):
        """getInstance(RendererNode self) -> Instance"""
        return _fife.RendererNode_getInstance(self)


    def getLocation(self):
        """getLocation(RendererNode self) -> Location"""
        return _fife.RendererNode_getLocation(self)


    def getLocationRef(self):
        """getLocationRef(RendererNode self) -> Location"""
        return _fife.RendererNode_getLocationRef(self)


    def getLayer(self):
        """getLayer(RendererNode self) -> Layer"""
        return _fife.RendererNode_getLayer(self)


    def getPoint(self):
        """getPoint(RendererNode self) -> Point"""
        return _fife.RendererNode_getPoint(self)


    def getPointRef(self):
        """getPointRef(RendererNode self) -> Point"""
        return _fife.RendererNode_getPointRef(self)


    def getCalculatedPoint(self, cam, layer, zoomed):
        """getCalculatedPoint(RendererNode self, Camera cam, Layer layer, bool const zoomed) -> Point"""
        return _fife.RendererNode_getCalculatedPoint(self, cam, layer, zoomed)

RendererNode.setAttached = new_instancemethod(_fife.RendererNode_setAttached, None, RendererNode)
RendererNode.setRelative = new_instancemethod(_fife.RendererNode_setRelative, None, RendererNode)
RendererNode.getAttachedInstance = new_instancemethod(_fife.RendererNode_getAttachedInstance, None, RendererNode)
RendererNode.getAttachedLocation = new_instancemethod(_fife.RendererNode_getAttachedLocation, None, RendererNode)
RendererNode.getAttachedLayer = new_instancemethod(_fife.RendererNode_getAttachedLayer, None, RendererNode)
RendererNode.getAttachedPoint = new_instancemethod(_fife.RendererNode_getAttachedPoint, None, RendererNode)
RendererNode.getOffsetLocation = new_instancemethod(_fife.RendererNode_getOffsetLocation, None, RendererNode)
RendererNode.getOffsetPoint = new_instancemethod(_fife.RendererNode_getOffsetPoint, None, RendererNode)
RendererNode.getInstance = new_instancemethod(_fife.RendererNode_getInstance, None, RendererNode)
RendererNode.getLocation = new_instancemethod(_fife.RendererNode_getLocation, None, RendererNode)
RendererNode.getLocationRef = new_instancemethod(_fife.RendererNode_getLocationRef, None, RendererNode)
RendererNode.getLayer = new_instancemethod(_fife.RendererNode_getLayer, None, RendererNode)
RendererNode.getPoint = new_instancemethod(_fife.RendererNode_getPoint, None, RendererNode)
RendererNode.getPointRef = new_instancemethod(_fife.RendererNode_getPointRef, None, RendererNode)
RendererNode.getCalculatedPoint = new_instancemethod(_fife.RendererNode_getCalculatedPoint, None, RendererNode)
RendererNode_swigregister = _fife.RendererNode_swigregister
RendererNode_swigregister(RendererNode)

CELL_TRIGGER_ENTER = _fife.CELL_TRIGGER_ENTER
CELL_TRIGGER_EXIT = _fife.CELL_TRIGGER_EXIT
CELL_TRIGGER_BLOCKING_CHANGE = _fife.CELL_TRIGGER_BLOCKING_CHANGE
INSTANCE_TRIGGER_LOCATION = _fife.INSTANCE_TRIGGER_LOCATION
INSTANCE_TRIGGER_ROTATION = _fife.INSTANCE_TRIGGER_ROTATION
INSTANCE_TRIGGER_SPEED = _fife.INSTANCE_TRIGGER_SPEED
INSTANCE_TRIGGER_ACTION = _fife.INSTANCE_TRIGGER_ACTION
INSTANCE_TRIGGER_TIME_MULTIPLIER = _fife.INSTANCE_TRIGGER_TIME_MULTIPLIER
INSTANCE_TRIGGER_SAYTEXT = _fife.INSTANCE_TRIGGER_SAYTEXT
INSTANCE_TRIGGER_BLOCK = _fife.INSTANCE_TRIGGER_BLOCK
INSTANCE_TRIGGER_CELL = _fife.INSTANCE_TRIGGER_CELL
INSTANCE_TRIGGER_TRANSPARENCY = _fife.INSTANCE_TRIGGER_TRANSPARENCY
INSTANCE_TRIGGER_VISIBLE = _fife.INSTANCE_TRIGGER_VISIBLE
INSTANCE_TRIGGER_STACKPOS = _fife.INSTANCE_TRIGGER_STACKPOS
INSTANCE_TRIGGER_VISUAL = _fife.INSTANCE_TRIGGER_VISUAL
INSTANCE_TRIGGER_DELETE = _fife.INSTANCE_TRIGGER_DELETE
class ITriggerListener(object):
    """Proxy of C++ FIFE::ITriggerListener class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ITriggerListener

    def onTriggered(self):
        """onTriggered(ITriggerListener self)"""
        return _fife.ITriggerListener_onTriggered(self)


    def __init__(self):
        """__init__(FIFE::ITriggerListener self) -> ITriggerListener"""
        if self.__class__ == ITriggerListener:
            _self = None
        else:
            _self = self
        _fife.ITriggerListener_swiginit(self, _fife.new_ITriggerListener(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ITriggerListener(self)
        return weakref_proxy(self)
ITriggerListener.onTriggered = new_instancemethod(_fife.ITriggerListener_onTriggered, None, ITriggerListener)
ITriggerListener_swigregister = _fife.ITriggerListener_swigregister
ITriggerListener_swigregister(ITriggerListener)

class Trigger(FifeClass):
    """Proxy of C++ FIFE::Trigger class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Trigger

    def addTriggerListener(self, listener):
        """addTriggerListener(Trigger self, ITriggerListener listener)"""
        return _fife.Trigger_addTriggerListener(self, listener)


    def removeTriggerListener(self, listener):
        """removeTriggerListener(Trigger self, ITriggerListener listener)"""
        return _fife.Trigger_removeTriggerListener(self, listener)


    def reset(self):
        """reset(Trigger self)"""
        return _fife.Trigger_reset(self)


    def getName(self):
        """getName(Trigger self) -> std::string const &"""
        return _fife.Trigger_getName(self)


    def isTriggered(self):
        """isTriggered(Trigger self) -> bool"""
        return _fife.Trigger_isTriggered(self)


    def setTriggered(self):
        """setTriggered(Trigger self)"""
        return _fife.Trigger_setTriggered(self)


    def addTriggerCondition(self, type):
        """addTriggerCondition(Trigger self, FIFE::TriggerCondition type)"""
        return _fife.Trigger_addTriggerCondition(self, type)


    def getTriggerConditions(self):
        """getTriggerConditions(Trigger self) -> TriggerConditionVector"""
        return _fife.Trigger_getTriggerConditions(self)


    def removeTriggerCondition(self, type):
        """removeTriggerCondition(Trigger self, FIFE::TriggerCondition type)"""
        return _fife.Trigger_removeTriggerCondition(self, type)


    def enableForInstance(self, instance):
        """enableForInstance(Trigger self, Instance instance)"""
        return _fife.Trigger_enableForInstance(self, instance)


    def getEnabledInstances(self):
        """getEnabledInstances(Trigger self) -> InstanceVector"""
        return _fife.Trigger_getEnabledInstances(self)


    def disableForInstance(self, instance):
        """disableForInstance(Trigger self, Instance instance)"""
        return _fife.Trigger_disableForInstance(self, instance)


    def enableForAllInstances(self):
        """enableForAllInstances(Trigger self)"""
        return _fife.Trigger_enableForAllInstances(self)


    def isEnabledForAllInstances(self):
        """isEnabledForAllInstances(Trigger self) -> bool"""
        return _fife.Trigger_isEnabledForAllInstances(self)


    def disableForAllInstances(self):
        """disableForAllInstances(Trigger self)"""
        return _fife.Trigger_disableForAllInstances(self)


    def assign(self, *args):
        """
        assign(Trigger self, Layer layer, Point3D pt)
        assign(Trigger self, Cell cell)
        """
        return _fife.Trigger_assign(self, *args)


    def remove(self, *args):
        """
        remove(Trigger self, Layer layer, Point3D pt)
        remove(Trigger self, Cell cell)
        """
        return _fife.Trigger_remove(self, *args)


    def attach(self, instance):
        """attach(Trigger self, Instance instance)"""
        return _fife.Trigger_attach(self, instance)


    def detach(self):
        """detach(Trigger self)"""
        return _fife.Trigger_detach(self)


    def getAttached(self):
        """getAttached(Trigger self) -> Instance"""
        return _fife.Trigger_getAttached(self)


    def moveTo(self, newPos, oldPos):
        """moveTo(Trigger self, Point3D newPos, Point3D oldPos)"""
        return _fife.Trigger_moveTo(self, newPos, oldPos)


    def getAssignedCells(self):
        """getAssignedCells(Trigger self) -> CellVector"""
        return _fife.Trigger_getAssignedCells(self)

Trigger.addTriggerListener = new_instancemethod(_fife.Trigger_addTriggerListener, None, Trigger)
Trigger.removeTriggerListener = new_instancemethod(_fife.Trigger_removeTriggerListener, None, Trigger)
Trigger.reset = new_instancemethod(_fife.Trigger_reset, None, Trigger)
Trigger.getName = new_instancemethod(_fife.Trigger_getName, None, Trigger)
Trigger.isTriggered = new_instancemethod(_fife.Trigger_isTriggered, None, Trigger)
Trigger.setTriggered = new_instancemethod(_fife.Trigger_setTriggered, None, Trigger)
Trigger.addTriggerCondition = new_instancemethod(_fife.Trigger_addTriggerCondition, None, Trigger)
Trigger.getTriggerConditions = new_instancemethod(_fife.Trigger_getTriggerConditions, None, Trigger)
Trigger.removeTriggerCondition = new_instancemethod(_fife.Trigger_removeTriggerCondition, None, Trigger)
Trigger.enableForInstance = new_instancemethod(_fife.Trigger_enableForInstance, None, Trigger)
Trigger.getEnabledInstances = new_instancemethod(_fife.Trigger_getEnabledInstances, None, Trigger)
Trigger.disableForInstance = new_instancemethod(_fife.Trigger_disableForInstance, None, Trigger)
Trigger.enableForAllInstances = new_instancemethod(_fife.Trigger_enableForAllInstances, None, Trigger)
Trigger.isEnabledForAllInstances = new_instancemethod(_fife.Trigger_isEnabledForAllInstances, None, Trigger)
Trigger.disableForAllInstances = new_instancemethod(_fife.Trigger_disableForAllInstances, None, Trigger)
Trigger.assign = new_instancemethod(_fife.Trigger_assign, None, Trigger)
Trigger.remove = new_instancemethod(_fife.Trigger_remove, None, Trigger)
Trigger.attach = new_instancemethod(_fife.Trigger_attach, None, Trigger)
Trigger.detach = new_instancemethod(_fife.Trigger_detach, None, Trigger)
Trigger.getAttached = new_instancemethod(_fife.Trigger_getAttached, None, Trigger)
Trigger.moveTo = new_instancemethod(_fife.Trigger_moveTo, None, Trigger)
Trigger.getAssignedCells = new_instancemethod(_fife.Trigger_getAssignedCells, None, Trigger)
Trigger_swigregister = _fife.Trigger_swigregister
Trigger_swigregister(Trigger)

class TriggerController(FifeClass):
    """Proxy of C++ FIFE::TriggerController class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_TriggerController

    def createTrigger(self, triggerName):
        """createTrigger(TriggerController self, std::string const & triggerName) -> Trigger"""
        return _fife.TriggerController_createTrigger(self, triggerName)


    def createTriggerOnCoordinate(self, triggerName, layer, pt):
        """createTriggerOnCoordinate(TriggerController self, std::string const & triggerName, Layer layer, Point3D pt) -> Trigger"""
        return _fife.TriggerController_createTriggerOnCoordinate(self, triggerName, layer, pt)


    def createTriggerOnCoordinates(self, triggerName, layer, coords):
        """createTriggerOnCoordinates(TriggerController self, std::string const & triggerName, Layer layer, std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > > const & coords) -> Trigger"""
        return _fife.TriggerController_createTriggerOnCoordinates(self, triggerName, layer, coords)


    def createTriggerOnRect(self, triggerName, layer, rec):
        """createTriggerOnRect(TriggerController self, std::string const & triggerName, Layer layer, Rect rec) -> Trigger"""
        return _fife.TriggerController_createTriggerOnRect(self, triggerName, layer, rec)


    def createTriggerOnLocation(self, triggerName, loc):
        """createTriggerOnLocation(TriggerController self, std::string const & triggerName, Location loc) -> Trigger"""
        return _fife.TriggerController_createTriggerOnLocation(self, triggerName, loc)


    def createTriggerOnLocations(self, triggerName, locs):
        """createTriggerOnLocations(TriggerController self, std::string const & triggerName, LocationVector locs) -> Trigger"""
        return _fife.TriggerController_createTriggerOnLocations(self, triggerName, locs)


    def createTriggerOnCell(self, triggerName, cell):
        """createTriggerOnCell(TriggerController self, std::string const & triggerName, Cell cell) -> Trigger"""
        return _fife.TriggerController_createTriggerOnCell(self, triggerName, cell)


    def createTriggerOnCells(self, triggerName, cells):
        """createTriggerOnCells(TriggerController self, std::string const & triggerName, CellVector cells) -> Trigger"""
        return _fife.TriggerController_createTriggerOnCells(self, triggerName, cells)


    def createTriggerOnInstance(self, triggerName, instance):
        """createTriggerOnInstance(TriggerController self, std::string const & triggerName, Instance instance) -> Trigger"""
        return _fife.TriggerController_createTriggerOnInstance(self, triggerName, instance)


    def getTrigger(self, triggerName):
        """getTrigger(TriggerController self, std::string const & triggerName) -> Trigger"""
        return _fife.TriggerController_getTrigger(self, triggerName)


    def deleteTrigger(self, triggerName):
        """deleteTrigger(TriggerController self, std::string const & triggerName)"""
        return _fife.TriggerController_deleteTrigger(self, triggerName)


    def removeTriggerFromCoordinate(self, triggerName, layer, pt):
        """removeTriggerFromCoordinate(TriggerController self, std::string const & triggerName, Layer layer, Point3D pt)"""
        return _fife.TriggerController_removeTriggerFromCoordinate(self, triggerName, layer, pt)


    def removeTriggerFromCoordinates(self, triggerName, layer, coords):
        """removeTriggerFromCoordinates(TriggerController self, std::string const & triggerName, Layer layer, std::vector< FIFE::ModelCoordinate,std::allocator< FIFE::ModelCoordinate > > const & coords)"""
        return _fife.TriggerController_removeTriggerFromCoordinates(self, triggerName, layer, coords)


    def removeTriggerFromRect(self, triggerName, layer, rec):
        """removeTriggerFromRect(TriggerController self, std::string const & triggerName, Layer layer, Rect rec)"""
        return _fife.TriggerController_removeTriggerFromRect(self, triggerName, layer, rec)


    def removeTriggerFromLocation(self, triggerName, loc):
        """removeTriggerFromLocation(TriggerController self, std::string const & triggerName, Location loc)"""
        return _fife.TriggerController_removeTriggerFromLocation(self, triggerName, loc)


    def removeTriggerFromLocations(self, triggerName, locs):
        """removeTriggerFromLocations(TriggerController self, std::string const & triggerName, LocationVector locs)"""
        return _fife.TriggerController_removeTriggerFromLocations(self, triggerName, locs)


    def removeTriggerFromCell(self, triggerName, cell):
        """removeTriggerFromCell(TriggerController self, std::string const & triggerName, Cell cell)"""
        return _fife.TriggerController_removeTriggerFromCell(self, triggerName, cell)


    def removeTriggerFromCells(self, triggerName, cells):
        """removeTriggerFromCells(TriggerController self, std::string const & triggerName, CellVector cells)"""
        return _fife.TriggerController_removeTriggerFromCells(self, triggerName, cells)


    def removeTriggerFromInstance(self, triggerName, instance):
        """removeTriggerFromInstance(TriggerController self, std::string const & triggerName, Instance instance)"""
        return _fife.TriggerController_removeTriggerFromInstance(self, triggerName, instance)


    def getAllTriggers(self):
        """getAllTriggers(TriggerController self) -> TriggerVector"""
        return _fife.TriggerController_getAllTriggers(self)


    def getAllTriggerNames(self):
        """getAllTriggerNames(TriggerController self) -> StringVector"""
        return _fife.TriggerController_getAllTriggerNames(self)

TriggerController.createTrigger = new_instancemethod(_fife.TriggerController_createTrigger, None, TriggerController)
TriggerController.createTriggerOnCoordinate = new_instancemethod(_fife.TriggerController_createTriggerOnCoordinate, None, TriggerController)
TriggerController.createTriggerOnCoordinates = new_instancemethod(_fife.TriggerController_createTriggerOnCoordinates, None, TriggerController)
TriggerController.createTriggerOnRect = new_instancemethod(_fife.TriggerController_createTriggerOnRect, None, TriggerController)
TriggerController.createTriggerOnLocation = new_instancemethod(_fife.TriggerController_createTriggerOnLocation, None, TriggerController)
TriggerController.createTriggerOnLocations = new_instancemethod(_fife.TriggerController_createTriggerOnLocations, None, TriggerController)
TriggerController.createTriggerOnCell = new_instancemethod(_fife.TriggerController_createTriggerOnCell, None, TriggerController)
TriggerController.createTriggerOnCells = new_instancemethod(_fife.TriggerController_createTriggerOnCells, None, TriggerController)
TriggerController.createTriggerOnInstance = new_instancemethod(_fife.TriggerController_createTriggerOnInstance, None, TriggerController)
TriggerController.getTrigger = new_instancemethod(_fife.TriggerController_getTrigger, None, TriggerController)
TriggerController.deleteTrigger = new_instancemethod(_fife.TriggerController_deleteTrigger, None, TriggerController)
TriggerController.removeTriggerFromCoordinate = new_instancemethod(_fife.TriggerController_removeTriggerFromCoordinate, None, TriggerController)
TriggerController.removeTriggerFromCoordinates = new_instancemethod(_fife.TriggerController_removeTriggerFromCoordinates, None, TriggerController)
TriggerController.removeTriggerFromRect = new_instancemethod(_fife.TriggerController_removeTriggerFromRect, None, TriggerController)
TriggerController.removeTriggerFromLocation = new_instancemethod(_fife.TriggerController_removeTriggerFromLocation, None, TriggerController)
TriggerController.removeTriggerFromLocations = new_instancemethod(_fife.TriggerController_removeTriggerFromLocations, None, TriggerController)
TriggerController.removeTriggerFromCell = new_instancemethod(_fife.TriggerController_removeTriggerFromCell, None, TriggerController)
TriggerController.removeTriggerFromCells = new_instancemethod(_fife.TriggerController_removeTriggerFromCells, None, TriggerController)
TriggerController.removeTriggerFromInstance = new_instancemethod(_fife.TriggerController_removeTriggerFromInstance, None, TriggerController)
TriggerController.getAllTriggers = new_instancemethod(_fife.TriggerController_getAllTriggers, None, TriggerController)
TriggerController.getAllTriggerNames = new_instancemethod(_fife.TriggerController_getAllTriggerNames, None, TriggerController)
TriggerController_swigregister = _fife.TriggerController_swigregister
TriggerController_swigregister(TriggerController)

class TriggerConditionVector(object):
    """Proxy of C++ std::vector<(FIFE::TriggerCondition)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(TriggerConditionVector self) -> SwigPyIterator"""
        return _fife.TriggerConditionVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(TriggerConditionVector self) -> bool"""
        return _fife.TriggerConditionVector___nonzero__(self)


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


    def __len__(self):
        """__len__(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::size_type"""
        return _fife.TriggerConditionVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::difference_type i, std::vector< enum FIFE::TriggerCondition >::difference_type j) -> TriggerConditionVector"""
        return _fife.TriggerConditionVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::difference_type i, std::vector< enum FIFE::TriggerCondition >::difference_type j)
        __setslice__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::difference_type i, std::vector< enum FIFE::TriggerCondition >::difference_type j, TriggerConditionVector v)
        """
        return _fife.TriggerConditionVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::difference_type i, std::vector< enum FIFE::TriggerCondition >::difference_type j)"""
        return _fife.TriggerConditionVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::difference_type i)
        __delitem__(TriggerConditionVector self, PySliceObject * slice)
        """
        return _fife.TriggerConditionVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(TriggerConditionVector self, PySliceObject * slice) -> TriggerConditionVector
        __getitem__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::difference_type i) -> std::vector< enum FIFE::TriggerCondition >::value_type const &
        """
        return _fife.TriggerConditionVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(TriggerConditionVector self, PySliceObject * slice, TriggerConditionVector v)
        __setitem__(TriggerConditionVector self, PySliceObject * slice)
        __setitem__(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::difference_type i, std::vector< enum FIFE::TriggerCondition >::value_type const & x)
        """
        return _fife.TriggerConditionVector___setitem__(self, *args)


    def pop(self):
        """pop(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::value_type"""
        return _fife.TriggerConditionVector_pop(self)


    def append(self, x):
        """append(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::value_type const & x)"""
        return _fife.TriggerConditionVector_append(self, x)


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


    def size(self):
        """size(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::size_type"""
        return _fife.TriggerConditionVector_size(self)


    def swap(self, v):
        """swap(TriggerConditionVector self, TriggerConditionVector v)"""
        return _fife.TriggerConditionVector_swap(self, v)


    def begin(self):
        """begin(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::iterator"""
        return _fife.TriggerConditionVector_begin(self)


    def end(self):
        """end(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::iterator"""
        return _fife.TriggerConditionVector_end(self)


    def rbegin(self):
        """rbegin(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::reverse_iterator"""
        return _fife.TriggerConditionVector_rbegin(self)


    def rend(self):
        """rend(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::reverse_iterator"""
        return _fife.TriggerConditionVector_rend(self)


    def clear(self):
        """clear(TriggerConditionVector self)"""
        return _fife.TriggerConditionVector_clear(self)


    def get_allocator(self):
        """get_allocator(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::allocator_type"""
        return _fife.TriggerConditionVector_get_allocator(self)


    def pop_back(self):
        """pop_back(TriggerConditionVector self)"""
        return _fife.TriggerConditionVector_pop_back(self)


    def erase(self, *args):
        """
        erase(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::iterator pos) -> std::vector< enum FIFE::TriggerCondition >::iterator
        erase(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::iterator first, std::vector< enum FIFE::TriggerCondition >::iterator last) -> std::vector< enum FIFE::TriggerCondition >::iterator
        """
        return _fife.TriggerConditionVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(FIFE::TriggerCondition)> self) -> TriggerConditionVector
        __init__(std::vector<(FIFE::TriggerCondition)> self, TriggerConditionVector arg2) -> TriggerConditionVector
        __init__(std::vector<(FIFE::TriggerCondition)> self, std::vector< enum FIFE::TriggerCondition >::size_type size) -> TriggerConditionVector
        __init__(std::vector<(FIFE::TriggerCondition)> self, std::vector< enum FIFE::TriggerCondition >::size_type size, std::vector< enum FIFE::TriggerCondition >::value_type const & value) -> TriggerConditionVector
        """
        _fife.TriggerConditionVector_swiginit(self, _fife.new_TriggerConditionVector(*args))

    def push_back(self, x):
        """push_back(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::value_type const & x)"""
        return _fife.TriggerConditionVector_push_back(self, x)


    def front(self):
        """front(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::value_type const &"""
        return _fife.TriggerConditionVector_front(self)


    def back(self):
        """back(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::value_type const &"""
        return _fife.TriggerConditionVector_back(self)


    def assign(self, n, x):
        """assign(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::size_type n, std::vector< enum FIFE::TriggerCondition >::value_type const & x)"""
        return _fife.TriggerConditionVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::size_type new_size)
        resize(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::size_type new_size, std::vector< enum FIFE::TriggerCondition >::value_type const & x)
        """
        return _fife.TriggerConditionVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::iterator pos, std::vector< enum FIFE::TriggerCondition >::value_type const & x) -> std::vector< enum FIFE::TriggerCondition >::iterator
        insert(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::iterator pos, std::vector< enum FIFE::TriggerCondition >::size_type n, std::vector< enum FIFE::TriggerCondition >::value_type const & x)
        """
        return _fife.TriggerConditionVector_insert(self, *args)


    def reserve(self, n):
        """reserve(TriggerConditionVector self, std::vector< enum FIFE::TriggerCondition >::size_type n)"""
        return _fife.TriggerConditionVector_reserve(self, n)


    def capacity(self):
        """capacity(TriggerConditionVector self) -> std::vector< enum FIFE::TriggerCondition >::size_type"""
        return _fife.TriggerConditionVector_capacity(self)

    __swig_destroy__ = _fife.delete_TriggerConditionVector
TriggerConditionVector.iterator = new_instancemethod(_fife.TriggerConditionVector_iterator, None, TriggerConditionVector)
TriggerConditionVector.__nonzero__ = new_instancemethod(_fife.TriggerConditionVector___nonzero__, None, TriggerConditionVector)
TriggerConditionVector.__bool__ = new_instancemethod(_fife.TriggerConditionVector___bool__, None, TriggerConditionVector)
TriggerConditionVector.__len__ = new_instancemethod(_fife.TriggerConditionVector___len__, None, TriggerConditionVector)
TriggerConditionVector.__getslice__ = new_instancemethod(_fife.TriggerConditionVector___getslice__, None, TriggerConditionVector)
TriggerConditionVector.__setslice__ = new_instancemethod(_fife.TriggerConditionVector___setslice__, None, TriggerConditionVector)
TriggerConditionVector.__delslice__ = new_instancemethod(_fife.TriggerConditionVector___delslice__, None, TriggerConditionVector)
TriggerConditionVector.__delitem__ = new_instancemethod(_fife.TriggerConditionVector___delitem__, None, TriggerConditionVector)
TriggerConditionVector.__getitem__ = new_instancemethod(_fife.TriggerConditionVector___getitem__, None, TriggerConditionVector)
TriggerConditionVector.__setitem__ = new_instancemethod(_fife.TriggerConditionVector___setitem__, None, TriggerConditionVector)
TriggerConditionVector.pop = new_instancemethod(_fife.TriggerConditionVector_pop, None, TriggerConditionVector)
TriggerConditionVector.append = new_instancemethod(_fife.TriggerConditionVector_append, None, TriggerConditionVector)
TriggerConditionVector.empty = new_instancemethod(_fife.TriggerConditionVector_empty, None, TriggerConditionVector)
TriggerConditionVector.size = new_instancemethod(_fife.TriggerConditionVector_size, None, TriggerConditionVector)
TriggerConditionVector.swap = new_instancemethod(_fife.TriggerConditionVector_swap, None, TriggerConditionVector)
TriggerConditionVector.begin = new_instancemethod(_fife.TriggerConditionVector_begin, None, TriggerConditionVector)
TriggerConditionVector.end = new_instancemethod(_fife.TriggerConditionVector_end, None, TriggerConditionVector)
TriggerConditionVector.rbegin = new_instancemethod(_fife.TriggerConditionVector_rbegin, None, TriggerConditionVector)
TriggerConditionVector.rend = new_instancemethod(_fife.TriggerConditionVector_rend, None, TriggerConditionVector)
TriggerConditionVector.clear = new_instancemethod(_fife.TriggerConditionVector_clear, None, TriggerConditionVector)
TriggerConditionVector.get_allocator = new_instancemethod(_fife.TriggerConditionVector_get_allocator, None, TriggerConditionVector)
TriggerConditionVector.pop_back = new_instancemethod(_fife.TriggerConditionVector_pop_back, None, TriggerConditionVector)
TriggerConditionVector.erase = new_instancemethod(_fife.TriggerConditionVector_erase, None, TriggerConditionVector)
TriggerConditionVector.push_back = new_instancemethod(_fife.TriggerConditionVector_push_back, None, TriggerConditionVector)
TriggerConditionVector.front = new_instancemethod(_fife.TriggerConditionVector_front, None, TriggerConditionVector)
TriggerConditionVector.back = new_instancemethod(_fife.TriggerConditionVector_back, None, TriggerConditionVector)
TriggerConditionVector.assign = new_instancemethod(_fife.TriggerConditionVector_assign, None, TriggerConditionVector)
TriggerConditionVector.resize = new_instancemethod(_fife.TriggerConditionVector_resize, None, TriggerConditionVector)
TriggerConditionVector.insert = new_instancemethod(_fife.TriggerConditionVector_insert, None, TriggerConditionVector)
TriggerConditionVector.reserve = new_instancemethod(_fife.TriggerConditionVector_reserve, None, TriggerConditionVector)
TriggerConditionVector.capacity = new_instancemethod(_fife.TriggerConditionVector_capacity, None, TriggerConditionVector)
TriggerConditionVector_swigregister = _fife.TriggerConditionVector_swigregister
TriggerConditionVector_swigregister(TriggerConditionVector)

class TriggerVector(object):
    """Proxy of C++ std::vector<(p.FIFE::Trigger)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(TriggerVector self) -> SwigPyIterator"""
        return _fife.TriggerVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(TriggerVector self) -> bool"""
        return _fife.TriggerVector___nonzero__(self)


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


    def __len__(self):
        """__len__(TriggerVector self) -> std::vector< FIFE::Trigger * >::size_type"""
        return _fife.TriggerVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(TriggerVector self, std::vector< FIFE::Trigger * >::difference_type i, std::vector< FIFE::Trigger * >::difference_type j) -> TriggerVector"""
        return _fife.TriggerVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(TriggerVector self, std::vector< FIFE::Trigger * >::difference_type i, std::vector< FIFE::Trigger * >::difference_type j)
        __setslice__(TriggerVector self, std::vector< FIFE::Trigger * >::difference_type i, std::vector< FIFE::Trigger * >::difference_type j, TriggerVector v)
        """
        return _fife.TriggerVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(TriggerVector self, std::vector< FIFE::Trigger * >::difference_type i, std::vector< FIFE::Trigger * >::difference_type j)"""
        return _fife.TriggerVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(TriggerVector self, std::vector< FIFE::Trigger * >::difference_type i)
        __delitem__(TriggerVector self, PySliceObject * slice)
        """
        return _fife.TriggerVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(TriggerVector self, PySliceObject * slice) -> TriggerVector
        __getitem__(TriggerVector self, std::vector< FIFE::Trigger * >::difference_type i) -> Trigger
        """
        return _fife.TriggerVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(TriggerVector self, PySliceObject * slice, TriggerVector v)
        __setitem__(TriggerVector self, PySliceObject * slice)
        __setitem__(TriggerVector self, std::vector< FIFE::Trigger * >::difference_type i, Trigger x)
        """
        return _fife.TriggerVector___setitem__(self, *args)


    def pop(self):
        """pop(TriggerVector self) -> Trigger"""
        return _fife.TriggerVector_pop(self)


    def append(self, x):
        """append(TriggerVector self, Trigger x)"""
        return _fife.TriggerVector_append(self, x)


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


    def size(self):
        """size(TriggerVector self) -> std::vector< FIFE::Trigger * >::size_type"""
        return _fife.TriggerVector_size(self)


    def swap(self, v):
        """swap(TriggerVector self, TriggerVector v)"""
        return _fife.TriggerVector_swap(self, v)


    def begin(self):
        """begin(TriggerVector self) -> std::vector< FIFE::Trigger * >::iterator"""
        return _fife.TriggerVector_begin(self)


    def end(self):
        """end(TriggerVector self) -> std::vector< FIFE::Trigger * >::iterator"""
        return _fife.TriggerVector_end(self)


    def rbegin(self):
        """rbegin(TriggerVector self) -> std::vector< FIFE::Trigger * >::reverse_iterator"""
        return _fife.TriggerVector_rbegin(self)


    def rend(self):
        """rend(TriggerVector self) -> std::vector< FIFE::Trigger * >::reverse_iterator"""
        return _fife.TriggerVector_rend(self)


    def clear(self):
        """clear(TriggerVector self)"""
        return _fife.TriggerVector_clear(self)


    def get_allocator(self):
        """get_allocator(TriggerVector self) -> std::vector< FIFE::Trigger * >::allocator_type"""
        return _fife.TriggerVector_get_allocator(self)


    def pop_back(self):
        """pop_back(TriggerVector self)"""
        return _fife.TriggerVector_pop_back(self)


    def erase(self, *args):
        """
        erase(TriggerVector self, std::vector< FIFE::Trigger * >::iterator pos) -> std::vector< FIFE::Trigger * >::iterator
        erase(TriggerVector self, std::vector< FIFE::Trigger * >::iterator first, std::vector< FIFE::Trigger * >::iterator last) -> std::vector< FIFE::Trigger * >::iterator
        """
        return _fife.TriggerVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.FIFE::Trigger)> self) -> TriggerVector
        __init__(std::vector<(p.FIFE::Trigger)> self, TriggerVector arg2) -> TriggerVector
        __init__(std::vector<(p.FIFE::Trigger)> self, std::vector< FIFE::Trigger * >::size_type size) -> TriggerVector
        __init__(std::vector<(p.FIFE::Trigger)> self, std::vector< FIFE::Trigger * >::size_type size, Trigger value) -> TriggerVector
        """
        _fife.TriggerVector_swiginit(self, _fife.new_TriggerVector(*args))

    def push_back(self, x):
        """push_back(TriggerVector self, Trigger x)"""
        return _fife.TriggerVector_push_back(self, x)


    def front(self):
        """front(TriggerVector self) -> Trigger"""
        return _fife.TriggerVector_front(self)


    def back(self):
        """back(TriggerVector self) -> Trigger"""
        return _fife.TriggerVector_back(self)


    def assign(self, n, x):
        """assign(TriggerVector self, std::vector< FIFE::Trigger * >::size_type n, Trigger x)"""
        return _fife.TriggerVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(TriggerVector self, std::vector< FIFE::Trigger * >::size_type new_size)
        resize(TriggerVector self, std::vector< FIFE::Trigger * >::size_type new_size, Trigger x)
        """
        return _fife.TriggerVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(TriggerVector self, std::vector< FIFE::Trigger * >::iterator pos, Trigger x) -> std::vector< FIFE::Trigger * >::iterator
        insert(TriggerVector self, std::vector< FIFE::Trigger * >::iterator pos, std::vector< FIFE::Trigger * >::size_type n, Trigger x)
        """
        return _fife.TriggerVector_insert(self, *args)


    def reserve(self, n):
        """reserve(TriggerVector self, std::vector< FIFE::Trigger * >::size_type n)"""
        return _fife.TriggerVector_reserve(self, n)


    def capacity(self):
        """capacity(TriggerVector self) -> std::vector< FIFE::Trigger * >::size_type"""
        return _fife.TriggerVector_capacity(self)

    __swig_destroy__ = _fife.delete_TriggerVector
TriggerVector.iterator = new_instancemethod(_fife.TriggerVector_iterator, None, TriggerVector)
TriggerVector.__nonzero__ = new_instancemethod(_fife.TriggerVector___nonzero__, None, TriggerVector)
TriggerVector.__bool__ = new_instancemethod(_fife.TriggerVector___bool__, None, TriggerVector)
TriggerVector.__len__ = new_instancemethod(_fife.TriggerVector___len__, None, TriggerVector)
TriggerVector.__getslice__ = new_instancemethod(_fife.TriggerVector___getslice__, None, TriggerVector)
TriggerVector.__setslice__ = new_instancemethod(_fife.TriggerVector___setslice__, None, TriggerVector)
TriggerVector.__delslice__ = new_instancemethod(_fife.TriggerVector___delslice__, None, TriggerVector)
TriggerVector.__delitem__ = new_instancemethod(_fife.TriggerVector___delitem__, None, TriggerVector)
TriggerVector.__getitem__ = new_instancemethod(_fife.TriggerVector___getitem__, None, TriggerVector)
TriggerVector.__setitem__ = new_instancemethod(_fife.TriggerVector___setitem__, None, TriggerVector)
TriggerVector.pop = new_instancemethod(_fife.TriggerVector_pop, None, TriggerVector)
TriggerVector.append = new_instancemethod(_fife.TriggerVector_append, None, TriggerVector)
TriggerVector.empty = new_instancemethod(_fife.TriggerVector_empty, None, TriggerVector)
TriggerVector.size = new_instancemethod(_fife.TriggerVector_size, None, TriggerVector)
TriggerVector.swap = new_instancemethod(_fife.TriggerVector_swap, None, TriggerVector)
TriggerVector.begin = new_instancemethod(_fife.TriggerVector_begin, None, TriggerVector)
TriggerVector.end = new_instancemethod(_fife.TriggerVector_end, None, TriggerVector)
TriggerVector.rbegin = new_instancemethod(_fife.TriggerVector_rbegin, None, TriggerVector)
TriggerVector.rend = new_instancemethod(_fife.TriggerVector_rend, None, TriggerVector)
TriggerVector.clear = new_instancemethod(_fife.TriggerVector_clear, None, TriggerVector)
TriggerVector.get_allocator = new_instancemethod(_fife.TriggerVector_get_allocator, None, TriggerVector)
TriggerVector.pop_back = new_instancemethod(_fife.TriggerVector_pop_back, None, TriggerVector)
TriggerVector.erase = new_instancemethod(_fife.TriggerVector_erase, None, TriggerVector)
TriggerVector.push_back = new_instancemethod(_fife.TriggerVector_push_back, None, TriggerVector)
TriggerVector.front = new_instancemethod(_fife.TriggerVector_front, None, TriggerVector)
TriggerVector.back = new_instancemethod(_fife.TriggerVector_back, None, TriggerVector)
TriggerVector.assign = new_instancemethod(_fife.TriggerVector_assign, None, TriggerVector)
TriggerVector.resize = new_instancemethod(_fife.TriggerVector_resize, None, TriggerVector)
TriggerVector.insert = new_instancemethod(_fife.TriggerVector_insert, None, TriggerVector)
TriggerVector.reserve = new_instancemethod(_fife.TriggerVector_reserve, None, TriggerVector)
TriggerVector.capacity = new_instancemethod(_fife.TriggerVector_capacity, None, TriggerVector)
TriggerVector_swigregister = _fife.TriggerVector_swigregister
TriggerVector_swigregister(TriggerVector)

class StringList(object):
    """Proxy of C++ std::list<(std::string)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(StringList self) -> SwigPyIterator"""
        return _fife.StringList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(StringList self) -> bool"""
        return _fife.StringList___nonzero__(self)


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


    def __len__(self):
        """__len__(StringList self) -> std::list< std::string >::size_type"""
        return _fife.StringList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j) -> StringList"""
        return _fife.StringList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j)
        __setslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j, StringList v)
        """
        return _fife.StringList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::difference_type j)"""
        return _fife.StringList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(StringList self, std::list< std::string >::difference_type i)
        __delitem__(StringList self, PySliceObject * slice)
        """
        return _fife.StringList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(StringList self, PySliceObject * slice) -> StringList
        __getitem__(StringList self, std::list< std::string >::difference_type i) -> std::list< std::string >::value_type const &
        """
        return _fife.StringList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(StringList self, PySliceObject * slice, StringList v)
        __setitem__(StringList self, PySliceObject * slice)
        __setitem__(StringList self, std::list< std::string >::difference_type i, std::list< std::string >::value_type const & x)
        """
        return _fife.StringList___setitem__(self, *args)


    def pop(self):
        """pop(StringList self) -> std::list< std::string >::value_type"""
        return _fife.StringList_pop(self)


    def append(self, x):
        """append(StringList self, std::list< std::string >::value_type const & x)"""
        return _fife.StringList_append(self, x)


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


    def size(self):
        """size(StringList self) -> std::list< std::string >::size_type"""
        return _fife.StringList_size(self)


    def swap(self, v):
        """swap(StringList self, StringList v)"""
        return _fife.StringList_swap(self, v)


    def begin(self):
        """begin(StringList self) -> std::list< std::string >::iterator"""
        return _fife.StringList_begin(self)


    def end(self):
        """end(StringList self) -> std::list< std::string >::iterator"""
        return _fife.StringList_end(self)


    def rbegin(self):
        """rbegin(StringList self) -> std::list< std::string >::reverse_iterator"""
        return _fife.StringList_rbegin(self)


    def rend(self):
        """rend(StringList self) -> std::list< std::string >::reverse_iterator"""
        return _fife.StringList_rend(self)


    def clear(self):
        """clear(StringList self)"""
        return _fife.StringList_clear(self)


    def get_allocator(self):
        """get_allocator(StringList self) -> std::list< std::string >::allocator_type"""
        return _fife.StringList_get_allocator(self)


    def pop_back(self):
        """pop_back(StringList self)"""
        return _fife.StringList_pop_back(self)


    def erase(self, *args):
        """
        erase(StringList self, std::list< std::string >::iterator pos) -> std::list< std::string >::iterator
        erase(StringList self, std::list< std::string >::iterator first, std::list< std::string >::iterator last) -> std::list< std::string >::iterator
        """
        return _fife.StringList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(std::string)> self) -> StringList
        __init__(std::list<(std::string)> self, StringList arg2) -> StringList
        __init__(std::list<(std::string)> self, std::list< std::string >::size_type size) -> StringList
        __init__(std::list<(std::string)> self, std::list< std::string >::size_type size, std::list< std::string >::value_type const & value) -> StringList
        """
        _fife.StringList_swiginit(self, _fife.new_StringList(*args))

    def push_back(self, x):
        """push_back(StringList self, std::list< std::string >::value_type const & x)"""
        return _fife.StringList_push_back(self, x)


    def front(self):
        """front(StringList self) -> std::list< std::string >::value_type const &"""
        return _fife.StringList_front(self)


    def back(self):
        """back(StringList self) -> std::list< std::string >::value_type const &"""
        return _fife.StringList_back(self)


    def assign(self, n, x):
        """assign(StringList self, std::list< std::string >::size_type n, std::list< std::string >::value_type const & x)"""
        return _fife.StringList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(StringList self, std::list< std::string >::size_type new_size)
        resize(StringList self, std::list< std::string >::size_type new_size, std::list< std::string >::value_type const & x)
        """
        return _fife.StringList_resize(self, *args)


    def insert(self, *args):
        """
        insert(StringList self, std::list< std::string >::iterator pos, std::list< std::string >::value_type const & x) -> std::list< std::string >::iterator
        insert(StringList self, std::list< std::string >::iterator pos, std::list< std::string >::size_type n, std::list< std::string >::value_type const & x)
        """
        return _fife.StringList_insert(self, *args)


    def pop_front(self):
        """pop_front(StringList self)"""
        return _fife.StringList_pop_front(self)


    def push_front(self, x):
        """push_front(StringList self, std::list< std::string >::value_type const & x)"""
        return _fife.StringList_push_front(self, x)


    def reverse(self):
        """reverse(StringList self)"""
        return _fife.StringList_reverse(self)

    __swig_destroy__ = _fife.delete_StringList
StringList.iterator = new_instancemethod(_fife.StringList_iterator, None, StringList)
StringList.__nonzero__ = new_instancemethod(_fife.StringList___nonzero__, None, StringList)
StringList.__bool__ = new_instancemethod(_fife.StringList___bool__, None, StringList)
StringList.__len__ = new_instancemethod(_fife.StringList___len__, None, StringList)
StringList.__getslice__ = new_instancemethod(_fife.StringList___getslice__, None, StringList)
StringList.__setslice__ = new_instancemethod(_fife.StringList___setslice__, None, StringList)
StringList.__delslice__ = new_instancemethod(_fife.StringList___delslice__, None, StringList)
StringList.__delitem__ = new_instancemethod(_fife.StringList___delitem__, None, StringList)
StringList.__getitem__ = new_instancemethod(_fife.StringList___getitem__, None, StringList)
StringList.__setitem__ = new_instancemethod(_fife.StringList___setitem__, None, StringList)
StringList.pop = new_instancemethod(_fife.StringList_pop, None, StringList)
StringList.append = new_instancemethod(_fife.StringList_append, None, StringList)
StringList.empty = new_instancemethod(_fife.StringList_empty, None, StringList)
StringList.size = new_instancemethod(_fife.StringList_size, None, StringList)
StringList.swap = new_instancemethod(_fife.StringList_swap, None, StringList)
StringList.begin = new_instancemethod(_fife.StringList_begin, None, StringList)
StringList.end = new_instancemethod(_fife.StringList_end, None, StringList)
StringList.rbegin = new_instancemethod(_fife.StringList_rbegin, None, StringList)
StringList.rend = new_instancemethod(_fife.StringList_rend, None, StringList)
StringList.clear = new_instancemethod(_fife.StringList_clear, None, StringList)
StringList.get_allocator = new_instancemethod(_fife.StringList_get_allocator, None, StringList)
StringList.pop_back = new_instancemethod(_fife.StringList_pop_back, None, StringList)
StringList.erase = new_instancemethod(_fife.StringList_erase, None, StringList)
StringList.push_back = new_instancemethod(_fife.StringList_push_back, None, StringList)
StringList.front = new_instancemethod(_fife.StringList_front, None, StringList)
StringList.back = new_instancemethod(_fife.StringList_back, None, StringList)
StringList.assign = new_instancemethod(_fife.StringList_assign, None, StringList)
StringList.resize = new_instancemethod(_fife.StringList_resize, None, StringList)
StringList.insert = new_instancemethod(_fife.StringList_insert, None, StringList)
StringList.pop_front = new_instancemethod(_fife.StringList_pop_front, None, StringList)
StringList.push_front = new_instancemethod(_fife.StringList_push_front, None, StringList)
StringList.reverse = new_instancemethod(_fife.StringList_reverse, None, StringList)
StringList_swigregister = _fife.StringList_swigregister
StringList_swigregister(StringList)

class ObjectList(object):
    """Proxy of C++ std::list<(p.FIFE::Object)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(ObjectList self) -> SwigPyIterator"""
        return _fife.ObjectList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(ObjectList self) -> bool"""
        return _fife.ObjectList___nonzero__(self)


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


    def __len__(self):
        """__len__(ObjectList self) -> std::list< FIFE::Object * >::size_type"""
        return _fife.ObjectList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ObjectList self, std::list< FIFE::Object * >::difference_type i, std::list< FIFE::Object * >::difference_type j) -> ObjectList"""
        return _fife.ObjectList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ObjectList self, std::list< FIFE::Object * >::difference_type i, std::list< FIFE::Object * >::difference_type j)
        __setslice__(ObjectList self, std::list< FIFE::Object * >::difference_type i, std::list< FIFE::Object * >::difference_type j, ObjectList v)
        """
        return _fife.ObjectList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ObjectList self, std::list< FIFE::Object * >::difference_type i, std::list< FIFE::Object * >::difference_type j)"""
        return _fife.ObjectList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ObjectList self, std::list< FIFE::Object * >::difference_type i)
        __delitem__(ObjectList self, PySliceObject * slice)
        """
        return _fife.ObjectList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ObjectList self, PySliceObject * slice) -> ObjectList
        __getitem__(ObjectList self, std::list< FIFE::Object * >::difference_type i) -> Object
        """
        return _fife.ObjectList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ObjectList self, PySliceObject * slice, ObjectList v)
        __setitem__(ObjectList self, PySliceObject * slice)
        __setitem__(ObjectList self, std::list< FIFE::Object * >::difference_type i, Object x)
        """
        return _fife.ObjectList___setitem__(self, *args)


    def pop(self):
        """pop(ObjectList self) -> Object"""
        return _fife.ObjectList_pop(self)


    def append(self, x):
        """append(ObjectList self, Object x)"""
        return _fife.ObjectList_append(self, x)


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


    def size(self):
        """size(ObjectList self) -> std::list< FIFE::Object * >::size_type"""
        return _fife.ObjectList_size(self)


    def swap(self, v):
        """swap(ObjectList self, ObjectList v)"""
        return _fife.ObjectList_swap(self, v)


    def begin(self):
        """begin(ObjectList self) -> std::list< FIFE::Object * >::iterator"""
        return _fife.ObjectList_begin(self)


    def end(self):
        """end(ObjectList self) -> std::list< FIFE::Object * >::iterator"""
        return _fife.ObjectList_end(self)


    def rbegin(self):
        """rbegin(ObjectList self) -> std::list< FIFE::Object * >::reverse_iterator"""
        return _fife.ObjectList_rbegin(self)


    def rend(self):
        """rend(ObjectList self) -> std::list< FIFE::Object * >::reverse_iterator"""
        return _fife.ObjectList_rend(self)


    def clear(self):
        """clear(ObjectList self)"""
        return _fife.ObjectList_clear(self)


    def get_allocator(self):
        """get_allocator(ObjectList self) -> std::list< FIFE::Object * >::allocator_type"""
        return _fife.ObjectList_get_allocator(self)


    def pop_back(self):
        """pop_back(ObjectList self)"""
        return _fife.ObjectList_pop_back(self)


    def erase(self, *args):
        """
        erase(ObjectList self, std::list< FIFE::Object * >::iterator pos) -> std::list< FIFE::Object * >::iterator
        erase(ObjectList self, std::list< FIFE::Object * >::iterator first, std::list< FIFE::Object * >::iterator last) -> std::list< FIFE::Object * >::iterator
        """
        return _fife.ObjectList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.FIFE::Object)> self) -> ObjectList
        __init__(std::list<(p.FIFE::Object)> self, ObjectList arg2) -> ObjectList
        __init__(std::list<(p.FIFE::Object)> self, std::list< FIFE::Object * >::size_type size) -> ObjectList
        __init__(std::list<(p.FIFE::Object)> self, std::list< FIFE::Object * >::size_type size, Object value) -> ObjectList
        """
        _fife.ObjectList_swiginit(self, _fife.new_ObjectList(*args))

    def push_back(self, x):
        """push_back(ObjectList self, Object x)"""
        return _fife.ObjectList_push_back(self, x)


    def front(self):
        """front(ObjectList self) -> Object"""
        return _fife.ObjectList_front(self)


    def back(self):
        """back(ObjectList self) -> Object"""
        return _fife.ObjectList_back(self)


    def assign(self, n, x):
        """assign(ObjectList self, std::list< FIFE::Object * >::size_type n, Object x)"""
        return _fife.ObjectList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ObjectList self, std::list< FIFE::Object * >::size_type new_size)
        resize(ObjectList self, std::list< FIFE::Object * >::size_type new_size, Object x)
        """
        return _fife.ObjectList_resize(self, *args)


    def insert(self, *args):
        """
        insert(ObjectList self, std::list< FIFE::Object * >::iterator pos, Object x) -> std::list< FIFE::Object * >::iterator
        insert(ObjectList self, std::list< FIFE::Object * >::iterator pos, std::list< FIFE::Object * >::size_type n, Object x)
        """
        return _fife.ObjectList_insert(self, *args)


    def pop_front(self):
        """pop_front(ObjectList self)"""
        return _fife.ObjectList_pop_front(self)


    def push_front(self, x):
        """push_front(ObjectList self, Object x)"""
        return _fife.ObjectList_push_front(self, x)


    def remove(self, x):
        """remove(ObjectList self, Object x)"""
        return _fife.ObjectList_remove(self, x)


    def unique(self):
        """unique(ObjectList self)"""
        return _fife.ObjectList_unique(self)


    def reverse(self):
        """reverse(ObjectList self)"""
        return _fife.ObjectList_reverse(self)


    def sort(self):
        """sort(ObjectList self)"""
        return _fife.ObjectList_sort(self)


    def merge(self, x):
        """merge(ObjectList self, ObjectList x)"""
        return _fife.ObjectList_merge(self, x)

    __swig_destroy__ = _fife.delete_ObjectList
ObjectList.iterator = new_instancemethod(_fife.ObjectList_iterator, None, ObjectList)
ObjectList.__nonzero__ = new_instancemethod(_fife.ObjectList___nonzero__, None, ObjectList)
ObjectList.__bool__ = new_instancemethod(_fife.ObjectList___bool__, None, ObjectList)
ObjectList.__len__ = new_instancemethod(_fife.ObjectList___len__, None, ObjectList)
ObjectList.__getslice__ = new_instancemethod(_fife.ObjectList___getslice__, None, ObjectList)
ObjectList.__setslice__ = new_instancemethod(_fife.ObjectList___setslice__, None, ObjectList)
ObjectList.__delslice__ = new_instancemethod(_fife.ObjectList___delslice__, None, ObjectList)
ObjectList.__delitem__ = new_instancemethod(_fife.ObjectList___delitem__, None, ObjectList)
ObjectList.__getitem__ = new_instancemethod(_fife.ObjectList___getitem__, None, ObjectList)
ObjectList.__setitem__ = new_instancemethod(_fife.ObjectList___setitem__, None, ObjectList)
ObjectList.pop = new_instancemethod(_fife.ObjectList_pop, None, ObjectList)
ObjectList.append = new_instancemethod(_fife.ObjectList_append, None, ObjectList)
ObjectList.empty = new_instancemethod(_fife.ObjectList_empty, None, ObjectList)
ObjectList.size = new_instancemethod(_fife.ObjectList_size, None, ObjectList)
ObjectList.swap = new_instancemethod(_fife.ObjectList_swap, None, ObjectList)
ObjectList.begin = new_instancemethod(_fife.ObjectList_begin, None, ObjectList)
ObjectList.end = new_instancemethod(_fife.ObjectList_end, None, ObjectList)
ObjectList.rbegin = new_instancemethod(_fife.ObjectList_rbegin, None, ObjectList)
ObjectList.rend = new_instancemethod(_fife.ObjectList_rend, None, ObjectList)
ObjectList.clear = new_instancemethod(_fife.ObjectList_clear, None, ObjectList)
ObjectList.get_allocator = new_instancemethod(_fife.ObjectList_get_allocator, None, ObjectList)
ObjectList.pop_back = new_instancemethod(_fife.ObjectList_pop_back, None, ObjectList)
ObjectList.erase = new_instancemethod(_fife.ObjectList_erase, None, ObjectList)
ObjectList.push_back = new_instancemethod(_fife.ObjectList_push_back, None, ObjectList)
ObjectList.front = new_instancemethod(_fife.ObjectList_front, None, ObjectList)
ObjectList.back = new_instancemethod(_fife.ObjectList_back, None, ObjectList)
ObjectList.assign = new_instancemethod(_fife.ObjectList_assign, None, ObjectList)
ObjectList.resize = new_instancemethod(_fife.ObjectList_resize, None, ObjectList)
ObjectList.insert = new_instancemethod(_fife.ObjectList_insert, None, ObjectList)
ObjectList.pop_front = new_instancemethod(_fife.ObjectList_pop_front, None, ObjectList)
ObjectList.push_front = new_instancemethod(_fife.ObjectList_push_front, None, ObjectList)
ObjectList.remove = new_instancemethod(_fife.ObjectList_remove, None, ObjectList)
ObjectList.unique = new_instancemethod(_fife.ObjectList_unique, None, ObjectList)
ObjectList.reverse = new_instancemethod(_fife.ObjectList_reverse, None, ObjectList)
ObjectList.sort = new_instancemethod(_fife.ObjectList_sort, None, ObjectList)
ObjectList.merge = new_instancemethod(_fife.ObjectList_merge, None, ObjectList)
ObjectList_swigregister = _fife.ObjectList_swigregister
ObjectList_swigregister(ObjectList)

class MapList(object):
    """Proxy of C++ std::list<(p.FIFE::Map)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(MapList self) -> SwigPyIterator"""
        return _fife.MapList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(MapList self) -> bool"""
        return _fife.MapList___nonzero__(self)


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


    def __len__(self):
        """__len__(MapList self) -> std::list< FIFE::Map * >::size_type"""
        return _fife.MapList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(MapList self, std::list< FIFE::Map * >::difference_type i, std::list< FIFE::Map * >::difference_type j) -> MapList"""
        return _fife.MapList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(MapList self, std::list< FIFE::Map * >::difference_type i, std::list< FIFE::Map * >::difference_type j)
        __setslice__(MapList self, std::list< FIFE::Map * >::difference_type i, std::list< FIFE::Map * >::difference_type j, MapList v)
        """
        return _fife.MapList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(MapList self, std::list< FIFE::Map * >::difference_type i, std::list< FIFE::Map * >::difference_type j)"""
        return _fife.MapList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(MapList self, std::list< FIFE::Map * >::difference_type i)
        __delitem__(MapList self, PySliceObject * slice)
        """
        return _fife.MapList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(MapList self, PySliceObject * slice) -> MapList
        __getitem__(MapList self, std::list< FIFE::Map * >::difference_type i) -> Map
        """
        return _fife.MapList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(MapList self, PySliceObject * slice, MapList v)
        __setitem__(MapList self, PySliceObject * slice)
        __setitem__(MapList self, std::list< FIFE::Map * >::difference_type i, Map x)
        """
        return _fife.MapList___setitem__(self, *args)


    def pop(self):
        """pop(MapList self) -> Map"""
        return _fife.MapList_pop(self)


    def append(self, x):
        """append(MapList self, Map x)"""
        return _fife.MapList_append(self, x)


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


    def size(self):
        """size(MapList self) -> std::list< FIFE::Map * >::size_type"""
        return _fife.MapList_size(self)


    def swap(self, v):
        """swap(MapList self, MapList v)"""
        return _fife.MapList_swap(self, v)


    def begin(self):
        """begin(MapList self) -> std::list< FIFE::Map * >::iterator"""
        return _fife.MapList_begin(self)


    def end(self):
        """end(MapList self) -> std::list< FIFE::Map * >::iterator"""
        return _fife.MapList_end(self)


    def rbegin(self):
        """rbegin(MapList self) -> std::list< FIFE::Map * >::reverse_iterator"""
        return _fife.MapList_rbegin(self)


    def rend(self):
        """rend(MapList self) -> std::list< FIFE::Map * >::reverse_iterator"""
        return _fife.MapList_rend(self)


    def clear(self):
        """clear(MapList self)"""
        return _fife.MapList_clear(self)


    def get_allocator(self):
        """get_allocator(MapList self) -> std::list< FIFE::Map * >::allocator_type"""
        return _fife.MapList_get_allocator(self)


    def pop_back(self):
        """pop_back(MapList self)"""
        return _fife.MapList_pop_back(self)


    def erase(self, *args):
        """
        erase(MapList self, std::list< FIFE::Map * >::iterator pos) -> std::list< FIFE::Map * >::iterator
        erase(MapList self, std::list< FIFE::Map * >::iterator first, std::list< FIFE::Map * >::iterator last) -> std::list< FIFE::Map * >::iterator
        """
        return _fife.MapList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(p.FIFE::Map)> self) -> MapList
        __init__(std::list<(p.FIFE::Map)> self, MapList arg2) -> MapList
        __init__(std::list<(p.FIFE::Map)> self, std::list< FIFE::Map * >::size_type size) -> MapList
        __init__(std::list<(p.FIFE::Map)> self, std::list< FIFE::Map * >::size_type size, Map value) -> MapList
        """
        _fife.MapList_swiginit(self, _fife.new_MapList(*args))

    def push_back(self, x):
        """push_back(MapList self, Map x)"""
        return _fife.MapList_push_back(self, x)


    def front(self):
        """front(MapList self) -> Map"""
        return _fife.MapList_front(self)


    def back(self):
        """back(MapList self) -> Map"""
        return _fife.MapList_back(self)


    def assign(self, n, x):
        """assign(MapList self, std::list< FIFE::Map * >::size_type n, Map x)"""
        return _fife.MapList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(MapList self, std::list< FIFE::Map * >::size_type new_size)
        resize(MapList self, std::list< FIFE::Map * >::size_type new_size, Map x)
        """
        return _fife.MapList_resize(self, *args)


    def insert(self, *args):
        """
        insert(MapList self, std::list< FIFE::Map * >::iterator pos, Map x) -> std::list< FIFE::Map * >::iterator
        insert(MapList self, std::list< FIFE::Map * >::iterator pos, std::list< FIFE::Map * >::size_type n, Map x)
        """
        return _fife.MapList_insert(self, *args)


    def pop_front(self):
        """pop_front(MapList self)"""
        return _fife.MapList_pop_front(self)


    def push_front(self, x):
        """push_front(MapList self, Map x)"""
        return _fife.MapList_push_front(self, x)


    def remove(self, x):
        """remove(MapList self, Map x)"""
        return _fife.MapList_remove(self, x)


    def unique(self):
        """unique(MapList self)"""
        return _fife.MapList_unique(self)


    def reverse(self):
        """reverse(MapList self)"""
        return _fife.MapList_reverse(self)


    def sort(self):
        """sort(MapList self)"""
        return _fife.MapList_sort(self)


    def merge(self, x):
        """merge(MapList self, MapList x)"""
        return _fife.MapList_merge(self, x)

    __swig_destroy__ = _fife.delete_MapList
MapList.iterator = new_instancemethod(_fife.MapList_iterator, None, MapList)
MapList.__nonzero__ = new_instancemethod(_fife.MapList___nonzero__, None, MapList)
MapList.__bool__ = new_instancemethod(_fife.MapList___bool__, None, MapList)
MapList.__len__ = new_instancemethod(_fife.MapList___len__, None, MapList)
MapList.__getslice__ = new_instancemethod(_fife.MapList___getslice__, None, MapList)
MapList.__setslice__ = new_instancemethod(_fife.MapList___setslice__, None, MapList)
MapList.__delslice__ = new_instancemethod(_fife.MapList___delslice__, None, MapList)
MapList.__delitem__ = new_instancemethod(_fife.MapList___delitem__, None, MapList)
MapList.__getitem__ = new_instancemethod(_fife.MapList___getitem__, None, MapList)
MapList.__setitem__ = new_instancemethod(_fife.MapList___setitem__, None, MapList)
MapList.pop = new_instancemethod(_fife.MapList_pop, None, MapList)
MapList.append = new_instancemethod(_fife.MapList_append, None, MapList)
MapList.empty = new_instancemethod(_fife.MapList_empty, None, MapList)
MapList.size = new_instancemethod(_fife.MapList_size, None, MapList)
MapList.swap = new_instancemethod(_fife.MapList_swap, None, MapList)
MapList.begin = new_instancemethod(_fife.MapList_begin, None, MapList)
MapList.end = new_instancemethod(_fife.MapList_end, None, MapList)
MapList.rbegin = new_instancemethod(_fife.MapList_rbegin, None, MapList)
MapList.rend = new_instancemethod(_fife.MapList_rend, None, MapList)
MapList.clear = new_instancemethod(_fife.MapList_clear, None, MapList)
MapList.get_allocator = new_instancemethod(_fife.MapList_get_allocator, None, MapList)
MapList.pop_back = new_instancemethod(_fife.MapList_pop_back, None, MapList)
MapList.erase = new_instancemethod(_fife.MapList_erase, None, MapList)
MapList.push_back = new_instancemethod(_fife.MapList_push_back, None, MapList)
MapList.front = new_instancemethod(_fife.MapList_front, None, MapList)
MapList.back = new_instancemethod(_fife.MapList_back, None, MapList)
MapList.assign = new_instancemethod(_fife.MapList_assign, None, MapList)
MapList.resize = new_instancemethod(_fife.MapList_resize, None, MapList)
MapList.insert = new_instancemethod(_fife.MapList_insert, None, MapList)
MapList.pop_front = new_instancemethod(_fife.MapList_pop_front, None, MapList)
MapList.push_front = new_instancemethod(_fife.MapList_push_front, None, MapList)
MapList.remove = new_instancemethod(_fife.MapList_remove, None, MapList)
MapList.unique = new_instancemethod(_fife.MapList_unique, None, MapList)
MapList.reverse = new_instancemethod(_fife.MapList_reverse, None, MapList)
MapList.sort = new_instancemethod(_fife.MapList_sort, None, MapList)
MapList.merge = new_instancemethod(_fife.MapList_merge, None, MapList)
MapList_swigregister = _fife.MapList_swigregister
MapList_swigregister(MapList)

class Model(FifeClass):
    """Proxy of C++ FIFE::Model class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, renderbackend, renderers):
        """__init__(FIFE::Model self, RenderBackend renderbackend, std::vector< FIFE::RendererBase *,std::allocator< FIFE::RendererBase * > > const & renderers) -> Model"""
        _fife.Model_swiginit(self, _fife.new_Model(renderbackend, renderers))
    __swig_destroy__ = _fife.delete_Model

    def createMap(self, identifier):
        """createMap(Model self, std::string const & identifier) -> Map"""
        return _fife.Model_createMap(self, identifier)


    def deleteMap(self, arg2):
        """deleteMap(Model self, Map arg2)"""
        return _fife.Model_deleteMap(self, arg2)


    def getMaps(self):
        """getMaps(Model self) -> MapList"""
        return _fife.Model_getMaps(self)


    def getMap(self, id):
        """getMap(Model self, std::string const & id) -> Map"""
        return _fife.Model_getMap(self, id)


    def getNamespaces(self):
        """getNamespaces(Model self) -> StringList"""
        return _fife.Model_getNamespaces(self)


    def createObject(self, identifier, name_space, parent=None):
        """createObject(Model self, std::string const & identifier, std::string const & name_space, Object parent=None) -> Object"""
        return _fife.Model_createObject(self, identifier, name_space, parent)


    def deleteObject(self, arg2):
        """deleteObject(Model self, Object arg2) -> bool"""
        return _fife.Model_deleteObject(self, arg2)


    def deleteObjects(self):
        """deleteObjects(Model self) -> bool"""
        return _fife.Model_deleteObjects(self)


    def getObject(self, id, name_space):
        """getObject(Model self, std::string const & id, std::string const & name_space) -> Object"""
        return _fife.Model_getObject(self, id, name_space)


    def getObjects(self, name_space):
        """getObjects(Model self, std::string const & name_space) -> ObjectList"""
        return _fife.Model_getObjects(self, name_space)


    def getMapCount(self):
        """getMapCount(Model self) -> uint32_t"""
        return _fife.Model_getMapCount(self)


    def deleteMaps(self):
        """deleteMaps(Model self)"""
        return _fife.Model_deleteMaps(self)


    def adoptPather(self, pather):
        """adoptPather(Model self, IPather pather)"""
        return _fife.Model_adoptPather(self, pather)


    def getPather(self, pathername):
        """getPather(Model self, std::string const & pathername) -> IPather"""
        return _fife.Model_getPather(self, pathername)


    def getCellGrid(self, gridtype):
        """getCellGrid(Model self, std::string const & gridtype) -> CellGrid"""
        return _fife.Model_getCellGrid(self, gridtype)


    def setTimeMultiplier(self, multip):
        """setTimeMultiplier(Model self, float multip)"""
        return _fife.Model_setTimeMultiplier(self, multip)


    def getTimeMultiplier(self):
        """getTimeMultiplier(Model self) -> double"""
        return _fife.Model_getTimeMultiplier(self)

Model.createMap = new_instancemethod(_fife.Model_createMap, None, Model)
Model.deleteMap = new_instancemethod(_fife.Model_deleteMap, None, Model)
Model.getMaps = new_instancemethod(_fife.Model_getMaps, None, Model)
Model.getMap = new_instancemethod(_fife.Model_getMap, None, Model)
Model.getNamespaces = new_instancemethod(_fife.Model_getNamespaces, None, Model)
Model.createObject = new_instancemethod(_fife.Model_createObject, None, Model)
Model.deleteObject = new_instancemethod(_fife.Model_deleteObject, None, Model)
Model.deleteObjects = new_instancemethod(_fife.Model_deleteObjects, None, Model)
Model.getObject = new_instancemethod(_fife.Model_getObject, None, Model)
Model.getObjects = new_instancemethod(_fife.Model_getObjects, None, Model)
Model.getMapCount = new_instancemethod(_fife.Model_getMapCount, None, Model)
Model.deleteMaps = new_instancemethod(_fife.Model_deleteMaps, None, Model)
Model.adoptPather = new_instancemethod(_fife.Model_adoptPather, None, Model)
Model.getPather = new_instancemethod(_fife.Model_getPather, None, Model)
Model.getCellGrid = new_instancemethod(_fife.Model_getCellGrid, None, Model)
Model.setTimeMultiplier = new_instancemethod(_fife.Model_setTimeMultiplier, None, Model)
Model.getTimeMultiplier = new_instancemethod(_fife.Model_getTimeMultiplier, None, Model)
Model_swigregister = _fife.Model_swigregister
Model_swigregister(Model)

class LocationList(object):
    """Proxy of C++ std::list<(FIFE::Location)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(LocationList self) -> SwigPyIterator"""
        return _fife.LocationList_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(LocationList self) -> bool"""
        return _fife.LocationList___nonzero__(self)


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


    def __len__(self):
        """__len__(LocationList self) -> std::list< FIFE::Location >::size_type"""
        return _fife.LocationList___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(LocationList self, std::list< FIFE::Location >::difference_type i, std::list< FIFE::Location >::difference_type j) -> LocationList"""
        return _fife.LocationList___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(LocationList self, std::list< FIFE::Location >::difference_type i, std::list< FIFE::Location >::difference_type j)
        __setslice__(LocationList self, std::list< FIFE::Location >::difference_type i, std::list< FIFE::Location >::difference_type j, LocationList v)
        """
        return _fife.LocationList___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(LocationList self, std::list< FIFE::Location >::difference_type i, std::list< FIFE::Location >::difference_type j)"""
        return _fife.LocationList___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(LocationList self, std::list< FIFE::Location >::difference_type i)
        __delitem__(LocationList self, PySliceObject * slice)
        """
        return _fife.LocationList___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(LocationList self, PySliceObject * slice) -> LocationList
        __getitem__(LocationList self, std::list< FIFE::Location >::difference_type i) -> Location
        """
        return _fife.LocationList___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(LocationList self, PySliceObject * slice, LocationList v)
        __setitem__(LocationList self, PySliceObject * slice)
        __setitem__(LocationList self, std::list< FIFE::Location >::difference_type i, Location x)
        """
        return _fife.LocationList___setitem__(self, *args)


    def pop(self):
        """pop(LocationList self) -> Location"""
        return _fife.LocationList_pop(self)


    def append(self, x):
        """append(LocationList self, Location x)"""
        return _fife.LocationList_append(self, x)


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


    def size(self):
        """size(LocationList self) -> std::list< FIFE::Location >::size_type"""
        return _fife.LocationList_size(self)


    def swap(self, v):
        """swap(LocationList self, LocationList v)"""
        return _fife.LocationList_swap(self, v)


    def begin(self):
        """begin(LocationList self) -> std::list< FIFE::Location >::iterator"""
        return _fife.LocationList_begin(self)


    def end(self):
        """end(LocationList self) -> std::list< FIFE::Location >::iterator"""
        return _fife.LocationList_end(self)


    def rbegin(self):
        """rbegin(LocationList self) -> std::list< FIFE::Location >::reverse_iterator"""
        return _fife.LocationList_rbegin(self)


    def rend(self):
        """rend(LocationList self) -> std::list< FIFE::Location >::reverse_iterator"""
        return _fife.LocationList_rend(self)


    def clear(self):
        """clear(LocationList self)"""
        return _fife.LocationList_clear(self)


    def get_allocator(self):
        """get_allocator(LocationList self) -> std::list< FIFE::Location >::allocator_type"""
        return _fife.LocationList_get_allocator(self)


    def pop_back(self):
        """pop_back(LocationList self)"""
        return _fife.LocationList_pop_back(self)


    def erase(self, *args):
        """
        erase(LocationList self, std::list< FIFE::Location >::iterator pos) -> std::list< FIFE::Location >::iterator
        erase(LocationList self, std::list< FIFE::Location >::iterator first, std::list< FIFE::Location >::iterator last) -> std::list< FIFE::Location >::iterator
        """
        return _fife.LocationList_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::list<(FIFE::Location)> self) -> LocationList
        __init__(std::list<(FIFE::Location)> self, LocationList arg2) -> LocationList
        __init__(std::list<(FIFE::Location)> self, std::list< FIFE::Location >::size_type size) -> LocationList
        __init__(std::list<(FIFE::Location)> self, std::list< FIFE::Location >::size_type size, Location value) -> LocationList
        """
        _fife.LocationList_swiginit(self, _fife.new_LocationList(*args))

    def push_back(self, x):
        """push_back(LocationList self, Location x)"""
        return _fife.LocationList_push_back(self, x)


    def front(self):
        """front(LocationList self) -> Location"""
        return _fife.LocationList_front(self)


    def back(self):
        """back(LocationList self) -> Location"""
        return _fife.LocationList_back(self)


    def assign(self, n, x):
        """assign(LocationList self, std::list< FIFE::Location >::size_type n, Location x)"""
        return _fife.LocationList_assign(self, n, x)


    def resize(self, *args):
        """
        resize(LocationList self, std::list< FIFE::Location >::size_type new_size)
        resize(LocationList self, std::list< FIFE::Location >::size_type new_size, Location x)
        """
        return _fife.LocationList_resize(self, *args)


    def insert(self, *args):
        """
        insert(LocationList self, std::list< FIFE::Location >::iterator pos, Location x) -> std::list< FIFE::Location >::iterator
        insert(LocationList self, std::list< FIFE::Location >::iterator pos, std::list< FIFE::Location >::size_type n, Location x)
        """
        return _fife.LocationList_insert(self, *args)


    def pop_front(self):
        """pop_front(LocationList self)"""
        return _fife.LocationList_pop_front(self)


    def push_front(self, x):
        """push_front(LocationList self, Location x)"""
        return _fife.LocationList_push_front(self, x)


    def reverse(self):
        """reverse(LocationList self)"""
        return _fife.LocationList_reverse(self)

    __swig_destroy__ = _fife.delete_LocationList
LocationList.iterator = new_instancemethod(_fife.LocationList_iterator, None, LocationList)
LocationList.__nonzero__ = new_instancemethod(_fife.LocationList___nonzero__, None, LocationList)
LocationList.__bool__ = new_instancemethod(_fife.LocationList___bool__, None, LocationList)
LocationList.__len__ = new_instancemethod(_fife.LocationList___len__, None, LocationList)
LocationList.__getslice__ = new_instancemethod(_fife.LocationList___getslice__, None, LocationList)
LocationList.__setslice__ = new_instancemethod(_fife.LocationList___setslice__, None, LocationList)
LocationList.__delslice__ = new_instancemethod(_fife.LocationList___delslice__, None, LocationList)
LocationList.__delitem__ = new_instancemethod(_fife.LocationList___delitem__, None, LocationList)
LocationList.__getitem__ = new_instancemethod(_fife.LocationList___getitem__, None, LocationList)
LocationList.__setitem__ = new_instancemethod(_fife.LocationList___setitem__, None, LocationList)
LocationList.pop = new_instancemethod(_fife.LocationList_pop, None, LocationList)
LocationList.append = new_instancemethod(_fife.LocationList_append, None, LocationList)
LocationList.empty = new_instancemethod(_fife.LocationList_empty, None, LocationList)
LocationList.size = new_instancemethod(_fife.LocationList_size, None, LocationList)
LocationList.swap = new_instancemethod(_fife.LocationList_swap, None, LocationList)
LocationList.begin = new_instancemethod(_fife.LocationList_begin, None, LocationList)
LocationList.end = new_instancemethod(_fife.LocationList_end, None, LocationList)
LocationList.rbegin = new_instancemethod(_fife.LocationList_rbegin, None, LocationList)
LocationList.rend = new_instancemethod(_fife.LocationList_rend, None, LocationList)
LocationList.clear = new_instancemethod(_fife.LocationList_clear, None, LocationList)
LocationList.get_allocator = new_instancemethod(_fife.LocationList_get_allocator, None, LocationList)
LocationList.pop_back = new_instancemethod(_fife.LocationList_pop_back, None, LocationList)
LocationList.erase = new_instancemethod(_fife.LocationList_erase, None, LocationList)
LocationList.push_back = new_instancemethod(_fife.LocationList_push_back, None, LocationList)
LocationList.front = new_instancemethod(_fife.LocationList_front, None, LocationList)
LocationList.back = new_instancemethod(_fife.LocationList_back, None, LocationList)
LocationList.assign = new_instancemethod(_fife.LocationList_assign, None, LocationList)
LocationList.resize = new_instancemethod(_fife.LocationList_resize, None, LocationList)
LocationList.insert = new_instancemethod(_fife.LocationList_insert, None, LocationList)
LocationList.pop_front = new_instancemethod(_fife.LocationList_pop_front, None, LocationList)
LocationList.push_front = new_instancemethod(_fife.LocationList_push_front, None, LocationList)
LocationList.reverse = new_instancemethod(_fife.LocationList_reverse, None, LocationList)
LocationList_swigregister = _fife.LocationList_swigregister
LocationList_swigregister(LocationList)

class RoutePather(IPather):
    """Proxy of C++ FIFE::RoutePather class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::RoutePather self) -> RoutePather"""
        _fife.RoutePather_swiginit(self, _fife.new_RoutePather())
    __swig_destroy__ = _fife.delete_RoutePather

    def getName(self):
        """getName(RoutePather self) -> std::string"""
        return _fife.RoutePather_getName(self)

RoutePather.getName = new_instancemethod(_fife.RoutePather_getName, None, RoutePather)
RoutePather_swigregister = _fife.RoutePather_swigregister
RoutePather_swigregister(RoutePather)

class IAnimationSaver(object):
    """Proxy of C++ FIFE::IAnimationSaver class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAnimationSaver

    def save(self, filename):
        """save(IAnimationSaver self, std::string const & filename)"""
        return _fife.IAnimationSaver_save(self, filename)


    def __init__(self):
        """__init__(FIFE::IAnimationSaver self) -> IAnimationSaver"""
        if self.__class__ == IAnimationSaver:
            _self = None
        else:
            _self = self
        _fife.IAnimationSaver_swiginit(self, _fife.new_IAnimationSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationSaver(self)
        return weakref_proxy(self)
IAnimationSaver.save = new_instancemethod(_fife.IAnimationSaver_save, None, IAnimationSaver)
IAnimationSaver_swigregister = _fife.IAnimationSaver_swigregister
IAnimationSaver_swigregister(IAnimationSaver)

class IAtlasSaver(object):
    """Proxy of C++ FIFE::IAtlasSaver class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IAtlasSaver

    def save(self, filename):
        """save(IAtlasSaver self, std::string const & filename)"""
        return _fife.IAtlasSaver_save(self, filename)


    def __init__(self):
        """__init__(FIFE::IAtlasSaver self) -> IAtlasSaver"""
        if self.__class__ == IAtlasSaver:
            _self = None
        else:
            _self = self
        _fife.IAtlasSaver_swiginit(self, _fife.new_IAtlasSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasSaver(self)
        return weakref_proxy(self)
IAtlasSaver.save = new_instancemethod(_fife.IAtlasSaver_save, None, IAtlasSaver)
IAtlasSaver_swigregister = _fife.IAtlasSaver_swigregister
IAtlasSaver_swigregister(IAtlasSaver)

class IMapSaver(object):
    """Proxy of C++ FIFE::IMapSaver class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IMapSaver

    def setObjectSaver(self, objectSaver):
        """setObjectSaver(IMapSaver self, FIFE::ObjectSaverPtr const & objectSaver)"""
        return _fife.IMapSaver_setObjectSaver(self, objectSaver)


    def setAnimationSaver(self, animationSaver):
        """setAnimationSaver(IMapSaver self, FIFE::AnimationSaverPtr const & animationSaver)"""
        return _fife.IMapSaver_setAnimationSaver(self, animationSaver)


    def setAtlasSaver(self, atlasSaver):
        """setAtlasSaver(IMapSaver self, FIFE::AtlasSaverPtr const & atlasSaver)"""
        return _fife.IMapSaver_setAtlasSaver(self, atlasSaver)


    def save(self, map, filename, importFiles):
        """save(IMapSaver self, Map map, std::string const & filename, StringVector importFiles)"""
        return _fife.IMapSaver_save(self, map, filename, importFiles)


    def __init__(self):
        """__init__(FIFE::IMapSaver self) -> IMapSaver"""
        if self.__class__ == IMapSaver:
            _self = None
        else:
            _self = self
        _fife.IMapSaver_swiginit(self, _fife.new_IMapSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapSaver(self)
        return weakref_proxy(self)
IMapSaver.setObjectSaver = new_instancemethod(_fife.IMapSaver_setObjectSaver, None, IMapSaver)
IMapSaver.setAnimationSaver = new_instancemethod(_fife.IMapSaver_setAnimationSaver, None, IMapSaver)
IMapSaver.setAtlasSaver = new_instancemethod(_fife.IMapSaver_setAtlasSaver, None, IMapSaver)
IMapSaver.save = new_instancemethod(_fife.IMapSaver_save, None, IMapSaver)
IMapSaver_swigregister = _fife.IMapSaver_swigregister
IMapSaver_swigregister(IMapSaver)

class IObjectSaver(object):
    """Proxy of C++ FIFE::IObjectSaver class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IObjectSaver

    def setAnimationSaver(self, animationSaver):
        """setAnimationSaver(IObjectSaver self, FIFE::AnimationSaverPtr const & animationSaver)"""
        return _fife.IObjectSaver_setAnimationSaver(self, animationSaver)


    def save(self, filename):
        """save(IObjectSaver self, std::string const & filename)"""
        return _fife.IObjectSaver_save(self, filename)


    def __init__(self):
        """__init__(FIFE::IObjectSaver self) -> IObjectSaver"""
        if self.__class__ == IObjectSaver:
            _self = None
        else:
            _self = self
        _fife.IObjectSaver_swiginit(self, _fife.new_IObjectSaver(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectSaver(self)
        return weakref_proxy(self)
IObjectSaver.setAnimationSaver = new_instancemethod(_fife.IObjectSaver_setAnimationSaver, None, IObjectSaver)
IObjectSaver.save = new_instancemethod(_fife.IObjectSaver_save, None, IObjectSaver)
IObjectSaver_swigregister = _fife.IObjectSaver_swigregister
IObjectSaver_swigregister(IObjectSaver)

class MapSaver(IMapSaver):
    """Proxy of C++ FIFE::MapSaver class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::MapSaver self) -> MapSaver"""
        _fife.MapSaver_swiginit(self, _fife.new_MapSaver())
    __swig_destroy__ = _fife.delete_MapSaver

    def setObjectSaver(self, objectSaver):
        """setObjectSaver(MapSaver self, FIFE::ObjectSaverPtr const & objectSaver)"""
        return _fife.MapSaver_setObjectSaver(self, objectSaver)


    def setAnimationSaver(self, animationSaver):
        """setAnimationSaver(MapSaver self, FIFE::AnimationSaverPtr const & animationSaver)"""
        return _fife.MapSaver_setAnimationSaver(self, animationSaver)


    def setAtlasSaver(self, atlasSaver):
        """setAtlasSaver(MapSaver self, FIFE::AtlasSaverPtr const & atlasSaver)"""
        return _fife.MapSaver_setAtlasSaver(self, atlasSaver)


    def save(self, map, filename, importFiles):
        """save(MapSaver self, Map map, std::string const & filename, StringVector importFiles)"""
        return _fife.MapSaver_save(self, map, filename, importFiles)

MapSaver.setObjectSaver = new_instancemethod(_fife.MapSaver_setObjectSaver, None, MapSaver)
MapSaver.setAnimationSaver = new_instancemethod(_fife.MapSaver_setAnimationSaver, None, MapSaver)
MapSaver.setAtlasSaver = new_instancemethod(_fife.MapSaver_setAtlasSaver, None, MapSaver)
MapSaver.save = new_instancemethod(_fife.MapSaver_save, None, MapSaver)
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_CURSOR = _fife.LM_CURSOR
LM_MODULE_MAX = _fife.LM_MODULE_MAX
class moduleVector(object):
    """Proxy of C++ std::vector<(logmodule_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(moduleVector self) -> SwigPyIterator"""
        return _fife.moduleVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(moduleVector self) -> bool"""
        return _fife.moduleVector___nonzero__(self)


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


    def __len__(self):
        """__len__(moduleVector self) -> std::vector< enum logmodule_t >::size_type"""
        return _fife.moduleVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(moduleVector self, std::vector< enum logmodule_t >::difference_type i, std::vector< enum logmodule_t >::difference_type j) -> moduleVector"""
        return _fife.moduleVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(moduleVector self, std::vector< enum logmodule_t >::difference_type i, std::vector< enum logmodule_t >::difference_type j)
        __setslice__(moduleVector 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, i, j):
        """__delslice__(moduleVector self, std::vector< enum logmodule_t >::difference_type i, std::vector< enum logmodule_t >::difference_type j)"""
        return _fife.moduleVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(moduleVector self, std::vector< enum logmodule_t >::difference_type i)
        __delitem__(moduleVector self, PySliceObject * slice)
        """
        return _fife.moduleVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(moduleVector self, PySliceObject * slice) -> moduleVector
        __getitem__(moduleVector self, std::vector< enum logmodule_t >::difference_type i) -> std::vector< enum logmodule_t >::value_type const &
        """
        return _fife.moduleVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(moduleVector self, PySliceObject * slice, moduleVector v)
        __setitem__(moduleVector self, PySliceObject * slice)
        __setitem__(moduleVector self, std::vector< enum logmodule_t >::difference_type i, std::vector< enum logmodule_t >::value_type const & x)
        """
        return _fife.moduleVector___setitem__(self, *args)


    def pop(self):
        """pop(moduleVector self) -> std::vector< enum logmodule_t >::value_type"""
        return _fife.moduleVector_pop(self)


    def append(self, x):
        """append(moduleVector self, std::vector< enum logmodule_t >::value_type const & x)"""
        return _fife.moduleVector_append(self, x)


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


    def size(self):
        """size(moduleVector self) -> std::vector< enum logmodule_t >::size_type"""
        return _fife.moduleVector_size(self)


    def swap(self, v):
        """swap(moduleVector self, moduleVector v)"""
        return _fife.moduleVector_swap(self, v)


    def begin(self):
        """begin(moduleVector self) -> std::vector< enum logmodule_t >::iterator"""
        return _fife.moduleVector_begin(self)


    def end(self):
        """end(moduleVector self) -> std::vector< enum logmodule_t >::iterator"""
        return _fife.moduleVector_end(self)


    def rbegin(self):
        """rbegin(moduleVector self) -> std::vector< enum logmodule_t >::reverse_iterator"""
        return _fife.moduleVector_rbegin(self)


    def rend(self):
        """rend(moduleVector self) -> std::vector< enum logmodule_t >::reverse_iterator"""
        return _fife.moduleVector_rend(self)


    def clear(self):
        """clear(moduleVector self)"""
        return _fife.moduleVector_clear(self)


    def get_allocator(self):
        """get_allocator(moduleVector self) -> std::vector< enum logmodule_t >::allocator_type"""
        return _fife.moduleVector_get_allocator(self)


    def pop_back(self):
        """pop_back(moduleVector self)"""
        return _fife.moduleVector_pop_back(self)


    def erase(self, *args):
        """
        erase(moduleVector self, std::vector< enum logmodule_t >::iterator pos) -> std::vector< enum logmodule_t >::iterator
        erase(moduleVector 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__(std::vector<(logmodule_t)> self) -> moduleVector
        __init__(std::vector<(logmodule_t)> self, moduleVector arg2) -> moduleVector
        __init__(std::vector<(logmodule_t)> self, std::vector< enum logmodule_t >::size_type size) -> moduleVector
        __init__(std::vector<(logmodule_t)> self, std::vector< enum logmodule_t >::size_type size, std::vector< enum logmodule_t >::value_type const & value) -> moduleVector
        """
        _fife.moduleVector_swiginit(self, _fife.new_moduleVector(*args))

    def push_back(self, x):
        """push_back(moduleVector self, std::vector< enum logmodule_t >::value_type const & x)"""
        return _fife.moduleVector_push_back(self, x)


    def front(self):
        """front(moduleVector self) -> std::vector< enum logmodule_t >::value_type const &"""
        return _fife.moduleVector_front(self)


    def back(self):
        """back(moduleVector self) -> std::vector< enum logmodule_t >::value_type const &"""
        return _fife.moduleVector_back(self)


    def assign(self, n, x):
        """assign(moduleVector self, std::vector< enum logmodule_t >::size_type n, std::vector< enum logmodule_t >::value_type const & x)"""
        return _fife.moduleVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(moduleVector self, std::vector< enum logmodule_t >::size_type new_size)
        resize(moduleVector self, std::vector< enum logmodule_t >::size_type new_size, std::vector< enum logmodule_t >::value_type const & x)
        """
        return _fife.moduleVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(moduleVector self, std::vector< enum logmodule_t >::iterator pos, std::vector< enum logmodule_t >::value_type const & x) -> std::vector< enum logmodule_t >::iterator
        insert(moduleVector self, std::vector< enum logmodule_t >::iterator pos, std::vector< enum logmodule_t >::size_type n, std::vector< enum logmodule_t >::value_type const & x)
        """
        return _fife.moduleVector_insert(self, *args)


    def reserve(self, n):
        """reserve(moduleVector self, std::vector< enum logmodule_t >::size_type n)"""
        return _fife.moduleVector_reserve(self, n)


    def capacity(self):
        """capacity(moduleVector self) -> std::vector< enum logmodule_t >::size_type"""
        return _fife.moduleVector_capacity(self)

    __swig_destroy__ = _fife.delete_moduleVector
moduleVector.iterator = new_instancemethod(_fife.moduleVector_iterator, None, moduleVector)
moduleVector.__nonzero__ = new_instancemethod(_fife.moduleVector___nonzero__, None, moduleVector)
moduleVector.__bool__ = new_instancemethod(_fife.moduleVector___bool__, None, moduleVector)
moduleVector.__len__ = new_instancemethod(_fife.moduleVector___len__, None, moduleVector)
moduleVector.__getslice__ = new_instancemethod(_fife.moduleVector___getslice__, None, moduleVector)
moduleVector.__setslice__ = new_instancemethod(_fife.moduleVector___setslice__, None, moduleVector)
moduleVector.__delslice__ = new_instancemethod(_fife.moduleVector___delslice__, None, moduleVector)
moduleVector.__delitem__ = new_instancemethod(_fife.moduleVector___delitem__, None, moduleVector)
moduleVector.__getitem__ = new_instancemethod(_fife.moduleVector___getitem__, None, moduleVector)
moduleVector.__setitem__ = new_instancemethod(_fife.moduleVector___setitem__, None, moduleVector)
moduleVector.pop = new_instancemethod(_fife.moduleVector_pop, None, moduleVector)
moduleVector.append = new_instancemethod(_fife.moduleVector_append, None, moduleVector)
moduleVector.empty = new_instancemethod(_fife.moduleVector_empty, None, moduleVector)
moduleVector.size = new_instancemethod(_fife.moduleVector_size, None, moduleVector)
moduleVector.swap = new_instancemethod(_fife.moduleVector_swap, None, moduleVector)
moduleVector.begin = new_instancemethod(_fife.moduleVector_begin, None, moduleVector)
moduleVector.end = new_instancemethod(_fife.moduleVector_end, None, moduleVector)
moduleVector.rbegin = new_instancemethod(_fife.moduleVector_rbegin, None, moduleVector)
moduleVector.rend = new_instancemethod(_fife.moduleVector_rend, None, moduleVector)
moduleVector.clear = new_instancemethod(_fife.moduleVector_clear, None, moduleVector)
moduleVector.get_allocator = new_instancemethod(_fife.moduleVector_get_allocator, None, moduleVector)
moduleVector.pop_back = new_instancemethod(_fife.moduleVector_pop_back, None, moduleVector)
moduleVector.erase = new_instancemethod(_fife.moduleVector_erase, None, moduleVector)
moduleVector.push_back = new_instancemethod(_fife.moduleVector_push_back, None, moduleVector)
moduleVector.front = new_instancemethod(_fife.moduleVector_front, None, moduleVector)
moduleVector.back = new_instancemethod(_fife.moduleVector_back, None, moduleVector)
moduleVector.assign = new_instancemethod(_fife.moduleVector_assign, None, moduleVector)
moduleVector.resize = new_instancemethod(_fife.moduleVector_resize, None, moduleVector)
moduleVector.insert = new_instancemethod(_fife.moduleVector_insert, None, moduleVector)
moduleVector.reserve = new_instancemethod(_fife.moduleVector_reserve, None, moduleVector)
moduleVector.capacity = new_instancemethod(_fife.moduleVector_capacity, None, moduleVector)
moduleVector_swigregister = _fife.moduleVector_swigregister
moduleVector_swigregister(moduleVector)

class LogManager(object):
    """Proxy of C++ FIFE::LogManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    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

    def log(self, level, module, msg):
        """log(LogManager self, FIFE::LogManager::LogLevel level, logmodule_t module, std::string const & msg)"""
        return _fife.LogManager_log(self, level, module, msg)


    def setLevelFilter(self, level):
        """setLevelFilter(LogManager self, FIFE::LogManager::LogLevel level)"""
        return _fife.LogManager_setLevelFilter(self, level)


    def getLevelFilter(self):
        """getLevelFilter(LogManager self) -> FIFE::LogManager::LogLevel"""
        return _fife.LogManager_getLevelFilter(self)


    def addVisibleModule(self, module):
        """addVisibleModule(LogManager self, logmodule_t module)"""
        return _fife.LogManager_addVisibleModule(self, module)


    def removeVisibleModule(self, module):
        """removeVisibleModule(LogManager self, logmodule_t module)"""
        return _fife.LogManager_removeVisibleModule(self, module)


    def clearVisibleModules(self):
        """clearVisibleModules(LogManager self)"""
        return _fife.LogManager_clearVisibleModules(self)


    def isVisible(self, module):
        """isVisible(LogManager self, logmodule_t module) -> bool"""
        return _fife.LogManager_isVisible(self, module)


    def setLogToPrompt(self, logtoprompt):
        """setLogToPrompt(LogManager self, bool logtoprompt)"""
        return _fife.LogManager_setLogToPrompt(self, logtoprompt)


    def isLogToPrompt(self):
        """isLogToPrompt(LogManager self) -> bool"""
        return _fife.LogManager_isLogToPrompt(self)


    def setLogToFile(self, logtofile):
        """setLogToFile(LogManager self, bool logtofile)"""
        return _fife.LogManager_setLogToFile(self, logtofile)


    def isLogToFile(self):
        """isLogToFile(LogManager self) -> bool"""
        return _fife.LogManager_isLogToFile(self)


    def getModuleName(self, module):
        """getModuleName(LogManager self, logmodule_t module) -> std::string"""
        return _fife.LogManager_getModuleName(self, module)

LogManager.log = new_instancemethod(_fife.LogManager_log, None, LogManager)
LogManager.setLevelFilter = new_instancemethod(_fife.LogManager_setLevelFilter, None, LogManager)
LogManager.getLevelFilter = new_instancemethod(_fife.LogManager_getLevelFilter, None, LogManager)
LogManager.addVisibleModule = new_instancemethod(_fife.LogManager_addVisibleModule, None, LogManager)
LogManager.removeVisibleModule = new_instancemethod(_fife.LogManager_removeVisibleModule, None, LogManager)
LogManager.clearVisibleModules = new_instancemethod(_fife.LogManager_clearVisibleModules, None, LogManager)
LogManager.isVisible = new_instancemethod(_fife.LogManager_isVisible, None, LogManager)
LogManager.setLogToPrompt = new_instancemethod(_fife.LogManager_setLogToPrompt, None, LogManager)
LogManager.isLogToPrompt = new_instancemethod(_fife.LogManager_isLogToPrompt, None, LogManager)
LogManager.setLogToFile = new_instancemethod(_fife.LogManager_setLogToFile, None, LogManager)
LogManager.isLogToFile = new_instancemethod(_fife.LogManager_isLogToFile, None, LogManager)
LogManager.getModuleName = new_instancemethod(_fife.LogManager_getModuleName, None, LogManager)
LogManager_swigregister = _fife.LogManager_swigregister
LogManager_swigregister(LogManager)

class Logger(object):
    """Proxy of C++ FIFE::Logger class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, module):
        """__init__(FIFE::Logger self, logmodule_t module) -> Logger"""
        _fife.Logger_swiginit(self, _fife.new_Logger(module))
    __swig_destroy__ = _fife.delete_Logger

    def log(self, level, msg):
        """log(Logger self, FIFE::LogManager::LogLevel level, std::string const & msg)"""
        return _fife.Logger_log(self, level, msg)

Logger.log = new_instancemethod(_fife.Logger_log, None, Logger)
Logger_swigregister = _fife.Logger_swigregister
Logger_swigregister(Logger)


def getAngleBetween(*args):
    """
    getAngleBetween(Location loc1, Location loc2) -> int32_t
    getAngleBetween(DoublePoint3D emc1, DoublePoint3D emc2) -> int32_t
    """
    return _fife.getAngleBetween(*args)

def getFacing(*args):
    """
    getFacing(Location loc, int32_t const angle) -> Location
    getFacing(DoublePoint3D emc, int32_t const angle) -> DoublePoint3D
    """
    return _fife.getFacing(*args)
class Mathf(object):
    """Proxy of C++ FIFE::Math<(float)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def epsilon():
        """epsilon() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_epsilon()

    epsilon = staticmethod(epsilon)

    def zeroTolerance():
        """zeroTolerance() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_zeroTolerance()

    zeroTolerance = staticmethod(zeroTolerance)

    def max():
        """max() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_max()

    max = staticmethod(max)

    def pi():
        """pi() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_pi()

    pi = staticmethod(pi)

    def twoPi():
        """twoPi() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_twoPi()

    twoPi = staticmethod(twoPi)

    def halfPi():
        """halfPi() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_halfPi()

    halfPi = staticmethod(halfPi)

    def inversePi():
        """inversePi() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_inversePi()

    inversePi = staticmethod(inversePi)

    def inverseTwoPi():
        """inverseTwoPi() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_inverseTwoPi()

    inverseTwoPi = staticmethod(inverseTwoPi)

    def degToRad():
        """degToRad() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_degToRad()

    degToRad = staticmethod(degToRad)

    def radToDeg():
        """radToDeg() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_radToDeg()

    radToDeg = staticmethod(radToDeg)

    def log2():
        """log2() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_log2()

    log2 = staticmethod(log2)

    def log10():
        """log10() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_log10()

    log10 = staticmethod(log10)

    def invLog2():
        """invLog2() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_invLog2()

    invLog2 = staticmethod(invLog2)

    def invLog10():
        """invLog10() -> FIFE::Math< float >::num_type"""
        return _fife.Mathf_invLog10()

    invLog10 = staticmethod(invLog10)

    def ACos(_val):
        """ACos(float _val) -> float"""
        return _fife.Mathf_ACos(_val)

    ACos = staticmethod(ACos)

    def ASin(_val):
        """ASin(float _val) -> float"""
        return _fife.Mathf_ASin(_val)

    ASin = staticmethod(ASin)

    def ATan(_val):
        """ATan(float _val) -> float"""
        return _fife.Mathf_ATan(_val)

    ATan = staticmethod(ATan)

    def ATan2(_x, _y):
        """ATan2(float _x, float _y) -> float"""
        return _fife.Mathf_ATan2(_x, _y)

    ATan2 = staticmethod(ATan2)

    def Ceil(_val):
        """Ceil(float _val) -> float"""
        return _fife.Mathf_Ceil(_val)

    Ceil = staticmethod(Ceil)

    def Cos(_val):
        """Cos(float _val) -> float"""
        return _fife.Mathf_Cos(_val)

    Cos = staticmethod(Cos)

    def Exp(_val):
        """Exp(float _val) -> float"""
        return _fife.Mathf_Exp(_val)

    Exp = staticmethod(Exp)

    def FAbs(_val):
        """FAbs(float _val) -> float"""
        return _fife.Mathf_FAbs(_val)

    FAbs = staticmethod(FAbs)

    def Floor(_val):
        """Floor(float _val) -> float"""
        return _fife.Mathf_Floor(_val)

    Floor = staticmethod(Floor)

    def FMod(_x, _y):
        """FMod(float _x, float _y) -> float"""
        return _fife.Mathf_FMod(_x, _y)

    FMod = staticmethod(FMod)

    def InvSqrt(_val):
        """InvSqrt(float _val) -> float"""
        return _fife.Mathf_InvSqrt(_val)

    InvSqrt = staticmethod(InvSqrt)

    def Log(_val):
        """Log(float _val) -> float"""
        return _fife.Mathf_Log(_val)

    Log = staticmethod(Log)

    def Log2(_val):
        """Log2(float _val) -> float"""
        return _fife.Mathf_Log2(_val)

    Log2 = staticmethod(Log2)

    def Log10(_val):
        """Log10(float _val) -> float"""
        return _fife.Mathf_Log10(_val)

    Log10 = staticmethod(Log10)

    def Pow(_base, _exponent):
        """Pow(float _base, float _exponent) -> float"""
        return _fife.Mathf_Pow(_base, _exponent)

    Pow = staticmethod(Pow)

    def Sin(_val):
        """Sin(float _val) -> float"""
        return _fife.Mathf_Sin(_val)

    Sin = staticmethod(Sin)

    def Sqr(_val):
        """Sqr(float _val) -> float"""
        return _fife.Mathf_Sqr(_val)

    Sqr = staticmethod(Sqr)

    def Sqrt(_val):
        """Sqrt(float _val) -> float"""
        return _fife.Mathf_Sqrt(_val)

    Sqrt = staticmethod(Sqrt)

    def Tan(_val):
        """Tan(float _val) -> float"""
        return _fife.Mathf_Tan(_val)

    Tan = staticmethod(Tan)

    def __init__(self):
        """__init__(FIFE::Math<(float)> self) -> Mathf"""
        _fife.Mathf_swiginit(self, _fife.new_Mathf())
    __swig_destroy__ = _fife.delete_Mathf
Mathf_swigregister = _fife.Mathf_swigregister
Mathf_swigregister(Mathf)

def Mathf_epsilon():
    """Mathf_epsilon() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_epsilon()

def Mathf_zeroTolerance():
    """Mathf_zeroTolerance() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_zeroTolerance()

def Mathf_max():
    """Mathf_max() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_max()

def Mathf_pi():
    """Mathf_pi() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_pi()

def Mathf_twoPi():
    """Mathf_twoPi() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_twoPi()

def Mathf_halfPi():
    """Mathf_halfPi() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_halfPi()

def Mathf_inversePi():
    """Mathf_inversePi() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_inversePi()

def Mathf_inverseTwoPi():
    """Mathf_inverseTwoPi() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_inverseTwoPi()

def Mathf_degToRad():
    """Mathf_degToRad() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_degToRad()

def Mathf_radToDeg():
    """Mathf_radToDeg() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_radToDeg()

def Mathf_log2():
    """Mathf_log2() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_log2()

def Mathf_log10():
    """Mathf_log10() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_log10()

def Mathf_invLog2():
    """Mathf_invLog2() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_invLog2()

def Mathf_invLog10():
    """Mathf_invLog10() -> FIFE::Math< float >::num_type"""
    return _fife.Mathf_invLog10()

def Mathf_ACos(_val):
    """Mathf_ACos(float _val) -> float"""
    return _fife.Mathf_ACos(_val)

def Mathf_ASin(_val):
    """Mathf_ASin(float _val) -> float"""
    return _fife.Mathf_ASin(_val)

def Mathf_ATan(_val):
    """Mathf_ATan(float _val) -> float"""
    return _fife.Mathf_ATan(_val)

def Mathf_ATan2(_x, _y):
    """Mathf_ATan2(float _x, float _y) -> float"""
    return _fife.Mathf_ATan2(_x, _y)

def Mathf_Ceil(_val):
    """Mathf_Ceil(float _val) -> float"""
    return _fife.Mathf_Ceil(_val)

def Mathf_Cos(_val):
    """Mathf_Cos(float _val) -> float"""
    return _fife.Mathf_Cos(_val)

def Mathf_Exp(_val):
    """Mathf_Exp(float _val) -> float"""
    return _fife.Mathf_Exp(_val)

def Mathf_FAbs(_val):
    """Mathf_FAbs(float _val) -> float"""
    return _fife.Mathf_FAbs(_val)

def Mathf_Floor(_val):
    """Mathf_Floor(float _val) -> float"""
    return _fife.Mathf_Floor(_val)

def Mathf_FMod(_x, _y):
    """Mathf_FMod(float _x, float _y) -> float"""
    return _fife.Mathf_FMod(_x, _y)

def Mathf_InvSqrt(_val):
    """Mathf_InvSqrt(float _val) -> float"""
    return _fife.Mathf_InvSqrt(_val)

def Mathf_Log(_val):
    """Mathf_Log(float _val) -> float"""
    return _fife.Mathf_Log(_val)

def Mathf_Log2(_val):
    """Mathf_Log2(float _val) -> float"""
    return _fife.Mathf_Log2(_val)

def Mathf_Log10(_val):
    """Mathf_Log10(float _val) -> float"""
    return _fife.Mathf_Log10(_val)

def Mathf_Pow(_base, _exponent):
    """Mathf_Pow(float _base, float _exponent) -> float"""
    return _fife.Mathf_Pow(_base, _exponent)

def Mathf_Sin(_val):
    """Mathf_Sin(float _val) -> float"""
    return _fife.Mathf_Sin(_val)

def Mathf_Sqr(_val):
    """Mathf_Sqr(float _val) -> float"""
    return _fife.Mathf_Sqr(_val)

def Mathf_Sqrt(_val):
    """Mathf_Sqrt(float _val) -> float"""
    return _fife.Mathf_Sqrt(_val)

def Mathf_Tan(_val):
    """Mathf_Tan(float _val) -> float"""
    return _fife.Mathf_Tan(_val)

class Mathd(object):
    """Proxy of C++ FIFE::Math<(double)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def epsilon():
        """epsilon() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_epsilon()

    epsilon = staticmethod(epsilon)

    def zeroTolerance():
        """zeroTolerance() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_zeroTolerance()

    zeroTolerance = staticmethod(zeroTolerance)

    def max():
        """max() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_max()

    max = staticmethod(max)

    def pi():
        """pi() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_pi()

    pi = staticmethod(pi)

    def twoPi():
        """twoPi() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_twoPi()

    twoPi = staticmethod(twoPi)

    def halfPi():
        """halfPi() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_halfPi()

    halfPi = staticmethod(halfPi)

    def inversePi():
        """inversePi() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_inversePi()

    inversePi = staticmethod(inversePi)

    def inverseTwoPi():
        """inverseTwoPi() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_inverseTwoPi()

    inverseTwoPi = staticmethod(inverseTwoPi)

    def degToRad():
        """degToRad() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_degToRad()

    degToRad = staticmethod(degToRad)

    def radToDeg():
        """radToDeg() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_radToDeg()

    radToDeg = staticmethod(radToDeg)

    def log2():
        """log2() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_log2()

    log2 = staticmethod(log2)

    def log10():
        """log10() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_log10()

    log10 = staticmethod(log10)

    def invLog2():
        """invLog2() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_invLog2()

    invLog2 = staticmethod(invLog2)

    def invLog10():
        """invLog10() -> FIFE::Math< double >::num_type"""
        return _fife.Mathd_invLog10()

    invLog10 = staticmethod(invLog10)

    def ACos(_val):
        """ACos(double _val) -> double"""
        return _fife.Mathd_ACos(_val)

    ACos = staticmethod(ACos)

    def ASin(_val):
        """ASin(double _val) -> double"""
        return _fife.Mathd_ASin(_val)

    ASin = staticmethod(ASin)

    def ATan(_val):
        """ATan(double _val) -> double"""
        return _fife.Mathd_ATan(_val)

    ATan = staticmethod(ATan)

    def ATan2(_x, _y):
        """ATan2(double _x, double _y) -> double"""
        return _fife.Mathd_ATan2(_x, _y)

    ATan2 = staticmethod(ATan2)

    def Ceil(_val):
        """Ceil(double _val) -> double"""
        return _fife.Mathd_Ceil(_val)

    Ceil = staticmethod(Ceil)

    def Cos(_val):
        """Cos(double _val) -> double"""
        return _fife.Mathd_Cos(_val)

    Cos = staticmethod(Cos)

    def Exp(_val):
        """Exp(double _val) -> double"""
        return _fife.Mathd_Exp(_val)

    Exp = staticmethod(Exp)

    def FAbs(_val):
        """FAbs(double _val) -> double"""
        return _fife.Mathd_FAbs(_val)

    FAbs = staticmethod(FAbs)

    def Floor(_val):
        """Floor(double _val) -> double"""
        return _fife.Mathd_Floor(_val)

    Floor = staticmethod(Floor)

    def FMod(_x, _y):
        """FMod(double _x, double _y) -> double"""
        return _fife.Mathd_FMod(_x, _y)

    FMod = staticmethod(FMod)

    def InvSqrt(_val):
        """InvSqrt(double _val) -> double"""
        return _fife.Mathd_InvSqrt(_val)

    InvSqrt = staticmethod(InvSqrt)

    def Log(_val):
        """Log(double _val) -> double"""
        return _fife.Mathd_Log(_val)

    Log = staticmethod(Log)

    def Log2(_val):
        """Log2(double _val) -> double"""
        return _fife.Mathd_Log2(_val)

    Log2 = staticmethod(Log2)

    def Log10(_val):
        """Log10(double _val) -> double"""
        return _fife.Mathd_Log10(_val)

    Log10 = staticmethod(Log10)

    def Pow(_base, _exponent):
        """Pow(double _base, double _exponent) -> double"""
        return _fife.Mathd_Pow(_base, _exponent)

    Pow = staticmethod(Pow)

    def Sin(_val):
        """Sin(double _val) -> double"""
        return _fife.Mathd_Sin(_val)

    Sin = staticmethod(Sin)

    def Sqr(_val):
        """Sqr(double _val) -> double"""
        return _fife.Mathd_Sqr(_val)

    Sqr = staticmethod(Sqr)

    def Sqrt(_val):
        """Sqrt(double _val) -> double"""
        return _fife.Mathd_Sqrt(_val)

    Sqrt = staticmethod(Sqrt)

    def Tan(_val):
        """Tan(double _val) -> double"""
        return _fife.Mathd_Tan(_val)

    Tan = staticmethod(Tan)

    def __init__(self):
        """__init__(FIFE::Math<(double)> self) -> Mathd"""
        _fife.Mathd_swiginit(self, _fife.new_Mathd())
    __swig_destroy__ = _fife.delete_Mathd
Mathd_swigregister = _fife.Mathd_swigregister
Mathd_swigregister(Mathd)

def Mathd_epsilon():
    """Mathd_epsilon() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_epsilon()

def Mathd_zeroTolerance():
    """Mathd_zeroTolerance() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_zeroTolerance()

def Mathd_max():
    """Mathd_max() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_max()

def Mathd_pi():
    """Mathd_pi() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_pi()

def Mathd_twoPi():
    """Mathd_twoPi() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_twoPi()

def Mathd_halfPi():
    """Mathd_halfPi() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_halfPi()

def Mathd_inversePi():
    """Mathd_inversePi() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_inversePi()

def Mathd_inverseTwoPi():
    """Mathd_inverseTwoPi() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_inverseTwoPi()

def Mathd_degToRad():
    """Mathd_degToRad() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_degToRad()

def Mathd_radToDeg():
    """Mathd_radToDeg() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_radToDeg()

def Mathd_log2():
    """Mathd_log2() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_log2()

def Mathd_log10():
    """Mathd_log10() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_log10()

def Mathd_invLog2():
    """Mathd_invLog2() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_invLog2()

def Mathd_invLog10():
    """Mathd_invLog10() -> FIFE::Math< double >::num_type"""
    return _fife.Mathd_invLog10()

def Mathd_ACos(_val):
    """Mathd_ACos(double _val) -> double"""
    return _fife.Mathd_ACos(_val)

def Mathd_ASin(_val):
    """Mathd_ASin(double _val) -> double"""
    return _fife.Mathd_ASin(_val)

def Mathd_ATan(_val):
    """Mathd_ATan(double _val) -> double"""
    return _fife.Mathd_ATan(_val)

def Mathd_ATan2(_x, _y):
    """Mathd_ATan2(double _x, double _y) -> double"""
    return _fife.Mathd_ATan2(_x, _y)

def Mathd_Ceil(_val):
    """Mathd_Ceil(double _val) -> double"""
    return _fife.Mathd_Ceil(_val)

def Mathd_Cos(_val):
    """Mathd_Cos(double _val) -> double"""
    return _fife.Mathd_Cos(_val)

def Mathd_Exp(_val):
    """Mathd_Exp(double _val) -> double"""
    return _fife.Mathd_Exp(_val)

def Mathd_FAbs(_val):
    """Mathd_FAbs(double _val) -> double"""
    return _fife.Mathd_FAbs(_val)

def Mathd_Floor(_val):
    """Mathd_Floor(double _val) -> double"""
    return _fife.Mathd_Floor(_val)

def Mathd_FMod(_x, _y):
    """Mathd_FMod(double _x, double _y) -> double"""
    return _fife.Mathd_FMod(_x, _y)

def Mathd_InvSqrt(_val):
    """Mathd_InvSqrt(double _val) -> double"""
    return _fife.Mathd_InvSqrt(_val)

def Mathd_Log(_val):
    """Mathd_Log(double _val) -> double"""
    return _fife.Mathd_Log(_val)

def Mathd_Log2(_val):
    """Mathd_Log2(double _val) -> double"""
    return _fife.Mathd_Log2(_val)

def Mathd_Log10(_val):
    """Mathd_Log10(double _val) -> double"""
    return _fife.Mathd_Log10(_val)

def Mathd_Pow(_base, _exponent):
    """Mathd_Pow(double _base, double _exponent) -> double"""
    return _fife.Mathd_Pow(_base, _exponent)

def Mathd_Sin(_val):
    """Mathd_Sin(double _val) -> double"""
    return _fife.Mathd_Sin(_val)

def Mathd_Sqr(_val):
    """Mathd_Sqr(double _val) -> double"""
    return _fife.Mathd_Sqr(_val)

def Mathd_Sqrt(_val):
    """Mathd_Sqrt(double _val) -> double"""
    return _fife.Mathd_Sqrt(_val)

def Mathd_Tan(_val):
    """Mathd_Tan(double _val) -> double"""
    return _fife.Mathd_Tan(_val)

class TimeEvent(object):
    """Proxy of C++ FIFE::TimeEvent class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, period=-1):
        """__init__(FIFE::TimeEvent self, int32_t period=-1) -> TimeEvent"""
        if self.__class__ == TimeEvent:
            _self = None
        else:
            _self = self
        _fife.TimeEvent_swiginit(self, _fife.new_TimeEvent(_self, period))
    __swig_destroy__ = _fife.delete_TimeEvent

    def updateEvent(self, time):
        """updateEvent(TimeEvent self, uint32_t time)"""
        return _fife.TimeEvent_updateEvent(self, time)


    def setPeriod(self, period):
        """setPeriod(TimeEvent self, int32_t period)"""
        return _fife.TimeEvent_setPeriod(self, period)


    def getPeriod(self):
        """getPeriod(TimeEvent self) -> int32_t"""
        return _fife.TimeEvent_getPeriod(self)


    def getLastUpdateTime(self):
        """getLastUpdateTime(TimeEvent self) -> uint32_t"""
        return _fife.TimeEvent_getLastUpdateTime(self)


    def setLastUpdateTime(self, arg2):
        """setLastUpdateTime(TimeEvent self, uint32_t arg2)"""
        return _fife.TimeEvent_setLastUpdateTime(self, arg2)

    def __disown__(self):
        self.this.disown()
        _fife.disown_TimeEvent(self)
        return weakref_proxy(self)
TimeEvent.updateEvent = new_instancemethod(_fife.TimeEvent_updateEvent, None, TimeEvent)
TimeEvent.setPeriod = new_instancemethod(_fife.TimeEvent_setPeriod, None, TimeEvent)
TimeEvent.getPeriod = new_instancemethod(_fife.TimeEvent_getPeriod, None, TimeEvent)
TimeEvent.getLastUpdateTime = new_instancemethod(_fife.TimeEvent_getLastUpdateTime, None, TimeEvent)
TimeEvent.setLastUpdateTime = new_instancemethod(_fife.TimeEvent_setLastUpdateTime, None, TimeEvent)
TimeEvent_swigregister = _fife.TimeEvent_swigregister
TimeEvent_swigregister(TimeEvent)

class TimeManager(object):
    """Proxy of C++ FIFE::TimeManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::TimeManager self) -> TimeManager"""
        _fife.TimeManager_swiginit(self, _fife.new_TimeManager())
    __swig_destroy__ = _fife.delete_TimeManager

    def update(self):
        """update(TimeManager self)"""
        return _fife.TimeManager_update(self)


    def getTime(self):
        """getTime(TimeManager self) -> uint32_t"""
        return _fife.TimeManager_getTime(self)


    def getTimeDelta(self):
        """getTimeDelta(TimeManager self) -> uint32_t"""
        return _fife.TimeManager_getTimeDelta(self)


    def getAverageFrameTime(self):
        """getAverageFrameTime(TimeManager self) -> double"""
        return _fife.TimeManager_getAverageFrameTime(self)


    def printStatistics(self):
        """printStatistics(TimeManager self)"""
        return _fife.TimeManager_printStatistics(self)


    def registerEvent(self, event):
        """registerEvent(TimeManager self, TimeEvent event)"""
        return _fife.TimeManager_registerEvent(self, event)


    def unregisterEvent(self, event):
        """unregisterEvent(TimeManager self, TimeEvent event)"""
        return _fife.TimeManager_unregisterEvent(self, event)

TimeManager.update = new_instancemethod(_fife.TimeManager_update, None, TimeManager)
TimeManager.getTime = new_instancemethod(_fife.TimeManager_getTime, None, TimeManager)
TimeManager.getTimeDelta = new_instancemethod(_fife.TimeManager_getTimeDelta, None, TimeManager)
TimeManager.getAverageFrameTime = new_instancemethod(_fife.TimeManager_getAverageFrameTime, None, TimeManager)
TimeManager.printStatistics = new_instancemethod(_fife.TimeManager_printStatistics, None, TimeManager)
TimeManager.registerEvent = new_instancemethod(_fife.TimeManager_registerEvent, None, TimeManager)
TimeManager.unregisterEvent = new_instancemethod(_fife.TimeManager_unregisterEvent, None, TimeManager)
TimeManager_swigregister = _fife.TimeManager_swigregister
TimeManager_swigregister(TimeManager)

class RawDataSource(object):
    """Proxy of C++ FIFE::RawDataSource class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RawDataSource

    def getSize(self):
        """getSize(RawDataSource self) -> uint32_t"""
        return _fife.RawDataSource_getSize(self)


    def readInto(self, buffer, start, length):
        """readInto(RawDataSource self, uint8_t * buffer, uint32_t start, uint32_t length)"""
        return _fife.RawDataSource_readInto(self, buffer, start, length)

RawDataSource.getSize = new_instancemethod(_fife.RawDataSource_getSize, None, RawDataSource)
RawDataSource.readInto = new_instancemethod(_fife.RawDataSource_readInto, None, RawDataSource)
RawDataSource_swigregister = _fife.RawDataSource_swigregister
RawDataSource_swigregister(RawDataSource)

class RawData(object):
    """Proxy of C++ FIFE::RawData class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, datasource):
        """__init__(FIFE::RawData self, RawDataSource datasource) -> RawData"""
        _fife.RawData_swiginit(self, _fife.new_RawData(datasource))
    __swig_destroy__ = _fife.delete_RawData

    def getDataInBytes(self):
        """getDataInBytes(RawData self) -> vectoru"""
        return _fife.RawData_getDataInBytes(self)


    def getDataInLines(self):
        """getDataInLines(RawData self) -> StringVector"""
        return _fife.RawData_getDataInLines(self)


    def getDataLength(self):
        """getDataLength(RawData self) -> uint32_t"""
        return _fife.RawData_getDataLength(self)


    def getCurrentIndex(self):
        """getCurrentIndex(RawData self) -> uint32_t"""
        return _fife.RawData_getCurrentIndex(self)


    def setIndex(self, index):
        """setIndex(RawData self, uint32_t index)"""
        return _fife.RawData_setIndex(self, index)


    def moveIndex(self, offset):
        """moveIndex(RawData self, int32_t offset)"""
        return _fife.RawData_moveIndex(self, offset)


    def readInto(self, len):
        """readInto(RawData self, size_t len)"""
        return _fife.RawData_readInto(self, len)


    def read8(self):
        """read8(RawData self) -> uint8_t"""
        return _fife.RawData_read8(self)


    def read16Little(self):
        """read16Little(RawData self) -> uint16_t"""
        return _fife.RawData_read16Little(self)


    def read32Little(self):
        """read32Little(RawData self) -> uint32_t"""
        return _fife.RawData_read32Little(self)


    def read16Big(self):
        """read16Big(RawData self) -> uint16_t"""
        return _fife.RawData_read16Big(self)


    def read32Big(self):
        """read32Big(RawData self) -> uint32_t"""
        return _fife.RawData_read32Big(self)


    def read(self, size=-1):
        """read(RawData self, int32_t size=-1)"""
        return _fife.RawData_read(self, size)


    def readString(self, len):
        """readString(RawData self, size_t len) -> std::string"""
        return _fife.RawData_readString(self, len)


    def getLine(self, buffer):
        """getLine(RawData self, std::string & buffer) -> bool"""
        return _fife.RawData_getLine(self, buffer)

RawData.getDataInBytes = new_instancemethod(_fife.RawData_getDataInBytes, None, RawData)
RawData.getDataInLines = new_instancemethod(_fife.RawData_getDataInLines, None, RawData)
RawData.getDataLength = new_instancemethod(_fife.RawData_getDataLength, None, RawData)
RawData.getCurrentIndex = new_instancemethod(_fife.RawData_getCurrentIndex, None, RawData)
RawData.setIndex = new_instancemethod(_fife.RawData_setIndex, None, RawData)
RawData.moveIndex = new_instancemethod(_fife.RawData_moveIndex, None, RawData)
RawData.readInto = new_instancemethod(_fife.RawData_readInto, None, RawData)
RawData.read8 = new_instancemethod(_fife.RawData_read8, None, RawData)
RawData.read16Little = new_instancemethod(_fife.RawData_read16Little, None, RawData)
RawData.read32Little = new_instancemethod(_fife.RawData_read32Little, None, RawData)
RawData.read16Big = new_instancemethod(_fife.RawData_read16Big, None, RawData)
RawData.read32Big = new_instancemethod(_fife.RawData_read32Big, None, RawData)
RawData.read = new_instancemethod(_fife.RawData_read, None, RawData)
RawData.readString = new_instancemethod(_fife.RawData_readString, None, RawData)
RawData.getLine = new_instancemethod(_fife.RawData_getLine, None, RawData)
RawData_swigregister = _fife.RawData_swigregister
RawData_swigregister(RawData)

class StringSet(object):
    """Proxy of C++ std::set<(std::string)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(StringSet self) -> SwigPyIterator"""
        return _fife.StringSet_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(StringSet self) -> bool"""
        return _fife.StringSet___nonzero__(self)


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


    def __len__(self):
        """__len__(StringSet self) -> std::set< std::string >::size_type"""
        return _fife.StringSet___len__(self)


    def append(self, x):
        """append(StringSet self, std::set< std::string >::value_type x)"""
        return _fife.StringSet_append(self, x)


    def __contains__(self, x):
        """__contains__(StringSet self, std::set< std::string >::value_type x) -> bool"""
        return _fife.StringSet___contains__(self, x)


    def __getitem__(self, i):
        """__getitem__(StringSet self, std::set< std::string >::difference_type i) -> std::set< std::string >::value_type"""
        return _fife.StringSet___getitem__(self, i)


    def add(self, x):
        """add(StringSet self, std::set< std::string >::value_type x)"""
        return _fife.StringSet_add(self, x)


    def discard(self, x):
        """discard(StringSet self, std::set< std::string >::value_type x)"""
        return _fife.StringSet_discard(self, x)


    def __init__(self, *args):
        """
        __init__(std::set<(std::string)> self, std::less< std::string > const & arg2) -> StringSet
        __init__(std::set<(std::string)> self) -> StringSet
        __init__(std::set<(std::string)> self, StringSet arg2) -> StringSet
        """
        _fife.StringSet_swiginit(self, _fife.new_StringSet(*args))

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


    def size(self):
        """size(StringSet self) -> std::set< std::string >::size_type"""
        return _fife.StringSet_size(self)


    def clear(self):
        """clear(StringSet self)"""
        return _fife.StringSet_clear(self)


    def swap(self, v):
        """swap(StringSet self, StringSet v)"""
        return _fife.StringSet_swap(self, v)


    def count(self, x):
        """count(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type"""
        return _fife.StringSet_count(self, x)


    def begin(self):
        """begin(StringSet self) -> std::set< std::string >::iterator"""
        return _fife.StringSet_begin(self)


    def end(self):
        """end(StringSet self) -> std::set< std::string >::iterator"""
        return _fife.StringSet_end(self)


    def rbegin(self):
        """rbegin(StringSet self) -> std::set< std::string >::reverse_iterator"""
        return _fife.StringSet_rbegin(self)


    def rend(self):
        """rend(StringSet self) -> std::set< std::string >::reverse_iterator"""
        return _fife.StringSet_rend(self)


    def erase(self, *args):
        """
        erase(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::size_type
        erase(StringSet self, std::set< std::string >::iterator pos)
        erase(StringSet self, std::set< std::string >::iterator first, std::set< std::string >::iterator last)
        """
        return _fife.StringSet_erase(self, *args)


    def find(self, x):
        """find(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator"""
        return _fife.StringSet_find(self, x)


    def lower_bound(self, x):
        """lower_bound(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator"""
        return _fife.StringSet_lower_bound(self, x)


    def upper_bound(self, x):
        """upper_bound(StringSet self, std::set< std::string >::key_type const & x) -> std::set< std::string >::iterator"""
        return _fife.StringSet_upper_bound(self, x)


    def equal_range(self, x):
        """equal_range(StringSet self, std::set< std::string >::key_type const & x) -> std::pair< std::set< std::string >::iterator,std::set< std::string >::iterator >"""
        return _fife.StringSet_equal_range(self, x)


    def insert(self, __x):
        """insert(StringSet self, std::set< std::string >::value_type const & __x) -> std::pair< std::set< std::string >::iterator,bool >"""
        return _fife.StringSet_insert(self, __x)

    __swig_destroy__ = _fife.delete_StringSet
StringSet.iterator = new_instancemethod(_fife.StringSet_iterator, None, StringSet)
StringSet.__nonzero__ = new_instancemethod(_fife.StringSet___nonzero__, None, StringSet)
StringSet.__bool__ = new_instancemethod(_fife.StringSet___bool__, None, StringSet)
StringSet.__len__ = new_instancemethod(_fife.StringSet___len__, None, StringSet)
StringSet.append = new_instancemethod(_fife.StringSet_append, None, StringSet)
StringSet.__contains__ = new_instancemethod(_fife.StringSet___contains__, None, StringSet)
StringSet.__getitem__ = new_instancemethod(_fife.StringSet___getitem__, None, StringSet)
StringSet.add = new_instancemethod(_fife.StringSet_add, None, StringSet)
StringSet.discard = new_instancemethod(_fife.StringSet_discard, None, StringSet)
StringSet.empty = new_instancemethod(_fife.StringSet_empty, None, StringSet)
StringSet.size = new_instancemethod(_fife.StringSet_size, None, StringSet)
StringSet.clear = new_instancemethod(_fife.StringSet_clear, None, StringSet)
StringSet.swap = new_instancemethod(_fife.StringSet_swap, None, StringSet)
StringSet.count = new_instancemethod(_fife.StringSet_count, None, StringSet)
StringSet.begin = new_instancemethod(_fife.StringSet_begin, None, StringSet)
StringSet.end = new_instancemethod(_fife.StringSet_end, None, StringSet)
StringSet.rbegin = new_instancemethod(_fife.StringSet_rbegin, None, StringSet)
StringSet.rend = new_instancemethod(_fife.StringSet_rend, None, StringSet)
StringSet.erase = new_instancemethod(_fife.StringSet_erase, None, StringSet)
StringSet.find = new_instancemethod(_fife.StringSet_find, None, StringSet)
StringSet.lower_bound = new_instancemethod(_fife.StringSet_lower_bound, None, StringSet)
StringSet.upper_bound = new_instancemethod(_fife.StringSet_upper_bound, None, StringSet)
StringSet.equal_range = new_instancemethod(_fife.StringSet_equal_range, None, StringSet)
StringSet.insert = new_instancemethod(_fife.StringSet_insert, None, StringSet)
StringSet_swigregister = _fife.StringSet_swigregister
StringSet_swigregister(StringSet)

class vectoru(object):
    """Proxy of C++ std::vector<(uint8_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(vectoru self) -> SwigPyIterator"""
        return _fife.vectoru_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(vectoru self) -> bool"""
        return _fife.vectoru___nonzero__(self)


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


    def __len__(self):
        """__len__(vectoru self) -> std::vector< unsigned char >::size_type"""
        return _fife.vectoru___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(vectoru self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j) -> vectoru"""
        return _fife.vectoru___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(vectoru self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)
        __setslice__(vectoru 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, i, j):
        """__delslice__(vectoru self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)"""
        return _fife.vectoru___delslice__(self, i, j)


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


    def __getitem__(self, *args):
        """
        __getitem__(vectoru self, PySliceObject * slice) -> vectoru
        __getitem__(vectoru self, std::vector< unsigned char >::difference_type i) -> std::vector< unsigned char >::value_type const &
        """
        return _fife.vectoru___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(vectoru self, PySliceObject * slice, vectoru v)
        __setitem__(vectoru self, PySliceObject * slice)
        __setitem__(vectoru self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::value_type const & x)
        """
        return _fife.vectoru___setitem__(self, *args)


    def pop(self):
        """pop(vectoru self) -> std::vector< unsigned char >::value_type"""
        return _fife.vectoru_pop(self)


    def append(self, x):
        """append(vectoru self, std::vector< unsigned char >::value_type const & x)"""
        return _fife.vectoru_append(self, x)


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


    def size(self):
        """size(vectoru self) -> std::vector< unsigned char >::size_type"""
        return _fife.vectoru_size(self)


    def swap(self, v):
        """swap(vectoru self, vectoru v)"""
        return _fife.vectoru_swap(self, v)


    def begin(self):
        """begin(vectoru self) -> std::vector< unsigned char >::iterator"""
        return _fife.vectoru_begin(self)


    def end(self):
        """end(vectoru self) -> std::vector< unsigned char >::iterator"""
        return _fife.vectoru_end(self)


    def rbegin(self):
        """rbegin(vectoru self) -> std::vector< unsigned char >::reverse_iterator"""
        return _fife.vectoru_rbegin(self)


    def rend(self):
        """rend(vectoru self) -> std::vector< unsigned char >::reverse_iterator"""
        return _fife.vectoru_rend(self)


    def clear(self):
        """clear(vectoru self)"""
        return _fife.vectoru_clear(self)


    def get_allocator(self):
        """get_allocator(vectoru self) -> std::vector< unsigned char >::allocator_type"""
        return _fife.vectoru_get_allocator(self)


    def pop_back(self):
        """pop_back(vectoru self)"""
        return _fife.vectoru_pop_back(self)


    def erase(self, *args):
        """
        erase(vectoru self, std::vector< unsigned char >::iterator pos) -> std::vector< unsigned char >::iterator
        erase(vectoru 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__(std::vector<(uint8_t)> self) -> vectoru
        __init__(std::vector<(uint8_t)> self, vectoru arg2) -> vectoru
        __init__(std::vector<(uint8_t)> self, std::vector< unsigned char >::size_type size) -> vectoru
        __init__(std::vector<(uint8_t)> self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> vectoru
        """
        _fife.vectoru_swiginit(self, _fife.new_vectoru(*args))

    def push_back(self, x):
        """push_back(vectoru self, std::vector< unsigned char >::value_type const & x)"""
        return _fife.vectoru_push_back(self, x)


    def front(self):
        """front(vectoru self) -> std::vector< unsigned char >::value_type const &"""
        return _fife.vectoru_front(self)


    def back(self):
        """back(vectoru self) -> std::vector< unsigned char >::value_type const &"""
        return _fife.vectoru_back(self)


    def assign(self, n, x):
        """assign(vectoru self, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)"""
        return _fife.vectoru_assign(self, n, x)


    def resize(self, *args):
        """
        resize(vectoru self, std::vector< unsigned char >::size_type new_size)
        resize(vectoru self, std::vector< unsigned char >::size_type new_size, std::vector< unsigned char >::value_type const & x)
        """
        return _fife.vectoru_resize(self, *args)


    def insert(self, *args):
        """
        insert(vectoru self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::value_type const & x) -> std::vector< unsigned char >::iterator
        insert(vectoru self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)
        """
        return _fife.vectoru_insert(self, *args)


    def reserve(self, n):
        """reserve(vectoru self, std::vector< unsigned char >::size_type n)"""
        return _fife.vectoru_reserve(self, n)


    def capacity(self):
        """capacity(vectoru self) -> std::vector< unsigned char >::size_type"""
        return _fife.vectoru_capacity(self)

    __swig_destroy__ = _fife.delete_vectoru
vectoru.iterator = new_instancemethod(_fife.vectoru_iterator, None, vectoru)
vectoru.__nonzero__ = new_instancemethod(_fife.vectoru___nonzero__, None, vectoru)
vectoru.__bool__ = new_instancemethod(_fife.vectoru___bool__, None, vectoru)
vectoru.__len__ = new_instancemethod(_fife.vectoru___len__, None, vectoru)
vectoru.__getslice__ = new_instancemethod(_fife.vectoru___getslice__, None, vectoru)
vectoru.__setslice__ = new_instancemethod(_fife.vectoru___setslice__, None, vectoru)
vectoru.__delslice__ = new_instancemethod(_fife.vectoru___delslice__, None, vectoru)
vectoru.__delitem__ = new_instancemethod(_fife.vectoru___delitem__, None, vectoru)
vectoru.__getitem__ = new_instancemethod(_fife.vectoru___getitem__, None, vectoru)
vectoru.__setitem__ = new_instancemethod(_fife.vectoru___setitem__, None, vectoru)
vectoru.pop = new_instancemethod(_fife.vectoru_pop, None, vectoru)
vectoru.append = new_instancemethod(_fife.vectoru_append, None, vectoru)
vectoru.empty = new_instancemethod(_fife.vectoru_empty, None, vectoru)
vectoru.size = new_instancemethod(_fife.vectoru_size, None, vectoru)
vectoru.swap = new_instancemethod(_fife.vectoru_swap, None, vectoru)
vectoru.begin = new_instancemethod(_fife.vectoru_begin, None, vectoru)
vectoru.end = new_instancemethod(_fife.vectoru_end, None, vectoru)
vectoru.rbegin = new_instancemethod(_fife.vectoru_rbegin, None, vectoru)
vectoru.rend = new_instancemethod(_fife.vectoru_rend, None, vectoru)
vectoru.clear = new_instancemethod(_fife.vectoru_clear, None, vectoru)
vectoru.get_allocator = new_instancemethod(_fife.vectoru_get_allocator, None, vectoru)
vectoru.pop_back = new_instancemethod(_fife.vectoru_pop_back, None, vectoru)
vectoru.erase = new_instancemethod(_fife.vectoru_erase, None, vectoru)
vectoru.push_back = new_instancemethod(_fife.vectoru_push_back, None, vectoru)
vectoru.front = new_instancemethod(_fife.vectoru_front, None, vectoru)
vectoru.back = new_instancemethod(_fife.vectoru_back, None, vectoru)
vectoru.assign = new_instancemethod(_fife.vectoru_assign, None, vectoru)
vectoru.resize = new_instancemethod(_fife.vectoru_resize, None, vectoru)
vectoru.insert = new_instancemethod(_fife.vectoru_insert, None, vectoru)
vectoru.reserve = new_instancemethod(_fife.vectoru_reserve, None, vectoru)
vectoru.capacity = new_instancemethod(_fife.vectoru_capacity, None, vectoru)
vectoru_swigregister = _fife.vectoru_swigregister
vectoru_swigregister(vectoru)

class VFS(object):
    """Proxy of C++ FIFE::VFS class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::VFS self) -> VFS"""
        _fife.VFS_swiginit(self, _fife.new_VFS())
    __swig_destroy__ = _fife.delete_VFS

    def cleanup(self):
        """cleanup(VFS self)"""
        return _fife.VFS_cleanup(self)


    def addNewSource(self, path):
        """addNewSource(VFS self, std::string const & path)"""
        return _fife.VFS_addNewSource(self, path)


    def removeSource(self, path):
        """removeSource(VFS self, std::string const & path)"""
        return _fife.VFS_removeSource(self, path)


    def exists(self, file):
        """exists(VFS self, std::string const & file) -> bool"""
        return _fife.VFS_exists(self, file)


    def open(self, path):
        """open(VFS self, std::string const & path) -> RawData"""
        return _fife.VFS_open(self, path)


    def listFiles(self, path):
        """listFiles(VFS self, std::string const & path) -> StringSet"""
        return _fife.VFS_listFiles(self, path)


    def listDirectories(self, path):
        """listDirectories(VFS self, std::string const & path) -> StringSet"""
        return _fife.VFS_listDirectories(self, path)

VFS.cleanup = new_instancemethod(_fife.VFS_cleanup, None, VFS)
VFS.addNewSource = new_instancemethod(_fife.VFS_addNewSource, None, VFS)
VFS.removeSource = new_instancemethod(_fife.VFS_removeSource, None, VFS)
VFS.exists = new_instancemethod(_fife.VFS_exists, None, VFS)
VFS.open = new_instancemethod(_fife.VFS_open, None, VFS)
VFS.listFiles = new_instancemethod(_fife.VFS_listFiles, None, VFS)
VFS.listDirectories = new_instancemethod(_fife.VFS_listDirectories, None, VFS)
VFS_swigregister = _fife.VFS_swigregister
VFS_swigregister(VFS)

class IFont(object):
    """Proxy of C++ FIFE::IFont class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IFont

    def setRowSpacing(self, spacing):
        """setRowSpacing(IFont self, int32_t spacing)"""
        return _fife.IFont_setRowSpacing(self, spacing)


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


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


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


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


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


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


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


    def getWidth(self, text):
        """getWidth(IFont self, std::string const & text) -> int32_t"""
        return _fife.IFont_getWidth(self, text)


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

IFont.setRowSpacing = new_instancemethod(_fife.IFont_setRowSpacing, None, IFont)
IFont.getRowSpacing = new_instancemethod(_fife.IFont_getRowSpacing, None, IFont)
IFont.setGlyphSpacing = new_instancemethod(_fife.IFont_setGlyphSpacing, None, IFont)
IFont.getGlyphSpacing = new_instancemethod(_fife.IFont_getGlyphSpacing, None, IFont)
IFont.setAntiAlias = new_instancemethod(_fife.IFont_setAntiAlias, None, IFont)
IFont.isAntiAlias = new_instancemethod(_fife.IFont_isAntiAlias, None, IFont)
IFont.setColor = new_instancemethod(_fife.IFont_setColor, None, IFont)
IFont.getColor = new_instancemethod(_fife.IFont_getColor, None, IFont)
IFont.getWidth = new_instancemethod(_fife.IFont_getWidth, None, IFont)
IFont.getHeight = new_instancemethod(_fife.IFont_getHeight, None, IFont)
IFont_swigregister = _fife.IFont_swigregister
IFont_swigregister(IFont)

class FontBase(IFont):
    """Proxy of C++ FIFE::FontBase class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_FontBase
FontBase_swigregister = _fife.FontBase_swigregister
FontBase_swigregister(FontBase)

class TTFont(FontBase):
    """Proxy of C++ FIFE::TrueTypeFont class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, filename, size):
        """__init__(FIFE::TrueTypeFont self, std::string const & filename, int32_t size) -> TTFont"""
        _fife.TTFont_swiginit(self, _fife.new_TTFont(filename, size))
    __swig_destroy__ = _fife.delete_TTFont

    def setColor(self, r, g, b, a=255):
        """setColor(TTFont self, Uint8 r, Uint8 g, Uint8 b, Uint8 a=255)"""
        return _fife.TTFont_setColor(self, r, g, b, a)


    def getWidth(self, text):
        """getWidth(TTFont self, std::string const & text) -> int32_t"""
        return _fife.TTFont_getWidth(self, text)


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

TTFont.setColor = new_instancemethod(_fife.TTFont_setColor, None, TTFont)
TTFont.getWidth = new_instancemethod(_fife.TTFont_getWidth, None, TTFont)
TTFont.getHeight = new_instancemethod(_fife.TTFont_getHeight, None, TTFont)
TTFont_swigregister = _fife.TTFont_swigregister
TTFont_swigregister(TTFont)

class SubImageFont(FontBase):
    """Proxy of C++ FIFE::SubImageFont class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, filename, glyphs):
        """__init__(FIFE::SubImageFont self, std::string const & filename, std::string const & glyphs) -> SubImageFont"""
        _fife.SubImageFont_swiginit(self, _fife.new_SubImageFont(filename, glyphs))
    __swig_destroy__ = _fife.delete_SubImageFont

    def setColor(self, r, g, b, a=255):
        """setColor(SubImageFont self, Uint8 r, Uint8 g, Uint8 b, Uint8 a=255)"""
        return _fife.SubImageFont_setColor(self, r, g, b, a)


    def getWidth(self, text):
        """getWidth(SubImageFont self, std::string const & text) -> int32_t"""
        return _fife.SubImageFont_getWidth(self, text)


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

SubImageFont.setColor = new_instancemethod(_fife.SubImageFont_setColor, None, SubImageFont)
SubImageFont.getWidth = new_instancemethod(_fife.SubImageFont_getWidth, None, SubImageFont)
SubImageFont.getHeight = new_instancemethod(_fife.SubImageFont_getHeight, None, SubImageFont)
SubImageFont_swigregister = _fife.SubImageFont_swigregister
SubImageFont_swigregister(SubImageFont)

class RendererBase(object):
    """Proxy of C++ FIFE::RendererBase class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RendererBase

    def getName(self):
        """getName(RendererBase self) -> std::string"""
        return _fife.RendererBase_getName(self)


    def getPipelinePosition(self):
        """getPipelinePosition(RendererBase self) -> int32_t"""
        return _fife.RendererBase_getPipelinePosition(self)


    def setPipelinePosition(self, position):
        """setPipelinePosition(RendererBase self, int32_t position)"""
        return _fife.RendererBase_setPipelinePosition(self, position)


    def setEnabled(self, enabled):
        """setEnabled(RendererBase self, bool enabled)"""
        return _fife.RendererBase_setEnabled(self, enabled)


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


    def addActiveLayer(self, layer):
        """addActiveLayer(RendererBase self, Layer layer)"""
        return _fife.RendererBase_addActiveLayer(self, layer)


    def removeActiveLayer(self, layer):
        """removeActiveLayer(RendererBase self, Layer layer)"""
        return _fife.RendererBase_removeActiveLayer(self, layer)


    def clearActiveLayers(self):
        """clearActiveLayers(RendererBase self)"""
        return _fife.RendererBase_clearActiveLayers(self)


    def activateAllLayers(self, map):
        """activateAllLayers(RendererBase self, Map map)"""
        return _fife.RendererBase_activateAllLayers(self, map)


    def getActiveLayers(self):
        """getActiveLayers(RendererBase self) -> LayerList"""
        return _fife.RendererBase_getActiveLayers(self)

RendererBase.getName = new_instancemethod(_fife.RendererBase_getName, None, RendererBase)
RendererBase.getPipelinePosition = new_instancemethod(_fife.RendererBase_getPipelinePosition, None, RendererBase)
RendererBase.setPipelinePosition = new_instancemethod(_fife.RendererBase_setPipelinePosition, None, RendererBase)
RendererBase.setEnabled = new_instancemethod(_fife.RendererBase_setEnabled, None, RendererBase)
RendererBase.isEnabled = new_instancemethod(_fife.RendererBase_isEnabled, None, RendererBase)
RendererBase.addActiveLayer = new_instancemethod(_fife.RendererBase_addActiveLayer, None, RendererBase)
RendererBase.removeActiveLayer = new_instancemethod(_fife.RendererBase_removeActiveLayer, None, RendererBase)
RendererBase.clearActiveLayers = new_instancemethod(_fife.RendererBase_clearActiveLayers, None, RendererBase)
RendererBase.activateAllLayers = new_instancemethod(_fife.RendererBase_activateAllLayers, None, RendererBase)
RendererBase.getActiveLayers = new_instancemethod(_fife.RendererBase_getActiveLayers, None, RendererBase)
RendererBase_swigregister = _fife.RendererBase_swigregister
RendererBase_swigregister(RendererBase)

class IRendererContainer(object):
    """Proxy of C++ FIFE::IRendererContainer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IRendererContainer

    def getRenderer(self, renderername):
        """getRenderer(IRendererContainer self, std::string const & renderername) -> RendererBase"""
        return _fife.IRendererContainer_getRenderer(self, renderername)

IRendererContainer.getRenderer = new_instancemethod(_fife.IRendererContainer_getRenderer, None, IRendererContainer)
IRendererContainer_swigregister = _fife.IRendererContainer_swigregister
IRendererContainer_swigregister(IRendererContainer)

class ScreenPoint(object):
    """Proxy of C++ FIFE::PointType3D<(int32_t)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    x = _swig_property(_fife.ScreenPoint_x_get, _fife.ScreenPoint_x_set)
    y = _swig_property(_fife.ScreenPoint_y_get, _fife.ScreenPoint_y_set)
    z = _swig_property(_fife.ScreenPoint_z_get, _fife.ScreenPoint_z_set)

    def __init__(self, *args):
        """
        __init__(FIFE::PointType3D<(int32_t)> self, int _x=0, int _y=0, int _z=0) -> ScreenPoint
        __init__(FIFE::PointType3D<(int32_t)> self, Point3D rhs) -> ScreenPoint
        """
        _fife.ScreenPoint_swiginit(self, _fife.new_ScreenPoint(*args))

    def __add__(self, p):
        """__add__(ScreenPoint self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___add__(self, p)


    def __sub__(self, p):
        """__sub__(ScreenPoint self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___sub__(self, p)


    def __iadd__(self, p):
        """__iadd__(ScreenPoint self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___iadd__(self, p)


    def __isub__(self, p):
        """__isub__(ScreenPoint self, Point3D p) -> Point3D"""
        return _fife.ScreenPoint___isub__(self, p)


    def __mul__(self, i):
        """__mul__(ScreenPoint self, int const & i) -> Point3D"""
        return _fife.ScreenPoint___mul__(self, i)


    def __truediv__(self, *args):
        return _fife.ScreenPoint___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, p):
        """__eq__(ScreenPoint self, Point3D p) -> bool"""
        return _fife.ScreenPoint___eq__(self, p)


    def __ne__(self, p):
        """__ne__(ScreenPoint self, Point3D p) -> bool"""
        return _fife.ScreenPoint___ne__(self, p)


    def length(self):
        """length(ScreenPoint self) -> int"""
        return _fife.ScreenPoint_length(self)


    def normalize(self):
        """normalize(ScreenPoint self)"""
        return _fife.ScreenPoint_normalize(self)


    def set(self, _x, _y, _z):
        """set(ScreenPoint self, int _x, int _y, int _z)"""
        return _fife.ScreenPoint_set(self, _x, _y, _z)


    def __str__(self):
        """__str__(ScreenPoint self) -> std::string"""
        return _fife.ScreenPoint___str__(self)

    __swig_destroy__ = _fife.delete_ScreenPoint
ScreenPoint.__add__ = new_instancemethod(_fife.ScreenPoint___add__, None, ScreenPoint)
ScreenPoint.__sub__ = new_instancemethod(_fife.ScreenPoint___sub__, None, ScreenPoint)
ScreenPoint.__iadd__ = new_instancemethod(_fife.ScreenPoint___iadd__, None, ScreenPoint)
ScreenPoint.__isub__ = new_instancemethod(_fife.ScreenPoint___isub__, None, ScreenPoint)
ScreenPoint.__mul__ = new_instancemethod(_fife.ScreenPoint___mul__, None, ScreenPoint)
ScreenPoint.__eq__ = new_instancemethod(_fife.ScreenPoint___eq__, None, ScreenPoint)
ScreenPoint.__ne__ = new_instancemethod(_fife.ScreenPoint___ne__, None, ScreenPoint)
ScreenPoint.length = new_instancemethod(_fife.ScreenPoint_length, None, ScreenPoint)
ScreenPoint.normalize = new_instancemethod(_fife.ScreenPoint_normalize, None, ScreenPoint)
ScreenPoint.set = new_instancemethod(_fife.ScreenPoint_set, None, ScreenPoint)
ScreenPoint.__str__ = new_instancemethod(_fife.ScreenPoint___str__, None, ScreenPoint)
ScreenPoint_swigregister = _fife.ScreenPoint_swigregister
ScreenPoint_swigregister(ScreenPoint)

class Camera(IRendererContainer):
    """Proxy of C++ FIFE::Camera class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Camera

    def getId(self):
        """getId(Camera self) -> std::string const &"""
        return _fife.Camera_getId(self)


    def setId(self, id):
        """setId(Camera self, std::string const & id)"""
        return _fife.Camera_setId(self, id)


    def setTilt(self, tilt):
        """setTilt(Camera self, double tilt)"""
        return _fife.Camera_setTilt(self, tilt)


    def getTilt(self):
        """getTilt(Camera self) -> double"""
        return _fife.Camera_getTilt(self)


    def setRotation(self, rotation):
        """setRotation(Camera self, double rotation)"""
        return _fife.Camera_setRotation(self, rotation)


    def getRotation(self):
        """getRotation(Camera self) -> double"""
        return _fife.Camera_getRotation(self)


    def setZoom(self, zoom):
        """setZoom(Camera self, double zoom)"""
        return _fife.Camera_setZoom(self, zoom)


    def getZoom(self):
        """getZoom(Camera self) -> double"""
        return _fife.Camera_getZoom(self)


    def getOriginalZToY(self):
        """getOriginalZToY(Camera self) -> double"""
        return _fife.Camera_getOriginalZToY(self)


    def setZToY(self, zToY):
        """setZToY(Camera self, double zToY)"""
        return _fife.Camera_setZToY(self, zToY)


    def getZToY(self):
        """getZToY(Camera self) -> double"""
        return _fife.Camera_getZToY(self)


    def setZToYEnabled(self, enabled):
        """setZToYEnabled(Camera self, bool enabled)"""
        return _fife.Camera_setZToYEnabled(self, enabled)


    def isZToYEnabled(self):
        """isZToYEnabled(Camera self) -> bool"""
        return _fife.Camera_isZToYEnabled(self)


    def setLocation(self, location):
        """setLocation(Camera self, Location location)"""
        return _fife.Camera_setLocation(self, location)


    def getLocation(self):
        """getLocation(Camera self) -> Location"""
        return _fife.Camera_getLocation(self)


    def setPosition(self, position):
        """setPosition(Camera self, DoublePoint3D position)"""
        return _fife.Camera_setPosition(self, position)


    def getPosition(self):
        """getPosition(Camera self) -> DoublePoint3D"""
        return _fife.Camera_getPosition(self)


    def getOrigin(self):
        """getOrigin(Camera self) -> Point3D"""
        return _fife.Camera_getOrigin(self)


    def attach(self, instance):
        """attach(Camera self, Instance instance)"""
        return _fife.Camera_attach(self, instance)


    def detach(self):
        """detach(Camera self)"""
        return _fife.Camera_detach(self)


    def getAttached(self):
        """getAttached(Camera self) -> Instance"""
        return _fife.Camera_getAttached(self)


    def setViewPort(self, viewport):
        """setViewPort(Camera self, Rect viewport)"""
        return _fife.Camera_setViewPort(self, viewport)


    def getViewPort(self):
        """getViewPort(Camera self) -> Rect"""
        return _fife.Camera_getViewPort(self)


    def getMapViewPort(self):
        """getMapViewPort(Camera self) -> Rect"""
        return _fife.Camera_getMapViewPort(self)


    def getLayerViewPort(self, layer):
        """getLayerViewPort(Camera self, Layer layer) -> Rect"""
        return _fife.Camera_getLayerViewPort(self, layer)


    def setCellImageDimensions(self, width, height):
        """setCellImageDimensions(Camera self, uint32_t width, uint32_t height)"""
        return _fife.Camera_setCellImageDimensions(self, width, height)


    def getCellImageDimensions(self, *args):
        """
        getCellImageDimensions(Camera self) -> Point
        getCellImageDimensions(Camera self, Layer layer) -> Point
        """
        return _fife.Camera_getCellImageDimensions(self, *args)


    def toScreenCoordinates(self, map_coords):
        """toScreenCoordinates(Camera self, DoublePoint3D map_coords) -> Point3D"""
        return _fife.Camera_toScreenCoordinates(self, map_coords)


    def toMapCoordinates(self, screen_coords, z_calculated=True):
        """toMapCoordinates(Camera self, Point3D screen_coords, bool z_calculated=True) -> DoublePoint3D"""
        return _fife.Camera_toMapCoordinates(self, screen_coords, z_calculated)


    def setEnabled(self, enabled):
        """setEnabled(Camera self, bool enabled)"""
        return _fife.Camera_setEnabled(self, enabled)


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


    def getMatchingInstances(self, *args):
        """
        getMatchingInstances(Camera self, Point3D screen_coords, Layer layer, uint8_t alpha=0)
        getMatchingInstances(Camera self, Rect screen_rect, Layer layer, uint8_t alpha=0)
        getMatchingInstances(Camera self, Location loc, bool use_exactcoordinates=False)
        """
        return _fife.Camera_getMatchingInstances(self, *args)


    def getRenderer(self, name):
        """getRenderer(Camera self, std::string const & name) -> RendererBase"""
        return _fife.Camera_getRenderer(self, name)


    def resetRenderers(self):
        """resetRenderers(Camera self)"""
        return _fife.Camera_resetRenderers(self)


    def setLightingColor(self, red, green, blue):
        """setLightingColor(Camera self, float red, float green, float blue)"""
        return _fife.Camera_setLightingColor(self, red, green, blue)


    def resetLightingColor(self):
        """resetLightingColor(Camera self)"""
        return _fife.Camera_resetLightingColor(self)


    def getLightingColor(self):
        """getLightingColor(Camera self) -> FloatVector"""
        return _fife.Camera_getLightingColor(self)


    def setOverlayColor(self, red, green, blue, alpha):
        """setOverlayColor(Camera self, uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha)"""
        return _fife.Camera_setOverlayColor(self, red, green, blue, alpha)


    def getOverlayColor(self):
        """getOverlayColor(Camera self) -> vectoru"""
        return _fife.Camera_getOverlayColor(self)


    def resetOverlayColor(self):
        """resetOverlayColor(Camera self)"""
        return _fife.Camera_resetOverlayColor(self)


    def setOverlayImage(self, id, fill=False):
        """setOverlayImage(Camera self, int32_t id, bool fill=False)"""
        return _fife.Camera_setOverlayImage(self, id, fill)


    def getOverlayImage(self):
        """getOverlayImage(Camera self) -> int32_t"""
        return _fife.Camera_getOverlayImage(self)


    def resetOverlayImage(self):
        """resetOverlayImage(Camera self)"""
        return _fife.Camera_resetOverlayImage(self)


    def setOverlayAnimation(self, anim, fill=False):
        """setOverlayAnimation(Camera self, SharedAnimationPointer anim, bool fill=False)"""
        return _fife.Camera_setOverlayAnimation(self, anim, fill)


    def getOverlayAnimation(self):
        """getOverlayAnimation(Camera self) -> SharedAnimationPointer"""
        return _fife.Camera_getOverlayAnimation(self)


    def resetOverlayAnimation(self):
        """resetOverlayAnimation(Camera self)"""
        return _fife.Camera_resetOverlayAnimation(self)


    def refresh(self):
        """refresh(Camera self)"""
        return _fife.Camera_refresh(self)

Camera.getId = new_instancemethod(_fife.Camera_getId, None, Camera)
Camera.setId = new_instancemethod(_fife.Camera_setId, None, Camera)
Camera.setTilt = new_instancemethod(_fife.Camera_setTilt, None, Camera)
Camera.getTilt = new_instancemethod(_fife.Camera_getTilt, None, Camera)
Camera.setRotation = new_instancemethod(_fife.Camera_setRotation, None, Camera)
Camera.getRotation = new_instancemethod(_fife.Camera_getRotation, None, Camera)
Camera.setZoom = new_instancemethod(_fife.Camera_setZoom, None, Camera)
Camera.getZoom = new_instancemethod(_fife.Camera_getZoom, None, Camera)
Camera.getOriginalZToY = new_instancemethod(_fife.Camera_getOriginalZToY, None, Camera)
Camera.setZToY = new_instancemethod(_fife.Camera_setZToY, None, Camera)
Camera.getZToY = new_instancemethod(_fife.Camera_getZToY, None, Camera)
Camera.setZToYEnabled = new_instancemethod(_fife.Camera_setZToYEnabled, None, Camera)
Camera.isZToYEnabled = new_instancemethod(_fife.Camera_isZToYEnabled, None, Camera)
Camera.setLocation = new_instancemethod(_fife.Camera_setLocation, None, Camera)
Camera.getLocation = new_instancemethod(_fife.Camera_getLocation, None, Camera)
Camera.setPosition = new_instancemethod(_fife.Camera_setPosition, None, Camera)
Camera.getPosition = new_instancemethod(_fife.Camera_getPosition, None, Camera)
Camera.getOrigin = new_instancemethod(_fife.Camera_getOrigin, None, Camera)
Camera.attach = new_instancemethod(_fife.Camera_attach, None, Camera)
Camera.detach = new_instancemethod(_fife.Camera_detach, None, Camera)
Camera.getAttached = new_instancemethod(_fife.Camera_getAttached, None, Camera)
Camera.setViewPort = new_instancemethod(_fife.Camera_setViewPort, None, Camera)
Camera.getViewPort = new_instancemethod(_fife.Camera_getViewPort, None, Camera)
Camera.getMapViewPort = new_instancemethod(_fife.Camera_getMapViewPort, None, Camera)
Camera.getLayerViewPort = new_instancemethod(_fife.Camera_getLayerViewPort, None, Camera)
Camera.setCellImageDimensions = new_instancemethod(_fife.Camera_setCellImageDimensions, None, Camera)
Camera.getCellImageDimensions = new_instancemethod(_fife.Camera_getCellImageDimensions, None, Camera)
Camera.toScreenCoordinates = new_instancemethod(_fife.Camera_toScreenCoordinates, None, Camera)
Camera.toMapCoordinates = new_instancemethod(_fife.Camera_toMapCoordinates, None, Camera)
Camera.setEnabled = new_instancemethod(_fife.Camera_setEnabled, None, Camera)
Camera.isEnabled = new_instancemethod(_fife.Camera_isEnabled, None, Camera)
Camera.getMatchingInstances = new_instancemethod(_fife.Camera_getMatchingInstances, None, Camera)
Camera.getRenderer = new_instancemethod(_fife.Camera_getRenderer, None, Camera)
Camera.resetRenderers = new_instancemethod(_fife.Camera_resetRenderers, None, Camera)
Camera.setLightingColor = new_instancemethod(_fife.Camera_setLightingColor, None, Camera)
Camera.resetLightingColor = new_instancemethod(_fife.Camera_resetLightingColor, None, Camera)
Camera.getLightingColor = new_instancemethod(_fife.Camera_getLightingColor, None, Camera)
Camera.setOverlayColor = new_instancemethod(_fife.Camera_setOverlayColor, None, Camera)
Camera.getOverlayColor = new_instancemethod(_fife.Camera_getOverlayColor, None, Camera)
Camera.resetOverlayColor = new_instancemethod(_fife.Camera_resetOverlayColor, None, Camera)
Camera.setOverlayImage = new_instancemethod(_fife.Camera_setOverlayImage, None, Camera)
Camera.getOverlayImage = new_instancemethod(_fife.Camera_getOverlayImage, None, Camera)
Camera.resetOverlayImage = new_instancemethod(_fife.Camera_resetOverlayImage, None, Camera)
Camera.setOverlayAnimation = new_instancemethod(_fife.Camera_setOverlayAnimation, None, Camera)
Camera.getOverlayAnimation = new_instancemethod(_fife.Camera_getOverlayAnimation, None, Camera)
Camera.resetOverlayAnimation = new_instancemethod(_fife.Camera_resetOverlayAnimation, None, Camera)
Camera.refresh = new_instancemethod(_fife.Camera_refresh, None, Camera)
Camera_swigregister = _fife.Camera_swigregister
Camera_swigregister(Camera)

class OverlayColors(object):
    """Proxy of C++ FIFE::OverlayColors class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::OverlayColors self) -> OverlayColors
        __init__(FIFE::OverlayColors self, SharedImagePointer image) -> OverlayColors
        __init__(FIFE::OverlayColors self, SharedAnimationPointer animation) -> OverlayColors
        """
        _fife.OverlayColors_swiginit(self, _fife.new_OverlayColors(*args))
    __swig_destroy__ = _fife.delete_OverlayColors

    def setColorOverlayImage(self, image):
        """setColorOverlayImage(OverlayColors self, SharedImagePointer image)"""
        return _fife.OverlayColors_setColorOverlayImage(self, image)


    def getColorOverlayImage(self):
        """getColorOverlayImage(OverlayColors self) -> SharedImagePointer"""
        return _fife.OverlayColors_getColorOverlayImage(self)


    def setColorOverlayAnimation(self, animation):
        """setColorOverlayAnimation(OverlayColors self, SharedAnimationPointer animation)"""
        return _fife.OverlayColors_setColorOverlayAnimation(self, animation)


    def getColorOverlayAnimation(self):
        """getColorOverlayAnimation(OverlayColors self) -> SharedAnimationPointer"""
        return _fife.OverlayColors_getColorOverlayAnimation(self)


    def changeColor(self, source, target):
        """changeColor(OverlayColors self, Color source, Color target)"""
        return _fife.OverlayColors_changeColor(self, source, target)


    def getColors(self):
        """getColors(OverlayColors self) -> std::map< FIFE::Color,FIFE::Color,std::less< FIFE::Color >,std::allocator< std::pair< FIFE::Color const,FIFE::Color > > > const &"""
        return _fife.OverlayColors_getColors(self)


    def resetColors(self):
        """resetColors(OverlayColors self)"""
        return _fife.OverlayColors_resetColors(self)

OverlayColors.setColorOverlayImage = new_instancemethod(_fife.OverlayColors_setColorOverlayImage, None, OverlayColors)
OverlayColors.getColorOverlayImage = new_instancemethod(_fife.OverlayColors_getColorOverlayImage, None, OverlayColors)
OverlayColors.setColorOverlayAnimation = new_instancemethod(_fife.OverlayColors_setColorOverlayAnimation, None, OverlayColors)
OverlayColors.getColorOverlayAnimation = new_instancemethod(_fife.OverlayColors_getColorOverlayAnimation, None, OverlayColors)
OverlayColors.changeColor = new_instancemethod(_fife.OverlayColors_changeColor, None, OverlayColors)
OverlayColors.getColors = new_instancemethod(_fife.OverlayColors_getColors, None, OverlayColors)
OverlayColors.resetColors = new_instancemethod(_fife.OverlayColors_resetColors, None, OverlayColors)
OverlayColors_swigregister = _fife.OverlayColors_swigregister
OverlayColors_swigregister(OverlayColors)

class Visual2DGfx(object):
    """Proxy of C++ FIFE::Visual2DGfx class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Visual2DGfx
Visual2DGfx_swigregister = _fife.Visual2DGfx_swigregister
Visual2DGfx_swigregister(Visual2DGfx)

class ObjectVisual(Visual2DGfx):
    """Proxy of C++ FIFE::ObjectVisual class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def create(object):
        """create(Object object) -> ObjectVisual"""
        return _fife.ObjectVisual_create(object)

    create = staticmethod(create)
    __swig_destroy__ = _fife.delete_ObjectVisual

    def addStaticImage(self, angle, image_index):
        """addStaticImage(ObjectVisual self, uint32_t angle, int32_t image_index)"""
        return _fife.ObjectVisual_addStaticImage(self, angle, image_index)


    def getStaticImageIndexByAngle(self, angle):
        """getStaticImageIndexByAngle(ObjectVisual self, int32_t angle) -> int32_t"""
        return _fife.ObjectVisual_getStaticImageIndexByAngle(self, angle)


    def addStaticColorOverlay(self, angle, colors):
        """addStaticColorOverlay(ObjectVisual self, uint32_t angle, OverlayColors colors)"""
        return _fife.ObjectVisual_addStaticColorOverlay(self, angle, colors)


    def getStaticColorOverlay(self, angle):
        """getStaticColorOverlay(ObjectVisual self, int32_t angle) -> OverlayColors"""
        return _fife.ObjectVisual_getStaticColorOverlay(self, angle)


    def removeStaticColorOverlay(self, angle):
        """removeStaticColorOverlay(ObjectVisual self, int32_t angle)"""
        return _fife.ObjectVisual_removeStaticColorOverlay(self, angle)


    def getClosestMatchingAngle(self, angle):
        """getClosestMatchingAngle(ObjectVisual self, int32_t angle) -> int32_t"""
        return _fife.ObjectVisual_getClosestMatchingAngle(self, angle)


    def getStaticImageAngles(self):
        """getStaticImageAngles(ObjectVisual self)"""
        return _fife.ObjectVisual_getStaticImageAngles(self)

ObjectVisual.addStaticImage = new_instancemethod(_fife.ObjectVisual_addStaticImage, None, ObjectVisual)
ObjectVisual.getStaticImageIndexByAngle = new_instancemethod(_fife.ObjectVisual_getStaticImageIndexByAngle, None, ObjectVisual)
ObjectVisual.addStaticColorOverlay = new_instancemethod(_fife.ObjectVisual_addStaticColorOverlay, None, ObjectVisual)
ObjectVisual.getStaticColorOverlay = new_instancemethod(_fife.ObjectVisual_getStaticColorOverlay, None, ObjectVisual)
ObjectVisual.removeStaticColorOverlay = new_instancemethod(_fife.ObjectVisual_removeStaticColorOverlay, None, ObjectVisual)
ObjectVisual.getClosestMatchingAngle = new_instancemethod(_fife.ObjectVisual_getClosestMatchingAngle, None, ObjectVisual)
ObjectVisual.getStaticImageAngles = new_instancemethod(_fife.ObjectVisual_getStaticImageAngles, None, ObjectVisual)
ObjectVisual_swigregister = _fife.ObjectVisual_swigregister
ObjectVisual_swigregister(ObjectVisual)

def ObjectVisual_create(object):
    """ObjectVisual_create(Object object) -> ObjectVisual"""
    return _fife.ObjectVisual_create(object)

class InstanceVisual(Visual2DGfx):
    """Proxy of C++ FIFE::InstanceVisual class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def create(instance):
        """create(Instance instance) -> InstanceVisual"""
        return _fife.InstanceVisual_create(instance)

    create = staticmethod(create)
    __swig_destroy__ = _fife.delete_InstanceVisual

    def setTransparency(self, transparency):
        """setTransparency(InstanceVisual self, uint8_t transparency)"""
        return _fife.InstanceVisual_setTransparency(self, transparency)


    def getTransparency(self):
        """getTransparency(InstanceVisual self) -> uint8_t"""
        return _fife.InstanceVisual_getTransparency(self)


    def setVisible(self, visible):
        """setVisible(InstanceVisual self, bool visible)"""
        return _fife.InstanceVisual_setVisible(self, visible)


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


    def setStackPosition(self, stackposition):
        """setStackPosition(InstanceVisual self, int32_t stackposition)"""
        return _fife.InstanceVisual_setStackPosition(self, stackposition)


    def getStackPosition(self):
        """getStackPosition(InstanceVisual self) -> int32_t"""
        return _fife.InstanceVisual_getStackPosition(self)

InstanceVisual.setTransparency = new_instancemethod(_fife.InstanceVisual_setTransparency, None, InstanceVisual)
InstanceVisual.getTransparency = new_instancemethod(_fife.InstanceVisual_getTransparency, None, InstanceVisual)
InstanceVisual.setVisible = new_instancemethod(_fife.InstanceVisual_setVisible, None, InstanceVisual)
InstanceVisual.isVisible = new_instancemethod(_fife.InstanceVisual_isVisible, None, InstanceVisual)
InstanceVisual.setStackPosition = new_instancemethod(_fife.InstanceVisual_setStackPosition, None, InstanceVisual)
InstanceVisual.getStackPosition = new_instancemethod(_fife.InstanceVisual_getStackPosition, None, InstanceVisual)
InstanceVisual_swigregister = _fife.InstanceVisual_swigregister
InstanceVisual_swigregister(InstanceVisual)

def InstanceVisual_create(instance):
    """InstanceVisual_create(Instance instance) -> InstanceVisual"""
    return _fife.InstanceVisual_create(instance)

class ActionVisual(Visual2DGfx):
    """Proxy of C++ FIFE::ActionVisual class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    def create(action):
        """create(Action action) -> ActionVisual"""
        return _fife.ActionVisual_create(action)

    create = staticmethod(create)
    __swig_destroy__ = _fife.delete_ActionVisual

    def addAnimation(self, angle, animationptr):
        """addAnimation(ActionVisual self, uint32_t angle, SharedAnimationPointer animationptr)"""
        return _fife.ActionVisual_addAnimation(self, angle, animationptr)


    def getAnimationByAngle(self, angle):
        """getAnimationByAngle(ActionVisual self, int32_t angle) -> SharedAnimationPointer"""
        return _fife.ActionVisual_getAnimationByAngle(self, angle)


    def addAnimationOverlay(self, angle, order, animationptr):
        """addAnimationOverlay(ActionVisual self, uint32_t angle, int32_t order, SharedAnimationPointer animationptr)"""
        return _fife.ActionVisual_addAnimationOverlay(self, angle, order, animationptr)


    def removeAnimationOverlay(self, angle, order):
        """removeAnimationOverlay(ActionVisual self, uint32_t angle, int32_t order)"""
        return _fife.ActionVisual_removeAnimationOverlay(self, angle, order)


    def getAnimationOverlay(self, angle):
        """getAnimationOverlay(ActionVisual self, int32_t angle) -> AnimationOverlayMap"""
        return _fife.ActionVisual_getAnimationOverlay(self, angle)


    def addColorOverlay(self, *args):
        """
        addColorOverlay(ActionVisual self, uint32_t angle, OverlayColors colors)
        addColorOverlay(ActionVisual self, uint32_t angle, int32_t order, OverlayColors colors)
        """
        return _fife.ActionVisual_addColorOverlay(self, *args)


    def getColorOverlay(self, *args):
        """
        getColorOverlay(ActionVisual self, int32_t angle) -> OverlayColors
        getColorOverlay(ActionVisual self, int32_t angle, int32_t order) -> OverlayColors
        """
        return _fife.ActionVisual_getColorOverlay(self, *args)


    def removeColorOverlay(self, *args):
        """
        removeColorOverlay(ActionVisual self, int32_t angle)
        removeColorOverlay(ActionVisual self, int32_t angle, int32_t order)
        """
        return _fife.ActionVisual_removeColorOverlay(self, *args)


    def getActionImageAngles(self):
        """getActionImageAngles(ActionVisual self)"""
        return _fife.ActionVisual_getActionImageAngles(self)


    def convertToOverlays(self, color):
        """convertToOverlays(ActionVisual self, bool color)"""
        return _fife.ActionVisual_convertToOverlays(self, color)


    def isAnimationOverlay(self):
        """isAnimationOverlay(ActionVisual self) -> bool"""
        return _fife.ActionVisual_isAnimationOverlay(self)


    def isColorOverlay(self):
        """isColorOverlay(ActionVisual self) -> bool"""
        return _fife.ActionVisual_isColorOverlay(self)

ActionVisual.addAnimation = new_instancemethod(_fife.ActionVisual_addAnimation, None, ActionVisual)
ActionVisual.getAnimationByAngle = new_instancemethod(_fife.ActionVisual_getAnimationByAngle, None, ActionVisual)
ActionVisual.addAnimationOverlay = new_instancemethod(_fife.ActionVisual_addAnimationOverlay, None, ActionVisual)
ActionVisual.removeAnimationOverlay = new_instancemethod(_fife.ActionVisual_removeAnimationOverlay, None, ActionVisual)
ActionVisual.getAnimationOverlay = new_instancemethod(_fife.ActionVisual_getAnimationOverlay, None, ActionVisual)
ActionVisual.addColorOverlay = new_instancemethod(_fife.ActionVisual_addColorOverlay, None, ActionVisual)
ActionVisual.getColorOverlay = new_instancemethod(_fife.ActionVisual_getColorOverlay, None, ActionVisual)
ActionVisual.removeColorOverlay = new_instancemethod(_fife.ActionVisual_removeColorOverlay, None, ActionVisual)
ActionVisual.getActionImageAngles = new_instancemethod(_fife.ActionVisual_getActionImageAngles, None, ActionVisual)
ActionVisual.convertToOverlays = new_instancemethod(_fife.ActionVisual_convertToOverlays, None, ActionVisual)
ActionVisual.isAnimationOverlay = new_instancemethod(_fife.ActionVisual_isAnimationOverlay, None, ActionVisual)
ActionVisual.isColorOverlay = new_instancemethod(_fife.ActionVisual_isColorOverlay, None, ActionVisual)
ActionVisual_swigregister = _fife.ActionVisual_swigregister
ActionVisual_swigregister(ActionVisual)

def ActionVisual_create(action):
    """ActionVisual_create(Action action) -> ActionVisual"""
    return _fife.ActionVisual_create(action)

class BlockingInfoRenderer(RendererBase):
    """Proxy of C++ FIFE::BlockingInfoRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_BlockingInfoRenderer

    def getName(self):
        """getName(BlockingInfoRenderer self) -> std::string"""
        return _fife.BlockingInfoRenderer_getName(self)


    def setColor(self, r, g, b):
        """setColor(BlockingInfoRenderer self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.BlockingInfoRenderer_setColor(self, r, g, b)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> BlockingInfoRenderer"""
        return _fife.BlockingInfoRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)
BlockingInfoRenderer.getName = new_instancemethod(_fife.BlockingInfoRenderer_getName, None, BlockingInfoRenderer)
BlockingInfoRenderer.setColor = new_instancemethod(_fife.BlockingInfoRenderer_setColor, None, BlockingInfoRenderer)
BlockingInfoRenderer_swigregister = _fife.BlockingInfoRenderer_swigregister
BlockingInfoRenderer_swigregister(BlockingInfoRenderer)

def BlockingInfoRenderer_getInstance(cnt):
    """BlockingInfoRenderer_getInstance(IRendererContainer cnt) -> BlockingInfoRenderer"""
    return _fife.BlockingInfoRenderer_getInstance(cnt)

class CellRenderer(RendererBase):
    """Proxy of C++ FIFE::CellRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellRenderer

    def getName(self):
        """getName(CellRenderer self) -> std::string"""
        return _fife.CellRenderer_getName(self)


    def setBlockerColor(self, r, g, b):
        """setBlockerColor(CellRenderer self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CellRenderer_setBlockerColor(self, r, g, b)


    def setPathColor(self, r, g, b):
        """setPathColor(CellRenderer self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CellRenderer_setPathColor(self, r, g, b)


    def setEnabledBlocking(self, enabled):
        """setEnabledBlocking(CellRenderer self, bool enabled)"""
        return _fife.CellRenderer_setEnabledBlocking(self, enabled)


    def isEnabledBlocking(self):
        """isEnabledBlocking(CellRenderer self) -> bool"""
        return _fife.CellRenderer_isEnabledBlocking(self)


    def setEnabledPathVisual(self, enabled):
        """setEnabledPathVisual(CellRenderer self, bool enabled)"""
        return _fife.CellRenderer_setEnabledPathVisual(self, enabled)


    def isEnabledPathVisual(self):
        """isEnabledPathVisual(CellRenderer self) -> bool"""
        return _fife.CellRenderer_isEnabledPathVisual(self)


    def addPathVisual(self, instance):
        """addPathVisual(CellRenderer self, Instance instance)"""
        return _fife.CellRenderer_addPathVisual(self, instance)


    def removePathVisual(self, instance):
        """removePathVisual(CellRenderer self, Instance instance)"""
        return _fife.CellRenderer_removePathVisual(self, instance)


    def setEnabledCost(self, costId, enabled):
        """setEnabledCost(CellRenderer self, std::string const & costId, bool enabled)"""
        return _fife.CellRenderer_setEnabledCost(self, costId, enabled)


    def isEnabledCost(self, costId):
        """isEnabledCost(CellRenderer self, std::string const & costId) -> bool"""
        return _fife.CellRenderer_isEnabledCost(self, costId)


    def setFont(self, font):
        """setFont(CellRenderer self, IFont font)"""
        return _fife.CellRenderer_setFont(self, font)


    def getFont(self):
        """getFont(CellRenderer self) -> IFont"""
        return _fife.CellRenderer_getFont(self)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> CellRenderer"""
        return _fife.CellRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)
CellRenderer.getName = new_instancemethod(_fife.CellRenderer_getName, None, CellRenderer)
CellRenderer.setBlockerColor = new_instancemethod(_fife.CellRenderer_setBlockerColor, None, CellRenderer)
CellRenderer.setPathColor = new_instancemethod(_fife.CellRenderer_setPathColor, None, CellRenderer)
CellRenderer.setEnabledBlocking = new_instancemethod(_fife.CellRenderer_setEnabledBlocking, None, CellRenderer)
CellRenderer.isEnabledBlocking = new_instancemethod(_fife.CellRenderer_isEnabledBlocking, None, CellRenderer)
CellRenderer.setEnabledPathVisual = new_instancemethod(_fife.CellRenderer_setEnabledPathVisual, None, CellRenderer)
CellRenderer.isEnabledPathVisual = new_instancemethod(_fife.CellRenderer_isEnabledPathVisual, None, CellRenderer)
CellRenderer.addPathVisual = new_instancemethod(_fife.CellRenderer_addPathVisual, None, CellRenderer)
CellRenderer.removePathVisual = new_instancemethod(_fife.CellRenderer_removePathVisual, None, CellRenderer)
CellRenderer.setEnabledCost = new_instancemethod(_fife.CellRenderer_setEnabledCost, None, CellRenderer)
CellRenderer.isEnabledCost = new_instancemethod(_fife.CellRenderer_isEnabledCost, None, CellRenderer)
CellRenderer.setFont = new_instancemethod(_fife.CellRenderer_setFont, None, CellRenderer)
CellRenderer.getFont = new_instancemethod(_fife.CellRenderer_getFont, None, CellRenderer)
CellRenderer_swigregister = _fife.CellRenderer_swigregister
CellRenderer_swigregister(CellRenderer)

def CellRenderer_getInstance(cnt):
    """CellRenderer_getInstance(IRendererContainer cnt) -> CellRenderer"""
    return _fife.CellRenderer_getInstance(cnt)

class CellSelectionRenderer(RendererBase):
    """Proxy of C++ FIFE::CellSelectionRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CellSelectionRenderer

    def getName(self):
        """getName(CellSelectionRenderer self) -> std::string"""
        return _fife.CellSelectionRenderer_getName(self)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> CellSelectionRenderer"""
        return _fife.CellSelectionRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)

    def reset(self):
        """reset(CellSelectionRenderer self)"""
        return _fife.CellSelectionRenderer_reset(self)


    def selectLocation(self, loc):
        """selectLocation(CellSelectionRenderer self, Location loc)"""
        return _fife.CellSelectionRenderer_selectLocation(self, loc)


    def deselectLocation(self, loc):
        """deselectLocation(CellSelectionRenderer self, Location loc)"""
        return _fife.CellSelectionRenderer_deselectLocation(self, loc)


    def getLocations(self):
        """getLocations(CellSelectionRenderer self) -> LocationVector"""
        return _fife.CellSelectionRenderer_getLocations(self)


    def setColor(self, r, g, b):
        """setColor(CellSelectionRenderer self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CellSelectionRenderer_setColor(self, r, g, b)

CellSelectionRenderer.getName = new_instancemethod(_fife.CellSelectionRenderer_getName, None, CellSelectionRenderer)
CellSelectionRenderer.reset = new_instancemethod(_fife.CellSelectionRenderer_reset, None, CellSelectionRenderer)
CellSelectionRenderer.selectLocation = new_instancemethod(_fife.CellSelectionRenderer_selectLocation, None, CellSelectionRenderer)
CellSelectionRenderer.deselectLocation = new_instancemethod(_fife.CellSelectionRenderer_deselectLocation, None, CellSelectionRenderer)
CellSelectionRenderer.getLocations = new_instancemethod(_fife.CellSelectionRenderer_getLocations, None, CellSelectionRenderer)
CellSelectionRenderer.setColor = new_instancemethod(_fife.CellSelectionRenderer_setColor, None, CellSelectionRenderer)
CellSelectionRenderer_swigregister = _fife.CellSelectionRenderer_swigregister
CellSelectionRenderer_swigregister(CellSelectionRenderer)

def CellSelectionRenderer_getInstance(cnt):
    """CellSelectionRenderer_getInstance(IRendererContainer cnt) -> CellSelectionRenderer"""
    return _fife.CellSelectionRenderer_getInstance(cnt)

class CoordinateRenderer(RendererBase):
    """Proxy of C++ FIFE::CoordinateRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_CoordinateRenderer

    def getName(self):
        """getName(CoordinateRenderer self) -> std::string"""
        return _fife.CoordinateRenderer_getName(self)


    def setFont(self, font):
        """setFont(CoordinateRenderer self, IFont font)"""
        return _fife.CoordinateRenderer_setFont(self, font)


    def setColor(self, r, g, b):
        """setColor(CoordinateRenderer self, uint8_t r, uint8_t g, uint8_t b)"""
        return _fife.CoordinateRenderer_setColor(self, r, g, b)


    def setZoom(self, enable):
        """setZoom(CoordinateRenderer self, bool enable)"""
        return _fife.CoordinateRenderer_setZoom(self, enable)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> CoordinateRenderer"""
        return _fife.CoordinateRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)
CoordinateRenderer.getName = new_instancemethod(_fife.CoordinateRenderer_getName, None, CoordinateRenderer)
CoordinateRenderer.setFont = new_instancemethod(_fife.CoordinateRenderer_setFont, None, CoordinateRenderer)
CoordinateRenderer.setColor = new_instancemethod(_fife.CoordinateRenderer_setColor, None, CoordinateRenderer)
CoordinateRenderer.setZoom = new_instancemethod(_fife.CoordinateRenderer_setZoom, None, CoordinateRenderer)
CoordinateRenderer_swigregister = _fife.CoordinateRenderer_swigregister
CoordinateRenderer_swigregister(CoordinateRenderer)

def CoordinateRenderer_getInstance(cnt):
    """CoordinateRenderer_getInstance(IRendererContainer cnt) -> CoordinateRenderer"""
    return _fife.CoordinateRenderer_getInstance(cnt)

class FloatingTextRenderer(RendererBase):
    """Proxy of C++ FIFE::FloatingTextRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_FloatingTextRenderer

    def setFont(self, font):
        """setFont(FloatingTextRenderer self, IFont font)"""
        return _fife.FloatingTextRenderer_setFont(self, font)


    def setColor(self, r, g, b, a=255):
        """setColor(FloatingTextRenderer self, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.FloatingTextRenderer_setColor(self, r, g, b, a)


    def setBackground(self, br, bg, bb, ba=255):
        """setBackground(FloatingTextRenderer self, uint8_t br, uint8_t bg, uint8_t bb, uint8_t ba=255)"""
        return _fife.FloatingTextRenderer_setBackground(self, br, bg, bb, ba)


    def setBorder(self, bbr, bbg, bbb, bba=255):
        """setBorder(FloatingTextRenderer self, uint8_t bbr, uint8_t bbg, uint8_t bbb, uint8_t bba=255)"""
        return _fife.FloatingTextRenderer_setBorder(self, bbr, bbg, bbb, bba)


    def resetBackground(self):
        """resetBackground(FloatingTextRenderer self)"""
        return _fife.FloatingTextRenderer_resetBackground(self)


    def resetBorder(self):
        """resetBorder(FloatingTextRenderer self)"""
        return _fife.FloatingTextRenderer_resetBorder(self)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> FloatingTextRenderer"""
        return _fife.FloatingTextRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)
FloatingTextRenderer.setFont = new_instancemethod(_fife.FloatingTextRenderer_setFont, None, FloatingTextRenderer)
FloatingTextRenderer.setColor = new_instancemethod(_fife.FloatingTextRenderer_setColor, None, FloatingTextRenderer)
FloatingTextRenderer.setBackground = new_instancemethod(_fife.FloatingTextRenderer_setBackground, None, FloatingTextRenderer)
FloatingTextRenderer.setBorder = new_instancemethod(_fife.FloatingTextRenderer_setBorder, None, FloatingTextRenderer)
FloatingTextRenderer.resetBackground = new_instancemethod(_fife.FloatingTextRenderer_resetBackground, None, FloatingTextRenderer)
FloatingTextRenderer.resetBorder = new_instancemethod(_fife.FloatingTextRenderer_resetBorder, None, FloatingTextRenderer)
FloatingTextRenderer_swigregister = _fife.FloatingTextRenderer_swigregister
FloatingTextRenderer_swigregister(FloatingTextRenderer)

def FloatingTextRenderer_getInstance(cnt):
    """FloatingTextRenderer_getInstance(IRendererContainer cnt) -> FloatingTextRenderer"""
    return _fife.FloatingTextRenderer_getInstance(cnt)

class GenericRendererElementInfo(object):
    """Proxy of C++ FIFE::GenericRendererElementInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_GenericRendererElementInfo

    def __init__(self):
        """__init__(FIFE::GenericRendererElementInfo self) -> GenericRendererElementInfo"""
        _fife.GenericRendererElementInfo_swiginit(self, _fife.new_GenericRendererElementInfo())
GenericRendererElementInfo_swigregister = _fife.GenericRendererElementInfo_swigregister
GenericRendererElementInfo_swigregister(GenericRendererElementInfo)

class GenericRendererLineInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererLineInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n1, n2, r, g, b, a):
        """__init__(FIFE::GenericRendererLineInfo self, RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererLineInfo"""
        _fife.GenericRendererLineInfo_swiginit(self, _fife.new_GenericRendererLineInfo(n1, n2, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererLineInfo
GenericRendererLineInfo_swigregister = _fife.GenericRendererLineInfo_swigregister
GenericRendererLineInfo_swigregister(GenericRendererLineInfo)

class GenericRendererPointInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererPointInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, r, g, b, a):
        """__init__(FIFE::GenericRendererPointInfo self, RendererNode n, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererPointInfo"""
        _fife.GenericRendererPointInfo_swiginit(self, _fife.new_GenericRendererPointInfo(n, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererPointInfo
GenericRendererPointInfo_swigregister = _fife.GenericRendererPointInfo_swigregister
GenericRendererPointInfo_swigregister(GenericRendererPointInfo)

class GenericRendererTriangleInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererTriangleInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n1, n2, n3, r, g, b, a):
        """__init__(FIFE::GenericRendererTriangleInfo self, RendererNode n1, RendererNode n2, RendererNode n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererTriangleInfo"""
        _fife.GenericRendererTriangleInfo_swiginit(self, _fife.new_GenericRendererTriangleInfo(n1, n2, n3, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererTriangleInfo
GenericRendererTriangleInfo_swigregister = _fife.GenericRendererTriangleInfo_swigregister
GenericRendererTriangleInfo_swigregister(GenericRendererTriangleInfo)

class GenericRendererQuadInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererQuadInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n1, n2, n3, n4, r, g, b, a):
        """__init__(FIFE::GenericRendererQuadInfo self, RendererNode n1, RendererNode n2, RendererNode n3, RendererNode n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererQuadInfo"""
        _fife.GenericRendererQuadInfo_swiginit(self, _fife.new_GenericRendererQuadInfo(n1, n2, n3, n4, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererQuadInfo
GenericRendererQuadInfo_swigregister = _fife.GenericRendererQuadInfo_swigregister
GenericRendererQuadInfo_swigregister(GenericRendererQuadInfo)

class GenericRendererVertexInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererVertexInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, center, size, r, g, b, a):
        """__init__(FIFE::GenericRendererVertexInfo self, RendererNode center, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> GenericRendererVertexInfo"""
        _fife.GenericRendererVertexInfo_swiginit(self, _fife.new_GenericRendererVertexInfo(center, size, r, g, b, a))
    __swig_destroy__ = _fife.delete_GenericRendererVertexInfo
GenericRendererVertexInfo_swigregister = _fife.GenericRendererVertexInfo_swigregister
GenericRendererVertexInfo_swigregister(GenericRendererVertexInfo)

class GenericRendererImageInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererImageInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, image, zoomed=True):
        """__init__(FIFE::GenericRendererImageInfo self, RendererNode n, SharedImagePointer image, bool zoomed=True) -> GenericRendererImageInfo"""
        _fife.GenericRendererImageInfo_swiginit(self, _fife.new_GenericRendererImageInfo(n, image, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererImageInfo
GenericRendererImageInfo_swigregister = _fife.GenericRendererImageInfo_swigregister
GenericRendererImageInfo_swigregister(GenericRendererImageInfo)

class GenericRendererAnimationInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererAnimationInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, animation, zoomed=True):
        """__init__(FIFE::GenericRendererAnimationInfo self, RendererNode n, SharedAnimationPointer animation, bool zoomed=True) -> GenericRendererAnimationInfo"""
        _fife.GenericRendererAnimationInfo_swiginit(self, _fife.new_GenericRendererAnimationInfo(n, animation, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererAnimationInfo
GenericRendererAnimationInfo_swigregister = _fife.GenericRendererAnimationInfo_swigregister
GenericRendererAnimationInfo_swigregister(GenericRendererAnimationInfo)

class GenericRendererTextInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererTextInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, font, text, zoomed=True):
        """__init__(FIFE::GenericRendererTextInfo self, RendererNode n, IFont font, std::string text, bool zoomed=True) -> GenericRendererTextInfo"""
        _fife.GenericRendererTextInfo_swiginit(self, _fife.new_GenericRendererTextInfo(n, font, text, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererTextInfo
GenericRendererTextInfo_swigregister = _fife.GenericRendererTextInfo_swigregister
GenericRendererTextInfo_swigregister(GenericRendererTextInfo)

class GenericRendererResizeInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererResizeInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, image, width, height, zoomed=True):
        """__init__(FIFE::GenericRendererResizeInfo self, RendererNode n, SharedImagePointer image, int32_t width, int32_t height, bool zoomed=True) -> GenericRendererResizeInfo"""
        _fife.GenericRendererResizeInfo_swiginit(self, _fife.new_GenericRendererResizeInfo(n, image, width, height, zoomed))
    __swig_destroy__ = _fife.delete_GenericRendererResizeInfo
GenericRendererResizeInfo_swigregister = _fife.GenericRendererResizeInfo_swigregister
GenericRendererResizeInfo_swigregister(GenericRendererResizeInfo)

class GenericRenderer(RendererBase):
    """Proxy of C++ FIFE::GenericRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, renderbackend, position):
        """__init__(FIFE::GenericRenderer self, RenderBackend renderbackend, int32_t position) -> GenericRenderer"""
        _fife.GenericRenderer_swiginit(self, _fife.new_GenericRenderer(renderbackend, position))
    __swig_destroy__ = _fife.delete_GenericRenderer

    def getName(self):
        """getName(GenericRenderer self) -> std::string"""
        return _fife.GenericRenderer_getName(self)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> GenericRenderer"""
        return _fife.GenericRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)

    def addLine(self, group, n1, n2, r, g, b, a=255):
        """addLine(GenericRenderer self, std::string const & group, RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.GenericRenderer_addLine(self, group, n1, n2, r, g, b, a)


    def addPoint(self, group, n, r, g, b, a=255):
        """addPoint(GenericRenderer self, std::string const & group, RendererNode n, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.GenericRenderer_addPoint(self, group, n, r, g, b, a)


    def addTriangle(self, group, n1, n2, n3, r, g, b, a=255):
        """addTriangle(GenericRenderer self, std::string const & group, RendererNode n1, RendererNode n2, RendererNode n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.GenericRenderer_addTriangle(self, group, n1, n2, n3, r, g, b, a)


    def addQuad(self, group, n1, n2, n3, n4, r, g, b, a=255):
        """addQuad(GenericRenderer self, std::string const & group, RendererNode n1, RendererNode n2, RendererNode n3, RendererNode n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.GenericRenderer_addQuad(self, group, n1, n2, n3, n4, r, g, b, a)


    def addVertex(self, group, n, size, r, g, b, a=255):
        """addVertex(GenericRenderer self, std::string const & group, RendererNode n, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.GenericRenderer_addVertex(self, group, n, size, r, g, b, a)


    def addText(self, group, n, font, text, zoomed=True):
        """addText(GenericRenderer self, std::string const & group, RendererNode n, IFont font, std::string const & text, bool zoomed=True)"""
        return _fife.GenericRenderer_addText(self, group, n, font, text, zoomed)


    def addImage(self, group, n, image, zoomed=True):
        """addImage(GenericRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, bool zoomed=True)"""
        return _fife.GenericRenderer_addImage(self, group, n, image, zoomed)


    def addAnimation(self, group, n, animation, zoomed=True):
        """addAnimation(GenericRenderer self, std::string const & group, RendererNode n, SharedAnimationPointer animation, bool zoomed=True)"""
        return _fife.GenericRenderer_addAnimation(self, group, n, animation, zoomed)


    def resizeImage(self, group, n, image, width, height, zoomed=True):
        """resizeImage(GenericRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, int32_t width, int32_t height, bool zoomed=True)"""
        return _fife.GenericRenderer_resizeImage(self, group, n, image, width, height, zoomed)


    def removeAll(self, *args):
        """
        removeAll(GenericRenderer self, std::string const & group)
        removeAll(GenericRenderer self)
        """
        return _fife.GenericRenderer_removeAll(self, *args)

GenericRenderer.getName = new_instancemethod(_fife.GenericRenderer_getName, None, GenericRenderer)
GenericRenderer.addLine = new_instancemethod(_fife.GenericRenderer_addLine, None, GenericRenderer)
GenericRenderer.addPoint = new_instancemethod(_fife.GenericRenderer_addPoint, None, GenericRenderer)
GenericRenderer.addTriangle = new_instancemethod(_fife.GenericRenderer_addTriangle, None, GenericRenderer)
GenericRenderer.addQuad = new_instancemethod(_fife.GenericRenderer_addQuad, None, GenericRenderer)
GenericRenderer.addVertex = new_instancemethod(_fife.GenericRenderer_addVertex, None, GenericRenderer)
GenericRenderer.addText = new_instancemethod(_fife.GenericRenderer_addText, None, GenericRenderer)
GenericRenderer.addImage = new_instancemethod(_fife.GenericRenderer_addImage, None, GenericRenderer)
GenericRenderer.addAnimation = new_instancemethod(_fife.GenericRenderer_addAnimation, None, GenericRenderer)
GenericRenderer.resizeImage = new_instancemethod(_fife.GenericRenderer_resizeImage, None, GenericRenderer)
GenericRenderer.removeAll = new_instancemethod(_fife.GenericRenderer_removeAll, None, GenericRenderer)
GenericRenderer_swigregister = _fife.GenericRenderer_swigregister
GenericRenderer_swigregister(GenericRenderer)

def GenericRenderer_getInstance(cnt):
    """GenericRenderer_getInstance(IRendererContainer cnt) -> GenericRenderer"""
    return _fife.GenericRenderer_getInstance(cnt)

class GridRenderer(RendererBase):
    """Proxy of C++ FIFE::GridRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_GridRenderer

    def getName(self):
        """getName(GridRenderer self) -> std::string"""
        return _fife.GridRenderer_getName(self)


    def setColor(self, r, g, b):
        """setColor(GridRenderer self, Uint8 r, Uint8 g, Uint8 b)"""
        return _fife.GridRenderer_setColor(self, r, g, b)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> GridRenderer"""
        return _fife.GridRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)
GridRenderer.getName = new_instancemethod(_fife.GridRenderer_getName, None, GridRenderer)
GridRenderer.setColor = new_instancemethod(_fife.GridRenderer_setColor, None, GridRenderer)
GridRenderer_swigregister = _fife.GridRenderer_swigregister
GridRenderer_swigregister(GridRenderer)

def GridRenderer_getInstance(cnt):
    """GridRenderer_getInstance(IRendererContainer cnt) -> GridRenderer"""
    return _fife.GridRenderer_getInstance(cnt)

class InstanceRenderer(RendererBase):
    """Proxy of C++ FIFE::InstanceRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_InstanceRenderer

    def getName(self):
        """getName(InstanceRenderer self) -> std::string"""
        return _fife.InstanceRenderer_getName(self)


    def addOutlined(self, instance, r, g, b, width, threshold=1):
        """addOutlined(InstanceRenderer self, Instance instance, int32_t r, int32_t g, int32_t b, int32_t width, int32_t threshold=1)"""
        return _fife.InstanceRenderer_addOutlined(self, instance, r, g, b, width, threshold)


    def removeOutlined(self, instance):
        """removeOutlined(InstanceRenderer self, Instance instance)"""
        return _fife.InstanceRenderer_removeOutlined(self, instance)


    def removeAllOutlines(self):
        """removeAllOutlines(InstanceRenderer self)"""
        return _fife.InstanceRenderer_removeAllOutlines(self)


    def addColored(self, instance, r, g, b, a=128):
        """addColored(InstanceRenderer self, Instance instance, int32_t r, int32_t g, int32_t b, int32_t a=128)"""
        return _fife.InstanceRenderer_addColored(self, instance, r, g, b, a)


    def removeColored(self, instance):
        """removeColored(InstanceRenderer self, Instance instance)"""
        return _fife.InstanceRenderer_removeColored(self, instance)


    def removeAllColored(self):
        """removeAllColored(InstanceRenderer self)"""
        return _fife.InstanceRenderer_removeAllColored(self)


    def addTransparentArea(self, instance, groups, w, h, trans, front=True):
        """addTransparentArea(InstanceRenderer self, Instance instance, StringList groups, uint32_t w, uint32_t h, uint8_t trans, bool front=True)"""
        return _fife.InstanceRenderer_addTransparentArea(self, instance, groups, w, h, trans, front)


    def removeTransparentArea(self, instance):
        """removeTransparentArea(InstanceRenderer self, Instance instance)"""
        return _fife.InstanceRenderer_removeTransparentArea(self, instance)


    def removeAllTransparentAreas(self):
        """removeAllTransparentAreas(InstanceRenderer self)"""
        return _fife.InstanceRenderer_removeAllTransparentAreas(self)


    def addIgnoreLight(self, groups):
        """addIgnoreLight(InstanceRenderer self, StringList groups)"""
        return _fife.InstanceRenderer_addIgnoreLight(self, groups)


    def removeIgnoreLight(self, groups):
        """removeIgnoreLight(InstanceRenderer self, StringList groups)"""
        return _fife.InstanceRenderer_removeIgnoreLight(self, groups)


    def removeAllIgnoreLight(self):
        """removeAllIgnoreLight(InstanceRenderer self)"""
        return _fife.InstanceRenderer_removeAllIgnoreLight(self)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> InstanceRenderer"""
        return _fife.InstanceRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)

    def setRemoveInterval(self, interval):
        """setRemoveInterval(InstanceRenderer self, uint32_t interval)"""
        return _fife.InstanceRenderer_setRemoveInterval(self, interval)


    def getRemoveInterval(self):
        """getRemoveInterval(InstanceRenderer self) -> uint32_t"""
        return _fife.InstanceRenderer_getRemoveInterval(self)

InstanceRenderer.getName = new_instancemethod(_fife.InstanceRenderer_getName, None, InstanceRenderer)
InstanceRenderer.addOutlined = new_instancemethod(_fife.InstanceRenderer_addOutlined, None, InstanceRenderer)
InstanceRenderer.removeOutlined = new_instancemethod(_fife.InstanceRenderer_removeOutlined, None, InstanceRenderer)
InstanceRenderer.removeAllOutlines = new_instancemethod(_fife.InstanceRenderer_removeAllOutlines, None, InstanceRenderer)
InstanceRenderer.addColored = new_instancemethod(_fife.InstanceRenderer_addColored, None, InstanceRenderer)
InstanceRenderer.removeColored = new_instancemethod(_fife.InstanceRenderer_removeColored, None, InstanceRenderer)
InstanceRenderer.removeAllColored = new_instancemethod(_fife.InstanceRenderer_removeAllColored, None, InstanceRenderer)
InstanceRenderer.addTransparentArea = new_instancemethod(_fife.InstanceRenderer_addTransparentArea, None, InstanceRenderer)
InstanceRenderer.removeTransparentArea = new_instancemethod(_fife.InstanceRenderer_removeTransparentArea, None, InstanceRenderer)
InstanceRenderer.removeAllTransparentAreas = new_instancemethod(_fife.InstanceRenderer_removeAllTransparentAreas, None, InstanceRenderer)
InstanceRenderer.addIgnoreLight = new_instancemethod(_fife.InstanceRenderer_addIgnoreLight, None, InstanceRenderer)
InstanceRenderer.removeIgnoreLight = new_instancemethod(_fife.InstanceRenderer_removeIgnoreLight, None, InstanceRenderer)
InstanceRenderer.removeAllIgnoreLight = new_instancemethod(_fife.InstanceRenderer_removeAllIgnoreLight, None, InstanceRenderer)
InstanceRenderer.setRemoveInterval = new_instancemethod(_fife.InstanceRenderer_setRemoveInterval, None, InstanceRenderer)
InstanceRenderer.getRemoveInterval = new_instancemethod(_fife.InstanceRenderer_getRemoveInterval, None, InstanceRenderer)
InstanceRenderer_swigregister = _fife.InstanceRenderer_swigregister
InstanceRenderer_swigregister(InstanceRenderer)

def InstanceRenderer_getInstance(cnt):
    """InstanceRenderer_getInstance(IRendererContainer cnt) -> InstanceRenderer"""
    return _fife.InstanceRenderer_getInstance(cnt)

class LightRendererElementInfo(object):
    """Proxy of C++ FIFE::LightRendererElementInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererElementInfo

    def getName(self):
        """getName(LightRendererElementInfo self) -> std::string"""
        return _fife.LightRendererElementInfo_getName(self)


    def getNode(self):
        """getNode(LightRendererElementInfo self) -> RendererNode"""
        return _fife.LightRendererElementInfo_getNode(self)


    def getSrcBlend(self):
        """getSrcBlend(LightRendererElementInfo self) -> int32_t"""
        return _fife.LightRendererElementInfo_getSrcBlend(self)


    def getDstBlend(self):
        """getDstBlend(LightRendererElementInfo self) -> int32_t"""
        return _fife.LightRendererElementInfo_getDstBlend(self)


    def setStencil(self, stencil_ref):
        """setStencil(LightRendererElementInfo self, uint8_t stencil_ref)"""
        return _fife.LightRendererElementInfo_setStencil(self, stencil_ref)


    def getStencil(self):
        """getStencil(LightRendererElementInfo self) -> int32_t"""
        return _fife.LightRendererElementInfo_getStencil(self)


    def removeStencil(self):
        """removeStencil(LightRendererElementInfo self)"""
        return _fife.LightRendererElementInfo_removeStencil(self)


    def getColor(self):
        """getColor(LightRendererElementInfo self) -> vectoru"""
        return _fife.LightRendererElementInfo_getColor(self)


    def getRadius(self):
        """getRadius(LightRendererElementInfo self) -> float"""
        return _fife.LightRendererElementInfo_getRadius(self)


    def getSubdivisions(self):
        """getSubdivisions(LightRendererElementInfo self) -> int32_t"""
        return _fife.LightRendererElementInfo_getSubdivisions(self)


    def getXStretch(self):
        """getXStretch(LightRendererElementInfo self) -> float"""
        return _fife.LightRendererElementInfo_getXStretch(self)


    def getYStretch(self):
        """getYStretch(LightRendererElementInfo self) -> float"""
        return _fife.LightRendererElementInfo_getYStretch(self)

LightRendererElementInfo.getName = new_instancemethod(_fife.LightRendererElementInfo_getName, None, LightRendererElementInfo)
LightRendererElementInfo.getNode = new_instancemethod(_fife.LightRendererElementInfo_getNode, None, LightRendererElementInfo)
LightRendererElementInfo.getSrcBlend = new_instancemethod(_fife.LightRendererElementInfo_getSrcBlend, None, LightRendererElementInfo)
LightRendererElementInfo.getDstBlend = new_instancemethod(_fife.LightRendererElementInfo_getDstBlend, None, LightRendererElementInfo)
LightRendererElementInfo.setStencil = new_instancemethod(_fife.LightRendererElementInfo_setStencil, None, LightRendererElementInfo)
LightRendererElementInfo.getStencil = new_instancemethod(_fife.LightRendererElementInfo_getStencil, None, LightRendererElementInfo)
LightRendererElementInfo.removeStencil = new_instancemethod(_fife.LightRendererElementInfo_removeStencil, None, LightRendererElementInfo)
LightRendererElementInfo.getColor = new_instancemethod(_fife.LightRendererElementInfo_getColor, None, LightRendererElementInfo)
LightRendererElementInfo.getRadius = new_instancemethod(_fife.LightRendererElementInfo_getRadius, None, LightRendererElementInfo)
LightRendererElementInfo.getSubdivisions = new_instancemethod(_fife.LightRendererElementInfo_getSubdivisions, None, LightRendererElementInfo)
LightRendererElementInfo.getXStretch = new_instancemethod(_fife.LightRendererElementInfo_getXStretch, None, LightRendererElementInfo)
LightRendererElementInfo.getYStretch = new_instancemethod(_fife.LightRendererElementInfo_getYStretch, None, LightRendererElementInfo)
LightRendererElementInfo_swigregister = _fife.LightRendererElementInfo_swigregister
LightRendererElementInfo_swigregister(LightRendererElementInfo)

class LightRendererImageInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererImageInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererImageInfo

    def getImage(self):
        """getImage(LightRendererImageInfo self) -> SharedImagePointer"""
        return _fife.LightRendererImageInfo_getImage(self)

LightRendererImageInfo.getImage = new_instancemethod(_fife.LightRendererImageInfo_getImage, None, LightRendererImageInfo)
LightRendererImageInfo_swigregister = _fife.LightRendererImageInfo_swigregister
LightRendererImageInfo_swigregister(LightRendererImageInfo)

class LightRendererAnimationInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererAnimationInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererAnimationInfo

    def getAnimation(self):
        """getAnimation(LightRendererAnimationInfo self) -> SharedAnimationPointer"""
        return _fife.LightRendererAnimationInfo_getAnimation(self)

LightRendererAnimationInfo.getAnimation = new_instancemethod(_fife.LightRendererAnimationInfo_getAnimation, None, LightRendererAnimationInfo)
LightRendererAnimationInfo_swigregister = _fife.LightRendererAnimationInfo_swigregister
LightRendererAnimationInfo_swigregister(LightRendererAnimationInfo)

class LightRendererSimpleLightInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererSimpleLightInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererSimpleLightInfo

    def getColor(self):
        """getColor(LightRendererSimpleLightInfo self) -> vectoru"""
        return _fife.LightRendererSimpleLightInfo_getColor(self)


    def getRadius(self):
        """getRadius(LightRendererSimpleLightInfo self) -> float"""
        return _fife.LightRendererSimpleLightInfo_getRadius(self)


    def getSubdivisions(self):
        """getSubdivisions(LightRendererSimpleLightInfo self) -> int32_t"""
        return _fife.LightRendererSimpleLightInfo_getSubdivisions(self)


    def getXStretch(self):
        """getXStretch(LightRendererSimpleLightInfo self) -> float"""
        return _fife.LightRendererSimpleLightInfo_getXStretch(self)


    def getYStretch(self):
        """getYStretch(LightRendererSimpleLightInfo self) -> float"""
        return _fife.LightRendererSimpleLightInfo_getYStretch(self)

LightRendererSimpleLightInfo.getColor = new_instancemethod(_fife.LightRendererSimpleLightInfo_getColor, None, LightRendererSimpleLightInfo)
LightRendererSimpleLightInfo.getRadius = new_instancemethod(_fife.LightRendererSimpleLightInfo_getRadius, None, LightRendererSimpleLightInfo)
LightRendererSimpleLightInfo.getSubdivisions = new_instancemethod(_fife.LightRendererSimpleLightInfo_getSubdivisions, None, LightRendererSimpleLightInfo)
LightRendererSimpleLightInfo.getXStretch = new_instancemethod(_fife.LightRendererSimpleLightInfo_getXStretch, None, LightRendererSimpleLightInfo)
LightRendererSimpleLightInfo.getYStretch = new_instancemethod(_fife.LightRendererSimpleLightInfo_getYStretch, None, LightRendererSimpleLightInfo)
LightRendererSimpleLightInfo_swigregister = _fife.LightRendererSimpleLightInfo_swigregister
LightRendererSimpleLightInfo_swigregister(LightRendererSimpleLightInfo)

class LightRendererResizeInfo(LightRendererElementInfo):
    """Proxy of C++ FIFE::LightRendererResizeInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_LightRendererResizeInfo

    def getImage(self):
        """getImage(LightRendererResizeInfo self) -> SharedImagePointer"""
        return _fife.LightRendererResizeInfo_getImage(self)

LightRendererResizeInfo.getImage = new_instancemethod(_fife.LightRendererResizeInfo_getImage, None, LightRendererResizeInfo)
LightRendererResizeInfo_swigregister = _fife.LightRendererResizeInfo_swigregister
LightRendererResizeInfo_swigregister(LightRendererResizeInfo)

class LightRenderer(RendererBase):
    """Proxy of C++ FIFE::LightRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, renderbackend, position):
        """__init__(FIFE::LightRenderer self, RenderBackend renderbackend, int32_t position) -> LightRenderer"""
        _fife.LightRenderer_swiginit(self, _fife.new_LightRenderer(renderbackend, position))
    __swig_destroy__ = _fife.delete_LightRenderer

    def getName(self):
        """getName(LightRenderer self) -> std::string"""
        return _fife.LightRenderer_getName(self)


    def getInstance(cnt):
        """getInstance(IRendererContainer cnt) -> LightRenderer"""
        return _fife.LightRenderer_getInstance(cnt)

    getInstance = staticmethod(getInstance)

    def addImage(self, group, n, image, src=-1, dst=-1):
        """addImage(LightRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, int32_t src=-1, int32_t dst=-1)"""
        return _fife.LightRenderer_addImage(self, group, n, image, src, dst)


    def addAnimation(self, group, n, animation, src=-1, dst=-1):
        """addAnimation(LightRenderer self, std::string const & group, RendererNode n, SharedAnimationPointer animation, int32_t src=-1, int32_t dst=-1)"""
        return _fife.LightRenderer_addAnimation(self, group, n, animation, src, dst)


    def addSimpleLight(self, group, n, intensity, radius, subdivisions, xstretch, ystretch, r, g, b, src=-1, dst=-1):
        """addSimpleLight(LightRenderer self, std::string const & 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)"""
        return _fife.LightRenderer_addSimpleLight(self, group, n, intensity, radius, subdivisions, xstretch, ystretch, r, g, b, src, dst)


    def resizeImage(self, group, n, image, width, height, src=-1, dst=-1):
        """resizeImage(LightRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, int32_t width, int32_t height, int32_t src=-1, int32_t dst=-1)"""
        return _fife.LightRenderer_resizeImage(self, group, n, image, width, height, src, dst)


    def addStencilTest(self, group, stencil_ref=0):
        """addStencilTest(LightRenderer self, std::string const & group, uint8_t stencil_ref=0)"""
        return _fife.LightRenderer_addStencilTest(self, group, stencil_ref)


    def removeStencilTest(self, group):
        """removeStencilTest(LightRenderer self, std::string const & group)"""
        return _fife.LightRenderer_removeStencilTest(self, group)


    def getGroups(self):
        """getGroups(LightRenderer self) -> StringList"""
        return _fife.LightRenderer_getGroups(self)


    def getLightInfo(self, group):
        """getLightInfo(LightRenderer self, std::string const & group) -> LightRendererElementInfoVector"""
        return _fife.LightRenderer_getLightInfo(self, group)


    def removeAll(self, *args):
        """
        removeAll(LightRenderer self, std::string const & group)
        removeAll(LightRenderer self)
        """
        return _fife.LightRenderer_removeAll(self, *args)

LightRenderer.getName = new_instancemethod(_fife.LightRenderer_getName, None, LightRenderer)
LightRenderer.addImage = new_instancemethod(_fife.LightRenderer_addImage, None, LightRenderer)
LightRenderer.addAnimation = new_instancemethod(_fife.LightRenderer_addAnimation, None, LightRenderer)
LightRenderer.addSimpleLight = new_instancemethod(_fife.LightRenderer_addSimpleLight, None, LightRenderer)
LightRenderer.resizeImage = new_instancemethod(_fife.LightRenderer_resizeImage, None, LightRenderer)
LightRenderer.addStencilTest = new_instancemethod(_fife.LightRenderer_addStencilTest, None, LightRenderer)
LightRenderer.removeStencilTest = new_instancemethod(_fife.LightRenderer_removeStencilTest, None, LightRenderer)
LightRenderer.getGroups = new_instancemethod(_fife.LightRenderer_getGroups, None, LightRenderer)
LightRenderer.getLightInfo = new_instancemethod(_fife.LightRenderer_getLightInfo, None, LightRenderer)
LightRenderer.removeAll = new_instancemethod(_fife.LightRenderer_removeAll, None, LightRenderer)
LightRenderer_swigregister = _fife.LightRenderer_swigregister
LightRenderer_swigregister(LightRenderer)

def LightRenderer_getInstance(cnt):
    """LightRenderer_getInstance(IRendererContainer cnt) -> LightRenderer"""
    return _fife.LightRenderer_getInstance(cnt)

class LightRendererElementInfoVector(object):
    """Proxy of C++ std::vector<(p.FIFE::LightRendererElementInfo)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def iterator(self):
        """iterator(LightRendererElementInfoVector self) -> SwigPyIterator"""
        return _fife.LightRendererElementInfoVector_iterator(self)

    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        """__nonzero__(LightRendererElementInfoVector self) -> bool"""
        return _fife.LightRendererElementInfoVector___nonzero__(self)


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


    def __len__(self):
        """__len__(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::size_type"""
        return _fife.LightRendererElementInfoVector___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::difference_type i, std::vector< FIFE::LightRendererElementInfo * >::difference_type j) -> LightRendererElementInfoVector"""
        return _fife.LightRendererElementInfoVector___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::difference_type i, std::vector< FIFE::LightRendererElementInfo * >::difference_type j)
        __setslice__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::difference_type i, std::vector< FIFE::LightRendererElementInfo * >::difference_type j, LightRendererElementInfoVector v)
        """
        return _fife.LightRendererElementInfoVector___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::difference_type i, std::vector< FIFE::LightRendererElementInfo * >::difference_type j)"""
        return _fife.LightRendererElementInfoVector___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::difference_type i)
        __delitem__(LightRendererElementInfoVector self, PySliceObject * slice)
        """
        return _fife.LightRendererElementInfoVector___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(LightRendererElementInfoVector self, PySliceObject * slice) -> LightRendererElementInfoVector
        __getitem__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::difference_type i) -> LightRendererElementInfo
        """
        return _fife.LightRendererElementInfoVector___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(LightRendererElementInfoVector self, PySliceObject * slice, LightRendererElementInfoVector v)
        __setitem__(LightRendererElementInfoVector self, PySliceObject * slice)
        __setitem__(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::difference_type i, LightRendererElementInfo x)
        """
        return _fife.LightRendererElementInfoVector___setitem__(self, *args)


    def pop(self):
        """pop(LightRendererElementInfoVector self) -> LightRendererElementInfo"""
        return _fife.LightRendererElementInfoVector_pop(self)


    def append(self, x):
        """append(LightRendererElementInfoVector self, LightRendererElementInfo x)"""
        return _fife.LightRendererElementInfoVector_append(self, x)


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


    def size(self):
        """size(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::size_type"""
        return _fife.LightRendererElementInfoVector_size(self)


    def swap(self, v):
        """swap(LightRendererElementInfoVector self, LightRendererElementInfoVector v)"""
        return _fife.LightRendererElementInfoVector_swap(self, v)


    def begin(self):
        """begin(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::iterator"""
        return _fife.LightRendererElementInfoVector_begin(self)


    def end(self):
        """end(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::iterator"""
        return _fife.LightRendererElementInfoVector_end(self)


    def rbegin(self):
        """rbegin(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::reverse_iterator"""
        return _fife.LightRendererElementInfoVector_rbegin(self)


    def rend(self):
        """rend(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::reverse_iterator"""
        return _fife.LightRendererElementInfoVector_rend(self)


    def clear(self):
        """clear(LightRendererElementInfoVector self)"""
        return _fife.LightRendererElementInfoVector_clear(self)


    def get_allocator(self):
        """get_allocator(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::allocator_type"""
        return _fife.LightRendererElementInfoVector_get_allocator(self)


    def pop_back(self):
        """pop_back(LightRendererElementInfoVector self)"""
        return _fife.LightRendererElementInfoVector_pop_back(self)


    def erase(self, *args):
        """
        erase(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::iterator pos) -> std::vector< FIFE::LightRendererElementInfo * >::iterator
        erase(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::iterator first, std::vector< FIFE::LightRendererElementInfo * >::iterator last) -> std::vector< FIFE::LightRendererElementInfo * >::iterator
        """
        return _fife.LightRendererElementInfoVector_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(p.FIFE::LightRendererElementInfo)> self) -> LightRendererElementInfoVector
        __init__(std::vector<(p.FIFE::LightRendererElementInfo)> self, LightRendererElementInfoVector arg2) -> LightRendererElementInfoVector
        __init__(std::vector<(p.FIFE::LightRendererElementInfo)> self, std::vector< FIFE::LightRendererElementInfo * >::size_type size) -> LightRendererElementInfoVector
        __init__(std::vector<(p.FIFE::LightRendererElementInfo)> self, std::vector< FIFE::LightRendererElementInfo * >::size_type size, LightRendererElementInfo value) -> LightRendererElementInfoVector
        """
        _fife.LightRendererElementInfoVector_swiginit(self, _fife.new_LightRendererElementInfoVector(*args))

    def push_back(self, x):
        """push_back(LightRendererElementInfoVector self, LightRendererElementInfo x)"""
        return _fife.LightRendererElementInfoVector_push_back(self, x)


    def front(self):
        """front(LightRendererElementInfoVector self) -> LightRendererElementInfo"""
        return _fife.LightRendererElementInfoVector_front(self)


    def back(self):
        """back(LightRendererElementInfoVector self) -> LightRendererElementInfo"""
        return _fife.LightRendererElementInfoVector_back(self)


    def assign(self, n, x):
        """assign(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::size_type n, LightRendererElementInfo x)"""
        return _fife.LightRendererElementInfoVector_assign(self, n, x)


    def resize(self, *args):
        """
        resize(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::size_type new_size)
        resize(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::size_type new_size, LightRendererElementInfo x)
        """
        return _fife.LightRendererElementInfoVector_resize(self, *args)


    def insert(self, *args):
        """
        insert(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::iterator pos, LightRendererElementInfo x) -> std::vector< FIFE::LightRendererElementInfo * >::iterator
        insert(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::iterator pos, std::vector< FIFE::LightRendererElementInfo * >::size_type n, LightRendererElementInfo x)
        """
        return _fife.LightRendererElementInfoVector_insert(self, *args)


    def reserve(self, n):
        """reserve(LightRendererElementInfoVector self, std::vector< FIFE::LightRendererElementInfo * >::size_type n)"""
        return _fife.LightRendererElementInfoVector_reserve(self, n)


    def capacity(self):
        """capacity(LightRendererElementInfoVector self) -> std::vector< FIFE::LightRendererElementInfo * >::size_type"""
        return _fife.LightRendererElementInfoVector_capacity(self)

    __swig_destroy__ = _fife.delete_LightRendererElementInfoVector
LightRendererElementInfoVector.iterator = new_instancemethod(_fife.LightRendererElementInfoVector_iterator, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__nonzero__ = new_instancemethod(_fife.LightRendererElementInfoVector___nonzero__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__bool__ = new_instancemethod(_fife.LightRendererElementInfoVector___bool__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__len__ = new_instancemethod(_fife.LightRendererElementInfoVector___len__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__getslice__ = new_instancemethod(_fife.LightRendererElementInfoVector___getslice__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__setslice__ = new_instancemethod(_fife.LightRendererElementInfoVector___setslice__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__delslice__ = new_instancemethod(_fife.LightRendererElementInfoVector___delslice__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__delitem__ = new_instancemethod(_fife.LightRendererElementInfoVector___delitem__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__getitem__ = new_instancemethod(_fife.LightRendererElementInfoVector___getitem__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.__setitem__ = new_instancemethod(_fife.LightRendererElementInfoVector___setitem__, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.pop = new_instancemethod(_fife.LightRendererElementInfoVector_pop, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.append = new_instancemethod(_fife.LightRendererElementInfoVector_append, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.empty = new_instancemethod(_fife.LightRendererElementInfoVector_empty, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.size = new_instancemethod(_fife.LightRendererElementInfoVector_size, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.swap = new_instancemethod(_fife.LightRendererElementInfoVector_swap, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.begin = new_instancemethod(_fife.LightRendererElementInfoVector_begin, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.end = new_instancemethod(_fife.LightRendererElementInfoVector_end, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.rbegin = new_instancemethod(_fife.LightRendererElementInfoVector_rbegin, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.rend = new_instancemethod(_fife.LightRendererElementInfoVector_rend, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.clear = new_instancemethod(_fife.LightRendererElementInfoVector_clear, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.get_allocator = new_instancemethod(_fife.LightRendererElementInfoVector_get_allocator, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.pop_back = new_instancemethod(_fife.LightRendererElementInfoVector_pop_back, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.erase = new_instancemethod(_fife.LightRendererElementInfoVector_erase, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.push_back = new_instancemethod(_fife.LightRendererElementInfoVector_push_back, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.front = new_instancemethod(_fife.LightRendererElementInfoVector_front, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.back = new_instancemethod(_fife.LightRendererElementInfoVector_back, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.assign = new_instancemethod(_fife.LightRendererElementInfoVector_assign, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.resize = new_instancemethod(_fife.LightRendererElementInfoVector_resize, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.insert = new_instancemethod(_fife.LightRendererElementInfoVector_insert, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.reserve = new_instancemethod(_fife.LightRendererElementInfoVector_reserve, None, LightRendererElementInfoVector)
LightRendererElementInfoVector.capacity = new_instancemethod(_fife.LightRendererElementInfoVector_capacity, None, LightRendererElementInfoVector)
LightRendererElementInfoVector_swigregister = _fife.LightRendererElementInfoVector_swigregister
LightRendererElementInfoVector_swigregister(LightRendererElementInfoVector)

class OffRendererElementInfo(object):
    """Proxy of C++ FIFE::OffRendererElementInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_OffRendererElementInfo

    def __init__(self):
        """__init__(FIFE::OffRendererElementInfo self) -> OffRendererElementInfo"""
        _fife.OffRendererElementInfo_swiginit(self, _fife.new_OffRendererElementInfo())
OffRendererElementInfo_swigregister = _fife.OffRendererElementInfo_swigregister
OffRendererElementInfo_swigregister(OffRendererElementInfo)

class OffRendererLineInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererLineInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n1, n2, r, g, b, a):
        """__init__(FIFE::OffRendererLineInfo self, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererLineInfo"""
        _fife.OffRendererLineInfo_swiginit(self, _fife.new_OffRendererLineInfo(n1, n2, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererLineInfo
OffRendererLineInfo_swigregister = _fife.OffRendererLineInfo_swigregister
OffRendererLineInfo_swigregister(OffRendererLineInfo)

class OffRendererPointInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererPointInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, r, g, b, a):
        """__init__(FIFE::OffRendererPointInfo self, Point n, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererPointInfo"""
        _fife.OffRendererPointInfo_swiginit(self, _fife.new_OffRendererPointInfo(n, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererPointInfo
OffRendererPointInfo_swigregister = _fife.OffRendererPointInfo_swigregister
OffRendererPointInfo_swigregister(OffRendererPointInfo)

class OffRendererTriangleInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererTriangleInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n1, n2, n3, r, g, b, a):
        """__init__(FIFE::OffRendererTriangleInfo self, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererTriangleInfo"""
        _fife.OffRendererTriangleInfo_swiginit(self, _fife.new_OffRendererTriangleInfo(n1, n2, n3, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererTriangleInfo
OffRendererTriangleInfo_swigregister = _fife.OffRendererTriangleInfo_swigregister
OffRendererTriangleInfo_swigregister(OffRendererTriangleInfo)

class OffRendererQuadInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererQuadInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n1, n2, n3, n4, r, g, b, a):
        """__init__(FIFE::OffRendererQuadInfo self, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererQuadInfo"""
        _fife.OffRendererQuadInfo_swiginit(self, _fife.new_OffRendererQuadInfo(n1, n2, n3, n4, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererQuadInfo
OffRendererQuadInfo_swigregister = _fife.OffRendererQuadInfo_swigregister
OffRendererQuadInfo_swigregister(OffRendererQuadInfo)

class OffRendererVertexInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererVertexInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, center, size, r, g, b, a):
        """__init__(FIFE::OffRendererVertexInfo self, Point center, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a) -> OffRendererVertexInfo"""
        _fife.OffRendererVertexInfo_swiginit(self, _fife.new_OffRendererVertexInfo(center, size, r, g, b, a))
    __swig_destroy__ = _fife.delete_OffRendererVertexInfo
OffRendererVertexInfo_swigregister = _fife.OffRendererVertexInfo_swigregister
OffRendererVertexInfo_swigregister(OffRendererVertexInfo)

class OffRendererImageInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererImageInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, image):
        """__init__(FIFE::OffRendererImageInfo self, Point n, SharedImagePointer image) -> OffRendererImageInfo"""
        _fife.OffRendererImageInfo_swiginit(self, _fife.new_OffRendererImageInfo(n, image))
    __swig_destroy__ = _fife.delete_OffRendererImageInfo
OffRendererImageInfo_swigregister = _fife.OffRendererImageInfo_swigregister
OffRendererImageInfo_swigregister(OffRendererImageInfo)

class OffRendererAnimationInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererAnimationInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, animation):
        """__init__(FIFE::OffRendererAnimationInfo self, Point n, SharedAnimationPointer animation) -> OffRendererAnimationInfo"""
        _fife.OffRendererAnimationInfo_swiginit(self, _fife.new_OffRendererAnimationInfo(n, animation))
    __swig_destroy__ = _fife.delete_OffRendererAnimationInfo
OffRendererAnimationInfo_swigregister = _fife.OffRendererAnimationInfo_swigregister
OffRendererAnimationInfo_swigregister(OffRendererAnimationInfo)

class OffRendererTextInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererTextInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, font, text):
        """__init__(FIFE::OffRendererTextInfo self, Point n, IFont font, std::string text) -> OffRendererTextInfo"""
        _fife.OffRendererTextInfo_swiginit(self, _fife.new_OffRendererTextInfo(n, font, text))
    __swig_destroy__ = _fife.delete_OffRendererTextInfo
OffRendererTextInfo_swigregister = _fife.OffRendererTextInfo_swigregister
OffRendererTextInfo_swigregister(OffRendererTextInfo)

class OffRendererResizeInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererResizeInfo class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, n, image, width, height):
        """__init__(FIFE::OffRendererResizeInfo self, Point n, SharedImagePointer image, int32_t width, int32_t height) -> OffRendererResizeInfo"""
        _fife.OffRendererResizeInfo_swiginit(self, _fife.new_OffRendererResizeInfo(n, image, width, height))
    __swig_destroy__ = _fife.delete_OffRendererResizeInfo
OffRendererResizeInfo_swigregister = _fife.OffRendererResizeInfo_swigregister
OffRendererResizeInfo_swigregister(OffRendererResizeInfo)

class OffRenderer(object):
    """Proxy of C++ FIFE::OffRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, renderbackend):
        """__init__(FIFE::OffRenderer self, RenderBackend renderbackend) -> OffRenderer"""
        _fife.OffRenderer_swiginit(self, _fife.new_OffRenderer(renderbackend))
    __swig_destroy__ = _fife.delete_OffRenderer

    def setEnabled(self, enabled):
        """setEnabled(OffRenderer self, bool enabled)"""
        return _fife.OffRenderer_setEnabled(self, enabled)


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


    def setClipArea(self, area):
        """setClipArea(OffRenderer self, Rect area)"""
        return _fife.OffRenderer_setClipArea(self, area)


    def getClipArea(self):
        """getClipArea(OffRenderer self) -> Rect"""
        return _fife.OffRenderer_getClipArea(self)


    def addLine(self, group, n1, n2, r, g, b, a=255):
        """addLine(OffRenderer self, std::string const & group, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.OffRenderer_addLine(self, group, n1, n2, r, g, b, a)


    def addPoint(self, group, n, r, g, b, a=255):
        """addPoint(OffRenderer self, std::string const & group, Point n, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.OffRenderer_addPoint(self, group, n, r, g, b, a)


    def addTriangle(self, group, n1, n2, n3, r, g, b, a=255):
        """addTriangle(OffRenderer self, std::string const & group, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.OffRenderer_addTriangle(self, group, n1, n2, n3, r, g, b, a)


    def addQuad(self, group, n1, n2, n3, n4, r, g, b, a=255):
        """addQuad(OffRenderer self, std::string const & group, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.OffRenderer_addQuad(self, group, n1, n2, n3, n4, r, g, b, a)


    def addVertex(self, group, n, size, r, g, b, a=255):
        """addVertex(OffRenderer self, std::string const & group, Point n, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.OffRenderer_addVertex(self, group, n, size, r, g, b, a)


    def addText(self, group, n, font, text):
        """addText(OffRenderer self, std::string const & group, Point n, IFont font, std::string const & text)"""
        return _fife.OffRenderer_addText(self, group, n, font, text)


    def addImage(self, group, n, image):
        """addImage(OffRenderer self, std::string const & group, Point n, SharedImagePointer image)"""
        return _fife.OffRenderer_addImage(self, group, n, image)


    def addAnimation(self, group, n, animation):
        """addAnimation(OffRenderer self, std::string const & group, Point n, SharedAnimationPointer animation)"""
        return _fife.OffRenderer_addAnimation(self, group, n, animation)


    def resizeImage(self, group, n, image, width, height):
        """resizeImage(OffRenderer self, std::string const & group, Point n, SharedImagePointer image, int32_t width, int32_t height)"""
        return _fife.OffRenderer_resizeImage(self, group, n, image, width, height)


    def removeAll(self, *args):
        """
        removeAll(OffRenderer self, std::string const & group)
        removeAll(OffRenderer self)
        """
        return _fife.OffRenderer_removeAll(self, *args)

OffRenderer.setEnabled = new_instancemethod(_fife.OffRenderer_setEnabled, None, OffRenderer)
OffRenderer.isEnabled = new_instancemethod(_fife.OffRenderer_isEnabled, None, OffRenderer)
OffRenderer.setClipArea = new_instancemethod(_fife.OffRenderer_setClipArea, None, OffRenderer)
OffRenderer.getClipArea = new_instancemethod(_fife.OffRenderer_getClipArea, None, OffRenderer)
OffRenderer.addLine = new_instancemethod(_fife.OffRenderer_addLine, None, OffRenderer)
OffRenderer.addPoint = new_instancemethod(_fife.OffRenderer_addPoint, None, OffRenderer)
OffRenderer.addTriangle = new_instancemethod(_fife.OffRenderer_addTriangle, None, OffRenderer)
OffRenderer.addQuad = new_instancemethod(_fife.OffRenderer_addQuad, None, OffRenderer)
OffRenderer.addVertex = new_instancemethod(_fife.OffRenderer_addVertex, None, OffRenderer)
OffRenderer.addText = new_instancemethod(_fife.OffRenderer_addText, None, OffRenderer)
OffRenderer.addImage = new_instancemethod(_fife.OffRenderer_addImage, None, OffRenderer)
OffRenderer.addAnimation = new_instancemethod(_fife.OffRenderer_addAnimation, None, OffRenderer)
OffRenderer.resizeImage = new_instancemethod(_fife.OffRenderer_resizeImage, None, OffRenderer)
OffRenderer.removeAll = new_instancemethod(_fife.OffRenderer_removeAll, None, OffRenderer)
OffRenderer_swigregister = _fife.OffRenderer_swigregister
OffRenderer_swigregister(OffRenderer)

class RenderTarget(object):
    """Proxy of C++ FIFE::RenderTarget class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_RenderTarget

    def addLine(self, group, n1, n2, r, g, b, a=255):
        """addLine(RenderTarget self, std::string const & group, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.RenderTarget_addLine(self, group, n1, n2, r, g, b, a)


    def addPoint(self, group, n, r, g, b, a=255):
        """addPoint(RenderTarget self, std::string const & group, Point n, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.RenderTarget_addPoint(self, group, n, r, g, b, a)


    def addTriangle(self, group, n1, n2, n3, r, g, b, a=255):
        """addTriangle(RenderTarget self, std::string const & group, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.RenderTarget_addTriangle(self, group, n1, n2, n3, r, g, b, a)


    def addQuad(self, group, n1, n2, n3, n4, r, g, b, a=255):
        """addQuad(RenderTarget self, std::string const & group, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.RenderTarget_addQuad(self, group, n1, n2, n3, n4, r, g, b, a)


    def addVertex(self, group, n, size, r, g, b, a=255):
        """addVertex(RenderTarget self, std::string const & group, Point n, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.RenderTarget_addVertex(self, group, n, size, r, g, b, a)


    def addText(self, group, n, font, text):
        """addText(RenderTarget self, std::string const & group, Point n, IFont font, std::string const & text)"""
        return _fife.RenderTarget_addText(self, group, n, font, text)


    def addImage(self, group, n, image):
        """addImage(RenderTarget self, std::string const & group, Point n, SharedImagePointer image)"""
        return _fife.RenderTarget_addImage(self, group, n, image)


    def addAnimation(self, group, n, animation):
        """addAnimation(RenderTarget self, std::string const & group, Point n, SharedAnimationPointer animation)"""
        return _fife.RenderTarget_addAnimation(self, group, n, animation)


    def resizeImage(self, group, n, image, width, height):
        """resizeImage(RenderTarget self, std::string const & group, Point n, SharedImagePointer image, int32_t width, int32_t height)"""
        return _fife.RenderTarget_resizeImage(self, group, n, image, width, height)


    def removeAll(self, *args):
        """
        removeAll(RenderTarget self, std::string const & group)
        removeAll(RenderTarget self)
        """
        return _fife.RenderTarget_removeAll(self, *args)


    def render(self):
        """render(RenderTarget self)"""
        return _fife.RenderTarget_render(self)


    def getTarget(self):
        """getTarget(RenderTarget self) -> SharedImagePointer"""
        return _fife.RenderTarget_getTarget(self)

RenderTarget.addLine = new_instancemethod(_fife.RenderTarget_addLine, None, RenderTarget)
RenderTarget.addPoint = new_instancemethod(_fife.RenderTarget_addPoint, None, RenderTarget)
RenderTarget.addTriangle = new_instancemethod(_fife.RenderTarget_addTriangle, None, RenderTarget)
RenderTarget.addQuad = new_instancemethod(_fife.RenderTarget_addQuad, None, RenderTarget)
RenderTarget.addVertex = new_instancemethod(_fife.RenderTarget_addVertex, None, RenderTarget)
RenderTarget.addText = new_instancemethod(_fife.RenderTarget_addText, None, RenderTarget)
RenderTarget.addImage = new_instancemethod(_fife.RenderTarget_addImage, None, RenderTarget)
RenderTarget.addAnimation = new_instancemethod(_fife.RenderTarget_addAnimation, None, RenderTarget)
RenderTarget.resizeImage = new_instancemethod(_fife.RenderTarget_resizeImage, None, RenderTarget)
RenderTarget.removeAll = new_instancemethod(_fife.RenderTarget_removeAll, None, RenderTarget)
RenderTarget.render = new_instancemethod(_fife.RenderTarget_render, None, RenderTarget)
RenderTarget.getTarget = new_instancemethod(_fife.RenderTarget_getTarget, None, RenderTarget)
RenderTarget_swigregister = _fife.RenderTarget_swigregister
RenderTarget_swigregister(RenderTarget)

class SharedRenderTargetPointer(object):
    """Proxy of C++ FIFE::SharedPtr<(FIFE::RenderTarget)> class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::SharedPtr<(FIFE::RenderTarget)> self) -> SharedRenderTargetPointer
        __init__(FIFE::SharedPtr<(FIFE::RenderTarget)> self, SharedRenderTargetPointer rhs) -> SharedRenderTargetPointer
        """
        _fife.SharedRenderTargetPointer_swiginit(self, _fife.new_SharedRenderTargetPointer(*args))
    __swig_destroy__ = _fife.delete_SharedRenderTargetPointer

    def __ref__(self):
        """__ref__(SharedRenderTargetPointer self) -> RenderTarget"""
        return _fife.SharedRenderTargetPointer___ref__(self)


    def __deref__(self):
        """__deref__(SharedRenderTargetPointer self) -> RenderTarget"""
        return _fife.SharedRenderTargetPointer___deref__(self)


    def get(self):
        """get(SharedRenderTargetPointer self) -> RenderTarget"""
        return _fife.SharedRenderTargetPointer_get(self)


    def reset(self, ptr=None):
        """reset(SharedRenderTargetPointer self, RenderTarget ptr=None)"""
        return _fife.SharedRenderTargetPointer_reset(self, ptr)


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


    def useCountPtr(self):
        """useCountPtr(SharedRenderTargetPointer self) -> uint32_t *"""
        return _fife.SharedRenderTargetPointer_useCountPtr(self)


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


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



    def addLine(self, group, n1, n2, r, g, b, a=255):
        """addLine(SharedRenderTargetPointer self, std::string const & group, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.SharedRenderTargetPointer_addLine(self, group, n1, n2, r, g, b, a)


    def addPoint(self, group, n, r, g, b, a=255):
        """addPoint(SharedRenderTargetPointer self, std::string const & group, Point n, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.SharedRenderTargetPointer_addPoint(self, group, n, r, g, b, a)


    def addTriangle(self, group, n1, n2, n3, r, g, b, a=255):
        """addTriangle(SharedRenderTargetPointer self, std::string const & group, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.SharedRenderTargetPointer_addTriangle(self, group, n1, n2, n3, r, g, b, a)


    def addQuad(self, group, n1, n2, n3, n4, r, g, b, a=255):
        """addQuad(SharedRenderTargetPointer self, std::string const & group, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.SharedRenderTargetPointer_addQuad(self, group, n1, n2, n3, n4, r, g, b, a)


    def addVertex(self, group, n, size, r, g, b, a=255):
        """addVertex(SharedRenderTargetPointer self, std::string const & group, Point n, int32_t size, uint8_t r, uint8_t g, uint8_t b, uint8_t a=255)"""
        return _fife.SharedRenderTargetPointer_addVertex(self, group, n, size, r, g, b, a)


    def addText(self, group, n, font, text):
        """addText(SharedRenderTargetPointer self, std::string const & group, Point n, IFont font, std::string const & text)"""
        return _fife.SharedRenderTargetPointer_addText(self, group, n, font, text)


    def addImage(self, group, n, image):
        """addImage(SharedRenderTargetPointer self, std::string const & group, Point n, SharedImagePointer image)"""
        return _fife.SharedRenderTargetPointer_addImage(self, group, n, image)


    def addAnimation(self, group, n, animation):
        """addAnimation(SharedRenderTargetPointer self, std::string const & group, Point n, SharedAnimationPointer animation)"""
        return _fife.SharedRenderTargetPointer_addAnimation(self, group, n, animation)


    def resizeImage(self, group, n, image, width, height):
        """resizeImage(SharedRenderTargetPointer self, std::string const & group, Point n, SharedImagePointer image, int32_t width, int32_t height)"""
        return _fife.SharedRenderTargetPointer_resizeImage(self, group, n, image, width, height)


    def removeAll(self, *args):
        """
        removeAll(SharedRenderTargetPointer self, std::string const & group)
        removeAll(SharedRenderTargetPointer self)
        """
        return _fife.SharedRenderTargetPointer_removeAll(self, *args)


    def render(self):
        """render(SharedRenderTargetPointer self)"""
        return _fife.SharedRenderTargetPointer_render(self)


    def getTarget(self):
        """getTarget(SharedRenderTargetPointer self) -> SharedImagePointer"""
        return _fife.SharedRenderTargetPointer_getTarget(self)

SharedRenderTargetPointer.__ref__ = new_instancemethod(_fife.SharedRenderTargetPointer___ref__, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.__deref__ = new_instancemethod(_fife.SharedRenderTargetPointer___deref__, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.get = new_instancemethod(_fife.SharedRenderTargetPointer_get, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.reset = new_instancemethod(_fife.SharedRenderTargetPointer_reset, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.useCount = new_instancemethod(_fife.SharedRenderTargetPointer_useCount, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.useCountPtr = new_instancemethod(_fife.SharedRenderTargetPointer_useCountPtr, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.unique = new_instancemethod(_fife.SharedRenderTargetPointer_unique, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addLine = new_instancemethod(_fife.SharedRenderTargetPointer_addLine, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addPoint = new_instancemethod(_fife.SharedRenderTargetPointer_addPoint, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addTriangle = new_instancemethod(_fife.SharedRenderTargetPointer_addTriangle, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addQuad = new_instancemethod(_fife.SharedRenderTargetPointer_addQuad, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addVertex = new_instancemethod(_fife.SharedRenderTargetPointer_addVertex, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addText = new_instancemethod(_fife.SharedRenderTargetPointer_addText, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addImage = new_instancemethod(_fife.SharedRenderTargetPointer_addImage, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.addAnimation = new_instancemethod(_fife.SharedRenderTargetPointer_addAnimation, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.resizeImage = new_instancemethod(_fife.SharedRenderTargetPointer_resizeImage, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.removeAll = new_instancemethod(_fife.SharedRenderTargetPointer_removeAll, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.render = new_instancemethod(_fife.SharedRenderTargetPointer_render, None, SharedRenderTargetPointer)
SharedRenderTargetPointer.getTarget = new_instancemethod(_fife.SharedRenderTargetPointer_getTarget, None, SharedRenderTargetPointer)
SharedRenderTargetPointer_swigregister = _fife.SharedRenderTargetPointer_swigregister
SharedRenderTargetPointer_swigregister(SharedRenderTargetPointer)

class TargetRenderer(object):
    """Proxy of C++ FIFE::TargetRenderer class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, renderbackend):
        """__init__(FIFE::TargetRenderer self, RenderBackend renderbackend) -> TargetRenderer"""
        _fife.TargetRenderer_swiginit(self, _fife.new_TargetRenderer(renderbackend))
    __swig_destroy__ = _fife.delete_TargetRenderer

    def createRenderTarget(self, *args):
        """
        createRenderTarget(TargetRenderer self, std::string const & name, uint32_t width, uint32_t height) -> SharedRenderTargetPointer
        createRenderTarget(TargetRenderer self, SharedImagePointer image) -> SharedRenderTargetPointer
        """
        return _fife.TargetRenderer_createRenderTarget(self, *args)


    def setRenderTarget(self, targetname, discard, ndraws=0):
        """setRenderTarget(TargetRenderer self, std::string const & targetname, bool discard, int32_t ndraws=0)"""
        return _fife.TargetRenderer_setRenderTarget(self, targetname, discard, ndraws)


    def render(self):
        """render(TargetRenderer self)"""
        return _fife.TargetRenderer_render(self)

TargetRenderer.createRenderTarget = new_instancemethod(_fife.TargetRenderer_createRenderTarget, None, TargetRenderer)
TargetRenderer.setRenderTarget = new_instancemethod(_fife.TargetRenderer_setRenderTarget, None, TargetRenderer)
TargetRenderer.render = new_instancemethod(_fife.TargetRenderer_render, None, TargetRenderer)
TargetRenderer_swigregister = _fife.TargetRenderer_swigregister
TargetRenderer_swigregister(TargetRenderer)

class IGUIManager(ISdlEventListener):
    """Proxy of C++ FIFE::IGUIManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_IGUIManager

    def turn(self):
        """turn(IGUIManager self)"""
        return _fife.IGUIManager_turn(self)


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

IGUIManager.turn = new_instancemethod(_fife.IGUIManager_turn, None, IGUIManager)
IGUIManager.resizeTopContainer = new_instancemethod(_fife.IGUIManager_resizeTopContainer, None, IGUIManager)
IGUIManager_swigregister = _fife.IGUIManager_swigregister
IGUIManager_swigregister(IGUIManager)

class HybridGuiManager(IGUIManager):
    """Proxy of C++ FIFE::HybridGuiManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::HybridGuiManager self) -> HybridGuiManager"""
        _fife.HybridGuiManager_swiginit(self, _fife.new_HybridGuiManager())
    __swig_destroy__ = _fife.delete_HybridGuiManager

    def addGuiManager(self, guiManager):
        """addGuiManager(HybridGuiManager self, IGUIManager guiManager)"""
        return _fife.HybridGuiManager_addGuiManager(self, guiManager)


    def removeGuiManager(self, guiManager):
        """removeGuiManager(HybridGuiManager self, IGUIManager guiManager)"""
        return _fife.HybridGuiManager_removeGuiManager(self, guiManager)

HybridGuiManager.addGuiManager = new_instancemethod(_fife.HybridGuiManager_addGuiManager, None, HybridGuiManager)
HybridGuiManager.removeGuiManager = new_instancemethod(_fife.HybridGuiManager_removeGuiManager, None, HybridGuiManager)
HybridGuiManager_swigregister = _fife.HybridGuiManager_swigregister
HybridGuiManager_swigregister(HybridGuiManager)

class Font(object):
    """Proxy of C++ fcn::Font class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_Font

    def getWidth(self, text):
        """getWidth(Font self, std::string const & text) -> int32_t"""
        return _fife.Font_getWidth(self, text)


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

Font.getWidth = new_instancemethod(_fife.Font_getWidth, None, Font)
Font.getHeight = new_instancemethod(_fife.Font_getHeight, None, Font)
Font_swigregister = _fife.Font_swigregister
Font_swigregister(Font)

class GuiFont(Font, IFont):
    """Proxy of C++ FIFE::GuiFont class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, font):
        """__init__(FIFE::GuiFont self, IFont font) -> GuiFont"""
        _fife.GuiFont_swiginit(self, _fife.new_GuiFont(font))
    __swig_destroy__ = _fife.delete_GuiFont

    def getStringIndexAt(self, text, x):
        """getStringIndexAt(GuiFont self, std::string const & text, int32_t x) -> int32_t"""
        return _fife.GuiFont_getStringIndexAt(self, text, x)


    def drawString(self, graphics, text, x, y):
        """drawString(GuiFont self, Graphics graphics, std::string const & text, int32_t x, int32_t y)"""
        return _fife.GuiFont_drawString(self, graphics, text, x, y)


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


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


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


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


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


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


    def setBoldStyle(self, style):
        """setBoldStyle(GuiFont self, bool style)"""
        return _fife.GuiFont_setBoldStyle(self, style)


    def isBoldStyle(self):
        """isBoldStyle(GuiFont self) -> bool"""
        return _fife.GuiFont_isBoldStyle(self)


    def setItalicStyle(self, style):
        """setItalicStyle(GuiFont self, bool style)"""
        return _fife.GuiFont_setItalicStyle(self, style)


    def isItalicStyle(self):
        """isItalicStyle(GuiFont self) -> bool"""
        return _fife.GuiFont_isItalicStyle(self)


    def setUnderlineStyle(self, style):
        """setUnderlineStyle(GuiFont self, bool style)"""
        return _fife.GuiFont_setUnderlineStyle(self, style)


    def isUnderlineStyle(self):
        """isUnderlineStyle(GuiFont self) -> bool"""
        return _fife.GuiFont_isUnderlineStyle(self)


    def setStrikethroughStyle(self, style):
        """setStrikethroughStyle(GuiFont self, bool style)"""
        return _fife.GuiFont_setStrikethroughStyle(self, style)


    def isStrikethroughStyle(self):
        """isStrikethroughStyle(GuiFont self) -> bool"""
        return _fife.GuiFont_isStrikethroughStyle(self)


    def setDynamicColoring(self, coloring):
        """setDynamicColoring(GuiFont self, bool coloring)"""
        return _fife.GuiFont_setDynamicColoring(self, coloring)


    def isDynamicColoring(self):
        """isDynamicColoring(GuiFont self) -> bool"""
        return _fife.GuiFont_isDynamicColoring(self)


    def getAsImage(self, text):
        """getAsImage(GuiFont self, std::string const & text) -> Image"""
        return _fife.GuiFont_getAsImage(self, text)


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


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


    def getWidth(self, text):
        """getWidth(GuiFont self, std::string const & text) -> int32_t"""
        return _fife.GuiFont_getWidth(self, text)


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

GuiFont.getStringIndexAt = new_instancemethod(_fife.GuiFont_getStringIndexAt, None, GuiFont)
GuiFont.drawString = new_instancemethod(_fife.GuiFont_drawString, None, GuiFont)
GuiFont.setRowSpacing = new_instancemethod(_fife.GuiFont_setRowSpacing, None, GuiFont)
GuiFont.getRowSpacing = new_instancemethod(_fife.GuiFont_getRowSpacing, None, GuiFont)
GuiFont.setGlyphSpacing = new_instancemethod(_fife.GuiFont_setGlyphSpacing, None, GuiFont)
GuiFont.getGlyphSpacing = new_instancemethod(_fife.GuiFont_getGlyphSpacing, None, GuiFont)
GuiFont.setAntiAlias = new_instancemethod(_fife.GuiFont_setAntiAlias, None, GuiFont)
GuiFont.isAntiAlias = new_instancemethod(_fife.GuiFont_isAntiAlias, None, GuiFont)
GuiFont.setBoldStyle = new_instancemethod(_fife.GuiFont_setBoldStyle, None, GuiFont)
GuiFont.isBoldStyle = new_instancemethod(_fife.GuiFont_isBoldStyle, None, GuiFont)
GuiFont.setItalicStyle = new_instancemethod(_fife.GuiFont_setItalicStyle, None, GuiFont)
GuiFont.isItalicStyle = new_instancemethod(_fife.GuiFont_isItalicStyle, None, GuiFont)
GuiFont.setUnderlineStyle = new_instancemethod(_fife.GuiFont_setUnderlineStyle, None, GuiFont)
GuiFont.isUnderlineStyle = new_instancemethod(_fife.GuiFont_isUnderlineStyle, None, GuiFont)
GuiFont.setStrikethroughStyle = new_instancemethod(_fife.GuiFont_setStrikethroughStyle, None, GuiFont)
GuiFont.isStrikethroughStyle = new_instancemethod(_fife.GuiFont_isStrikethroughStyle, None, GuiFont)
GuiFont.setDynamicColoring = new_instancemethod(_fife.GuiFont_setDynamicColoring, None, GuiFont)
GuiFont.isDynamicColoring = new_instancemethod(_fife.GuiFont_isDynamicColoring, None, GuiFont)
GuiFont.getAsImage = new_instancemethod(_fife.GuiFont_getAsImage, None, GuiFont)
GuiFont.setColor = new_instancemethod(_fife.GuiFont_setColor, None, GuiFont)
GuiFont.getColor = new_instancemethod(_fife.GuiFont_getColor, None, GuiFont)
GuiFont.getWidth = new_instancemethod(_fife.GuiFont_getWidth, None, GuiFont)
GuiFont.getHeight = new_instancemethod(_fife.GuiFont_getHeight, None, GuiFont)
GuiFont_swigregister = _fife.GuiFont_swigregister
GuiFont_swigregister(GuiFont)

class GcnImage(object):
    """Proxy of C++ fcn::Image class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_GcnImage

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

    load = staticmethod(load)

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


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

GcnImage.getWidth = new_instancemethod(_fife.GcnImage_getWidth, None, GcnImage)
GcnImage.getHeight = new_instancemethod(_fife.GcnImage_getHeight, None, GcnImage)
GcnImage_swigregister = _fife.GcnImage_swigregister
GcnImage_swigregister(GcnImage)

def GcnImage_load(filename, convertToDisplayFormat=True):
    """GcnImage_load(std::string const & filename, bool convertToDisplayFormat=True) -> GcnImage"""
    return _fife.GcnImage_load(filename, convertToDisplayFormat)

class GuiImage(GcnImage):
    """Proxy of C++ FIFE::GuiImage class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(FIFE::GuiImage self) -> GuiImage
        __init__(FIFE::GuiImage self, SharedImagePointer Image) -> GuiImage
        """
        _fife.GuiImage_swiginit(self, _fife.new_GuiImage(*args))

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


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

    __swig_destroy__ = _fife.delete_GuiImage
GuiImage.getWidth = new_instancemethod(_fife.GuiImage_getWidth, None, GuiImage)
GuiImage.getHeight = new_instancemethod(_fife.GuiImage_getHeight, None, GuiImage)
GuiImage_swigregister = _fife.GuiImage_swigregister
GuiImage_swigregister(GuiImage)

class ConsoleExecuter(object):
    """Proxy of C++ FIFE::ConsoleExecuter class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    __swig_destroy__ = _fife.delete_ConsoleExecuter

    def onToolsClick(self):
        """onToolsClick(ConsoleExecuter self)"""
        return _fife.ConsoleExecuter_onToolsClick(self)


    def onConsoleCommand(self, command):
        """onConsoleCommand(ConsoleExecuter self, std::string const & command) -> std::string"""
        return _fife.ConsoleExecuter_onConsoleCommand(self, command)


    def __init__(self):
        """__init__(FIFE::ConsoleExecuter self) -> ConsoleExecuter"""
        if self.__class__ == ConsoleExecuter:
            _self = None
        else:
            _self = self
        _fife.ConsoleExecuter_swiginit(self, _fife.new_ConsoleExecuter(_self, ))
    def __disown__(self):
        self.this.disown()
        _fife.disown_ConsoleExecuter(self)
        return weakref_proxy(self)
ConsoleExecuter.onToolsClick = new_instancemethod(_fife.ConsoleExecuter_onToolsClick, None, ConsoleExecuter)
ConsoleExecuter.onConsoleCommand = new_instancemethod(_fife.ConsoleExecuter_onConsoleCommand, None, ConsoleExecuter)
ConsoleExecuter_swigregister = _fife.ConsoleExecuter_swigregister
ConsoleExecuter_swigregister(ConsoleExecuter)

class Console(object):
    """Proxy of C++ FIFE::Console class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def show(self):
        """show(Console self)"""
        return _fife.Console_show(self)


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


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


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


    def println(self, s):
        """println(Console self, std::string const & s)"""
        return _fife.Console_println(self, s)


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


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


    def __init__(self):
        """__init__(FIFE::Console self) -> Console"""
        _fife.Console_swiginit(self, _fife.new_Console())
    __swig_destroy__ = _fife.delete_Console
Console.show = new_instancemethod(_fife.Console_show, None, Console)
Console.hide = new_instancemethod(_fife.Console_hide, None, Console)
Console.clear = new_instancemethod(_fife.Console_clear, None, Console)
Console.toggleShowHide = new_instancemethod(_fife.Console_toggleShowHide, None, Console)
Console.println = new_instancemethod(_fife.Console_println, None, Console)
Console.setConsoleExecuter = new_instancemethod(_fife.Console_setConsoleExecuter, None, Console)
Console.removeConsoleExecuter = new_instancemethod(_fife.Console_removeConsoleExecuter, None, Console)
Console_swigregister = _fife.Console_swigregister
Console_swigregister(Console)

class FifechanManager(IGUIManager):
    """Proxy of C++ FIFE::FifechanManager class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(FIFE::FifechanManager self) -> FifechanManager"""
        _fife.FifechanManager_swiginit(self, _fife.new_FifechanManager())
    __swig_destroy__ = _fife.delete_FifechanManager

    def init(self, backend, screenWidth, screenHeight):
        """init(FifechanManager self, std::string const & backend, int32_t screenWidth, int32_t screenHeight)"""
        return _fife.FifechanManager_init(self, backend, screenWidth, screenHeight)


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


    def setConsoleEnabled(self, console):
        """setConsoleEnabled(FifechanManager self, bool console)"""
        return _fife.FifechanManager_setConsoleEnabled(self, console)


    def isConsoleEnabled(self):
        """isConsoleEnabled(FifechanManager self) -> bool"""
        return _fife.FifechanManager_isConsoleEnabled(self)


    def setCursor(self, cursor):
        """setCursor(FifechanManager self, Cursor cursor)"""
        return _fife.FifechanManager_setCursor(self, cursor)


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


    def add(self, widget):
        """add(FifechanManager self, Widget widget)"""
        return _fife.FifechanManager_add(self, widget)


    def remove(self, widget):
        """remove(FifechanManager self, Widget widget)"""
        return _fife.FifechanManager_remove(self, widget)


    def createFont(self, path, size, glyphs):
        """createFont(FifechanManager self, std::string const & path, uint32_t size, std::string const & glyphs) -> GuiFont"""
        return _fife.FifechanManager_createFont(self, path, size, glyphs)


    def releaseFont(self, font):
        """releaseFont(FifechanManager self, GuiFont font)"""
        return _fife.FifechanManager_releaseFont(self, font)


    def setDefaultFont(self, path, size, glyphs):
        """setDefaultFont(FifechanManager self, std::string const & path, uint32_t size, std::string const & glyphs) -> GuiFont"""
        return _fife.FifechanManager_setDefaultFont(self, path, size, glyphs)


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


    def translateKeyEvent(self, evt):
        """translateKeyEvent(FifechanManager self, fcn::KeyEvent const & evt) -> KeyEvent"""
        return _fife.FifechanManager_translateKeyEvent(self, evt)


    def translateMouseEvent(self, evt):
        """translateMouseEvent(FifechanManager self, fcn::MouseEvent const & evt) -> MouseEvent"""
        return _fife.FifechanManager_translateMouseEvent(self, evt)


    def setTabbingEnabled(self, tabbing):
        """setTabbingEnabled(FifechanManager self, bool tabbing)"""
        return _fife.FifechanManager_setTabbingEnabled(self, tabbing)


    def isTabbingEnabled(self):
        """isTabbingEnabled(FifechanManager self) -> bool"""
        return _fife.FifechanManager_isTabbingEnabled(self)

FifechanManager.init = new_instancemethod(_fife.FifechanManager_init, None, FifechanManager)
FifechanManager.getConsole = new_instancemethod(_fife.FifechanManager_getConsole, None, FifechanManager)
FifechanManager.setConsoleEnabled = new_instancemethod(_fife.FifechanManager_setConsoleEnabled, None, FifechanManager)
FifechanManager.isConsoleEnabled = new_instancemethod(_fife.FifechanManager_isConsoleEnabled, None, FifechanManager)
FifechanManager.setCursor = new_instancemethod(_fife.FifechanManager_setCursor, None, FifechanManager)
FifechanManager.getCursor = new_instancemethod(_fife.FifechanManager_getCursor, None, FifechanManager)
FifechanManager.add = new_instancemethod(_fife.FifechanManager_add, None, FifechanManager)
FifechanManager.remove = new_instancemethod(_fife.FifechanManager_remove, None, FifechanManager)
FifechanManager.createFont = new_instancemethod(_fife.FifechanManager_createFont, None, FifechanManager)
FifechanManager.releaseFont = new_instancemethod(_fife.FifechanManager_releaseFont, None, FifechanManager)
FifechanManager.setDefaultFont = new_instancemethod(_fife.FifechanManager_setDefaultFont, None, FifechanManager)
FifechanManager.getDefaultFont = new_instancemethod(_fife.FifechanManager_getDefaultFont, None, FifechanManager)
FifechanManager.translateKeyEvent = new_instancemethod(_fife.FifechanManager_translateKeyEvent, None, FifechanManager)
FifechanManager.translateMouseEvent = new_instancemethod(_fife.FifechanManager_translateMouseEvent, None, FifechanManager)
FifechanManager.setTabbingEnabled = new_instancemethod(_fife.FifechanManager_setTabbingEnabled, None, FifechanManager)
FifechanManager.isTabbingEnabled = new_instancemethod(_fife.FifechanManager_isTabbingEnabled, None, FifechanManager)
FifechanManager_swigregister = _fife.FifechanManager_swigregister
FifechanManager_swigregister(FifechanManager)

class AnimationIcon(fife.fifechan.Icon):
    """Proxy of C++ fcn::AnimationIcon class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(fcn::AnimationIcon self) -> AnimationIcon
        __init__(fcn::AnimationIcon self, SharedAnimationPointer animation) -> AnimationIcon
        """
        _fife.AnimationIcon_swiginit(self, _fife.new_AnimationIcon(*args))
    __swig_destroy__ = _fife.delete_AnimationIcon

    def setAnimation(self, animation):
        """setAnimation(AnimationIcon self, SharedAnimationPointer animation)"""
        return _fife.AnimationIcon_setAnimation(self, animation)


    def getAnimation(self):
        """getAnimation(AnimationIcon self) -> SharedAnimationPointer"""
        return _fife.AnimationIcon_getAnimation(self)


    def setRepeating(self, repeat):
        """setRepeating(AnimationIcon self, bool repeat)"""
        return _fife.AnimationIcon_setRepeating(self, repeat)


    def isRepeating(self):
        """isRepeating(AnimationIcon self) -> bool"""
        return _fife.AnimationIcon_isRepeating(self)


    def play(self):
        """play(AnimationIcon self)"""
        return _fife.AnimationIcon_play(self)


    def isPlaying(self):
        """isPlaying(AnimationIcon self) -> bool"""
        return _fife.AnimationIcon_isPlaying(self)


    def pause(self):
        """pause(AnimationIcon self)"""
        return _fife.AnimationIcon_pause(self)


    def stop(self):
        """stop(AnimationIcon self)"""
        return _fife.AnimationIcon_stop(self)

AnimationIcon.setAnimation = new_instancemethod(_fife.AnimationIcon_setAnimation, None, AnimationIcon)
AnimationIcon.getAnimation = new_instancemethod(_fife.AnimationIcon_getAnimation, None, AnimationIcon)
AnimationIcon.setRepeating = new_instancemethod(_fife.AnimationIcon_setRepeating, None, AnimationIcon)
AnimationIcon.isRepeating = new_instancemethod(_fife.AnimationIcon_isRepeating, None, AnimationIcon)
AnimationIcon.play = new_instancemethod(_fife.AnimationIcon_play, None, AnimationIcon)
AnimationIcon.isPlaying = new_instancemethod(_fife.AnimationIcon_isPlaying, None, AnimationIcon)
AnimationIcon.pause = new_instancemethod(_fife.AnimationIcon_pause, None, AnimationIcon)
AnimationIcon.stop = new_instancemethod(_fife.AnimationIcon_stop, None, AnimationIcon)
AnimationIcon_swigregister = _fife.AnimationIcon_swigregister
AnimationIcon_swigregister(AnimationIcon)

class Label(fife.fifechan.Widget):
    """Proxy of C++ fcn::ClickLabel class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        ClickLabel() -> Label
        __init__(fcn::ClickLabel self, std::string const & caption) -> Label
        """
        _fife.Label_swiginit(self, _fife.new_Label(*args))
    __swig_destroy__ = _fife.delete_Label

    def setCaption(self, caption):
        """setCaption(Label self, std::string const & caption)"""
        return _fife.Label_setCaption(self, caption)


    def getCaption(self):
        """getCaption(Label self) -> std::string const &"""
        return _fife.Label_getCaption(self)


    def setAlignment(self, alignment):
        """setAlignment(Label self, fcn::Graphics::Alignment alignment)"""
        return _fife.Label_setAlignment(self, alignment)


    def getAlignment(self):
        """getAlignment(Label self) -> fcn::Graphics::Alignment"""
        return _fife.Label_getAlignment(self)


    def setOpaque(self, opaque):
        """setOpaque(Label self, bool opaque)"""
        return _fife.Label_setOpaque(self, opaque)


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


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


    def setTextWrapping(self, arg2):
        """setTextWrapping(Label self, bool arg2)"""
        return _fife.Label_setTextWrapping(self, arg2)


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

Label.setCaption = new_instancemethod(_fife.Label_setCaption, None, Label)
Label.getCaption = new_instancemethod(_fife.Label_getCaption, None, Label)
Label.setAlignment = new_instancemethod(_fife.Label_setAlignment, None, Label)
Label.getAlignment = new_instancemethod(_fife.Label_getAlignment, None, Label)
Label.setOpaque = new_instancemethod(_fife.Label_setOpaque, None, Label)
Label.isOpaque = new_instancemethod(_fife.Label_isOpaque, None, Label)
Label.isTextWrapping = new_instancemethod(_fife.Label_isTextWrapping, None, Label)
Label.setTextWrapping = new_instancemethod(_fife.Label_setTextWrapping, None, Label)
Label.adjustSize = new_instancemethod(_fife.Label_adjustSize, None, Label)
Label_swigregister = _fife.Label_swigregister
Label_swigregister(Label)

class PercentageBar(fife.fifechan.Widget):
    """Proxy of C++ fcn::PercentageBar class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(fcn::PercentageBar self) -> PercentageBar"""
        _fife.PercentageBar_swiginit(self, _fife.new_PercentageBar())
    __swig_destroy__ = _fife.delete_PercentageBar

    def setForegroundImage(self, image):
        """setForegroundImage(PercentageBar self, GcnImage image)"""
        return _fife.PercentageBar_setForegroundImage(self, image)


    def setOrientation(self, orientation):
        """setOrientation(PercentageBar self, fcn::PercentageBar::Orientation orientation)"""
        return _fife.PercentageBar_setOrientation(self, orientation)


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


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


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

    HORIZONTAL = _fife.PercentageBar_HORIZONTAL
    VERTICAL = _fife.PercentageBar_VERTICAL
PercentageBar.setForegroundImage = new_instancemethod(_fife.PercentageBar_setForegroundImage, None, PercentageBar)
PercentageBar.setOrientation = new_instancemethod(_fife.PercentageBar_setOrientation, None, PercentageBar)
PercentageBar.getOrientation = new_instancemethod(_fife.PercentageBar_getOrientation, None, PercentageBar)
PercentageBar.getValue = new_instancemethod(_fife.PercentageBar_getValue, None, PercentageBar)
PercentageBar.setValue = new_instancemethod(_fife.PercentageBar_setValue, None, PercentageBar)
PercentageBar_swigregister = _fife.PercentageBar_swigregister
PercentageBar_swigregister(PercentageBar)

class ResizableWindow(fife.fifechan.Window):
    """Proxy of C++ fcn::ResizableWindow class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    CURSOR_DIRECTION_L = _fife.ResizableWindow_CURSOR_DIRECTION_L
    CURSOR_DIRECTION_R = _fife.ResizableWindow_CURSOR_DIRECTION_R
    CURSOR_DIRECTION_T = _fife.ResizableWindow_CURSOR_DIRECTION_T
    CURSOR_DIRECTION_B = _fife.ResizableWindow_CURSOR_DIRECTION_B
    CURSOR_DIRECTION_LT = _fife.ResizableWindow_CURSOR_DIRECTION_LT
    CURSOR_DIRECTION_RT = _fife.ResizableWindow_CURSOR_DIRECTION_RT
    CURSOR_DIRECTION_LB = _fife.ResizableWindow_CURSOR_DIRECTION_LB
    CURSOR_DIRECTION_RB = _fife.ResizableWindow_CURSOR_DIRECTION_RB

    def __init__(self, *args):
        """
        __init__(fcn::ResizableWindow self) -> ResizableWindow
        __init__(fcn::ResizableWindow self, bool resizable) -> ResizableWindow
        __init__(fcn::ResizableWindow self, std::string const & caption, bool resizable=True) -> ResizableWindow
        """
        _fife.ResizableWindow_swiginit(self, _fife.new_ResizableWindow(*args))
    __swig_destroy__ = _fife.delete_ResizableWindow

    def setResizableBorderDistance(self, border):
        """setResizableBorderDistance(ResizableWindow self, int32_t border)"""
        return _fife.ResizableWindow_setResizableBorderDistance(self, border)


    def getResizableBorderDistance(self):
        """getResizableBorderDistance(ResizableWindow self) -> int32_t"""
        return _fife.ResizableWindow_getResizableBorderDistance(self)


    def setResizable(self, resizable):
        """setResizable(ResizableWindow self, bool resizable)"""
        return _fife.ResizableWindow_setResizable(self, resizable)


    def isResizable(self):
        """isResizable(ResizableWindow self) -> bool"""
        return _fife.ResizableWindow_isResizable(self)


    def setTopResizable(self, resizable):
        """setTopResizable(ResizableWindow self, bool resizable)"""
        return _fife.ResizableWindow_setTopResizable(self, resizable)


    def isTopResizable(self):
        """isTopResizable(ResizableWindow self) -> bool"""
        return _fife.ResizableWindow_isTopResizable(self)


    def setRightResizable(self, resizable):
        """setRightResizable(ResizableWindow self, bool resizable)"""
        return _fife.ResizableWindow_setRightResizable(self, resizable)


    def isRightResizable(self):
        """isRightResizable(ResizableWindow self) -> bool"""
        return _fife.ResizableWindow_isRightResizable(self)


    def setBottomResizable(self, resizable):
        """setBottomResizable(ResizableWindow self, bool resizable)"""
        return _fife.ResizableWindow_setBottomResizable(self, resizable)


    def isBottomResizable(self):
        """isBottomResizable(ResizableWindow self) -> bool"""
        return _fife.ResizableWindow_isBottomResizable(self)


    def setLeftResizable(self, resizable):
        """setLeftResizable(ResizableWindow self, bool resizable)"""
        return _fife.ResizableWindow_setLeftResizable(self, resizable)


    def isLeftResizable(self):
        """isLeftResizable(ResizableWindow self) -> bool"""
        return _fife.ResizableWindow_isLeftResizable(self)


    def setShove(self, shove):
        """setShove(ResizableWindow self, bool shove)"""
        return _fife.ResizableWindow_setShove(self, shove)


    def getShove(self):
        """getShove(ResizableWindow self) -> bool"""
        return _fife.ResizableWindow_getShove(self)


    def set(self, *args):
        """
        set(ResizableWindow self, fcn::ResizableWindow::CursorDirections direction, uint32_t cursor_id=0)
        set(ResizableWindow self, fcn::ResizableWindow::CursorDirections direction, SharedImagePointer image)
        set(ResizableWindow self, fcn::ResizableWindow::CursorDirections direction, SharedAnimationPointer anim)
        """
        return _fife.ResizableWindow_set(self, *args)


    def getType(self, direction):
        """getType(ResizableWindow self, fcn::ResizableWindow::CursorDirections direction) -> FIFE::MouseCursorType"""
        return _fife.ResizableWindow_getType(self, direction)


    def getId(self, direction):
        """getId(ResizableWindow self, fcn::ResizableWindow::CursorDirections direction) -> uint32_t"""
        return _fife.ResizableWindow_getId(self, direction)


    def getImage(self, direction):
        """getImage(ResizableWindow self, fcn::ResizableWindow::CursorDirections direction) -> SharedImagePointer"""
        return _fife.ResizableWindow_getImage(self, direction)


    def getAnimation(self, direction):
        """getAnimation(ResizableWindow self, fcn::ResizableWindow::CursorDirections direction) -> SharedAnimationPointer"""
        return _fife.ResizableWindow_getAnimation(self, direction)

ResizableWindow.setResizableBorderDistance = new_instancemethod(_fife.ResizableWindow_setResizableBorderDistance, None, ResizableWindow)
ResizableWindow.getResizableBorderDistance = new_instancemethod(_fife.ResizableWindow_getResizableBorderDistance, None, ResizableWindow)
ResizableWindow.setResizable = new_instancemethod(_fife.ResizableWindow_setResizable, None, ResizableWindow)
ResizableWindow.isResizable = new_instancemethod(_fife.ResizableWindow_isResizable, None, ResizableWindow)
ResizableWindow.setTopResizable = new_instancemethod(_fife.ResizableWindow_setTopResizable, None, ResizableWindow)
ResizableWindow.isTopResizable = new_instancemethod(_fife.ResizableWindow_isTopResizable, None, ResizableWindow)
ResizableWindow.setRightResizable = new_instancemethod(_fife.ResizableWindow_setRightResizable, None, ResizableWindow)
ResizableWindow.isRightResizable = new_instancemethod(_fife.ResizableWindow_isRightResizable, None, ResizableWindow)
ResizableWindow.setBottomResizable = new_instancemethod(_fife.ResizableWindow_setBottomResizable, None, ResizableWindow)
ResizableWindow.isBottomResizable = new_instancemethod(_fife.ResizableWindow_isBottomResizable, None, ResizableWindow)
ResizableWindow.setLeftResizable = new_instancemethod(_fife.ResizableWindow_setLeftResizable, None, ResizableWindow)
ResizableWindow.isLeftResizable = new_instancemethod(_fife.ResizableWindow_isLeftResizable, None, ResizableWindow)
ResizableWindow.setShove = new_instancemethod(_fife.ResizableWindow_setShove, None, ResizableWindow)
ResizableWindow.getShove = new_instancemethod(_fife.ResizableWindow_getShove, None, ResizableWindow)
ResizableWindow.set = new_instancemethod(_fife.ResizableWindow_set, None, ResizableWindow)
ResizableWindow.getType = new_instancemethod(_fife.ResizableWindow_getType, None, ResizableWindow)
ResizableWindow.getId = new_instancemethod(_fife.ResizableWindow_getId, None, ResizableWindow)
ResizableWindow.getImage = new_instancemethod(_fife.ResizableWindow_getImage, None, ResizableWindow)
ResizableWindow.getAnimation = new_instancemethod(_fife.ResizableWindow_getAnimation, None, ResizableWindow)
ResizableWindow_swigregister = _fife.ResizableWindow_swigregister
ResizableWindow_swigregister(ResizableWindow)

class DockArea(ResizableWindow):
    """Proxy of C++ fcn::DockArea class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(fcn::DockArea self) -> DockArea
        __init__(fcn::DockArea self, bool active) -> DockArea
        """
        _fife.DockArea_swiginit(self, _fife.new_DockArea(*args))
    __swig_destroy__ = _fife.delete_DockArea

    def setActiveDockArea(self, active):
        """setActiveDockArea(DockArea self, bool active)"""
        return _fife.DockArea_setActiveDockArea(self, active)


    def isActiveDockArea(self):
        """isActiveDockArea(DockArea self) -> bool"""
        return _fife.DockArea_isActiveDockArea(self)


    def setTopSide(self, side):
        """setTopSide(DockArea self, bool side)"""
        return _fife.DockArea_setTopSide(self, side)


    def isTopSide(self):
        """isTopSide(DockArea self) -> bool"""
        return _fife.DockArea_isTopSide(self)


    def setRightSide(self, side):
        """setRightSide(DockArea self, bool side)"""
        return _fife.DockArea_setRightSide(self, side)


    def isRightSide(self):
        """isRightSide(DockArea self) -> bool"""
        return _fife.DockArea_isRightSide(self)


    def setBottomSide(self, side):
        """setBottomSide(DockArea self, bool side)"""
        return _fife.DockArea_setBottomSide(self, side)


    def isBottomSide(self):
        """isBottomSide(DockArea self) -> bool"""
        return _fife.DockArea_isBottomSide(self)


    def setLeftSide(self, side):
        """setLeftSide(DockArea self, bool side)"""
        return _fife.DockArea_setLeftSide(self, side)


    def isLeftSide(self):
        """isLeftSide(DockArea self) -> bool"""
        return _fife.DockArea_isLeftSide(self)


    def dockWidget(self, widget):
        """dockWidget(DockArea self, Widget widget)"""
        return _fife.DockArea_dockWidget(self, widget)


    def undockWidget(self, widget):
        """undockWidget(DockArea self, Widget widget)"""
        return _fife.DockArea_undockWidget(self, widget)


    def setHighlighted(self, highlighted):
        """setHighlighted(DockArea self, bool highlighted)"""
        return _fife.DockArea_setHighlighted(self, highlighted)


    def isHighlighted(self):
        """isHighlighted(DockArea self) -> bool"""
        return _fife.DockArea_isHighlighted(self)


    def setHighlightColor(self, color):
        """setHighlightColor(DockArea self, Color color)"""
        return _fife.DockArea_setHighlightColor(self, color)


    def getHighlightColor(self):
        """getHighlightColor(DockArea self) -> Color"""
        return _fife.DockArea_getHighlightColor(self)

DockArea.setActiveDockArea = new_instancemethod(_fife.DockArea_setActiveDockArea, None, DockArea)
DockArea.isActiveDockArea = new_instancemethod(_fife.DockArea_isActiveDockArea, None, DockArea)
DockArea.setTopSide = new_instancemethod(_fife.DockArea_setTopSide, None, DockArea)
DockArea.isTopSide = new_instancemethod(_fife.DockArea_isTopSide, None, DockArea)
DockArea.setRightSide = new_instancemethod(_fife.DockArea_setRightSide, None, DockArea)
DockArea.isRightSide = new_instancemethod(_fife.DockArea_isRightSide, None, DockArea)
DockArea.setBottomSide = new_instancemethod(_fife.DockArea_setBottomSide, None, DockArea)
DockArea.isBottomSide = new_instancemethod(_fife.DockArea_isBottomSide, None, DockArea)
DockArea.setLeftSide = new_instancemethod(_fife.DockArea_setLeftSide, None, DockArea)
DockArea.isLeftSide = new_instancemethod(_fife.DockArea_isLeftSide, None, DockArea)
DockArea.dockWidget = new_instancemethod(_fife.DockArea_dockWidget, None, DockArea)
DockArea.undockWidget = new_instancemethod(_fife.DockArea_undockWidget, None, DockArea)
DockArea.setHighlighted = new_instancemethod(_fife.DockArea_setHighlighted, None, DockArea)
DockArea.isHighlighted = new_instancemethod(_fife.DockArea_isHighlighted, None, DockArea)
DockArea.setHighlightColor = new_instancemethod(_fife.DockArea_setHighlightColor, None, DockArea)
DockArea.getHighlightColor = new_instancemethod(_fife.DockArea_getHighlightColor, None, DockArea)
DockArea_swigregister = _fife.DockArea_swigregister
DockArea_swigregister(DockArea)

class Panel(ResizableWindow):
    """Proxy of C++ fcn::Panel class."""

    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(fcn::Panel self) -> Panel
        __init__(fcn::Panel self, bool dockable) -> Panel
        """
        _fife.Panel_swiginit(self, _fife.new_Panel(*args))
    __swig_destroy__ = _fife.delete_Panel

    def setDockable(self, dockable):
        """setDockable(Panel self, bool dockable)"""
        return _fife.Panel_setDockable(self, dockable)


    def isDockable(self):
        """isDockable(Panel self) -> bool"""
        return _fife.Panel_isDockable(self)


    def setDocked(self, docked):
        """setDocked(Panel self, bool docked)"""
        return _fife.Panel_setDocked(self, docked)


    def isDocked(self):
        """isDocked(Panel self) -> bool"""
        return _fife.Panel_isDocked(self)

Panel.setDockable = new_instancemethod(_fife.Panel_setDockable, None, Panel)
Panel.isDockable = new_instancemethod(_fife.Panel_isDockable, None, Panel)
Panel.setDocked = new_instancemethod(_fife.Panel_setDocked, None, Panel)
Panel.isDocked = new_instancemethod(_fife.Panel_isDocked, None, Panel)
Panel_swigregister = _fife.Panel_swigregister
Panel_swigregister(Panel)



