# 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 >= (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


import fifechan
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
    __del__ = lambda self: None

    def value(self):
        return _fife.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _fife.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _fife.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _fife.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _fife.SwigPyIterator_equal(self, x)

    def copy(self):
        return _fife.SwigPyIterator_copy(self)

    def next(self):
        return _fife.SwigPyIterator_next(self)

    def __next__(self):
        return _fife.SwigPyIterator___next__(self)

    def previous(self):
        return _fife.SwigPyIterator_previous(self)

    def advance(self, n):
        return _fife.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _fife.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _fife.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _fife.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _fife.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _fife.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _fife.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _fife.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

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

    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
        """
        this = _fife.new_StringVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_UintVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_IntVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_FloatVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_DoubleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_BoolVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
BoolVector_swigregister = _fife.BoolVector_swigregister
BoolVector_swigregister(BoolVector)

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

    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
        """
        this = _fife.new_Uint16Uint16Pair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    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
    __del__ = lambda self: None
Uint16Uint16Pair_swigregister = _fife.Uint16Uint16Pair_swigregister
Uint16Uint16Pair_swigregister(Uint16Uint16Pair)

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

    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
        """
        this = _fife.new_Uint16Uint16PairVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
Uint16Uint16PairVector_swigregister = _fife.Uint16Uint16PairVector_swigregister
Uint16Uint16PairVector_swigregister(Uint16Uint16PairVector)


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

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()
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
    __del__ = lambda self: None

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

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
    __del__ = lambda self: None

    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_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
        """
        this = _fife.new_SharedResourcePointer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SharedResourcePointer
    __del__ = lambda self: None

    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)
        reset(SharedResourcePointer self)
        """
        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_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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

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

SoundClip_swigregister = _fife.SoundClip_swigregister
SoundClip_swigregister(SoundClip)

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

    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
        """
        this = _fife.new_SharedSoundClipPointer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SharedSoundClipPointer
    __del__ = lambda self: None

    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)
        reset(SharedSoundClipPointer self)
        """
        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_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
    __del__ = lambda self: None

    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
        create(SoundClipManager self, std::string const & name) -> 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
        load(SoundClipManager self, std::string const & name) -> 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"""
        this = _fife.new_SoundClipManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
SoundClipManager_swigregister = _fife.SoundClipManager_swigregister
SoundClipManager_swigregister(SoundClipManager)

SD_SAMPLE_POS = _fife.SD_SAMPLE_POS
SD_TIME_POS = _fife.SD_TIME_POS
SD_BYTE_POS = _fife.SD_BYTE_POS
class SoundEmitter(object):
    """Proxy of C++ FIFE::SoundEmitter class."""

    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, manager, uid):
        """__init__(FIFE::SoundEmitter self, SoundManager manager, uint32_t uid) -> SoundEmitter"""
        this = _fife.new_SoundEmitter(manager, uid)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SoundEmitter
    __del__ = lambda self: None

    def getId(self):
        """getId(SoundEmitter self) -> uint32_t"""
        return _fife.SoundEmitter_getId(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)
        reset(SoundEmitter self)
        """
        return _fife.SoundEmitter_reset(self, defaultall)


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


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


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


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


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


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


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


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


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


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

SoundEmitter_swigregister = _fife.SoundEmitter_swigregister
SoundEmitter_swigregister(SoundEmitter)

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__(FIFE::SoundManager self) -> SoundManager"""
        this = _fife.new_SoundManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SoundManager
    __del__ = lambda self: None

    def init(self):
        """init(SoundManager self)"""
        return _fife.SoundManager_init(self)


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


    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 setListenerPosition(self, x, y, z):
        """setListenerPosition(SoundManager self, float x, float y, float z)"""
        return _fife.SoundManager_setListenerPosition(self, x, y, z)


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

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
    __del__ = lambda self: None

    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)

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
    __del__ = lambda self: None

    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
        this = _fife.new_IEngineChangeListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEngineChangeListener(self)
        return weakref_proxy(self)
IEngineChangeListener_swigregister = _fife.IEngineChangeListener_swigregister
IEngineChangeListener_swigregister(IEngineChangeListener)

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

    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"""
        this = _fife.new_Engine()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Engine
    __del__ = lambda self: None

    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_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):
        """
        __init__(FIFE::Key self, FIFE::Key::KeyType key) -> Key
        __init__(FIFE::Key self) -> Key
        """
        this = _fife.new_Key(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Key
    __del__ = lambda self: None

    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_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
        __init__(FIFE::Text self, char const * text=None, int32_t start=0) -> Text
        __init__(FIFE::Text self, char const * text=None) -> Text
        __init__(FIFE::Text self) -> Text
        """
        this = _fife.new_Text(text, start, length)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Text
    __del__ = lambda self: None

    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_swigregister = _fife.Text_swigregister
Text_swigregister(Text)

ES_ENGINE = _fife.ES_ENGINE
ES_GUICHAN_WIDGET = _fife.ES_GUICHAN_WIDGET
CMD_UNKNOWN = _fife.CMD_UNKNOWN
CMD_QUIT_GAME = _fife.CMD_QUIT_GAME
CMD_MOUSE_FOCUS_GAINED = _fife.CMD_MOUSE_FOCUS_GAINED
CMD_MOUSE_FOCUS_LOST = _fife.CMD_MOUSE_FOCUS_LOST
CMD_INPUT_FOCUS_GAINED = _fife.CMD_INPUT_FOCUS_GAINED
CMD_INPUT_FOCUS_LOST = _fife.CMD_INPUT_FOCUS_LOST
CMD_APP_RESTORED = _fife.CMD_APP_RESTORED
CMD_APP_ICONIFIED = _fife.CMD_APP_ICONIFIED
class IEventSource(object):
    """Proxy of C++ FIFE::IEventSource class."""

    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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::IEventSource self) -> IEventSource"""
        if self.__class__ == IEventSource:
            _self = None
        else:
            _self = self
        this = _fife.new_IEventSource(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IEventSource(self)
        return weakref_proxy(self)
IEventSource_swigregister = _fife.IEventSource_swigregister
IEventSource_swigregister(IEventSource)

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

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None
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"""
        this = _fife.new_Command()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Command
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::ICommandListener self) -> ICommandListener"""
        if self.__class__ == ICommandListener:
            _self = None
        else:
            _self = self
        this = _fife.new_ICommandListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ICommandListener(self)
        return weakref_proxy(self)
ICommandListener_swigregister = _fife.ICommandListener_swigregister
ICommandListener_swigregister(ICommandListener)

class KeyEvent(InputEvent):
    """Proxy of C++ FIFE::KeyEvent class."""

    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
    __del__ = lambda self: None
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)

    __swig_destroy__ = _fife.delete_IKeyListener
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::IKeyListener self) -> IKeyListener"""
        if self.__class__ == IKeyListener:
            _self = None
        else:
            _self = self
        this = _fife.new_IKeyListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyListener(self)
        return weakref_proxy(self)
IKeyListener_swigregister = _fife.IKeyListener_swigregister
IKeyListener_swigregister(IKeyListener)

class 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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::ITextListener self) -> ITextListener"""
        if self.__class__ == ITextListener:
            _self = None
        else:
            _self = self
        this = _fife.new_ITextListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ITextListener(self)
        return weakref_proxy(self)
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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::ISdlEventListener self) -> ISdlEventListener"""
        if self.__class__ == ISdlEventListener:
            _self = None
        else:
            _self = self
        this = _fife.new_ISdlEventListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ISdlEventListener(self)
        return weakref_proxy(self)
ISdlEventListener_swigregister = _fife.ISdlEventListener_swigregister
ISdlEventListener_swigregister(ISdlEventListener)

class MouseEvent(InputEvent):
    """Proxy of C++ FIFE::MouseEvent class."""

    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
    __del__ = lambda self: None
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)

    __swig_destroy__ = _fife.delete_IMouseListener
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::IMouseListener self) -> IMouseListener"""
        if self.__class__ == IMouseListener:
            _self = None
        else:
            _self = self
        this = _fife.new_IMouseListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMouseListener(self)
        return weakref_proxy(self)
IMouseListener_swigregister = _fife.IMouseListener_swigregister
IMouseListener_swigregister(IMouseListener)

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

    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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::IKeyFilter self) -> IKeyFilter"""
        if self.__class__ == IKeyFilter:
            _self = None
        else:
            _self = self
        this = _fife.new_IKeyFilter(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IKeyFilter(self)
        return weakref_proxy(self)
IKeyFilter_swigregister = _fife.IKeyFilter_swigregister
IKeyFilter_swigregister(IKeyFilter)

class 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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::IDropListener self) -> IDropListener"""
        if self.__class__ == IDropListener:
            _self = None
        else:
            _self = self
        this = _fife.new_IDropListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IDropListener(self)
        return weakref_proxy(self)
IDropListener_swigregister = _fife.IDropListener_swigregister
IDropListener_swigregister(IDropListener)

class IMouseFilter(object):
    """Proxy of C++ FIFE::IMouseFilter 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(IMouseFilter self, MouseEvent evt) -> bool"""
        return _fife.IMouseFilter_isFiltered(self, evt)

    __swig_destroy__ = _fife.delete_IMouseFilter
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::IMouseFilter self) -> IMouseFilter"""
        if self.__class__ == IMouseFilter:
            _self = None
        else:
            _self = self
        this = _fife.new_IMouseFilter(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMouseFilter(self)
        return weakref_proxy(self)
IMouseFilter_swigregister = _fife.IMouseFilter_swigregister
IMouseFilter_swigregister(IMouseFilter)

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"""
        this = _fife.new_EventManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_EventManager
    __del__ = lambda self: None

    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 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 setMouseFilter(self, mouseFilter):
        """setMouseFilter(EventManager self, IMouseFilter mouseFilter)"""
        return _fife.EventManager_setMouseFilter(self, mouseFilter)


    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)

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"""
        this = _fife.new_Exception(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Exception
    __del__ = lambda self: None

    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_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"""
        this = _fife.new_SDLException(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
SDLException_swigregister = _fife.SDLException_swigregister
SDLException_swigregister(SDLException)

class NotFound(Exception):
    """Proxy of C++ FIFE::NotFound class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotFound, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotFound, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::NotFound self, std::string const & msg) -> NotFound"""
        this = _fife.new_NotFound(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
NotFound_swigregister = _fife.NotFound_swigregister
NotFound_swigregister(NotFound)

class NotSet(Exception):
    """Proxy of C++ FIFE::NotSet class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotSet, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotSet, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::NotSet self, std::string const & msg) -> NotSet"""
        this = _fife.new_NotSet(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
NotSet_swigregister = _fife.NotSet_swigregister
NotSet_swigregister(NotSet)

class IndexOverflow(Exception):
    """Proxy of C++ FIFE::IndexOverflow class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IndexOverflow, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, IndexOverflow, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::IndexOverflow self, std::string const & msg) -> IndexOverflow"""
        this = _fife.new_IndexOverflow(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
IndexOverflow_swigregister = _fife.IndexOverflow_swigregister
IndexOverflow_swigregister(IndexOverflow)

class InvalidFormat(Exception):
    """Proxy of C++ FIFE::InvalidFormat class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidFormat, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidFormat, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::InvalidFormat self, std::string const & msg) -> InvalidFormat"""
        this = _fife.new_InvalidFormat(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
InvalidFormat_swigregister = _fife.InvalidFormat_swigregister
InvalidFormat_swigregister(InvalidFormat)

class CannotOpenFile(Exception):
    """Proxy of C++ FIFE::CannotOpenFile class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CannotOpenFile, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CannotOpenFile, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::CannotOpenFile self, std::string const & msg) -> CannotOpenFile"""
        this = _fife.new_CannotOpenFile(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
CannotOpenFile_swigregister = _fife.CannotOpenFile_swigregister
CannotOpenFile_swigregister(CannotOpenFile)

class InvalidConversion(Exception):
    """Proxy of C++ FIFE::InvalidConversion class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InvalidConversion, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InvalidConversion, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::InvalidConversion self, std::string const & msg) -> InvalidConversion"""
        this = _fife.new_InvalidConversion(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
InvalidConversion_swigregister = _fife.InvalidConversion_swigregister
InvalidConversion_swigregister(InvalidConversion)

class NotSupported(Exception):
    """Proxy of C++ FIFE::NotSupported class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NotSupported, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NotSupported, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::NotSupported self, std::string const & msg) -> NotSupported"""
        this = _fife.new_NotSupported(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
NotSupported_swigregister = _fife.NotSupported_swigregister
NotSupported_swigregister(NotSupported)

class NameClash(Exception):
    """Proxy of C++ FIFE::NameClash class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NameClash, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NameClash, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::NameClash self, std::string const & msg) -> NameClash"""
        this = _fife.new_NameClash(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
NameClash_swigregister = _fife.NameClash_swigregister
NameClash_swigregister(NameClash)

class Duplicate(Exception):
    """Proxy of C++ FIFE::Duplicate class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Duplicate, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Duplicate, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::Duplicate self, std::string const & msg) -> Duplicate"""
        this = _fife.new_Duplicate(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
Duplicate_swigregister = _fife.Duplicate_swigregister
Duplicate_swigregister(Duplicate)

class ScriptException(Exception):
    """Proxy of C++ FIFE::ScriptException class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ScriptException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ScriptException, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::ScriptException self, std::string const & msg) -> ScriptException"""
        this = _fife.new_ScriptException(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
ScriptException_swigregister = _fife.ScriptException_swigregister
ScriptException_swigregister(ScriptException)

class EventException(Exception):
    """Proxy of C++ FIFE::EventException class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EventException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, EventException, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::EventException self, std::string const & msg) -> EventException"""
        this = _fife.new_EventException(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
EventException_swigregister = _fife.EventException_swigregister
EventException_swigregister(EventException)

class GuiException(Exception):
    """Proxy of C++ FIFE::GuiException class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GuiException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GuiException, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::GuiException self, std::string const & msg) -> GuiException"""
        this = _fife.new_GuiException(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
GuiException_swigregister = _fife.GuiException_swigregister
GuiException_swigregister(GuiException)

class InconsistencyDetected(Exception):
    """Proxy of C++ FIFE::InconsistencyDetected class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InconsistencyDetected, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, InconsistencyDetected, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::InconsistencyDetected self, std::string const & msg) -> InconsistencyDetected"""
        this = _fife.new_InconsistencyDetected(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
InconsistencyDetected_swigregister = _fife.InconsistencyDetected_swigregister
InconsistencyDetected_swigregister(InconsistencyDetected)

class OutOfMemory(Exception):
    """Proxy of C++ FIFE::OutOfMemory class."""

    __swig_setmethods__ = {}
    for _s in [Exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutOfMemory, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutOfMemory, name)
    __repr__ = _swig_repr

    def __init__(self, msg):
        """__init__(FIFE::OutOfMemory self, std::string const & msg) -> OutOfMemory"""
        this = _fife.new_OutOfMemory(msg)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    def getFifeId(self):
        """getFifeId(FifeClass self) -> FIFE::fifeid_t"""
        return _fife.FifeClass_getFifeId(self)


    def __init__(self):
        """__init__(FIFE::FifeClass self) -> FifeClass"""
        this = _fife.new_FifeClass()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
FifeClass_swigregister = _fife.FifeClass_swigregister
FifeClass_swigregister(FifeClass)

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, int _x=0) -> Point
        __init__(FIFE::PointType2D<(int32_t)> self) -> Point
        __init__(FIFE::PointType2D<(int32_t)> self, Point rhs) -> Point
        """
        this = _fife.new_Point(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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, double _x=0) -> DoublePoint
        __init__(FIFE::PointType2D<(double)> self) -> DoublePoint
        __init__(FIFE::PointType2D<(double)> self, DoublePoint rhs) -> DoublePoint
        """
        this = _fife.new_DoublePoint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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, int _x=0, int _y=0) -> Point3D
        __init__(FIFE::PointType3D<(int32_t)> self, int _x=0) -> Point3D
        __init__(FIFE::PointType3D<(int32_t)> self) -> Point3D
        __init__(FIFE::PointType3D<(int32_t)> self, Point3D rhs) -> Point3D
        """
        this = _fife.new_Point3D(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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, double _x=0, double _y=0) -> DoublePoint3D
        __init__(FIFE::PointType3D<(double)> self, double _x=0) -> DoublePoint3D
        __init__(FIFE::PointType3D<(double)> self) -> DoublePoint3D
        __init__(FIFE::PointType3D<(double)> self, DoublePoint3D rhs) -> DoublePoint3D
        """
        this = _fife.new_DoublePoint3D(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        __init__(FIFE::RectType<(int32_t)> self, int x=0, int y=0, int width=0) -> Rect
        __init__(FIFE::RectType<(int32_t)> self, int x=0, int y=0) -> Rect
        __init__(FIFE::RectType<(int32_t)> self, int x=0) -> Rect
        __init__(FIFE::RectType<(int32_t)> self) -> Rect
        """
        this = _fife.new_Rect(x, y, width, height)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        __init__(FIFE::RectType<(float)> self, float x=0, float y=0, float width=0) -> FloatRect
        __init__(FIFE::RectType<(float)> self, float x=0, float y=0) -> FloatRect
        __init__(FIFE::RectType<(float)> self, float x=0) -> FloatRect
        __init__(FIFE::RectType<(float)> self) -> FloatRect
        """
        this = _fife.new_FloatRect(x, y, width, height)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        __init__(FIFE::RectType<(double)> self, double x=0, double y=0, double width=0) -> DoubleRect
        __init__(FIFE::RectType<(double)> self, double x=0, double y=0) -> DoubleRect
        __init__(FIFE::RectType<(double)> self, double x=0) -> DoubleRect
        __init__(FIFE::RectType<(double)> self) -> DoubleRect
        """
        this = _fife.new_DoubleRect(x, y, width, height)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
DoubleRect_swigregister = _fife.DoubleRect_swigregister
DoubleRect_swigregister(DoubleRect)

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
        """
        this = _fife.new_ScreenModeVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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_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
        """
        this = _fife.new_SharedImagePointer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SharedImagePointer
    __del__ = lambda self: None

    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)
        reset(SharedImagePointer self)
        """
        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_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
    __del__ = lambda self: None

    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
        create(ImageManager self, std::string const & name) -> 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
        load(ImageManager self, std::string const & name) -> 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"""
        this = _fife.new_ImageManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
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
    __del__ = lambda self: None

    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_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
        """
        this = _fife.new_SharedAnimationPointer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SharedAnimationPointer
    __del__ = lambda self: None

    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)
        reset(SharedAnimationPointer self)
        """
        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_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
    __del__ = lambda self: None

    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
        create(AnimationManager self, std::string const & name) -> 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"""
        this = _fife.new_AnimationManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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)
        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, SharedAnimationPointer anim, int32_t drag_offset_x=0)
        setDrag(Cursor self, SharedAnimationPointer anim)
        setDrag(Cursor self, SharedImagePointer image, int32_t drag_offset_x=0, int32_t drag_offset_y=0)
        setDrag(Cursor self, SharedImagePointer image, int32_t drag_offset_x=0)
        setDrag(Cursor self, SharedImagePointer image)
        """
        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)

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
    __del__ = lambda self: None

    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"""
        this = _fife.new_ScreenMode()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
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"""
        this = _fife.new_DeviceCaps()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_DeviceCaps
    __del__ = lambda self: None

    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
        getNearestScreenMode(DeviceCaps self, uint16_t width, uint16_t height, uint16_t bpp, std::string const & renderer, bool fs, uint16_t refresh) -> 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
        getDisplayName(DeviceCaps self) -> std::string
        """
        return _fife.DeviceCaps_getDisplayName(self, display)


    def getDesktopFormat(self, display=0):
        """
        getDesktopFormat(DeviceCaps self, uint8_t display=0) -> uint32_t
        getDesktopFormat(DeviceCaps self) -> uint32_t
        """
        return _fife.DeviceCaps_getDesktopFormat(self, display)


    def getDesktopRefreshRate(self, display=0):
        """
        getDesktopRefreshRate(DeviceCaps self, uint8_t display=0) -> int32_t
        getDesktopRefreshRate(DeviceCaps self) -> int32_t
        """
        return _fife.DeviceCaps_getDesktopRefreshRate(self, display)


    def getDesktopWidth(self, display=0):
        """
        getDesktopWidth(DeviceCaps self, uint8_t display=0) -> int32_t
        getDesktopWidth(DeviceCaps self) -> int32_t
        """
        return _fife.DeviceCaps_getDesktopWidth(self, display)


    def getDesktopHeight(self, display=0):
        """
        getDesktopHeight(DeviceCaps self, uint8_t display=0) -> int32_t
        getDesktopHeight(DeviceCaps self) -> int32_t
        """
        return _fife.DeviceCaps_getDesktopHeight(self, display)


    def getDisplayBounds(self, display=0):
        """
        getDisplayBounds(DeviceCaps self, uint8_t display=0) -> Rect
        getDisplayBounds(DeviceCaps self) -> Rect
        """
        return _fife.DeviceCaps_getDisplayBounds(self, display)

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
        """
        this = _fife.new_AtlasBlock(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        __init__(FIFE::AtlasBook self, uint32_t pageWidth, uint32_t pageHeight) -> AtlasBook
        """
        this = _fife.new_AtlasBook(pageWidth, pageHeight, pixelSize)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        __init__(FIFE::Color self, uint8_t r=0, uint8_t g=0, uint8_t b=0) -> Color
        __init__(FIFE::Color self, uint8_t r=0, uint8_t g=0) -> Color
        __init__(FIFE::Color self, uint8_t r=0) -> Color
        __init__(FIFE::Color self) -> Color
        """
        this = _fife.new_Color(r, g, b, alpha)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Color
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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
        this = _fife.new_IAnimationLoader(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationLoader(self)
        return weakref_proxy(self)
IAnimationLoader_swigregister = _fife.IAnimationLoader_swigregister
IAnimationLoader_swigregister(IAnimationLoader)

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

    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
    __del__ = lambda self: None

    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
        this = _fife.new_IAtlasLoader(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasLoader(self)
        return weakref_proxy(self)
IAtlasLoader_swigregister = _fife.IAtlasLoader_swigregister
IAtlasLoader_swigregister(IAtlasLoader)

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

    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"""
        this = _fife.new_AtlasData()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_AtlasData
    __del__ = lambda self: None
AtlasData_swigregister = _fife.AtlasData_swigregister
AtlasData_swigregister(AtlasData)

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

    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"""
        this = _fife.new_Atlas(name)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Atlas
    __del__ = lambda self: None

    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_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"""
        this = _fife.new_AtlasLoader(model, vfs, imageManager, animationManager)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_AtlasLoader
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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
        this = _fife.new_IMapLoader(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapLoader(self)
        return weakref_proxy(self)
IMapLoader_swigregister = _fife.IMapLoader_swigregister
IMapLoader_swigregister(IMapLoader)

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

    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
    __del__ = lambda self: None

    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
        this = _fife.new_IObjectLoader(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectLoader(self)
        return weakref_proxy(self)
IObjectLoader_swigregister = _fife.IObjectLoader_swigregister
IObjectLoader_swigregister(IObjectLoader)

class ObjectLoader(IObjectLoader):
    """Proxy of C++ FIFE::ObjectLoader class."""

    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::ObjectLoader self, Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager, FIFE::AnimationLoaderPtr const & animationLoader, FIFE::AtlasLoaderPtr const & atlasLoader) -> ObjectLoader
        __init__(FIFE::ObjectLoader self, Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager, FIFE::AnimationLoaderPtr const & animationLoader) -> ObjectLoader
        __init__(FIFE::ObjectLoader self, Model model, VFS vfs, ImageManager imageManager, AnimationManager animationManager) -> ObjectLoader
        """
        this = _fife.new_ObjectLoader(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_ObjectLoader
    __del__ = lambda self: None

    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):
        """
        loadImportFile(ObjectLoader self, std::string const & file, std::string const & directory)
        loadImportFile(ObjectLoader self, std::string const & file)
        """
        return _fife.ObjectLoader_loadImportFile(self, *args)


    def loadImportDirectory(self, directory):
        """loadImportDirectory(ObjectLoader self, std::string const & directory)"""
        return _fife.ObjectLoader_loadImportDirectory(self, directory)

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"""
        this = _fife.new_MapLoader(model, vfs, imageManager, renderBackend)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_MapLoader
    __del__ = lambda self: None

    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):
        """
        loadImportFile(MapLoader self, std::string const & file, std::string const & directory)
        loadImportFile(MapLoader self, std::string const & file)
        """
        return _fife.MapLoader_loadImportFile(self, *args)


    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_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
    __del__ = lambda self: None

    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
        this = _fife.new_PercentDoneListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_PercentDoneListener(self)
        return weakref_proxy(self)
PercentDoneListener_swigregister = _fife.PercentDoneListener_swigregister
PercentDoneListener_swigregister(PercentDoneListener)

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

    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
    __del__ = lambda self: None
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"""
        this = _fife.new_Action(identifier)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Action
    __del__ = lambda self: None

    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_swigregister = _fife.Action_swigregister
Action_swigregister(Action)

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, int _x=0, int _y=0) -> ModelCoordinate
        __init__(FIFE::PointType3D<(int32_t)> self, int _x=0) -> ModelCoordinate
        __init__(FIFE::PointType3D<(int32_t)> self) -> ModelCoordinate
        __init__(FIFE::PointType3D<(int32_t)> self, Point3D rhs) -> ModelCoordinate
        """
        this = _fife.new_ModelCoordinate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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, double _x=0, double _y=0) -> ExactModelCoordinate
        __init__(FIFE::PointType3D<(double)> self, double _x=0) -> ExactModelCoordinate
        __init__(FIFE::PointType3D<(double)> self) -> ExactModelCoordinate
        __init__(FIFE::PointType3D<(double)> self, DoublePoint3D rhs) -> ExactModelCoordinate
        """
        this = _fife.new_ExactModelCoordinate(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
ExactModelCoordinate_swigregister = _fife.ExactModelCoordinate_swigregister
ExactModelCoordinate_swigregister(ExactModelCoordinate)

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
        """
        this = _fife.new_Location(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Location
    __del__ = lambda self: None

    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_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
        """
        this = _fife.new_LocationVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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
        this = _fife.new_InstanceActionListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceActionListener(self)
        return weakref_proxy(self)
InstanceActionListener_swigregister = _fife.InstanceActionListener_swigregister
InstanceActionListener_swigregister(InstanceActionListener)

ICHANGE_NO_CHANGES = _fife.ICHANGE_NO_CHANGES
ICHANGE_LOC = _fife.ICHANGE_LOC
ICHANGE_ROTATION = _fife.ICHANGE_ROTATION
ICHANGE_SPEED = _fife.ICHANGE_SPEED
ICHANGE_ACTION = _fife.ICHANGE_ACTION
ICHANGE_TIME_MULTIPLIER = _fife.ICHANGE_TIME_MULTIPLIER
ICHANGE_SAYTEXT = _fife.ICHANGE_SAYTEXT
ICHANGE_BLOCK = _fife.ICHANGE_BLOCK
ICHANGE_CELL = _fife.ICHANGE_CELL
ICHANGE_TRANSPARENCY = _fife.ICHANGE_TRANSPARENCY
ICHANGE_VISIBLE = _fife.ICHANGE_VISIBLE
ICHANGE_STACKPOS = _fife.ICHANGE_STACKPOS
class InstanceChangeListener(object):
    """Proxy of C++ FIFE::InstanceChangeListener class."""

    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
    __del__ = lambda self: None

    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
        this = _fife.new_InstanceChangeListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceChangeListener(self)
        return weakref_proxy(self)
InstanceChangeListener_swigregister = _fife.InstanceChangeListener_swigregister
InstanceChangeListener_swigregister(InstanceChangeListener)

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
    __del__ = lambda self: None

    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
        this = _fife.new_InstanceDeleteListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_InstanceDeleteListener(self)
        return weakref_proxy(self)
InstanceDeleteListener_swigregister = _fife.InstanceDeleteListener_swigregister
InstanceDeleteListener_swigregister(InstanceDeleteListener)

ITYPE_NO_SHAPE = _fife.ITYPE_NO_SHAPE
ITYPE_QUAD_SHAPE = _fife.ITYPE_QUAD_SHAPE
ITYPE_CIRCLE_SHAPE = _fife.ITYPE_CIRCLE_SHAPE
class Instance(FifeClass):
    """Proxy of C++ FIFE::Instance class."""

    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::Instance self, Object object, Location location, std::string const & identifier) -> Instance
        __init__(FIFE::Instance self, Object object, Location location) -> Instance
        """
        this = _fife.new_Instance(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Instance
    __del__ = lambda self: None

    def getId(self):
        """getId(Instance self) -> std::string const &"""
        return _fife.Instance_getId(self)


    def setId(self, *args):
        """
        setId(Instance self, std::string const & identifier)
        setId(Instance self)
        """
        return _fife.Instance_setId(self, *args)


    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):
        """
        move(Instance self, std::string const & actionName, Location target, double const speed, std::string const & costId)
        move(Instance self, std::string const & actionName, Location target, double const speed)
        """
        return _fife.Instance_move(self, *args)


    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)
        cancelMovement(Instance self)
        """
        return _fife.Instance_cancelMovement(self, length)


    def say(self, text, duration=0):
        """
        say(Instance self, std::string const & text, uint32_t duration=0)
        say(Instance self, std::string const & text)
        """
        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 setVisitor(self, visit):
        """setVisitor(Instance self, bool visit)"""
        return _fife.Instance_setVisitor(self, visit)


    def isVisitor(self):
        """isVisitor(Instance self) -> bool"""
        return _fife.Instance_isVisitor(self)


    def setVisitorShape(self, info):
        """setVisitorShape(Instance self, FIFE::VisitorShapeInfo info)"""
        return _fife.Instance_setVisitorShape(self, info)


    def getVisitorShape(self):
        """getVisitorShape(Instance self) -> FIFE::VisitorShapeInfo"""
        return _fife.Instance_getVisitorShape(self)


    def setVisitorRadius(self, radius):
        """setVisitorRadius(Instance self, uint16_t radius)"""
        return _fife.Instance_setVisitorRadius(self, radius)


    def getVisitorRadius(self):
        """getVisitorRadius(Instance self) -> uint16_t"""
        return _fife.Instance_getVisitorRadius(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_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
        """
        this = _fife.new_InstanceVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_InstanceList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_AnimationOverlayMap(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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"""
        this = _fife.new_Route(start, end)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Route
    __del__ = lambda self: None

    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
        walkToNextNode(Route self) -> 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)
        cutPath(Route self)
        """
        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_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
    __del__ = lambda self: None

    def createRoute(self, *args):
        """
        createRoute(IPather self, Location start, Location end, bool immediate=False, std::string const & cost_id) -> Route
        createRoute(IPather self, Location start, Location end, bool immediate=False) -> Route
        createRoute(IPather self, Location start, Location end) -> Route
        """
        return _fife.IPather_createRoute(self, *args)


    def solveRoute(self, *args):
        """
        solveRoute(IPather self, Route route, int32_t priority, bool immediate=False) -> bool
        solveRoute(IPather self, Route route, int32_t priority) -> bool
        solveRoute(IPather self, Route route) -> bool
        """
        return _fife.IPather_solveRoute(self, *args)


    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
        this = _fife.new_IPather(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IPather(self)
        return weakref_proxy(self)
IPather_swigregister = _fife.IPather_swigregister
IPather_swigregister(IPather)

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

    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
        __init__(FIFE::Object self, std::string const & identifier, std::string const & name_space) -> Object
        """
        this = _fife.new_Object(identifier, name_space, inherited)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Object
    __del__ = lambda self: None

    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
        createAction(Object self, std::string const & identifier) -> 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
        getAction(Object self, std::string const & identifier) -> 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_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"""
        this = _fife.new_TimeProvider(master)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_TimeProvider
    __del__ = lambda self: None

    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_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
        """
        this = _fife.new_ModelCoordinateVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_ExactModelCoordinateVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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)

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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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
CELLV_CONCEALED = _fife.CELLV_CONCEALED
CELLV_REVEALED = _fife.CELLV_REVEALED
CELLV_MASKED = _fife.CELLV_MASKED
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
    __del__ = lambda self: None

    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
        this = _fife.new_CellChangeListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_CellChangeListener(self)
        return weakref_proxy(self)
CellChangeListener_swigregister = _fife.CellChangeListener_swigregister
CellChangeListener_swigregister(CellChangeListener)

class 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
    __del__ = lambda self: None

    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
        this = _fife.new_CellDeleteListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_CellDeleteListener(self)
        return weakref_proxy(self)
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"""
        this = _fife.new_Cell(coordint, coordinate, layer)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Cell
    __del__ = lambda self: None

    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 setFoWType(self, type):
        """setFoWType(Cell self, FIFE::CellVisualEffect type)"""
        return _fife.Cell_setFoWType(self, type)


    def getFoWType(self):
        """getFoWType(Cell self) -> FIFE::CellVisualEffect"""
        return _fife.Cell_getFoWType(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_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
        """
        this = _fife.new_InstanceSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_CellSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_CellVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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"""
        this = _fife.new_CellCache(layer)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_CellCache
    __del__ = lambda self: None

    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
        getCellsInLine(CellCache self, Point3D pt1, Point3D pt2) -> 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_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
    __del__ = lambda self: None

    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
        this = _fife.new_LayerChangeListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_LayerChangeListener(self)
        return weakref_proxy(self)
LayerChangeListener_swigregister = _fife.LayerChangeListener_swigregister
LayerChangeListener_swigregister(LayerChangeListener)

class Layer(FifeClass):
    """Proxy of C++ FIFE::Layer class."""

    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"""
        this = _fife.new_Layer(identifier, map, geometry)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Layer
    __del__ = lambda self: None

    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, Point3D p) -> Instance
        createInstance(Layer self, Object object, DoublePoint3D p, std::string const & id) -> Instance
        createInstance(Layer self, Object object, DoublePoint3D p) -> 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
        getInstancesAt(Layer self, Location loc) -> 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)
        getMinMaxCoordinates(Layer self, Point3D min, Point3D max)
        """
        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_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
        """
        this = _fife.new_LayerList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_LayerVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_CameraVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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
        this = _fife.new_MapChangeListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_MapChangeListener(self)
        return weakref_proxy(self)
MapChangeListener_swigregister = _fife.MapChangeListener_swigregister
MapChangeListener_swigregister(MapChangeListener)

class Map(FifeClass):
    """Proxy of C++ FIFE::Map class."""

    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
        __init__(FIFE::Map self, std::string const & identifier, RenderBackend renderbackend, std::vector< FIFE::RendererBase *,std::allocator< FIFE::RendererBase * > > const & renderers) -> Map
        """
        this = _fife.new_Map(identifier, renderbackend, renderers, tp_master)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Map
    __del__ = lambda self: None

    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, layer, viewport):
        """addCamera(Map self, std::string const & id, Layer layer, Rect viewport) -> Camera"""
        return _fife.Map_addCamera(self, id, layer, 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_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, Layer relative_layer) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Location relative_location, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Location relative_location) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Layer relative_layer, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Layer relative_layer) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Instance attached_instance) -> RendererNode
        __init__(FIFE::RendererNode self, Location attached_location, Layer relative_layer, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Location attached_location, Layer relative_layer) -> RendererNode
        __init__(FIFE::RendererNode self, Location attached_location, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Location attached_location) -> RendererNode
        __init__(FIFE::RendererNode self, Layer attached_layer, Point relative_point) -> RendererNode
        __init__(FIFE::RendererNode self, Layer attached_layer) -> RendererNode
        __init__(FIFE::RendererNode self, Point attached_point) -> RendererNode
        __init__(FIFE::RendererNode self, RendererNode old) -> RendererNode
        """
        this = _fife.new_RendererNode(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_RendererNode
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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
        this = _fife.new_ITriggerListener(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ITriggerListener(self)
        return weakref_proxy(self)
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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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
        """
        this = _fife.new_TriggerConditionVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_TriggerVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_StringList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_ObjectList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_MapList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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"""
        this = _fife.new_Model(renderbackend, renderers)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Model
    __del__ = lambda self: None

    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
        createObject(Model self, std::string const & identifier, std::string const & name_space) -> 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_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
        """
        this = _fife.new_LocationList(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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"""
        this = _fife.new_RoutePather()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_RoutePather
    __del__ = lambda self: None

    def getName(self):
        """getName(RoutePather self) -> std::string"""
        return _fife.RoutePather_getName(self)

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
    __del__ = lambda self: None

    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
        this = _fife.new_IAnimationSaver(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAnimationSaver(self)
        return weakref_proxy(self)
IAnimationSaver_swigregister = _fife.IAnimationSaver_swigregister
IAnimationSaver_swigregister(IAnimationSaver)

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

    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
    __del__ = lambda self: None

    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
        this = _fife.new_IAtlasSaver(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IAtlasSaver(self)
        return weakref_proxy(self)
IAtlasSaver_swigregister = _fife.IAtlasSaver_swigregister
IAtlasSaver_swigregister(IAtlasSaver)

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

    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
    __del__ = lambda self: None

    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
        this = _fife.new_IMapSaver(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IMapSaver(self)
        return weakref_proxy(self)
IMapSaver_swigregister = _fife.IMapSaver_swigregister
IMapSaver_swigregister(IMapSaver)

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

    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
    __del__ = lambda self: None

    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
        this = _fife.new_IObjectSaver(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_IObjectSaver(self)
        return weakref_proxy(self)
IObjectSaver_swigregister = _fife.IObjectSaver_swigregister
IObjectSaver_swigregister(IObjectSaver)

class MapSaver(IMapSaver):
    """Proxy of C++ FIFE::MapSaver class."""

    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"""
        this = _fife.new_MapSaver()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_MapSaver
    __del__ = lambda self: None

    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_swigregister = _fife.MapSaver_swigregister
MapSaver_swigregister(MapSaver)

LM_CORE = _fife.LM_CORE
LM_AUDIO = _fife.LM_AUDIO
LM_CONTROLLER = _fife.LM_CONTROLLER
LM_EVTCHANNEL = _fife.LM_EVTCHANNEL
LM_GUI = _fife.LM_GUI
LM_CONSOLE = _fife.LM_CONSOLE
LM_LOADERS = _fife.LM_LOADERS
LM_NATIVE_LOADERS = _fife.LM_NATIVE_LOADERS
LM_FO_LOADERS = _fife.LM_FO_LOADERS
LM_SAVERS = _fife.LM_SAVERS
LM_NATIVE_SAVERS = _fife.LM_NATIVE_SAVERS
LM_MODEL = _fife.LM_MODEL
LM_STRUCTURES = _fife.LM_STRUCTURES
LM_INSTANCE = _fife.LM_INSTANCE
LM_LOCATION = _fife.LM_LOCATION
LM_METAMODEL = _fife.LM_METAMODEL
LM_CELLGRID = _fife.LM_CELLGRID
LM_SQUAREGRID = _fife.LM_SQUAREGRID
LM_HEXGRID = _fife.LM_HEXGRID
LM_PATHFINDER = _fife.LM_PATHFINDER
LM_UTIL = _fife.LM_UTIL
LM_RESMGR = _fife.LM_RESMGR
LM_VFS = _fife.LM_VFS
LM_VIDEO = _fife.LM_VIDEO
LM_VIEW = _fife.LM_VIEW
LM_CAMERA = _fife.LM_CAMERA
LM_VIEWVIEW = _fife.LM_VIEWVIEW
LM_XML = _fife.LM_XML
LM_EXCEPTION = _fife.LM_EXCEPTION
LM_SCRIPT = _fife.LM_SCRIPT
LM_MODULE_MAX = _fife.LM_MODULE_MAX
class moduleVector(object):
    """Proxy of C++ std::vector<(logmodule_t)> class."""

    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
        """
        this = _fife.new_moduleVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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_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"""
        this = _fife.new_Logger(module)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Logger
    __del__ = lambda self: None

    def log(self, level, msg):
        """log(Logger self, FIFE::LogManager::LogLevel level, std::string const & msg)"""
        return _fife.Logger_log(self, level, msg)

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"""
        this = _fife.new_Mathf()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Mathf
    __del__ = lambda self: None
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"""
        this = _fife.new_Mathd()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Mathd
    __del__ = lambda self: None
Mathd_swigregister = _fife.Mathd_swigregister
Mathd_swigregister(Mathd)

def Mathd_epsilon():
    """Mathd_epsilon() -> 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
        __init__(FIFE::TimeEvent self) -> TimeEvent
        """
        if self.__class__ == TimeEvent:
            _self = None
        else:
            _self = self
        this = _fife.new_TimeEvent(_self, period)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_TimeEvent
    __del__ = lambda self: None

    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_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"""
        this = _fife.new_TimeManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_TimeManager
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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"""
        this = _fife.new_RawData(datasource)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_RawData
    __del__ = lambda self: None

    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)
        read(RawData self)
        """
        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_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
        """
        this = _fife.new_StringSet(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
        """
        this = _fife.new_vectoru(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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"""
        this = _fife.new_VFS()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_VFS
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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)
        setColor(IFont self, uint8_t r, uint8_t g, uint8_t b)
        """
        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_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
    __del__ = lambda self: None
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"""
        this = _fife.new_TTFont(filename, size)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_TTFont
    __del__ = lambda self: None

    def setColor(self, r, g, b, a=255):
        """
        setColor(TTFont self, Uint8 r, Uint8 g, Uint8 b, Uint8 a=255)
        setColor(TTFont self, Uint8 r, Uint8 g, Uint8 b)
        """
        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_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"""
        this = _fife.new_SubImageFont(filename, glyphs)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SubImageFont
    __del__ = lambda self: None

    def setColor(self, r, g, b, a=255):
        """
        setColor(SubImageFont self, Uint8 r, Uint8 g, Uint8 b, Uint8 a=255)
        setColor(SubImageFont self, Uint8 r, Uint8 g, Uint8 b)
        """
        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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    def getRenderer(self, renderername):
        """getRenderer(IRendererContainer self, std::string const & renderername) -> RendererBase"""
        return _fife.IRendererContainer_getRenderer(self, renderername)

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, int _x=0, int _y=0) -> ScreenPoint
        __init__(FIFE::PointType3D<(int32_t)> self, int _x=0) -> ScreenPoint
        __init__(FIFE::PointType3D<(int32_t)> self) -> ScreenPoint
        __init__(FIFE::PointType3D<(int32_t)> self, Point3D rhs) -> ScreenPoint
        """
        this = _fife.new_ScreenPoint(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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 getLocationRef(self):
        """getLocationRef(Camera self) -> Location"""
        return _fife.Camera_getLocationRef(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):
        """getCellImageDimensions(Camera self) -> Point"""
        return _fife.Camera_getCellImageDimensions(self)


    def getZOffset(self, layer):
        """getZOffset(Camera self, Layer layer) -> Point3D"""
        return _fife.Camera_getZOffset(self, layer)


    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
        toMapCoordinates(Camera self, Point3D screen_coords) -> 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, Point3D screen_coords, Layer layer)
        getMatchingInstances(Camera self, Rect screen_rect, Layer layer, uint8_t alpha=0)
        getMatchingInstances(Camera self, Rect screen_rect, Layer layer)
        getMatchingInstances(Camera self, Location loc, bool use_exactcoordinates=False)
        getMatchingInstances(Camera self, Location loc)
        """
        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)
        setOverlayImage(Camera self, int32_t id)
        """
        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)
        setOverlayAnimation(Camera self, SharedAnimationPointer anim)
        """
        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_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
        """
        this = _fife.new_OverlayColors(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OverlayColors
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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 setEnabledFogOfWar(self, enabled):
        """setEnabledFogOfWar(CellRenderer self, bool enabled)"""
        return _fife.CellRenderer_setEnabledFogOfWar(self, enabled)


    def isEnabledFogOfWar(self):
        """isEnabledFogOfWar(CellRenderer self) -> bool"""
        return _fife.CellRenderer_isEnabledFogOfWar(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 setFogOfWarLayer(self, layer):
        """setFogOfWarLayer(CellRenderer self, Layer layer)"""
        return _fife.CellRenderer_setFogOfWarLayer(self, layer)


    def setConcealImage(self, image):
        """setConcealImage(CellRenderer self, SharedImagePointer image)"""
        return _fife.CellRenderer_setConcealImage(self, image)


    def setMaskImage(self, image):
        """setMaskImage(CellRenderer self, SharedImagePointer image)"""
        return _fife.CellRenderer_setMaskImage(self, image)


    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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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)
        setColor(FloatingTextRenderer self, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        setBackground(FloatingTextRenderer self, uint8_t br, uint8_t bg, uint8_t bb)
        """
        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)
        setBorder(FloatingTextRenderer self, uint8_t bbr, uint8_t bbg, uint8_t bbb)
        """
        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_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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::GenericRendererElementInfo self) -> GenericRendererElementInfo"""
        this = _fife.new_GenericRendererElementInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
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"""
        this = _fife.new_GenericRendererLineInfo(n1, n2, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererLineInfo
    __del__ = lambda self: None
GenericRendererLineInfo_swigregister = _fife.GenericRendererLineInfo_swigregister
GenericRendererLineInfo_swigregister(GenericRendererLineInfo)

class GenericRendererPointInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererPointInfo class."""

    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"""
        this = _fife.new_GenericRendererPointInfo(n, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererPointInfo
    __del__ = lambda self: None
GenericRendererPointInfo_swigregister = _fife.GenericRendererPointInfo_swigregister
GenericRendererPointInfo_swigregister(GenericRendererPointInfo)

class GenericRendererTriangleInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererTriangleInfo class."""

    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"""
        this = _fife.new_GenericRendererTriangleInfo(n1, n2, n3, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererTriangleInfo
    __del__ = lambda self: None
GenericRendererTriangleInfo_swigregister = _fife.GenericRendererTriangleInfo_swigregister
GenericRendererTriangleInfo_swigregister(GenericRendererTriangleInfo)

class GenericRendererQuadInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererQuadInfo class."""

    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"""
        this = _fife.new_GenericRendererQuadInfo(n1, n2, n3, n4, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererQuadInfo
    __del__ = lambda self: None
GenericRendererQuadInfo_swigregister = _fife.GenericRendererQuadInfo_swigregister
GenericRendererQuadInfo_swigregister(GenericRendererQuadInfo)

class GenericRendererVertexInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererVertexInfo class."""

    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"""
        this = _fife.new_GenericRendererVertexInfo(center, size, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererVertexInfo
    __del__ = lambda self: None
GenericRendererVertexInfo_swigregister = _fife.GenericRendererVertexInfo_swigregister
GenericRendererVertexInfo_swigregister(GenericRendererVertexInfo)

class GenericRendererImageInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererImageInfo class."""

    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
        __init__(FIFE::GenericRendererImageInfo self, RendererNode n, SharedImagePointer image) -> GenericRendererImageInfo
        """
        this = _fife.new_GenericRendererImageInfo(n, image, zoomed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererImageInfo
    __del__ = lambda self: None
GenericRendererImageInfo_swigregister = _fife.GenericRendererImageInfo_swigregister
GenericRendererImageInfo_swigregister(GenericRendererImageInfo)

class GenericRendererAnimationInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererAnimationInfo class."""

    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
        __init__(FIFE::GenericRendererAnimationInfo self, RendererNode n, SharedAnimationPointer animation) -> GenericRendererAnimationInfo
        """
        this = _fife.new_GenericRendererAnimationInfo(n, animation, zoomed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererAnimationInfo
    __del__ = lambda self: None
GenericRendererAnimationInfo_swigregister = _fife.GenericRendererAnimationInfo_swigregister
GenericRendererAnimationInfo_swigregister(GenericRendererAnimationInfo)

class GenericRendererTextInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererTextInfo class."""

    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
        __init__(FIFE::GenericRendererTextInfo self, RendererNode n, IFont font, std::string text) -> GenericRendererTextInfo
        """
        this = _fife.new_GenericRendererTextInfo(n, font, text, zoomed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererTextInfo
    __del__ = lambda self: None
GenericRendererTextInfo_swigregister = _fife.GenericRendererTextInfo_swigregister
GenericRendererTextInfo_swigregister(GenericRendererTextInfo)

class GenericRendererResizeInfo(GenericRendererElementInfo):
    """Proxy of C++ FIFE::GenericRendererResizeInfo class."""

    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
        __init__(FIFE::GenericRendererResizeInfo self, RendererNode n, SharedImagePointer image, int32_t width, int32_t height) -> GenericRendererResizeInfo
        """
        this = _fife.new_GenericRendererResizeInfo(n, image, width, height, zoomed)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRendererResizeInfo
    __del__ = lambda self: None
GenericRendererResizeInfo_swigregister = _fife.GenericRendererResizeInfo_swigregister
GenericRendererResizeInfo_swigregister(GenericRendererResizeInfo)

class GenericRenderer(RendererBase):
    """Proxy of C++ FIFE::GenericRenderer class."""

    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"""
        this = _fife.new_GenericRenderer(renderbackend, position)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GenericRenderer
    __del__ = lambda self: None

    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)
        addLine(GenericRenderer self, std::string const & group, RendererNode n1, RendererNode n2, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addPoint(GenericRenderer self, std::string const & group, RendererNode n, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addTriangle(GenericRenderer self, std::string const & group, RendererNode n1, RendererNode n2, RendererNode n3, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addQuad(GenericRenderer self, std::string const & group, RendererNode n1, RendererNode n2, RendererNode n3, RendererNode n4, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addVertex(GenericRenderer self, std::string const & group, RendererNode n, int32_t size, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addText(GenericRenderer self, std::string const & group, RendererNode n, IFont font, std::string const & text)
        """
        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)
        addImage(GenericRenderer self, std::string const & group, RendererNode n, SharedImagePointer image)
        """
        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)
        addAnimation(GenericRenderer self, std::string const & group, RendererNode n, SharedAnimationPointer animation)
        """
        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)
        resizeImage(GenericRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, int32_t width, int32_t height)
        """
        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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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)
        addOutlined(InstanceRenderer self, Instance instance, int32_t r, int32_t g, int32_t b, int32_t width)
        """
        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)
        addColored(InstanceRenderer self, Instance instance, int32_t r, int32_t g, int32_t b)
        """
        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)
        addTransparentArea(InstanceRenderer self, Instance instance, StringList groups, uint32_t w, uint32_t h, uint8_t trans)
        """
        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_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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    def getImage(self):
        """getImage(LightRendererImageInfo self) -> SharedImagePointer"""
        return _fife.LightRendererImageInfo_getImage(self)

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
    __del__ = lambda self: None

    def getAnimation(self):
        """getAnimation(LightRendererAnimationInfo self) -> SharedAnimationPointer"""
        return _fife.LightRendererAnimationInfo_getAnimation(self)

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
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    def getImage(self):
        """getImage(LightRendererResizeInfo self) -> SharedImagePointer"""
        return _fife.LightRendererResizeInfo_getImage(self)

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"""
        this = _fife.new_LightRenderer(renderbackend, position)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_LightRenderer
    __del__ = lambda self: None

    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)
        addImage(LightRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, int32_t src=-1)
        addImage(LightRenderer self, std::string const & group, RendererNode n, SharedImagePointer image)
        """
        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)
        addAnimation(LightRenderer self, std::string const & group, RendererNode n, SharedAnimationPointer animation, int32_t src=-1)
        addAnimation(LightRenderer self, std::string const & group, RendererNode n, SharedAnimationPointer animation)
        """
        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)
        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)
        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)
        """
        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)
        resizeImage(LightRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, int32_t width, int32_t height, int32_t src=-1)
        resizeImage(LightRenderer self, std::string const & group, RendererNode n, SharedImagePointer image, int32_t width, int32_t height)
        """
        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)
        addStencilTest(LightRenderer self, std::string const & group)
        """
        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_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
        """
        this = _fife.new_LightRendererElementInfoVector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    def __init__(self):
        """__init__(FIFE::OffRendererElementInfo self) -> OffRendererElementInfo"""
        this = _fife.new_OffRendererElementInfo()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
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"""
        this = _fife.new_OffRendererLineInfo(n1, n2, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererLineInfo
    __del__ = lambda self: None
OffRendererLineInfo_swigregister = _fife.OffRendererLineInfo_swigregister
OffRendererLineInfo_swigregister(OffRendererLineInfo)

class OffRendererPointInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererPointInfo class."""

    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"""
        this = _fife.new_OffRendererPointInfo(n, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererPointInfo
    __del__ = lambda self: None
OffRendererPointInfo_swigregister = _fife.OffRendererPointInfo_swigregister
OffRendererPointInfo_swigregister(OffRendererPointInfo)

class OffRendererTriangleInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererTriangleInfo class."""

    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"""
        this = _fife.new_OffRendererTriangleInfo(n1, n2, n3, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererTriangleInfo
    __del__ = lambda self: None
OffRendererTriangleInfo_swigregister = _fife.OffRendererTriangleInfo_swigregister
OffRendererTriangleInfo_swigregister(OffRendererTriangleInfo)

class OffRendererQuadInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererQuadInfo class."""

    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"""
        this = _fife.new_OffRendererQuadInfo(n1, n2, n3, n4, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererQuadInfo
    __del__ = lambda self: None
OffRendererQuadInfo_swigregister = _fife.OffRendererQuadInfo_swigregister
OffRendererQuadInfo_swigregister(OffRendererQuadInfo)

class OffRendererVertexInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererVertexInfo class."""

    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"""
        this = _fife.new_OffRendererVertexInfo(center, size, r, g, b, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererVertexInfo
    __del__ = lambda self: None
OffRendererVertexInfo_swigregister = _fife.OffRendererVertexInfo_swigregister
OffRendererVertexInfo_swigregister(OffRendererVertexInfo)

class OffRendererImageInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererImageInfo class."""

    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"""
        this = _fife.new_OffRendererImageInfo(n, image)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererImageInfo
    __del__ = lambda self: None
OffRendererImageInfo_swigregister = _fife.OffRendererImageInfo_swigregister
OffRendererImageInfo_swigregister(OffRendererImageInfo)

class OffRendererAnimationInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererAnimationInfo class."""

    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"""
        this = _fife.new_OffRendererAnimationInfo(n, animation)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererAnimationInfo
    __del__ = lambda self: None
OffRendererAnimationInfo_swigregister = _fife.OffRendererAnimationInfo_swigregister
OffRendererAnimationInfo_swigregister(OffRendererAnimationInfo)

class OffRendererTextInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererTextInfo class."""

    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"""
        this = _fife.new_OffRendererTextInfo(n, font, text)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererTextInfo
    __del__ = lambda self: None
OffRendererTextInfo_swigregister = _fife.OffRendererTextInfo_swigregister
OffRendererTextInfo_swigregister(OffRendererTextInfo)

class OffRendererResizeInfo(OffRendererElementInfo):
    """Proxy of C++ FIFE::OffRendererResizeInfo class."""

    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"""
        this = _fife.new_OffRendererResizeInfo(n, image, width, height)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRendererResizeInfo
    __del__ = lambda self: None
OffRendererResizeInfo_swigregister = _fife.OffRendererResizeInfo_swigregister
OffRendererResizeInfo_swigregister(OffRendererResizeInfo)

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

    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"""
        this = _fife.new_OffRenderer(renderbackend)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_OffRenderer
    __del__ = lambda self: None

    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)
        addLine(OffRenderer self, std::string const & group, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addPoint(OffRenderer self, std::string const & group, Point n, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addTriangle(OffRenderer self, std::string const & group, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addQuad(OffRenderer self, std::string const & group, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addVertex(OffRenderer self, std::string const & group, Point n, int32_t size, uint8_t r, uint8_t g, uint8_t b)
        """
        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_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
    __del__ = lambda self: None

    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)
        addLine(RenderTarget self, std::string const & group, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addPoint(RenderTarget self, std::string const & group, Point n, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addTriangle(RenderTarget self, std::string const & group, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addQuad(RenderTarget self, std::string const & group, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addVertex(RenderTarget self, std::string const & group, Point n, int32_t size, uint8_t r, uint8_t g, uint8_t b)
        """
        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_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
        """
        this = _fife.new_SharedRenderTargetPointer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_SharedRenderTargetPointer
    __del__ = lambda self: None

    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)
        reset(SharedRenderTargetPointer self)
        """
        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)
        addLine(SharedRenderTargetPointer self, std::string const & group, Point n1, Point n2, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addPoint(SharedRenderTargetPointer self, std::string const & group, Point n, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addTriangle(SharedRenderTargetPointer self, std::string const & group, Point n1, Point n2, Point n3, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addQuad(SharedRenderTargetPointer self, std::string const & group, Point n1, Point n2, Point n3, Point n4, uint8_t r, uint8_t g, uint8_t b)
        """
        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)
        addVertex(SharedRenderTargetPointer self, std::string const & group, Point n, int32_t size, uint8_t r, uint8_t g, uint8_t b)
        """
        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_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"""
        this = _fife.new_TargetRenderer(renderbackend)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_TargetRenderer
    __del__ = lambda self: None

    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)
        setRenderTarget(TargetRenderer self, std::string const & targetname, bool discard)
        """
        return _fife.TargetRenderer_setRenderTarget(self, targetname, discard, ndraws)


    def render(self):
        """render(TargetRenderer self)"""
        return _fife.TargetRenderer_render(self)

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
    __del__ = lambda self: None

    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_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"""
        this = _fife.new_HybridGuiManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_HybridGuiManager
    __del__ = lambda self: None

    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_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
    __del__ = lambda self: None

    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_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"""
        this = _fife.new_GuiFont(font)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_GuiFont
    __del__ = lambda self: None

    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 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)
        setColor(GuiFont self, uint8_t r, uint8_t g, uint8_t b)
        """
        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_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
    __del__ = lambda self: None

    def load(filename, convertToDisplayFormat=True):
        """
        load(std::string const & filename, bool convertToDisplayFormat=True) -> GcnImage
        load(std::string const & filename) -> 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_swigregister = _fife.GcnImage_swigregister
GcnImage_swigregister(GcnImage)

def GcnImage_load(filename, convertToDisplayFormat=True):
    """
    load(std::string const & filename, bool convertToDisplayFormat=True) -> GcnImage
    GcnImage_load(std::string const & filename) -> 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
        """
        this = _fife.new_GuiImage(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    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
    __del__ = lambda self: None
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
    __del__ = lambda self: None

    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
        this = _fife.new_ConsoleExecuter(_self, )
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    def __disown__(self):
        self.this.disown()
        _fife.disown_ConsoleExecuter(self)
        return weakref_proxy(self)
ConsoleExecuter_swigregister = _fife.ConsoleExecuter_swigregister
ConsoleExecuter_swigregister(ConsoleExecuter)

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

    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"""
        this = _fife.new_Console()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Console
    __del__ = lambda self: None
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"""
        this = _fife.new_FifechanManager()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_FifechanManager
    __del__ = lambda self: None

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

FifechanManager_swigregister = _fife.FifechanManager_swigregister
FifechanManager_swigregister(FifechanManager)

class TwoButton(fifechan.Widget):
    """Proxy of C++ fcn::TwoButton 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::TwoButton self, GcnImage up_image=None, GcnImage down_image=None, GcnImage hover_image=None, char const * caption) -> TwoButton
        __init__(fcn::TwoButton self, GcnImage up_image=None, GcnImage down_image=None, GcnImage hover_image=None) -> TwoButton
        __init__(fcn::TwoButton self, GcnImage up_image=None, GcnImage down_image=None) -> TwoButton
        __init__(fcn::TwoButton self, GcnImage up_image=None) -> TwoButton
        __init__(fcn::TwoButton self) -> TwoButton
        """
        this = _fife.new_TwoButton(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_TwoButton
    __del__ = lambda self: None

    def setCaption(self, caption):
        """setCaption(TwoButton self, std::string const & caption)"""
        return _fife.TwoButton_setCaption(self, caption)


    def getCaption(self):
        """getCaption(TwoButton self) -> std::string const &"""
        return _fife.TwoButton_getCaption(self)


    def setAlignment(self, alignment):
        """setAlignment(TwoButton self, fcn::Graphics::Alignment alignment)"""
        return _fife.TwoButton_setAlignment(self, alignment)


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


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


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


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


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


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


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

TwoButton_swigregister = _fife.TwoButton_swigregister
TwoButton_swigregister(TwoButton)

class ToggleButton(fifechan.Widget):
    """Proxy of C++ fcn::ToggleButton 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::ToggleButton self, GcnImage up_image=None, GcnImage down_image=None, GcnImage hover_image=None, char const * caption, char const * group) -> ToggleButton
        __init__(fcn::ToggleButton self, GcnImage up_image=None, GcnImage down_image=None, GcnImage hover_image=None, char const * caption) -> ToggleButton
        __init__(fcn::ToggleButton self, GcnImage up_image=None, GcnImage down_image=None, GcnImage hover_image=None) -> ToggleButton
        __init__(fcn::ToggleButton self, GcnImage up_image=None, GcnImage down_image=None) -> ToggleButton
        __init__(fcn::ToggleButton self, GcnImage up_image=None) -> ToggleButton
        __init__(fcn::ToggleButton self) -> ToggleButton
        """
        this = _fife.new_ToggleButton(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_ToggleButton
    __del__ = lambda self: None

    def setCaption(self, caption):
        """setCaption(ToggleButton self, std::string const & caption)"""
        return _fife.ToggleButton_setCaption(self, caption)


    def getCaption(self):
        """getCaption(ToggleButton self) -> std::string const &"""
        return _fife.ToggleButton_getCaption(self)


    def setAlignment(self, alignment):
        """setAlignment(ToggleButton self, fcn::Graphics::Alignment alignment)"""
        return _fife.ToggleButton_setAlignment(self, alignment)


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


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


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


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


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


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


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


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


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


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


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


    def setGroup(self, group):
        """setGroup(ToggleButton self, std::string const & group)"""
        return _fife.ToggleButton_setGroup(self, group)


    def getGroup(self):
        """getGroup(ToggleButton self) -> std::string const &"""
        return _fife.ToggleButton_getGroup(self)

ToggleButton_swigregister = _fife.ToggleButton_swigregister
ToggleButton_swigregister(ToggleButton)

class Label(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
        """
        this = _fife.new_Label(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Label
    __del__ = lambda self: None

    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 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 setWidth(self, width):
        """setWidth(Label self, int32_t width)"""
        return _fife.Label_setWidth(self, width)


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

Label_swigregister = _fife.Label_swigregister
Label_swigregister(Label)

class Icon(fifechan.Widget):
    """Proxy of C++ fcn::Icon2 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, image):
        """__init__(fcn::Icon2 self, GcnImage image) -> Icon"""
        this = _fife.new_Icon(image)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_Icon
    __del__ = lambda self: None

    def setImage(self, image):
        """setImage(Icon self, GcnImage image)"""
        return _fife.Icon_setImage(self, image)


    def isScaling(self):
        """isScaling(Icon self) -> bool"""
        return _fife.Icon_isScaling(self)


    def setScaling(self, scale):
        """setScaling(Icon self, bool scale)"""
        return _fife.Icon_setScaling(self, scale)


    def isTiling(self):
        """isTiling(Icon self) -> bool"""
        return _fife.Icon_isTiling(self)


    def setTiling(self, tile):
        """setTiling(Icon self, bool tile)"""
        return _fife.Icon_setTiling(self, tile)

Icon_swigregister = _fife.Icon_swigregister
Icon_swigregister(Icon)

class PercentageBar(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"""
        this = _fife.new_PercentageBar()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _fife.delete_PercentageBar
    __del__ = lambda self: None

    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_swigregister = _fife.PercentageBar_swigregister
PercentageBar_swigregister(PercentageBar)



